qidian-vue-ui 1.1.50 → 1.1.51

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/recoverable.mjs

@@ -0,0 +1,259 @@
+import { createTokenInstance, tokenMatcher, EOF } from "../../../scan/tokens_public.mjs";
+import { MismatchedTokenException } from "../../exceptions_public.mjs";
+import { IN } from "../../constants.mjs";
+import { DEFAULT_PARSER_CONFIG } from "../parser.mjs";
+import has from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.mjs";
+import isEmpty from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.mjs";
+import find from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/find.mjs";
+import includes from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/includes.mjs";
+import map from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs";
+import flatten from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.mjs";
+import dropRight from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/dropRight.mjs";
+import clone from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clone.mjs";
+const EOF_FOLLOW_KEY = {};
+const IN_RULE_RECOVERY_EXCEPTION = "InRuleRecoveryException";
+class InRuleRecoveryException extends Error {
+  constructor(message) {
+    super(message);
+    this.name = IN_RULE_RECOVERY_EXCEPTION;
+  }
+}
+class Recoverable {
+  initRecoverable(config) {
+    this.firstAfterRepMap = {};
+    this.resyncFollows = {};
+    this.recoveryEnabled = has(config, "recoveryEnabled") ? config.recoveryEnabled : DEFAULT_PARSER_CONFIG.recoveryEnabled;
+    if (this.recoveryEnabled) {
+      this.attemptInRepetitionRecovery = attemptInRepetitionRecovery;
+    }
+  }
+  getTokenToInsert(tokType) {
+    const tokToInsert = createTokenInstance(tokType, "", NaN, NaN, NaN, NaN, NaN, NaN);
+    tokToInsert.isInsertedInRecovery = true;
+    return tokToInsert;
+  }
+  canTokenTypeBeInsertedInRecovery(tokType) {
+    return true;
+  }
+  canTokenTypeBeDeletedInRecovery(tokType) {
+    return true;
+  }
+  tryInRepetitionRecovery(grammarRule, grammarRuleArgs, lookAheadFunc, expectedTokType) {
+    const reSyncTokType = this.findReSyncTokenType();
+    const savedLexerState = this.exportLexerState();
+    const resyncedTokens = [];
+    let passedResyncPoint = false;
+    const nextTokenWithoutResync = this.LA(1);
+    let currToken = this.LA(1);
+    const generateErrorMessage = () => {
+      const previousToken = this.LA(0);
+      const msg = this.errorMessageProvider.buildMismatchTokenMessage({
+        expected: expectedTokType,
+        actual: nextTokenWithoutResync,
+        previous: previousToken,
+        ruleName: this.getCurrRuleFullName()
+      });
+      const error = new MismatchedTokenException(msg, nextTokenWithoutResync, this.LA(0));
+      error.resyncedTokens = dropRight(resyncedTokens);
+      this.SAVE_ERROR(error);
+    };
+    while (!passedResyncPoint) {
+      if (this.tokenMatcher(currToken, expectedTokType)) {
+        generateErrorMessage();
+        return;
+      } else if (lookAheadFunc.call(this)) {
+        generateErrorMessage();
+        grammarRule.apply(this, grammarRuleArgs);
+        return;
+      } else if (this.tokenMatcher(currToken, reSyncTokType)) {
+        passedResyncPoint = true;
+      } else {
+        currToken = this.SKIP_TOKEN();
+        this.addToResyncTokens(currToken, resyncedTokens);
+      }
+    }
+    this.importLexerState(savedLexerState);
+  }
+  shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck) {
+    if (notStuck === false) {
+      return false;
+    }
+    if (this.tokenMatcher(this.LA(1), expectTokAfterLastMatch)) {
+      return false;
+    }
+    if (this.isBackTracking()) {
+      return false;
+    }
+    if (this.canPerformInRuleRecovery(expectTokAfterLastMatch, this.getFollowsForInRuleRecovery(expectTokAfterLastMatch, nextTokIdx))) {
+      return false;
+    }
+    return true;
+  }
+  // Error Recovery functionality
+  getFollowsForInRuleRecovery(tokType, tokIdxInRule) {
+    const grammarPath = this.getCurrentGrammarPath(tokType, tokIdxInRule);
+    const follows = this.getNextPossibleTokenTypes(grammarPath);
+    return follows;
+  }
+  tryInRuleRecovery(expectedTokType, follows) {
+    if (this.canRecoverWithSingleTokenInsertion(expectedTokType, follows)) {
+      const tokToInsert = this.getTokenToInsert(expectedTokType);
+      return tokToInsert;
+    }
+    if (this.canRecoverWithSingleTokenDeletion(expectedTokType)) {
+      const nextTok = this.SKIP_TOKEN();
+      this.consumeToken();
+      return nextTok;
+    }
+    throw new InRuleRecoveryException("sad sad panda");
+  }
+  canPerformInRuleRecovery(expectedToken, follows) {
+    return this.canRecoverWithSingleTokenInsertion(expectedToken, follows) || this.canRecoverWithSingleTokenDeletion(expectedToken);
+  }
+  canRecoverWithSingleTokenInsertion(expectedTokType, follows) {
+    if (!this.canTokenTypeBeInsertedInRecovery(expectedTokType)) {
+      return false;
+    }
+    if (isEmpty(follows)) {
+      return false;
+    }
+    const mismatchedTok = this.LA(1);
+    const isMisMatchedTokInFollows = find(follows, (possibleFollowsTokType) => {
+      return this.tokenMatcher(mismatchedTok, possibleFollowsTokType);
+    }) !== void 0;
+    return isMisMatchedTokInFollows;
+  }
+  canRecoverWithSingleTokenDeletion(expectedTokType) {
+    if (!this.canTokenTypeBeDeletedInRecovery(expectedTokType)) {
+      return false;
+    }
+    const isNextTokenWhatIsExpected = this.tokenMatcher(this.LA(2), expectedTokType);
+    return isNextTokenWhatIsExpected;
+  }
+  isInCurrentRuleReSyncSet(tokenTypeIdx) {
+    const followKey = this.getCurrFollowKey();
+    const currentRuleReSyncSet = this.getFollowSetFromFollowKey(followKey);
+    return includes(currentRuleReSyncSet, tokenTypeIdx);
+  }
+  findReSyncTokenType() {
+    const allPossibleReSyncTokTypes = this.flattenFollowSet();
+    let nextToken = this.LA(1);
+    let k = 2;
+    while (true) {
+      const foundMatch = find(allPossibleReSyncTokTypes, (resyncTokType) => {
+        const canMatch = tokenMatcher(nextToken, resyncTokType);
+        return canMatch;
+      });
+      if (foundMatch !== void 0) {
+        return foundMatch;
+      }
+      nextToken = this.LA(k);
+      k++;
+    }
+  }
+  getCurrFollowKey() {
+    if (this.RULE_STACK.length === 1) {
+      return EOF_FOLLOW_KEY;
+    }
+    const currRuleShortName = this.getLastExplicitRuleShortName();
+    const currRuleIdx = this.getLastExplicitRuleOccurrenceIndex();
+    const prevRuleShortName = this.getPreviousExplicitRuleShortName();
+    return {
+      ruleName: this.shortRuleNameToFullName(currRuleShortName),
+      idxInCallingRule: currRuleIdx,
+      inRule: this.shortRuleNameToFullName(prevRuleShortName)
+    };
+  }
+  buildFullFollowKeyStack() {
+    const explicitRuleStack = this.RULE_STACK;
+    const explicitOccurrenceStack = this.RULE_OCCURRENCE_STACK;
+    return map(explicitRuleStack, (ruleName, idx) => {
+      if (idx === 0) {
+        return EOF_FOLLOW_KEY;
+      }
+      return {
+        ruleName: this.shortRuleNameToFullName(ruleName),
+        idxInCallingRule: explicitOccurrenceStack[idx],
+        inRule: this.shortRuleNameToFullName(explicitRuleStack[idx - 1])
+      };
+    });
+  }
+  flattenFollowSet() {
+    const followStack = map(this.buildFullFollowKeyStack(), (currKey) => {
+      return this.getFollowSetFromFollowKey(currKey);
+    });
+    return flatten(followStack);
+  }
+  getFollowSetFromFollowKey(followKey) {
+    if (followKey === EOF_FOLLOW_KEY) {
+      return [EOF];
+    }
+    const followName = followKey.ruleName + followKey.idxInCallingRule + IN + followKey.inRule;
+    return this.resyncFollows[followName];
+  }
+  // It does not make any sense to include a virtual EOF token in the list of resynced tokens
+  // as EOF does not really exist and thus does not contain any useful information (line/column numbers)
+  addToResyncTokens(token, resyncTokens) {
+    if (!this.tokenMatcher(token, EOF)) {
+      resyncTokens.push(token);
+    }
+    return resyncTokens;
+  }
+  reSyncTo(tokType) {
+    const resyncedTokens = [];
+    let nextTok = this.LA(1);
+    while (this.tokenMatcher(nextTok, tokType) === false) {
+      nextTok = this.SKIP_TOKEN();
+      this.addToResyncTokens(nextTok, resyncedTokens);
+    }
+    return dropRight(resyncedTokens);
+  }
+  attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {
+  }
+  getCurrentGrammarPath(tokType, tokIdxInRule) {
+    const pathRuleStack = this.getHumanReadableRuleStack();
+    const pathOccurrenceStack = clone(this.RULE_OCCURRENCE_STACK);
+    const grammarPath = {
+      ruleStack: pathRuleStack,
+      occurrenceStack: pathOccurrenceStack,
+      lastTok: tokType,
+      lastTokOccurrence: tokIdxInRule
+    };
+    return grammarPath;
+  }
+  getHumanReadableRuleStack() {
+    return map(this.RULE_STACK, (currShortName) => this.shortRuleNameToFullName(currShortName));
+  }
+}
+function attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {
+  const key = this.getKeyForAutomaticLookahead(dslMethodIdx, prodOccurrence);
+  let firstAfterRepInfo = this.firstAfterRepMap[key];
+  if (firstAfterRepInfo === void 0) {
+    const currRuleName = this.getCurrRuleFullName();
+    const ruleGrammar = this.getGAstProductions()[currRuleName];
+    const walker = new nextToksWalker(ruleGrammar, prodOccurrence);
+    firstAfterRepInfo = walker.startWalking();
+    this.firstAfterRepMap[key] = firstAfterRepInfo;
+  }
+  let expectTokAfterLastMatch = firstAfterRepInfo.token;
+  let nextTokIdx = firstAfterRepInfo.occurrence;
+  const isEndOfRule = firstAfterRepInfo.isEndOfRule;
+  if (this.RULE_STACK.length === 1 && isEndOfRule && expectTokAfterLastMatch === void 0) {
+    expectTokAfterLastMatch = EOF;
+    nextTokIdx = 1;
+  }
+  if (expectTokAfterLastMatch === void 0 || nextTokIdx === void 0) {
+    return;
+  }
+  if (this.shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck)) {
+    this.tryInRepetitionRecovery(prodFunc, args, lookaheadFunc, expectTokAfterLastMatch);
+  }
+}
+export {
+  EOF_FOLLOW_KEY,
+  IN_RULE_RECOVERY_EXCEPTION,
+  InRuleRecoveryException,
+  Recoverable,
+  attemptInRepetitionRecovery
+};
+//# sourceMappingURL=recoverable.mjs.map

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/recoverable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recoverable.mjs","sources":["../../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/recoverable.js"],"sourcesContent":["import { createTokenInstance, EOF, tokenMatcher, } from \"../../../scan/tokens_public.js\";\nimport { clone, dropRight, find, flatten, has, includes, isEmpty, map, } from \"lodash-es\";\nimport { MismatchedTokenException } from \"../../exceptions_public.js\";\nimport { IN } from \"../../constants.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\nexport const EOF_FOLLOW_KEY = {};\nexport const IN_RULE_RECOVERY_EXCEPTION = \"InRuleRecoveryException\";\nexport class InRuleRecoveryException extends Error {\n    constructor(message) {\n        super(message);\n        this.name = IN_RULE_RECOVERY_EXCEPTION;\n    }\n}\n/**\n * This trait is responsible for the error recovery and fault tolerant logic\n */\nexport class Recoverable {\n    initRecoverable(config) {\n        this.firstAfterRepMap = {};\n        this.resyncFollows = {};\n        this.recoveryEnabled = has(config, \"recoveryEnabled\")\n            ? config.recoveryEnabled // assumes end user provides the correct config value/type\n            : DEFAULT_PARSER_CONFIG.recoveryEnabled;\n        // performance optimization, NOOP will be inlined which\n        // effectively means that this optional feature does not exist\n        // when not used.\n        if (this.recoveryEnabled) {\n            this.attemptInRepetitionRecovery = attemptInRepetitionRecovery;\n        }\n    }\n    getTokenToInsert(tokType) {\n        const tokToInsert = createTokenInstance(tokType, \"\", NaN, NaN, NaN, NaN, NaN, NaN);\n        tokToInsert.isInsertedInRecovery = true;\n        return tokToInsert;\n    }\n    canTokenTypeBeInsertedInRecovery(tokType) {\n        return true;\n    }\n    canTokenTypeBeDeletedInRecovery(tokType) {\n        return true;\n    }\n    tryInRepetitionRecovery(grammarRule, grammarRuleArgs, lookAheadFunc, expectedTokType) {\n        // TODO: can the resyncTokenType be cached?\n        const reSyncTokType = this.findReSyncTokenType();\n        const savedLexerState = this.exportLexerState();\n        const resyncedTokens = [];\n        let passedResyncPoint = false;\n        const nextTokenWithoutResync = this.LA(1);\n        let currToken = this.LA(1);\n        const generateErrorMessage = () => {\n            const previousToken = this.LA(0);\n            // we are preemptively re-syncing before an error has been detected, therefor we must reproduce\n            // the error that would have been thrown\n            const msg = this.errorMessageProvider.buildMismatchTokenMessage({\n                expected: expectedTokType,\n                actual: nextTokenWithoutResync,\n                previous: previousToken,\n                ruleName: this.getCurrRuleFullName(),\n            });\n            const error = new MismatchedTokenException(msg, nextTokenWithoutResync, this.LA(0));\n            // the first token here will be the original cause of the error, this is not part of the resyncedTokens property.\n            error.resyncedTokens = dropRight(resyncedTokens);\n            this.SAVE_ERROR(error);\n        };\n        while (!passedResyncPoint) {\n            // re-synced to a point where we can safely exit the repetition/\n            if (this.tokenMatcher(currToken, expectedTokType)) {\n                generateErrorMessage();\n                return; // must return here to avoid reverting the inputIdx\n            }\n            else if (lookAheadFunc.call(this)) {\n                // we skipped enough tokens so we can resync right back into another iteration of the repetition grammar rule\n                generateErrorMessage();\n                // recursive invocation in other to support multiple re-syncs in the same top level repetition grammar rule\n                grammarRule.apply(this, grammarRuleArgs);\n                return; // must return here to avoid reverting the inputIdx\n            }\n            else if (this.tokenMatcher(currToken, reSyncTokType)) {\n                passedResyncPoint = true;\n            }\n            else {\n                currToken = this.SKIP_TOKEN();\n                this.addToResyncTokens(currToken, resyncedTokens);\n            }\n        }\n        // we were unable to find a CLOSER point to resync inside the Repetition, reset the state.\n        // The parsing exception we were trying to prevent will happen in the NEXT parsing step. it may be handled by\n        // \"between rules\" resync recovery later in the flow.\n        this.importLexerState(savedLexerState);\n    }\n    shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck) {\n        // Edge case of arriving from a MANY repetition which is stuck\n        // Attempting recovery in this case could cause an infinite loop\n        if (notStuck === false) {\n            return false;\n        }\n        // no need to recover, next token is what we expect...\n        if (this.tokenMatcher(this.LA(1), expectTokAfterLastMatch)) {\n            return false;\n        }\n        // error recovery is disabled during backtracking as it can make the parser ignore a valid grammar path\n        // and prefer some backtracking path that includes recovered errors.\n        if (this.isBackTracking()) {\n            return false;\n        }\n        // if we can perform inRule recovery (single token insertion or deletion) we always prefer that recovery algorithm\n        // because if it works, it makes the least amount of changes to the input stream (greedy algorithm)\n        //noinspection RedundantIfStatementJS\n        if (this.canPerformInRuleRecovery(expectTokAfterLastMatch, this.getFollowsForInRuleRecovery(expectTokAfterLastMatch, nextTokIdx))) {\n            return false;\n        }\n        return true;\n    }\n    // Error Recovery functionality\n    getFollowsForInRuleRecovery(tokType, tokIdxInRule) {\n        const grammarPath = this.getCurrentGrammarPath(tokType, tokIdxInRule);\n        const follows = this.getNextPossibleTokenTypes(grammarPath);\n        return follows;\n    }\n    tryInRuleRecovery(expectedTokType, follows) {\n        if (this.canRecoverWithSingleTokenInsertion(expectedTokType, follows)) {\n            const tokToInsert = this.getTokenToInsert(expectedTokType);\n            return tokToInsert;\n        }\n        if (this.canRecoverWithSingleTokenDeletion(expectedTokType)) {\n            const nextTok = this.SKIP_TOKEN();\n            this.consumeToken();\n            return nextTok;\n        }\n        throw new InRuleRecoveryException(\"sad sad panda\");\n    }\n    canPerformInRuleRecovery(expectedToken, follows) {\n        return (this.canRecoverWithSingleTokenInsertion(expectedToken, follows) ||\n            this.canRecoverWithSingleTokenDeletion(expectedToken));\n    }\n    canRecoverWithSingleTokenInsertion(expectedTokType, follows) {\n        if (!this.canTokenTypeBeInsertedInRecovery(expectedTokType)) {\n            return false;\n        }\n        // must know the possible following tokens to perform single token insertion\n        if (isEmpty(follows)) {\n            return false;\n        }\n        const mismatchedTok = this.LA(1);\n        const isMisMatchedTokInFollows = find(follows, (possibleFollowsTokType) => {\n            return this.tokenMatcher(mismatchedTok, possibleFollowsTokType);\n        }) !== undefined;\n        return isMisMatchedTokInFollows;\n    }\n    canRecoverWithSingleTokenDeletion(expectedTokType) {\n        if (!this.canTokenTypeBeDeletedInRecovery(expectedTokType)) {\n            return false;\n        }\n        const isNextTokenWhatIsExpected = this.tokenMatcher(this.LA(2), expectedTokType);\n        return isNextTokenWhatIsExpected;\n    }\n    isInCurrentRuleReSyncSet(tokenTypeIdx) {\n        const followKey = this.getCurrFollowKey();\n        const currentRuleReSyncSet = this.getFollowSetFromFollowKey(followKey);\n        return includes(currentRuleReSyncSet, tokenTypeIdx);\n    }\n    findReSyncTokenType() {\n        const allPossibleReSyncTokTypes = this.flattenFollowSet();\n        // this loop will always terminate as EOF is always in the follow stack and also always (virtually) in the input\n        let nextToken = this.LA(1);\n        let k = 2;\n        while (true) {\n            const foundMatch = find(allPossibleReSyncTokTypes, (resyncTokType) => {\n                const canMatch = tokenMatcher(nextToken, resyncTokType);\n                return canMatch;\n            });\n            if (foundMatch !== undefined) {\n                return foundMatch;\n            }\n            nextToken = this.LA(k);\n            k++;\n        }\n    }\n    getCurrFollowKey() {\n        // the length is at least one as we always add the ruleName to the stack before invoking the rule.\n        if (this.RULE_STACK.length === 1) {\n            return EOF_FOLLOW_KEY;\n        }\n        const currRuleShortName = this.getLastExplicitRuleShortName();\n        const currRuleIdx = this.getLastExplicitRuleOccurrenceIndex();\n        const prevRuleShortName = this.getPreviousExplicitRuleShortName();\n        return {\n            ruleName: this.shortRuleNameToFullName(currRuleShortName),\n            idxInCallingRule: currRuleIdx,\n            inRule: this.shortRuleNameToFullName(prevRuleShortName),\n        };\n    }\n    buildFullFollowKeyStack() {\n        const explicitRuleStack = this.RULE_STACK;\n        const explicitOccurrenceStack = this.RULE_OCCURRENCE_STACK;\n        return map(explicitRuleStack, (ruleName, idx) => {\n            if (idx === 0) {\n                return EOF_FOLLOW_KEY;\n            }\n            return {\n                ruleName: this.shortRuleNameToFullName(ruleName),\n                idxInCallingRule: explicitOccurrenceStack[idx],\n                inRule: this.shortRuleNameToFullName(explicitRuleStack[idx - 1]),\n            };\n        });\n    }\n    flattenFollowSet() {\n        const followStack = map(this.buildFullFollowKeyStack(), (currKey) => {\n            return this.getFollowSetFromFollowKey(currKey);\n        });\n        return flatten(followStack);\n    }\n    getFollowSetFromFollowKey(followKey) {\n        if (followKey === EOF_FOLLOW_KEY) {\n            return [EOF];\n        }\n        const followName = followKey.ruleName + followKey.idxInCallingRule + IN + followKey.inRule;\n        return this.resyncFollows[followName];\n    }\n    // It does not make any sense to include a virtual EOF token in the list of resynced tokens\n    // as EOF does not really exist and thus does not contain any useful information (line/column numbers)\n    addToResyncTokens(token, resyncTokens) {\n        if (!this.tokenMatcher(token, EOF)) {\n            resyncTokens.push(token);\n        }\n        return resyncTokens;\n    }\n    reSyncTo(tokType) {\n        const resyncedTokens = [];\n        let nextTok = this.LA(1);\n        while (this.tokenMatcher(nextTok, tokType) === false) {\n            nextTok = this.SKIP_TOKEN();\n            this.addToResyncTokens(nextTok, resyncedTokens);\n        }\n        // the last token is not part of the error.\n        return dropRight(resyncedTokens);\n    }\n    attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {\n        // by default this is a NO-OP\n        // The actual implementation is with the function(not method) below\n    }\n    getCurrentGrammarPath(tokType, tokIdxInRule) {\n        const pathRuleStack = this.getHumanReadableRuleStack();\n        const pathOccurrenceStack = clone(this.RULE_OCCURRENCE_STACK);\n        const grammarPath = {\n            ruleStack: pathRuleStack,\n            occurrenceStack: pathOccurrenceStack,\n            lastTok: tokType,\n            lastTokOccurrence: tokIdxInRule,\n        };\n        return grammarPath;\n    }\n    getHumanReadableRuleStack() {\n        return map(this.RULE_STACK, (currShortName) => this.shortRuleNameToFullName(currShortName));\n    }\n}\nexport function attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {\n    const key = this.getKeyForAutomaticLookahead(dslMethodIdx, prodOccurrence);\n    let firstAfterRepInfo = this.firstAfterRepMap[key];\n    if (firstAfterRepInfo === undefined) {\n        const currRuleName = this.getCurrRuleFullName();\n        const ruleGrammar = this.getGAstProductions()[currRuleName];\n        const walker = new nextToksWalker(ruleGrammar, prodOccurrence);\n        firstAfterRepInfo = walker.startWalking();\n        this.firstAfterRepMap[key] = firstAfterRepInfo;\n    }\n    let expectTokAfterLastMatch = firstAfterRepInfo.token;\n    let nextTokIdx = firstAfterRepInfo.occurrence;\n    const isEndOfRule = firstAfterRepInfo.isEndOfRule;\n    // special edge case of a TOP most repetition after which the input should END.\n    // this will force an attempt for inRule recovery in that scenario.\n    if (this.RULE_STACK.length === 1 &&\n        isEndOfRule &&\n        expectTokAfterLastMatch === undefined) {\n        expectTokAfterLastMatch = EOF;\n        nextTokIdx = 1;\n    }\n    // We don't have anything to re-sync to...\n    // this condition was extracted from `shouldInRepetitionRecoveryBeTried` to act as a type-guard\n    if (expectTokAfterLastMatch === undefined || nextTokIdx === undefined) {\n        return;\n    }\n    if (this.shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck)) {\n        // TODO: performance optimization: instead of passing the original args here, we modify\n        // the args param (or create a new one) and make sure the lookahead func is explicitly provided\n        // to avoid searching the cache for it once more.\n        this.tryInRepetitionRecovery(prodFunc, args, lookaheadFunc, expectTokAfterLastMatch);\n    }\n}\n//# sourceMappingURL=recoverable.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/tree_builder.mjs

@@ -0,0 +1,171 @@
+import { setNodeLocationFull, setNodeLocationOnlyOffset, addTerminalToCst, addNoneTerminalToCst } from "../../cst/cst.mjs";
+import { createBaseSemanticVisitorConstructor, createBaseVisitorConstructorWithDefaults } from "../../cst/cst_visitor.mjs";
+import { DEFAULT_PARSER_CONFIG } from "../parser.mjs";
+import has from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.mjs";
+import noop from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/noop.mjs";
+import isUndefined from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isUndefined.mjs";
+import keys from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/keys.mjs";
+class TreeBuilder {
+  initTreeBuilder(config) {
+    this.CST_STACK = [];
+    this.outputCst = config.outputCst;
+    this.nodeLocationTracking = has(config, "nodeLocationTracking") ? config.nodeLocationTracking : DEFAULT_PARSER_CONFIG.nodeLocationTracking;
+    if (!this.outputCst) {
+      this.cstInvocationStateUpdate = noop;
+      this.cstFinallyStateUpdate = noop;
+      this.cstPostTerminal = noop;
+      this.cstPostNonTerminal = noop;
+      this.cstPostRule = noop;
+    } else {
+      if (/full/i.test(this.nodeLocationTracking)) {
+        if (this.recoveryEnabled) {
+          this.setNodeLocationFromToken = setNodeLocationFull;
+          this.setNodeLocationFromNode = setNodeLocationFull;
+          this.cstPostRule = noop;
+          this.setInitialNodeLocation = this.setInitialNodeLocationFullRecovery;
+        } else {
+          this.setNodeLocationFromToken = noop;
+          this.setNodeLocationFromNode = noop;
+          this.cstPostRule = this.cstPostRuleFull;
+          this.setInitialNodeLocation = this.setInitialNodeLocationFullRegular;
+        }
+      } else if (/onlyOffset/i.test(this.nodeLocationTracking)) {
+        if (this.recoveryEnabled) {
+          this.setNodeLocationFromToken = setNodeLocationOnlyOffset;
+          this.setNodeLocationFromNode = setNodeLocationOnlyOffset;
+          this.cstPostRule = noop;
+          this.setInitialNodeLocation = this.setInitialNodeLocationOnlyOffsetRecovery;
+        } else {
+          this.setNodeLocationFromToken = noop;
+          this.setNodeLocationFromNode = noop;
+          this.cstPostRule = this.cstPostRuleOnlyOffset;
+          this.setInitialNodeLocation = this.setInitialNodeLocationOnlyOffsetRegular;
+        }
+      } else if (/none/i.test(this.nodeLocationTracking)) {
+        this.setNodeLocationFromToken = noop;
+        this.setNodeLocationFromNode = noop;
+        this.cstPostRule = noop;
+        this.setInitialNodeLocation = noop;
+      } else {
+        throw Error(`Invalid <nodeLocationTracking> config option: "${config.nodeLocationTracking}"`);
+      }
+    }
+  }
+  setInitialNodeLocationOnlyOffsetRecovery(cstNode) {
+    cstNode.location = {
+      startOffset: NaN,
+      endOffset: NaN
+    };
+  }
+  setInitialNodeLocationOnlyOffsetRegular(cstNode) {
+    cstNode.location = {
+      // without error recovery the starting Location of a new CstNode is guaranteed
+      // To be the next Token's startOffset (for valid inputs).
+      // For invalid inputs there won't be any CSTOutput so this potential
+      // inaccuracy does not matter
+      startOffset: this.LA(1).startOffset,
+      endOffset: NaN
+    };
+  }
+  setInitialNodeLocationFullRecovery(cstNode) {
+    cstNode.location = {
+      startOffset: NaN,
+      startLine: NaN,
+      startColumn: NaN,
+      endOffset: NaN,
+      endLine: NaN,
+      endColumn: NaN
+    };
+  }
+  /**
+       *  @see setInitialNodeLocationOnlyOffsetRegular for explanation why this work
+  
+       * @param cstNode
+       */
+  setInitialNodeLocationFullRegular(cstNode) {
+    const nextToken = this.LA(1);
+    cstNode.location = {
+      startOffset: nextToken.startOffset,
+      startLine: nextToken.startLine,
+      startColumn: nextToken.startColumn,
+      endOffset: NaN,
+      endLine: NaN,
+      endColumn: NaN
+    };
+  }
+  cstInvocationStateUpdate(fullRuleName) {
+    const cstNode = {
+      name: fullRuleName,
+      children: /* @__PURE__ */ Object.create(null)
+    };
+    this.setInitialNodeLocation(cstNode);
+    this.CST_STACK.push(cstNode);
+  }
+  cstFinallyStateUpdate() {
+    this.CST_STACK.pop();
+  }
+  cstPostRuleFull(ruleCstNode) {
+    const prevToken = this.LA(0);
+    const loc = ruleCstNode.location;
+    if (loc.startOffset <= prevToken.startOffset === true) {
+      loc.endOffset = prevToken.endOffset;
+      loc.endLine = prevToken.endLine;
+      loc.endColumn = prevToken.endColumn;
+    } else {
+      loc.startOffset = NaN;
+      loc.startLine = NaN;
+      loc.startColumn = NaN;
+    }
+  }
+  cstPostRuleOnlyOffset(ruleCstNode) {
+    const prevToken = this.LA(0);
+    const loc = ruleCstNode.location;
+    if (loc.startOffset <= prevToken.startOffset === true) {
+      loc.endOffset = prevToken.endOffset;
+    } else {
+      loc.startOffset = NaN;
+    }
+  }
+  cstPostTerminal(key, consumedToken) {
+    const rootCst = this.CST_STACK[this.CST_STACK.length - 1];
+    addTerminalToCst(rootCst, consumedToken, key);
+    this.setNodeLocationFromToken(rootCst.location, consumedToken);
+  }
+  cstPostNonTerminal(ruleCstResult, ruleName) {
+    const preCstNode = this.CST_STACK[this.CST_STACK.length - 1];
+    addNoneTerminalToCst(preCstNode, ruleName, ruleCstResult);
+    this.setNodeLocationFromNode(preCstNode.location, ruleCstResult.location);
+  }
+  getBaseCstVisitorConstructor() {
+    if (isUndefined(this.baseCstVisitorConstructor)) {
+      const newBaseCstVisitorConstructor = createBaseSemanticVisitorConstructor(this.className, keys(this.gastProductionsCache));
+      this.baseCstVisitorConstructor = newBaseCstVisitorConstructor;
+      return newBaseCstVisitorConstructor;
+    }
+    return this.baseCstVisitorConstructor;
+  }
+  getBaseCstVisitorConstructorWithDefaults() {
+    if (isUndefined(this.baseCstVisitorWithDefaultsConstructor)) {
+      const newConstructor = createBaseVisitorConstructorWithDefaults(this.className, keys(this.gastProductionsCache), this.getBaseCstVisitorConstructor());
+      this.baseCstVisitorWithDefaultsConstructor = newConstructor;
+      return newConstructor;
+    }
+    return this.baseCstVisitorWithDefaultsConstructor;
+  }
+  getLastExplicitRuleShortName() {
+    const ruleStack = this.RULE_STACK;
+    return ruleStack[ruleStack.length - 1];
+  }
+  getPreviousExplicitRuleShortName() {
+    const ruleStack = this.RULE_STACK;
+    return ruleStack[ruleStack.length - 2];
+  }
+  getLastExplicitRuleOccurrenceIndex() {
+    const occurrenceStack = this.RULE_OCCURRENCE_STACK;
+    return occurrenceStack[occurrenceStack.length - 1];
+  }
+}
+export {
+  TreeBuilder
+};
+//# sourceMappingURL=tree_builder.mjs.map

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/tree_builder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree_builder.mjs","sources":["../../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/tree_builder.js"],"sourcesContent":["import { addNoneTerminalToCst, addTerminalToCst, setNodeLocationFull, setNodeLocationOnlyOffset, } from \"../../cst/cst.js\";\nimport { has, isUndefined, keys, noop } from \"lodash-es\";\nimport { createBaseSemanticVisitorConstructor, createBaseVisitorConstructorWithDefaults, } from \"../../cst/cst_visitor.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\n/**\n * This trait is responsible for the CST building logic.\n */\nexport class TreeBuilder {\n    initTreeBuilder(config) {\n        this.CST_STACK = [];\n        // outputCst is no longer exposed/defined in the pubic API\n        this.outputCst = config.outputCst;\n        this.nodeLocationTracking = has(config, \"nodeLocationTracking\")\n            ? config.nodeLocationTracking // assumes end user provides the correct config value/type\n            : DEFAULT_PARSER_CONFIG.nodeLocationTracking;\n        if (!this.outputCst) {\n            this.cstInvocationStateUpdate = noop;\n            this.cstFinallyStateUpdate = noop;\n            this.cstPostTerminal = noop;\n            this.cstPostNonTerminal = noop;\n            this.cstPostRule = noop;\n        }\n        else {\n            if (/full/i.test(this.nodeLocationTracking)) {\n                if (this.recoveryEnabled) {\n                    this.setNodeLocationFromToken = setNodeLocationFull;\n                    this.setNodeLocationFromNode = setNodeLocationFull;\n                    this.cstPostRule = noop;\n                    this.setInitialNodeLocation = this.setInitialNodeLocationFullRecovery;\n                }\n                else {\n                    this.setNodeLocationFromToken = noop;\n                    this.setNodeLocationFromNode = noop;\n                    this.cstPostRule = this.cstPostRuleFull;\n                    this.setInitialNodeLocation = this.setInitialNodeLocationFullRegular;\n                }\n            }\n            else if (/onlyOffset/i.test(this.nodeLocationTracking)) {\n                if (this.recoveryEnabled) {\n                    this.setNodeLocationFromToken = setNodeLocationOnlyOffset;\n                    this.setNodeLocationFromNode = setNodeLocationOnlyOffset;\n                    this.cstPostRule = noop;\n                    this.setInitialNodeLocation =\n                        this.setInitialNodeLocationOnlyOffsetRecovery;\n                }\n                else {\n                    this.setNodeLocationFromToken = noop;\n                    this.setNodeLocationFromNode = noop;\n                    this.cstPostRule = this.cstPostRuleOnlyOffset;\n                    this.setInitialNodeLocation =\n                        this.setInitialNodeLocationOnlyOffsetRegular;\n                }\n            }\n            else if (/none/i.test(this.nodeLocationTracking)) {\n                this.setNodeLocationFromToken = noop;\n                this.setNodeLocationFromNode = noop;\n                this.cstPostRule = noop;\n                this.setInitialNodeLocation = noop;\n            }\n            else {\n                throw Error(`Invalid <nodeLocationTracking> config option: \"${config.nodeLocationTracking}\"`);\n            }\n        }\n    }\n    setInitialNodeLocationOnlyOffsetRecovery(cstNode) {\n        cstNode.location = {\n            startOffset: NaN,\n            endOffset: NaN,\n        };\n    }\n    setInitialNodeLocationOnlyOffsetRegular(cstNode) {\n        cstNode.location = {\n            // without error recovery the starting Location of a new CstNode is guaranteed\n            // To be the next Token's startOffset (for valid inputs).\n            // For invalid inputs there won't be any CSTOutput so this potential\n            // inaccuracy does not matter\n            startOffset: this.LA(1).startOffset,\n            endOffset: NaN,\n        };\n    }\n    setInitialNodeLocationFullRecovery(cstNode) {\n        cstNode.location = {\n            startOffset: NaN,\n            startLine: NaN,\n            startColumn: NaN,\n            endOffset: NaN,\n            endLine: NaN,\n            endColumn: NaN,\n        };\n    }\n    /**\n       *  @see setInitialNodeLocationOnlyOffsetRegular for explanation why this work\n  \n       * @param cstNode\n       */\n    setInitialNodeLocationFullRegular(cstNode) {\n        const nextToken = this.LA(1);\n        cstNode.location = {\n            startOffset: nextToken.startOffset,\n            startLine: nextToken.startLine,\n            startColumn: nextToken.startColumn,\n            endOffset: NaN,\n            endLine: NaN,\n            endColumn: NaN,\n        };\n    }\n    cstInvocationStateUpdate(fullRuleName) {\n        const cstNode = {\n            name: fullRuleName,\n            children: Object.create(null),\n        };\n        this.setInitialNodeLocation(cstNode);\n        this.CST_STACK.push(cstNode);\n    }\n    cstFinallyStateUpdate() {\n        this.CST_STACK.pop();\n    }\n    cstPostRuleFull(ruleCstNode) {\n        // casts to `required<CstNodeLocation>` are safe because `cstPostRuleFull` should only be invoked when full location is enabled\n        const prevToken = this.LA(0);\n        const loc = ruleCstNode.location;\n        // If this condition is true it means we consumed at least one Token\n        // In this CstNode.\n        if (loc.startOffset <= prevToken.startOffset === true) {\n            loc.endOffset = prevToken.endOffset;\n            loc.endLine = prevToken.endLine;\n            loc.endColumn = prevToken.endColumn;\n        }\n        // \"empty\" CstNode edge case\n        else {\n            loc.startOffset = NaN;\n            loc.startLine = NaN;\n            loc.startColumn = NaN;\n        }\n    }\n    cstPostRuleOnlyOffset(ruleCstNode) {\n        const prevToken = this.LA(0);\n        // `location' is not null because `cstPostRuleOnlyOffset` will only be invoked when location tracking is enabled.\n        const loc = ruleCstNode.location;\n        // If this condition is true it means we consumed at least one Token\n        // In this CstNode.\n        if (loc.startOffset <= prevToken.startOffset === true) {\n            loc.endOffset = prevToken.endOffset;\n        }\n        // \"empty\" CstNode edge case\n        else {\n            loc.startOffset = NaN;\n        }\n    }\n    cstPostTerminal(key, consumedToken) {\n        const rootCst = this.CST_STACK[this.CST_STACK.length - 1];\n        addTerminalToCst(rootCst, consumedToken, key);\n        // This is only used when **both** error recovery and CST Output are enabled.\n        this.setNodeLocationFromToken(rootCst.location, consumedToken);\n    }\n    cstPostNonTerminal(ruleCstResult, ruleName) {\n        const preCstNode = this.CST_STACK[this.CST_STACK.length - 1];\n        addNoneTerminalToCst(preCstNode, ruleName, ruleCstResult);\n        // This is only used when **both** error recovery and CST Output are enabled.\n        this.setNodeLocationFromNode(preCstNode.location, ruleCstResult.location);\n    }\n    getBaseCstVisitorConstructor() {\n        if (isUndefined(this.baseCstVisitorConstructor)) {\n            const newBaseCstVisitorConstructor = createBaseSemanticVisitorConstructor(this.className, keys(this.gastProductionsCache));\n            this.baseCstVisitorConstructor = newBaseCstVisitorConstructor;\n            return newBaseCstVisitorConstructor;\n        }\n        return this.baseCstVisitorConstructor;\n    }\n    getBaseCstVisitorConstructorWithDefaults() {\n        if (isUndefined(this.baseCstVisitorWithDefaultsConstructor)) {\n            const newConstructor = createBaseVisitorConstructorWithDefaults(this.className, keys(this.gastProductionsCache), this.getBaseCstVisitorConstructor());\n            this.baseCstVisitorWithDefaultsConstructor = newConstructor;\n            return newConstructor;\n        }\n        return this.baseCstVisitorWithDefaultsConstructor;\n    }\n    getLastExplicitRuleShortName() {\n        const ruleStack = this.RULE_STACK;\n        return ruleStack[ruleStack.length - 1];\n    }\n    getPreviousExplicitRuleShortName() {\n        const ruleStack = this.RULE_STACK;\n        return ruleStack[ruleStack.length - 2];\n    }\n    getLastExplicitRuleOccurrenceIndex() {\n        const occurrenceStack = this.RULE_OCCURRENCE_STACK;\n        return occurrenceStack[occurrenceStack.length - 1];\n    }\n}\n//# sourceMappingURL=tree_builder.js.map"],"names":[],"mappings":";;;;;;;AAOO,MAAM,YAAY;AAAA,EACrB,gBAAgB,QAAQ;AACpB,SAAK,YAAY,CAAA;AAEjB,SAAK,YAAY,OAAO;AACxB,SAAK,uBAAuB,IAAI,QAAQ,sBAAsB,IACxD,OAAO,uBACP,sBAAsB;AAC5B,QAAI,CAAC,KAAK,WAAW;AACjB,WAAK,2BAA2B;AAChC,WAAK,wBAAwB;AAC7B,WAAK,kBAAkB;AACvB,WAAK,qBAAqB;AAC1B,WAAK,cAAc;AAAA,IACvB,OACK;AACD,UAAI,QAAQ,KAAK,KAAK,oBAAoB,GAAG;AACzC,YAAI,KAAK,iBAAiB;AACtB,eAAK,2BAA2B;AAChC,eAAK,0BAA0B;AAC/B,eAAK,cAAc;AACnB,eAAK,yBAAyB,KAAK;AAAA,QACvC,OACK;AACD,eAAK,2BAA2B;AAChC,eAAK,0BAA0B;AAC/B,eAAK,cAAc,KAAK;AACxB,eAAK,yBAAyB,KAAK;AAAA,QACvC;AAAA,MACJ,WACS,cAAc,KAAK,KAAK,oBAAoB,GAAG;AACpD,YAAI,KAAK,iBAAiB;AACtB,eAAK,2BAA2B;AAChC,eAAK,0BAA0B;AAC/B,eAAK,cAAc;AACnB,eAAK,yBACD,KAAK;AAAA,QACb,OACK;AACD,eAAK,2BAA2B;AAChC,eAAK,0BAA0B;AAC/B,eAAK,cAAc,KAAK;AACxB,eAAK,yBACD,KAAK;AAAA,QACb;AAAA,MACJ,WACS,QAAQ,KAAK,KAAK,oBAAoB,GAAG;AAC9C,aAAK,2BAA2B;AAChC,aAAK,0BAA0B;AAC/B,aAAK,cAAc;AACnB,aAAK,yBAAyB;AAAA,MAClC,OACK;AACD,cAAM,MAAM,kDAAkD,OAAO,oBAAoB,GAAG;AAAA,MAChG;AAAA,IACJ;AAAA,EACJ;AAAA,EACA,yCAAyC,SAAS;AAC9C,YAAQ,WAAW;AAAA,MACf,aAAa;AAAA,MACb,WAAW;AAAA,IACvB;AAAA,EACI;AAAA,EACA,wCAAwC,SAAS;AAC7C,YAAQ,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA,MAKf,aAAa,KAAK,GAAG,CAAC,EAAE;AAAA,MACxB,WAAW;AAAA,IACvB;AAAA,EACI;AAAA,EACA,mCAAmC,SAAS;AACxC,YAAQ,WAAW;AAAA,MACf,aAAa;AAAA,MACb,WAAW;AAAA,MACX,aAAa;AAAA,MACb,WAAW;AAAA,MACX,SAAS;AAAA,MACT,WAAW;AAAA,IACvB;AAAA,EACI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,kCAAkC,SAAS;AACvC,UAAM,YAAY,KAAK,GAAG,CAAC;AAC3B,YAAQ,WAAW;AAAA,MACf,aAAa,UAAU;AAAA,MACvB,WAAW,UAAU;AAAA,MACrB,aAAa,UAAU;AAAA,MACvB,WAAW;AAAA,MACX,SAAS;AAAA,MACT,WAAW;AAAA,IACvB;AAAA,EACI;AAAA,EACA,yBAAyB,cAAc;AACnC,UAAM,UAAU;AAAA,MACZ,MAAM;AAAA,MACN,UAAU,uBAAO,OAAO,IAAI;AAAA,IACxC;AACQ,SAAK,uBAAuB,OAAO;AACnC,SAAK,UAAU,KAAK,OAAO;AAAA,EAC/B;AAAA,EACA,wBAAwB;AACpB,SAAK,UAAU,IAAG;AAAA,EACtB;AAAA,EACA,gBAAgB,aAAa;AAEzB,UAAM,YAAY,KAAK,GAAG,CAAC;AAC3B,UAAM,MAAM,YAAY;AAGxB,QAAI,IAAI,eAAe,UAAU,gBAAgB,MAAM;AACnD,UAAI,YAAY,UAAU;AAC1B,UAAI,UAAU,UAAU;AACxB,UAAI,YAAY,UAAU;AAAA,IAC9B,OAEK;AACD,UAAI,cAAc;AAClB,UAAI,YAAY;AAChB,UAAI,cAAc;AAAA,IACtB;AAAA,EACJ;AAAA,EACA,sBAAsB,aAAa;AAC/B,UAAM,YAAY,KAAK,GAAG,CAAC;AAE3B,UAAM,MAAM,YAAY;AAGxB,QAAI,IAAI,eAAe,UAAU,gBAAgB,MAAM;AACnD,UAAI,YAAY,UAAU;AAAA,IAC9B,OAEK;AACD,UAAI,cAAc;AAAA,IACtB;AAAA,EACJ;AAAA,EACA,gBAAgB,KAAK,eAAe;AAChC,UAAM,UAAU,KAAK,UAAU,KAAK,UAAU,SAAS,CAAC;AACxD,qBAAiB,SAAS,eAAe,GAAG;AAE5C,SAAK,yBAAyB,QAAQ,UAAU,aAAa;AAAA,EACjE;AAAA,EACA,mBAAmB,eAAe,UAAU;AACxC,UAAM,aAAa,KAAK,UAAU,KAAK,UAAU,SAAS,CAAC;AAC3D,yBAAqB,YAAY,UAAU,aAAa;AAExD,SAAK,wBAAwB,WAAW,UAAU,cAAc,QAAQ;AAAA,EAC5E;AAAA,EACA,+BAA+B;AAC3B,QAAI,YAAY,KAAK,yBAAyB,GAAG;AAC7C,YAAM,+BAA+B,qCAAqC,KAAK,WAAW,KAAK,KAAK,oBAAoB,CAAC;AACzH,WAAK,4BAA4B;AACjC,aAAO;AAAA,IACX;AACA,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,2CAA2C;AACvC,QAAI,YAAY,KAAK,qCAAqC,GAAG;AACzD,YAAM,iBAAiB,yCAAyC,KAAK,WAAW,KAAK,KAAK,oBAAoB,GAAG,KAAK,8BAA8B;AACpJ,WAAK,wCAAwC;AAC7C,aAAO;AAAA,IACX;AACA,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,+BAA+B;AAC3B,UAAM,YAAY,KAAK;AACvB,WAAO,UAAU,UAAU,SAAS,CAAC;AAAA,EACzC;AAAA,EACA,mCAAmC;AAC/B,UAAM,YAAY,KAAK;AACvB,WAAO,UAAU,UAAU,SAAS,CAAC;AAAA,EACzC;AAAA,EACA,qCAAqC;AACjC,UAAM,kBAAkB,KAAK;AAC7B,WAAO,gBAAgB,gBAAgB,SAAS,CAAC;AAAA,EACrD;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/utils/apply_mixins.mjs

@@ -0,0 +1,20 @@
+function applyMixins(derivedCtor, baseCtors) {
+  baseCtors.forEach((baseCtor) => {
+    const baseProto = baseCtor.prototype;
+    Object.getOwnPropertyNames(baseProto).forEach((propName) => {
+      if (propName === "constructor") {
+        return;
+      }
+      const basePropDescriptor = Object.getOwnPropertyDescriptor(baseProto, propName);
+      if (basePropDescriptor && (basePropDescriptor.get || basePropDescriptor.set)) {
+        Object.defineProperty(derivedCtor.prototype, propName, basePropDescriptor);
+      } else {
+        derivedCtor.prototype[propName] = baseCtor.prototype[propName];
+      }
+    });
+  });
+}
+export {
+  applyMixins
+};
+//# sourceMappingURL=apply_mixins.mjs.map

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/utils/apply_mixins.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply_mixins.mjs","sources":["../../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/utils/apply_mixins.js"],"sourcesContent":["export function applyMixins(derivedCtor, baseCtors) {\n    baseCtors.forEach((baseCtor) => {\n        const baseProto = baseCtor.prototype;\n        Object.getOwnPropertyNames(baseProto).forEach((propName) => {\n            if (propName === \"constructor\") {\n                return;\n            }\n            const basePropDescriptor = Object.getOwnPropertyDescriptor(baseProto, propName);\n            // Handle Accessors\n            if (basePropDescriptor &&\n                (basePropDescriptor.get || basePropDescriptor.set)) {\n                Object.defineProperty(derivedCtor.prototype, propName, basePropDescriptor);\n            }\n            else {\n                derivedCtor.prototype[propName] = baseCtor.prototype[propName];\n            }\n        });\n    });\n}\n//# sourceMappingURL=apply_mixins.js.map"],"names":[],"mappings":"AAAO,SAAS,YAAY,aAAa,WAAW;AAChD,YAAU,QAAQ,CAAC,aAAa;AAC5B,UAAM,YAAY,SAAS;AAC3B,WAAO,oBAAoB,SAAS,EAAE,QAAQ,CAAC,aAAa;AACxD,UAAI,aAAa,eAAe;AAC5B;AAAA,MACJ;AACA,YAAM,qBAAqB,OAAO,yBAAyB,WAAW,QAAQ;AAE9E,UAAI,uBACC,mBAAmB,OAAO,mBAAmB,MAAM;AACpD,eAAO,eAAe,YAAY,WAAW,UAAU,kBAAkB;AAAA,MAC7E,OACK;AACD,oBAAY,UAAU,QAAQ,IAAI,SAAS,UAAU,QAAQ;AAAA,MACjE;AAAA,IACJ,CAAC;AAAA,EACL,CAAC;AACL;","x_google_ignoreList":[0]}