less 3.10.1 → 3.11.1

package/packages/css-parser/node_modules/chevrotain/lib_esm/src/parse/grammar/checks.js

@@ -0,0 +1,574 @@
+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 __());
+    };
+})();
+import * as utils from "../../utils/utils";
+import { contains, every, findAll, flatten, forEach, groupBy, isEmpty, map, pick, reduce, reject, values } from "../../utils/utils";
+import { ParserDefinitionErrorType } from "../parser/parser";
+import { getProductionDslName, isOptionalProd } from "./gast/gast";
+import { containsPath, getLookaheadPathsForOptionalProd, getLookaheadPathsForOr, getProdType, isStrictPrefixOfPath } from "./lookahead";
+import { NamedDSLMethodsCollectorVisitor } from "../cst/cst";
+import { nextPossibleTokensAfter } from "./interpreter";
+import { Alternation, Flat, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Terminal } from "./gast/gast_public";
+import { GAstVisitor } from "./gast/gast_visitor_public";
+export function validateGrammar(topLevels, globalMaxLookahead, tokenTypes, ignoredIssues, errMsgProvider, grammarName) {
+    var duplicateErrors = utils.map(topLevels, function (currTopLevel) {
+        return validateDuplicateProductions(currTopLevel, errMsgProvider);
+    });
+    var leftRecursionErrors = utils.map(topLevels, function (currTopRule) {
+        return validateNoLeftRecursion(currTopRule, currTopRule, errMsgProvider);
+    });
+    var emptyAltErrors = [];
+    var ambiguousAltsErrors = [];
+    var emptyRepetitionErrors = [];
+    // left recursion could cause infinite loops in the following validations.
+    // It is safest to first have the user fix the left recursion errors first and only then examine Further issues.
+    if (every(leftRecursionErrors, isEmpty)) {
+        emptyAltErrors = map(topLevels, function (currTopRule) {
+            return validateEmptyOrAlternative(currTopRule, errMsgProvider);
+        });
+        ambiguousAltsErrors = map(topLevels, function (currTopRule) {
+            return validateAmbiguousAlternationAlternatives(currTopRule, globalMaxLookahead, ignoredIssues, errMsgProvider);
+        });
+        emptyRepetitionErrors = validateSomeNonEmptyLookaheadPath(topLevels, globalMaxLookahead, errMsgProvider);
+    }
+    var termsNamespaceConflictErrors = checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider);
+    var tokenNameErrors = utils.map(tokenTypes, function (currTokType) {
+        return validateTokenName(currTokType, errMsgProvider);
+    });
+    var nestedRulesNameErrors = validateNestedRulesNames(topLevels, errMsgProvider);
+    var nestedRulesDuplicateErrors = validateDuplicateNestedRules(topLevels, errMsgProvider);
+    var tooManyAltsErrors = map(topLevels, function (curRule) {
+        return validateTooManyAlts(curRule, errMsgProvider);
+    });
+    var ruleNameErrors = map(topLevels, function (curRule) {
+        return validateRuleName(curRule, errMsgProvider);
+    });
+    var duplicateRulesError = map(topLevels, function (curRule) {
+        return validateRuleDoesNotAlreadyExist(curRule, topLevels, grammarName, errMsgProvider);
+    });
+    return (utils.flatten(duplicateErrors.concat(tokenNameErrors, nestedRulesNameErrors, nestedRulesDuplicateErrors, emptyRepetitionErrors, leftRecursionErrors, emptyAltErrors, ambiguousAltsErrors, termsNamespaceConflictErrors, tooManyAltsErrors, ruleNameErrors, duplicateRulesError)));
+}
+function validateNestedRulesNames(topLevels, errMsgProvider) {
+    var result = [];
+    forEach(topLevels, function (curTopLevel) {
+        var namedCollectorVisitor = new NamedDSLMethodsCollectorVisitor("");
+        curTopLevel.accept(namedCollectorVisitor);
+        var nestedProds = map(namedCollectorVisitor.result, function (currItem) { return currItem.orgProd; });
+        result.push(map(nestedProds, function (currNestedProd) {
+            return validateNestedRuleName(curTopLevel, currNestedProd, errMsgProvider);
+        }));
+    });
+    return flatten(result);
+}
+function validateDuplicateProductions(topLevelRule, errMsgProvider) {
+    var collectorVisitor = new OccurrenceValidationCollector();
+    topLevelRule.accept(collectorVisitor);
+    var allRuleProductions = collectorVisitor.allProductions;
+    var productionGroups = utils.groupBy(allRuleProductions, identifyProductionForDuplicates);
+    var duplicates = utils.pick(productionGroups, function (currGroup) {
+        return currGroup.length > 1;
+    });
+    var errors = utils.map(utils.values(duplicates), function (currDuplicates) {
+        var firstProd = utils.first(currDuplicates);
+        var msg = errMsgProvider.buildDuplicateFoundError(topLevelRule, currDuplicates);
+        var dslName = getProductionDslName(firstProd);
+        var defError = {
+            message: msg,
+            type: ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
+            ruleName: topLevelRule.name,
+            dslName: dslName,
+            occurrence: firstProd.idx
+        };
+        var param = getExtraProductionArgument(firstProd);
+        if (param) {
+            defError.parameter = param;
+        }
+        return defError;
+    });
+    return errors;
+}
+export function identifyProductionForDuplicates(prod) {
+    return getProductionDslName(prod) + "_#_" + prod.idx + "_#_" + getExtraProductionArgument(prod);
+}
+function getExtraProductionArgument(prod) {
+    if (prod instanceof Terminal) {
+        return prod.terminalType.name;
+    }
+    else if (prod instanceof NonTerminal) {
+        return prod.nonTerminalName;
+    }
+    else {
+        return "";
+    }
+}
+var OccurrenceValidationCollector = /** @class */ (function (_super) {
+    __extends(OccurrenceValidationCollector, _super);
+    function OccurrenceValidationCollector() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.allProductions = [];
+        return _this;
+    }
+    OccurrenceValidationCollector.prototype.visitNonTerminal = function (subrule) {
+        this.allProductions.push(subrule);
+    };
+    OccurrenceValidationCollector.prototype.visitOption = function (option) {
+        this.allProductions.push(option);
+    };
+    OccurrenceValidationCollector.prototype.visitRepetitionWithSeparator = function (manySep) {
+        this.allProductions.push(manySep);
+    };
+    OccurrenceValidationCollector.prototype.visitRepetitionMandatory = function (atLeastOne) {
+        this.allProductions.push(atLeastOne);
+    };
+    OccurrenceValidationCollector.prototype.visitRepetitionMandatoryWithSeparator = function (atLeastOneSep) {
+        this.allProductions.push(atLeastOneSep);
+    };
+    OccurrenceValidationCollector.prototype.visitRepetition = function (many) {
+        this.allProductions.push(many);
+    };
+    OccurrenceValidationCollector.prototype.visitAlternation = function (or) {
+        this.allProductions.push(or);
+    };
+    OccurrenceValidationCollector.prototype.visitTerminal = function (terminal) {
+        this.allProductions.push(terminal);
+    };
+    return OccurrenceValidationCollector;
+}(GAstVisitor));
+export { OccurrenceValidationCollector };
+export var validTermsPattern = /^[a-zA-Z_]\w*$/;
+export var validNestedRuleName = new RegExp(validTermsPattern.source.replace("^", "^\\$"));
+// TODO: remove this limitation now that we use recorders
+export function validateRuleName(rule, errMsgProvider) {
+    var errors = [];
+    var ruleName = rule.name;
+    if (!ruleName.match(validTermsPattern)) {
+        errors.push({
+            message: errMsgProvider.buildInvalidRuleNameError({
+                topLevelRule: rule,
+                expectedPattern: validTermsPattern
+            }),
+            type: ParserDefinitionErrorType.INVALID_RULE_NAME,
+            ruleName: ruleName
+        });
+    }
+    return errors;
+}
+// TODO: did the nested rule name regExp now change?
+export function validateNestedRuleName(topLevel, nestedProd, errMsgProvider) {
+    var errors = [];
+    var errMsg;
+    if (!nestedProd.name.match(validNestedRuleName)) {
+        errMsg = errMsgProvider.buildInvalidNestedRuleNameError(topLevel, nestedProd);
+        errors.push({
+            message: errMsg,
+            type: ParserDefinitionErrorType.INVALID_NESTED_RULE_NAME,
+            ruleName: topLevel.name
+        });
+    }
+    return errors;
+}
+// TODO: remove this limitation now that we use recorders
+export function validateTokenName(tokenType, errMsgProvider) {
+    var errors = [];
+    var tokTypeName = tokenType.name;
+    if (!tokTypeName.match(validTermsPattern)) {
+        errors.push({
+            message: errMsgProvider.buildTokenNameError({
+                tokenType: tokenType,
+                expectedPattern: validTermsPattern
+            }),
+            type: ParserDefinitionErrorType.INVALID_TOKEN_NAME
+        });
+    }
+    return errors;
+}
+export function validateRuleDoesNotAlreadyExist(rule, allRules, className, errMsgProvider) {
+    var errors = [];
+    var occurrences = reduce(allRules, function (result, curRule) {
+        if (curRule.name === rule.name) {
+            return result + 1;
+        }
+        return result;
+    }, 0);
+    if (occurrences > 1) {
+        var errMsg = errMsgProvider.buildDuplicateRuleNameError({
+            topLevelRule: rule,
+            grammarName: className
+        });
+        errors.push({
+            message: errMsg,
+            type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,
+            ruleName: rule.name
+        });
+    }
+    return errors;
+}
+// TODO: is there anyway to get only the rule names of rules inherited from the super grammars?
+// This is not part of the IGrammarErrorProvider because the validation cannot be performed on
+// The grammar structure, only at runtime.
+export function validateRuleIsOverridden(ruleName, definedRulesNames, className) {
+    var errors = [];
+    var errMsg;
+    if (!utils.contains(definedRulesNames, ruleName)) {
+        errMsg =
+            "Invalid rule override, rule: ->" + ruleName + "<- cannot be overridden in the grammar: ->" + className + "<-" +
+                "as it is not defined in any of the super grammars ";
+        errors.push({
+            message: errMsg,
+            type: ParserDefinitionErrorType.INVALID_RULE_OVERRIDE,
+            ruleName: ruleName
+        });
+    }
+    return errors;
+}
+export function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path) {
+    if (path === void 0) { path = []; }
+    var errors = [];
+    var nextNonTerminals = getFirstNoneTerminal(currRule.definition);
+    if (utils.isEmpty(nextNonTerminals)) {
+        return [];
+    }
+    else {
+        var ruleName = topRule.name;
+        var foundLeftRecursion = utils.contains(nextNonTerminals, topRule);
+        if (foundLeftRecursion) {
+            errors.push({
+                message: errMsgProvider.buildLeftRecursionError({
+                    topLevelRule: topRule,
+                    leftRecursionPath: path
+                }),
+                type: ParserDefinitionErrorType.LEFT_RECURSION,
+                ruleName: ruleName
+            });
+        }
+        // we are only looking for cyclic paths leading back to the specific topRule
+        // other cyclic paths are ignored, we still need this difference to avoid infinite loops...
+        var validNextSteps = utils.difference(nextNonTerminals, path.concat([topRule]));
+        var errorsFromNextSteps = utils.map(validNextSteps, function (currRefRule) {
+            var newPath = utils.cloneArr(path);
+            newPath.push(currRefRule);
+            return validateNoLeftRecursion(topRule, currRefRule, errMsgProvider, newPath);
+        });
+        return errors.concat(utils.flatten(errorsFromNextSteps));
+    }
+}
+export function getFirstNoneTerminal(definition) {
+    var result = [];
+    if (utils.isEmpty(definition)) {
+        return result;
+    }
+    var firstProd = utils.first(definition);
+    /* istanbul ignore else */
+    if (firstProd instanceof NonTerminal) {
+        result.push(firstProd.referencedRule);
+    }
+    else if (firstProd instanceof Flat ||
+        firstProd instanceof Option ||
+        firstProd instanceof RepetitionMandatory ||
+        firstProd instanceof RepetitionMandatoryWithSeparator ||
+        firstProd instanceof RepetitionWithSeparator ||
+        firstProd instanceof Repetition) {
+        result = result.concat(getFirstNoneTerminal(firstProd.definition));
+    }
+    else if (firstProd instanceof Alternation) {
+        // each sub definition in alternation is a FLAT
+        result = utils.flatten(utils.map(firstProd.definition, function (currSubDef) {
+            return getFirstNoneTerminal(currSubDef.definition);
+        }));
+    }
+    else if (firstProd instanceof Terminal) {
+        // nothing to see, move along
+    }
+    else {
+        throw Error("non exhaustive match");
+    }
+    var isFirstOptional = isOptionalProd(firstProd);
+    var hasMore = definition.length > 1;
+    if (isFirstOptional && hasMore) {
+        var rest = utils.drop(definition);
+        return result.concat(getFirstNoneTerminal(rest));
+    }
+    else {
+        return result;
+    }
+}
+var OrCollector = /** @class */ (function (_super) {
+    __extends(OrCollector, _super);
+    function OrCollector() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.alternations = [];
+        return _this;
+    }
+    OrCollector.prototype.visitAlternation = function (node) {
+        this.alternations.push(node);
+    };
+    return OrCollector;
+}(GAstVisitor));
+export function validateEmptyOrAlternative(topLevelRule, errMsgProvider) {
+    var orCollector = new OrCollector();
+    topLevelRule.accept(orCollector);
+    var ors = orCollector.alternations;
+    var errors = utils.reduce(ors, function (errors, currOr) {
+        var exceptLast = utils.dropRight(currOr.definition);
+        var currErrors = utils.map(exceptLast, function (currAlternative, currAltIdx) {
+            var possibleFirstInAlt = nextPossibleTokensAfter([currAlternative], [], null, 1);
+            if (utils.isEmpty(possibleFirstInAlt)) {
+                return {
+                    message: errMsgProvider.buildEmptyAlternationError({
+                        topLevelRule: topLevelRule,
+                        alternation: currOr,
+                        emptyChoiceIdx: currAltIdx
+                    }),
+                    type: ParserDefinitionErrorType.NONE_LAST_EMPTY_ALT,
+                    ruleName: topLevelRule.name,
+                    occurrence: currOr.idx,
+                    alternative: currAltIdx + 1
+                };
+            }
+            else {
+                return null;
+            }
+        });
+        return errors.concat(utils.compact(currErrors));
+    }, []);
+    return errors;
+}
+export function validateAmbiguousAlternationAlternatives(topLevelRule, globalMaxLookahead, ignoredIssues, errMsgProvider) {
+    var orCollector = new OrCollector();
+    topLevelRule.accept(orCollector);
+    var ors = orCollector.alternations;
+    // TODO: this filtering should be deprecated once we remove the ignoredIssues
+    //  IParserConfig property
+    var ignoredIssuesForCurrentRule = ignoredIssues[topLevelRule.name];
+    if (ignoredIssuesForCurrentRule) {
+        ors = reject(ors, function (currOr) {
+            return ignoredIssuesForCurrentRule[getProductionDslName(currOr) +
+                (currOr.idx === 0 ? "" : currOr.idx)];
+        });
+    }
+    // New Handling of ignoring ambiguities
+    // - https://github.com/SAP/chevrotain/issues/869
+    ors = reject(ors, function (currOr) { return currOr.ignoreAmbiguities === true; });
+    var errors = utils.reduce(ors, function (result, currOr) {
+        var currOccurrence = currOr.idx;
+        var actualMaxLookahead = currOr.maxLookahead || globalMaxLookahead;
+        var alternatives = getLookaheadPathsForOr(currOccurrence, topLevelRule, actualMaxLookahead, currOr);
+        var altsAmbiguityErrors = checkAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);
+        var altsPrefixAmbiguityErrors = checkPrefixAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);
+        return result.concat(altsAmbiguityErrors, altsPrefixAmbiguityErrors);
+    }, []);
+    return errors;
+}
+var RepetionCollector = /** @class */ (function (_super) {
+    __extends(RepetionCollector, _super);
+    function RepetionCollector() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.allProductions = [];
+        return _this;
+    }
+    RepetionCollector.prototype.visitRepetitionWithSeparator = function (manySep) {
+        this.allProductions.push(manySep);
+    };
+    RepetionCollector.prototype.visitRepetitionMandatory = function (atLeastOne) {
+        this.allProductions.push(atLeastOne);
+    };
+    RepetionCollector.prototype.visitRepetitionMandatoryWithSeparator = function (atLeastOneSep) {
+        this.allProductions.push(atLeastOneSep);
+    };
+    RepetionCollector.prototype.visitRepetition = function (many) {
+        this.allProductions.push(many);
+    };
+    return RepetionCollector;
+}(GAstVisitor));
+export { RepetionCollector };
+export function validateTooManyAlts(topLevelRule, errMsgProvider) {
+    var orCollector = new OrCollector();
+    topLevelRule.accept(orCollector);
+    var ors = orCollector.alternations;
+    var errors = utils.reduce(ors, function (errors, currOr) {
+        if (currOr.definition.length > 255) {
+            errors.push({
+                message: errMsgProvider.buildTooManyAlternativesError({
+                    topLevelRule: topLevelRule,
+                    alternation: currOr
+                }),
+                type: ParserDefinitionErrorType.TOO_MANY_ALTS,
+                ruleName: topLevelRule.name,
+                occurrence: currOr.idx
+            });
+        }
+        return errors;
+    }, []);
+    return errors;
+}
+export function validateSomeNonEmptyLookaheadPath(topLevelRules, maxLookahead, errMsgProvider) {
+    var errors = [];
+    forEach(topLevelRules, function (currTopRule) {
+        var collectorVisitor = new RepetionCollector();
+        currTopRule.accept(collectorVisitor);
+        var allRuleProductions = collectorVisitor.allProductions;
+        forEach(allRuleProductions, function (currProd) {
+            var prodType = getProdType(currProd);
+            var actualMaxLookahead = currProd.maxLookahead || maxLookahead;
+            var currOccurrence = currProd.idx;
+            var paths = getLookaheadPathsForOptionalProd(currOccurrence, currTopRule, prodType, actualMaxLookahead);
+            var pathsInsideProduction = paths[0];
+            if (isEmpty(flatten(pathsInsideProduction))) {
+                var errMsg = errMsgProvider.buildEmptyRepetitionError({
+                    topLevelRule: currTopRule,
+                    repetition: currProd
+                });
+                errors.push({
+                    message: errMsg,
+                    type: ParserDefinitionErrorType.NO_NON_EMPTY_LOOKAHEAD,
+                    ruleName: currTopRule.name
+                });
+            }
+        });
+    });
+    return errors;
+}
+function checkAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {
+    var foundAmbiguousPaths = [];
+    var identicalAmbiguities = reduce(alternatives, function (result, currAlt, currAltIdx) {
+        // ignore (skip) ambiguities with this alternative
+        if (alternation.definition[currAltIdx].ignoreAmbiguities === true) {
+            return result;
+        }
+        forEach(currAlt, function (currPath) {
+            var altsCurrPathAppearsIn = [currAltIdx];
+            forEach(alternatives, function (currOtherAlt, currOtherAltIdx) {
+                if (currAltIdx !== currOtherAltIdx &&
+                    containsPath(currOtherAlt, currPath) &&
+                    // ignore (skip) ambiguities with this "other" alternative
+                    alternation.definition[currOtherAltIdx]
+                        .ignoreAmbiguities !== true) {
+                    altsCurrPathAppearsIn.push(currOtherAltIdx);
+                }
+            });
+            if (altsCurrPathAppearsIn.length > 1 &&
+                !containsPath(foundAmbiguousPaths, currPath)) {
+                foundAmbiguousPaths.push(currPath);
+                result.push({
+                    alts: altsCurrPathAppearsIn,
+                    path: currPath
+                });
+            }
+        });
+        return result;
+    }, []);
+    var currErrors = utils.map(identicalAmbiguities, function (currAmbDescriptor) {
+        var ambgIndices = map(currAmbDescriptor.alts, function (currAltIdx) { return currAltIdx + 1; });
+        var currMessage = errMsgProvider.buildAlternationAmbiguityError({
+            topLevelRule: rule,
+            alternation: alternation,
+            ambiguityIndices: ambgIndices,
+            prefixPath: currAmbDescriptor.path
+        });
+        return {
+            message: currMessage,
+            type: ParserDefinitionErrorType.AMBIGUOUS_ALTS,
+            ruleName: rule.name,
+            occurrence: alternation.idx,
+            alternatives: [currAmbDescriptor.alts]
+        };
+    });
+    return currErrors;
+}
+export function checkPrefixAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {
+    var errors = [];
+    // flatten
+    var pathsAndIndices = reduce(alternatives, function (result, currAlt, idx) {
+        var currPathsAndIdx = map(currAlt, function (currPath) {
+            return { idx: idx, path: currPath };
+        });
+        return result.concat(currPathsAndIdx);
+    }, []);
+    forEach(pathsAndIndices, function (currPathAndIdx) {
+        var alternativeGast = alternation.definition[currPathAndIdx.idx];
+        // ignore (skip) ambiguities with this alternative
+        if (alternativeGast.ignoreAmbiguities === true) {
+            return;
+        }
+        var targetIdx = currPathAndIdx.idx;
+        var targetPath = currPathAndIdx.path;
+        var prefixAmbiguitiesPathsAndIndices = findAll(pathsAndIndices, function (searchPathAndIdx) {
+            // prefix ambiguity can only be created from lower idx (higher priority) path
+            return (
+            // ignore (skip) ambiguities with this "other" alternative
+            alternation.definition[searchPathAndIdx.idx]
+                .ignoreAmbiguities !== true &&
+                searchPathAndIdx.idx < targetIdx &&
+                // checking for strict prefix because identical lookaheads
+                // will be be detected using a different validation.
+                isStrictPrefixOfPath(searchPathAndIdx.path, targetPath));
+        });
+        var currPathPrefixErrors = map(prefixAmbiguitiesPathsAndIndices, function (currAmbPathAndIdx) {
+            var ambgIndices = [currAmbPathAndIdx.idx + 1, targetIdx + 1];
+            var occurrence = alternation.idx === 0 ? "" : alternation.idx;
+            var message = errMsgProvider.buildAlternationPrefixAmbiguityError({
+                topLevelRule: rule,
+                alternation: alternation,
+                ambiguityIndices: ambgIndices,
+                prefixPath: currAmbPathAndIdx.path
+            });
+            return {
+                message: message,
+                type: ParserDefinitionErrorType.AMBIGUOUS_PREFIX_ALTS,
+                ruleName: rule.name,
+                occurrence: occurrence,
+                alternatives: ambgIndices
+            };
+        });
+        errors = errors.concat(currPathPrefixErrors);
+    });
+    return errors;
+}
+function checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider) {
+    var errors = [];
+    var tokenNames = map(tokenTypes, function (currToken) { return currToken.name; });
+    forEach(topLevels, function (currRule) {
+        var currRuleName = currRule.name;
+        if (contains(tokenNames, currRuleName)) {
+            var errMsg = errMsgProvider.buildNamespaceConflictError(currRule);
+            errors.push({
+                message: errMsg,
+                type: ParserDefinitionErrorType.CONFLICT_TOKENS_RULES_NAMESPACE,
+                ruleName: currRuleName
+            });
+        }
+    });
+    return errors;
+}
+function validateDuplicateNestedRules(topLevelRules, errMsgProvider) {
+    var errors = [];
+    forEach(topLevelRules, function (currTopRule) {
+        var namedCollectorVisitor = new NamedDSLMethodsCollectorVisitor("");
+        currTopRule.accept(namedCollectorVisitor);
+        var prodsByGroup = groupBy(namedCollectorVisitor.result, function (item) { return item.name; });
+        var duplicates = pick(prodsByGroup, function (currGroup) {
+            return currGroup.length > 1;
+        });
+        forEach(values(duplicates), function (currDupGroup) {
+            var currDupProds = map(currDupGroup, function (dupGroup) { return dupGroup.orgProd; });
+            var errMsg = errMsgProvider.buildDuplicateNestedRuleNameError(currTopRule, currDupProds);
+            errors.push({
+                message: errMsg,
+                type: ParserDefinitionErrorType.DUPLICATE_NESTED_NAME,
+                ruleName: currTopRule.name
+            });
+        });
+    });
+    return errors;
+}
+//# sourceMappingURL=checks.js.map

package/packages/css-parser/node_modules/chevrotain/lib_esm/src/parse/grammar/first.js

@@ -0,0 +1,57 @@
+import { uniq, map, flatten } from "../../utils/utils";
+import { NonTerminal, Terminal } from "./gast/gast_public";
+import { isBranchingProd, isOptionalProd, isSequenceProd } from "./gast/gast";
+export function first(prod) {
+    /* istanbul ignore else */
+    if (prod instanceof NonTerminal) {
+        // this could in theory cause infinite loops if
+        // (1) prod A refs prod B.
+        // (2) prod B refs prod A
+        // (3) AB can match the empty set
+        // in other words a cycle where everything is optional so the first will keep
+        // looking ahead for the next optional part and will never exit
+        // currently there is no safeguard for this unique edge case because
+        // (1) not sure a grammar in which this can happen is useful for anything (productive)
+        return first(prod.referencedRule);
+    }
+    else if (prod instanceof Terminal) {
+        return firstForTerminal(prod);
+    }
+    else if (isSequenceProd(prod)) {
+        return firstForSequence(prod);
+    }
+    else if (isBranchingProd(prod)) {
+        return firstForBranching(prod);
+    }
+    else {
+        throw Error("non exhaustive match");
+    }
+}
+export function firstForSequence(prod) {
+    var firstSet = [];
+    var seq = prod.definition;
+    var nextSubProdIdx = 0;
+    var hasInnerProdsRemaining = seq.length > nextSubProdIdx;
+    var currSubProd;
+    // so we enter the loop at least once (if the definition is not empty
+    var isLastInnerProdOptional = true;
+    // scan a sequence until it's end or until we have found a NONE optional production in it
+    while (hasInnerProdsRemaining && isLastInnerProdOptional) {
+        currSubProd = seq[nextSubProdIdx];
+        isLastInnerProdOptional = isOptionalProd(currSubProd);
+        firstSet = firstSet.concat(first(currSubProd));
+        nextSubProdIdx = nextSubProdIdx + 1;
+        hasInnerProdsRemaining = seq.length > nextSubProdIdx;
+    }
+    return uniq(firstSet);
+}
+export function firstForBranching(prod) {
+    var allAlternativesFirsts = map(prod.definition, function (innerProd) {
+        return first(innerProd);
+    });
+    return uniq(flatten(allAlternativesFirsts));
+}
+export function firstForTerminal(terminal) {
+    return [terminal.terminalType];
+}
+//# sourceMappingURL=first.js.map

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

@@ -0,0 +1,62 @@
+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 __());
+    };
+})();
+import { RestWalker } from "./rest";
+import { first } from "./first";
+import { assign, forEach } from "../../utils/utils";
+import { IN } from "../constants";
+import { Flat } from "./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 Flat({ definition: fullRest });
+        var t_in_topProd_follows = first(restProd);
+        this.follows[followName] = t_in_topProd_follows;
+    };
+    return ResyncFollowsWalker;
+}(RestWalker));
+export { ResyncFollowsWalker };
+export function computeAllProdsFollows(topProductions) {
+    var reSyncFollows = {};
+    forEach(topProductions, function (topProd) {
+        var currRefsFollow = new ResyncFollowsWalker(topProd).startWalking();
+        assign(reSyncFollows, currRefsFollow);
+    });
+    return reSyncFollows;
+}
+export function buildBetweenProdsFollowPrefix(inner, occurenceInParent) {
+    return inner.name + occurenceInParent + IN;
+}
+export function buildInProdFollowPrefix(terminal) {
+    var terminalName = terminal.terminalType.name;
+    return terminalName + terminal.idx + IN;
+}
+//# sourceMappingURL=follow.js.map