less 3.10.1 → 3.11.1

package/packages/css-parser/node_modules/chevrotain/lib/src/parse/grammar/follow.js

@@ -0,0 +1,67 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var rest_1 = require("./rest");
+var first_1 = require("./first");
+var utils_1 = require("../../utils/utils");
+var constants_1 = require("../constants");
+var gast_public_1 = require("./gast/gast_public");
+// This ResyncFollowsWalker computes all of the follows required for RESYNC
+// (skipping reference production).
+var ResyncFollowsWalker = /** @class */ (function (_super) {
+    __extends(ResyncFollowsWalker, _super);
+    function ResyncFollowsWalker(topProd) {
+        var _this = _super.call(this) || this;
+        _this.topProd = topProd;
+        _this.follows = {};
+        return _this;
+    }
+    ResyncFollowsWalker.prototype.startWalking = function () {
+        this.walk(this.topProd);
+        return this.follows;
+    };
+    ResyncFollowsWalker.prototype.walkTerminal = function (terminal, currRest, prevRest) {
+        // do nothing! just like in the public sector after 13:00
+    };
+    ResyncFollowsWalker.prototype.walkProdRef = function (refProd, currRest, prevRest) {
+        var followName = buildBetweenProdsFollowPrefix(refProd.referencedRule, refProd.idx) +
+            this.topProd.name;
+        var fullRest = currRest.concat(prevRest);
+        var restProd = new gast_public_1.Flat({ definition: fullRest });
+        var t_in_topProd_follows = first_1.first(restProd);
+        this.follows[followName] = t_in_topProd_follows;
+    };
+    return ResyncFollowsWalker;
+}(rest_1.RestWalker));
+exports.ResyncFollowsWalker = ResyncFollowsWalker;
+function computeAllProdsFollows(topProductions) {
+    var reSyncFollows = {};
+    utils_1.forEach(topProductions, function (topProd) {
+        var currRefsFollow = new ResyncFollowsWalker(topProd).startWalking();
+        utils_1.assign(reSyncFollows, currRefsFollow);
+    });
+    return reSyncFollows;
+}
+exports.computeAllProdsFollows = computeAllProdsFollows;
+function buildBetweenProdsFollowPrefix(inner, occurenceInParent) {
+    return inner.name + occurenceInParent + constants_1.IN;
+}
+exports.buildBetweenProdsFollowPrefix = buildBetweenProdsFollowPrefix;
+function buildInProdFollowPrefix(terminal) {
+    var terminalName = terminal.terminalType.name;
+    return terminalName + terminal.idx + constants_1.IN;
+}
+exports.buildInProdFollowPrefix = buildInProdFollowPrefix;
+//# sourceMappingURL=follow.js.map

package/packages/css-parser/node_modules/chevrotain/lib/src/parse/grammar/gast/gast.js

@@ -0,0 +1,170 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../../utils/utils");
+var gast_public_1 = require("./gast_public");
+var gast_visitor_public_1 = require("./gast_visitor_public");
+function isSequenceProd(prod) {
+    return (prod instanceof gast_public_1.Flat ||
+        prod instanceof gast_public_1.Option ||
+        prod instanceof gast_public_1.Repetition ||
+        prod instanceof gast_public_1.RepetitionMandatory ||
+        prod instanceof gast_public_1.RepetitionMandatoryWithSeparator ||
+        prod instanceof gast_public_1.RepetitionWithSeparator ||
+        prod instanceof gast_public_1.Terminal ||
+        prod instanceof gast_public_1.Rule);
+}
+exports.isSequenceProd = isSequenceProd;
+function isOptionalProd(prod, alreadyVisited) {
+    if (alreadyVisited === void 0) { alreadyVisited = []; }
+    var isDirectlyOptional = prod instanceof gast_public_1.Option ||
+        prod instanceof gast_public_1.Repetition ||
+        prod instanceof gast_public_1.RepetitionWithSeparator;
+    if (isDirectlyOptional) {
+        return true;
+    }
+    // note that this can cause infinite loop if one optional empty TOP production has a cyclic dependency with another
+    // empty optional top rule
+    // may be indirectly optional ((A?B?C?) | (D?E?F?))
+    if (prod instanceof gast_public_1.Alternation) {
+        // for OR its enough for just one of the alternatives to be optional
+        return utils_1.some(prod.definition, function (subProd) {
+            return isOptionalProd(subProd, alreadyVisited);
+        });
+    }
+    else if (prod instanceof gast_public_1.NonTerminal && utils_1.contains(alreadyVisited, prod)) {
+        // avoiding stack overflow due to infinite recursion
+        return false;
+    }
+    else if (prod instanceof gast_public_1.AbstractProduction) {
+        if (prod instanceof gast_public_1.NonTerminal) {
+            alreadyVisited.push(prod);
+        }
+        return utils_1.every(prod.definition, function (subProd) {
+            return isOptionalProd(subProd, alreadyVisited);
+        });
+    }
+    else {
+        return false;
+    }
+}
+exports.isOptionalProd = isOptionalProd;
+function isBranchingProd(prod) {
+    return prod instanceof gast_public_1.Alternation;
+}
+exports.isBranchingProd = isBranchingProd;
+function getProductionDslName(prod) {
+    /* istanbul ignore else */
+    if (prod instanceof gast_public_1.NonTerminal) {
+        return "SUBRULE";
+    }
+    else if (prod instanceof gast_public_1.Option) {
+        return "OPTION";
+    }
+    else if (prod instanceof gast_public_1.Alternation) {
+        return "OR";
+    }
+    else if (prod instanceof gast_public_1.RepetitionMandatory) {
+        return "AT_LEAST_ONE";
+    }
+    else if (prod instanceof gast_public_1.RepetitionMandatoryWithSeparator) {
+        return "AT_LEAST_ONE_SEP";
+    }
+    else if (prod instanceof gast_public_1.RepetitionWithSeparator) {
+        return "MANY_SEP";
+    }
+    else if (prod instanceof gast_public_1.Repetition) {
+        return "MANY";
+    }
+    else if (prod instanceof gast_public_1.Terminal) {
+        return "CONSUME";
+    }
+    else {
+        throw Error("non exhaustive match");
+    }
+}
+exports.getProductionDslName = getProductionDslName;
+var DslMethodsCollectorVisitor = /** @class */ (function (_super) {
+    __extends(DslMethodsCollectorVisitor, _super);
+    function DslMethodsCollectorVisitor() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        // A minus is never valid in an identifier name
+        _this.separator = "-";
+        _this.dslMethods = {
+            option: [],
+            alternation: [],
+            repetition: [],
+            repetitionWithSeparator: [],
+            repetitionMandatory: [],
+            repetitionMandatoryWithSeparator: []
+        };
+        return _this;
+    }
+    DslMethodsCollectorVisitor.prototype.reset = function () {
+        this.dslMethods = {
+            option: [],
+            alternation: [],
+            repetition: [],
+            repetitionWithSeparator: [],
+            repetitionMandatory: [],
+            repetitionMandatoryWithSeparator: []
+        };
+    };
+    DslMethodsCollectorVisitor.prototype.visitTerminal = function (terminal) {
+        var key = terminal.terminalType.name + this.separator + "Terminal";
+        if (!utils_1.has(this.dslMethods, key)) {
+            this.dslMethods[key] = [];
+        }
+        this.dslMethods[key].push(terminal);
+    };
+    DslMethodsCollectorVisitor.prototype.visitNonTerminal = function (subrule) {
+        var key = subrule.nonTerminalName + this.separator + "Terminal";
+        if (!utils_1.has(this.dslMethods, key)) {
+            this.dslMethods[key] = [];
+        }
+        this.dslMethods[key].push(subrule);
+    };
+    DslMethodsCollectorVisitor.prototype.visitOption = function (option) {
+        this.dslMethods.option.push(option);
+    };
+    DslMethodsCollectorVisitor.prototype.visitRepetitionWithSeparator = function (manySep) {
+        this.dslMethods.repetitionWithSeparator.push(manySep);
+    };
+    DslMethodsCollectorVisitor.prototype.visitRepetitionMandatory = function (atLeastOne) {
+        this.dslMethods.repetitionMandatory.push(atLeastOne);
+    };
+    DslMethodsCollectorVisitor.prototype.visitRepetitionMandatoryWithSeparator = function (atLeastOneSep) {
+        this.dslMethods.repetitionMandatoryWithSeparator.push(atLeastOneSep);
+    };
+    DslMethodsCollectorVisitor.prototype.visitRepetition = function (many) {
+        this.dslMethods.repetition.push(many);
+    };
+    DslMethodsCollectorVisitor.prototype.visitAlternation = function (or) {
+        this.dslMethods.alternation.push(or);
+    };
+    return DslMethodsCollectorVisitor;
+}(gast_visitor_public_1.GAstVisitor));
+exports.DslMethodsCollectorVisitor = DslMethodsCollectorVisitor;
+var collectorVisitor = new DslMethodsCollectorVisitor();
+function collectMethods(rule) {
+    collectorVisitor.reset();
+    rule.accept(collectorVisitor);
+    var dslMethods = collectorVisitor.dslMethods;
+    // avoid uncleaned references
+    collectorVisitor.reset();
+    return dslMethods;
+}
+exports.collectMethods = collectMethods;
+//# sourceMappingURL=gast.js.map

package/packages/css-parser/node_modules/chevrotain/lib/src/parse/grammar/gast/gast_public.js

@@ -0,0 +1,262 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../../utils/utils");
+var tokens_public_1 = require("../../../scan/tokens_public");
+var AbstractProduction = /** @class */ (function () {
+    function AbstractProduction(definition) {
+        this.definition = definition;
+    }
+    AbstractProduction.prototype.accept = function (visitor) {
+        visitor.visit(this);
+        utils_1.forEach(this.definition, function (prod) {
+            prod.accept(visitor);
+        });
+    };
+    return AbstractProduction;
+}());
+exports.AbstractProduction = AbstractProduction;
+var NonTerminal = /** @class */ (function (_super) {
+    __extends(NonTerminal, _super);
+    function NonTerminal(options) {
+        var _this = _super.call(this, []) || this;
+        _this.idx = 1;
+        utils_1.assign(_this, utils_1.pick(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    Object.defineProperty(NonTerminal.prototype, "definition", {
+        get: function () {
+            if (this.referencedRule !== undefined) {
+                return this.referencedRule.definition;
+            }
+            return [];
+        },
+        set: function (definition) {
+            // immutable
+        },
+        enumerable: true,
+        configurable: true
+    });
+    NonTerminal.prototype.accept = function (visitor) {
+        visitor.visit(this);
+        // don't visit children of a reference, we will get cyclic infinite loops if we do so
+    };
+    return NonTerminal;
+}(AbstractProduction));
+exports.NonTerminal = NonTerminal;
+var Rule = /** @class */ (function (_super) {
+    __extends(Rule, _super);
+    function Rule(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.orgText = "";
+        utils_1.assign(_this, utils_1.pick(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return Rule;
+}(AbstractProduction));
+exports.Rule = Rule;
+// TODO: is this only used in an Alternation?
+//       Perhaps `Flat` should be renamed to `Alternative`?
+var Flat = /** @class */ (function (_super) {
+    __extends(Flat, _super);
+    // A named Flat production is used to indicate a Nested Rule in an alternation
+    function Flat(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.ignoreAmbiguities = false;
+        utils_1.assign(_this, utils_1.pick(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return Flat;
+}(AbstractProduction));
+exports.Flat = Flat;
+var Option = /** @class */ (function (_super) {
+    __extends(Option, _super);
+    function Option(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.idx = 1;
+        utils_1.assign(_this, utils_1.pick(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return Option;
+}(AbstractProduction));
+exports.Option = Option;
+var RepetitionMandatory = /** @class */ (function (_super) {
+    __extends(RepetitionMandatory, _super);
+    function RepetitionMandatory(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.idx = 1;
+        utils_1.assign(_this, utils_1.pick(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return RepetitionMandatory;
+}(AbstractProduction));
+exports.RepetitionMandatory = RepetitionMandatory;
+var RepetitionMandatoryWithSeparator = /** @class */ (function (_super) {
+    __extends(RepetitionMandatoryWithSeparator, _super);
+    function RepetitionMandatoryWithSeparator(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.idx = 1;
+        utils_1.assign(_this, utils_1.pick(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return RepetitionMandatoryWithSeparator;
+}(AbstractProduction));
+exports.RepetitionMandatoryWithSeparator = RepetitionMandatoryWithSeparator;
+var Repetition = /** @class */ (function (_super) {
+    __extends(Repetition, _super);
+    function Repetition(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.idx = 1;
+        utils_1.assign(_this, utils_1.pick(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return Repetition;
+}(AbstractProduction));
+exports.Repetition = Repetition;
+var RepetitionWithSeparator = /** @class */ (function (_super) {
+    __extends(RepetitionWithSeparator, _super);
+    function RepetitionWithSeparator(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.idx = 1;
+        utils_1.assign(_this, utils_1.pick(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return RepetitionWithSeparator;
+}(AbstractProduction));
+exports.RepetitionWithSeparator = RepetitionWithSeparator;
+var Alternation = /** @class */ (function (_super) {
+    __extends(Alternation, _super);
+    function Alternation(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.idx = 1;
+        _this.ignoreAmbiguities = false;
+        _this.hasPredicates = false;
+        utils_1.assign(_this, utils_1.pick(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return Alternation;
+}(AbstractProduction));
+exports.Alternation = Alternation;
+var Terminal = /** @class */ (function () {
+    function Terminal(options) {
+        this.idx = 1;
+        utils_1.assign(this, utils_1.pick(options, function (v) { return v !== undefined; }));
+    }
+    Terminal.prototype.accept = function (visitor) {
+        visitor.visit(this);
+    };
+    return Terminal;
+}());
+exports.Terminal = Terminal;
+function serializeGrammar(topRules) {
+    return utils_1.map(topRules, serializeProduction);
+}
+exports.serializeGrammar = serializeGrammar;
+function serializeProduction(node) {
+    function convertDefinition(definition) {
+        return utils_1.map(definition, serializeProduction);
+    }
+    /* istanbul ignore else */
+    if (node instanceof NonTerminal) {
+        return {
+            type: "NonTerminal",
+            name: node.nonTerminalName,
+            idx: node.idx
+        };
+    }
+    else if (node instanceof Flat) {
+        return {
+            type: "Flat",
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else if (node instanceof Option) {
+        return {
+            type: "Option",
+            idx: node.idx,
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else if (node instanceof RepetitionMandatory) {
+        return {
+            type: "RepetitionMandatory",
+            name: node.name,
+            idx: node.idx,
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else if (node instanceof RepetitionMandatoryWithSeparator) {
+        return {
+            type: "RepetitionMandatoryWithSeparator",
+            name: node.name,
+            idx: node.idx,
+            separator: (serializeProduction(new Terminal({ terminalType: node.separator }))),
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else if (node instanceof RepetitionWithSeparator) {
+        return {
+            type: "RepetitionWithSeparator",
+            name: node.name,
+            idx: node.idx,
+            separator: (serializeProduction(new Terminal({ terminalType: node.separator }))),
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else if (node instanceof Repetition) {
+        return {
+            type: "Repetition",
+            name: node.name,
+            idx: node.idx,
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else if (node instanceof Alternation) {
+        return {
+            type: "Alternation",
+            name: node.name,
+            idx: node.idx,
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else if (node instanceof Terminal) {
+        var serializedTerminal = {
+            type: "Terminal",
+            name: node.terminalType.name,
+            label: tokens_public_1.tokenLabel(node.terminalType),
+            idx: node.idx
+        };
+        var pattern = node.terminalType.PATTERN;
+        if (node.terminalType.PATTERN) {
+            serializedTerminal.pattern = utils_1.isRegExp(pattern)
+                ? pattern.source
+                : pattern;
+        }
+        return serializedTerminal;
+    }
+    else if (node instanceof Rule) {
+        return {
+            type: "Rule",
+            name: node.name,
+            orgText: node.orgText,
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else {
+        throw Error("non exhaustive match");
+    }
+}
+exports.serializeProduction = serializeProduction;
+//# sourceMappingURL=gast_public.js.map

package/packages/css-parser/node_modules/chevrotain/lib/src/parse/grammar/gast/gast_resolver_public.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../../utils/utils");
+var resolver_1 = require("../resolver");
+var checks_1 = require("../checks");
+var errors_public_1 = require("../../errors_public");
+var gast_1 = require("./gast");
+function resolveGrammar(options) {
+    options = utils_1.defaults(options, {
+        errMsgProvider: errors_public_1.defaultGrammarResolverErrorProvider
+    });
+    var topRulesTable = {};
+    utils_1.forEach(options.rules, function (rule) {
+        topRulesTable[rule.name] = rule;
+    });
+    return resolver_1.resolveGrammar(topRulesTable, options.errMsgProvider);
+}
+exports.resolveGrammar = resolveGrammar;
+function validateGrammar(options) {
+    options = utils_1.defaults(options, {
+        errMsgProvider: errors_public_1.defaultGrammarValidatorErrorProvider,
+        ignoredIssues: {}
+    });
+    return checks_1.validateGrammar(options.rules, options.maxLookahead, options.tokenTypes, options.ignoredIssues, options.errMsgProvider, options.grammarName);
+}
+exports.validateGrammar = validateGrammar;
+function assignOccurrenceIndices(options) {
+    utils_1.forEach(options.rules, function (currRule) {
+        var methodsCollector = new gast_1.DslMethodsCollectorVisitor();
+        currRule.accept(methodsCollector);
+        utils_1.forEach(methodsCollector.dslMethods, function (methods) {
+            utils_1.forEach(methods, function (currMethod, arrIdx) {
+                currMethod.idx = arrIdx + 1;
+            });
+        });
+    });
+}
+exports.assignOccurrenceIndices = assignOccurrenceIndices;
+//# sourceMappingURL=gast_resolver_public.js.map

package/packages/css-parser/node_modules/chevrotain/lib/src/parse/grammar/gast/gast_visitor_public.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var gast_public_1 = require("./gast_public");
+var GAstVisitor = /** @class */ (function () {
+    function GAstVisitor() {
+    }
+    GAstVisitor.prototype.visit = function (node) {
+        var nodeAny = node;
+        switch (nodeAny.constructor) {
+            case gast_public_1.NonTerminal:
+                return this.visitNonTerminal(nodeAny);
+            case gast_public_1.Flat:
+                return this.visitFlat(nodeAny);
+            case gast_public_1.Option:
+                return this.visitOption(nodeAny);
+            case gast_public_1.RepetitionMandatory:
+                return this.visitRepetitionMandatory(nodeAny);
+            case gast_public_1.RepetitionMandatoryWithSeparator:
+                return this.visitRepetitionMandatoryWithSeparator(nodeAny);
+            case gast_public_1.RepetitionWithSeparator:
+                return this.visitRepetitionWithSeparator(nodeAny);
+            case gast_public_1.Repetition:
+                return this.visitRepetition(nodeAny);
+            case gast_public_1.Alternation:
+                return this.visitAlternation(nodeAny);
+            case gast_public_1.Terminal:
+                return this.visitTerminal(nodeAny);
+            case gast_public_1.Rule:
+                return this.visitRule(nodeAny);
+            /* istanbul ignore next */
+            default:
+                throw Error("non exhaustive match");
+        }
+    };
+    GAstVisitor.prototype.visitNonTerminal = function (node) { };
+    GAstVisitor.prototype.visitFlat = function (node) { };
+    GAstVisitor.prototype.visitOption = function (node) { };
+    GAstVisitor.prototype.visitRepetition = function (node) { };
+    GAstVisitor.prototype.visitRepetitionMandatory = function (node) { };
+    GAstVisitor.prototype.visitRepetitionMandatoryWithSeparator = function (node) { };
+    GAstVisitor.prototype.visitRepetitionWithSeparator = function (node) { };
+    GAstVisitor.prototype.visitAlternation = function (node) { };
+    GAstVisitor.prototype.visitTerminal = function (node) { };
+    GAstVisitor.prototype.visitRule = function (node) { };
+    return GAstVisitor;
+}());
+exports.GAstVisitor = GAstVisitor;
+//# sourceMappingURL=gast_visitor_public.js.map