qidian-vue-ui 1.1.55 → 1.1.57

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/interpreter.mjs

@@ -1,431 +0,0 @@
-import { first } from "./first.mjs";
-import { RestWalker } from "./rest.mjs";
-import { Alternative, NonTerminal, Option, RepetitionMandatory, Repetition, RepetitionMandatoryWithSeparator, Terminal, RepetitionWithSeparator, Alternation, Rule } from "../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs";
-import clone from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clone.mjs";
-import forEach from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
-import drop from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/drop.mjs";
-import isEmpty from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.mjs";
-import dropRight from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/dropRight.mjs";
-import last from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/last.mjs";
-import head from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/head.mjs";
-class AbstractNextPossibleTokensWalker extends RestWalker {
-  constructor(topProd, path) {
-    super();
-    this.topProd = topProd;
-    this.path = path;
-    this.possibleTokTypes = [];
-    this.nextProductionName = "";
-    this.nextProductionOccurrence = 0;
-    this.found = false;
-    this.isAtEndOfPath = false;
-  }
-  startWalking() {
-    this.found = false;
-    if (this.path.ruleStack[0] !== this.topProd.name) {
-      throw Error("The path does not start with the walker's top Rule!");
-    }
-    this.ruleStack = clone(this.path.ruleStack).reverse();
-    this.occurrenceStack = clone(this.path.occurrenceStack).reverse();
-    this.ruleStack.pop();
-    this.occurrenceStack.pop();
-    this.updateExpectedNext();
-    this.walk(this.topProd);
-    return this.possibleTokTypes;
-  }
-  walk(prod, prevRest = []) {
-    if (!this.found) {
-      super.walk(prod, prevRest);
-    }
-  }
-  walkProdRef(refProd, currRest, prevRest) {
-    if (refProd.referencedRule.name === this.nextProductionName && refProd.idx === this.nextProductionOccurrence) {
-      const fullRest = currRest.concat(prevRest);
-      this.updateExpectedNext();
-      this.walk(refProd.referencedRule, fullRest);
-    }
-  }
-  updateExpectedNext() {
-    if (isEmpty(this.ruleStack)) {
-      this.nextProductionName = "";
-      this.nextProductionOccurrence = 0;
-      this.isAtEndOfPath = true;
-    } else {
-      this.nextProductionName = this.ruleStack.pop();
-      this.nextProductionOccurrence = this.occurrenceStack.pop();
-    }
-  }
-}
-class NextAfterTokenWalker extends AbstractNextPossibleTokensWalker {
-  constructor(topProd, path) {
-    super(topProd, path);
-    this.path = path;
-    this.nextTerminalName = "";
-    this.nextTerminalOccurrence = 0;
-    this.nextTerminalName = this.path.lastTok.name;
-    this.nextTerminalOccurrence = this.path.lastTokOccurrence;
-  }
-  walkTerminal(terminal, currRest, prevRest) {
-    if (this.isAtEndOfPath && terminal.terminalType.name === this.nextTerminalName && terminal.idx === this.nextTerminalOccurrence && !this.found) {
-      const fullRest = currRest.concat(prevRest);
-      const restProd = new Alternative({ definition: fullRest });
-      this.possibleTokTypes = first(restProd);
-      this.found = true;
-    }
-  }
-}
-class AbstractNextTerminalAfterProductionWalker extends RestWalker {
-  constructor(topRule, occurrence) {
-    super();
-    this.topRule = topRule;
-    this.occurrence = occurrence;
-    this.result = {
-      token: void 0,
-      occurrence: void 0,
-      isEndOfRule: void 0
-    };
-  }
-  startWalking() {
-    this.walk(this.topRule);
-    return this.result;
-  }
-}
-class NextTerminalAfterManyWalker extends AbstractNextTerminalAfterProductionWalker {
-  walkMany(manyProd, currRest, prevRest) {
-    if (manyProd.idx === this.occurrence) {
-      const firstAfterMany = head(currRest.concat(prevRest));
-      this.result.isEndOfRule = firstAfterMany === void 0;
-      if (firstAfterMany instanceof Terminal) {
-        this.result.token = firstAfterMany.terminalType;
-        this.result.occurrence = firstAfterMany.idx;
-      }
-    } else {
-      super.walkMany(manyProd, currRest, prevRest);
-    }
-  }
-}
-class NextTerminalAfterManySepWalker extends AbstractNextTerminalAfterProductionWalker {
-  walkManySep(manySepProd, currRest, prevRest) {
-    if (manySepProd.idx === this.occurrence) {
-      const firstAfterManySep = head(currRest.concat(prevRest));
-      this.result.isEndOfRule = firstAfterManySep === void 0;
-      if (firstAfterManySep instanceof Terminal) {
-        this.result.token = firstAfterManySep.terminalType;
-        this.result.occurrence = firstAfterManySep.idx;
-      }
-    } else {
-      super.walkManySep(manySepProd, currRest, prevRest);
-    }
-  }
-}
-class NextTerminalAfterAtLeastOneWalker extends AbstractNextTerminalAfterProductionWalker {
-  walkAtLeastOne(atLeastOneProd, currRest, prevRest) {
-    if (atLeastOneProd.idx === this.occurrence) {
-      const firstAfterAtLeastOne = head(currRest.concat(prevRest));
-      this.result.isEndOfRule = firstAfterAtLeastOne === void 0;
-      if (firstAfterAtLeastOne instanceof Terminal) {
-        this.result.token = firstAfterAtLeastOne.terminalType;
-        this.result.occurrence = firstAfterAtLeastOne.idx;
-      }
-    } else {
-      super.walkAtLeastOne(atLeastOneProd, currRest, prevRest);
-    }
-  }
-}
-class NextTerminalAfterAtLeastOneSepWalker extends AbstractNextTerminalAfterProductionWalker {
-  walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest) {
-    if (atleastOneSepProd.idx === this.occurrence) {
-      const firstAfterfirstAfterAtLeastOneSep = head(currRest.concat(prevRest));
-      this.result.isEndOfRule = firstAfterfirstAfterAtLeastOneSep === void 0;
-      if (firstAfterfirstAfterAtLeastOneSep instanceof Terminal) {
-        this.result.token = firstAfterfirstAfterAtLeastOneSep.terminalType;
-        this.result.occurrence = firstAfterfirstAfterAtLeastOneSep.idx;
-      }
-    } else {
-      super.walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest);
-    }
-  }
-}
-function possiblePathsFrom(targetDef, maxLength, currPath = []) {
-  currPath = clone(currPath);
-  let result = [];
-  let i = 0;
-  function remainingPathWith(nextDef) {
-    return nextDef.concat(drop(targetDef, i + 1));
-  }
-  function getAlternativesForProd(definition) {
-    const alternatives = possiblePathsFrom(remainingPathWith(definition), maxLength, currPath);
-    return result.concat(alternatives);
-  }
-  while (currPath.length < maxLength && i < targetDef.length) {
-    const prod = targetDef[i];
-    if (prod instanceof Alternative) {
-      return getAlternativesForProd(prod.definition);
-    } else if (prod instanceof NonTerminal) {
-      return getAlternativesForProd(prod.definition);
-    } else if (prod instanceof Option) {
-      result = getAlternativesForProd(prod.definition);
-    } else if (prod instanceof RepetitionMandatory) {
-      const newDef = prod.definition.concat([
-        new Repetition({
-          definition: prod.definition
-        })
-      ]);
-      return getAlternativesForProd(newDef);
-    } else if (prod instanceof RepetitionMandatoryWithSeparator) {
-      const newDef = [
-        new Alternative({ definition: prod.definition }),
-        new Repetition({
-          definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition)
-        })
-      ];
-      return getAlternativesForProd(newDef);
-    } else if (prod instanceof RepetitionWithSeparator) {
-      const newDef = prod.definition.concat([
-        new Repetition({
-          definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition)
-        })
-      ]);
-      result = getAlternativesForProd(newDef);
-    } else if (prod instanceof Repetition) {
-      const newDef = prod.definition.concat([
-        new Repetition({
-          definition: prod.definition
-        })
-      ]);
-      result = getAlternativesForProd(newDef);
-    } else if (prod instanceof Alternation) {
-      forEach(prod.definition, (currAlt) => {
-        if (isEmpty(currAlt.definition) === false) {
-          result = getAlternativesForProd(currAlt.definition);
-        }
-      });
-      return result;
-    } else if (prod instanceof Terminal) {
-      currPath.push(prod.terminalType);
-    } else {
-      throw Error("non exhaustive match");
-    }
-    i++;
-  }
-  result.push({
-    partialPath: currPath,
-    suffixDef: drop(targetDef, i)
-  });
-  return result;
-}
-function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhead) {
-  const EXIT_NON_TERMINAL = "EXIT_NONE_TERMINAL";
-  const EXIT_NON_TERMINAL_ARR = [EXIT_NON_TERMINAL];
-  const EXIT_ALTERNATIVE = "EXIT_ALTERNATIVE";
-  let foundCompletePath = false;
-  const tokenVectorLength = tokenVector.length;
-  const minimalAlternativesIndex = tokenVectorLength - maxLookAhead - 1;
-  const result = [];
-  const possiblePaths = [];
-  possiblePaths.push({
-    idx: -1,
-    def: initialDef,
-    ruleStack: [],
-    occurrenceStack: []
-  });
-  while (!isEmpty(possiblePaths)) {
-    const currPath = possiblePaths.pop();
-    if (currPath === EXIT_ALTERNATIVE) {
-      if (foundCompletePath && last(possiblePaths).idx <= minimalAlternativesIndex) {
-        possiblePaths.pop();
-      }
-      continue;
-    }
-    const currDef = currPath.def;
-    const currIdx = currPath.idx;
-    const currRuleStack = currPath.ruleStack;
-    const currOccurrenceStack = currPath.occurrenceStack;
-    if (isEmpty(currDef)) {
-      continue;
-    }
-    const prod = currDef[0];
-    if (prod === EXIT_NON_TERMINAL) {
-      const nextPath = {
-        idx: currIdx,
-        def: drop(currDef),
-        ruleStack: dropRight(currRuleStack),
-        occurrenceStack: dropRight(currOccurrenceStack)
-      };
-      possiblePaths.push(nextPath);
-    } else if (prod instanceof Terminal) {
-      if (currIdx < tokenVectorLength - 1) {
-        const nextIdx = currIdx + 1;
-        const actualToken = tokenVector[nextIdx];
-        if (tokMatcher(actualToken, prod.terminalType)) {
-          const nextPath = {
-            idx: nextIdx,
-            def: drop(currDef),
-            ruleStack: currRuleStack,
-            occurrenceStack: currOccurrenceStack
-          };
-          possiblePaths.push(nextPath);
-        }
-      } else if (currIdx === tokenVectorLength - 1) {
-        result.push({
-          nextTokenType: prod.terminalType,
-          nextTokenOccurrence: prod.idx,
-          ruleStack: currRuleStack,
-          occurrenceStack: currOccurrenceStack
-        });
-        foundCompletePath = true;
-      } else {
-        throw Error("non exhaustive match");
-      }
-    } else if (prod instanceof NonTerminal) {
-      const newRuleStack = clone(currRuleStack);
-      newRuleStack.push(prod.nonTerminalName);
-      const newOccurrenceStack = clone(currOccurrenceStack);
-      newOccurrenceStack.push(prod.idx);
-      const nextPath = {
-        idx: currIdx,
-        def: prod.definition.concat(EXIT_NON_TERMINAL_ARR, drop(currDef)),
-        ruleStack: newRuleStack,
-        occurrenceStack: newOccurrenceStack
-      };
-      possiblePaths.push(nextPath);
-    } else if (prod instanceof Option) {
-      const nextPathWithout = {
-        idx: currIdx,
-        def: drop(currDef),
-        ruleStack: currRuleStack,
-        occurrenceStack: currOccurrenceStack
-      };
-      possiblePaths.push(nextPathWithout);
-      possiblePaths.push(EXIT_ALTERNATIVE);
-      const nextPathWith = {
-        idx: currIdx,
-        def: prod.definition.concat(drop(currDef)),
-        ruleStack: currRuleStack,
-        occurrenceStack: currOccurrenceStack
-      };
-      possiblePaths.push(nextPathWith);
-    } else if (prod instanceof RepetitionMandatory) {
-      const secondIteration = new Repetition({
-        definition: prod.definition,
-        idx: prod.idx
-      });
-      const nextDef = prod.definition.concat([secondIteration], drop(currDef));
-      const nextPath = {
-        idx: currIdx,
-        def: nextDef,
-        ruleStack: currRuleStack,
-        occurrenceStack: currOccurrenceStack
-      };
-      possiblePaths.push(nextPath);
-    } else if (prod instanceof RepetitionMandatoryWithSeparator) {
-      const separatorGast = new Terminal({
-        terminalType: prod.separator
-      });
-      const secondIteration = new Repetition({
-        definition: [separatorGast].concat(prod.definition),
-        idx: prod.idx
-      });
-      const nextDef = prod.definition.concat([secondIteration], drop(currDef));
-      const nextPath = {
-        idx: currIdx,
-        def: nextDef,
-        ruleStack: currRuleStack,
-        occurrenceStack: currOccurrenceStack
-      };
-      possiblePaths.push(nextPath);
-    } else if (prod instanceof RepetitionWithSeparator) {
-      const nextPathWithout = {
-        idx: currIdx,
-        def: drop(currDef),
-        ruleStack: currRuleStack,
-        occurrenceStack: currOccurrenceStack
-      };
-      possiblePaths.push(nextPathWithout);
-      possiblePaths.push(EXIT_ALTERNATIVE);
-      const separatorGast = new Terminal({
-        terminalType: prod.separator
-      });
-      const nthRepetition = new Repetition({
-        definition: [separatorGast].concat(prod.definition),
-        idx: prod.idx
-      });
-      const nextDef = prod.definition.concat([nthRepetition], drop(currDef));
-      const nextPathWith = {
-        idx: currIdx,
-        def: nextDef,
-        ruleStack: currRuleStack,
-        occurrenceStack: currOccurrenceStack
-      };
-      possiblePaths.push(nextPathWith);
-    } else if (prod instanceof Repetition) {
-      const nextPathWithout = {
-        idx: currIdx,
-        def: drop(currDef),
-        ruleStack: currRuleStack,
-        occurrenceStack: currOccurrenceStack
-      };
-      possiblePaths.push(nextPathWithout);
-      possiblePaths.push(EXIT_ALTERNATIVE);
-      const nthRepetition = new Repetition({
-        definition: prod.definition,
-        idx: prod.idx
-      });
-      const nextDef = prod.definition.concat([nthRepetition], drop(currDef));
-      const nextPathWith = {
-        idx: currIdx,
-        def: nextDef,
-        ruleStack: currRuleStack,
-        occurrenceStack: currOccurrenceStack
-      };
-      possiblePaths.push(nextPathWith);
-    } else if (prod instanceof Alternation) {
-      for (let i = prod.definition.length - 1; i >= 0; i--) {
-        const currAlt = prod.definition[i];
-        const currAltPath = {
-          idx: currIdx,
-          def: currAlt.definition.concat(drop(currDef)),
-          ruleStack: currRuleStack,
-          occurrenceStack: currOccurrenceStack
-        };
-        possiblePaths.push(currAltPath);
-        possiblePaths.push(EXIT_ALTERNATIVE);
-      }
-    } else if (prod instanceof Alternative) {
-      possiblePaths.push({
-        idx: currIdx,
-        def: prod.definition.concat(drop(currDef)),
-        ruleStack: currRuleStack,
-        occurrenceStack: currOccurrenceStack
-      });
-    } else if (prod instanceof Rule) {
-      possiblePaths.push(expandTopLevelRule(prod, currIdx, currRuleStack, currOccurrenceStack));
-    } else {
-      throw Error("non exhaustive match");
-    }
-  }
-  return result;
-}
-function expandTopLevelRule(topRule, currIdx, currRuleStack, currOccurrenceStack) {
-  const newRuleStack = clone(currRuleStack);
-  newRuleStack.push(topRule.name);
-  const newCurrOccurrenceStack = clone(currOccurrenceStack);
-  newCurrOccurrenceStack.push(1);
-  return {
-    idx: currIdx,
-    def: topRule.definition,
-    ruleStack: newRuleStack,
-    occurrenceStack: newCurrOccurrenceStack
-  };
-}
-export {
-  AbstractNextPossibleTokensWalker,
-  AbstractNextTerminalAfterProductionWalker,
-  NextAfterTokenWalker,
-  NextTerminalAfterAtLeastOneSepWalker,
-  NextTerminalAfterAtLeastOneWalker,
-  NextTerminalAfterManySepWalker,
-  NextTerminalAfterManyWalker,
-  nextPossibleTokensAfter,
-  possiblePathsFrom
-};
-//# sourceMappingURL=interpreter.mjs.map

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/interpreter.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"interpreter.mjs","sources":["../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/interpreter.js"],"sourcesContent":["import { clone, drop, dropRight, first as _first, forEach, isEmpty, last, } from \"lodash-es\";\nimport { first } from \"./first.js\";\nimport { RestWalker } from \"./rest.js\";\nimport { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal, } from \"@chevrotain/gast\";\nexport class AbstractNextPossibleTokensWalker extends RestWalker {\n    constructor(topProd, path) {\n        super();\n        this.topProd = topProd;\n        this.path = path;\n        this.possibleTokTypes = [];\n        this.nextProductionName = \"\";\n        this.nextProductionOccurrence = 0;\n        this.found = false;\n        this.isAtEndOfPath = false;\n    }\n    startWalking() {\n        this.found = false;\n        if (this.path.ruleStack[0] !== this.topProd.name) {\n            throw Error(\"The path does not start with the walker's top Rule!\");\n        }\n        // immutable for the win\n        this.ruleStack = clone(this.path.ruleStack).reverse(); // intelij bug requires assertion\n        this.occurrenceStack = clone(this.path.occurrenceStack).reverse(); // intelij bug requires assertion\n        // already verified that the first production is valid, we now seek the 2nd production\n        this.ruleStack.pop();\n        this.occurrenceStack.pop();\n        this.updateExpectedNext();\n        this.walk(this.topProd);\n        return this.possibleTokTypes;\n    }\n    walk(prod, prevRest = []) {\n        // stop scanning once we found the path\n        if (!this.found) {\n            super.walk(prod, prevRest);\n        }\n    }\n    walkProdRef(refProd, currRest, prevRest) {\n        // found the next production, need to keep walking in it\n        if (refProd.referencedRule.name === this.nextProductionName &&\n            refProd.idx === this.nextProductionOccurrence) {\n            const fullRest = currRest.concat(prevRest);\n            this.updateExpectedNext();\n            this.walk(refProd.referencedRule, fullRest);\n        }\n    }\n    updateExpectedNext() {\n        // need to consume the Terminal\n        if (isEmpty(this.ruleStack)) {\n            // must reset nextProductionXXX to avoid walking down another Top Level production while what we are\n            // really seeking is the last Terminal...\n            this.nextProductionName = \"\";\n            this.nextProductionOccurrence = 0;\n            this.isAtEndOfPath = true;\n        }\n        else {\n            this.nextProductionName = this.ruleStack.pop();\n            this.nextProductionOccurrence = this.occurrenceStack.pop();\n        }\n    }\n}\nexport class NextAfterTokenWalker extends AbstractNextPossibleTokensWalker {\n    constructor(topProd, path) {\n        super(topProd, path);\n        this.path = path;\n        this.nextTerminalName = \"\";\n        this.nextTerminalOccurrence = 0;\n        this.nextTerminalName = this.path.lastTok.name;\n        this.nextTerminalOccurrence = this.path.lastTokOccurrence;\n    }\n    walkTerminal(terminal, currRest, prevRest) {\n        if (this.isAtEndOfPath &&\n            terminal.terminalType.name === this.nextTerminalName &&\n            terminal.idx === this.nextTerminalOccurrence &&\n            !this.found) {\n            const fullRest = currRest.concat(prevRest);\n            const restProd = new Alternative({ definition: fullRest });\n            this.possibleTokTypes = first(restProd);\n            this.found = true;\n        }\n    }\n}\n/**\n * This walker only \"walks\" a single \"TOP\" level in the Grammar Ast, this means\n * it never \"follows\" production refs\n */\nexport class AbstractNextTerminalAfterProductionWalker extends RestWalker {\n    constructor(topRule, occurrence) {\n        super();\n        this.topRule = topRule;\n        this.occurrence = occurrence;\n        this.result = {\n            token: undefined,\n            occurrence: undefined,\n            isEndOfRule: undefined,\n        };\n    }\n    startWalking() {\n        this.walk(this.topRule);\n        return this.result;\n    }\n}\nexport class NextTerminalAfterManyWalker extends AbstractNextTerminalAfterProductionWalker {\n    walkMany(manyProd, currRest, prevRest) {\n        if (manyProd.idx === this.occurrence) {\n            const firstAfterMany = _first(currRest.concat(prevRest));\n            this.result.isEndOfRule = firstAfterMany === undefined;\n            if (firstAfterMany instanceof Terminal) {\n                this.result.token = firstAfterMany.terminalType;\n                this.result.occurrence = firstAfterMany.idx;\n            }\n        }\n        else {\n            super.walkMany(manyProd, currRest, prevRest);\n        }\n    }\n}\nexport class NextTerminalAfterManySepWalker extends AbstractNextTerminalAfterProductionWalker {\n    walkManySep(manySepProd, currRest, prevRest) {\n        if (manySepProd.idx === this.occurrence) {\n            const firstAfterManySep = _first(currRest.concat(prevRest));\n            this.result.isEndOfRule = firstAfterManySep === undefined;\n            if (firstAfterManySep instanceof Terminal) {\n                this.result.token = firstAfterManySep.terminalType;\n                this.result.occurrence = firstAfterManySep.idx;\n            }\n        }\n        else {\n            super.walkManySep(manySepProd, currRest, prevRest);\n        }\n    }\n}\nexport class NextTerminalAfterAtLeastOneWalker extends AbstractNextTerminalAfterProductionWalker {\n    walkAtLeastOne(atLeastOneProd, currRest, prevRest) {\n        if (atLeastOneProd.idx === this.occurrence) {\n            const firstAfterAtLeastOne = _first(currRest.concat(prevRest));\n            this.result.isEndOfRule = firstAfterAtLeastOne === undefined;\n            if (firstAfterAtLeastOne instanceof Terminal) {\n                this.result.token = firstAfterAtLeastOne.terminalType;\n                this.result.occurrence = firstAfterAtLeastOne.idx;\n            }\n        }\n        else {\n            super.walkAtLeastOne(atLeastOneProd, currRest, prevRest);\n        }\n    }\n}\n// TODO: reduce code duplication in the AfterWalkers\nexport class NextTerminalAfterAtLeastOneSepWalker extends AbstractNextTerminalAfterProductionWalker {\n    walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest) {\n        if (atleastOneSepProd.idx === this.occurrence) {\n            const firstAfterfirstAfterAtLeastOneSep = _first(currRest.concat(prevRest));\n            this.result.isEndOfRule = firstAfterfirstAfterAtLeastOneSep === undefined;\n            if (firstAfterfirstAfterAtLeastOneSep instanceof Terminal) {\n                this.result.token = firstAfterfirstAfterAtLeastOneSep.terminalType;\n                this.result.occurrence = firstAfterfirstAfterAtLeastOneSep.idx;\n            }\n        }\n        else {\n            super.walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest);\n        }\n    }\n}\nexport function possiblePathsFrom(targetDef, maxLength, currPath = []) {\n    // avoid side effects\n    currPath = clone(currPath);\n    let result = [];\n    let i = 0;\n    // TODO: avoid inner funcs\n    function remainingPathWith(nextDef) {\n        return nextDef.concat(drop(targetDef, i + 1));\n    }\n    // TODO: avoid inner funcs\n    function getAlternativesForProd(definition) {\n        const alternatives = possiblePathsFrom(remainingPathWith(definition), maxLength, currPath);\n        return result.concat(alternatives);\n    }\n    /**\n     * Mandatory productions will halt the loop as the paths computed from their recursive calls will already contain the\n     * following (rest) of the targetDef.\n     *\n     * For optional productions (Option/Repetition/...) the loop will continue to represent the paths that do not include the\n     * the optional production.\n     */\n    while (currPath.length < maxLength && i < targetDef.length) {\n        const prod = targetDef[i];\n        /* istanbul ignore else */\n        if (prod instanceof Alternative) {\n            return getAlternativesForProd(prod.definition);\n        }\n        else if (prod instanceof NonTerminal) {\n            return getAlternativesForProd(prod.definition);\n        }\n        else if (prod instanceof Option) {\n            result = getAlternativesForProd(prod.definition);\n        }\n        else if (prod instanceof RepetitionMandatory) {\n            const newDef = prod.definition.concat([\n                new Repetition({\n                    definition: prod.definition,\n                }),\n            ]);\n            return getAlternativesForProd(newDef);\n        }\n        else if (prod instanceof RepetitionMandatoryWithSeparator) {\n            const newDef = [\n                new Alternative({ definition: prod.definition }),\n                new Repetition({\n                    definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition),\n                }),\n            ];\n            return getAlternativesForProd(newDef);\n        }\n        else if (prod instanceof RepetitionWithSeparator) {\n            const newDef = prod.definition.concat([\n                new Repetition({\n                    definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition),\n                }),\n            ]);\n            result = getAlternativesForProd(newDef);\n        }\n        else if (prod instanceof Repetition) {\n            const newDef = prod.definition.concat([\n                new Repetition({\n                    definition: prod.definition,\n                }),\n            ]);\n            result = getAlternativesForProd(newDef);\n        }\n        else if (prod instanceof Alternation) {\n            forEach(prod.definition, (currAlt) => {\n                // TODO: this is a limited check for empty alternatives\n                //   It would prevent a common case of infinite loops during parser initialization.\n                //   However **in-directly** empty alternatives may still cause issues.\n                if (isEmpty(currAlt.definition) === false) {\n                    result = getAlternativesForProd(currAlt.definition);\n                }\n            });\n            return result;\n        }\n        else if (prod instanceof Terminal) {\n            currPath.push(prod.terminalType);\n        }\n        else {\n            throw Error(\"non exhaustive match\");\n        }\n        i++;\n    }\n    result.push({\n        partialPath: currPath,\n        suffixDef: drop(targetDef, i),\n    });\n    return result;\n}\nexport function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhead) {\n    const EXIT_NON_TERMINAL = \"EXIT_NONE_TERMINAL\";\n    // to avoid creating a new Array each time.\n    const EXIT_NON_TERMINAL_ARR = [EXIT_NON_TERMINAL];\n    const EXIT_ALTERNATIVE = \"EXIT_ALTERNATIVE\";\n    let foundCompletePath = false;\n    const tokenVectorLength = tokenVector.length;\n    const minimalAlternativesIndex = tokenVectorLength - maxLookAhead - 1;\n    const result = [];\n    const possiblePaths = [];\n    possiblePaths.push({\n        idx: -1,\n        def: initialDef,\n        ruleStack: [],\n        occurrenceStack: [],\n    });\n    while (!isEmpty(possiblePaths)) {\n        const currPath = possiblePaths.pop();\n        // skip alternatives if no more results can be found (assuming deterministic grammar with fixed lookahead)\n        if (currPath === EXIT_ALTERNATIVE) {\n            if (foundCompletePath &&\n                last(possiblePaths).idx <= minimalAlternativesIndex) {\n                // remove irrelevant alternative\n                possiblePaths.pop();\n            }\n            continue;\n        }\n        const currDef = currPath.def;\n        const currIdx = currPath.idx;\n        const currRuleStack = currPath.ruleStack;\n        const currOccurrenceStack = currPath.occurrenceStack;\n        // For Example: an empty path could exist in a valid grammar in the case of an EMPTY_ALT\n        if (isEmpty(currDef)) {\n            continue;\n        }\n        const prod = currDef[0];\n        /* istanbul ignore else */\n        if (prod === EXIT_NON_TERMINAL) {\n            const nextPath = {\n                idx: currIdx,\n                def: drop(currDef),\n                ruleStack: dropRight(currRuleStack),\n                occurrenceStack: dropRight(currOccurrenceStack),\n            };\n            possiblePaths.push(nextPath);\n        }\n        else if (prod instanceof Terminal) {\n            /* istanbul ignore else */\n            if (currIdx < tokenVectorLength - 1) {\n                const nextIdx = currIdx + 1;\n                const actualToken = tokenVector[nextIdx];\n                if (tokMatcher(actualToken, prod.terminalType)) {\n                    const nextPath = {\n                        idx: nextIdx,\n                        def: drop(currDef),\n                        ruleStack: currRuleStack,\n                        occurrenceStack: currOccurrenceStack,\n                    };\n                    possiblePaths.push(nextPath);\n                }\n                // end of the line\n            }\n            else if (currIdx === tokenVectorLength - 1) {\n                // IGNORE ABOVE ELSE\n                result.push({\n                    nextTokenType: prod.terminalType,\n                    nextTokenOccurrence: prod.idx,\n                    ruleStack: currRuleStack,\n                    occurrenceStack: currOccurrenceStack,\n                });\n                foundCompletePath = true;\n            }\n            else {\n                throw Error(\"non exhaustive match\");\n            }\n        }\n        else if (prod instanceof NonTerminal) {\n            const newRuleStack = clone(currRuleStack);\n            newRuleStack.push(prod.nonTerminalName);\n            const newOccurrenceStack = clone(currOccurrenceStack);\n            newOccurrenceStack.push(prod.idx);\n            const nextPath = {\n                idx: currIdx,\n                def: prod.definition.concat(EXIT_NON_TERMINAL_ARR, drop(currDef)),\n                ruleStack: newRuleStack,\n                occurrenceStack: newOccurrenceStack,\n            };\n            possiblePaths.push(nextPath);\n        }\n        else if (prod instanceof Option) {\n            // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n            const nextPathWithout = {\n                idx: currIdx,\n                def: drop(currDef),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWithout);\n            // required marker to avoid backtracking paths whose higher priority alternatives already matched\n            possiblePaths.push(EXIT_ALTERNATIVE);\n            const nextPathWith = {\n                idx: currIdx,\n                def: prod.definition.concat(drop(currDef)),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWith);\n        }\n        else if (prod instanceof RepetitionMandatory) {\n            // TODO:(THE NEW operators here take a while...) (convert once?)\n            const secondIteration = new Repetition({\n                definition: prod.definition,\n                idx: prod.idx,\n            });\n            const nextDef = prod.definition.concat([secondIteration], drop(currDef));\n            const nextPath = {\n                idx: currIdx,\n                def: nextDef,\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPath);\n        }\n        else if (prod instanceof RepetitionMandatoryWithSeparator) {\n            // TODO:(THE NEW operators here take a while...) (convert once?)\n            const separatorGast = new Terminal({\n                terminalType: prod.separator,\n            });\n            const secondIteration = new Repetition({\n                definition: [separatorGast].concat(prod.definition),\n                idx: prod.idx,\n            });\n            const nextDef = prod.definition.concat([secondIteration], drop(currDef));\n            const nextPath = {\n                idx: currIdx,\n                def: nextDef,\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPath);\n        }\n        else if (prod instanceof RepetitionWithSeparator) {\n            // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n            const nextPathWithout = {\n                idx: currIdx,\n                def: drop(currDef),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWithout);\n            // required marker to avoid backtracking paths whose higher priority alternatives already matched\n            possiblePaths.push(EXIT_ALTERNATIVE);\n            const separatorGast = new Terminal({\n                terminalType: prod.separator,\n            });\n            const nthRepetition = new Repetition({\n                definition: [separatorGast].concat(prod.definition),\n                idx: prod.idx,\n            });\n            const nextDef = prod.definition.concat([nthRepetition], drop(currDef));\n            const nextPathWith = {\n                idx: currIdx,\n                def: nextDef,\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWith);\n        }\n        else if (prod instanceof Repetition) {\n            // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n            const nextPathWithout = {\n                idx: currIdx,\n                def: drop(currDef),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWithout);\n            // required marker to avoid backtracking paths whose higher priority alternatives already matched\n            possiblePaths.push(EXIT_ALTERNATIVE);\n            // TODO: an empty repetition will cause infinite loops here, will the parser detect this in selfAnalysis?\n            const nthRepetition = new Repetition({\n                definition: prod.definition,\n                idx: prod.idx,\n            });\n            const nextDef = prod.definition.concat([nthRepetition], drop(currDef));\n            const nextPathWith = {\n                idx: currIdx,\n                def: nextDef,\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWith);\n        }\n        else if (prod instanceof Alternation) {\n            // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n            for (let i = prod.definition.length - 1; i >= 0; i--) {\n                const currAlt = prod.definition[i];\n                const currAltPath = {\n                    idx: currIdx,\n                    def: currAlt.definition.concat(drop(currDef)),\n                    ruleStack: currRuleStack,\n                    occurrenceStack: currOccurrenceStack,\n                };\n                possiblePaths.push(currAltPath);\n                possiblePaths.push(EXIT_ALTERNATIVE);\n            }\n        }\n        else if (prod instanceof Alternative) {\n            possiblePaths.push({\n                idx: currIdx,\n                def: prod.definition.concat(drop(currDef)),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            });\n        }\n        else if (prod instanceof Rule) {\n            // last because we should only encounter at most a single one of these per invocation.\n            possiblePaths.push(expandTopLevelRule(prod, currIdx, currRuleStack, currOccurrenceStack));\n        }\n        else {\n            throw Error(\"non exhaustive match\");\n        }\n    }\n    return result;\n}\nfunction expandTopLevelRule(topRule, currIdx, currRuleStack, currOccurrenceStack) {\n    const newRuleStack = clone(currRuleStack);\n    newRuleStack.push(topRule.name);\n    const newCurrOccurrenceStack = clone(currOccurrenceStack);\n    // top rule is always assumed to have been called with occurrence index 1\n    newCurrOccurrenceStack.push(1);\n    return {\n        idx: currIdx,\n        def: topRule.definition,\n        ruleStack: newRuleStack,\n        occurrenceStack: newCurrOccurrenceStack,\n    };\n}\n//# sourceMappingURL=interpreter.js.map"],"names":["_first"],"mappings":";;;;;;;;;;AAIO,MAAM,yCAAyC,WAAW;AAAA,EAC7D,YAAY,SAAS,MAAM;AACvB,UAAK;AACL,SAAK,UAAU;AACf,SAAK,OAAO;AACZ,SAAK,mBAAmB,CAAA;AACxB,SAAK,qBAAqB;AAC1B,SAAK,2BAA2B;AAChC,SAAK,QAAQ;AACb,SAAK,gBAAgB;AAAA,EACzB;AAAA,EACA,eAAe;AACX,SAAK,QAAQ;AACb,QAAI,KAAK,KAAK,UAAU,CAAC,MAAM,KAAK,QAAQ,MAAM;AAC9C,YAAM,MAAM,qDAAqD;AAAA,IACrE;AAEA,SAAK,YAAY,MAAM,KAAK,KAAK,SAAS,EAAE;AAC5C,SAAK,kBAAkB,MAAM,KAAK,KAAK,eAAe,EAAE;AAExD,SAAK,UAAU,IAAG;AAClB,SAAK,gBAAgB,IAAG;AACxB,SAAK,mBAAkB;AACvB,SAAK,KAAK,KAAK,OAAO;AACtB,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,KAAK,MAAM,WAAW,IAAI;AAEtB,QAAI,CAAC,KAAK,OAAO;AACb,YAAM,KAAK,MAAM,QAAQ;AAAA,IAC7B;AAAA,EACJ;AAAA,EACA,YAAY,SAAS,UAAU,UAAU;AAErC,QAAI,QAAQ,eAAe,SAAS,KAAK,sBACrC,QAAQ,QAAQ,KAAK,0BAA0B;AAC/C,YAAM,WAAW,SAAS,OAAO,QAAQ;AACzC,WAAK,mBAAkB;AACvB,WAAK,KAAK,QAAQ,gBAAgB,QAAQ;AAAA,IAC9C;AAAA,EACJ;AAAA,EACA,qBAAqB;AAEjB,QAAI,QAAQ,KAAK,SAAS,GAAG;AAGzB,WAAK,qBAAqB;AAC1B,WAAK,2BAA2B;AAChC,WAAK,gBAAgB;AAAA,IACzB,OACK;AACD,WAAK,qBAAqB,KAAK,UAAU,IAAG;AAC5C,WAAK,2BAA2B,KAAK,gBAAgB,IAAG;AAAA,IAC5D;AAAA,EACJ;AACJ;AACO,MAAM,6BAA6B,iCAAiC;AAAA,EACvE,YAAY,SAAS,MAAM;AACvB,UAAM,SAAS,IAAI;AACnB,SAAK,OAAO;AACZ,SAAK,mBAAmB;AACxB,SAAK,yBAAyB;AAC9B,SAAK,mBAAmB,KAAK,KAAK,QAAQ;AAC1C,SAAK,yBAAyB,KAAK,KAAK;AAAA,EAC5C;AAAA,EACA,aAAa,UAAU,UAAU,UAAU;AACvC,QAAI,KAAK,iBACL,SAAS,aAAa,SAAS,KAAK,oBACpC,SAAS,QAAQ,KAAK,0BACtB,CAAC,KAAK,OAAO;AACb,YAAM,WAAW,SAAS,OAAO,QAAQ;AACzC,YAAM,WAAW,IAAI,YAAY,EAAE,YAAY,SAAQ,CAAE;AACzD,WAAK,mBAAmB,MAAM,QAAQ;AACtC,WAAK,QAAQ;AAAA,IACjB;AAAA,EACJ;AACJ;AAKO,MAAM,kDAAkD,WAAW;AAAA,EACtE,YAAY,SAAS,YAAY;AAC7B,UAAK;AACL,SAAK,UAAU;AACf,SAAK,aAAa;AAClB,SAAK,SAAS;AAAA,MACV,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,aAAa;AAAA,IACzB;AAAA,EACI;AAAA,EACA,eAAe;AACX,SAAK,KAAK,KAAK,OAAO;AACtB,WAAO,KAAK;AAAA,EAChB;AACJ;AACO,MAAM,oCAAoC,0CAA0C;AAAA,EACvF,SAAS,UAAU,UAAU,UAAU;AACnC,QAAI,SAAS,QAAQ,KAAK,YAAY;AAClC,YAAM,iBAAiBA,KAAO,SAAS,OAAO,QAAQ,CAAC;AACvD,WAAK,OAAO,cAAc,mBAAmB;AAC7C,UAAI,0BAA0B,UAAU;AACpC,aAAK,OAAO,QAAQ,eAAe;AACnC,aAAK,OAAO,aAAa,eAAe;AAAA,MAC5C;AAAA,IACJ,OACK;AACD,YAAM,SAAS,UAAU,UAAU,QAAQ;AAAA,IAC/C;AAAA,EACJ;AACJ;AACO,MAAM,uCAAuC,0CAA0C;AAAA,EAC1F,YAAY,aAAa,UAAU,UAAU;AACzC,QAAI,YAAY,QAAQ,KAAK,YAAY;AACrC,YAAM,oBAAoBA,KAAO,SAAS,OAAO,QAAQ,CAAC;AAC1D,WAAK,OAAO,cAAc,sBAAsB;AAChD,UAAI,6BAA6B,UAAU;AACvC,aAAK,OAAO,QAAQ,kBAAkB;AACtC,aAAK,OAAO,aAAa,kBAAkB;AAAA,MAC/C;AAAA,IACJ,OACK;AACD,YAAM,YAAY,aAAa,UAAU,QAAQ;AAAA,IACrD;AAAA,EACJ;AACJ;AACO,MAAM,0CAA0C,0CAA0C;AAAA,EAC7F,eAAe,gBAAgB,UAAU,UAAU;AAC/C,QAAI,eAAe,QAAQ,KAAK,YAAY;AACxC,YAAM,uBAAuBA,KAAO,SAAS,OAAO,QAAQ,CAAC;AAC7D,WAAK,OAAO,cAAc,yBAAyB;AACnD,UAAI,gCAAgC,UAAU;AAC1C,aAAK,OAAO,QAAQ,qBAAqB;AACzC,aAAK,OAAO,aAAa,qBAAqB;AAAA,MAClD;AAAA,IACJ,OACK;AACD,YAAM,eAAe,gBAAgB,UAAU,QAAQ;AAAA,IAC3D;AAAA,EACJ;AACJ;AAEO,MAAM,6CAA6C,0CAA0C;AAAA,EAChG,kBAAkB,mBAAmB,UAAU,UAAU;AACrD,QAAI,kBAAkB,QAAQ,KAAK,YAAY;AAC3C,YAAM,oCAAoCA,KAAO,SAAS,OAAO,QAAQ,CAAC;AAC1E,WAAK,OAAO,cAAc,sCAAsC;AAChE,UAAI,6CAA6C,UAAU;AACvD,aAAK,OAAO,QAAQ,kCAAkC;AACtD,aAAK,OAAO,aAAa,kCAAkC;AAAA,MAC/D;AAAA,IACJ,OACK;AACD,YAAM,kBAAkB,mBAAmB,UAAU,QAAQ;AAAA,IACjE;AAAA,EACJ;AACJ;AACO,SAAS,kBAAkB,WAAW,WAAW,WAAW,CAAA,GAAI;AAEnE,aAAW,MAAM,QAAQ;AACzB,MAAI,SAAS,CAAA;AACb,MAAI,IAAI;AAER,WAAS,kBAAkB,SAAS;AAChC,WAAO,QAAQ,OAAO,KAAK,WAAW,IAAI,CAAC,CAAC;AAAA,EAChD;AAEA,WAAS,uBAAuB,YAAY;AACxC,UAAM,eAAe,kBAAkB,kBAAkB,UAAU,GAAG,WAAW,QAAQ;AACzF,WAAO,OAAO,OAAO,YAAY;AAAA,EACrC;AAQA,SAAO,SAAS,SAAS,aAAa,IAAI,UAAU,QAAQ;AACxD,UAAM,OAAO,UAAU,CAAC;AAExB,QAAI,gBAAgB,aAAa;AAC7B,aAAO,uBAAuB,KAAK,UAAU;AAAA,IACjD,WACS,gBAAgB,aAAa;AAClC,aAAO,uBAAuB,KAAK,UAAU;AAAA,IACjD,WACS,gBAAgB,QAAQ;AAC7B,eAAS,uBAAuB,KAAK,UAAU;AAAA,IACnD,WACS,gBAAgB,qBAAqB;AAC1C,YAAM,SAAS,KAAK,WAAW,OAAO;AAAA,QAClC,IAAI,WAAW;AAAA,UACX,YAAY,KAAK;AAAA,QACrC,CAAiB;AAAA,MACjB,CAAa;AACD,aAAO,uBAAuB,MAAM;AAAA,IACxC,WACS,gBAAgB,kCAAkC;AACvD,YAAM,SAAS;AAAA,QACX,IAAI,YAAY,EAAE,YAAY,KAAK,WAAU,CAAE;AAAA,QAC/C,IAAI,WAAW;AAAA,UACX,YAAY,CAAC,IAAI,SAAS,EAAE,cAAc,KAAK,UAAS,CAAE,CAAC,EAAE,OAAO,KAAK,UAAU;AAAA,QACvG,CAAiB;AAAA,MACjB;AACY,aAAO,uBAAuB,MAAM;AAAA,IACxC,WACS,gBAAgB,yBAAyB;AAC9C,YAAM,SAAS,KAAK,WAAW,OAAO;AAAA,QAClC,IAAI,WAAW;AAAA,UACX,YAAY,CAAC,IAAI,SAAS,EAAE,cAAc,KAAK,UAAS,CAAE,CAAC,EAAE,OAAO,KAAK,UAAU;AAAA,QACvG,CAAiB;AAAA,MACjB,CAAa;AACD,eAAS,uBAAuB,MAAM;AAAA,IAC1C,WACS,gBAAgB,YAAY;AACjC,YAAM,SAAS,KAAK,WAAW,OAAO;AAAA,QAClC,IAAI,WAAW;AAAA,UACX,YAAY,KAAK;AAAA,QACrC,CAAiB;AAAA,MACjB,CAAa;AACD,eAAS,uBAAuB,MAAM;AAAA,IAC1C,WACS,gBAAgB,aAAa;AAClC,cAAQ,KAAK,YAAY,CAAC,YAAY;AAIlC,YAAI,QAAQ,QAAQ,UAAU,MAAM,OAAO;AACvC,mBAAS,uBAAuB,QAAQ,UAAU;AAAA,QACtD;AAAA,MACJ,CAAC;AACD,aAAO;AAAA,IACX,WACS,gBAAgB,UAAU;AAC/B,eAAS,KAAK,KAAK,YAAY;AAAA,IACnC,OACK;AACD,YAAM,MAAM,sBAAsB;AAAA,IACtC;AACA;AAAA,EACJ;AACA,SAAO,KAAK;AAAA,IACR,aAAa;AAAA,IACb,WAAW,KAAK,WAAW,CAAC;AAAA,EACpC,CAAK;AACD,SAAO;AACX;AACO,SAAS,wBAAwB,YAAY,aAAa,YAAY,cAAc;AACvF,QAAM,oBAAoB;AAE1B,QAAM,wBAAwB,CAAC,iBAAiB;AAChD,QAAM,mBAAmB;AACzB,MAAI,oBAAoB;AACxB,QAAM,oBAAoB,YAAY;AACtC,QAAM,2BAA2B,oBAAoB,eAAe;AACpE,QAAM,SAAS,CAAA;AACf,QAAM,gBAAgB,CAAA;AACtB,gBAAc,KAAK;AAAA,IACf,KAAK;AAAA,IACL,KAAK;AAAA,IACL,WAAW,CAAA;AAAA,IACX,iBAAiB,CAAA;AAAA,EACzB,CAAK;AACD,SAAO,CAAC,QAAQ,aAAa,GAAG;AAC5B,UAAM,WAAW,cAAc,IAAG;AAElC,QAAI,aAAa,kBAAkB;AAC/B,UAAI,qBACA,KAAK,aAAa,EAAE,OAAO,0BAA0B;AAErD,sBAAc,IAAG;AAAA,MACrB;AACA;AAAA,IACJ;AACA,UAAM,UAAU,SAAS;AACzB,UAAM,UAAU,SAAS;AACzB,UAAM,gBAAgB,SAAS;AAC/B,UAAM,sBAAsB,SAAS;AAErC,QAAI,QAAQ,OAAO,GAAG;AAClB;AAAA,IACJ;AACA,UAAM,OAAO,QAAQ,CAAC;AAEtB,QAAI,SAAS,mBAAmB;AAC5B,YAAM,WAAW;AAAA,QACb,KAAK;AAAA,QACL,KAAK,KAAK,OAAO;AAAA,QACjB,WAAW,UAAU,aAAa;AAAA,QAClC,iBAAiB,UAAU,mBAAmB;AAAA,MAC9D;AACY,oBAAc,KAAK,QAAQ;AAAA,IAC/B,WACS,gBAAgB,UAAU;AAE/B,UAAI,UAAU,oBAAoB,GAAG;AACjC,cAAM,UAAU,UAAU;AAC1B,cAAM,cAAc,YAAY,OAAO;AACvC,YAAI,WAAW,aAAa,KAAK,YAAY,GAAG;AAC5C,gBAAM,WAAW;AAAA,YACb,KAAK;AAAA,YACL,KAAK,KAAK,OAAO;AAAA,YACjB,WAAW;AAAA,YACX,iBAAiB;AAAA,UACzC;AACoB,wBAAc,KAAK,QAAQ;AAAA,QAC/B;AAAA,MAEJ,WACS,YAAY,oBAAoB,GAAG;AAExC,eAAO,KAAK;AAAA,UACR,eAAe,KAAK;AAAA,UACpB,qBAAqB,KAAK;AAAA,UAC1B,WAAW;AAAA,UACX,iBAAiB;AAAA,QACrC,CAAiB;AACD,4BAAoB;AAAA,MACxB,OACK;AACD,cAAM,MAAM,sBAAsB;AAAA,MACtC;AAAA,IACJ,WACS,gBAAgB,aAAa;AAClC,YAAM,eAAe,MAAM,aAAa;AACxC,mBAAa,KAAK,KAAK,eAAe;AACtC,YAAM,qBAAqB,MAAM,mBAAmB;AACpD,yBAAmB,KAAK,KAAK,GAAG;AAChC,YAAM,WAAW;AAAA,QACb,KAAK;AAAA,QACL,KAAK,KAAK,WAAW,OAAO,uBAAuB,KAAK,OAAO,CAAC;AAAA,QAChE,WAAW;AAAA,QACX,iBAAiB;AAAA,MACjC;AACY,oBAAc,KAAK,QAAQ;AAAA,IAC/B,WACS,gBAAgB,QAAQ;AAE7B,YAAM,kBAAkB;AAAA,QACpB,KAAK;AAAA,QACL,KAAK,KAAK,OAAO;AAAA,QACjB,WAAW;AAAA,QACX,iBAAiB;AAAA,MACjC;AACY,oBAAc,KAAK,eAAe;AAElC,oBAAc,KAAK,gBAAgB;AACnC,YAAM,eAAe;AAAA,QACjB,KAAK;AAAA,QACL,KAAK,KAAK,WAAW,OAAO,KAAK,OAAO,CAAC;AAAA,QACzC,WAAW;AAAA,QACX,iBAAiB;AAAA,MACjC;AACY,oBAAc,KAAK,YAAY;AAAA,IACnC,WACS,gBAAgB,qBAAqB;AAE1C,YAAM,kBAAkB,IAAI,WAAW;AAAA,QACnC,YAAY,KAAK;AAAA,QACjB,KAAK,KAAK;AAAA,MAC1B,CAAa;AACD,YAAM,UAAU,KAAK,WAAW,OAAO,CAAC,eAAe,GAAG,KAAK,OAAO,CAAC;AACvE,YAAM,WAAW;AAAA,QACb,KAAK;AAAA,QACL,KAAK;AAAA,QACL,WAAW;AAAA,QACX,iBAAiB;AAAA,MACjC;AACY,oBAAc,KAAK,QAAQ;AAAA,IAC/B,WACS,gBAAgB,kCAAkC;AAEvD,YAAM,gBAAgB,IAAI,SAAS;AAAA,QAC/B,cAAc,KAAK;AAAA,MACnC,CAAa;AACD,YAAM,kBAAkB,IAAI,WAAW;AAAA,QACnC,YAAY,CAAC,aAAa,EAAE,OAAO,KAAK,UAAU;AAAA,QAClD,KAAK,KAAK;AAAA,MAC1B,CAAa;AACD,YAAM,UAAU,KAAK,WAAW,OAAO,CAAC,eAAe,GAAG,KAAK,OAAO,CAAC;AACvE,YAAM,WAAW;AAAA,QACb,KAAK;AAAA,QACL,KAAK;AAAA,QACL,WAAW;AAAA,QACX,iBAAiB;AAAA,MACjC;AACY,oBAAc,KAAK,QAAQ;AAAA,IAC/B,WACS,gBAAgB,yBAAyB;AAE9C,YAAM,kBAAkB;AAAA,QACpB,KAAK;AAAA,QACL,KAAK,KAAK,OAAO;AAAA,QACjB,WAAW;AAAA,QACX,iBAAiB;AAAA,MACjC;AACY,oBAAc,KAAK,eAAe;AAElC,oBAAc,KAAK,gBAAgB;AACnC,YAAM,gBAAgB,IAAI,SAAS;AAAA,QAC/B,cAAc,KAAK;AAAA,MACnC,CAAa;AACD,YAAM,gBAAgB,IAAI,WAAW;AAAA,QACjC,YAAY,CAAC,aAAa,EAAE,OAAO,KAAK,UAAU;AAAA,QAClD,KAAK,KAAK;AAAA,MAC1B,CAAa;AACD,YAAM,UAAU,KAAK,WAAW,OAAO,CAAC,aAAa,GAAG,KAAK,OAAO,CAAC;AACrE,YAAM,eAAe;AAAA,QACjB,KAAK;AAAA,QACL,KAAK;AAAA,QACL,WAAW;AAAA,QACX,iBAAiB;AAAA,MACjC;AACY,oBAAc,KAAK,YAAY;AAAA,IACnC,WACS,gBAAgB,YAAY;AAEjC,YAAM,kBAAkB;AAAA,QACpB,KAAK;AAAA,QACL,KAAK,KAAK,OAAO;AAAA,QACjB,WAAW;AAAA,QACX,iBAAiB;AAAA,MACjC;AACY,oBAAc,KAAK,eAAe;AAElC,oBAAc,KAAK,gBAAgB;AAEnC,YAAM,gBAAgB,IAAI,WAAW;AAAA,QACjC,YAAY,KAAK;AAAA,QACjB,KAAK,KAAK;AAAA,MAC1B,CAAa;AACD,YAAM,UAAU,KAAK,WAAW,OAAO,CAAC,aAAa,GAAG,KAAK,OAAO,CAAC;AACrE,YAAM,eAAe;AAAA,QACjB,KAAK;AAAA,QACL,KAAK;AAAA,QACL,WAAW;AAAA,QACX,iBAAiB;AAAA,MACjC;AACY,oBAAc,KAAK,YAAY;AAAA,IACnC,WACS,gBAAgB,aAAa;AAElC,eAAS,IAAI,KAAK,WAAW,SAAS,GAAG,KAAK,GAAG,KAAK;AAClD,cAAM,UAAU,KAAK,WAAW,CAAC;AACjC,cAAM,cAAc;AAAA,UAChB,KAAK;AAAA,UACL,KAAK,QAAQ,WAAW,OAAO,KAAK,OAAO,CAAC;AAAA,UAC5C,WAAW;AAAA,UACX,iBAAiB;AAAA,QACrC;AACgB,sBAAc,KAAK,WAAW;AAC9B,sBAAc,KAAK,gBAAgB;AAAA,MACvC;AAAA,IACJ,WACS,gBAAgB,aAAa;AAClC,oBAAc,KAAK;AAAA,QACf,KAAK;AAAA,QACL,KAAK,KAAK,WAAW,OAAO,KAAK,OAAO,CAAC;AAAA,QACzC,WAAW;AAAA,QACX,iBAAiB;AAAA,MACjC,CAAa;AAAA,IACL,WACS,gBAAgB,MAAM;AAE3B,oBAAc,KAAK,mBAAmB,MAAM,SAAS,eAAe,mBAAmB,CAAC;AAAA,IAC5F,OACK;AACD,YAAM,MAAM,sBAAsB;AAAA,IACtC;AAAA,EACJ;AACA,SAAO;AACX;AACA,SAAS,mBAAmB,SAAS,SAAS,eAAe,qBAAqB;AAC9E,QAAM,eAAe,MAAM,aAAa;AACxC,eAAa,KAAK,QAAQ,IAAI;AAC9B,QAAM,yBAAyB,MAAM,mBAAmB;AAExD,yBAAuB,KAAK,CAAC;AAC7B,SAAO;AAAA,IACH,KAAK;AAAA,IACL,KAAK,QAAQ;AAAA,IACb,WAAW;AAAA,IACX,iBAAiB;AAAA,EACzB;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/keys.mjs

@@ -1,23 +0,0 @@
-const BITS_FOR_METHOD_TYPE = 4;
-const BITS_FOR_OCCURRENCE_IDX = 8;
-const OR_IDX = 1 << BITS_FOR_OCCURRENCE_IDX;
-const OPTION_IDX = 2 << BITS_FOR_OCCURRENCE_IDX;
-const MANY_IDX = 3 << BITS_FOR_OCCURRENCE_IDX;
-const AT_LEAST_ONE_IDX = 4 << BITS_FOR_OCCURRENCE_IDX;
-const MANY_SEP_IDX = 5 << BITS_FOR_OCCURRENCE_IDX;
-const AT_LEAST_ONE_SEP_IDX = 6 << BITS_FOR_OCCURRENCE_IDX;
-function getKeyForAutomaticLookahead(ruleIdx, dslMethodIdx, occurrence) {
-  return occurrence | dslMethodIdx | ruleIdx;
-}
-export {
-  AT_LEAST_ONE_IDX,
-  AT_LEAST_ONE_SEP_IDX,
-  BITS_FOR_METHOD_TYPE,
-  BITS_FOR_OCCURRENCE_IDX,
-  MANY_IDX,
-  MANY_SEP_IDX,
-  OPTION_IDX,
-  OR_IDX,
-  getKeyForAutomaticLookahead
-};
-//# sourceMappingURL=keys.mjs.map

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/keys.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"keys.mjs","sources":["../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/keys.js"],"sourcesContent":["// Lookahead keys are 32Bit integers in the form\n// TTTTTTTT-ZZZZZZZZZZZZ-YYYY-XXXXXXXX\n// XXXX -> Occurrence Index bitmap.\n// YYYY -> DSL Method Type bitmap.\n// ZZZZZZZZZZZZZZZ -> Rule short Index bitmap.\n// TTTTTTTTT -> alternation alternative index bitmap\nexport const BITS_FOR_METHOD_TYPE = 4;\nexport const BITS_FOR_OCCURRENCE_IDX = 8;\nexport const BITS_FOR_RULE_IDX = 12;\n// TODO: validation, this means that there may at most 2^8 --> 256 alternatives for an alternation.\nexport const BITS_FOR_ALT_IDX = 8;\n// short string used as part of mapping keys.\n// being short improves the performance when composing KEYS for maps out of these\n// The 5 - 8 bits (16 possible values, are reserved for the DSL method indices)\nexport const OR_IDX = 1 << BITS_FOR_OCCURRENCE_IDX;\nexport const OPTION_IDX = 2 << BITS_FOR_OCCURRENCE_IDX;\nexport const MANY_IDX = 3 << BITS_FOR_OCCURRENCE_IDX;\nexport const AT_LEAST_ONE_IDX = 4 << BITS_FOR_OCCURRENCE_IDX;\nexport const MANY_SEP_IDX = 5 << BITS_FOR_OCCURRENCE_IDX;\nexport const AT_LEAST_ONE_SEP_IDX = 6 << BITS_FOR_OCCURRENCE_IDX;\n// this actually returns a number, but it is always used as a string (object prop key)\nexport function getKeyForAutomaticLookahead(ruleIdx, dslMethodIdx, occurrence) {\n    return occurrence | dslMethodIdx | ruleIdx;\n}\nconst BITS_START_FOR_ALT_IDX = 32 - BITS_FOR_ALT_IDX;\n//# sourceMappingURL=keys.js.map"],"names":[],"mappings":"AAMY,MAAC,uBAAuB;AACxB,MAAC,0BAA0B;AAO3B,MAAC,SAAS,KAAK;AACf,MAAC,aAAa,KAAK;AACnB,MAAC,WAAW,KAAK;AACjB,MAAC,mBAAmB,KAAK;AACzB,MAAC,eAAe,KAAK;AACrB,MAAC,uBAAuB,KAAK;AAElC,SAAS,4BAA4B,SAAS,cAAc,YAAY;AAC3E,SAAO,aAAa,eAAe;AACvC;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.mjs

@@ -1,50 +0,0 @@
-import { defaultGrammarValidatorErrorProvider } from "../errors_public.mjs";
-import { DEFAULT_PARSER_CONFIG } from "../parser/parser.mjs";
-import { validateSomeNonEmptyLookaheadPath, validateNoLeftRecursion, validateEmptyOrAlternative, validateAmbiguousAlternationAlternatives } from "./checks.mjs";
-import { buildLookaheadFuncForOr, buildLookaheadFuncForOptionalProd, getProdType, buildAlternativesLookAheadFunc, buildSingleAlternativeLookaheadFunction } from "./lookahead.mjs";
-import isEmpty from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.mjs";
-import flatMap from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatMap.mjs";
-class LLkLookaheadStrategy {
-  constructor(options) {
-    var _a;
-    this.maxLookahead = (_a = options === null || options === void 0 ? void 0 : options.maxLookahead) !== null && _a !== void 0 ? _a : DEFAULT_PARSER_CONFIG.maxLookahead;
-  }
-  validate(options) {
-    const leftRecursionErrors = this.validateNoLeftRecursion(options.rules);
-    if (isEmpty(leftRecursionErrors)) {
-      const emptyAltErrors = this.validateEmptyOrAlternatives(options.rules);
-      const ambiguousAltsErrors = this.validateAmbiguousAlternationAlternatives(options.rules, this.maxLookahead);
-      const emptyRepetitionErrors = this.validateSomeNonEmptyLookaheadPath(options.rules, this.maxLookahead);
-      const allErrors = [
-        ...leftRecursionErrors,
-        ...emptyAltErrors,
-        ...ambiguousAltsErrors,
-        ...emptyRepetitionErrors
-      ];
-      return allErrors;
-    }
-    return leftRecursionErrors;
-  }
-  validateNoLeftRecursion(rules) {
-    return flatMap(rules, (currTopRule) => validateNoLeftRecursion(currTopRule, currTopRule, defaultGrammarValidatorErrorProvider));
-  }
-  validateEmptyOrAlternatives(rules) {
-    return flatMap(rules, (currTopRule) => validateEmptyOrAlternative(currTopRule, defaultGrammarValidatorErrorProvider));
-  }
-  validateAmbiguousAlternationAlternatives(rules, maxLookahead) {
-    return flatMap(rules, (currTopRule) => validateAmbiguousAlternationAlternatives(currTopRule, maxLookahead, defaultGrammarValidatorErrorProvider));
-  }
-  validateSomeNonEmptyLookaheadPath(rules, maxLookahead) {
-    return validateSomeNonEmptyLookaheadPath(rules, maxLookahead, defaultGrammarValidatorErrorProvider);
-  }
-  buildLookaheadForAlternation(options) {
-    return buildLookaheadFuncForOr(options.prodOccurrence, options.rule, options.maxLookahead, options.hasPredicates, options.dynamicTokensEnabled, buildAlternativesLookAheadFunc);
-  }
-  buildLookaheadForOptional(options) {
-    return buildLookaheadFuncForOptionalProd(options.prodOccurrence, options.rule, options.maxLookahead, options.dynamicTokensEnabled, getProdType(options.prodType), buildSingleAlternativeLookaheadFunction);
-  }
-}
-export {
-  LLkLookaheadStrategy
-};
-//# sourceMappingURL=llk_lookahead.mjs.map

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"llk_lookahead.mjs","sources":["../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.js"],"sourcesContent":["import { flatMap, isEmpty } from \"lodash-es\";\nimport { defaultGrammarValidatorErrorProvider } from \"../errors_public.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser/parser.js\";\nimport { validateAmbiguousAlternationAlternatives, validateEmptyOrAlternative, validateNoLeftRecursion, validateSomeNonEmptyLookaheadPath, } from \"./checks.js\";\nimport { buildAlternativesLookAheadFunc, buildLookaheadFuncForOptionalProd, buildLookaheadFuncForOr, buildSingleAlternativeLookaheadFunction, getProdType, } from \"./lookahead.js\";\nexport class LLkLookaheadStrategy {\n    constructor(options) {\n        var _a;\n        this.maxLookahead =\n            (_a = options === null || options === void 0 ? void 0 : options.maxLookahead) !== null && _a !== void 0 ? _a : DEFAULT_PARSER_CONFIG.maxLookahead;\n    }\n    validate(options) {\n        const leftRecursionErrors = this.validateNoLeftRecursion(options.rules);\n        if (isEmpty(leftRecursionErrors)) {\n            const emptyAltErrors = this.validateEmptyOrAlternatives(options.rules);\n            const ambiguousAltsErrors = this.validateAmbiguousAlternationAlternatives(options.rules, this.maxLookahead);\n            const emptyRepetitionErrors = this.validateSomeNonEmptyLookaheadPath(options.rules, this.maxLookahead);\n            const allErrors = [\n                ...leftRecursionErrors,\n                ...emptyAltErrors,\n                ...ambiguousAltsErrors,\n                ...emptyRepetitionErrors,\n            ];\n            return allErrors;\n        }\n        return leftRecursionErrors;\n    }\n    validateNoLeftRecursion(rules) {\n        return flatMap(rules, (currTopRule) => validateNoLeftRecursion(currTopRule, currTopRule, defaultGrammarValidatorErrorProvider));\n    }\n    validateEmptyOrAlternatives(rules) {\n        return flatMap(rules, (currTopRule) => validateEmptyOrAlternative(currTopRule, defaultGrammarValidatorErrorProvider));\n    }\n    validateAmbiguousAlternationAlternatives(rules, maxLookahead) {\n        return flatMap(rules, (currTopRule) => validateAmbiguousAlternationAlternatives(currTopRule, maxLookahead, defaultGrammarValidatorErrorProvider));\n    }\n    validateSomeNonEmptyLookaheadPath(rules, maxLookahead) {\n        return validateSomeNonEmptyLookaheadPath(rules, maxLookahead, defaultGrammarValidatorErrorProvider);\n    }\n    buildLookaheadForAlternation(options) {\n        return buildLookaheadFuncForOr(options.prodOccurrence, options.rule, options.maxLookahead, options.hasPredicates, options.dynamicTokensEnabled, buildAlternativesLookAheadFunc);\n    }\n    buildLookaheadForOptional(options) {\n        return buildLookaheadFuncForOptionalProd(options.prodOccurrence, options.rule, options.maxLookahead, options.dynamicTokensEnabled, getProdType(options.prodType), buildSingleAlternativeLookaheadFunction);\n    }\n}\n//# sourceMappingURL=llk_lookahead.js.map"],"names":[],"mappings":";;;;;;AAKO,MAAM,qBAAqB;AAAA,EAC9B,YAAY,SAAS;AACjB,QAAI;AACJ,SAAK,gBACA,KAAK,YAAY,QAAQ,YAAY,SAAS,SAAS,QAAQ,kBAAkB,QAAQ,OAAO,SAAS,KAAK,sBAAsB;AAAA,EAC7I;AAAA,EACA,SAAS,SAAS;AACd,UAAM,sBAAsB,KAAK,wBAAwB,QAAQ,KAAK;AACtE,QAAI,QAAQ,mBAAmB,GAAG;AAC9B,YAAM,iBAAiB,KAAK,4BAA4B,QAAQ,KAAK;AACrE,YAAM,sBAAsB,KAAK,yCAAyC,QAAQ,OAAO,KAAK,YAAY;AAC1G,YAAM,wBAAwB,KAAK,kCAAkC,QAAQ,OAAO,KAAK,YAAY;AACrG,YAAM,YAAY;AAAA,QACd,GAAG;AAAA,QACH,GAAG;AAAA,QACH,GAAG;AAAA,QACH,GAAG;AAAA,MACnB;AACY,aAAO;AAAA,IACX;AACA,WAAO;AAAA,EACX;AAAA,EACA,wBAAwB,OAAO;AAC3B,WAAO,QAAQ,OAAO,CAAC,gBAAgB,wBAAwB,aAAa,aAAa,oCAAoC,CAAC;AAAA,EAClI;AAAA,EACA,4BAA4B,OAAO;AAC/B,WAAO,QAAQ,OAAO,CAAC,gBAAgB,2BAA2B,aAAa,oCAAoC,CAAC;AAAA,EACxH;AAAA,EACA,yCAAyC,OAAO,cAAc;AAC1D,WAAO,QAAQ,OAAO,CAAC,gBAAgB,yCAAyC,aAAa,cAAc,oCAAoC,CAAC;AAAA,EACpJ;AAAA,EACA,kCAAkC,OAAO,cAAc;AACnD,WAAO,kCAAkC,OAAO,cAAc,oCAAoC;AAAA,EACtG;AAAA,EACA,6BAA6B,SAAS;AAClC,WAAO,wBAAwB,QAAQ,gBAAgB,QAAQ,MAAM,QAAQ,cAAc,QAAQ,eAAe,QAAQ,sBAAsB,8BAA8B;AAAA,EAClL;AAAA,EACA,0BAA0B,SAAS;AAC/B,WAAO,kCAAkC,QAAQ,gBAAgB,QAAQ,MAAM,QAAQ,cAAc,QAAQ,sBAAsB,YAAY,QAAQ,QAAQ,GAAG,uCAAuC;AAAA,EAC7M;AACJ;","x_google_ignoreList":[0]}