feat: docker compose maybe

node_modules/css-tree/cjs/syntax/node/AnPlusB.cjs

@@ -0,0 +1,293 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+const charCodeDefinitions = require('../../tokenizer/char-code-definitions.cjs');
+
+const PLUSSIGN = 0x002B;    // U+002B PLUS SIGN (+)
+const HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)
+const N = 0x006E;           // U+006E LATIN SMALL LETTER N (n)
+const DISALLOW_SIGN = true;
+const ALLOW_SIGN = false;
+
+function checkInteger(offset, disallowSign) {
+    let pos = this.tokenStart + offset;
+    const code = this.charCodeAt(pos);
+
+    if (code === PLUSSIGN || code === HYPHENMINUS) {
+        if (disallowSign) {
+            this.error('Number sign is not allowed');
+        }
+        pos++;
+    }
+
+    for (; pos < this.tokenEnd; pos++) {
+        if (!charCodeDefinitions.isDigit(this.charCodeAt(pos))) {
+            this.error('Integer is expected', pos);
+        }
+    }
+}
+
+function checkTokenIsInteger(disallowSign) {
+    return checkInteger.call(this, 0, disallowSign);
+}
+
+function expectCharCode(offset, code) {
+    if (!this.cmpChar(this.tokenStart + offset, code)) {
+        let msg = '';
+
+        switch (code) {
+            case N:
+                msg = 'N is expected';
+                break;
+            case HYPHENMINUS:
+                msg = 'HyphenMinus is expected';
+                break;
+        }
+
+        this.error(msg, this.tokenStart + offset);
+    }
+}
+
+// ... <signed-integer>
+// ... ['+' | '-'] <signless-integer>
+function consumeB() {
+    let offset = 0;
+    let sign = 0;
+    let type = this.tokenType;
+
+    while (type === types.WhiteSpace || type === types.Comment) {
+        type = this.lookupType(++offset);
+    }
+
+    if (type !== types.Number) {
+        if (this.isDelim(PLUSSIGN, offset) ||
+            this.isDelim(HYPHENMINUS, offset)) {
+            sign = this.isDelim(PLUSSIGN, offset) ? PLUSSIGN : HYPHENMINUS;
+
+            do {
+                type = this.lookupType(++offset);
+            } while (type === types.WhiteSpace || type === types.Comment);
+
+            if (type !== types.Number) {
+                this.skip(offset);
+                checkTokenIsInteger.call(this, DISALLOW_SIGN);
+            }
+        } else {
+            return null;
+        }
+    }
+
+    if (offset > 0) {
+        this.skip(offset);
+    }
+
+    if (sign === 0) {
+        type = this.charCodeAt(this.tokenStart);
+        if (type !== PLUSSIGN && type !== HYPHENMINUS) {
+            this.error('Number sign is expected');
+        }
+    }
+
+    checkTokenIsInteger.call(this, sign !== 0);
+    return sign === HYPHENMINUS ? '-' + this.consume(types.Number) : this.consume(types.Number);
+}
+
+// An+B microsyntax https://www.w3.org/TR/css-syntax-3/#anb
+const name = 'AnPlusB';
+const structure = {
+    a: [String, null],
+    b: [String, null]
+};
+
+function parse() {
+    /* eslint-disable brace-style*/
+    const start = this.tokenStart;
+    let a = null;
+    let b = null;
+
+    // <integer>
+    if (this.tokenType === types.Number) {
+        checkTokenIsInteger.call(this, ALLOW_SIGN);
+        b = this.consume(types.Number);
+    }
+
+    // -n
+    // -n <signed-integer>
+    // -n ['+' | '-'] <signless-integer>
+    // -n- <signless-integer>
+    // <dashndashdigit-ident>
+    else if (this.tokenType === types.Ident && this.cmpChar(this.tokenStart, HYPHENMINUS)) {
+        a = '-1';
+
+        expectCharCode.call(this, 1, N);
+
+        switch (this.tokenEnd - this.tokenStart) {
+            // -n
+            // -n <signed-integer>
+            // -n ['+' | '-'] <signless-integer>
+            case 2:
+                this.next();
+                b = consumeB.call(this);
+                break;
+
+            // -n- <signless-integer>
+            case 3:
+                expectCharCode.call(this, 2, HYPHENMINUS);
+
+                this.next();
+                this.skipSC();
+
+                checkTokenIsInteger.call(this, DISALLOW_SIGN);
+
+                b = '-' + this.consume(types.Number);
+                break;
+
+            // <dashndashdigit-ident>
+            default:
+                expectCharCode.call(this, 2, HYPHENMINUS);
+                checkInteger.call(this, 3, DISALLOW_SIGN);
+                this.next();
+
+                b = this.substrToCursor(start + 2);
+        }
+    }
+
+    // '+'? n
+    // '+'? n <signed-integer>
+    // '+'? n ['+' | '-'] <signless-integer>
+    // '+'? n- <signless-integer>
+    // '+'? <ndashdigit-ident>
+    else if (this.tokenType === types.Ident || (this.isDelim(PLUSSIGN) && this.lookupType(1) === types.Ident)) {
+        let sign = 0;
+        a = '1';
+
+        // just ignore a plus
+        if (this.isDelim(PLUSSIGN)) {
+            sign = 1;
+            this.next();
+        }
+
+        expectCharCode.call(this, 0, N);
+
+        switch (this.tokenEnd - this.tokenStart) {
+            // '+'? n
+            // '+'? n <signed-integer>
+            // '+'? n ['+' | '-'] <signless-integer>
+            case 1:
+                this.next();
+                b = consumeB.call(this);
+                break;
+
+            // '+'? n- <signless-integer>
+            case 2:
+                expectCharCode.call(this, 1, HYPHENMINUS);
+
+                this.next();
+                this.skipSC();
+
+                checkTokenIsInteger.call(this, DISALLOW_SIGN);
+
+                b = '-' + this.consume(types.Number);
+                break;
+
+            // '+'? <ndashdigit-ident>
+            default:
+                expectCharCode.call(this, 1, HYPHENMINUS);
+                checkInteger.call(this, 2, DISALLOW_SIGN);
+                this.next();
+
+                b = this.substrToCursor(start + sign + 1);
+        }
+    }
+
+    // <ndashdigit-dimension>
+    // <ndash-dimension> <signless-integer>
+    // <n-dimension>
+    // <n-dimension> <signed-integer>
+    // <n-dimension> ['+' | '-'] <signless-integer>
+    else if (this.tokenType === types.Dimension) {
+        const code = this.charCodeAt(this.tokenStart);
+        const sign = code === PLUSSIGN || code === HYPHENMINUS;
+        let i = this.tokenStart + sign;
+
+        for (; i < this.tokenEnd; i++) {
+            if (!charCodeDefinitions.isDigit(this.charCodeAt(i))) {
+                break;
+            }
+        }
+
+        if (i === this.tokenStart + sign) {
+            this.error('Integer is expected', this.tokenStart + sign);
+        }
+
+        expectCharCode.call(this, i - this.tokenStart, N);
+        a = this.substring(start, i);
+
+        // <n-dimension>
+        // <n-dimension> <signed-integer>
+        // <n-dimension> ['+' | '-'] <signless-integer>
+        if (i + 1 === this.tokenEnd) {
+            this.next();
+            b = consumeB.call(this);
+        } else {
+            expectCharCode.call(this, i - this.tokenStart + 1, HYPHENMINUS);
+
+            // <ndash-dimension> <signless-integer>
+            if (i + 2 === this.tokenEnd) {
+                this.next();
+                this.skipSC();
+                checkTokenIsInteger.call(this, DISALLOW_SIGN);
+                b = '-' + this.consume(types.Number);
+            }
+            // <ndashdigit-dimension>
+            else {
+                checkInteger.call(this, i - this.tokenStart + 2, DISALLOW_SIGN);
+                this.next();
+                b = this.substrToCursor(i + 1);
+            }
+        }
+    } else {
+        this.error();
+    }
+
+    if (a !== null && a.charCodeAt(0) === PLUSSIGN) {
+        a = a.substr(1);
+    }
+
+    if (b !== null && b.charCodeAt(0) === PLUSSIGN) {
+        b = b.substr(1);
+    }
+
+    return {
+        type: 'AnPlusB',
+        loc: this.getLocation(start, this.tokenStart),
+        a,
+        b
+    };
+}
+
+function generate(node) {
+    if (node.a) {
+        const a =
+            node.a === '+1' && 'n' ||
+            node.a ===  '1' && 'n' ||
+            node.a === '-1' && '-n' ||
+            node.a + 'n';
+
+        if (node.b) {
+            const b = node.b[0] === '-' || node.b[0] === '+'
+                ? node.b
+                : '+' + node.b;
+            this.tokenize(a + b);
+        } else {
+            this.tokenize(a);
+        }
+    } else {
+        this.tokenize(node.b);
+    }
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Atrule.cjs

@@ -0,0 +1,103 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+function consumeRaw(startToken) {
+    return this.Raw(startToken, this.consumeUntilLeftCurlyBracketOrSemicolon, true);
+}
+
+function isDeclarationBlockAtrule() {
+    for (let offset = 1, type; type = this.lookupType(offset); offset++) {
+        if (type === types.RightCurlyBracket) {
+            return true;
+        }
+
+        if (type === types.LeftCurlyBracket ||
+            type === types.AtKeyword) {
+            return false;
+        }
+    }
+
+    return false;
+}
+
+
+const name = 'Atrule';
+const walkContext = 'atrule';
+const structure = {
+    name: String,
+    prelude: ['AtrulePrelude', 'Raw', null],
+    block: ['Block', null]
+};
+
+function parse(isDeclaration = false) {
+    const start = this.tokenStart;
+    let name;
+    let nameLowerCase;
+    let prelude = null;
+    let block = null;
+
+    this.eat(types.AtKeyword);
+
+    name = this.substrToCursor(start + 1);
+    nameLowerCase = name.toLowerCase();
+    this.skipSC();
+
+    // parse prelude
+    if (this.eof === false &&
+        this.tokenType !== types.LeftCurlyBracket &&
+        this.tokenType !== types.Semicolon) {
+        if (this.parseAtrulePrelude) {
+            prelude = this.parseWithFallback(this.AtrulePrelude.bind(this, name, isDeclaration), consumeRaw);
+        } else {
+            prelude = consumeRaw.call(this, this.tokenIndex);
+        }
+
+        this.skipSC();
+    }
+
+    switch (this.tokenType) {
+        case types.Semicolon:
+            this.next();
+            break;
+
+        case types.LeftCurlyBracket:
+            if (hasOwnProperty.call(this.atrule, nameLowerCase) &&
+                typeof this.atrule[nameLowerCase].block === 'function') {
+                block = this.atrule[nameLowerCase].block.call(this, isDeclaration);
+            } else {
+                // TODO: should consume block content as Raw?
+                block = this.Block(isDeclarationBlockAtrule.call(this));
+            }
+
+            break;
+    }
+
+    return {
+        type: 'Atrule',
+        loc: this.getLocation(start, this.tokenStart),
+        name,
+        prelude,
+        block
+    };
+}
+
+function generate(node) {
+    this.token(types.AtKeyword, '@' + node.name);
+
+    if (node.prelude !== null) {
+        this.node(node.prelude);
+    }
+
+    if (node.block) {
+        this.node(node.block);
+    } else {
+        this.token(types.Semicolon, ';');
+    }
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;
+exports.walkContext = walkContext;

node_modules/css-tree/cjs/syntax/node/AtrulePrelude.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'AtrulePrelude';
+const walkContext = 'atrulePrelude';
+const structure = {
+    children: [[]]
+};
+
+function parse(name) {
+    let children = null;
+
+    if (name !== null) {
+        name = name.toLowerCase();
+    }
+
+    this.skipSC();
+
+    if (hasOwnProperty.call(this.atrule, name) &&
+        typeof this.atrule[name].prelude === 'function') {
+        // custom consumer
+        children = this.atrule[name].prelude.call(this);
+    } else {
+        // default consumer
+        children = this.readSequence(this.scope.AtrulePrelude);
+    }
+
+    this.skipSC();
+
+    if (this.eof !== true &&
+        this.tokenType !== types.LeftCurlyBracket &&
+        this.tokenType !== types.Semicolon) {
+        this.error('Semicolon or block is expected');
+    }
+
+    return {
+        type: 'AtrulePrelude',
+        loc: this.getLocationFromList(children),
+        children
+    };
+}
+
+function generate(node) {
+    this.children(node);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;
+exports.walkContext = walkContext;

node_modules/css-tree/cjs/syntax/node/AttributeSelector.cjs

@@ -0,0 +1,148 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const DOLLARSIGN = 0x0024;       // U+0024 DOLLAR SIGN ($)
+const ASTERISK = 0x002A;         // U+002A ASTERISK (*)
+const EQUALSSIGN = 0x003D;       // U+003D EQUALS SIGN (=)
+const CIRCUMFLEXACCENT = 0x005E; // U+005E (^)
+const VERTICALLINE = 0x007C;     // U+007C VERTICAL LINE (|)
+const TILDE = 0x007E;            // U+007E TILDE (~)
+
+function getAttributeName() {
+    if (this.eof) {
+        this.error('Unexpected end of input');
+    }
+
+    const start = this.tokenStart;
+    let expectIdent = false;
+
+    if (this.isDelim(ASTERISK)) {
+        expectIdent = true;
+        this.next();
+    } else if (!this.isDelim(VERTICALLINE)) {
+        this.eat(types.Ident);
+    }
+
+    if (this.isDelim(VERTICALLINE)) {
+        if (this.charCodeAt(this.tokenStart + 1) !== EQUALSSIGN) {
+            this.next();
+            this.eat(types.Ident);
+        } else if (expectIdent) {
+            this.error('Identifier is expected', this.tokenEnd);
+        }
+    } else if (expectIdent) {
+        this.error('Vertical line is expected');
+    }
+
+    return {
+        type: 'Identifier',
+        loc: this.getLocation(start, this.tokenStart),
+        name: this.substrToCursor(start)
+    };
+}
+
+function getOperator() {
+    const start = this.tokenStart;
+    const code = this.charCodeAt(start);
+
+    if (code !== EQUALSSIGN &&        // =
+        code !== TILDE &&             // ~=
+        code !== CIRCUMFLEXACCENT &&  // ^=
+        code !== DOLLARSIGN &&        // $=
+        code !== ASTERISK &&          // *=
+        code !== VERTICALLINE         // |=
+    ) {
+        this.error('Attribute selector (=, ~=, ^=, $=, *=, |=) is expected');
+    }
+
+    this.next();
+
+    if (code !== EQUALSSIGN) {
+        if (!this.isDelim(EQUALSSIGN)) {
+            this.error('Equal sign is expected');
+        }
+
+        this.next();
+    }
+
+    return this.substrToCursor(start);
+}
+
+// '[' <wq-name> ']'
+// '[' <wq-name> <attr-matcher> [ <string-token> | <ident-token> ] <attr-modifier>? ']'
+const name = 'AttributeSelector';
+const structure = {
+    name: 'Identifier',
+    matcher: [String, null],
+    value: ['String', 'Identifier', null],
+    flags: [String, null]
+};
+
+function parse() {
+    const start = this.tokenStart;
+    let name;
+    let matcher = null;
+    let value = null;
+    let flags = null;
+
+    this.eat(types.LeftSquareBracket);
+    this.skipSC();
+
+    name = getAttributeName.call(this);
+    this.skipSC();
+
+    if (this.tokenType !== types.RightSquareBracket) {
+        // avoid case `[name i]`
+        if (this.tokenType !== types.Ident) {
+            matcher = getOperator.call(this);
+
+            this.skipSC();
+
+            value = this.tokenType === types.String
+                ? this.String()
+                : this.Identifier();
+
+            this.skipSC();
+        }
+
+        // attribute flags
+        if (this.tokenType === types.Ident) {
+            flags = this.consume(types.Ident);
+
+            this.skipSC();
+        }
+    }
+
+    this.eat(types.RightSquareBracket);
+
+    return {
+        type: 'AttributeSelector',
+        loc: this.getLocation(start, this.tokenStart),
+        name,
+        matcher,
+        value,
+        flags
+    };
+}
+
+function generate(node) {
+    this.token(types.Delim, '[');
+    this.node(node.name);
+
+    if (node.matcher !== null) {
+        this.tokenize(node.matcher);
+        this.node(node.value);
+    }
+
+    if (node.flags !== null) {
+        this.token(types.Ident, node.flags);
+    }
+
+    this.token(types.Delim, ']');
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Block.cjs

@@ -0,0 +1,96 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const AMPERSAND = 0x0026;       // U+0026 AMPERSAND (&)
+
+function consumeRaw(startToken) {
+    return this.Raw(startToken, null, true);
+}
+function consumeRule() {
+    return this.parseWithFallback(this.Rule, consumeRaw);
+}
+function consumeRawDeclaration(startToken) {
+    return this.Raw(startToken, this.consumeUntilSemicolonIncluded, true);
+}
+function consumeDeclaration() {
+    if (this.tokenType === types.Semicolon) {
+        return consumeRawDeclaration.call(this, this.tokenIndex);
+    }
+
+    const node = this.parseWithFallback(this.Declaration, consumeRawDeclaration);
+
+    if (this.tokenType === types.Semicolon) {
+        this.next();
+    }
+
+    return node;
+}
+
+const name = 'Block';
+const walkContext = 'block';
+const structure = {
+    children: [[
+        'Atrule',
+        'Rule',
+        'Declaration'
+    ]]
+};
+
+function parse(isStyleBlock) {
+    const consumer = isStyleBlock ? consumeDeclaration : consumeRule;
+    const start = this.tokenStart;
+    let children = this.createList();
+
+    this.eat(types.LeftCurlyBracket);
+
+    scan:
+    while (!this.eof) {
+        switch (this.tokenType) {
+            case types.RightCurlyBracket:
+                break scan;
+
+            case types.WhiteSpace:
+            case types.Comment:
+                this.next();
+                break;
+
+            case types.AtKeyword:
+                children.push(this.parseWithFallback(this.Atrule.bind(this, isStyleBlock), consumeRaw));
+                break;
+
+            default:
+                if (isStyleBlock && this.isDelim(AMPERSAND))  {
+                    children.push(consumeRule.call(this));
+                } else {
+                    children.push(consumer.call(this));
+                }
+        }
+    }
+
+    if (!this.eof) {
+        this.eat(types.RightCurlyBracket);
+    }
+
+    return {
+        type: 'Block',
+        loc: this.getLocation(start, this.tokenStart),
+        children
+    };
+}
+
+function generate(node) {
+    this.token(types.LeftCurlyBracket, '{');
+    this.children(node, prev => {
+        if (prev.type === 'Declaration') {
+            this.token(types.Semicolon, ';');
+        }
+    });
+    this.token(types.RightCurlyBracket, '}');
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;
+exports.walkContext = walkContext;

node_modules/css-tree/cjs/syntax/node/Brackets.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'Brackets';
+const structure = {
+    children: [[]]
+};
+
+function parse(readSequence, recognizer) {
+    const start = this.tokenStart;
+    let children = null;
+
+    this.eat(types.LeftSquareBracket);
+
+    children = readSequence.call(this, recognizer);
+
+    if (!this.eof) {
+        this.eat(types.RightSquareBracket);
+    }
+
+    return {
+        type: 'Brackets',
+        loc: this.getLocation(start, this.tokenStart),
+        children
+    };
+}
+
+function generate(node) {
+    this.token(types.Delim, '[');
+    this.children(node);
+    this.token(types.Delim, ']');
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/CDC.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'CDC';
+const structure = [];
+
+function parse() {
+    const start = this.tokenStart;
+
+    this.eat(types.CDC); // -->
+
+    return {
+        type: 'CDC',
+        loc: this.getLocation(start, this.tokenStart)
+    };
+}
+
+function generate() {
+    this.token(types.CDC, '-->');
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/CDO.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'CDO';
+const structure = [];
+
+function parse() {
+    const start = this.tokenStart;
+
+    this.eat(types.CDO); // <!--
+
+    return {
+        type: 'CDO',
+        loc: this.getLocation(start, this.tokenStart)
+    };
+}
+
+function generate() {
+    this.token(types.CDO, '<!--');
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/ClassSelector.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const FULLSTOP = 0x002E; // U+002E FULL STOP (.)
+
+// '.' ident
+const name = 'ClassSelector';
+const structure = {
+    name: String
+};
+
+function parse() {
+    this.eatDelim(FULLSTOP);
+
+    return {
+        type: 'ClassSelector',
+        loc: this.getLocation(this.tokenStart - 1, this.tokenEnd),
+        name: this.consume(types.Ident)
+    };
+}
+
+function generate(node) {
+    this.token(types.Delim, '.');
+    this.token(types.Ident, node.name);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Combinator.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const PLUSSIGN = 0x002B;        // U+002B PLUS SIGN (+)
+const SOLIDUS = 0x002F;         // U+002F SOLIDUS (/)
+const GREATERTHANSIGN = 0x003E; // U+003E GREATER-THAN SIGN (>)
+const TILDE = 0x007E;           // U+007E TILDE (~)
+
+const name = 'Combinator';
+const structure = {
+    name: String
+};
+
+// + | > | ~ | /deep/
+function parse() {
+    const start = this.tokenStart;
+    let name;
+
+    switch (this.tokenType) {
+        case types.WhiteSpace:
+            name = ' ';
+            break;
+
+        case types.Delim:
+            switch (this.charCodeAt(this.tokenStart)) {
+                case GREATERTHANSIGN:
+                case PLUSSIGN:
+                case TILDE:
+                    this.next();
+                    break;
+
+                case SOLIDUS:
+                    this.next();
+                    this.eatIdent('deep');
+                    this.eatDelim(SOLIDUS);
+                    break;
+
+                default:
+                    this.error('Combinator is expected');
+            }
+
+            name = this.substrToCursor(start);
+            break;
+    }
+
+    return {
+        type: 'Combinator',
+        loc: this.getLocation(start, this.tokenStart),
+        name
+    };
+}
+
+function generate(node) {
+    this.tokenize(node.name);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Comment.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const ASTERISK = 0x002A;        // U+002A ASTERISK (*)
+const SOLIDUS = 0x002F;         // U+002F SOLIDUS (/)
+
+
+const name = 'Comment';
+const structure = {
+    value: String
+};
+
+function parse() {
+    const start = this.tokenStart;
+    let end = this.tokenEnd;
+
+    this.eat(types.Comment);
+
+    if ((end - start + 2) >= 2 &&
+        this.charCodeAt(end - 2) === ASTERISK &&
+        this.charCodeAt(end - 1) === SOLIDUS) {
+        end -= 2;
+    }
+
+    return {
+        type: 'Comment',
+        loc: this.getLocation(start, this.tokenStart),
+        value: this.substring(start + 2, end)
+    };
+}
+
+function generate(node) {
+    this.token(types.Comment, '/*' + node.value + '*/');
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Condition.cjs

@@ -0,0 +1,127 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const MediaFeatureToken = new Set([types.Colon, types.RightParenthesis, types.EOF]);
+const SupportsFeatureToken = new Set([types.Colon, types.EOF]);
+
+const name = 'Condition';
+const structure = {
+    kind: String,
+    children: [[
+        'Identifier',
+        'Feature',
+        'FeatureRange'
+    ]]
+};
+
+const conditions = {
+    media() {
+        if (this.tokenType === types.LeftParenthesis) {
+            const firstToken = this.lookupTypeNonSC(1);
+            if (firstToken === types.Ident && MediaFeatureToken.has(this.lookupTypeNonSC(2))) {
+                return this.Feature('media');
+            } else if (firstToken !== types.LeftParenthesis) {
+                return this.parseWithFallback(() => this.FeatureRange('media'), (startIndex) => {
+                    this.skip(startIndex - this.tokenIndex);
+                });
+            }
+        }
+    },
+    supports() {
+        if (this.tokenType === types.LeftParenthesis) {
+            if (this.lookupTypeNonSC(1) === types.Ident && SupportsFeatureToken.has(this.lookupTypeNonSC(2))) {
+                return this.Declaration();
+            }
+        }
+    },
+    container() {
+        if (this.tokenType === types.LeftParenthesis) {
+            if (this.lookupTypeNonSC(1) === types.Ident && MediaFeatureToken.has(this.lookupTypeNonSC(2))) {
+                return this.Feature('size');
+            } else if (this.lookupTypeNonSC(1) !== types.LeftParenthesis) {
+                return this.FeatureRange('size');
+            }
+        }
+    }
+};
+
+function parse(kind = 'media') {
+    const children = this.createList();
+    const termParser = conditions[kind];
+
+    scan: while (!this.eof) {
+        switch (this.tokenType) {
+            case types.Comment:
+            case types.WhiteSpace:
+                this.next();
+                continue;
+
+            case types.Ident:
+                children.push(this.Identifier());
+                break;
+
+            case types.LeftParenthesis: {
+                let term = termParser.call(this);
+
+                if (!term) {
+                    term = this.parseWithFallback(() => {
+                        this.next();
+                        const res = this.Condition(kind);
+                        this.eat(types.RightParenthesis);
+                        return res;
+                    }, (startIndex) => {
+                        this.skip(startIndex - this.tokenIndex);
+                        return this.GeneralEnclosed();
+                    });
+                }
+
+                children.push(term);
+                break;
+            }
+
+            case types.Function: {
+                let term = termParser.call(this);
+
+                if (!term) {
+                    term = this.GeneralEnclosed();
+                }
+
+                children.push(term);
+                break;
+            }
+
+            default:
+                break scan;
+        }
+    }
+
+    if (children.isEmpty) {
+        this.error('Condition can\'t be empty');
+    }
+
+    return {
+        type: 'Condition',
+        loc: this.getLocationFromList(children),
+        kind,
+        children
+    };
+}
+
+function generate(node) {
+    node.children.forEach(child => {
+        if (child.type === 'Condition') {
+            this.token(types.LeftParenthesis, '(');
+            this.node(child);
+            this.token(types.RightParenthesis, ')');
+        } else {
+            this.node(child);
+        }
+    });
+}
+
+exports.conditions = conditions;
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Declaration.cjs

@@ -0,0 +1,166 @@
+'use strict';
+
+const names = require('../../utils/names.cjs');
+const types = require('../../tokenizer/types.cjs');
+
+const EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!)
+const NUMBERSIGN = 0x0023;      // U+0023 NUMBER SIGN (#)
+const DOLLARSIGN = 0x0024;      // U+0024 DOLLAR SIGN ($)
+const AMPERSAND = 0x0026;       // U+0026 AMPERSAND (&)
+const ASTERISK = 0x002A;        // U+002A ASTERISK (*)
+const PLUSSIGN = 0x002B;        // U+002B PLUS SIGN (+)
+const SOLIDUS = 0x002F;         // U+002F SOLIDUS (/)
+
+function consumeValueRaw(startToken) {
+    return this.Raw(startToken, this.consumeUntilExclamationMarkOrSemicolon, true);
+}
+
+function consumeCustomPropertyRaw(startToken) {
+    return this.Raw(startToken, this.consumeUntilExclamationMarkOrSemicolon, false);
+}
+
+function consumeValue() {
+    const startValueToken = this.tokenIndex;
+    const value = this.Value();
+
+    if (value.type !== 'Raw' &&
+        this.eof === false &&
+        this.tokenType !== types.Semicolon &&
+        this.isDelim(EXCLAMATIONMARK) === false &&
+        this.isBalanceEdge(startValueToken) === false) {
+        this.error();
+    }
+
+    return value;
+}
+
+const name = 'Declaration';
+const walkContext = 'declaration';
+const structure = {
+    important: [Boolean, String],
+    property: String,
+    value: ['Value', 'Raw']
+};
+
+function parse() {
+    const start = this.tokenStart;
+    const startToken = this.tokenIndex;
+    const property = readProperty.call(this);
+    const customProperty = names.isCustomProperty(property);
+    const parseValue = customProperty ? this.parseCustomProperty : this.parseValue;
+    const consumeRaw = customProperty ? consumeCustomPropertyRaw : consumeValueRaw;
+    let important = false;
+    let value;
+
+    this.skipSC();
+    this.eat(types.Colon);
+
+    const valueStart = this.tokenIndex;
+
+    if (!customProperty) {
+        this.skipSC();
+    }
+
+    if (parseValue) {
+        value = this.parseWithFallback(consumeValue, consumeRaw);
+    } else {
+        value = consumeRaw.call(this, this.tokenIndex);
+    }
+
+    if (customProperty && value.type === 'Value' && value.children.isEmpty) {
+        for (let offset = valueStart - this.tokenIndex; offset <= 0; offset++) {
+            if (this.lookupType(offset) === types.WhiteSpace) {
+                value.children.appendData({
+                    type: 'WhiteSpace',
+                    loc: null,
+                    value: ' '
+                });
+                break;
+            }
+        }
+    }
+
+    if (this.isDelim(EXCLAMATIONMARK)) {
+        important = getImportant.call(this);
+        this.skipSC();
+    }
+
+    // Do not include semicolon to range per spec
+    // https://drafts.csswg.org/css-syntax/#declaration-diagram
+
+    if (this.eof === false &&
+        this.tokenType !== types.Semicolon &&
+        this.isBalanceEdge(startToken) === false) {
+        this.error();
+    }
+
+    return {
+        type: 'Declaration',
+        loc: this.getLocation(start, this.tokenStart),
+        important,
+        property,
+        value
+    };
+}
+
+function generate(node) {
+    this.token(types.Ident, node.property);
+    this.token(types.Colon, ':');
+    this.node(node.value);
+
+    if (node.important) {
+        this.token(types.Delim, '!');
+        this.token(types.Ident, node.important === true ? 'important' : node.important);
+    }
+}
+
+function readProperty() {
+    const start = this.tokenStart;
+
+    // hacks
+    if (this.tokenType === types.Delim) {
+        switch (this.charCodeAt(this.tokenStart)) {
+            case ASTERISK:
+            case DOLLARSIGN:
+            case PLUSSIGN:
+            case NUMBERSIGN:
+            case AMPERSAND:
+                this.next();
+                break;
+
+            // TODO: not sure we should support this hack
+            case SOLIDUS:
+                this.next();
+                if (this.isDelim(SOLIDUS)) {
+                    this.next();
+                }
+                break;
+        }
+    }
+
+    if (this.tokenType === types.Hash) {
+        this.eat(types.Hash);
+    } else {
+        this.eat(types.Ident);
+    }
+
+    return this.substrToCursor(start);
+}
+
+// ! ws* important
+function getImportant() {
+    this.eat(types.Delim);
+    this.skipSC();
+
+    const important = this.consume(types.Ident);
+
+    // store original value in case it differ from `important`
+    // for better original source restoring and hacks like `!ie` support
+    return important === 'important' ? true : important;
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;
+exports.walkContext = walkContext;

node_modules/css-tree/cjs/syntax/node/DeclarationList.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const AMPERSAND = 0x0026;       // U+0026 AMPERSAND (&)
+
+function consumeRaw(startToken) {
+    return this.Raw(startToken, this.consumeUntilSemicolonIncluded, true);
+}
+
+const name = 'DeclarationList';
+const structure = {
+    children: [[
+        'Declaration',
+        'Atrule',
+        'Rule'
+    ]]
+};
+
+function parse() {
+    const children = this.createList();
+
+    while (!this.eof) {
+        switch (this.tokenType) {
+            case types.WhiteSpace:
+            case types.Comment:
+            case types.Semicolon:
+                this.next();
+                break;
+
+            case types.AtKeyword:
+                children.push(this.parseWithFallback(this.Atrule.bind(this, true), consumeRaw));
+                break;
+
+            default:
+                if (this.isDelim(AMPERSAND))  {
+                    children.push(this.parseWithFallback(this.Rule, consumeRaw));
+                } else {
+                    children.push(this.parseWithFallback(this.Declaration, consumeRaw));
+                }
+        }
+    }
+
+    return {
+        type: 'DeclarationList',
+        loc: this.getLocationFromList(children),
+        children
+    };
+}
+
+function generate(node) {
+    this.children(node, prev => {
+        if (prev.type === 'Declaration') {
+            this.token(types.Semicolon, ';');
+        }
+    });
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Dimension.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'Dimension';
+const structure = {
+    value: String,
+    unit: String
+};
+
+function parse() {
+    const start = this.tokenStart;
+    const value = this.consumeNumber(types.Dimension);
+
+    return {
+        type: 'Dimension',
+        loc: this.getLocation(start, this.tokenStart),
+        value,
+        unit: this.substring(start + value.length, this.tokenStart)
+    };
+}
+
+function generate(node) {
+    this.token(types.Dimension, node.value + node.unit);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Feature.cjs

@@ -0,0 +1,78 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'Feature';
+const structure = {
+    kind: String,
+    name: String,
+    value: ['Identifier', 'Number', 'Dimension', 'Ratio', null]
+};
+
+function parse(kind = 'unknown') {
+    const start = this.tokenStart;
+    let name;
+    let value = null;
+
+    this.eat(types.LeftParenthesis);
+    this.skipSC();
+
+    name = this.consume(types.Ident);
+    this.skipSC();
+
+    if (this.tokenType !== types.RightParenthesis) {
+        this.eat(types.Colon);
+        this.skipSC();
+
+        switch (this.tokenType) {
+            case types.Number:
+                if (this.lookupNonWSType(1) === types.Delim) {
+                    value = this.Ratio();
+                } else {
+                    value = this.Number();
+                }
+
+                break;
+
+            case types.Dimension:
+                value = this.Dimension();
+                break;
+
+            case types.Ident:
+                value = this.Identifier();
+                break;
+
+            default:
+                this.error('Number, dimension, ratio or identifier is expected');
+        }
+
+        this.skipSC();
+    }
+
+    this.eat(types.RightParenthesis);
+
+    return {
+        type: 'Feature',
+        loc: this.getLocation(start, this.tokenStart),
+        kind,
+        name,
+        value
+    };
+}
+
+function generate(node) {
+    this.token(types.LeftParenthesis, '(');
+    this.token(types.Ident, node.name);
+
+    if (node.value !== null) {
+        this.token(types.Colon, ':');
+        this.node(node.value);
+    }
+
+    this.token(types.RightParenthesis, ')');
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/FeatureRange.cjs

@@ -0,0 +1,114 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const LESSTHANSIGN = 60;    // <
+const EQUALSIGN = 61;       // =
+const GREATERTHANSIGN = 62; // >
+
+const name = 'FeatureRange';
+const structure = {
+    kind: String,
+    left: ['Identifier', 'Number', 'Dimension', 'Ratio'],
+    leftComparison: String,
+    middle: ['Identifier', 'Number', 'Dimension', 'Ratio'],
+    rightComparison: [String, null],
+    right: ['Identifier', 'Number', 'Dimension', 'Ratio', null]
+};
+
+function readTerm() {
+    this.skipSC();
+
+    switch (this.tokenType) {
+        case types.Number:
+            if (this.lookupNonWSType(1) === types.Delim) {
+                return this.Ratio();
+            } else {
+                return this.Number();
+            }
+
+        case types.Dimension:
+            return this.Dimension();
+
+        case types.Ident:
+            return this.Identifier();
+
+        default:
+            this.error('Number, dimension, ratio or identifier is expected');
+    }
+}
+
+function readComparison(expectColon) {
+    this.skipSC();
+
+    if (this.isDelim(LESSTHANSIGN) ||
+        this.isDelim(GREATERTHANSIGN)) {
+        const value = this.source[this.tokenStart];
+
+        this.next();
+
+        if (this.isDelim(EQUALSIGN)) {
+            this.next();
+            return value + '=';
+        }
+
+        return value;
+    }
+
+    if (this.isDelim(EQUALSIGN)) {
+        return '=';
+    }
+
+    this.error(`Expected ${expectColon ? '":", ' : ''}"<", ">", "=" or ")"`);
+}
+
+function parse(kind = 'unknown') {
+    const start = this.tokenStart;
+
+    this.skipSC();
+    this.eat(types.LeftParenthesis);
+
+    const left = readTerm.call(this);
+    const leftComparison = readComparison.call(this, left.type === 'Identifier');
+    const middle = readTerm.call(this);
+    let rightComparison = null;
+    let right = null;
+
+    if (this.lookupNonWSType(0) !== types.RightParenthesis) {
+        rightComparison = readComparison.call(this);
+        right = readTerm.call(this);
+    }
+
+    this.skipSC();
+    this.eat(types.RightParenthesis);
+
+    return {
+        type: 'FeatureRange',
+        loc: this.getLocation(start, this.tokenStart),
+        kind,
+        left,
+        leftComparison,
+        middle,
+        rightComparison,
+        right
+    };
+}
+
+function generate(node) {
+    this.token(types.LeftParenthesis, '(');
+    this.node(node.left);
+    this.tokenize(node.leftComparison);
+    this.node(node.middle);
+
+    if (node.right) {
+        this.tokenize(node.rightComparison);
+        this.node(node.right);
+    }
+
+    this.token(types.RightParenthesis, ')');
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Function.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'Function';
+const walkContext = 'function';
+const structure = {
+    name: String,
+    children: [[]]
+};
+
+// <function-token> <sequence> )
+function parse(readSequence, recognizer) {
+    const start = this.tokenStart;
+    const name = this.consumeFunctionName();
+    const nameLowerCase = name.toLowerCase();
+    let children;
+
+    children = recognizer.hasOwnProperty(nameLowerCase)
+        ? recognizer[nameLowerCase].call(this, recognizer)
+        : readSequence.call(this, recognizer);
+
+    if (!this.eof) {
+        this.eat(types.RightParenthesis);
+    }
+
+    return {
+        type: 'Function',
+        loc: this.getLocation(start, this.tokenStart),
+        name,
+        children
+    };
+}
+
+function generate(node) {
+    this.token(types.Function, node.name + '(');
+    this.children(node);
+    this.token(types.RightParenthesis, ')');
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;
+exports.walkContext = walkContext;

node_modules/css-tree/cjs/syntax/node/GeneralEnclosed.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'GeneralEnclosed';
+const structure = {
+    function: [String, null],
+    children: [[]]
+};
+
+// <function-token> <any-value> )
+// ( <any-value> )
+function parse() {
+    const start = this.tokenStart;
+    let functionName = null;
+
+    if (this.tokenType === types.Function) {
+        functionName = this.consumeFunctionName();
+    } else {
+        this.eat(types.LeftParenthesis);
+    }
+
+    const children = this.readSequence(this.scope.Value);
+
+    if (!this.eof) {
+        this.eat(types.RightParenthesis);
+    }
+
+    return {
+        type: 'GeneralEnclosed',
+        loc: this.getLocation(start, this.tokenStart),
+        function: functionName,
+        children
+    };
+}
+
+function generate(node) {
+    if (node.function) {
+        this.token(types.Function, node.function + '(');
+    } else {
+        this.token(types.LeftParenthesis, '(');
+    }
+
+    this.children(node);
+    this.token(types.RightParenthesis, ')');
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Hash.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+// '#' ident
+const xxx = 'XXX';
+const name = 'Hash';
+const structure = {
+    value: String
+};
+function parse() {
+    const start = this.tokenStart;
+
+    this.eat(types.Hash);
+
+    return {
+        type: 'Hash',
+        loc: this.getLocation(start, this.tokenStart),
+        value: this.substrToCursor(start + 1)
+    };
+}
+function generate(node) {
+    this.token(types.Hash, '#' + node.value);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;
+exports.xxx = xxx;

node_modules/css-tree/cjs/syntax/node/IdSelector.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'IdSelector';
+const structure = {
+    name: String
+};
+
+function parse() {
+    const start = this.tokenStart;
+
+    // TODO: check value is an ident
+    this.eat(types.Hash);
+
+    return {
+        type: 'IdSelector',
+        loc: this.getLocation(start, this.tokenStart),
+        name: this.substrToCursor(start + 1)
+    };
+}
+
+function generate(node) {
+    // Using Delim instead of Hash is a hack to avoid for a whitespace between ident and id-selector
+    // in safe mode (e.g. "a#id"), because IE11 doesn't allow a sequence <ident-token> <hash-token>
+    // without a whitespace in values (e.g. "1px solid#000")
+    this.token(types.Delim, '#' + node.name);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Identifier.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'Identifier';
+const structure = {
+    name: String
+};
+
+function parse() {
+    return {
+        type: 'Identifier',
+        loc: this.getLocation(this.tokenStart, this.tokenEnd),
+        name: this.consume(types.Ident)
+    };
+}
+
+function generate(node) {
+    this.token(types.Ident, node.name);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/MediaCondition.cjs

@@ -0,0 +1,70 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const MediaFeatureToken = new Set([types.Colon, types.RightParenthesis, types.EOF]);
+
+const name = 'MediaCondition';
+const structure = {
+    children: [[
+        'Identifier',
+        'MediaFeature',
+        'MediaFeatureRange'
+    ]]
+};
+
+function parse() {
+    const children = this.createList();
+
+    scan: while (!this.eof) {
+        switch (this.tokenType) {
+            case types.Comment:
+            case types.WhiteSpace:
+                this.next();
+                continue;
+
+            case types.Ident:
+                children.push(this.Identifier());
+                break;
+
+            case types.LeftParenthesis:
+                if (this.lookupTypeNonSC(1) === types.Ident && MediaFeatureToken.has(this.lookupTypeNonSC(2))) {
+                    children.push(this.MediaFeature());
+                } else if (this.lookupTypeNonSC(1) === types.LeftParenthesis || this.lookupTypeNonSC(2) === types.LeftParenthesis) {
+                    this.next();
+                    children.push(this.MediaCondition());
+                    this.eat(types.RightParenthesis);
+                } else {
+                    children.push(this.MediaFeatureRange());
+                }
+
+                break;
+
+            default:
+                break scan;
+        }
+    }
+
+    return {
+        type: 'MediaCondition',
+        loc: this.getLocationFromList(children),
+        children
+    };
+}
+
+function generate(node) {
+    node.children.forEach(child => {
+        if (child.type === 'MediaCondition') {
+            this.token(types.LeftParenthesis, '(');
+            this.node(child);
+            this.token(types.RightParenthesis, ')');
+        } else {
+            this.node(child);
+        }
+    });
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/MediaFeature.cjs

@@ -0,0 +1,76 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'MediaFeature';
+const structure = {
+    name: String,
+    value: ['Identifier', 'Number', 'Dimension', 'Ratio', null]
+};
+
+function parse() {
+    const start = this.tokenStart;
+    let name;
+    let value = null;
+
+    this.eat(types.LeftParenthesis);
+    this.skipSC();
+
+    name = this.consume(types.Ident);
+    this.skipSC();
+
+    if (this.tokenType !== types.RightParenthesis) {
+        this.eat(types.Colon);
+        this.skipSC();
+
+        switch (this.tokenType) {
+            case types.Number:
+                if (this.lookupNonWSType(1) === types.Delim) {
+                    value = this.Ratio();
+                } else {
+                    value = this.Number();
+                }
+
+                break;
+
+            case types.Dimension:
+                value = this.Dimension();
+                break;
+
+            case types.Ident:
+                value = this.Identifier();
+                break;
+
+            default:
+                this.error('Number, dimension, ratio or identifier is expected');
+        }
+
+        this.skipSC();
+    }
+
+    this.eat(types.RightParenthesis);
+
+    return {
+        type: 'MediaFeature',
+        loc: this.getLocation(start, this.tokenStart),
+        name,
+        value
+    };
+}
+
+function generate(node) {
+    this.token(types.LeftParenthesis, '(');
+    this.token(types.Ident, node.name);
+
+    if (node.value !== null) {
+        this.token(types.Colon, ':');
+        this.node(node.value);
+    }
+
+    this.token(types.RightParenthesis, ')');
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/MediaFeatureRange.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const featureRange = require('./common/feature-range.cjs');
+
+const name = 'MediaFeatureRange';
+const parse = featureRange.createParse(name);
+
+exports.generate = featureRange.generate;
+exports.structure = featureRange.structure;
+exports.name = name;
+exports.parse = parse;

node_modules/css-tree/cjs/syntax/node/MediaQuery.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'MediaQuery';
+const structure = {
+    children: [[
+        'Identifier',
+        'MediaFeature',
+        'WhiteSpace'
+    ]]
+};
+
+function parse() {
+    const children = this.createList();
+    let child = null;
+
+    this.skipSC();
+
+    scan:
+    while (!this.eof) {
+        switch (this.tokenType) {
+            case types.Comment:
+            case types.WhiteSpace:
+                this.next();
+                continue;
+
+            case types.Ident:
+                child = this.Identifier();
+                break;
+
+            case types.LeftParenthesis:
+                child = this.MediaFeature();
+                break;
+
+            default:
+                break scan;
+        }
+
+        children.push(child);
+    }
+
+    if (child === null) {
+        this.error('Identifier or parenthesis is expected');
+    }
+
+    return {
+        type: 'MediaQuery',
+        loc: this.getLocationFromList(children),
+        children
+    };
+}
+
+function generate(node) {
+    this.children(node);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/MediaQueryList.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'MediaQueryList';
+const structure = {
+    children: [[
+        'MediaQuery'
+    ]]
+};
+
+function parse() {
+    const children = this.createList();
+
+    this.skipSC();
+
+    while (!this.eof) {
+        children.push(this.MediaQuery());
+
+        if (this.tokenType !== types.Comma) {
+            break;
+        }
+
+        this.next();
+    }
+
+    return {
+        type: 'MediaQueryList',
+        loc: this.getLocationFromList(children),
+        children
+    };
+}
+
+function generate(node) {
+    this.children(node, () => this.token(types.Comma, ','));
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/NestingSelector.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const AMPERSAND = 0x0026;       // U+0026 AMPERSAND (&)
+
+const name = 'NestingSelector';
+const structure = {
+};
+
+function parse() {
+    const start = this.tokenStart;
+
+    this.eatDelim(AMPERSAND);
+
+    return {
+        type: 'NestingSelector',
+        loc: this.getLocation(start, this.tokenStart)
+    };
+}
+
+function generate() {
+    this.token(types.Delim, '&');
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Nth.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'Nth';
+const structure = {
+    nth: ['AnPlusB', 'Identifier'],
+    selector: ['SelectorList', null]
+};
+
+function parse() {
+    this.skipSC();
+
+    const start = this.tokenStart;
+    let end = start;
+    let selector = null;
+    let nth;
+
+    if (this.lookupValue(0, 'odd') || this.lookupValue(0, 'even')) {
+        nth = this.Identifier();
+    } else {
+        nth = this.AnPlusB();
+    }
+
+    end = this.tokenStart;
+    this.skipSC();
+
+    if (this.lookupValue(0, 'of')) {
+        this.next();
+
+        selector = this.SelectorList();
+        end = this.tokenStart;
+    }
+
+    return {
+        type: 'Nth',
+        loc: this.getLocation(start, end),
+        nth,
+        selector
+    };
+}
+
+function generate(node) {
+    this.node(node.nth);
+    if (node.selector !== null) {
+        this.token(types.Ident, 'of');
+        this.node(node.selector);
+    }
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Number.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'Number';
+const structure = {
+    value: String
+};
+
+function parse() {
+    return {
+        type: 'Number',
+        loc: this.getLocation(this.tokenStart, this.tokenEnd),
+        value: this.consume(types.Number)
+    };
+}
+
+function generate(node) {
+    this.token(types.Number, node.value);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Operator.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+// '/' | '*' | ',' | ':' | '+' | '-'
+const name = 'Operator';
+const structure = {
+    value: String
+};
+
+function parse() {
+    const start = this.tokenStart;
+
+    this.next();
+
+    return {
+        type: 'Operator',
+        loc: this.getLocation(start, this.tokenStart),
+        value: this.substrToCursor(start)
+    };
+}
+
+function generate(node) {
+    this.tokenize(node.value);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Parentheses.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'Parentheses';
+const structure = {
+    children: [[]]
+};
+
+function parse(readSequence, recognizer) {
+    const start = this.tokenStart;
+    let children = null;
+
+    this.eat(types.LeftParenthesis);
+
+    children = readSequence.call(this, recognizer);
+
+    if (!this.eof) {
+        this.eat(types.RightParenthesis);
+    }
+
+    return {
+        type: 'Parentheses',
+        loc: this.getLocation(start, this.tokenStart),
+        children
+    };
+}
+
+function generate(node) {
+    this.token(types.LeftParenthesis, '(');
+    this.children(node);
+    this.token(types.RightParenthesis, ')');
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Percentage.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'Percentage';
+const structure = {
+    value: String
+};
+
+function parse() {
+    return {
+        type: 'Percentage',
+        loc: this.getLocation(this.tokenStart, this.tokenEnd),
+        value: this.consumeNumber(types.Percentage)
+    };
+}
+
+function generate(node) {
+    this.token(types.Percentage, node.value + '%');
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/PseudoClassSelector.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'PseudoClassSelector';
+const walkContext = 'function';
+const structure = {
+    name: String,
+    children: [['Raw'], null]
+};
+
+// : [ <ident> | <function-token> <any-value>? ) ]
+function parse() {
+    const start = this.tokenStart;
+    let children = null;
+    let name;
+    let nameLowerCase;
+
+    this.eat(types.Colon);
+
+    if (this.tokenType === types.Function) {
+        name = this.consumeFunctionName();
+        nameLowerCase = name.toLowerCase();
+
+        if (hasOwnProperty.call(this.pseudo, nameLowerCase)) {
+            this.skipSC();
+            children = this.pseudo[nameLowerCase].call(this);
+            this.skipSC();
+        } else {
+            children = this.createList();
+            children.push(
+                this.Raw(this.tokenIndex, null, false)
+            );
+        }
+
+        this.eat(types.RightParenthesis);
+    } else {
+        name = this.consume(types.Ident);
+    }
+
+    return {
+        type: 'PseudoClassSelector',
+        loc: this.getLocation(start, this.tokenStart),
+        name,
+        children
+    };
+}
+
+function generate(node) {
+    this.token(types.Colon, ':');
+
+    if (node.children === null) {
+        this.token(types.Ident, node.name);
+    } else {
+        this.token(types.Function, node.name + '(');
+        this.children(node);
+        this.token(types.RightParenthesis, ')');
+    }
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;
+exports.walkContext = walkContext;

node_modules/css-tree/cjs/syntax/node/PseudoElementSelector.cjs

@@ -0,0 +1,67 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'PseudoElementSelector';
+const walkContext = 'function';
+const structure = {
+    name: String,
+    children: [['Raw'], null]
+};
+
+// :: [ <ident> | <function-token> <any-value>? ) ]
+function parse() {
+    const start = this.tokenStart;
+    let children = null;
+    let name;
+    let nameLowerCase;
+
+    this.eat(types.Colon);
+    this.eat(types.Colon);
+
+    if (this.tokenType === types.Function) {
+        name = this.consumeFunctionName();
+        nameLowerCase = name.toLowerCase();
+
+        if (hasOwnProperty.call(this.pseudo, nameLowerCase)) {
+            this.skipSC();
+            children = this.pseudo[nameLowerCase].call(this);
+            this.skipSC();
+        } else {
+            children = this.createList();
+            children.push(
+                this.Raw(this.tokenIndex, null, false)
+            );
+        }
+
+        this.eat(types.RightParenthesis);
+    } else {
+        name = this.consume(types.Ident);
+    }
+
+    return {
+        type: 'PseudoElementSelector',
+        loc: this.getLocation(start, this.tokenStart),
+        name,
+        children
+    };
+}
+
+function generate(node) {
+    this.token(types.Colon, ':');
+    this.token(types.Colon, ':');
+
+    if (node.children === null) {
+        this.token(types.Ident, node.name);
+    } else {
+        this.token(types.Function, node.name + '(');
+        this.children(node);
+        this.token(types.RightParenthesis, ')');
+    }
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;
+exports.walkContext = walkContext;

node_modules/css-tree/cjs/syntax/node/Ratio.cjs

@@ -0,0 +1,67 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+const charCodeDefinitions = require('../../tokenizer/char-code-definitions.cjs');
+
+const SOLIDUS = 0x002F;  // U+002F SOLIDUS (/)
+const FULLSTOP = 0x002E; // U+002E FULL STOP (.)
+
+// Terms of <ratio> should be a positive numbers (not zero or negative)
+// (see https://drafts.csswg.org/mediaqueries-3/#values)
+// However, -o-min-device-pixel-ratio takes fractional values as a ratio's term
+// and this is using by various sites. Therefore we relax checking on parse
+// to test a term is unsigned number without an exponent part.
+// Additional checking may be applied on lexer validation.
+function consumeNumber() {
+    this.skipSC();
+
+    const value = this.consume(types.Number);
+
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (!charCodeDefinitions.isDigit(code) && code !== FULLSTOP) {
+            this.error('Unsigned number is expected', this.tokenStart - value.length + i);
+        }
+    }
+
+    if (Number(value) === 0) {
+        this.error('Zero number is not allowed', this.tokenStart - value.length);
+    }
+
+    return value;
+}
+
+const name = 'Ratio';
+const structure = {
+    left: String,
+    right: String
+};
+
+// <positive-integer> S* '/' S* <positive-integer>
+function parse() {
+    const start = this.tokenStart;
+    const left = consumeNumber.call(this);
+    let right;
+
+    this.skipSC();
+    this.eatDelim(SOLIDUS);
+    right = consumeNumber.call(this);
+
+    return {
+        type: 'Ratio',
+        loc: this.getLocation(start, this.tokenStart),
+        left,
+        right
+    };
+}
+
+function generate(node) {
+    this.token(types.Number, node.left);
+    this.token(types.Delim, '/');
+    this.token(types.Number, node.right);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Raw.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+function getOffsetExcludeWS() {
+    if (this.tokenIndex > 0) {
+        if (this.lookupType(-1) === types.WhiteSpace) {
+            return this.tokenIndex > 1
+                ? this.getTokenStart(this.tokenIndex - 1)
+                : this.firstCharOffset;
+        }
+    }
+
+    return this.tokenStart;
+}
+
+const name = 'Raw';
+const structure = {
+    value: String
+};
+
+function parse(startToken, consumeUntil, excludeWhiteSpace) {
+    const startOffset = this.getTokenStart(startToken);
+    let endOffset;
+
+    this.skipUntilBalanced(startToken, consumeUntil || this.consumeUntilBalanceEnd);
+
+    if (excludeWhiteSpace && this.tokenStart > startOffset) {
+        endOffset = getOffsetExcludeWS.call(this);
+    } else {
+        endOffset = this.tokenStart;
+    }
+
+    return {
+        type: 'Raw',
+        loc: this.getLocation(startOffset, endOffset),
+        value: this.substring(startOffset, endOffset)
+    };
+}
+
+function generate(node) {
+    this.tokenize(node.value);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Rule.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+function consumeRaw(startToken) {
+    return this.Raw(startToken, this.consumeUntilLeftCurlyBracket, true);
+}
+
+function consumePrelude() {
+    const prelude = this.SelectorList();
+
+    if (prelude.type !== 'Raw' &&
+        this.eof === false &&
+        this.tokenType !== types.LeftCurlyBracket) {
+        this.error();
+    }
+
+    return prelude;
+}
+
+const name = 'Rule';
+const walkContext = 'rule';
+const structure = {
+    prelude: ['SelectorList', 'Raw'],
+    block: ['Block']
+};
+
+function parse() {
+    const startToken = this.tokenIndex;
+    const startOffset = this.tokenStart;
+    let prelude;
+    let block;
+
+    if (this.parseRulePrelude) {
+        prelude = this.parseWithFallback(consumePrelude, consumeRaw);
+    } else {
+        prelude = consumeRaw.call(this, startToken);
+    }
+
+    block = this.Block(true);
+
+    return {
+        type: 'Rule',
+        loc: this.getLocation(startOffset, this.tokenStart),
+        prelude,
+        block
+    };
+}
+function generate(node) {
+    this.node(node.prelude);
+    this.node(node.block);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;
+exports.walkContext = walkContext;

node_modules/css-tree/cjs/syntax/node/Selector.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+const name = 'Selector';
+const structure = {
+    children: [[
+        'TypeSelector',
+        'IdSelector',
+        'ClassSelector',
+        'AttributeSelector',
+        'PseudoClassSelector',
+        'PseudoElementSelector',
+        'Combinator',
+        'WhiteSpace'
+    ]]
+};
+
+function parse() {
+    const children = this.readSequence(this.scope.Selector);
+
+    // nothing were consumed
+    if (this.getFirstListNode(children) === null) {
+        this.error('Selector is expected');
+    }
+
+    return {
+        type: 'Selector',
+        loc: this.getLocationFromList(children),
+        children
+    };
+}
+
+function generate(node) {
+    this.children(node);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/SelectorList.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'SelectorList';
+const walkContext = 'selector';
+const structure = {
+    children: [[
+        'Selector',
+        'Raw'
+    ]]
+};
+
+function parse() {
+    const children = this.createList();
+
+    while (!this.eof) {
+        children.push(this.Selector());
+
+        if (this.tokenType === types.Comma) {
+            this.next();
+            continue;
+        }
+
+        break;
+    }
+
+    return {
+        type: 'SelectorList',
+        loc: this.getLocationFromList(children),
+        children
+    };
+}
+
+function generate(node) {
+    this.children(node, () => this.token(types.Comma, ','));
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;
+exports.walkContext = walkContext;

node_modules/css-tree/cjs/syntax/node/String.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+const string = require('../../utils/string.cjs');
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'String';
+const structure = {
+    value: String
+};
+
+function parse() {
+    return {
+        type: 'String',
+        loc: this.getLocation(this.tokenStart, this.tokenEnd),
+        value: string.decode(this.consume(types.String))
+    };
+}
+
+function generate(node) {
+    this.token(types.String, string.encode(node.value));
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/StyleSheet.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!)
+
+function consumeRaw(startToken) {
+    return this.Raw(startToken, null, false);
+}
+
+const name = 'StyleSheet';
+const walkContext = 'stylesheet';
+const structure = {
+    children: [[
+        'Comment',
+        'CDO',
+        'CDC',
+        'Atrule',
+        'Rule',
+        'Raw'
+    ]]
+};
+
+function parse() {
+    const start = this.tokenStart;
+    const children = this.createList();
+    let child;
+
+    while (!this.eof) {
+        switch (this.tokenType) {
+            case types.WhiteSpace:
+                this.next();
+                continue;
+
+            case types.Comment:
+                // ignore comments except exclamation comments (i.e. /*! .. */) on top level
+                if (this.charCodeAt(this.tokenStart + 2) !== EXCLAMATIONMARK) {
+                    this.next();
+                    continue;
+                }
+
+                child = this.Comment();
+                break;
+
+            case types.CDO: // <!--
+                child = this.CDO();
+                break;
+
+            case types.CDC: // -->
+                child = this.CDC();
+                break;
+
+            // CSS Syntax Module Level 3
+            // §2.2 Error handling
+            // At the "top level" of a stylesheet, an <at-keyword-token> starts an at-rule.
+            case types.AtKeyword:
+                child = this.parseWithFallback(this.Atrule, consumeRaw);
+                break;
+
+            // Anything else starts a qualified rule ...
+            default:
+                child = this.parseWithFallback(this.Rule, consumeRaw);
+        }
+
+        children.push(child);
+    }
+
+    return {
+        type: 'StyleSheet',
+        loc: this.getLocation(start, this.tokenStart),
+        children
+    };
+}
+
+function generate(node) {
+    this.children(node);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;
+exports.walkContext = walkContext;

node_modules/css-tree/cjs/syntax/node/TypeSelector.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const ASTERISK = 0x002A;     // U+002A ASTERISK (*)
+const VERTICALLINE = 0x007C; // U+007C VERTICAL LINE (|)
+
+function eatIdentifierOrAsterisk() {
+    if (this.tokenType !== types.Ident &&
+        this.isDelim(ASTERISK) === false) {
+        this.error('Identifier or asterisk is expected');
+    }
+
+    this.next();
+}
+
+const name = 'TypeSelector';
+const structure = {
+    name: String
+};
+
+// ident
+// ident|ident
+// ident|*
+// *
+// *|ident
+// *|*
+// |ident
+// |*
+function parse() {
+    const start = this.tokenStart;
+
+    if (this.isDelim(VERTICALLINE)) {
+        this.next();
+        eatIdentifierOrAsterisk.call(this);
+    } else {
+        eatIdentifierOrAsterisk.call(this);
+
+        if (this.isDelim(VERTICALLINE)) {
+            this.next();
+            eatIdentifierOrAsterisk.call(this);
+        }
+    }
+
+    return {
+        type: 'TypeSelector',
+        loc: this.getLocation(start, this.tokenStart),
+        name: this.substrToCursor(start)
+    };
+}
+
+function generate(node) {
+    this.tokenize(node.name);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/UnicodeRange.cjs

@@ -0,0 +1,158 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+const charCodeDefinitions = require('../../tokenizer/char-code-definitions.cjs');
+
+const PLUSSIGN = 0x002B;     // U+002B PLUS SIGN (+)
+const HYPHENMINUS = 0x002D;  // U+002D HYPHEN-MINUS (-)
+const QUESTIONMARK = 0x003F; // U+003F QUESTION MARK (?)
+
+function eatHexSequence(offset, allowDash) {
+    let len = 0;
+
+    for (let pos = this.tokenStart + offset; pos < this.tokenEnd; pos++) {
+        const code = this.charCodeAt(pos);
+
+        if (code === HYPHENMINUS && allowDash && len !== 0) {
+            eatHexSequence.call(this, offset + len + 1, false);
+            return -1;
+        }
+
+        if (!charCodeDefinitions.isHexDigit(code)) {
+            this.error(
+                allowDash && len !== 0
+                    ? 'Hyphen minus' + (len < 6 ? ' or hex digit' : '') + ' is expected'
+                    : (len < 6 ? 'Hex digit is expected' : 'Unexpected input'),
+                pos
+            );
+        }
+
+        if (++len > 6) {
+            this.error('Too many hex digits', pos);
+        }    }
+
+    this.next();
+    return len;
+}
+
+function eatQuestionMarkSequence(max) {
+    let count = 0;
+
+    while (this.isDelim(QUESTIONMARK)) {
+        if (++count > max) {
+            this.error('Too many question marks');
+        }
+
+        this.next();
+    }
+}
+
+function startsWith(code) {
+    if (this.charCodeAt(this.tokenStart) !== code) {
+        this.error((code === PLUSSIGN ? 'Plus sign' : 'Hyphen minus') + ' is expected');
+    }
+}
+
+// https://drafts.csswg.org/css-syntax/#urange
+// Informally, the <urange> production has three forms:
+// U+0001
+//      Defines a range consisting of a single code point, in this case the code point "1".
+// U+0001-00ff
+//      Defines a range of codepoints between the first and the second value, in this case
+//      the range between "1" and "ff" (255 in decimal) inclusive.
+// U+00??
+//      Defines a range of codepoints where the "?" characters range over all hex digits,
+//      in this case defining the same as the value U+0000-00ff.
+// In each form, a maximum of 6 digits is allowed for each hexadecimal number (if you treat "?" as a hexadecimal digit).
+//
+// <urange> =
+//   u '+' <ident-token> '?'* |
+//   u <dimension-token> '?'* |
+//   u <number-token> '?'* |
+//   u <number-token> <dimension-token> |
+//   u <number-token> <number-token> |
+//   u '+' '?'+
+function scanUnicodeRange() {
+    let hexLength = 0;
+
+    switch (this.tokenType) {
+        case types.Number:
+            // u <number-token> '?'*
+            // u <number-token> <dimension-token>
+            // u <number-token> <number-token>
+            hexLength = eatHexSequence.call(this, 1, true);
+
+            if (this.isDelim(QUESTIONMARK)) {
+                eatQuestionMarkSequence.call(this, 6 - hexLength);
+                break;
+            }
+
+            if (this.tokenType === types.Dimension ||
+                this.tokenType === types.Number) {
+                startsWith.call(this, HYPHENMINUS);
+                eatHexSequence.call(this, 1, false);
+                break;
+            }
+
+            break;
+
+        case types.Dimension:
+            // u <dimension-token> '?'*
+            hexLength = eatHexSequence.call(this, 1, true);
+
+            if (hexLength > 0) {
+                eatQuestionMarkSequence.call(this, 6 - hexLength);
+            }
+
+            break;
+
+        default:
+            // u '+' <ident-token> '?'*
+            // u '+' '?'+
+            this.eatDelim(PLUSSIGN);
+
+            if (this.tokenType === types.Ident) {
+                hexLength = eatHexSequence.call(this, 0, true);
+                if (hexLength > 0) {
+                    eatQuestionMarkSequence.call(this, 6 - hexLength);
+                }
+                break;
+            }
+
+            if (this.isDelim(QUESTIONMARK)) {
+                this.next();
+                eatQuestionMarkSequence.call(this, 5);
+                break;
+            }
+
+            this.error('Hex digit or question mark is expected');
+    }
+}
+
+const name = 'UnicodeRange';
+const structure = {
+    value: String
+};
+
+function parse() {
+    const start = this.tokenStart;
+
+    // U or u
+    this.eatIdent('u');
+    scanUnicodeRange.call(this);
+
+    return {
+        type: 'UnicodeRange',
+        loc: this.getLocation(start, this.tokenStart),
+        value: this.substrToCursor(start)
+    };
+}
+
+function generate(node) {
+    this.tokenize(node.value);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Url.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+const url = require('../../utils/url.cjs');
+const string = require('../../utils/string.cjs');
+const types = require('../../tokenizer/types.cjs');
+
+const name = 'Url';
+const structure = {
+    value: String
+};
+
+// <url-token> | <function-token> <string> )
+function parse() {
+    const start = this.tokenStart;
+    let value;
+
+    switch (this.tokenType) {
+        case types.Url:
+            value = url.decode(this.consume(types.Url));
+            break;
+
+        case types.Function:
+            if (!this.cmpStr(this.tokenStart, this.tokenEnd, 'url(')) {
+                this.error('Function name must be `url`');
+            }
+
+            this.eat(types.Function);
+            this.skipSC();
+            value = string.decode(this.consume(types.String));
+            this.skipSC();
+            if (!this.eof) {
+                this.eat(types.RightParenthesis);
+            }
+            break;
+
+        default:
+            this.error('Url or Function is expected');
+    }
+
+    return {
+        type: 'Url',
+        loc: this.getLocation(start, this.tokenStart),
+        value
+    };
+}
+
+function generate(node) {
+    this.token(types.Url, url.encode(node.value));
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/Value.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+const name = 'Value';
+const structure = {
+    children: [[]]
+};
+
+function parse() {
+    const start = this.tokenStart;
+    const children = this.readSequence(this.scope.Value);
+
+    return {
+        type: 'Value',
+        loc: this.getLocation(start, this.tokenStart),
+        children
+    };
+}
+
+function generate(node) {
+    this.children(node);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/WhiteSpace.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+const types = require('../../tokenizer/types.cjs');
+
+const SPACE = Object.freeze({
+    type: 'WhiteSpace',
+    loc: null,
+    value: ' '
+});
+
+const name = 'WhiteSpace';
+const structure = {
+    value: String
+};
+
+function parse() {
+    this.eat(types.WhiteSpace);
+    return SPACE;
+
+    // return {
+    //     type: 'WhiteSpace',
+    //     loc: this.getLocation(this.tokenStart, this.tokenEnd),
+    //     value: this.consume(WHITESPACE)
+    // };
+}
+
+function generate(node) {
+    this.token(types.WhiteSpace, node.value);
+}
+
+exports.generate = generate;
+exports.name = name;
+exports.parse = parse;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/common/feature-range.cjs

@@ -0,0 +1,112 @@
+'use strict';
+
+const types = require('../../../tokenizer/types.cjs');
+
+const LESSTHANSIGN = 60;    // <
+const EQUALSIGN = 61;       // =
+const GREATERTHANSIGN = 62; // >
+
+const structure = {
+    left: ['Identifier', 'Number', 'Dimension', 'Ratio'],
+    leftComparison: String,
+    middle: ['Identifier', 'Number', 'Dimension', 'Ratio'],
+    rightComparison: [String, null],
+    right: ['Identifier', 'Number', 'Dimension', 'Ratio', null]
+};
+
+function readTerm() {
+    this.skipSC();
+
+    switch (this.tokenType) {
+        case types.Number:
+            if (this.lookupNonWSType(1) === types.Delim) {
+                return this.Ratio();
+            } else {
+                return this.Number();
+            }
+
+        case types.Dimension:
+            return this.Dimension();
+
+        case types.Ident:
+            return this.Identifier();
+
+        default:
+            this.error('Number, dimension, ratio or identifier is expected');
+    }
+}
+
+function readComparison(expectColon) {
+    this.skipSC();
+
+    if (this.isDelim(LESSTHANSIGN) ||
+        this.isDelim(GREATERTHANSIGN)) {
+        const value = this.source[this.tokenStart];
+
+        this.next();
+
+        if (this.isDelim(EQUALSIGN)) {
+            this.next();
+            return value + '=';
+        }
+
+        return value;
+    }
+
+    if (this.isDelim(EQUALSIGN)) {
+        return '=';
+    }
+
+    this.error(`Expected ${expectColon ? '":", ' : ''}"<", ">", "=" or ")"`);
+}
+
+function createParse(type) {
+    return function parse() {
+        const start = this.tokenStart;
+
+        this.skipSC();
+        this.eat(types.LeftParenthesis);
+
+        const left = readTerm.call(this);
+        const leftComparison = readComparison.call(this, left.type === 'Identifier');
+        const middle = readTerm.call(this);
+        let rightComparison = null;
+        let right = null;
+
+        if (this.lookupNonWSType(0) !== types.RightParenthesis) {
+            rightComparison = readComparison.call(this);
+            right = readTerm.call(this);
+        }
+
+        this.skipSC();
+        this.eat(types.RightParenthesis);
+
+        return {
+            type,
+            loc: this.getLocation(start, this.tokenStart),
+            left,
+            leftComparison,
+            middle,
+            rightComparison,
+            right
+        };
+    };
+}
+
+function generate(node) {
+    this.token(types.LeftParenthesis, '(');
+    this.node(node.left);
+    this.tokenize(node.leftComparison);
+    this.node(node.middle);
+
+    if (node.right) {
+        this.tokenize(node.rightComparison);
+        this.node(node.right);
+    }
+
+    this.token(types.RightParenthesis, ')');
+}
+
+exports.createParse = createParse;
+exports.generate = generate;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/common/feature.cjs

@@ -0,0 +1,76 @@
+'use strict';
+
+const types = require('../../../tokenizer/types.cjs');
+
+const structure = {
+    name: String,
+    value: ['Identifier', 'Number', 'Dimension', 'Ratio', null]
+};
+
+function createParse(type) {
+    return function parse() {
+        const start = this.tokenStart;
+        let name;
+        let value = null;
+
+        this.eat(types.LeftParenthesis);
+        this.skipSC();
+
+        name = this.consume(types.Ident);
+        this.skipSC();
+
+        if (this.tokenType !== types.RightParenthesis) {
+            this.eat(types.Colon);
+            this.skipSC();
+
+            switch (this.tokenType) {
+                case types.Number:
+                    if (this.lookupNonWSType(1) === types.Delim) {
+                        value = this.Ratio();
+                    } else {
+                        value = this.Number();
+                    }
+
+                    break;
+
+                case types.Dimension:
+                    value = this.Dimension();
+                    break;
+
+                case types.Ident:
+                    value = this.Identifier();
+                    break;
+
+                default:
+                    this.error('Number, dimension, ratio or identifier is expected');
+            }
+
+            this.skipSC();
+        }
+
+        this.eat(types.RightParenthesis);
+
+        return {
+            type,
+            loc: this.getLocation(start, this.tokenStart),
+            name,
+            value
+        };
+    };
+}
+
+function generate(node) {
+    this.token(types.LeftParenthesis, '(');
+    this.token(types.Ident, node.name);
+
+    if (node.value !== null) {
+        this.token(types.Colon, ':');
+        this.node(node.value);
+    }
+
+    this.token(types.RightParenthesis, ')');
+}
+
+exports.createParse = createParse;
+exports.generate = generate;
+exports.structure = structure;

node_modules/css-tree/cjs/syntax/node/index-generate.cjs

@@ -0,0 +1,87 @@
+'use strict';
+
+const AnPlusB = require('./AnPlusB.cjs');
+const Atrule = require('./Atrule.cjs');
+const AtrulePrelude = require('./AtrulePrelude.cjs');
+const AttributeSelector = require('./AttributeSelector.cjs');
+const Block = require('./Block.cjs');
+const Brackets = require('./Brackets.cjs');
+const CDC = require('./CDC.cjs');
+const CDO = require('./CDO.cjs');
+const ClassSelector = require('./ClassSelector.cjs');
+const Combinator = require('./Combinator.cjs');
+const Comment = require('./Comment.cjs');
+const Declaration = require('./Declaration.cjs');
+const DeclarationList = require('./DeclarationList.cjs');
+const Dimension = require('./Dimension.cjs');
+const Function = require('./Function.cjs');
+const Hash = require('./Hash.cjs');
+const Identifier = require('./Identifier.cjs');
+const IdSelector = require('./IdSelector.cjs');
+const MediaFeature = require('./MediaFeature.cjs');
+const MediaQuery = require('./MediaQuery.cjs');
+const MediaQueryList = require('./MediaQueryList.cjs');
+const NestingSelector = require('./NestingSelector.cjs');
+const Nth = require('./Nth.cjs');
+const Number = require('./Number.cjs');
+const Operator = require('./Operator.cjs');
+const Parentheses = require('./Parentheses.cjs');
+const Percentage = require('./Percentage.cjs');
+const PseudoClassSelector = require('./PseudoClassSelector.cjs');
+const PseudoElementSelector = require('./PseudoElementSelector.cjs');
+const Ratio = require('./Ratio.cjs');
+const Raw = require('./Raw.cjs');
+const Rule = require('./Rule.cjs');
+const Selector = require('./Selector.cjs');
+const SelectorList = require('./SelectorList.cjs');
+const String = require('./String.cjs');
+const StyleSheet = require('./StyleSheet.cjs');
+const TypeSelector = require('./TypeSelector.cjs');
+const UnicodeRange = require('./UnicodeRange.cjs');
+const Url = require('./Url.cjs');
+const Value = require('./Value.cjs');
+const WhiteSpace = require('./WhiteSpace.cjs');
+
+
+
+exports.AnPlusB = AnPlusB.generate;
+exports.Atrule = Atrule.generate;
+exports.AtrulePrelude = AtrulePrelude.generate;
+exports.AttributeSelector = AttributeSelector.generate;
+exports.Block = Block.generate;
+exports.Brackets = Brackets.generate;
+exports.CDC = CDC.generate;
+exports.CDO = CDO.generate;
+exports.ClassSelector = ClassSelector.generate;
+exports.Combinator = Combinator.generate;
+exports.Comment = Comment.generate;
+exports.Declaration = Declaration.generate;
+exports.DeclarationList = DeclarationList.generate;
+exports.Dimension = Dimension.generate;
+exports.Function = Function.generate;
+exports.Hash = Hash.generate;
+exports.Identifier = Identifier.generate;
+exports.IdSelector = IdSelector.generate;
+exports.MediaFeature = MediaFeature.generate;
+exports.MediaQuery = MediaQuery.generate;
+exports.MediaQueryList = MediaQueryList.generate;
+exports.NestingSelector = NestingSelector.generate;
+exports.Nth = Nth.generate;
+exports.Number = Number.generate;
+exports.Operator = Operator.generate;
+exports.Parentheses = Parentheses.generate;
+exports.Percentage = Percentage.generate;
+exports.PseudoClassSelector = PseudoClassSelector.generate;
+exports.PseudoElementSelector = PseudoElementSelector.generate;
+exports.Ratio = Ratio.generate;
+exports.Raw = Raw.generate;
+exports.Rule = Rule.generate;
+exports.Selector = Selector.generate;
+exports.SelectorList = SelectorList.generate;
+exports.String = String.generate;
+exports.StyleSheet = StyleSheet.generate;
+exports.TypeSelector = TypeSelector.generate;
+exports.UnicodeRange = UnicodeRange.generate;
+exports.Url = Url.generate;
+exports.Value = Value.generate;
+exports.WhiteSpace = WhiteSpace.generate;

node_modules/css-tree/cjs/syntax/node/index-parse-selector.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+const AnPlusB = require('./AnPlusB.cjs');
+const AttributeSelector = require('./AttributeSelector.cjs');
+const ClassSelector = require('./ClassSelector.cjs');
+const Combinator = require('./Combinator.cjs');
+const Identifier = require('./Identifier.cjs');
+const IdSelector = require('./IdSelector.cjs');
+const NestingSelector = require('./NestingSelector.cjs');
+const Nth = require('./Nth.cjs');
+const Percentage = require('./Percentage.cjs');
+const PseudoClassSelector = require('./PseudoClassSelector.cjs');
+const PseudoElementSelector = require('./PseudoElementSelector.cjs');
+const Raw = require('./Raw.cjs');
+const Selector = require('./Selector.cjs');
+const SelectorList = require('./SelectorList.cjs');
+const String = require('./String.cjs');
+const TypeSelector = require('./TypeSelector.cjs');
+
+
+
+exports.AnPlusB = AnPlusB.parse;
+exports.AttributeSelector = AttributeSelector.parse;
+exports.ClassSelector = ClassSelector.parse;
+exports.Combinator = Combinator.parse;
+exports.Identifier = Identifier.parse;
+exports.IdSelector = IdSelector.parse;
+exports.NestingSelector = NestingSelector.parse;
+exports.Nth = Nth.parse;
+exports.Percentage = Percentage.parse;
+exports.PseudoClassSelector = PseudoClassSelector.parse;
+exports.PseudoElementSelector = PseudoElementSelector.parse;
+exports.Raw = Raw.parse;
+exports.Selector = Selector.parse;
+exports.SelectorList = SelectorList.parse;
+exports.String = String.parse;
+exports.TypeSelector = TypeSelector.parse;

node_modules/css-tree/cjs/syntax/node/index-parse.cjs

@@ -0,0 +1,87 @@
+'use strict';
+
+const AnPlusB = require('./AnPlusB.cjs');
+const Atrule = require('./Atrule.cjs');
+const AtrulePrelude = require('./AtrulePrelude.cjs');
+const AttributeSelector = require('./AttributeSelector.cjs');
+const Block = require('./Block.cjs');
+const Brackets = require('./Brackets.cjs');
+const CDC = require('./CDC.cjs');
+const CDO = require('./CDO.cjs');
+const ClassSelector = require('./ClassSelector.cjs');
+const Combinator = require('./Combinator.cjs');
+const Comment = require('./Comment.cjs');
+const Declaration = require('./Declaration.cjs');
+const DeclarationList = require('./DeclarationList.cjs');
+const Dimension = require('./Dimension.cjs');
+const Function = require('./Function.cjs');
+const Hash = require('./Hash.cjs');
+const Identifier = require('./Identifier.cjs');
+const IdSelector = require('./IdSelector.cjs');
+const MediaFeature = require('./MediaFeature.cjs');
+const MediaQuery = require('./MediaQuery.cjs');
+const MediaQueryList = require('./MediaQueryList.cjs');
+const NestingSelector = require('./NestingSelector.cjs');
+const Nth = require('./Nth.cjs');
+const Number = require('./Number.cjs');
+const Operator = require('./Operator.cjs');
+const Parentheses = require('./Parentheses.cjs');
+const Percentage = require('./Percentage.cjs');
+const PseudoClassSelector = require('./PseudoClassSelector.cjs');
+const PseudoElementSelector = require('./PseudoElementSelector.cjs');
+const Ratio = require('./Ratio.cjs');
+const Raw = require('./Raw.cjs');
+const Rule = require('./Rule.cjs');
+const Selector = require('./Selector.cjs');
+const SelectorList = require('./SelectorList.cjs');
+const String = require('./String.cjs');
+const StyleSheet = require('./StyleSheet.cjs');
+const TypeSelector = require('./TypeSelector.cjs');
+const UnicodeRange = require('./UnicodeRange.cjs');
+const Url = require('./Url.cjs');
+const Value = require('./Value.cjs');
+const WhiteSpace = require('./WhiteSpace.cjs');
+
+
+
+exports.AnPlusB = AnPlusB.parse;
+exports.Atrule = Atrule.parse;
+exports.AtrulePrelude = AtrulePrelude.parse;
+exports.AttributeSelector = AttributeSelector.parse;
+exports.Block = Block.parse;
+exports.Brackets = Brackets.parse;
+exports.CDC = CDC.parse;
+exports.CDO = CDO.parse;
+exports.ClassSelector = ClassSelector.parse;
+exports.Combinator = Combinator.parse;
+exports.Comment = Comment.parse;
+exports.Declaration = Declaration.parse;
+exports.DeclarationList = DeclarationList.parse;
+exports.Dimension = Dimension.parse;
+exports.Function = Function.parse;
+exports.Hash = Hash.parse;
+exports.Identifier = Identifier.parse;
+exports.IdSelector = IdSelector.parse;
+exports.MediaFeature = MediaFeature.parse;
+exports.MediaQuery = MediaQuery.parse;
+exports.MediaQueryList = MediaQueryList.parse;
+exports.NestingSelector = NestingSelector.parse;
+exports.Nth = Nth.parse;
+exports.Number = Number.parse;
+exports.Operator = Operator.parse;
+exports.Parentheses = Parentheses.parse;
+exports.Percentage = Percentage.parse;
+exports.PseudoClassSelector = PseudoClassSelector.parse;
+exports.PseudoElementSelector = PseudoElementSelector.parse;
+exports.Ratio = Ratio.parse;
+exports.Raw = Raw.parse;
+exports.Rule = Rule.parse;
+exports.Selector = Selector.parse;
+exports.SelectorList = SelectorList.parse;
+exports.String = String.parse;
+exports.StyleSheet = StyleSheet.parse;
+exports.TypeSelector = TypeSelector.parse;
+exports.UnicodeRange = UnicodeRange.parse;
+exports.Url = Url.parse;
+exports.Value = Value.parse;
+exports.WhiteSpace = WhiteSpace.parse;

node_modules/css-tree/cjs/syntax/node/index.cjs

@@ -0,0 +1,87 @@
+'use strict';
+
+const AnPlusB = require('./AnPlusB.cjs');
+const Atrule = require('./Atrule.cjs');
+const AtrulePrelude = require('./AtrulePrelude.cjs');
+const AttributeSelector = require('./AttributeSelector.cjs');
+const Block = require('./Block.cjs');
+const Brackets = require('./Brackets.cjs');
+const CDC = require('./CDC.cjs');
+const CDO = require('./CDO.cjs');
+const ClassSelector = require('./ClassSelector.cjs');
+const Combinator = require('./Combinator.cjs');
+const Comment = require('./Comment.cjs');
+const Declaration = require('./Declaration.cjs');
+const DeclarationList = require('./DeclarationList.cjs');
+const Dimension = require('./Dimension.cjs');
+const Function = require('./Function.cjs');
+const Hash = require('./Hash.cjs');
+const Identifier = require('./Identifier.cjs');
+const IdSelector = require('./IdSelector.cjs');
+const MediaFeature = require('./MediaFeature.cjs');
+const MediaQuery = require('./MediaQuery.cjs');
+const MediaQueryList = require('./MediaQueryList.cjs');
+const NestingSelector = require('./NestingSelector.cjs');
+const Nth = require('./Nth.cjs');
+const Number$1 = require('./Number.cjs');
+const Operator = require('./Operator.cjs');
+const Parentheses = require('./Parentheses.cjs');
+const Percentage = require('./Percentage.cjs');
+const PseudoClassSelector = require('./PseudoClassSelector.cjs');
+const PseudoElementSelector = require('./PseudoElementSelector.cjs');
+const Ratio = require('./Ratio.cjs');
+const Raw = require('./Raw.cjs');
+const Rule = require('./Rule.cjs');
+const Selector = require('./Selector.cjs');
+const SelectorList = require('./SelectorList.cjs');
+const String$1 = require('./String.cjs');
+const StyleSheet = require('./StyleSheet.cjs');
+const TypeSelector = require('./TypeSelector.cjs');
+const UnicodeRange = require('./UnicodeRange.cjs');
+const Url = require('./Url.cjs');
+const Value = require('./Value.cjs');
+const WhiteSpace = require('./WhiteSpace.cjs');
+
+
+
+exports.AnPlusB = AnPlusB;
+exports.Atrule = Atrule;
+exports.AtrulePrelude = AtrulePrelude;
+exports.AttributeSelector = AttributeSelector;
+exports.Block = Block;
+exports.Brackets = Brackets;
+exports.CDC = CDC;
+exports.CDO = CDO;
+exports.ClassSelector = ClassSelector;
+exports.Combinator = Combinator;
+exports.Comment = Comment;
+exports.Declaration = Declaration;
+exports.DeclarationList = DeclarationList;
+exports.Dimension = Dimension;
+exports.Function = Function;
+exports.Hash = Hash;
+exports.Identifier = Identifier;
+exports.IdSelector = IdSelector;
+exports.MediaFeature = MediaFeature;
+exports.MediaQuery = MediaQuery;
+exports.MediaQueryList = MediaQueryList;
+exports.NestingSelector = NestingSelector;
+exports.Nth = Nth;
+exports.Number = Number$1;
+exports.Operator = Operator;
+exports.Parentheses = Parentheses;
+exports.Percentage = Percentage;
+exports.PseudoClassSelector = PseudoClassSelector;
+exports.PseudoElementSelector = PseudoElementSelector;
+exports.Ratio = Ratio;
+exports.Raw = Raw;
+exports.Rule = Rule;
+exports.Selector = Selector;
+exports.SelectorList = SelectorList;
+exports.String = String$1;
+exports.StyleSheet = StyleSheet;
+exports.TypeSelector = TypeSelector;
+exports.UnicodeRange = UnicodeRange;
+exports.Url = Url;
+exports.Value = Value;
+exports.WhiteSpace = WhiteSpace;