feat: docker compose maybe

node_modules/css-tree/cjs/definition-syntax/SyntaxError.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+const createCustomError = require('../utils/create-custom-error.cjs');
+
+function SyntaxError(message, input, offset) {
+    return Object.assign(createCustomError.createCustomError('SyntaxError', message), {
+        input,
+        offset,
+        rawMessage: message,
+        message: message + '\n' +
+            '  ' + input + '\n' +
+            '--' + new Array((offset || input.length) + 1).join('-') + '^'
+    });
+}
+
+exports.SyntaxError = SyntaxError;

node_modules/css-tree/cjs/definition-syntax/generate.cjs

@@ -0,0 +1,135 @@
+'use strict';
+
+function noop(value) {
+    return value;
+}
+
+function generateMultiplier(multiplier) {
+    const { min, max, comma } = multiplier;
+
+    if (min === 0 && max === 0) {
+        return comma ? '#?' : '*';
+    }
+
+    if (min === 0 && max === 1) {
+        return '?';
+    }
+
+    if (min === 1 && max === 0) {
+        return comma ? '#' : '+';
+    }
+
+    if (min === 1 && max === 1) {
+        return '';
+    }
+
+    return (
+        (comma ? '#' : '') +
+        (min === max
+            ? '{' + min + '}'
+            : '{' + min + ',' + (max !== 0 ? max : '') + '}'
+        )
+    );
+}
+
+function generateTypeOpts(node) {
+    switch (node.type) {
+        case 'Range':
+            return (
+                ' [' +
+                (node.min === null ? '-∞' : node.min) +
+                ',' +
+                (node.max === null ? '∞' : node.max) +
+                ']'
+            );
+
+        default:
+            throw new Error('Unknown node type `' + node.type + '`');
+    }
+}
+
+function generateSequence(node, decorate, forceBraces, compact) {
+    const combinator = node.combinator === ' ' || compact ? node.combinator : ' ' + node.combinator + ' ';
+    const result = node.terms
+        .map(term => internalGenerate(term, decorate, forceBraces, compact))
+        .join(combinator);
+
+    if (node.explicit || forceBraces) {
+        return (compact || result[0] === ',' ? '[' : '[ ') + result + (compact ? ']' : ' ]');
+    }
+
+    return result;
+}
+
+function internalGenerate(node, decorate, forceBraces, compact) {
+    let result;
+
+    switch (node.type) {
+        case 'Group':
+            result =
+                generateSequence(node, decorate, forceBraces, compact) +
+                (node.disallowEmpty ? '!' : '');
+            break;
+
+        case 'Multiplier':
+            // return since node is a composition
+            return (
+                internalGenerate(node.term, decorate, forceBraces, compact) +
+                decorate(generateMultiplier(node), node)
+            );
+
+        case 'Type':
+            result = '<' + node.name + (node.opts ? decorate(generateTypeOpts(node.opts), node.opts) : '') + '>';
+            break;
+
+        case 'Property':
+            result = '<\'' + node.name + '\'>';
+            break;
+
+        case 'Keyword':
+            result = node.name;
+            break;
+
+        case 'AtKeyword':
+            result = '@' + node.name;
+            break;
+
+        case 'Function':
+            result = node.name + '(';
+            break;
+
+        case 'String':
+        case 'Token':
+            result = node.value;
+            break;
+
+        case 'Comma':
+            result = ',';
+            break;
+
+        default:
+            throw new Error('Unknown node type `' + node.type + '`');
+    }
+
+    return decorate(result, node);
+}
+
+function generate(node, options) {
+    let decorate = noop;
+    let forceBraces = false;
+    let compact = false;
+
+    if (typeof options === 'function') {
+        decorate = options;
+    } else if (options) {
+        forceBraces = Boolean(options.forceBraces);
+        compact = Boolean(options.compact);
+        if (typeof options.decorate === 'function') {
+            decorate = options.decorate;
+        }
+    }
+
+    return internalGenerate(node, decorate, forceBraces, compact);
+}
+
+exports.generate = generate;

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

@@ -0,0 +1,13 @@
+'use strict';
+
+const SyntaxError = require('./SyntaxError.cjs');
+const generate = require('./generate.cjs');
+const parse = require('./parse.cjs');
+const walk = require('./walk.cjs');
+
+
+
+exports.SyntaxError = SyntaxError.SyntaxError;
+exports.generate = generate.generate;
+exports.parse = parse.parse;
+exports.walk = walk.walk;

node_modules/css-tree/cjs/definition-syntax/parse.cjs

@@ -0,0 +1,588 @@
+'use strict';
+
+const tokenizer = require('./tokenizer.cjs');
+
+const TAB = 9;
+const N = 10;
+const F = 12;
+const R = 13;
+const SPACE = 32;
+const EXCLAMATIONMARK = 33;    // !
+const NUMBERSIGN = 35;         // #
+const AMPERSAND = 38;          // &
+const APOSTROPHE = 39;         // '
+const LEFTPARENTHESIS = 40;    // (
+const RIGHTPARENTHESIS = 41;   // )
+const ASTERISK = 42;           // *
+const PLUSSIGN = 43;           // +
+const COMMA = 44;              // ,
+const HYPERMINUS = 45;         // -
+const LESSTHANSIGN = 60;       // <
+const GREATERTHANSIGN = 62;    // >
+const QUESTIONMARK = 63;       // ?
+const COMMERCIALAT = 64;       // @
+const LEFTSQUAREBRACKET = 91;  // [
+const RIGHTSQUAREBRACKET = 93; // ]
+const LEFTCURLYBRACKET = 123;  // {
+const VERTICALLINE = 124;      // |
+const RIGHTCURLYBRACKET = 125; // }
+const INFINITY = 8734;         // ∞
+const NAME_CHAR = new Uint8Array(128).map((_, idx) =>
+    /[a-zA-Z0-9\-]/.test(String.fromCharCode(idx)) ? 1 : 0
+);
+const COMBINATOR_PRECEDENCE = {
+    ' ': 1,
+    '&&': 2,
+    '||': 3,
+    '|': 4
+};
+
+function scanSpaces(tokenizer) {
+    return tokenizer.substringToPos(
+        tokenizer.findWsEnd(tokenizer.pos)
+    );
+}
+
+function scanWord(tokenizer) {
+    let end = tokenizer.pos;
+
+    for (; end < tokenizer.str.length; end++) {
+        const code = tokenizer.str.charCodeAt(end);
+        if (code >= 128 || NAME_CHAR[code] === 0) {
+            break;
+        }
+    }
+
+    if (tokenizer.pos === end) {
+        tokenizer.error('Expect a keyword');
+    }
+
+    return tokenizer.substringToPos(end);
+}
+
+function scanNumber(tokenizer) {
+    let end = tokenizer.pos;
+
+    for (; end < tokenizer.str.length; end++) {
+        const code = tokenizer.str.charCodeAt(end);
+        if (code < 48 || code > 57) {
+            break;
+        }
+    }
+
+    if (tokenizer.pos === end) {
+        tokenizer.error('Expect a number');
+    }
+
+    return tokenizer.substringToPos(end);
+}
+
+function scanString(tokenizer) {
+    const end = tokenizer.str.indexOf('\'', tokenizer.pos + 1);
+
+    if (end === -1) {
+        tokenizer.pos = tokenizer.str.length;
+        tokenizer.error('Expect an apostrophe');
+    }
+
+    return tokenizer.substringToPos(end + 1);
+}
+
+function readMultiplierRange(tokenizer) {
+    let min = null;
+    let max = null;
+
+    tokenizer.eat(LEFTCURLYBRACKET);
+
+    min = scanNumber(tokenizer);
+
+    if (tokenizer.charCode() === COMMA) {
+        tokenizer.pos++;
+        if (tokenizer.charCode() !== RIGHTCURLYBRACKET) {
+            max = scanNumber(tokenizer);
+        }
+    } else {
+        max = min;
+    }
+
+    tokenizer.eat(RIGHTCURLYBRACKET);
+
+    return {
+        min: Number(min),
+        max: max ? Number(max) : 0
+    };
+}
+
+function readMultiplier(tokenizer) {
+    let range = null;
+    let comma = false;
+
+    switch (tokenizer.charCode()) {
+        case ASTERISK:
+            tokenizer.pos++;
+
+            range = {
+                min: 0,
+                max: 0
+            };
+
+            break;
+
+        case PLUSSIGN:
+            tokenizer.pos++;
+
+            range = {
+                min: 1,
+                max: 0
+            };
+
+            break;
+
+        case QUESTIONMARK:
+            tokenizer.pos++;
+
+            range = {
+                min: 0,
+                max: 1
+            };
+
+            break;
+
+        case NUMBERSIGN:
+            tokenizer.pos++;
+
+            comma = true;
+
+            if (tokenizer.charCode() === LEFTCURLYBRACKET) {
+                range = readMultiplierRange(tokenizer);
+            } else if (tokenizer.charCode() === QUESTIONMARK) {
+                // https://www.w3.org/TR/css-values-4/#component-multipliers
+                // > the # and ? multipliers may be stacked as #?
+                // In this case just treat "#?" as a single multiplier
+                // { min: 0, max: 0, comma: true }
+                tokenizer.pos++;
+                range = {
+                    min: 0,
+                    max: 0
+                };
+            } else {
+                range = {
+                    min: 1,
+                    max: 0
+                };
+            }
+
+            break;
+
+        case LEFTCURLYBRACKET:
+            range = readMultiplierRange(tokenizer);
+            break;
+
+        default:
+            return null;
+    }
+
+    return {
+        type: 'Multiplier',
+        comma,
+        min: range.min,
+        max: range.max,
+        term: null
+    };
+}
+
+function maybeMultiplied(tokenizer, node) {
+    const multiplier = readMultiplier(tokenizer);
+
+    if (multiplier !== null) {
+        multiplier.term = node;
+
+        // https://www.w3.org/TR/css-values-4/#component-multipliers
+        // > The + and # multipliers may be stacked as +#;
+        // Represent "+#" as nested multipliers:
+        // { ...<multiplier #>,
+        //   term: {
+        //     ...<multipler +>,
+        //     term: node
+        //   }
+        // }
+        if (tokenizer.charCode() === NUMBERSIGN &&
+            tokenizer.charCodeAt(tokenizer.pos - 1) === PLUSSIGN) {
+            return maybeMultiplied(tokenizer, multiplier);
+        }
+
+        return multiplier;
+    }
+
+    return node;
+}
+
+function maybeToken(tokenizer) {
+    const ch = tokenizer.peek();
+
+    if (ch === '') {
+        return null;
+    }
+
+    return {
+        type: 'Token',
+        value: ch
+    };
+}
+
+function readProperty(tokenizer) {
+    let name;
+
+    tokenizer.eat(LESSTHANSIGN);
+    tokenizer.eat(APOSTROPHE);
+
+    name = scanWord(tokenizer);
+
+    tokenizer.eat(APOSTROPHE);
+    tokenizer.eat(GREATERTHANSIGN);
+
+    return maybeMultiplied(tokenizer, {
+        type: 'Property',
+        name
+    });
+}
+
+// https://drafts.csswg.org/css-values-3/#numeric-ranges
+// 4.1. Range Restrictions and Range Definition Notation
+//
+// Range restrictions can be annotated in the numeric type notation using CSS bracketed
+// range notation—[min,max]—within the angle brackets, after the identifying keyword,
+// indicating a closed range between (and including) min and max.
+// For example, <integer [0, 10]> indicates an integer between 0 and 10, inclusive.
+function readTypeRange(tokenizer) {
+    // use null for Infinity to make AST format JSON serializable/deserializable
+    let min = null; // -Infinity
+    let max = null; // Infinity
+    let sign = 1;
+
+    tokenizer.eat(LEFTSQUAREBRACKET);
+
+    if (tokenizer.charCode() === HYPERMINUS) {
+        tokenizer.peek();
+        sign = -1;
+    }
+
+    if (sign == -1 && tokenizer.charCode() === INFINITY) {
+        tokenizer.peek();
+    } else {
+        min = sign * Number(scanNumber(tokenizer));
+
+        if (NAME_CHAR[tokenizer.charCode()] !== 0) {
+            min += scanWord(tokenizer);
+        }
+    }
+
+    scanSpaces(tokenizer);
+    tokenizer.eat(COMMA);
+    scanSpaces(tokenizer);
+
+    if (tokenizer.charCode() === INFINITY) {
+        tokenizer.peek();
+    } else {
+        sign = 1;
+
+        if (tokenizer.charCode() === HYPERMINUS) {
+            tokenizer.peek();
+            sign = -1;
+        }
+
+        max = sign * Number(scanNumber(tokenizer));
+
+        if (NAME_CHAR[tokenizer.charCode()] !== 0) {
+            max += scanWord(tokenizer);
+        }
+    }
+
+    tokenizer.eat(RIGHTSQUAREBRACKET);
+
+    return {
+        type: 'Range',
+        min,
+        max
+    };
+}
+
+function readType(tokenizer) {
+    let name;
+    let opts = null;
+
+    tokenizer.eat(LESSTHANSIGN);
+    name = scanWord(tokenizer);
+
+    if (tokenizer.charCode() === LEFTPARENTHESIS &&
+        tokenizer.nextCharCode() === RIGHTPARENTHESIS) {
+        tokenizer.pos += 2;
+        name += '()';
+    }
+
+    if (tokenizer.charCodeAt(tokenizer.findWsEnd(tokenizer.pos)) === LEFTSQUAREBRACKET) {
+        scanSpaces(tokenizer);
+        opts = readTypeRange(tokenizer);
+    }
+
+    tokenizer.eat(GREATERTHANSIGN);
+
+    return maybeMultiplied(tokenizer, {
+        type: 'Type',
+        name,
+        opts
+    });
+}
+
+function readKeywordOrFunction(tokenizer) {
+    const name = scanWord(tokenizer);
+
+    if (tokenizer.charCode() === LEFTPARENTHESIS) {
+        tokenizer.pos++;
+
+        return {
+            type: 'Function',
+            name
+        };
+    }
+
+    return maybeMultiplied(tokenizer, {
+        type: 'Keyword',
+        name
+    });
+}
+
+function regroupTerms(terms, combinators) {
+    function createGroup(terms, combinator) {
+        return {
+            type: 'Group',
+            terms,
+            combinator,
+            disallowEmpty: false,
+            explicit: false
+        };
+    }
+
+    let combinator;
+
+    combinators = Object.keys(combinators)
+        .sort((a, b) => COMBINATOR_PRECEDENCE[a] - COMBINATOR_PRECEDENCE[b]);
+
+    while (combinators.length > 0) {
+        combinator = combinators.shift();
+
+        let i = 0;
+        let subgroupStart = 0;
+
+        for (; i < terms.length; i++) {
+            const term = terms[i];
+
+            if (term.type === 'Combinator') {
+                if (term.value === combinator) {
+                    if (subgroupStart === -1) {
+                        subgroupStart = i - 1;
+                    }
+                    terms.splice(i, 1);
+                    i--;
+                } else {
+                    if (subgroupStart !== -1 && i - subgroupStart > 1) {
+                        terms.splice(
+                            subgroupStart,
+                            i - subgroupStart,
+                            createGroup(terms.slice(subgroupStart, i), combinator)
+                        );
+                        i = subgroupStart + 1;
+                    }
+                    subgroupStart = -1;
+                }
+            }
+        }
+
+        if (subgroupStart !== -1 && combinators.length) {
+            terms.splice(
+                subgroupStart,
+                i - subgroupStart,
+                createGroup(terms.slice(subgroupStart, i), combinator)
+            );
+        }
+    }
+
+    return combinator;
+}
+
+function readImplicitGroup(tokenizer) {
+    const terms = [];
+    const combinators = {};
+    let token;
+    let prevToken = null;
+    let prevTokenPos = tokenizer.pos;
+
+    while (token = peek(tokenizer)) {
+        if (token.type !== 'Spaces') {
+            if (token.type === 'Combinator') {
+                // check for combinator in group beginning and double combinator sequence
+                if (prevToken === null || prevToken.type === 'Combinator') {
+                    tokenizer.pos = prevTokenPos;
+                    tokenizer.error('Unexpected combinator');
+                }
+
+                combinators[token.value] = true;
+            } else if (prevToken !== null && prevToken.type !== 'Combinator') {
+                combinators[' '] = true;  // a b
+                terms.push({
+                    type: 'Combinator',
+                    value: ' '
+                });
+            }
+
+            terms.push(token);
+            prevToken = token;
+            prevTokenPos = tokenizer.pos;
+        }
+    }
+
+    // check for combinator in group ending
+    if (prevToken !== null && prevToken.type === 'Combinator') {
+        tokenizer.pos -= prevTokenPos;
+        tokenizer.error('Unexpected combinator');
+    }
+
+    return {
+        type: 'Group',
+        terms,
+        combinator: regroupTerms(terms, combinators) || ' ',
+        disallowEmpty: false,
+        explicit: false
+    };
+}
+
+function readGroup(tokenizer) {
+    let result;
+
+    tokenizer.eat(LEFTSQUAREBRACKET);
+    result = readImplicitGroup(tokenizer);
+    tokenizer.eat(RIGHTSQUAREBRACKET);
+
+    result.explicit = true;
+
+    if (tokenizer.charCode() === EXCLAMATIONMARK) {
+        tokenizer.pos++;
+        result.disallowEmpty = true;
+    }
+
+    return result;
+}
+
+function peek(tokenizer) {
+    let code = tokenizer.charCode();
+
+    if (code < 128 && NAME_CHAR[code] === 1) {
+        return readKeywordOrFunction(tokenizer);
+    }
+
+    switch (code) {
+        case RIGHTSQUAREBRACKET:
+            // don't eat, stop scan a group
+            break;
+
+        case LEFTSQUAREBRACKET:
+            return maybeMultiplied(tokenizer, readGroup(tokenizer));
+
+        case LESSTHANSIGN:
+            return tokenizer.nextCharCode() === APOSTROPHE
+                ? readProperty(tokenizer)
+                : readType(tokenizer);
+
+        case VERTICALLINE:
+            return {
+                type: 'Combinator',
+                value: tokenizer.substringToPos(
+                    tokenizer.pos + (tokenizer.nextCharCode() === VERTICALLINE ? 2 : 1)
+                )
+            };
+
+        case AMPERSAND:
+            tokenizer.pos++;
+            tokenizer.eat(AMPERSAND);
+
+            return {
+                type: 'Combinator',
+                value: '&&'
+            };
+
+        case COMMA:
+            tokenizer.pos++;
+            return {
+                type: 'Comma'
+            };
+
+        case APOSTROPHE:
+            return maybeMultiplied(tokenizer, {
+                type: 'String',
+                value: scanString(tokenizer)
+            });
+
+        case SPACE:
+        case TAB:
+        case N:
+        case R:
+        case F:
+            return {
+                type: 'Spaces',
+                value: scanSpaces(tokenizer)
+            };
+
+        case COMMERCIALAT:
+            code = tokenizer.nextCharCode();
+
+            if (code < 128 && NAME_CHAR[code] === 1) {
+                tokenizer.pos++;
+                return {
+                    type: 'AtKeyword',
+                    name: scanWord(tokenizer)
+                };
+            }
+
+            return maybeToken(tokenizer);
+
+        case ASTERISK:
+        case PLUSSIGN:
+        case QUESTIONMARK:
+        case NUMBERSIGN:
+        case EXCLAMATIONMARK:
+            // prohibited tokens (used as a multiplier start)
+            break;
+
+        case LEFTCURLYBRACKET:
+            // LEFTCURLYBRACKET is allowed since mdn/data uses it w/o quoting
+            // check next char isn't a number, because it's likely a disjoined multiplier
+            code = tokenizer.nextCharCode();
+
+            if (code < 48 || code > 57) {
+                return maybeToken(tokenizer);
+            }
+
+            break;
+
+        default:
+            return maybeToken(tokenizer);
+    }
+}
+
+function parse(source) {
+    const tokenizer$1 = new tokenizer.Tokenizer(source);
+    const result = readImplicitGroup(tokenizer$1);
+
+    if (tokenizer$1.pos !== source.length) {
+        tokenizer$1.error('Unexpected input');
+    }
+
+    // reduce redundant groups with single group term
+    if (result.terms.length === 1 && result.terms[0].type === 'Group') {
+        return result.terms[0];
+    }
+
+    return result;
+}
+
+exports.parse = parse;

node_modules/css-tree/cjs/definition-syntax/tokenizer.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+const SyntaxError = require('./SyntaxError.cjs');
+
+const TAB = 9;
+const N = 10;
+const F = 12;
+const R = 13;
+const SPACE = 32;
+
+class Tokenizer {
+    constructor(str) {
+        this.str = str;
+        this.pos = 0;
+    }
+    charCodeAt(pos) {
+        return pos < this.str.length ? this.str.charCodeAt(pos) : 0;
+    }
+    charCode() {
+        return this.charCodeAt(this.pos);
+    }
+    nextCharCode() {
+        return this.charCodeAt(this.pos + 1);
+    }
+    nextNonWsCode(pos) {
+        return this.charCodeAt(this.findWsEnd(pos));
+    }
+    findWsEnd(pos) {
+        for (; pos < this.str.length; pos++) {
+            const code = this.str.charCodeAt(pos);
+            if (code !== R && code !== N && code !== F && code !== SPACE && code !== TAB) {
+                break;
+            }
+        }
+
+        return pos;
+    }
+    substringToPos(end) {
+        return this.str.substring(this.pos, this.pos = end);
+    }
+    eat(code) {
+        if (this.charCode() !== code) {
+            this.error('Expect `' + String.fromCharCode(code) + '`');
+        }
+
+        this.pos++;
+    }
+    peek() {
+        return this.pos < this.str.length ? this.str.charAt(this.pos++) : '';
+    }
+    error(message) {
+        throw new SyntaxError.SyntaxError(message, this.str, this.pos);
+    }
+}
+
+exports.Tokenizer = Tokenizer;

node_modules/css-tree/cjs/definition-syntax/walk.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+const noop = function() {};
+
+function ensureFunction(value) {
+    return typeof value === 'function' ? value : noop;
+}
+
+function walk(node, options, context) {
+    function walk(node) {
+        enter.call(context, node);
+
+        switch (node.type) {
+            case 'Group':
+                node.terms.forEach(walk);
+                break;
+
+            case 'Multiplier':
+                walk(node.term);
+                break;
+
+            case 'Type':
+            case 'Property':
+            case 'Keyword':
+            case 'AtKeyword':
+            case 'Function':
+            case 'String':
+            case 'Token':
+            case 'Comma':
+                break;
+
+            default:
+                throw new Error('Unknown type: ' + node.type);
+        }
+
+        leave.call(context, node);
+    }
+
+    let enter = noop;
+    let leave = noop;
+
+    if (typeof options === 'function') {
+        enter = options;
+    } else if (options) {
+        enter = ensureFunction(options.enter);
+        leave = ensureFunction(options.leave);
+    }
+
+    if (enter === noop && leave === noop) {
+        throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\'t a function');
+    }
+
+    walk(node);
+}
+
+exports.walk = walk;