qidian-vue-ui 1.1.50 → 1.1.51

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

@@ -0,0 +1,431 @@
+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

@@ -0,0 +1 @@
+{"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":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1 @@
+{"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]}