feat: docker compose maybe

node_modules/css-tree/cjs/utils/List.cjs

@@ -0,0 +1,473 @@
+'use strict';
+
+//
+//                              list
+//                            ┌──────┐
+//             ┌──────────────┼─head │
+//             │              │ tail─┼──────────────┐
+//             │              └──────┘              │
+//             ▼                                    ▼
+//            item        item        item        item
+//          ┌──────┐    ┌──────┐    ┌──────┐    ┌──────┐
+//  null ◀──┼─prev │◀───┼─prev │◀───┼─prev │◀───┼─prev │
+//          │ next─┼───▶│ next─┼───▶│ next─┼───▶│ next─┼──▶ null
+//          ├──────┤    ├──────┤    ├──────┤    ├──────┤
+//          │ data │    │ data │    │ data │    │ data │
+//          └──────┘    └──────┘    └──────┘    └──────┘
+//
+
+let releasedCursors = null;
+
+class List {
+    static createItem(data) {
+        return {
+            prev: null,
+            next: null,
+            data
+        };
+    }
+
+    constructor() {
+        this.head = null;
+        this.tail = null;
+        this.cursor = null;
+    }
+    createItem(data) {
+        return List.createItem(data);
+    }
+
+    // cursor helpers
+    allocateCursor(prev, next) {
+        let cursor;
+
+        if (releasedCursors !== null) {
+            cursor = releasedCursors;
+            releasedCursors = releasedCursors.cursor;
+            cursor.prev = prev;
+            cursor.next = next;
+            cursor.cursor = this.cursor;
+        } else {
+            cursor = {
+                prev,
+                next,
+                cursor: this.cursor
+            };
+        }
+
+        this.cursor = cursor;
+
+        return cursor;
+    }
+    releaseCursor() {
+        const { cursor } = this;
+
+        this.cursor = cursor.cursor;
+        cursor.prev = null;
+        cursor.next = null;
+        cursor.cursor = releasedCursors;
+        releasedCursors = cursor;
+    }
+    updateCursors(prevOld, prevNew, nextOld, nextNew) {
+        let { cursor } = this;
+
+        while (cursor !== null) {
+            if (cursor.prev === prevOld) {
+                cursor.prev = prevNew;
+            }
+
+            if (cursor.next === nextOld) {
+                cursor.next = nextNew;
+            }
+
+            cursor = cursor.cursor;
+        }
+    }
+    *[Symbol.iterator]() {
+        for (let cursor = this.head; cursor !== null; cursor = cursor.next) {
+            yield cursor.data;
+        }
+    }
+
+    // getters
+    get size() {
+        let size = 0;
+
+        for (let cursor = this.head; cursor !== null; cursor = cursor.next) {
+            size++;
+        }
+
+        return size;
+    }
+    get isEmpty() {
+        return this.head === null;
+    }
+    get first() {
+        return this.head && this.head.data;
+    }
+    get last() {
+        return this.tail && this.tail.data;
+    }
+
+    // convertors
+    fromArray(array) {
+        let cursor = null;
+        this.head = null;
+
+        for (let data of array) {
+            const item = List.createItem(data);
+
+            if (cursor !== null) {
+                cursor.next = item;
+            } else {
+                this.head = item;
+            }
+
+            item.prev = cursor;
+            cursor = item;
+        }
+
+        this.tail = cursor;
+        return this;
+    }
+    toArray() {
+        return [...this];
+    }
+    toJSON() {
+        return [...this];
+    }
+
+    // array-like methods
+    forEach(fn, thisArg = this) {
+        // push cursor
+        const cursor = this.allocateCursor(null, this.head);
+
+        while (cursor.next !== null) {
+            const item = cursor.next;
+            cursor.next = item.next;
+            fn.call(thisArg, item.data, item, this);
+        }
+
+        // pop cursor
+        this.releaseCursor();
+    }
+    forEachRight(fn, thisArg = this) {
+        // push cursor
+        const cursor = this.allocateCursor(this.tail, null);
+
+        while (cursor.prev !== null) {
+            const item = cursor.prev;
+            cursor.prev = item.prev;
+            fn.call(thisArg, item.data, item, this);
+        }
+
+        // pop cursor
+        this.releaseCursor();
+    }
+    reduce(fn, initialValue, thisArg = this) {
+        // push cursor
+        let cursor = this.allocateCursor(null, this.head);
+        let acc = initialValue;
+        let item;
+
+        while (cursor.next !== null) {
+            item = cursor.next;
+            cursor.next = item.next;
+
+            acc = fn.call(thisArg, acc, item.data, item, this);
+        }
+
+        // pop cursor
+        this.releaseCursor();
+
+        return acc;
+    }
+    reduceRight(fn, initialValue, thisArg = this) {
+        // push cursor
+        let cursor = this.allocateCursor(this.tail, null);
+        let acc = initialValue;
+        let item;
+
+        while (cursor.prev !== null) {
+            item = cursor.prev;
+            cursor.prev = item.prev;
+
+            acc = fn.call(thisArg, acc, item.data, item, this);
+        }
+
+        // pop cursor
+        this.releaseCursor();
+
+        return acc;
+    }
+    some(fn, thisArg = this) {
+        for (let cursor = this.head; cursor !== null; cursor = cursor.next) {
+            if (fn.call(thisArg, cursor.data, cursor, this)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+    map(fn, thisArg = this) {
+        const result = new List();
+
+        for (let cursor = this.head; cursor !== null; cursor = cursor.next) {
+            result.appendData(fn.call(thisArg, cursor.data, cursor, this));
+        }
+
+        return result;
+    }
+    filter(fn, thisArg = this) {
+        const result = new List();
+
+        for (let cursor = this.head; cursor !== null; cursor = cursor.next) {
+            if (fn.call(thisArg, cursor.data, cursor, this)) {
+                result.appendData(cursor.data);
+            }
+        }
+
+        return result;
+    }
+
+    nextUntil(start, fn, thisArg = this) {
+        if (start === null) {
+            return;
+        }
+
+        // push cursor
+        const cursor = this.allocateCursor(null, start);
+
+        while (cursor.next !== null) {
+            const item = cursor.next;
+            cursor.next = item.next;
+            if (fn.call(thisArg, item.data, item, this)) {
+                break;
+            }
+        }
+
+        // pop cursor
+        this.releaseCursor();
+    }
+    prevUntil(start, fn, thisArg = this) {
+        if (start === null) {
+            return;
+        }
+
+        // push cursor
+        const cursor = this.allocateCursor(start, null);
+
+        while (cursor.prev !== null) {
+            const item = cursor.prev;
+            cursor.prev = item.prev;
+            if (fn.call(thisArg, item.data, item, this)) {
+                break;
+            }
+        }
+
+        // pop cursor
+        this.releaseCursor();
+    }
+
+    // mutation
+    clear() {
+        this.head = null;
+        this.tail = null;
+    }
+    copy() {
+        const result = new List();
+
+        for (let data of this) {
+            result.appendData(data);
+        }
+
+        return result;
+    }
+    prepend(item) {
+        //      head
+        //    ^
+        // item
+        this.updateCursors(null, item, this.head, item);
+
+        // insert to the beginning of the list
+        if (this.head !== null) {
+            // new item <- first item
+            this.head.prev = item;
+            // new item -> first item
+            item.next = this.head;
+        } else {
+            // if list has no head, then it also has no tail
+            // in this case tail points to the new item
+            this.tail = item;
+        }
+
+        // head always points to new item
+        this.head = item;
+        return this;
+    }
+    prependData(data) {
+        return this.prepend(List.createItem(data));
+    }
+    append(item) {
+        return this.insert(item);
+    }
+    appendData(data) {
+        return this.insert(List.createItem(data));
+    }
+    insert(item, before = null) {
+        if (before !== null) {
+            // prev   before
+            //      ^
+            //     item
+            this.updateCursors(before.prev, item, before, item);
+
+            if (before.prev === null) {
+                // insert to the beginning of list
+                if (this.head !== before) {
+                    throw new Error('before doesn\'t belong to list');
+                }
+                // since head points to before therefore list doesn't empty
+                // no need to check tail
+                this.head = item;
+                before.prev = item;
+                item.next = before;
+                this.updateCursors(null, item);
+            } else {
+                // insert between two items
+                before.prev.next = item;
+                item.prev = before.prev;
+                before.prev = item;
+                item.next = before;
+            }
+        } else {
+            // tail
+            //      ^
+            //      item
+            this.updateCursors(this.tail, item, null, item);
+
+            // insert to the ending of the list
+            if (this.tail !== null) {
+                // last item -> new item
+                this.tail.next = item;
+                // last item <- new item
+                item.prev = this.tail;
+            } else {
+                // if list has no tail, then it also has no head
+                // in this case head points to new item
+                this.head = item;
+            }
+
+            // tail always points to new item
+            this.tail = item;
+        }
+
+        return this;
+    }
+    insertData(data, before) {
+        return this.insert(List.createItem(data), before);
+    }
+    remove(item) {
+        //      item
+        //       ^
+        // prev     next
+        this.updateCursors(item, item.prev, item, item.next);
+
+        if (item.prev !== null) {
+            item.prev.next = item.next;
+        } else {
+            if (this.head !== item) {
+                throw new Error('item doesn\'t belong to list');
+            }
+
+            this.head = item.next;
+        }
+
+        if (item.next !== null) {
+            item.next.prev = item.prev;
+        } else {
+            if (this.tail !== item) {
+                throw new Error('item doesn\'t belong to list');
+            }
+
+            this.tail = item.prev;
+        }
+
+        item.prev = null;
+        item.next = null;
+
+        return item;
+    }
+    push(data) {
+        this.insert(List.createItem(data));
+    }
+    pop() {
+        return this.tail !== null ? this.remove(this.tail) : null;
+    }
+    unshift(data) {
+        this.prepend(List.createItem(data));
+    }
+    shift() {
+        return this.head !== null ? this.remove(this.head) : null;
+    }
+    prependList(list) {
+        return this.insertList(list, this.head);
+    }
+    appendList(list) {
+        return this.insertList(list);
+    }
+    insertList(list, before) {
+        // ignore empty lists
+        if (list.head === null) {
+            return this;
+        }
+
+        if (before !== undefined && before !== null) {
+            this.updateCursors(before.prev, list.tail, before, list.head);
+
+            // insert in the middle of dist list
+            if (before.prev !== null) {
+                // before.prev <-> list.head
+                before.prev.next = list.head;
+                list.head.prev = before.prev;
+            } else {
+                this.head = list.head;
+            }
+
+            before.prev = list.tail;
+            list.tail.next = before;
+        } else {
+            this.updateCursors(this.tail, list.tail, null, list.head);
+
+            // insert to end of the list
+            if (this.tail !== null) {
+                // if destination list has a tail, then it also has a head,
+                // but head doesn't change
+                // dest tail -> source head
+                this.tail.next = list.head;
+                // dest tail <- source head
+                list.head.prev = this.tail;
+            } else {
+                // if list has no a tail, then it also has no a head
+                // in this case points head to new item
+                this.head = list.head;
+            }
+
+            // tail always start point to new item
+            this.tail = list.tail;
+        }
+
+        list.head = null;
+        list.tail = null;
+        return this;
+    }
+    replace(oldItem, newItemOrList) {
+        if ('head' in newItemOrList) {
+            this.insertList(newItemOrList, oldItem);
+        } else {
+            this.insert(newItemOrList, oldItem);
+        }
+
+        this.remove(oldItem);
+    }
+}
+
+exports.List = List;

node_modules/css-tree/cjs/utils/clone.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const List = require('./List.cjs');
+
+function clone(node) {
+    const result = {};
+
+    for (const key in node) {
+        let value = node[key];
+
+        if (value) {
+            if (Array.isArray(value) || value instanceof List.List) {
+                value = value.map(clone);
+            } else if (value.constructor === Object) {
+                value = clone(value);
+            }
+        }
+
+        result[key] = value;
+    }
+
+    return result;
+}
+
+exports.clone = clone;

node_modules/css-tree/cjs/utils/create-custom-error.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+function createCustomError(name, message) {
+    // use Object.create(), because some VMs prevent setting line/column otherwise
+    // (iOS Safari 10 even throws an exception)
+    const error = Object.create(SyntaxError.prototype);
+    const errorStack = new Error();
+
+    return Object.assign(error, {
+        name,
+        message,
+        get stack() {
+            return (errorStack.stack || '').replace(/^(.+\n){1,3}/, `${name}: ${message}\n`);
+        }
+    });
+}
+
+exports.createCustomError = createCustomError;

node_modules/css-tree/cjs/utils/ident.cjs

@@ -0,0 +1,102 @@
+'use strict';
+
+const charCodeDefinitions = require('../tokenizer/char-code-definitions.cjs');
+const utils = require('../tokenizer/utils.cjs');
+
+const REVERSE_SOLIDUS = 0x005c; // U+005C REVERSE SOLIDUS (\)
+
+function decode(str) {
+    const end = str.length - 1;
+    let decoded = '';
+
+    for (let i = 0; i < str.length; i++) {
+        let code = str.charCodeAt(i);
+
+        if (code === REVERSE_SOLIDUS) {
+            // special case at the ending
+            if (i === end) {
+                // if the next input code point is EOF, do nothing
+                break;
+            }
+
+            code = str.charCodeAt(++i);
+
+            // consume escaped
+            if (charCodeDefinitions.isValidEscape(REVERSE_SOLIDUS, code)) {
+                const escapeStart = i - 1;
+                const escapeEnd = utils.consumeEscaped(str, escapeStart);
+
+                i = escapeEnd - 1;
+                decoded += utils.decodeEscaped(str.substring(escapeStart + 1, escapeEnd));
+            } else {
+                // \r\n
+                if (code === 0x000d && str.charCodeAt(i + 1) === 0x000a) {
+                    i++;
+                }
+            }
+        } else {
+            decoded += str[i];
+        }
+    }
+
+    return decoded;
+}
+
+// https://drafts.csswg.org/cssom/#serialize-an-identifier
+// § 2.1. Common Serializing Idioms
+function encode(str) {
+    let encoded = '';
+
+    // If the character is the first character and is a "-" (U+002D),
+    // and there is no second character, then the escaped character.
+    // Note: That's means a single dash string "-" return as escaped dash,
+    // so move the condition out of the main loop
+    if (str.length === 1 && str.charCodeAt(0) === 0x002D) {
+        return '\\-';
+    }
+
+    // To serialize an identifier means to create a string represented
+    // by the concatenation of, for each character of the identifier:
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+
+        // If the character is NULL (U+0000), then the REPLACEMENT CHARACTER (U+FFFD).
+        if (code === 0x0000) {
+            encoded += '\uFFFD';
+            continue;
+        }
+
+        if (
+            // If the character is in the range [\1-\1f] (U+0001 to U+001F) or is U+007F ...
+            // Note: Do not compare with 0x0001 since 0x0000 is precessed before
+            code <= 0x001F || code === 0x007F ||
+            // [or] ... is in the range [0-9] (U+0030 to U+0039),
+            (code >= 0x0030 && code <= 0x0039 && (
+                // If the character is the first character ...
+                i === 0 ||
+                // If the character is the second character ... and the first character is a "-" (U+002D)
+                i === 1 && str.charCodeAt(0) === 0x002D
+            ))
+        ) {
+            // ... then the character escaped as code point.
+            encoded += '\\' + code.toString(16) + ' ';
+            continue;
+        }
+
+        // If the character is not handled by one of the above rules and is greater
+        // than or equal to U+0080, is "-" (U+002D) or "_" (U+005F), or is in one
+        // of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to U+005A),
+        // or \[a-z] (U+0061 to U+007A), then the character itself.
+        if (charCodeDefinitions.isName(code)) {
+            encoded += str.charAt(i);
+        } else {
+            // Otherwise, the escaped character.
+            encoded += '\\' + str.charAt(i);
+        }
+    }
+
+    return encoded;
+}
+
+exports.decode = decode;
+exports.encode = encode;

node_modules/css-tree/cjs/utils/index.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+const clone = require('./clone.cjs');
+const ident = require('./ident.cjs');
+const List = require('./List.cjs');
+const names = require('./names.cjs');
+const string = require('./string.cjs');
+const url = require('./url.cjs');
+
+
+
+exports.clone = clone.clone;
+exports.ident = ident;
+exports.List = List.List;
+exports.isCustomProperty = names.isCustomProperty;
+exports.keyword = names.keyword;
+exports.property = names.property;
+exports.vendorPrefix = names.vendorPrefix;
+exports.string = string;
+exports.url = url;

node_modules/css-tree/cjs/utils/names.cjs

@@ -0,0 +1,113 @@
+'use strict';
+
+const keywords = new Map();
+const properties = new Map();
+const HYPHENMINUS = 45; // '-'.charCodeAt()
+
+const keyword = getKeywordDescriptor;
+const property = getPropertyDescriptor;
+const vendorPrefix = getVendorPrefix;
+function isCustomProperty(str, offset) {
+    offset = offset || 0;
+
+    return str.length - offset >= 2 &&
+           str.charCodeAt(offset) === HYPHENMINUS &&
+           str.charCodeAt(offset + 1) === HYPHENMINUS;
+}
+
+function getVendorPrefix(str, offset) {
+    offset = offset || 0;
+
+    // verdor prefix should be at least 3 chars length
+    if (str.length - offset >= 3) {
+        // vendor prefix starts with hyper minus following non-hyper minus
+        if (str.charCodeAt(offset) === HYPHENMINUS &&
+            str.charCodeAt(offset + 1) !== HYPHENMINUS) {
+            // vendor prefix should contain a hyper minus at the ending
+            const secondDashIndex = str.indexOf('-', offset + 2);
+
+            if (secondDashIndex !== -1) {
+                return str.substring(offset, secondDashIndex + 1);
+            }
+        }
+    }
+
+    return '';
+}
+
+function getKeywordDescriptor(keyword) {
+    if (keywords.has(keyword)) {
+        return keywords.get(keyword);
+    }
+
+    const name = keyword.toLowerCase();
+    let descriptor = keywords.get(name);
+
+    if (descriptor === undefined) {
+        const custom = isCustomProperty(name, 0);
+        const vendor = !custom ? getVendorPrefix(name, 0) : '';
+        descriptor = Object.freeze({
+            basename: name.substr(vendor.length),
+            name,
+            prefix: vendor,
+            vendor,
+            custom
+        });
+    }
+
+    keywords.set(keyword, descriptor);
+
+    return descriptor;
+}
+
+function getPropertyDescriptor(property) {
+    if (properties.has(property)) {
+        return properties.get(property);
+    }
+
+    let name = property;
+    let hack = property[0];
+
+    if (hack === '/') {
+        hack = property[1] === '/' ? '//' : '/';
+    } else if (hack !== '_' &&
+               hack !== '*' &&
+               hack !== '$' &&
+               hack !== '#' &&
+               hack !== '+' &&
+               hack !== '&') {
+        hack = '';
+    }
+
+    const custom = isCustomProperty(name, hack.length);
+
+    // re-use result when possible (the same as for lower case)
+    if (!custom) {
+        name = name.toLowerCase();
+        if (properties.has(name)) {
+            const descriptor = properties.get(name);
+            properties.set(property, descriptor);
+            return descriptor;
+        }
+    }
+
+    const vendor = !custom ? getVendorPrefix(name, hack.length) : '';
+    const prefix = name.substr(0, hack.length + vendor.length);
+    const descriptor = Object.freeze({
+        basename: name.substr(prefix.length),
+        name: name.substr(hack.length),
+        hack,
+        vendor,
+        prefix,
+        custom
+    });
+
+    properties.set(property, descriptor);
+
+    return descriptor;
+}
+
+exports.isCustomProperty = isCustomProperty;
+exports.keyword = keyword;
+exports.property = property;
+exports.vendorPrefix = vendorPrefix;

node_modules/css-tree/cjs/utils/string.cjs

@@ -0,0 +1,99 @@
+'use strict';
+
+const charCodeDefinitions = require('../tokenizer/char-code-definitions.cjs');
+const utils = require('../tokenizer/utils.cjs');
+
+const REVERSE_SOLIDUS = 0x005c; // U+005C REVERSE SOLIDUS (\)
+const QUOTATION_MARK = 0x0022;  // "
+const APOSTROPHE = 0x0027;      // '
+
+function decode(str) {
+    const len = str.length;
+    const firstChar = str.charCodeAt(0);
+    const start = firstChar === QUOTATION_MARK || firstChar === APOSTROPHE ? 1 : 0;
+    const end = start === 1 && len > 1 && str.charCodeAt(len - 1) === firstChar ? len - 2 : len - 1;
+    let decoded = '';
+
+    for (let i = start; i <= end; i++) {
+        let code = str.charCodeAt(i);
+
+        if (code === REVERSE_SOLIDUS) {
+            // special case at the ending
+            if (i === end) {
+                // if the next input code point is EOF, do nothing
+                // otherwise include last quote as escaped
+                if (i !== len - 1) {
+                    decoded = str.substr(i + 1);
+                }
+                break;
+            }
+
+            code = str.charCodeAt(++i);
+
+            // consume escaped
+            if (charCodeDefinitions.isValidEscape(REVERSE_SOLIDUS, code)) {
+                const escapeStart = i - 1;
+                const escapeEnd = utils.consumeEscaped(str, escapeStart);
+
+                i = escapeEnd - 1;
+                decoded += utils.decodeEscaped(str.substring(escapeStart + 1, escapeEnd));
+            } else {
+                // \r\n
+                if (code === 0x000d && str.charCodeAt(i + 1) === 0x000a) {
+                    i++;
+                }
+            }
+        } else {
+            decoded += str[i];
+        }
+    }
+
+    return decoded;
+}
+
+// https://drafts.csswg.org/cssom/#serialize-a-string
+// § 2.1. Common Serializing Idioms
+function encode(str, apostrophe) {
+    const quote = apostrophe ? '\'' : '"';
+    const quoteCode = apostrophe ? APOSTROPHE : QUOTATION_MARK;
+    let encoded = '';
+    let wsBeforeHexIsNeeded = false;
+
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+
+        // If the character is NULL (U+0000), then the REPLACEMENT CHARACTER (U+FFFD).
+        if (code === 0x0000) {
+            encoded += '\uFFFD';
+            continue;
+        }
+
+        // If the character is in the range [\1-\1f] (U+0001 to U+001F) or is U+007F,
+        // the character escaped as code point.
+        // Note: Do not compare with 0x0001 since 0x0000 is precessed before
+        if (code <= 0x001f || code === 0x007F) {
+            encoded += '\\' + code.toString(16);
+            wsBeforeHexIsNeeded = true;
+            continue;
+        }
+
+        // If the character is '"' (U+0022) or "\" (U+005C), the escaped character.
+        if (code === quoteCode || code === REVERSE_SOLIDUS) {
+            encoded += '\\' + str.charAt(i);
+            wsBeforeHexIsNeeded = false;
+        } else {
+            if (wsBeforeHexIsNeeded && (charCodeDefinitions.isHexDigit(code) || charCodeDefinitions.isWhiteSpace(code))) {
+                encoded += ' ';
+            }
+
+            // Otherwise, the character itself.
+            encoded += str.charAt(i);
+            wsBeforeHexIsNeeded = false;
+        }
+    }
+
+    return quote + encoded + quote;
+}
+
+exports.decode = decode;
+exports.encode = encode;

node_modules/css-tree/cjs/utils/url.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+const charCodeDefinitions = require('../tokenizer/char-code-definitions.cjs');
+const utils = require('../tokenizer/utils.cjs');
+
+const SPACE = 0x0020;            // U+0020 SPACE
+const REVERSE_SOLIDUS = 0x005c;  // U+005C REVERSE SOLIDUS (\)
+const QUOTATION_MARK = 0x0022;   // "
+const APOSTROPHE = 0x0027;       // '
+const LEFTPARENTHESIS = 0x0028;  // U+0028 LEFT PARENTHESIS (()
+const RIGHTPARENTHESIS = 0x0029; // U+0029 RIGHT PARENTHESIS ())
+
+function decode(str) {
+    const len = str.length;
+    let start = 4; // length of "url("
+    let end = str.charCodeAt(len - 1) === RIGHTPARENTHESIS ? len - 2 : len - 1;
+    let decoded = '';
+
+    while (start < end && charCodeDefinitions.isWhiteSpace(str.charCodeAt(start))) {
+        start++;
+    }
+
+    while (start < end && charCodeDefinitions.isWhiteSpace(str.charCodeAt(end))) {
+        end--;
+    }
+
+    for (let i = start; i <= end; i++) {
+        let code = str.charCodeAt(i);
+
+        if (code === REVERSE_SOLIDUS) {
+            // special case at the ending
+            if (i === end) {
+                // if the next input code point is EOF, do nothing
+                // otherwise include last left parenthesis as escaped
+                if (i !== len - 1) {
+                    decoded = str.substr(i + 1);
+                }
+                break;
+            }
+
+            code = str.charCodeAt(++i);
+
+            // consume escaped
+            if (charCodeDefinitions.isValidEscape(REVERSE_SOLIDUS, code)) {
+                const escapeStart = i - 1;
+                const escapeEnd = utils.consumeEscaped(str, escapeStart);
+
+                i = escapeEnd - 1;
+                decoded += utils.decodeEscaped(str.substring(escapeStart + 1, escapeEnd));
+            } else {
+                // \r\n
+                if (code === 0x000d && str.charCodeAt(i + 1) === 0x000a) {
+                    i++;
+                }
+            }
+        } else {
+            decoded += str[i];
+        }
+    }
+
+    return decoded;
+}
+
+function encode(str) {
+    let encoded = '';
+    let wsBeforeHexIsNeeded = false;
+
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+
+        // If the character is NULL (U+0000), then the REPLACEMENT CHARACTER (U+FFFD).
+        if (code === 0x0000) {
+            encoded += '\uFFFD';
+            continue;
+        }
+
+        // If the character is in the range [\1-\1f] (U+0001 to U+001F) or is U+007F,
+        // the character escaped as code point.
+        // Note: Do not compare with 0x0001 since 0x0000 is precessed before
+        if (code <= 0x001f || code === 0x007F) {
+            encoded += '\\' + code.toString(16);
+            wsBeforeHexIsNeeded = true;
+            continue;
+        }
+
+        if (code === SPACE ||
+            code === REVERSE_SOLIDUS ||
+            code === QUOTATION_MARK ||
+            code === APOSTROPHE ||
+            code === LEFTPARENTHESIS ||
+            code === RIGHTPARENTHESIS) {
+            encoded += '\\' + str.charAt(i);
+            wsBeforeHexIsNeeded = false;
+        } else {
+            if (wsBeforeHexIsNeeded && charCodeDefinitions.isHexDigit(code)) {
+                encoded += ' ';
+            }
+
+            encoded += str.charAt(i);
+            wsBeforeHexIsNeeded = false;
+        }
+    }
+
+    return 'url(' + encoded + ')';
+}
+
+exports.decode = decode;
+exports.encode = encode;