完成世界书、骰子、apiconfig页面处理

frontend/node_modules/chevrotain/lib/src/parse/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/parse/constants.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,MAAM,CAAC,MAAM,EAAE,GAAG,QAAQ,CAAC"}

frontend/node_modules/chevrotain/lib/src/parse/grammar/first.js

@@ -0,0 +1,56 @@
+import { flatten, map, uniq } from "lodash-es";
+import { isBranchingProd, isOptionalProd, isSequenceProd, NonTerminal, Terminal, } from "@chevrotain/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) {
+    let firstSet = [];
+    const seq = prod.definition;
+    let nextSubProdIdx = 0;
+    let hasInnerProdsRemaining = seq.length > nextSubProdIdx;
+    let currSubProd;
+    // so we enter the loop at least once (if the definition is not empty
+    let 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) {
+    const allAlternativesFirsts = map(prod.definition, (innerProd) => {
+        return first(innerProd);
+    });
+    return uniq(flatten(allAlternativesFirsts));
+}
+export function firstForTerminal(terminal) {
+    return [terminal.terminalType];
+}
+//# sourceMappingURL=first.js.map

frontend/node_modules/chevrotain/lib/src/parse/grammar/first.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"first.js","sourceRoot":"","sources":["../../../../src/parse/grammar/first.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EACL,eAAe,EACf,cAAc,EACd,cAAc,EACd,WAAW,EACX,QAAQ,GACT,MAAM,kBAAkB,CAAC;AAG1B,MAAM,UAAU,KAAK,CAAC,IAAiB;IACrC,0BAA0B;IAC1B,IAAI,IAAI,YAAY,WAAW,EAAE,CAAC;QAChC,+CAA+C;QAC/C,0BAA0B;QAC1B,yBAAyB;QACzB,iCAAiC;QACjC,6EAA6E;QAC7E,+DAA+D;QAC/D,oEAAoE;QACpE,sFAAsF;QACtF,OAAO,KAAK,CAAe,IAAK,CAAC,cAAc,CAAC,CAAC;IACnD,CAAC;SAAM,IAAI,IAAI,YAAY,QAAQ,EAAE,CAAC;QACpC,OAAO,gBAAgB,CAAW,IAAI,CAAC,CAAC;IAC1C,CAAC;SAAM,IAAI,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;QAChC,OAAO,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;SAAM,IAAI,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC;QACjC,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;SAAM,CAAC;QACN,MAAM,KAAK,CAAC,sBAAsB,CAAC,CAAC;IACtC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,IAEhC;IACC,IAAI,QAAQ,GAAgB,EAAE,CAAC;IAC/B,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC;IAC5B,IAAI,cAAc,GAAG,CAAC,CAAC;IACvB,IAAI,sBAAsB,GAAG,GAAG,CAAC,MAAM,GAAG,cAAc,CAAC;IACzD,IAAI,WAAW,CAAC;IAChB,qEAAqE;IACrE,IAAI,uBAAuB,GAAG,IAAI,CAAC;IACnC,yFAAyF;IACzF,OAAO,sBAAsB,IAAI,uBAAuB,EAAE,CAAC;QACzD,WAAW,GAAG,GAAG,CAAC,cAAc,CAAC,CAAC;QAClC,uBAAuB,GAAG,cAAc,CAAC,WAAW,CAAC,CAAC;QACtD,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;QAC/C,cAAc,GAAG,cAAc,GAAG,CAAC,CAAC;QACpC,sBAAsB,GAAG,GAAG,CAAC,MAAM,GAAG,cAAc,CAAC;IACvD,CAAC;IAED,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,IAEjC;IACC,MAAM,qBAAqB,GAAkB,GAAG,CAC9C,IAAI,CAAC,UAAU,EACf,CAAC,SAAS,EAAE,EAAE;QACZ,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC;IAC1B,CAAC,CACF,CAAC;IACF,OAAO,IAAI,CAAC,OAAO,CAAY,qBAAqB,CAAC,CAAC,CAAC;AACzD,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,QAAkB;IACjD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;AACjC,CAAC"}

frontend/node_modules/chevrotain/lib/src/parse/grammar/keys.js

@@ -0,0 +1,26 @@
+// Lookahead keys are 32Bit integers in the form
+// TTTTTTTT-ZZZZZZZZZZZZ-YYYY-XXXXXXXX
+// XXXX -> Occurrence Index bitmap.
+// YYYY -> DSL Method Type bitmap.
+// ZZZZZZZZZZZZZZZ -> Rule short Index bitmap.
+// TTTTTTTTT -> alternation alternative index bitmap
+export const BITS_FOR_METHOD_TYPE = 4;
+export const BITS_FOR_OCCURRENCE_IDX = 8;
+export const BITS_FOR_RULE_IDX = 12;
+// TODO: validation, this means that there may at most 2^8 --> 256 alternatives for an alternation.
+export const BITS_FOR_ALT_IDX = 8;
+// short string used as part of mapping keys.
+// being short improves the performance when composing KEYS for maps out of these
+// The 5 - 8 bits (16 possible values, are reserved for the DSL method indices)
+export const OR_IDX = 1 << BITS_FOR_OCCURRENCE_IDX;
+export const OPTION_IDX = 2 << BITS_FOR_OCCURRENCE_IDX;
+export const MANY_IDX = 3 << BITS_FOR_OCCURRENCE_IDX;
+export const AT_LEAST_ONE_IDX = 4 << BITS_FOR_OCCURRENCE_IDX;
+export const MANY_SEP_IDX = 5 << BITS_FOR_OCCURRENCE_IDX;
+export const AT_LEAST_ONE_SEP_IDX = 6 << BITS_FOR_OCCURRENCE_IDX;
+// this actually returns a number, but it is always used as a string (object prop key)
+export function getKeyForAutomaticLookahead(ruleIdx, dslMethodIdx, occurrence) {
+    return occurrence | dslMethodIdx | ruleIdx;
+}
+const BITS_START_FOR_ALT_IDX = 32 - BITS_FOR_ALT_IDX;
+//# sourceMappingURL=keys.js.map

frontend/node_modules/chevrotain/lib/src/parse/grammar/lookahead.js

@@ -0,0 +1,471 @@
+import { every, flatten, forEach, has, isEmpty, map, reduce } from "lodash-es";
+import { possiblePathsFrom } from "./interpreter.js";
+import { RestWalker } from "./rest.js";
+import { tokenStructuredMatcher, tokenStructuredMatcherNoCategories, } from "../../scan/tokens.js";
+import { Alternation, Alternative as AlternativeGAST, GAstVisitor, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, } from "@chevrotain/gast";
+export var PROD_TYPE;
+(function (PROD_TYPE) {
+    PROD_TYPE[PROD_TYPE["OPTION"] = 0] = "OPTION";
+    PROD_TYPE[PROD_TYPE["REPETITION"] = 1] = "REPETITION";
+    PROD_TYPE[PROD_TYPE["REPETITION_MANDATORY"] = 2] = "REPETITION_MANDATORY";
+    PROD_TYPE[PROD_TYPE["REPETITION_MANDATORY_WITH_SEPARATOR"] = 3] = "REPETITION_MANDATORY_WITH_SEPARATOR";
+    PROD_TYPE[PROD_TYPE["REPETITION_WITH_SEPARATOR"] = 4] = "REPETITION_WITH_SEPARATOR";
+    PROD_TYPE[PROD_TYPE["ALTERNATION"] = 5] = "ALTERNATION";
+})(PROD_TYPE || (PROD_TYPE = {}));
+export function getProdType(prod) {
+    /* istanbul ignore else */
+    if (prod instanceof Option || prod === "Option") {
+        return PROD_TYPE.OPTION;
+    }
+    else if (prod instanceof Repetition || prod === "Repetition") {
+        return PROD_TYPE.REPETITION;
+    }
+    else if (prod instanceof RepetitionMandatory ||
+        prod === "RepetitionMandatory") {
+        return PROD_TYPE.REPETITION_MANDATORY;
+    }
+    else if (prod instanceof RepetitionMandatoryWithSeparator ||
+        prod === "RepetitionMandatoryWithSeparator") {
+        return PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR;
+    }
+    else if (prod instanceof RepetitionWithSeparator ||
+        prod === "RepetitionWithSeparator") {
+        return PROD_TYPE.REPETITION_WITH_SEPARATOR;
+    }
+    else if (prod instanceof Alternation || prod === "Alternation") {
+        return PROD_TYPE.ALTERNATION;
+    }
+    else {
+        throw Error("non exhaustive match");
+    }
+}
+export function getLookaheadPaths(options) {
+    const { occurrence, rule, prodType, maxLookahead } = options;
+    const type = getProdType(prodType);
+    if (type === PROD_TYPE.ALTERNATION) {
+        return getLookaheadPathsForOr(occurrence, rule, maxLookahead);
+    }
+    else {
+        return getLookaheadPathsForOptionalProd(occurrence, rule, type, maxLookahead);
+    }
+}
+export function buildLookaheadFuncForOr(occurrence, ruleGrammar, maxLookahead, hasPredicates, dynamicTokensEnabled, laFuncBuilder) {
+    const lookAheadPaths = getLookaheadPathsForOr(occurrence, ruleGrammar, maxLookahead);
+    const tokenMatcher = areTokenCategoriesNotUsed(lookAheadPaths)
+        ? tokenStructuredMatcherNoCategories
+        : tokenStructuredMatcher;
+    return laFuncBuilder(lookAheadPaths, hasPredicates, tokenMatcher, dynamicTokensEnabled);
+}
+/**
+ *  When dealing with an Optional production (OPTION/MANY/2nd iteration of AT_LEAST_ONE/...) we need to compare
+ *  the lookahead "inside" the production and the lookahead immediately "after" it in the same top level rule (context free).
+ *
+ *  Example: given a production:
+ *  ABC(DE)?DF
+ *
+ *  The optional '(DE)?' should only be entered if we see 'DE'. a single Token 'D' is not sufficient to distinguish between the two
+ *  alternatives.
+ *
+ *  @returns A Lookahead function which will return true IFF the parser should parse the Optional production.
+ */
+export function buildLookaheadFuncForOptionalProd(occurrence, ruleGrammar, k, dynamicTokensEnabled, prodType, lookaheadBuilder) {
+    const lookAheadPaths = getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, k);
+    const tokenMatcher = areTokenCategoriesNotUsed(lookAheadPaths)
+        ? tokenStructuredMatcherNoCategories
+        : tokenStructuredMatcher;
+    return lookaheadBuilder(lookAheadPaths[0], tokenMatcher, dynamicTokensEnabled);
+}
+export function buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher, dynamicTokensEnabled) {
+    const numOfAlts = alts.length;
+    const areAllOneTokenLookahead = every(alts, (currAlt) => {
+        return every(currAlt, (currPath) => {
+            return currPath.length === 1;
+        });
+    });
+    // This version takes into account the predicates as well.
+    if (hasPredicates) {
+        /**
+         * @returns {number} - The chosen alternative index
+         */
+        return function (orAlts) {
+            // unfortunately the predicates must be extracted every single time
+            // as they cannot be cached due to references to parameters(vars) which are no longer valid.
+            // note that in the common case of no predicates, no cpu time will be wasted on this (see else block)
+            const predicates = map(orAlts, (currAlt) => currAlt.GATE);
+            for (let t = 0; t < numOfAlts; t++) {
+                const currAlt = alts[t];
+                const currNumOfPaths = currAlt.length;
+                const currPredicate = predicates[t];
+                if (currPredicate !== undefined && currPredicate.call(this) === false) {
+                    // if the predicate does not match there is no point in checking the paths
+                    continue;
+                }
+                nextPath: for (let j = 0; j < currNumOfPaths; j++) {
+                    const currPath = currAlt[j];
+                    const currPathLength = currPath.length;
+                    for (let i = 0; i < currPathLength; i++) {
+                        const nextToken = this.LA(i + 1);
+                        if (tokenMatcher(nextToken, currPath[i]) === false) {
+                            // mismatch in current path
+                            // try the next pth
+                            continue nextPath;
+                        }
+                    }
+                    // found a full path that matches.
+                    // this will also work for an empty ALT as the loop will be skipped
+                    return t;
+                }
+                // none of the paths for the current alternative matched
+                // try the next alternative
+            }
+            // none of the alternatives could be matched
+            return undefined;
+        };
+    }
+    else if (areAllOneTokenLookahead && !dynamicTokensEnabled) {
+        // optimized (common) case of all the lookaheads paths requiring only
+        // a single token lookahead. These Optimizations cannot work if dynamically defined Tokens are used.
+        const singleTokenAlts = map(alts, (currAlt) => {
+            return flatten(currAlt);
+        });
+        const choiceToAlt = reduce(singleTokenAlts, (result, currAlt, idx) => {
+            forEach(currAlt, (currTokType) => {
+                if (!has(result, currTokType.tokenTypeIdx)) {
+                    result[currTokType.tokenTypeIdx] = idx;
+                }
+                forEach(currTokType.categoryMatches, (currExtendingType) => {
+                    if (!has(result, currExtendingType)) {
+                        result[currExtendingType] = idx;
+                    }
+                });
+            });
+            return result;
+        }, {});
+        /**
+         * @returns {number} - The chosen alternative index
+         */
+        return function () {
+            const nextToken = this.LA(1);
+            return choiceToAlt[nextToken.tokenTypeIdx];
+        };
+    }
+    else {
+        // optimized lookahead without needing to check the predicates at all.
+        // this causes code duplication which is intentional to improve performance.
+        /**
+         * @returns {number} - The chosen alternative index
+         */
+        return function () {
+            for (let t = 0; t < numOfAlts; t++) {
+                const currAlt = alts[t];
+                const currNumOfPaths = currAlt.length;
+                nextPath: for (let j = 0; j < currNumOfPaths; j++) {
+                    const currPath = currAlt[j];
+                    const currPathLength = currPath.length;
+                    for (let i = 0; i < currPathLength; i++) {
+                        const nextToken = this.LA(i + 1);
+                        if (tokenMatcher(nextToken, currPath[i]) === false) {
+                            // mismatch in current path
+                            // try the next pth
+                            continue nextPath;
+                        }
+                    }
+                    // found a full path that matches.
+                    // this will also work for an empty ALT as the loop will be skipped
+                    return t;
+                }
+                // none of the paths for the current alternative matched
+                // try the next alternative
+            }
+            // none of the alternatives could be matched
+            return undefined;
+        };
+    }
+}
+export function buildSingleAlternativeLookaheadFunction(alt, tokenMatcher, dynamicTokensEnabled) {
+    const areAllOneTokenLookahead = every(alt, (currPath) => {
+        return currPath.length === 1;
+    });
+    const numOfPaths = alt.length;
+    // optimized (common) case of all the lookaheads paths requiring only
+    // a single token lookahead.
+    if (areAllOneTokenLookahead && !dynamicTokensEnabled) {
+        const singleTokensTypes = flatten(alt);
+        if (singleTokensTypes.length === 1 &&
+            isEmpty(singleTokensTypes[0].categoryMatches)) {
+            const expectedTokenType = singleTokensTypes[0];
+            const expectedTokenUniqueKey = expectedTokenType.tokenTypeIdx;
+            return function () {
+                return this.LA(1).tokenTypeIdx === expectedTokenUniqueKey;
+            };
+        }
+        else {
+            const choiceToAlt = reduce(singleTokensTypes, (result, currTokType, idx) => {
+                result[currTokType.tokenTypeIdx] = true;
+                forEach(currTokType.categoryMatches, (currExtendingType) => {
+                    result[currExtendingType] = true;
+                });
+                return result;
+            }, []);
+            return function () {
+                const nextToken = this.LA(1);
+                return choiceToAlt[nextToken.tokenTypeIdx] === true;
+            };
+        }
+    }
+    else {
+        return function () {
+            nextPath: for (let j = 0; j < numOfPaths; j++) {
+                const currPath = alt[j];
+                const currPathLength = currPath.length;
+                for (let i = 0; i < currPathLength; i++) {
+                    const nextToken = this.LA(i + 1);
+                    if (tokenMatcher(nextToken, currPath[i]) === false) {
+                        // mismatch in current path
+                        // try the next pth
+                        continue nextPath;
+                    }
+                }
+                // found a full path that matches.
+                return true;
+            }
+            // none of the paths matched
+            return false;
+        };
+    }
+}
+class RestDefinitionFinderWalker extends RestWalker {
+    constructor(topProd, targetOccurrence, targetProdType) {
+        super();
+        this.topProd = topProd;
+        this.targetOccurrence = targetOccurrence;
+        this.targetProdType = targetProdType;
+    }
+    startWalking() {
+        this.walk(this.topProd);
+        return this.restDef;
+    }
+    checkIsTarget(node, expectedProdType, currRest, prevRest) {
+        if (node.idx === this.targetOccurrence &&
+            this.targetProdType === expectedProdType) {
+            this.restDef = currRest.concat(prevRest);
+            return true;
+        }
+        // performance optimization, do not iterate over the entire Grammar ast after we have found the target
+        return false;
+    }
+    walkOption(optionProd, currRest, prevRest) {
+        if (!this.checkIsTarget(optionProd, PROD_TYPE.OPTION, currRest, prevRest)) {
+            super.walkOption(optionProd, currRest, prevRest);
+        }
+    }
+    walkAtLeastOne(atLeastOneProd, currRest, prevRest) {
+        if (!this.checkIsTarget(atLeastOneProd, PROD_TYPE.REPETITION_MANDATORY, currRest, prevRest)) {
+            super.walkOption(atLeastOneProd, currRest, prevRest);
+        }
+    }
+    walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) {
+        if (!this.checkIsTarget(atLeastOneSepProd, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, currRest, prevRest)) {
+            super.walkOption(atLeastOneSepProd, currRest, prevRest);
+        }
+    }
+    walkMany(manyProd, currRest, prevRest) {
+        if (!this.checkIsTarget(manyProd, PROD_TYPE.REPETITION, currRest, prevRest)) {
+            super.walkOption(manyProd, currRest, prevRest);
+        }
+    }
+    walkManySep(manySepProd, currRest, prevRest) {
+        if (!this.checkIsTarget(manySepProd, PROD_TYPE.REPETITION_WITH_SEPARATOR, currRest, prevRest)) {
+            super.walkOption(manySepProd, currRest, prevRest);
+        }
+    }
+}
+/**
+ * Returns the definition of a target production in a top level level rule.
+ */
+class InsideDefinitionFinderVisitor extends GAstVisitor {
+    constructor(targetOccurrence, targetProdType, targetRef) {
+        super();
+        this.targetOccurrence = targetOccurrence;
+        this.targetProdType = targetProdType;
+        this.targetRef = targetRef;
+        this.result = [];
+    }
+    checkIsTarget(node, expectedProdName) {
+        if (node.idx === this.targetOccurrence &&
+            this.targetProdType === expectedProdName &&
+            (this.targetRef === undefined || node === this.targetRef)) {
+            this.result = node.definition;
+        }
+    }
+    visitOption(node) {
+        this.checkIsTarget(node, PROD_TYPE.OPTION);
+    }
+    visitRepetition(node) {
+        this.checkIsTarget(node, PROD_TYPE.REPETITION);
+    }
+    visitRepetitionMandatory(node) {
+        this.checkIsTarget(node, PROD_TYPE.REPETITION_MANDATORY);
+    }
+    visitRepetitionMandatoryWithSeparator(node) {
+        this.checkIsTarget(node, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR);
+    }
+    visitRepetitionWithSeparator(node) {
+        this.checkIsTarget(node, PROD_TYPE.REPETITION_WITH_SEPARATOR);
+    }
+    visitAlternation(node) {
+        this.checkIsTarget(node, PROD_TYPE.ALTERNATION);
+    }
+}
+function initializeArrayOfArrays(size) {
+    const result = new Array(size);
+    for (let i = 0; i < size; i++) {
+        result[i] = [];
+    }
+    return result;
+}
+/**
+ * A sort of hash function between a Path in the grammar and a string.
+ * Note that this returns multiple "hashes" to support the scenario of token categories.
+ * -  A single path with categories may match multiple **actual** paths.
+ */
+function pathToHashKeys(path) {
+    let keys = [""];
+    for (let i = 0; i < path.length; i++) {
+        const tokType = path[i];
+        const longerKeys = [];
+        for (let j = 0; j < keys.length; j++) {
+            const currShorterKey = keys[j];
+            longerKeys.push(currShorterKey + "_" + tokType.tokenTypeIdx);
+            for (let t = 0; t < tokType.categoryMatches.length; t++) {
+                const categoriesKeySuffix = "_" + tokType.categoryMatches[t];
+                longerKeys.push(currShorterKey + categoriesKeySuffix);
+            }
+        }
+        keys = longerKeys;
+    }
+    return keys;
+}
+/**
+ * Imperative style due to being called from a hot spot
+ */
+function isUniquePrefixHash(altKnownPathsKeys, searchPathKeys, idx) {
+    for (let currAltIdx = 0; currAltIdx < altKnownPathsKeys.length; currAltIdx++) {
+        // We only want to test vs the other alternatives
+        if (currAltIdx === idx) {
+            continue;
+        }
+        const otherAltKnownPathsKeys = altKnownPathsKeys[currAltIdx];
+        for (let searchIdx = 0; searchIdx < searchPathKeys.length; searchIdx++) {
+            const searchKey = searchPathKeys[searchIdx];
+            if (otherAltKnownPathsKeys[searchKey] === true) {
+                return false;
+            }
+        }
+    }
+    // None of the SearchPathKeys were found in any of the other alternatives
+    return true;
+}
+export function lookAheadSequenceFromAlternatives(altsDefs, k) {
+    const partialAlts = map(altsDefs, (currAlt) => possiblePathsFrom([currAlt], 1));
+    const finalResult = initializeArrayOfArrays(partialAlts.length);
+    const altsHashes = map(partialAlts, (currAltPaths) => {
+        const dict = {};
+        forEach(currAltPaths, (item) => {
+            const keys = pathToHashKeys(item.partialPath);
+            forEach(keys, (currKey) => {
+                dict[currKey] = true;
+            });
+        });
+        return dict;
+    });
+    let newData = partialAlts;
+    // maxLookahead loop
+    for (let pathLength = 1; pathLength <= k; pathLength++) {
+        const currDataset = newData;
+        newData = initializeArrayOfArrays(currDataset.length);
+        // alternatives loop
+        for (let altIdx = 0; altIdx < currDataset.length; altIdx++) {
+            const currAltPathsAndSuffixes = currDataset[altIdx];
+            // paths in current alternative loop
+            for (let currPathIdx = 0; currPathIdx < currAltPathsAndSuffixes.length; currPathIdx++) {
+                const currPathPrefix = currAltPathsAndSuffixes[currPathIdx].partialPath;
+                const suffixDef = currAltPathsAndSuffixes[currPathIdx].suffixDef;
+                const prefixKeys = pathToHashKeys(currPathPrefix);
+                const isUnique = isUniquePrefixHash(altsHashes, prefixKeys, altIdx);
+                // End of the line for this path.
+                if (isUnique || isEmpty(suffixDef) || currPathPrefix.length === k) {
+                    const currAltResult = finalResult[altIdx];
+                    // TODO: Can we implement a containsPath using Maps/Dictionaries?
+                    if (containsPath(currAltResult, currPathPrefix) === false) {
+                        currAltResult.push(currPathPrefix);
+                        // Update all new  keys for the current path.
+                        for (let j = 0; j < prefixKeys.length; j++) {
+                            const currKey = prefixKeys[j];
+                            altsHashes[altIdx][currKey] = true;
+                        }
+                    }
+                }
+                // Expand longer paths
+                else {
+                    const newPartialPathsAndSuffixes = possiblePathsFrom(suffixDef, pathLength + 1, currPathPrefix);
+                    newData[altIdx] = newData[altIdx].concat(newPartialPathsAndSuffixes);
+                    // Update keys for new known paths
+                    forEach(newPartialPathsAndSuffixes, (item) => {
+                        const prefixKeys = pathToHashKeys(item.partialPath);
+                        forEach(prefixKeys, (key) => {
+                            altsHashes[altIdx][key] = true;
+                        });
+                    });
+                }
+            }
+        }
+    }
+    return finalResult;
+}
+export function getLookaheadPathsForOr(occurrence, ruleGrammar, k, orProd) {
+    const visitor = new InsideDefinitionFinderVisitor(occurrence, PROD_TYPE.ALTERNATION, orProd);
+    ruleGrammar.accept(visitor);
+    return lookAheadSequenceFromAlternatives(visitor.result, k);
+}
+export function getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, k) {
+    const insideDefVisitor = new InsideDefinitionFinderVisitor(occurrence, prodType);
+    ruleGrammar.accept(insideDefVisitor);
+    const insideDef = insideDefVisitor.result;
+    const afterDefWalker = new RestDefinitionFinderWalker(ruleGrammar, occurrence, prodType);
+    const afterDef = afterDefWalker.startWalking();
+    const insideFlat = new AlternativeGAST({ definition: insideDef });
+    const afterFlat = new AlternativeGAST({ definition: afterDef });
+    return lookAheadSequenceFromAlternatives([insideFlat, afterFlat], k);
+}
+export function containsPath(alternative, searchPath) {
+    compareOtherPath: for (let i = 0; i < alternative.length; i++) {
+        const otherPath = alternative[i];
+        if (otherPath.length !== searchPath.length) {
+            continue;
+        }
+        for (let j = 0; j < otherPath.length; j++) {
+            const searchTok = searchPath[j];
+            const otherTok = otherPath[j];
+            const matchingTokens = searchTok === otherTok ||
+                otherTok.categoryMatchesMap[searchTok.tokenTypeIdx] !== undefined;
+            if (matchingTokens === false) {
+                continue compareOtherPath;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+export function isStrictPrefixOfPath(prefix, other) {
+    return (prefix.length < other.length &&
+        every(prefix, (tokType, idx) => {
+            const otherTokType = other[idx];
+            return (tokType === otherTokType ||
+                otherTokType.categoryMatchesMap[tokType.tokenTypeIdx]);
+        }));
+}
+export function areTokenCategoriesNotUsed(lookAheadPaths) {
+    return every(lookAheadPaths, (singleAltPaths) => every(singleAltPaths, (singlePath) => every(singlePath, (token) => isEmpty(token.categoryMatches))));
+}
+//# sourceMappingURL=lookahead.js.map

frontend/node_modules/chevrotain/lib/src/parse/grammar/resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../../../../src/parse/grammar/resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,yBAAyB,GAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAqB,MAAM,kBAAkB,CAAC;AAMlE,MAAM,UAAU,cAAc,CAC5B,SAA+B,EAC/B,cAAoD;IAEpD,MAAM,WAAW,GAAG,IAAI,sBAAsB,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;IAC1E,WAAW,CAAC,WAAW,EAAE,CAAC;IAC1B,OAAO,WAAW,CAAC,MAAM,CAAC;AAC5B,CAAC;AAED,MAAM,OAAO,sBAAuB,SAAQ,WAAW;IAIrD,YACU,aAAmC,EACnC,cAAoD;QAE5D,KAAK,EAAE,CAAC;QAHA,kBAAa,GAAb,aAAa,CAAsB;QACnC,mBAAc,GAAd,cAAc,CAAsC;QALvD,WAAM,GAA0C,EAAE,CAAC;IAQ1D,CAAC;IAEM,WAAW;QAChB,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE;YAC3C,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACpB,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,gBAAgB,CAAC,IAAiB;QACvC,MAAM,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAErD,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,MAAM,GAAG,GAAG,IAAI,CAAC,cAAc,CAAC,sBAAsB,CACpD,IAAI,CAAC,YAAY,EACjB,IAAI,CACL,CAAC;YACF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;gBACf,OAAO,EAAE,GAAG;gBACZ,IAAI,EAAE,yBAAyB,CAAC,sBAAsB;gBACtD,QAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI;gBAChC,iBAAiB,EAAE,IAAI,CAAC,eAAe;aACxC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,cAAc,GAAG,GAAG,CAAC;QAC5B,CAAC;IACH,CAAC;CACF"}

frontend/node_modules/chevrotain/lib/src/parse/grammar/rest.js

@@ -0,0 +1,103 @@
+import { drop, forEach } from "lodash-es";
+import { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Terminal, } from "@chevrotain/gast";
+/**
+ *  A Grammar Walker that computes the "remaining" grammar "after" a productions in the grammar.
+ */
+export class RestWalker {
+    walk(prod, prevRest = []) {
+        forEach(prod.definition, (subProd, index) => {
+            const currRest = drop(prod.definition, index + 1);
+            /* istanbul ignore else */
+            if (subProd instanceof NonTerminal) {
+                this.walkProdRef(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof Terminal) {
+                this.walkTerminal(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof Alternative) {
+                this.walkFlat(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof Option) {
+                this.walkOption(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof RepetitionMandatory) {
+                this.walkAtLeastOne(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof RepetitionMandatoryWithSeparator) {
+                this.walkAtLeastOneSep(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof RepetitionWithSeparator) {
+                this.walkManySep(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof Repetition) {
+                this.walkMany(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof Alternation) {
+                this.walkOr(subProd, currRest, prevRest);
+            }
+            else {
+                throw Error("non exhaustive match");
+            }
+        });
+    }
+    walkTerminal(terminal, currRest, prevRest) { }
+    walkProdRef(refProd, currRest, prevRest) { }
+    walkFlat(flatProd, currRest, prevRest) {
+        // ABCDEF => after the D the rest is EF
+        const fullOrRest = currRest.concat(prevRest);
+        this.walk(flatProd, fullOrRest);
+    }
+    walkOption(optionProd, currRest, prevRest) {
+        // ABC(DE)?F => after the (DE)? the rest is F
+        const fullOrRest = currRest.concat(prevRest);
+        this.walk(optionProd, fullOrRest);
+    }
+    walkAtLeastOne(atLeastOneProd, currRest, prevRest) {
+        // ABC(DE)+F => after the (DE)+ the rest is (DE)?F
+        const fullAtLeastOneRest = [
+            new Option({ definition: atLeastOneProd.definition }),
+        ].concat(currRest, prevRest);
+        this.walk(atLeastOneProd, fullAtLeastOneRest);
+    }
+    walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) {
+        // ABC DE(,DE)* F => after the (,DE)+ the rest is (,DE)?F
+        const fullAtLeastOneSepRest = restForRepetitionWithSeparator(atLeastOneSepProd, currRest, prevRest);
+        this.walk(atLeastOneSepProd, fullAtLeastOneSepRest);
+    }
+    walkMany(manyProd, currRest, prevRest) {
+        // ABC(DE)*F => after the (DE)* the rest is (DE)?F
+        const fullManyRest = [
+            new Option({ definition: manyProd.definition }),
+        ].concat(currRest, prevRest);
+        this.walk(manyProd, fullManyRest);
+    }
+    walkManySep(manySepProd, currRest, prevRest) {
+        // ABC (DE(,DE)*)? F => after the (,DE)* the rest is (,DE)?F
+        const fullManySepRest = restForRepetitionWithSeparator(manySepProd, currRest, prevRest);
+        this.walk(manySepProd, fullManySepRest);
+    }
+    walkOr(orProd, currRest, prevRest) {
+        // ABC(D|E|F)G => when finding the (D|E|F) the rest is G
+        const fullOrRest = currRest.concat(prevRest);
+        // walk all different alternatives
+        forEach(orProd.definition, (alt) => {
+            // wrapping each alternative in a single definition wrapper
+            // to avoid errors in computing the rest of that alternative in the invocation to computeInProdFollows
+            // (otherwise for OR([alt1,alt2]) alt2 will be considered in 'rest' of alt1
+            const prodWrapper = new Alternative({ definition: [alt] });
+            this.walk(prodWrapper, fullOrRest);
+        });
+    }
+}
+function restForRepetitionWithSeparator(repSepProd, currRest, prevRest) {
+    const repSepRest = [
+        new Option({
+            definition: [
+                new Terminal({ terminalType: repSepProd.separator }),
+            ].concat(repSepProd.definition),
+        }),
+    ];
+    const fullRepSepRest = repSepRest.concat(currRest, prevRest);
+    return fullRepSepRest;
+}
+//# sourceMappingURL=rest.js.map

frontend/node_modules/chevrotain/lib/src/parse/grammar/rest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest.js","sourceRoot":"","sources":["../../../../src/parse/grammar/rest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EACL,WAAW,EACX,WAAW,EACX,WAAW,EACX,MAAM,EACN,UAAU,EACV,mBAAmB,EACnB,gCAAgC,EAChC,uBAAuB,EACvB,QAAQ,GACT,MAAM,kBAAkB,CAAC;AAG1B;;GAEG;AACH,MAAM,OAAgB,UAAU;IAC9B,IAAI,CAAC,IAAmC,EAAE,WAAkB,EAAE;QAC5D,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,OAAoB,EAAE,KAAK,EAAE,EAAE;YACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC;YAClD,0BAA0B;YAC1B,IAAI,OAAO,YAAY,WAAW,EAAE,CAAC;gBACnC,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAChD,CAAC;iBAAM,IAAI,OAAO,YAAY,QAAQ,EAAE,CAAC;gBACvC,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;YACjD,CAAC;iBAAM,IAAI,OAAO,YAAY,WAAW,EAAE,CAAC;gBAC1C,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAC7C,CAAC;iBAAM,IAAI,OAAO,YAAY,MAAM,EAAE,CAAC;gBACrC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAC/C,CAAC;iBAAM,IAAI,OAAO,YAAY,mBAAmB,EAAE,CAAC;gBAClD,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;YACnD,CAAC;iBAAM,IAAI,OAAO,YAAY,gCAAgC,EAAE,CAAC;gBAC/D,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;YACtD,CAAC;iBAAM,IAAI,OAAO,YAAY,uBAAuB,EAAE,CAAC;gBACtD,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAChD,CAAC;iBAAM,IAAI,OAAO,YAAY,UAAU,EAAE,CAAC;gBACzC,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAC7C,CAAC;iBAAM,IAAI,OAAO,YAAY,WAAW,EAAE,CAAC;gBAC1C,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAC3C,CAAC;iBAAM,CAAC;gBACN,MAAM,KAAK,CAAC,sBAAsB,CAAC,CAAC;YACtC,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,YAAY,CACV,QAAkB,EAClB,QAAuB,EACvB,QAAuB,IAChB,CAAC;IAEV,WAAW,CACT,OAAoB,EACpB,QAAuB,EACvB,QAAuB,IAChB,CAAC;IAEV,QAAQ,CACN,QAAqB,EACrB,QAAuB,EACvB,QAAuB;QAEvB,uCAAuC;QACvC,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC7C,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAO,UAAU,CAAC,CAAC;IACvC,CAAC;IAED,UAAU,CACR,UAAkB,EAClB,QAAuB,EACvB,QAAuB;QAEvB,6CAA6C;QAC7C,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC7C,IAAI,CAAC,IAAI,CAAC,UAAU,EAAO,UAAU,CAAC,CAAC;IACzC,CAAC;IAED,cAAc,CACZ,cAAmC,EACnC,QAAuB,EACvB,QAAuB;QAEvB,kDAAkD;QAClD,MAAM,kBAAkB,GAAkB;YACxC,IAAI,MAAM,CAAC,EAAE,UAAU,EAAE,cAAc,CAAC,UAAU,EAAE,CAAC;SACtD,CAAC,MAAM,CAAM,QAAQ,EAAO,QAAQ,CAAC,CAAC;QACvC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC;IAChD,CAAC;IAED,iBAAiB,CACf,iBAAmD,EACnD,QAAuB,EACvB,QAAuB;QAEvB,yDAAyD;QACzD,MAAM,qBAAqB,GAAG,8BAA8B,CAC1D,iBAAiB,EACjB,QAAQ,EACR,QAAQ,CACT,CAAC;QACF,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,qBAAqB,CAAC,CAAC;IACtD,CAAC;IAED,QAAQ,CACN,QAAoB,EACpB,QAAuB,EACvB,QAAuB;QAEvB,kDAAkD;QAClD,MAAM,YAAY,GAAkB;YAClC,IAAI,MAAM,CAAC,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU,EAAE,CAAC;SAChD,CAAC,MAAM,CAAM,QAAQ,EAAO,QAAQ,CAAC,CAAC;QACvC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;IACpC,CAAC;IAED,WAAW,CACT,WAAoC,EACpC,QAAuB,EACvB,QAAuB;QAEvB,4DAA4D;QAC5D,MAAM,eAAe,GAAG,8BAA8B,CACpD,WAAW,EACX,QAAQ,EACR,QAAQ,CACT,CAAC;QACF,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,eAAe,CAAC,CAAC;IAC1C,CAAC;IAED,MAAM,CACJ,MAAmB,EACnB,QAAuB,EACvB,QAAuB;QAEvB,wDAAwD;QACxD,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC7C,kCAAkC;QAClC,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,EAAE;YACjC,2DAA2D;YAC3D,sGAAsG;YACtG,2EAA2E;YAC3E,MAAM,WAAW,GAAG,IAAI,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC3D,IAAI,CAAC,IAAI,CAAC,WAAW,EAAO,UAAU,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAED,SAAS,8BAA8B,CACrC,UAAmC,EACnC,QAAuB,EACvB,QAAuB;IAEvB,MAAM,UAAU,GAAG;QACjB,IAAI,MAAM,CAAC;YACT,UAAU,EAAE;gBACV,IAAI,QAAQ,CAAC,EAAE,YAAY,EAAE,UAAU,CAAC,SAAS,EAAE,CAAgB;aACpE,CAAC,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC;SAChC,CAAgB;KAClB,CAAC;IACF,MAAM,cAAc,GAAkB,UAAU,CAAC,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAC5E,OAAO,cAAc,CAAC;AACxB,CAAC"}

frontend/node_modules/chevrotain/lib/src/parse/parser/traits/gast_recorder.js

@@ -0,0 +1,295 @@
+import { forEach, has, isArray, isFunction, last as peek, some, } from "lodash-es";
+import { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal, } from "@chevrotain/gast";
+import { Lexer } from "../../../scan/lexer_public.js";
+import { augmentTokenTypes, hasShortKeyProperty, } from "../../../scan/tokens.js";
+import { createToken, createTokenInstance, } from "../../../scan/tokens_public.js";
+import { END_OF_FILE } from "../parser.js";
+import { BITS_FOR_OCCURRENCE_IDX } from "../../grammar/keys.js";
+const RECORDING_NULL_OBJECT = {
+    description: "This Object indicates the Parser is during Recording Phase",
+};
+Object.freeze(RECORDING_NULL_OBJECT);
+const HANDLE_SEPARATOR = true;
+const MAX_METHOD_IDX = Math.pow(2, BITS_FOR_OCCURRENCE_IDX) - 1;
+const RFT = createToken({ name: "RECORDING_PHASE_TOKEN", pattern: Lexer.NA });
+augmentTokenTypes([RFT]);
+const RECORDING_PHASE_TOKEN = createTokenInstance(RFT, "This IToken indicates the Parser is in Recording Phase\n\t" +
+    "" +
+    "See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details", 
+// Using "-1" instead of NaN (as in EOF) because an actual number is less likely to
+// cause errors if the output of LA or CONSUME would be (incorrectly) used during the recording phase.
+-1, -1, -1, -1, -1, -1);
+Object.freeze(RECORDING_PHASE_TOKEN);
+const RECORDING_PHASE_CSTNODE = {
+    name: "This CSTNode indicates the Parser is in Recording Phase\n\t" +
+        "See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details",
+    children: {},
+};
+/**
+ * This trait handles the creation of the GAST structure for Chevrotain Grammars
+ */
+export class GastRecorder {
+    initGastRecorder(config) {
+        this.recordingProdStack = [];
+        this.RECORDING_PHASE = false;
+    }
+    enableRecording() {
+        this.RECORDING_PHASE = true;
+        this.TRACE_INIT("Enable Recording", () => {
+            /**
+             * Warning Dark Voodoo Magic upcoming!
+             * We are "replacing" the public parsing DSL methods API
+             * With **new** alternative implementations on the Parser **instance**
+             *
+             * So far this is the only way I've found to avoid performance regressions during parsing time.
+             * - Approx 30% performance regression was measured on Chrome 75 Canary when attempting to replace the "internal"
+             *   implementations directly instead.
+             */
+            for (let i = 0; i < 10; i++) {
+                const idx = i > 0 ? i : "";
+                this[`CONSUME${idx}`] = function (arg1, arg2) {
+                    return this.consumeInternalRecord(arg1, i, arg2);
+                };
+                this[`SUBRULE${idx}`] = function (arg1, arg2) {
+                    return this.subruleInternalRecord(arg1, i, arg2);
+                };
+                this[`OPTION${idx}`] = function (arg1) {
+                    return this.optionInternalRecord(arg1, i);
+                };
+                this[`OR${idx}`] = function (arg1) {
+                    return this.orInternalRecord(arg1, i);
+                };
+                this[`MANY${idx}`] = function (arg1) {
+                    this.manyInternalRecord(i, arg1);
+                };
+                this[`MANY_SEP${idx}`] = function (arg1) {
+                    this.manySepFirstInternalRecord(i, arg1);
+                };
+                this[`AT_LEAST_ONE${idx}`] = function (arg1) {
+                    this.atLeastOneInternalRecord(i, arg1);
+                };
+                this[`AT_LEAST_ONE_SEP${idx}`] = function (arg1) {
+                    this.atLeastOneSepFirstInternalRecord(i, arg1);
+                };
+            }
+            // DSL methods with the idx(suffix) as an argument
+            this[`consume`] = function (idx, arg1, arg2) {
+                return this.consumeInternalRecord(arg1, idx, arg2);
+            };
+            this[`subrule`] = function (idx, arg1, arg2) {
+                return this.subruleInternalRecord(arg1, idx, arg2);
+            };
+            this[`option`] = function (idx, arg1) {
+                return this.optionInternalRecord(arg1, idx);
+            };
+            this[`or`] = function (idx, arg1) {
+                return this.orInternalRecord(arg1, idx);
+            };
+            this[`many`] = function (idx, arg1) {
+                this.manyInternalRecord(idx, arg1);
+            };
+            this[`atLeastOne`] = function (idx, arg1) {
+                this.atLeastOneInternalRecord(idx, arg1);
+            };
+            this.ACTION = this.ACTION_RECORD;
+            this.BACKTRACK = this.BACKTRACK_RECORD;
+            this.LA = this.LA_RECORD;
+        });
+    }
+    disableRecording() {
+        this.RECORDING_PHASE = false;
+        // By deleting these **instance** properties, any future invocation
+        // will be deferred to the original methods on the **prototype** object
+        // This seems to get rid of any incorrect optimizations that V8 may
+        // do during the recording phase.
+        this.TRACE_INIT("Deleting Recording methods", () => {
+            const that = this;
+            for (let i = 0; i < 10; i++) {
+                const idx = i > 0 ? i : "";
+                delete that[`CONSUME${idx}`];
+                delete that[`SUBRULE${idx}`];
+                delete that[`OPTION${idx}`];
+                delete that[`OR${idx}`];
+                delete that[`MANY${idx}`];
+                delete that[`MANY_SEP${idx}`];
+                delete that[`AT_LEAST_ONE${idx}`];
+                delete that[`AT_LEAST_ONE_SEP${idx}`];
+            }
+            delete that[`consume`];
+            delete that[`subrule`];
+            delete that[`option`];
+            delete that[`or`];
+            delete that[`many`];
+            delete that[`atLeastOne`];
+            delete that.ACTION;
+            delete that.BACKTRACK;
+            delete that.LA;
+        });
+    }
+    //   Parser methods are called inside an ACTION?
+    //   Maybe try/catch/finally on ACTIONS while disabling the recorders state changes?
+    // @ts-expect-error -- noop place holder
+    ACTION_RECORD(impl) {
+        // NO-OP during recording
+    }
+    // Executing backtracking logic will break our recording logic assumptions
+    BACKTRACK_RECORD(grammarRule, args) {
+        return () => true;
+    }
+    // LA is part of the official API and may be used for custom lookahead logic
+    // by end users who may forget to wrap it in ACTION or inside a GATE
+    LA_RECORD(howMuch) {
+        // We cannot use the RECORD_PHASE_TOKEN here because someone may depend
+        // On LA return EOF at the end of the input so an infinite loop may occur.
+        return END_OF_FILE;
+    }
+    topLevelRuleRecord(name, def) {
+        try {
+            const newTopLevelRule = new Rule({ definition: [], name: name });
+            newTopLevelRule.name = name;
+            this.recordingProdStack.push(newTopLevelRule);
+            def.call(this);
+            this.recordingProdStack.pop();
+            return newTopLevelRule;
+        }
+        catch (originalError) {
+            if (originalError.KNOWN_RECORDER_ERROR !== true) {
+                try {
+                    originalError.message =
+                        originalError.message +
+                            '\n\t This error was thrown during the "grammar recording phase" For more info see:\n\t' +
+                            "https://chevrotain.io/docs/guide/internals.html#grammar-recording";
+                }
+                catch (mutabilityError) {
+                    // We may not be able to modify the original error object
+                    throw originalError;
+                }
+            }
+            throw originalError;
+        }
+    }
+    // Implementation of parsing DSL
+    optionInternalRecord(actionORMethodDef, occurrence) {
+        return recordProd.call(this, Option, actionORMethodDef, occurrence);
+    }
+    atLeastOneInternalRecord(occurrence, actionORMethodDef) {
+        recordProd.call(this, RepetitionMandatory, actionORMethodDef, occurrence);
+    }
+    atLeastOneSepFirstInternalRecord(occurrence, options) {
+        recordProd.call(this, RepetitionMandatoryWithSeparator, options, occurrence, HANDLE_SEPARATOR);
+    }
+    manyInternalRecord(occurrence, actionORMethodDef) {
+        recordProd.call(this, Repetition, actionORMethodDef, occurrence);
+    }
+    manySepFirstInternalRecord(occurrence, options) {
+        recordProd.call(this, RepetitionWithSeparator, options, occurrence, HANDLE_SEPARATOR);
+    }
+    orInternalRecord(altsOrOpts, occurrence) {
+        return recordOrProd.call(this, altsOrOpts, occurrence);
+    }
+    subruleInternalRecord(ruleToCall, occurrence, options) {
+        assertMethodIdxIsValid(occurrence);
+        if (!ruleToCall || has(ruleToCall, "ruleName") === false) {
+            const error = new Error(`<SUBRULE${getIdxSuffix(occurrence)}> argument is invalid` +
+                ` expecting a Parser method reference but got: <${JSON.stringify(ruleToCall)}>` +
+                `\n inside top level rule: <${this.recordingProdStack[0].name}>`);
+            error.KNOWN_RECORDER_ERROR = true;
+            throw error;
+        }
+        const prevProd = peek(this.recordingProdStack);
+        const ruleName = ruleToCall.ruleName;
+        const newNoneTerminal = new NonTerminal({
+            idx: occurrence,
+            nonTerminalName: ruleName,
+            label: options === null || options === void 0 ? void 0 : options.LABEL,
+            // The resolving of the `referencedRule` property will be done once all the Rule's GASTs have been created
+            referencedRule: undefined,
+        });
+        prevProd.definition.push(newNoneTerminal);
+        return this.outputCst
+            ? RECORDING_PHASE_CSTNODE
+            : RECORDING_NULL_OBJECT;
+    }
+    consumeInternalRecord(tokType, occurrence, options) {
+        assertMethodIdxIsValid(occurrence);
+        if (!hasShortKeyProperty(tokType)) {
+            const error = new Error(`<CONSUME${getIdxSuffix(occurrence)}> argument is invalid` +
+                ` expecting a TokenType reference but got: <${JSON.stringify(tokType)}>` +
+                `\n inside top level rule: <${this.recordingProdStack[0].name}>`);
+            error.KNOWN_RECORDER_ERROR = true;
+            throw error;
+        }
+        const prevProd = peek(this.recordingProdStack);
+        const newNoneTerminal = new Terminal({
+            idx: occurrence,
+            terminalType: tokType,
+            label: options === null || options === void 0 ? void 0 : options.LABEL,
+        });
+        prevProd.definition.push(newNoneTerminal);
+        return RECORDING_PHASE_TOKEN;
+    }
+}
+function recordProd(prodConstructor, mainProdArg, occurrence, handleSep = false) {
+    assertMethodIdxIsValid(occurrence);
+    const prevProd = peek(this.recordingProdStack);
+    const grammarAction = isFunction(mainProdArg) ? mainProdArg : mainProdArg.DEF;
+    const newProd = new prodConstructor({ definition: [], idx: occurrence });
+    if (handleSep) {
+        newProd.separator = mainProdArg.SEP;
+    }
+    if (has(mainProdArg, "MAX_LOOKAHEAD")) {
+        newProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
+    }
+    this.recordingProdStack.push(newProd);
+    grammarAction.call(this);
+    prevProd.definition.push(newProd);
+    this.recordingProdStack.pop();
+    return RECORDING_NULL_OBJECT;
+}
+function recordOrProd(mainProdArg, occurrence) {
+    assertMethodIdxIsValid(occurrence);
+    const prevProd = peek(this.recordingProdStack);
+    // Only an array of alternatives
+    const hasOptions = isArray(mainProdArg) === false;
+    const alts = hasOptions === false ? mainProdArg : mainProdArg.DEF;
+    const newOrProd = new Alternation({
+        definition: [],
+        idx: occurrence,
+        ignoreAmbiguities: hasOptions && mainProdArg.IGNORE_AMBIGUITIES === true,
+    });
+    if (has(mainProdArg, "MAX_LOOKAHEAD")) {
+        newOrProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
+    }
+    const hasPredicates = some(alts, (currAlt) => isFunction(currAlt.GATE));
+    newOrProd.hasPredicates = hasPredicates;
+    prevProd.definition.push(newOrProd);
+    forEach(alts, (currAlt) => {
+        const currAltFlat = new Alternative({ definition: [] });
+        newOrProd.definition.push(currAltFlat);
+        if (has(currAlt, "IGNORE_AMBIGUITIES")) {
+            currAltFlat.ignoreAmbiguities = currAlt.IGNORE_AMBIGUITIES; // assumes end user provides the correct config value/type
+        }
+        // **implicit** ignoreAmbiguities due to usage of gate
+        else if (has(currAlt, "GATE")) {
+            currAltFlat.ignoreAmbiguities = true;
+        }
+        this.recordingProdStack.push(currAltFlat);
+        currAlt.ALT.call(this);
+        this.recordingProdStack.pop();
+    });
+    return RECORDING_NULL_OBJECT;
+}
+function getIdxSuffix(idx) {
+    return idx === 0 ? "" : `${idx}`;
+}
+function assertMethodIdxIsValid(idx) {
+    if (idx < 0 || idx > MAX_METHOD_IDX) {
+        const error = new Error(
+        // The stack trace will contain all the needed details
+        `Invalid DSL Method idx value: <${idx}>\n\t` +
+            `Idx value must be a none negative value smaller than ${MAX_METHOD_IDX + 1}`);
+        error.KNOWN_RECORDER_ERROR = true;
+        throw error;
+    }
+}
+//# sourceMappingURL=gast_recorder.js.map

frontend/node_modules/chevrotain/lib/src/parse/parser/traits/lexer_adapter.js

@@ -0,0 +1,70 @@
+import { END_OF_FILE } from "../parser.js";
+/**
+ * Trait responsible abstracting over the interaction with Lexer output (Token vector).
+ *
+ * This could be generalized to support other kinds of lexers, e.g.
+ * - Just in Time Lexing / Lexer-Less parsing.
+ * - Streaming Lexer.
+ */
+export class LexerAdapter {
+    initLexerAdapter() {
+        this.tokVector = [];
+        this.tokVectorLength = 0;
+        this.currIdx = -1;
+    }
+    set input(newInput) {
+        // @ts-ignore - `this parameter` not supported in setters/getters
+        //   - https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters
+        if (this.selfAnalysisDone !== true) {
+            throw Error(`Missing <performSelfAnalysis> invocation at the end of the Parser's constructor.`);
+        }
+        // @ts-ignore - `this parameter` not supported in setters/getters
+        //   - https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters
+        this.reset();
+        this.tokVector = newInput;
+        this.tokVectorLength = newInput.length;
+    }
+    get input() {
+        return this.tokVector;
+    }
+    // skips a token and returns the next token
+    SKIP_TOKEN() {
+        if (this.currIdx <= this.tokVector.length - 2) {
+            this.consumeToken();
+            return this.LA(1);
+        }
+        else {
+            return END_OF_FILE;
+        }
+    }
+    // Lexer (accessing Token vector) related methods which can be overridden to implement lazy lexers
+    // or lexers dependent on parser context.
+    LA(howMuch) {
+        const soughtIdx = this.currIdx + howMuch;
+        if (soughtIdx < 0 || this.tokVectorLength <= soughtIdx) {
+            return END_OF_FILE;
+        }
+        else {
+            return this.tokVector[soughtIdx];
+        }
+    }
+    consumeToken() {
+        this.currIdx++;
+    }
+    exportLexerState() {
+        return this.currIdx;
+    }
+    importLexerState(newState) {
+        this.currIdx = newState;
+    }
+    resetLexerState() {
+        this.currIdx = -1;
+    }
+    moveToTerminatedState() {
+        this.currIdx = this.tokVector.length - 1;
+    }
+    getLexerPosition() {
+        return this.exportLexerState();
+    }
+}
+//# sourceMappingURL=lexer_adapter.js.map

frontend/node_modules/chevrotain/lib/src/parse/parser/traits/parser_traits.js

@@ -0,0 +1,4 @@
+import { CstParser as CstParserConstructorImpel, EmbeddedActionsParser as EmbeddedActionsParserConstructorImpl, } from "../parser.js";
+export const CstParser = (CstParserConstructorImpel);
+export const EmbeddedActionsParser = EmbeddedActionsParserConstructorImpl;
+//# sourceMappingURL=parser_traits.js.map

frontend/node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_api.js

@@ -0,0 +1,334 @@
+import { includes, values } from "lodash-es";
+import { isRecognitionException } from "../../exceptions_public.js";
+import { DEFAULT_RULE_CONFIG, ParserDefinitionErrorType } from "../parser.js";
+import { defaultGrammarValidatorErrorProvider } from "../../errors_public.js";
+import { validateRuleIsOverridden } from "../../grammar/checks.js";
+import { serializeGrammar } from "@chevrotain/gast";
+/**
+ * This trait is responsible for implementing the public API
+ * for defining Chevrotain parsers, i.e:
+ * - CONSUME
+ * - RULE
+ * - OPTION
+ * - ...
+ */
+export class RecognizerApi {
+    ACTION(impl) {
+        return impl.call(this);
+    }
+    consume(idx, tokType, options) {
+        return this.consumeInternal(tokType, idx, options);
+    }
+    subrule(idx, ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, idx, options);
+    }
+    option(idx, actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, idx);
+    }
+    or(idx, altsOrOpts) {
+        return this.orInternal(altsOrOpts, idx);
+    }
+    many(idx, actionORMethodDef) {
+        return this.manyInternal(idx, actionORMethodDef);
+    }
+    atLeastOne(idx, actionORMethodDef) {
+        return this.atLeastOneInternal(idx, actionORMethodDef);
+    }
+    CONSUME(tokType, options) {
+        return this.consumeInternal(tokType, 0, options);
+    }
+    CONSUME1(tokType, options) {
+        return this.consumeInternal(tokType, 1, options);
+    }
+    CONSUME2(tokType, options) {
+        return this.consumeInternal(tokType, 2, options);
+    }
+    CONSUME3(tokType, options) {
+        return this.consumeInternal(tokType, 3, options);
+    }
+    CONSUME4(tokType, options) {
+        return this.consumeInternal(tokType, 4, options);
+    }
+    CONSUME5(tokType, options) {
+        return this.consumeInternal(tokType, 5, options);
+    }
+    CONSUME6(tokType, options) {
+        return this.consumeInternal(tokType, 6, options);
+    }
+    CONSUME7(tokType, options) {
+        return this.consumeInternal(tokType, 7, options);
+    }
+    CONSUME8(tokType, options) {
+        return this.consumeInternal(tokType, 8, options);
+    }
+    CONSUME9(tokType, options) {
+        return this.consumeInternal(tokType, 9, options);
+    }
+    SUBRULE(ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 0, options);
+    }
+    SUBRULE1(ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 1, options);
+    }
+    SUBRULE2(ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 2, options);
+    }
+    SUBRULE3(ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 3, options);
+    }
+    SUBRULE4(ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 4, options);
+    }
+    SUBRULE5(ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 5, options);
+    }
+    SUBRULE6(ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 6, options);
+    }
+    SUBRULE7(ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 7, options);
+    }
+    SUBRULE8(ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 8, options);
+    }
+    SUBRULE9(ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 9, options);
+    }
+    OPTION(actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 0);
+    }
+    OPTION1(actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 1);
+    }
+    OPTION2(actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 2);
+    }
+    OPTION3(actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 3);
+    }
+    OPTION4(actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 4);
+    }
+    OPTION5(actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 5);
+    }
+    OPTION6(actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 6);
+    }
+    OPTION7(actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 7);
+    }
+    OPTION8(actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 8);
+    }
+    OPTION9(actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 9);
+    }
+    OR(altsOrOpts) {
+        return this.orInternal(altsOrOpts, 0);
+    }
+    OR1(altsOrOpts) {
+        return this.orInternal(altsOrOpts, 1);
+    }
+    OR2(altsOrOpts) {
+        return this.orInternal(altsOrOpts, 2);
+    }
+    OR3(altsOrOpts) {
+        return this.orInternal(altsOrOpts, 3);
+    }
+    OR4(altsOrOpts) {
+        return this.orInternal(altsOrOpts, 4);
+    }
+    OR5(altsOrOpts) {
+        return this.orInternal(altsOrOpts, 5);
+    }
+    OR6(altsOrOpts) {
+        return this.orInternal(altsOrOpts, 6);
+    }
+    OR7(altsOrOpts) {
+        return this.orInternal(altsOrOpts, 7);
+    }
+    OR8(altsOrOpts) {
+        return this.orInternal(altsOrOpts, 8);
+    }
+    OR9(altsOrOpts) {
+        return this.orInternal(altsOrOpts, 9);
+    }
+    MANY(actionORMethodDef) {
+        this.manyInternal(0, actionORMethodDef);
+    }
+    MANY1(actionORMethodDef) {
+        this.manyInternal(1, actionORMethodDef);
+    }
+    MANY2(actionORMethodDef) {
+        this.manyInternal(2, actionORMethodDef);
+    }
+    MANY3(actionORMethodDef) {
+        this.manyInternal(3, actionORMethodDef);
+    }
+    MANY4(actionORMethodDef) {
+        this.manyInternal(4, actionORMethodDef);
+    }
+    MANY5(actionORMethodDef) {
+        this.manyInternal(5, actionORMethodDef);
+    }
+    MANY6(actionORMethodDef) {
+        this.manyInternal(6, actionORMethodDef);
+    }
+    MANY7(actionORMethodDef) {
+        this.manyInternal(7, actionORMethodDef);
+    }
+    MANY8(actionORMethodDef) {
+        this.manyInternal(8, actionORMethodDef);
+    }
+    MANY9(actionORMethodDef) {
+        this.manyInternal(9, actionORMethodDef);
+    }
+    MANY_SEP(options) {
+        this.manySepFirstInternal(0, options);
+    }
+    MANY_SEP1(options) {
+        this.manySepFirstInternal(1, options);
+    }
+    MANY_SEP2(options) {
+        this.manySepFirstInternal(2, options);
+    }
+    MANY_SEP3(options) {
+        this.manySepFirstInternal(3, options);
+    }
+    MANY_SEP4(options) {
+        this.manySepFirstInternal(4, options);
+    }
+    MANY_SEP5(options) {
+        this.manySepFirstInternal(5, options);
+    }
+    MANY_SEP6(options) {
+        this.manySepFirstInternal(6, options);
+    }
+    MANY_SEP7(options) {
+        this.manySepFirstInternal(7, options);
+    }
+    MANY_SEP8(options) {
+        this.manySepFirstInternal(8, options);
+    }
+    MANY_SEP9(options) {
+        this.manySepFirstInternal(9, options);
+    }
+    AT_LEAST_ONE(actionORMethodDef) {
+        this.atLeastOneInternal(0, actionORMethodDef);
+    }
+    AT_LEAST_ONE1(actionORMethodDef) {
+        return this.atLeastOneInternal(1, actionORMethodDef);
+    }
+    AT_LEAST_ONE2(actionORMethodDef) {
+        this.atLeastOneInternal(2, actionORMethodDef);
+    }
+    AT_LEAST_ONE3(actionORMethodDef) {
+        this.atLeastOneInternal(3, actionORMethodDef);
+    }
+    AT_LEAST_ONE4(actionORMethodDef) {
+        this.atLeastOneInternal(4, actionORMethodDef);
+    }
+    AT_LEAST_ONE5(actionORMethodDef) {
+        this.atLeastOneInternal(5, actionORMethodDef);
+    }
+    AT_LEAST_ONE6(actionORMethodDef) {
+        this.atLeastOneInternal(6, actionORMethodDef);
+    }
+    AT_LEAST_ONE7(actionORMethodDef) {
+        this.atLeastOneInternal(7, actionORMethodDef);
+    }
+    AT_LEAST_ONE8(actionORMethodDef) {
+        this.atLeastOneInternal(8, actionORMethodDef);
+    }
+    AT_LEAST_ONE9(actionORMethodDef) {
+        this.atLeastOneInternal(9, actionORMethodDef);
+    }
+    AT_LEAST_ONE_SEP(options) {
+        this.atLeastOneSepFirstInternal(0, options);
+    }
+    AT_LEAST_ONE_SEP1(options) {
+        this.atLeastOneSepFirstInternal(1, options);
+    }
+    AT_LEAST_ONE_SEP2(options) {
+        this.atLeastOneSepFirstInternal(2, options);
+    }
+    AT_LEAST_ONE_SEP3(options) {
+        this.atLeastOneSepFirstInternal(3, options);
+    }
+    AT_LEAST_ONE_SEP4(options) {
+        this.atLeastOneSepFirstInternal(4, options);
+    }
+    AT_LEAST_ONE_SEP5(options) {
+        this.atLeastOneSepFirstInternal(5, options);
+    }
+    AT_LEAST_ONE_SEP6(options) {
+        this.atLeastOneSepFirstInternal(6, options);
+    }
+    AT_LEAST_ONE_SEP7(options) {
+        this.atLeastOneSepFirstInternal(7, options);
+    }
+    AT_LEAST_ONE_SEP8(options) {
+        this.atLeastOneSepFirstInternal(8, options);
+    }
+    AT_LEAST_ONE_SEP9(options) {
+        this.atLeastOneSepFirstInternal(9, options);
+    }
+    RULE(name, implementation, config = DEFAULT_RULE_CONFIG) {
+        if (includes(this.definedRulesNames, name)) {
+            const errMsg = defaultGrammarValidatorErrorProvider.buildDuplicateRuleNameError({
+                topLevelRule: name,
+                grammarName: this.className,
+            });
+            const error = {
+                message: errMsg,
+                type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,
+                ruleName: name,
+            };
+            this.definitionErrors.push(error);
+        }
+        this.definedRulesNames.push(name);
+        const ruleImplementation = this.defineRule(name, implementation, config);
+        this[name] = ruleImplementation;
+        return ruleImplementation;
+    }
+    OVERRIDE_RULE(name, impl, config = DEFAULT_RULE_CONFIG) {
+        const ruleErrors = validateRuleIsOverridden(name, this.definedRulesNames, this.className);
+        this.definitionErrors = this.definitionErrors.concat(ruleErrors);
+        const ruleImplementation = this.defineRule(name, impl, config);
+        this[name] = ruleImplementation;
+        return ruleImplementation;
+    }
+    BACKTRACK(grammarRule, args) {
+        return function () {
+            // save org state
+            this.isBackTrackingStack.push(1);
+            const orgState = this.saveRecogState();
+            try {
+                grammarRule.apply(this, args);
+                // if no exception was thrown we have succeed parsing the rule.
+                return true;
+            }
+            catch (e) {
+                if (isRecognitionException(e)) {
+                    return false;
+                }
+                else {
+                    throw e;
+                }
+            }
+            finally {
+                this.reloadRecogState(orgState);
+                this.isBackTrackingStack.pop();
+            }
+        };
+    }
+    // GAST export APIs
+    getGAstProductions() {
+        return this.gastProductionsCache;
+    }
+    getSerializedGastProductions() {
+        return serializeGrammar(values(this.gastProductionsCache));
+    }
+}
+//# sourceMappingURL=recognizer_api.js.map

frontend/node_modules/chevrotain/lib/src/parse/parser/traits/tree_builder.js

@@ -0,0 +1,191 @@
+import { addNoneTerminalToCst, addTerminalToCst, setNodeLocationFull, setNodeLocationOnlyOffset, } from "../../cst/cst.js";
+import { has, isUndefined, keys, noop } from "lodash-es";
+import { createBaseSemanticVisitorConstructor, createBaseVisitorConstructorWithDefaults, } from "../../cst/cst_visitor.js";
+import { DEFAULT_PARSER_CONFIG } from "../parser.js";
+/**
+ * This trait is responsible for the CST building logic.
+ */
+export class TreeBuilder {
+    initTreeBuilder(config) {
+        this.CST_STACK = [];
+        // outputCst is no longer exposed/defined in the pubic API
+        this.outputCst = config.outputCst;
+        this.nodeLocationTracking = has(config, "nodeLocationTracking")
+            ? config.nodeLocationTracking // assumes end user provides the correct config value/type
+            : DEFAULT_PARSER_CONFIG.nodeLocationTracking;
+        if (!this.outputCst) {
+            this.cstInvocationStateUpdate = noop;
+            this.cstFinallyStateUpdate = noop;
+            this.cstPostTerminal = noop;
+            this.cstPostNonTerminal = noop;
+            this.cstPostRule = noop;
+        }
+        else {
+            if (/full/i.test(this.nodeLocationTracking)) {
+                if (this.recoveryEnabled) {
+                    this.setNodeLocationFromToken = setNodeLocationFull;
+                    this.setNodeLocationFromNode = setNodeLocationFull;
+                    this.cstPostRule = noop;
+                    this.setInitialNodeLocation = this.setInitialNodeLocationFullRecovery;
+                }
+                else {
+                    this.setNodeLocationFromToken = noop;
+                    this.setNodeLocationFromNode = noop;
+                    this.cstPostRule = this.cstPostRuleFull;
+                    this.setInitialNodeLocation = this.setInitialNodeLocationFullRegular;
+                }
+            }
+            else if (/onlyOffset/i.test(this.nodeLocationTracking)) {
+                if (this.recoveryEnabled) {
+                    this.setNodeLocationFromToken = setNodeLocationOnlyOffset;
+                    this.setNodeLocationFromNode = setNodeLocationOnlyOffset;
+                    this.cstPostRule = noop;
+                    this.setInitialNodeLocation =
+                        this.setInitialNodeLocationOnlyOffsetRecovery;
+                }
+                else {
+                    this.setNodeLocationFromToken = noop;
+                    this.setNodeLocationFromNode = noop;
+                    this.cstPostRule = this.cstPostRuleOnlyOffset;
+                    this.setInitialNodeLocation =
+                        this.setInitialNodeLocationOnlyOffsetRegular;
+                }
+            }
+            else if (/none/i.test(this.nodeLocationTracking)) {
+                this.setNodeLocationFromToken = noop;
+                this.setNodeLocationFromNode = noop;
+                this.cstPostRule = noop;
+                this.setInitialNodeLocation = noop;
+            }
+            else {
+                throw Error(`Invalid <nodeLocationTracking> config option: "${config.nodeLocationTracking}"`);
+            }
+        }
+    }
+    setInitialNodeLocationOnlyOffsetRecovery(cstNode) {
+        cstNode.location = {
+            startOffset: NaN,
+            endOffset: NaN,
+        };
+    }
+    setInitialNodeLocationOnlyOffsetRegular(cstNode) {
+        cstNode.location = {
+            // without error recovery the starting Location of a new CstNode is guaranteed
+            // To be the next Token's startOffset (for valid inputs).
+            // For invalid inputs there won't be any CSTOutput so this potential
+            // inaccuracy does not matter
+            startOffset: this.LA(1).startOffset,
+            endOffset: NaN,
+        };
+    }
+    setInitialNodeLocationFullRecovery(cstNode) {
+        cstNode.location = {
+            startOffset: NaN,
+            startLine: NaN,
+            startColumn: NaN,
+            endOffset: NaN,
+            endLine: NaN,
+            endColumn: NaN,
+        };
+    }
+    /**
+       *  @see setInitialNodeLocationOnlyOffsetRegular for explanation why this work
+  
+       * @param cstNode
+       */
+    setInitialNodeLocationFullRegular(cstNode) {
+        const nextToken = this.LA(1);
+        cstNode.location = {
+            startOffset: nextToken.startOffset,
+            startLine: nextToken.startLine,
+            startColumn: nextToken.startColumn,
+            endOffset: NaN,
+            endLine: NaN,
+            endColumn: NaN,
+        };
+    }
+    cstInvocationStateUpdate(fullRuleName) {
+        const cstNode = {
+            name: fullRuleName,
+            children: Object.create(null),
+        };
+        this.setInitialNodeLocation(cstNode);
+        this.CST_STACK.push(cstNode);
+    }
+    cstFinallyStateUpdate() {
+        this.CST_STACK.pop();
+    }
+    cstPostRuleFull(ruleCstNode) {
+        // casts to `required<CstNodeLocation>` are safe because `cstPostRuleFull` should only be invoked when full location is enabled
+        const prevToken = this.LA(0);
+        const loc = ruleCstNode.location;
+        // If this condition is true it means we consumed at least one Token
+        // In this CstNode.
+        if (loc.startOffset <= prevToken.startOffset === true) {
+            loc.endOffset = prevToken.endOffset;
+            loc.endLine = prevToken.endLine;
+            loc.endColumn = prevToken.endColumn;
+        }
+        // "empty" CstNode edge case
+        else {
+            loc.startOffset = NaN;
+            loc.startLine = NaN;
+            loc.startColumn = NaN;
+        }
+    }
+    cstPostRuleOnlyOffset(ruleCstNode) {
+        const prevToken = this.LA(0);
+        // `location' is not null because `cstPostRuleOnlyOffset` will only be invoked when location tracking is enabled.
+        const loc = ruleCstNode.location;
+        // If this condition is true it means we consumed at least one Token
+        // In this CstNode.
+        if (loc.startOffset <= prevToken.startOffset === true) {
+            loc.endOffset = prevToken.endOffset;
+        }
+        // "empty" CstNode edge case
+        else {
+            loc.startOffset = NaN;
+        }
+    }
+    cstPostTerminal(key, consumedToken) {
+        const rootCst = this.CST_STACK[this.CST_STACK.length - 1];
+        addTerminalToCst(rootCst, consumedToken, key);
+        // This is only used when **both** error recovery and CST Output are enabled.
+        this.setNodeLocationFromToken(rootCst.location, consumedToken);
+    }
+    cstPostNonTerminal(ruleCstResult, ruleName) {
+        const preCstNode = this.CST_STACK[this.CST_STACK.length - 1];
+        addNoneTerminalToCst(preCstNode, ruleName, ruleCstResult);
+        // This is only used when **both** error recovery and CST Output are enabled.
+        this.setNodeLocationFromNode(preCstNode.location, ruleCstResult.location);
+    }
+    getBaseCstVisitorConstructor() {
+        if (isUndefined(this.baseCstVisitorConstructor)) {
+            const newBaseCstVisitorConstructor = createBaseSemanticVisitorConstructor(this.className, keys(this.gastProductionsCache));
+            this.baseCstVisitorConstructor = newBaseCstVisitorConstructor;
+            return newBaseCstVisitorConstructor;
+        }
+        return this.baseCstVisitorConstructor;
+    }
+    getBaseCstVisitorConstructorWithDefaults() {
+        if (isUndefined(this.baseCstVisitorWithDefaultsConstructor)) {
+            const newConstructor = createBaseVisitorConstructorWithDefaults(this.className, keys(this.gastProductionsCache), this.getBaseCstVisitorConstructor());
+            this.baseCstVisitorWithDefaultsConstructor = newConstructor;
+            return newConstructor;
+        }
+        return this.baseCstVisitorWithDefaultsConstructor;
+    }
+    getLastExplicitRuleShortName() {
+        const ruleStack = this.RULE_STACK;
+        return ruleStack[ruleStack.length - 1];
+    }
+    getPreviousExplicitRuleShortName() {
+        const ruleStack = this.RULE_STACK;
+        return ruleStack[ruleStack.length - 2];
+    }
+    getLastExplicitRuleOccurrenceIndex() {
+        const occurrenceStack = this.RULE_OCCURRENCE_STACK;
+        return occurrenceStack[occurrenceStack.length - 1];
+    }
+}
+//# sourceMappingURL=tree_builder.js.map

frontend/node_modules/chevrotain/lib/src/parse/parser/utils/apply_mixins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply_mixins.js","sourceRoot":"","sources":["../../../../../src/parse/parser/utils/apply_mixins.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,WAAW,CAAC,WAAgB,EAAE,SAAgB;IAC5D,SAAS,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;QAC7B,MAAM,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;QACrC,MAAM,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;YACzD,IAAI,QAAQ,KAAK,aAAa,EAAE,CAAC;gBAC/B,OAAO;YACT,CAAC;YAED,MAAM,kBAAkB,GAAG,MAAM,CAAC,wBAAwB,CACxD,SAAS,EACT,QAAQ,CACT,CAAC;YACF,mBAAmB;YACnB,IACE,kBAAkB;gBAClB,CAAC,kBAAkB,CAAC,GAAG,IAAI,kBAAkB,CAAC,GAAG,CAAC,EAClD,CAAC;gBACD,MAAM,CAAC,cAAc,CACnB,WAAW,CAAC,SAAS,EACrB,QAAQ,EACR,kBAAkB,CACnB,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,WAAW,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YACjE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}