@traqula/chevrotain 1.0.5 → 1.0.6

package/dist/cjs/lib/index.js

@@ -63,7 +63,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // ../../node_modules/chevrotain/lib/src/version.js
-var VERSION = "11.0.3";
+var VERSION = "11.2.0";
 
 // ../../node_modules/lodash-es/_freeGlobal.js
 var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
@@ -3575,6 +3575,16 @@ var RegExpParser = class {
           case "!":
             type = "NegativeLookahead";
             break;
+          case "<": {
+            switch (this.popChar()) {
+              case "=":
+                type = "Lookbehind";
+                break;
+              case "!":
+                type = "NegativeLookbehind";
+            }
+            break;
+          }
         }
         ASSERT_EXISTS(type);
         const disjunction = this.disjunction();
@@ -4066,9 +4076,9 @@ var RegExpParser = class {
           default:
             return false;
         }
-      // '(?=' or '(?!'
+      // '(?=' or '(?!' or `(?<=` or `(?<!`
       case "(":
-        return this.peekChar(1) === "?" && (this.peekChar(2) === "=" || this.peekChar(2) === "!");
+        return this.peekChar(1) === "?" && (this.peekChar(2) === "=" || this.peekChar(2) === "!" || this.peekChar(2) === "<" && (this.peekChar(3) === "=" || this.peekChar(3) === "!"));
       default:
         return false;
     }
@@ -4188,6 +4198,12 @@ var BaseRegExpVisitor = class {
       case "NegativeLookahead":
         this.visitNegativeLookahead(node);
         break;
+      case "Lookbehind":
+        this.visitLookbehind(node);
+        break;
+      case "NegativeLookbehind":
+        this.visitNegativeLookbehind(node);
+        break;
       case "Character":
         this.visitCharacter(node);
         break;
@@ -4227,6 +4243,10 @@ var BaseRegExpVisitor = class {
   }
   visitNegativeLookahead(node) {
   }
+  visitLookbehind(node) {
+  }
+  visitNegativeLookbehind(node) {
+  }
   // atoms
   visitCharacter(node) {
   }
@@ -4306,6 +4326,8 @@ function firstCharOptimizedIndices(ast, result, ignoreCase) {
           // assertions do not affect potential starting codes
           case "Lookahead":
           case "NegativeLookahead":
+          case "Lookbehind":
+          case "NegativeLookbehind":
           case "StartAnchor":
           case "WordBoundary":
           case "NonWordBoundary":
@@ -4428,6 +4450,12 @@ var CharCodeFinder = class extends BaseRegExpVisitor {
       case "NegativeLookahead":
         this.visitNegativeLookahead(node);
         return;
+      case "Lookbehind":
+        this.visitLookbehind(node);
+        return;
+      case "NegativeLookbehind":
+        this.visitNegativeLookbehind(node);
+        return;
     }
     super.visitChildren(node);
   }
@@ -4465,10 +4493,8 @@ function canMatchCharCode(charCodes, pattern) {
 var PATTERN = "PATTERN";
 var DEFAULT_MODE = "defaultMode";
 var MODES = "modes";
-var SUPPORT_STICKY = typeof new RegExp("(?:)").sticky === "boolean";
 function analyzeTokenTypes(tokenTypes, options) {
   options = defaults_default(options, {
-    useSticky: SUPPORT_STICKY,
     debug: false,
     safeMode: false,
     positionTracking: "full",
@@ -4517,7 +4543,7 @@ function analyzeTokenTypes(tokenTypes, options) {
         ], regExpSource[1])) {
           return regExpSource[1];
         } else {
-          return options.useSticky ? addStickyFlag(currPattern) : addStartOfInput(currPattern);
+          return addStickyFlag(currPattern);
         }
       } else if (isFunction_default(currPattern)) {
         hasCustom = true;
@@ -4531,7 +4557,7 @@ function analyzeTokenTypes(tokenTypes, options) {
         } else {
           const escapedRegExpString = currPattern.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
           const wrappedRegExp = new RegExp(escapedRegExpString);
-          return options.useSticky ? addStickyFlag(wrappedRegExp) : addStartOfInput(wrappedRegExp);
+          return addStickyFlag(wrappedRegExp);
         }
       } else {
         throw Error("non exhaustive match");
@@ -4883,24 +4909,27 @@ function findUnreachablePatterns(tokenTypes) {
     }
     return result;
   }, []);
-  forEach_default(tokenTypes, (tokType, testIdx) => {
-    forEach_default(canBeTested, ({ str, idx, tokenType }) => {
-      if (testIdx < idx && testTokenType(str, tokType.PATTERN)) {
-        const msg = `Token: ->${tokenType.name}<- can never be matched.
-Because it appears AFTER the Token Type ->${tokType.name}<-in the lexer's definition.
+  forEach_default(tokenTypes, (aTokType, aIdx) => {
+    forEach_default(canBeTested, ({ str: bStr, idx: bIdx, tokenType: bTokType }) => {
+      if (aIdx < bIdx && tryToMatchStrToPattern(bStr, aTokType.PATTERN)) {
+        const msg = `Token: ->${bTokType.name}<- can never be matched.
+Because it appears AFTER the Token Type ->${aTokType.name}<-in the lexer's definition.
 See https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNREACHABLE`;
         errors.push({
           message: msg,
           type: LexerDefinitionErrorType.UNREACHABLE_PATTERN,
-          tokenTypes: [tokType, tokenType]
+          tokenTypes: [aTokType, bTokType]
         });
       }
     });
   });
   return errors;
 }
-function testTokenType(str, pattern) {
+function tryToMatchStrToPattern(str, pattern) {
   if (isRegExp_default(pattern)) {
+    if (usesLookAheadOrBehind(pattern)) {
+      return false;
+    }
     const regExpArray = pattern.exec(str);
     return regExpArray !== null && regExpArray.index === 0;
   } else if (isFunction_default(pattern)) {
@@ -4931,9 +4960,8 @@ function noMetaChar(regExp) {
   ];
   return find_default(metaChars, (char) => regExp.source.indexOf(char) !== -1) === void 0;
 }
-function addStartOfInput(pattern) {
-  const flags = pattern.ignoreCase ? "i" : "";
-  return new RegExp(`^(?:${pattern.source})`, flags);
+function usesLookAheadOrBehind(regExp) {
+  return /(\(\?=)|(\(\?!)|(\(\?<=)|(\(\?<!)/.test(regExp.source);
 }
 function addStickyFlag(pattern) {
   const flags = pattern.ignoreCase ? "iy" : "y";
@@ -5252,7 +5280,7 @@ var defaultLexerErrorProvider = {
   buildUnableToPopLexerModeMessage(token) {
     return `Unable to pop Lexer Mode after encountering Token ->${token.image}<- The Mode Stack is empty`;
   },
-  buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column) {
+  buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column, mode) {
     return `unexpected character: ->${fullText.charAt(startOffset)}<- at offset: ${startOffset}, skipped ${length} characters.`;
   }
 };
@@ -5415,13 +5443,6 @@ var Lexer = class {
         PRINT_WARNING(warningDescriptor.message);
       });
       this.TRACE_INIT("Choosing sub-methods implementations", () => {
-        if (SUPPORT_STICKY) {
-          this.chopInput = identity_default;
-          this.match = this.matchWithTest;
-        } else {
-          this.updateLastIndex = noop_default;
-          this.match = this.matchWithExec;
-        }
         if (hasOnlySingleMode) {
           this.handleModes = noop_default;
         }
@@ -5484,7 +5505,7 @@ var Lexer = class {
   // this method also used quite a bit of `!` none null assertions because it is too optimized
   // for `tsc` to always understand it is "safe"
   tokenizeInternal(text, initialMode) {
-    let i, j, k, matchAltImage, longerAlt, matchedImage, payload, altPayload, imageLength, group, tokType, newToken, errLength, droppedChar, msg, match;
+    let i, j, k, matchAltImage, longerAlt, matchedImage, payload, altPayload, imageLength, group, tokType, newToken, errLength, msg, match;
     const orgText = text;
     const orgLength = orgText.length;
     let offset = 0;
@@ -5503,19 +5524,7 @@ var Lexer = class {
     const modeStack = [];
     const emptyArray = [];
     Object.freeze(emptyArray);
-    let getPossiblePatterns;
-    function getPossiblePatternsSlow() {
-      return patternIdxToConfig;
-    }
-    function getPossiblePatternsOptimized(charCode) {
-      const optimizedCharIdx = charCodeToOptimizedIndex(charCode);
-      const possiblePatterns = currCharCodeToPatternIdxToConfig[optimizedCharIdx];
-      if (possiblePatterns === void 0) {
-        return emptyArray;
-      } else {
-        return possiblePatterns;
-      }
-    }
+    let isOptimizedMode = false;
     const pop_mode = (popToken) => {
       if (modeStack.length === 1 && // if we have both a POP_MODE and a PUSH_MODE this is in-fact a "transition"
       // So no error should occur.
@@ -5536,9 +5545,9 @@ var Lexer = class {
         currModePatternsLength = patternIdxToConfig.length;
         const modeCanBeOptimized = this.canModeBeOptimized[newMode] && this.config.safeMode === false;
         if (currCharCodeToPatternIdxToConfig && modeCanBeOptimized) {
-          getPossiblePatterns = getPossiblePatternsOptimized;
+          isOptimizedMode = true;
         } else {
-          getPossiblePatterns = getPossiblePatternsSlow;
+          isOptimizedMode = false;
         }
       }
     };
@@ -5550,9 +5559,9 @@ var Lexer = class {
       currModePatternsLength = patternIdxToConfig.length;
       const modeCanBeOptimized = this.canModeBeOptimized[newMode] && this.config.safeMode === false;
       if (currCharCodeToPatternIdxToConfig && modeCanBeOptimized) {
-        getPossiblePatterns = getPossiblePatternsOptimized;
+        isOptimizedMode = true;
       } else {
-        getPossiblePatterns = getPossiblePatternsSlow;
+        isOptimizedMode = false;
       }
     }
     push_mode.call(this, initialMode);
@@ -5560,8 +5569,16 @@ var Lexer = class {
     const recoveryEnabled = this.config.recoveryEnabled;
     while (offset < orgLength) {
       matchedImage = null;
+      imageLength = -1;
       const nextCharCode = orgText.charCodeAt(offset);
-      const chosenPatternIdxToConfig = getPossiblePatterns(nextCharCode);
+      let chosenPatternIdxToConfig;
+      if (isOptimizedMode) {
+        const optimizedCharIdx = charCodeToOptimizedIndex(nextCharCode);
+        const possiblePatterns = currCharCodeToPatternIdxToConfig[optimizedCharIdx];
+        chosenPatternIdxToConfig = possiblePatterns !== void 0 ? possiblePatterns : emptyArray;
+      } else {
+        chosenPatternIdxToConfig = patternIdxToConfig;
+      }
       const chosenPatternsLength = chosenPatternIdxToConfig.length;
       for (i = 0; i < chosenPatternsLength; i++) {
         currConfig = chosenPatternIdxToConfig[i];
@@ -5570,12 +5587,14 @@ var Lexer = class {
         const singleCharCode = currConfig.short;
         if (singleCharCode !== false) {
           if (nextCharCode === singleCharCode) {
+            imageLength = 1;
             matchedImage = currPattern;
           }
         } else if (currConfig.isCustom === true) {
           match = currPattern.exec(orgText, offset, matchedTokens, groups);
           if (match !== null) {
             matchedImage = match[0];
+            imageLength = matchedImage.length;
             if (match.payload !== void 0) {
               payload = match.payload;
             }
@@ -5583,12 +5602,13 @@ var Lexer = class {
             matchedImage = null;
           }
         } else {
-          this.updateLastIndex(currPattern, offset);
-          matchedImage = this.match(currPattern, text, offset);
+          currPattern.lastIndex = offset;
+          imageLength = this.matchLength(currPattern, text, offset);
         }
-        if (matchedImage !== null) {
+        if (imageLength !== -1) {
           longerAlt = currConfig.longerAlt;
           if (longerAlt !== void 0) {
+            matchedImage = text.substring(offset, offset + imageLength);
             const longerAltLength = longerAlt.length;
             for (k = 0; k < longerAltLength; k++) {
               const longerAltConfig = patternIdxToConfig[longerAlt[k]];
@@ -5605,11 +5625,12 @@ var Lexer = class {
                   matchAltImage = null;
                 }
               } else {
-                this.updateLastIndex(longerAltPattern, offset);
+                longerAltPattern.lastIndex = offset;
                 matchAltImage = this.match(longerAltPattern, text, offset);
               }
               if (matchAltImage && matchAltImage.length > matchedImage.length) {
                 matchedImage = matchAltImage;
+                imageLength = matchAltImage.length;
                 payload = altPayload;
                 currConfig = longerAltConfig;
                 break;
@@ -5619,10 +5640,10 @@ var Lexer = class {
           break;
         }
       }
-      if (matchedImage !== null) {
-        imageLength = matchedImage.length;
+      if (imageLength !== -1) {
         group = currConfig.group;
         if (group !== void 0) {
+          matchedImage = matchedImage !== null ? matchedImage : text.substring(offset, offset + imageLength);
           tokType = currConfig.tokenTypeIdx;
           newToken = this.createTokenInstance(matchedImage, offset, tokType, currConfig.tokenType, line, column, imageLength);
           this.handlePayload(newToken, payload);
@@ -5632,15 +5653,13 @@ var Lexer = class {
             groups[group].push(newToken);
           }
         }
-        text = this.chopInput(text, imageLength);
-        offset = offset + imageLength;
-        column = this.computeNewColumn(column, imageLength);
         if (trackLines === true && currConfig.canLineTerminator === true) {
           let numOfLTsInMatch = 0;
           let foundTerminator;
           let lastLTEndOffset;
           lineTerminatorPattern.lastIndex = 0;
           do {
+            matchedImage = matchedImage !== null ? matchedImage : text.substring(offset, offset + imageLength);
             foundTerminator = lineTerminatorPattern.test(matchedImage);
             if (foundTerminator === true) {
               lastLTEndOffset = lineTerminatorPattern.lastIndex - 1;
@@ -5651,8 +5670,13 @@ var Lexer = class {
             line = line + numOfLTsInMatch;
             column = imageLength - lastLTEndOffset;
             this.updateTokenEndLineColumnLocation(newToken, group, lastLTEndOffset, numOfLTsInMatch, line, column, imageLength);
+          } else {
+            column = this.computeNewColumn(column, imageLength);
           }
+        } else {
+          column = this.computeNewColumn(column, imageLength);
         }
+        offset = offset + imageLength;
         this.handleModes(currConfig, pop_mode, push_mode, newToken);
       } else {
         const errorStartOffset = offset;
@@ -5660,7 +5684,6 @@ var Lexer = class {
         const errorColumn = column;
         let foundResyncPoint = recoveryEnabled === false;
         while (foundResyncPoint === false && offset < orgLength) {
-          text = this.chopInput(text, 1);
           offset++;
           for (j = 0; j < currModePatternsLength; j++) {
             const currConfig2 = patternIdxToConfig[j];
@@ -5673,7 +5696,7 @@ var Lexer = class {
             } else if (currConfig2.isCustom === true) {
               foundResyncPoint = currPattern.exec(orgText, offset, matchedTokens, groups) !== null;
             } else {
-              this.updateLastIndex(currPattern, offset);
+              currPattern.lastIndex = offset;
               foundResyncPoint = currPattern.exec(text) !== null;
             }
             if (foundResyncPoint === true) {
@@ -5683,7 +5706,7 @@ var Lexer = class {
         }
         errLength = offset - errorStartOffset;
         column = this.computeNewColumn(column, errLength);
-        msg = this.config.errorMessageProvider.buildUnexpectedCharactersMessage(orgText, errorStartOffset, errLength, errorLine, errorColumn);
+        msg = this.config.errorMessageProvider.buildUnexpectedCharactersMessage(orgText, errorStartOffset, errLength, errorLine, errorColumn, last_default(modeStack));
         errors.push({
           offset: errorStartOffset,
           line: errorLine,
@@ -5716,12 +5739,6 @@ var Lexer = class {
       push_mode.call(this, config.push);
     }
   }
-  chopInput(text, length) {
-    return text.substring(length);
-  }
-  updateLastIndex(regExp, newLastIndex) {
-    regExp.lastIndex = newLastIndex;
-  }
   // TODO: decrease this under 600 characters? inspect stripping comments option in TSC compiler
   updateTokenEndLineColumnLocation(newToken, group, lastLTIdx, numOfLTsInMatch, line, column, imageLength) {
     let lastCharIsLT, fixForEndingInLT;
@@ -5784,19 +5801,22 @@ var Lexer = class {
       token.payload = payload;
     }
   }
-  matchWithTest(pattern, text, offset) {
+  match(pattern, text, offset) {
     const found = pattern.test(text);
     if (found === true) {
       return text.substring(offset, pattern.lastIndex);
     }
     return null;
   }
-  matchWithExec(pattern, text) {
-    const regExpArray = pattern.exec(text);
-    return regExpArray !== null ? regExpArray[0] : null;
+  matchLength(pattern, text, offset) {
+    const found = pattern.test(text);
+    if (found === true) {
+      return pattern.lastIndex - offset;
+    }
+    return -1;
   }
 };
-Lexer.SKIPPED = "This marks a skipped Token pattern, this means each token identified by it willbe consumed and then thrown into oblivion, this can be used to for example to completely ignore whitespace.";
+Lexer.SKIPPED = "This marks a skipped Token pattern, this means each token identified by it will be consumed and then thrown into oblivion, this can be used to for example to completely ignore whitespace.";
 Lexer.NA = /NOT_APPLICABLE/;
 
 // ../../node_modules/chevrotain/lib/src/scan/tokens_public.js
@@ -5972,12 +5992,20 @@ For Further details.`;
     return errMsg;
   },
   buildAlternationAmbiguityError(options) {
-    const pathMsg = map_default(options.prefixPath, (currtok) => tokenLabel2(currtok)).join(", ");
     const occurrence = options.alternation.idx === 0 ? "" : options.alternation.idx;
+    const isEmptyPath = options.prefixPath.length === 0;
     let currMessage = `Ambiguous Alternatives Detected: <${options.ambiguityIndices.join(" ,")}> in <OR${occurrence}> inside <${options.topLevelRule.name}> Rule,
-<${pathMsg}> may appears as a prefix path in all these alternatives.
 `;
-    currMessage = currMessage + `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES
+    if (isEmptyPath) {
+      currMessage += `These alternatives are all empty (match no tokens), making them indistinguishable.
+Only the last alternative may be empty.
+`;
+    } else {
+      const pathMsg = map_default(options.prefixPath, (currtok) => tokenLabel2(currtok)).join(", ");
+      currMessage += `<${pathMsg}> may appears as a prefix path in all these alternatives.
+`;
+    }
+    currMessage += `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES
 For Further details.`;
     return currMessage;
   },
@@ -6548,7 +6576,7 @@ function buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher2, dyna
           const currPath = currAlt[j];
           const currPathLength = currPath.length;
           for (let i = 0; i < currPathLength; i++) {
-            const nextToken = this.LA(i + 1);
+            const nextToken = this.LA_FAST(i + 1);
             if (tokenMatcher2(nextToken, currPath[i]) === false) {
               continue nextPath;
             }
@@ -6576,7 +6604,7 @@ function buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher2, dyna
       return result;
     }, {});
     return function() {
-      const nextToken = this.LA(1);
+      const nextToken = this.LA_FAST(1);
       return choiceToAlt[nextToken.tokenTypeIdx];
     };
   } else {
@@ -6588,7 +6616,7 @@ function buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher2, dyna
           const currPath = currAlt[j];
           const currPathLength = currPath.length;
           for (let i = 0; i < currPathLength; i++) {
-            const nextToken = this.LA(i + 1);
+            const nextToken = this.LA_FAST(i + 1);
             if (tokenMatcher2(nextToken, currPath[i]) === false) {
               continue nextPath;
             }
@@ -6611,7 +6639,7 @@ function buildSingleAlternativeLookaheadFunction(alt, tokenMatcher2, dynamicToke
       const expectedTokenType = singleTokensTypes[0];
       const expectedTokenUniqueKey = expectedTokenType.tokenTypeIdx;
       return function() {
-        return this.LA(1).tokenTypeIdx === expectedTokenUniqueKey;
+        return this.LA_FAST(1).tokenTypeIdx === expectedTokenUniqueKey;
       };
     } else {
       const choiceToAlt = reduce_default(singleTokensTypes, (result, currTokType, idx) => {
@@ -6622,7 +6650,7 @@ function buildSingleAlternativeLookaheadFunction(alt, tokenMatcher2, dynamicToke
         return result;
       }, []);
       return function() {
-        const nextToken = this.LA(1);
+        const nextToken = this.LA_FAST(1);
         return choiceToAlt[nextToken.tokenTypeIdx] === true;
       };
     }
@@ -6632,7 +6660,7 @@ function buildSingleAlternativeLookaheadFunction(alt, tokenMatcher2, dynamicToke
         const currPath = alt[j];
         const currPathLength = currPath.length;
         for (let i = 0; i < currPathLength; i++) {
-          const nextToken = this.LA(i + 1);
+          const nextToken = this.LA_FAST(i + 1);
           if (tokenMatcher2(nextToken, currPath[i]) === false) {
             continue nextPath;
           }
@@ -7349,8 +7377,8 @@ var Recoverable = class {
     const savedLexerState = this.exportLexerState();
     const resyncedTokens = [];
     let passedResyncPoint = false;
-    const nextTokenWithoutResync = this.LA(1);
-    let currToken = this.LA(1);
+    const nextTokenWithoutResync = this.LA_FAST(1);
+    let currToken = this.LA_FAST(1);
     const generateErrorMessage = () => {
       const previousToken = this.LA(0);
       const msg = this.errorMessageProvider.buildMismatchTokenMessage({
@@ -7384,7 +7412,7 @@ var Recoverable = class {
     if (notStuck === false) {
       return false;
     }
-    if (this.tokenMatcher(this.LA(1), expectTokAfterLastMatch)) {
+    if (this.tokenMatcher(this.LA_FAST(1), expectTokAfterLastMatch)) {
       return false;
     }
     if (this.isBackTracking()) {
@@ -7423,7 +7451,7 @@ var Recoverable = class {
     if (isEmpty_default(follows)) {
       return false;
     }
-    const mismatchedTok = this.LA(1);
+    const mismatchedTok = this.LA_FAST(1);
     const isMisMatchedTokInFollows = find_default(follows, (possibleFollowsTokType) => {
       return this.tokenMatcher(mismatchedTok, possibleFollowsTokType);
     }) !== void 0;
@@ -7433,7 +7461,12 @@ var Recoverable = class {
     if (!this.canTokenTypeBeDeletedInRecovery(expectedTokType)) {
       return false;
     }
-    const isNextTokenWhatIsExpected = this.tokenMatcher(this.LA(2), expectedTokType);
+    const isNextTokenWhatIsExpected = this.tokenMatcher(
+      // not using LA_FAST because LA(2) might be un-safe with maxLookahead=1
+      // in some edge cases (?)
+      this.LA(2),
+      expectedTokType
+    );
     return isNextTokenWhatIsExpected;
   }
   isInCurrentRuleReSyncSet(tokenTypeIdx) {
@@ -7443,7 +7476,7 @@ var Recoverable = class {
   }
   findReSyncTokenType() {
     const allPossibleReSyncTokTypes = this.flattenFollowSet();
-    let nextToken = this.LA(1);
+    let nextToken = this.LA_FAST(1);
     let k = 2;
     while (true) {
       const foundMatch = find_default(allPossibleReSyncTokTypes, (resyncTokType) => {
@@ -7458,10 +7491,10 @@ var Recoverable = class {
     }
   }
   getCurrFollowKey() {
-    if (this.RULE_STACK.length === 1) {
+    if (this.RULE_STACK_IDX === 0) {
       return EOF_FOLLOW_KEY;
     }
-    const currRuleShortName = this.getLastExplicitRuleShortName();
+    const currRuleShortName = this.currRuleShortName;
     const currRuleIdx = this.getLastExplicitRuleOccurrenceIndex();
     const prevRuleShortName = this.getPreviousExplicitRuleShortName();
     return {
@@ -7473,16 +7506,20 @@ var Recoverable = class {
   buildFullFollowKeyStack() {
     const explicitRuleStack = this.RULE_STACK;
     const explicitOccurrenceStack = this.RULE_OCCURRENCE_STACK;
-    return map_default(explicitRuleStack, (ruleName, idx) => {
+    const len = this.RULE_STACK_IDX + 1;
+    const result = new Array(len);
+    for (let idx = 0; idx < len; idx++) {
       if (idx === 0) {
-        return EOF_FOLLOW_KEY;
+        result[idx] = EOF_FOLLOW_KEY;
+      } else {
+        result[idx] = {
+          ruleName: this.shortRuleNameToFullName(explicitRuleStack[idx]),
+          idxInCallingRule: explicitOccurrenceStack[idx],
+          inRule: this.shortRuleNameToFullName(explicitRuleStack[idx - 1])
+        };
       }
-      return {
-        ruleName: this.shortRuleNameToFullName(ruleName),
-        idxInCallingRule: explicitOccurrenceStack[idx],
-        inRule: this.shortRuleNameToFullName(explicitRuleStack[idx - 1])
-      };
-    });
+    }
+    return result;
   }
   flattenFollowSet() {
     const followStack = map_default(this.buildFullFollowKeyStack(), (currKey) => {
@@ -7507,7 +7544,7 @@ var Recoverable = class {
   }
   reSyncTo(tokType) {
     const resyncedTokens = [];
-    let nextTok = this.LA(1);
+    let nextTok = this.LA_FAST(1);
     while (this.tokenMatcher(nextTok, tokType) === false) {
       nextTok = this.SKIP_TOKEN();
       this.addToResyncTokens(nextTok, resyncedTokens);
@@ -7518,7 +7555,7 @@ var Recoverable = class {
   }
   getCurrentGrammarPath(tokType, tokIdxInRule) {
     const pathRuleStack = this.getHumanReadableRuleStack();
-    const pathOccurrenceStack = clone_default(this.RULE_OCCURRENCE_STACK);
+    const pathOccurrenceStack = this.RULE_OCCURRENCE_STACK.slice(0, this.RULE_OCCURRENCE_STACK_IDX + 1);
     const grammarPath = {
       ruleStack: pathRuleStack,
       occurrenceStack: pathOccurrenceStack,
@@ -7528,7 +7565,12 @@ var Recoverable = class {
     return grammarPath;
   }
   getHumanReadableRuleStack() {
-    return map_default(this.RULE_STACK, (currShortName) => this.shortRuleNameToFullName(currShortName));
+    const len = this.RULE_STACK_IDX + 1;
+    const result = new Array(len);
+    for (let i = 0; i < len; i++) {
+      result[i] = this.shortRuleNameToFullName(this.RULE_STACK[i]);
+    }
+    return result;
   }
 };
 function attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {
@@ -7544,7 +7586,7 @@ function attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx
   let expectTokAfterLastMatch = firstAfterRepInfo.token;
   let nextTokIdx = firstAfterRepInfo.occurrence;
   const isEndOfRule = firstAfterRepInfo.isEndOfRule;
-  if (this.RULE_STACK.length === 1 && isEndOfRule && expectTokAfterLastMatch === void 0) {
+  if (this.RULE_STACK_IDX === 0 && isEndOfRule && expectTokAfterLastMatch === void 0) {
     expectTokAfterLastMatch = EOF;
     nextTokIdx = 1;
   }
@@ -7672,8 +7714,7 @@ var LooksAhead = class {
   }
   // this actually returns a number, but it is always used as a string (object prop key)
   getKeyForAutomaticLookahead(dslMethodIdx, occurrence) {
-    const currRuleShortName = this.getLastExplicitRuleShortName();
-    return getKeyForAutomaticLookahead(currRuleShortName, dslMethodIdx, occurrence);
+    return getKeyForAutomaticLookahead(this.currRuleShortName, dslMethodIdx, occurrence);
   }
   getLaFuncFromCache(key) {
     return this.lookAheadFuncsCache.get(key);
@@ -7920,7 +7961,7 @@ var TreeBuilder = class {
       // 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,
+      startOffset: this.LA_FAST(1).startOffset,
       endOffset: NaN
     };
   }
@@ -7940,7 +7981,7 @@ var TreeBuilder = class {
        * @param cstNode
        */
   setInitialNodeLocationFullRegular(cstNode) {
-    const nextToken = this.LA(1);
+    const nextToken = this.LA_FAST(1);
     cstNode.location = {
       startOffset: nextToken.startOffset,
       startLine: nextToken.startLine,
@@ -8009,17 +8050,11 @@ var TreeBuilder = class {
     }
     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];
+    return this.RULE_STACK[this.RULE_STACK_IDX - 1];
   }
   getLastExplicitRuleOccurrenceIndex() {
-    const occurrenceStack = this.RULE_OCCURRENCE_STACK;
-    return occurrenceStack[occurrenceStack.length - 1];
+    return this.RULE_OCCURRENCE_STACK[this.RULE_OCCURRENCE_STACK_IDX];
   }
 };
 
@@ -8043,15 +8078,22 @@ var LexerAdapter = class {
   }
   // skips a token and returns the next token
   SKIP_TOKEN() {
-    if (this.currIdx <= this.tokVector.length - 2) {
+    if (this.currIdx <= this.tokVectorLength - 2) {
       this.consumeToken();
-      return this.LA(1);
+      return this.LA_FAST(1);
     } else {
       return END_OF_FILE;
     }
   }
   // Lexer (accessing Token vector) related methods which can be overridden to implement lazy lexers
   // or lexers dependent on parser context.
+  // Performance Optimized version of LA without bound checks
+  // note that token beyond the end of the token vector EOF Token will still be returned
+  // due to using sentinels at the end of the token vector. (for K=max lookahead)
+  LA_FAST(howMuch) {
+    const soughtIdx = this.currIdx + howMuch;
+    return this.tokVector[soughtIdx];
+  }
   LA(howMuch) {
     const soughtIdx = this.currIdx + howMuch;
     if (soughtIdx < 0 || this.tokVectorLength <= soughtIdx) {
@@ -8073,7 +8115,7 @@ var LexerAdapter = class {
     this.currIdx = -1;
   }
   moveToTerminatedState() {
-    this.currIdx = this.tokVector.length - 1;
+    this.currIdx = this.tokVectorLength - 1;
   }
   getLexerPosition() {
     return this.exportLexerState();
@@ -8369,11 +8411,13 @@ var RecognizerApi = class {
     return ruleImplementation;
   }
   BACKTRACK(grammarRule, args) {
+    var _a;
+    const ruleToCall = (_a = grammarRule.coreRule) !== null && _a !== void 0 ? _a : grammarRule;
     return function() {
       this.isBackTrackingStack.push(1);
       const orgState = this.saveRecogState();
       try {
-        grammarRule.apply(this, args);
+        ruleToCall.apply(this, args);
         return true;
       } catch (e) {
         if (isRecognitionException(e)) {
@@ -8405,11 +8449,14 @@ var RecognizerEngine = class {
     this.ruleShortNameIdx = 256;
     this.tokenMatcher = tokenStructuredMatcherNoCategories;
     this.subruleIdx = 0;
+    this.currRuleShortName = 0;
     this.definedRulesNames = [];
     this.tokensMap = {};
     this.isBackTrackingStack = [];
     this.RULE_STACK = [];
+    this.RULE_STACK_IDX = -1;
     this.RULE_OCCURRENCE_STACK = [];
+    this.RULE_OCCURRENCE_STACK_IDX = -1;
     this.gastProductionsCache = {};
     if (has_default(config, "serializedGrammar")) {
       throw Error("The Parser's configuration can no longer contain a <serializedGrammar> property.\n	See: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_6-0-0\n	For Further details.");
@@ -8456,9 +8503,9 @@ Make sure that all grammar rule definitions are done before 'performSelfAnalysis
     this.ruleShortNameIdx++;
     this.shortRuleNameToFull[shortName] = ruleName;
     this.fullRuleNameToShort[ruleName] = shortName;
-    let invokeRuleWithTry;
+    let coreRuleFunction;
     if (this.outputCst === true) {
-      invokeRuleWithTry = function invokeRuleWithTry2(...args) {
+      coreRuleFunction = function invokeRuleWithTry(...args) {
         try {
           this.ruleInvocationStateUpdate(shortName, ruleName, this.subruleIdx);
           impl.apply(this, args);
@@ -8472,7 +8519,7 @@ Make sure that all grammar rule definitions are done before 'performSelfAnalysis
         }
       };
     } else {
-      invokeRuleWithTry = function invokeRuleWithTryCst(...args) {
+      coreRuleFunction = function invokeRuleWithTryCst(...args) {
         try {
           this.ruleInvocationStateUpdate(shortName, ruleName, this.subruleIdx);
           return impl.apply(this, args);
@@ -8483,11 +8530,19 @@ Make sure that all grammar rule definitions are done before 'performSelfAnalysis
         }
       };
     }
-    const wrappedGrammarRule = Object.assign(invokeRuleWithTry, { ruleName, originalGrammarAction: impl });
+    const rootRuleFunction = function rootRule(...args) {
+      this.onBeforeParse(ruleName);
+      try {
+        return coreRuleFunction.apply(this, args);
+      } finally {
+        this.onAfterParse(ruleName);
+      }
+    };
+    const wrappedGrammarRule = Object.assign(rootRuleFunction, { ruleName, originalGrammarAction: impl, coreRule: coreRuleFunction });
     return wrappedGrammarRule;
   }
   invokeRuleCatch(e, resyncEnabledConfig, recoveryValueFunc) {
-    const isFirstInvokedRule = this.RULE_STACK.length === 1;
+    const isFirstInvokedRule = this.RULE_STACK_IDX === 0;
     const reSyncEnabled = resyncEnabledConfig && !this.isBackTracking() && this.recoveryEnabled;
     if (isRecognitionException(e)) {
       const recogError = e;
@@ -8585,9 +8640,9 @@ Make sure that all grammar rule definitions are done before 'performSelfAnalysis
     if (firstIterationLookaheadFunc.call(this) === true) {
       action.call(this);
       const separatorLookAheadFunc = () => {
-        return this.tokenMatcher(this.LA(1), separator);
+        return this.tokenMatcher(this.LA_FAST(1), separator);
       };
-      while (this.tokenMatcher(this.LA(1), separator) === true) {
+      while (this.tokenMatcher(this.LA_FAST(1), separator) === true) {
         this.CONSUME(separator);
         action.call(this);
       }
@@ -8651,9 +8706,9 @@ Make sure that all grammar rule definitions are done before 'performSelfAnalysis
     if (firstIterationLaFunc.call(this) === true) {
       action.call(this);
       const separatorLookAheadFunc = () => {
-        return this.tokenMatcher(this.LA(1), separator);
+        return this.tokenMatcher(this.LA_FAST(1), separator);
       };
-      while (this.tokenMatcher(this.LA(1), separator) === true) {
+      while (this.tokenMatcher(this.LA_FAST(1), separator) === true) {
         this.CONSUME(separator);
         action.call(this);
       }
@@ -8697,24 +8752,19 @@ Make sure that all grammar rule definitions are done before 'performSelfAnalysis
     this.raiseNoAltException(occurrence, altsOrOpts.ERR_MSG);
   }
   ruleFinallyStateUpdate() {
-    this.RULE_STACK.pop();
-    this.RULE_OCCURRENCE_STACK.pop();
-    this.cstFinallyStateUpdate();
-    if (this.RULE_STACK.length === 0 && this.isAtEndOfInput() === false) {
-      const firstRedundantTok = this.LA(1);
-      const errMsg = this.errorMessageProvider.buildNotAllInputParsedMessage({
-        firstRedundant: firstRedundantTok,
-        ruleName: this.getCurrRuleFullName()
-      });
-      this.SAVE_ERROR(new NotAllInputParsedException(errMsg, firstRedundantTok));
+    this.RULE_STACK_IDX--;
+    this.RULE_OCCURRENCE_STACK_IDX--;
+    if (this.RULE_STACK_IDX >= 0) {
+      this.currRuleShortName = this.RULE_STACK[this.RULE_STACK_IDX];
     }
+    this.cstFinallyStateUpdate();
   }
   subruleInternal(ruleToCall, idx, options) {
     let ruleResult;
     try {
       const args = options !== void 0 ? options.ARGS : void 0;
       this.subruleIdx = idx;
-      ruleResult = ruleToCall.apply(this, args);
+      ruleResult = ruleToCall.coreRule.apply(this, args);
       this.cstPostNonTerminal(ruleResult, options !== void 0 && options.LABEL !== void 0 ? options.LABEL : ruleToCall.ruleName);
       return ruleResult;
     } catch (e) {
@@ -8731,7 +8781,7 @@ Make sure that all grammar rule definitions are done before 'performSelfAnalysis
   consumeInternal(tokType, idx, options) {
     let consumedToken;
     try {
-      const nextToken = this.LA(1);
+      const nextToken = this.LA_FAST(1);
       if (this.tokenMatcher(nextToken, tokType) === true) {
         this.consumeToken();
         consumedToken = nextToken;
@@ -8778,7 +8828,7 @@ Make sure that all grammar rule definitions are done before 'performSelfAnalysis
   }
   saveRecogState() {
     const savedErrors = this.errors;
-    const savedRuleStack = clone_default(this.RULE_STACK);
+    const savedRuleStack = this.RULE_STACK.slice(0, this.RULE_STACK_IDX + 1);
     return {
       errors: savedErrors,
       lexerState: this.exportLexerState(),
@@ -8789,18 +8839,26 @@ Make sure that all grammar rule definitions are done before 'performSelfAnalysis
   reloadRecogState(newState) {
     this.errors = newState.errors;
     this.importLexerState(newState.lexerState);
-    this.RULE_STACK = newState.RULE_STACK;
+    const saved = newState.RULE_STACK;
+    for (let i = 0; i < saved.length; i++) {
+      this.RULE_STACK[i] = saved[i];
+    }
+    this.RULE_STACK_IDX = saved.length - 1;
+    if (this.RULE_STACK_IDX >= 0) {
+      this.currRuleShortName = this.RULE_STACK[this.RULE_STACK_IDX];
+    }
   }
   ruleInvocationStateUpdate(shortName, fullName, idxInCallingRule) {
-    this.RULE_OCCURRENCE_STACK.push(idxInCallingRule);
-    this.RULE_STACK.push(shortName);
+    this.RULE_OCCURRENCE_STACK[++this.RULE_OCCURRENCE_STACK_IDX] = idxInCallingRule;
+    this.RULE_STACK[++this.RULE_STACK_IDX] = shortName;
+    this.currRuleShortName = shortName;
     this.cstInvocationStateUpdate(fullName);
   }
   isBackTracking() {
     return this.isBackTrackingStack.length !== 0;
   }
   getCurrRuleFullName() {
-    const shortName = this.getLastExplicitRuleShortName();
+    const shortName = this.currRuleShortName;
     return this.shortRuleNameToFull[shortName];
   }
   shortRuleNameToFullName(shortName) {
@@ -8812,11 +8870,53 @@ Make sure that all grammar rule definitions are done before 'performSelfAnalysis
   reset() {
     this.resetLexerState();
     this.subruleIdx = 0;
+    this.currRuleShortName = 0;
     this.isBackTrackingStack = [];
     this.errors = [];
-    this.RULE_STACK = [];
+    this.RULE_STACK_IDX = -1;
+    this.RULE_OCCURRENCE_STACK_IDX = -1;
     this.CST_STACK = [];
-    this.RULE_OCCURRENCE_STACK = [];
+  }
+  /**
+   * Hook called before the root-level parsing rule is invoked.
+   * This is only called when a rule is invoked directly by the consumer
+   * (e.g., `parser.json()`), not when invoked as a sub-rule via SUBRULE.
+   *
+   * Override this method to perform actions before parsing begins.
+   * The default implementation is a no-op.
+   *
+   * @param ruleName - The name of the root rule being invoked.
+   */
+  onBeforeParse(ruleName) {
+    for (let i = 0; i < this.maxLookahead + 1; i++) {
+      this.tokVector.push(END_OF_FILE);
+    }
+  }
+  /**
+   * Hook called after the root-level parsing rule has completed (or thrown).
+   * This is only called when a rule is invoked directly by the consumer
+   * (e.g., `parser.json()`), not when invoked as a sub-rule via SUBRULE.
+   *
+   * This hook is called in a `finally` block, so it executes regardless of
+   * whether parsing succeeded or threw an error.
+   *
+   * Override this method to perform actions after parsing completes.
+   * The default implementation is a no-op.
+   *
+   * @param ruleName - The name of the root rule that was invoked.
+   */
+  onAfterParse(ruleName) {
+    if (this.isAtEndOfInput() === false) {
+      const firstRedundantTok = this.LA(1);
+      const errMsg = this.errorMessageProvider.buildNotAllInputParsedMessage({
+        firstRedundant: firstRedundantTok,
+        ruleName: this.getCurrRuleFullName()
+      });
+      this.SAVE_ERROR(new NotAllInputParsedException(errMsg, firstRedundantTok));
+    }
+    while (this.tokVector.at(-1) === END_OF_FILE) {
+      this.tokVector.pop();
+    }
   }
 };
 
@@ -8830,7 +8930,7 @@ var ErrorHandler = class {
     if (isRecognitionException(error)) {
       error.context = {
         ruleStack: this.getHumanReadableRuleStack(),
-        ruleOccurrenceStack: clone_default(this.RULE_OCCURRENCE_STACK)
+        ruleOccurrenceStack: this.RULE_OCCURRENCE_STACK.slice(0, this.RULE_OCCURRENCE_STACK_IDX + 1)
       };
       this._errors.push(error);
       return error;
@@ -9605,10 +9705,11 @@ lodash-es/lodash.js:
   (**
    * @license
    * Lodash (Custom Build) <https://lodash.com/>
-   * Build: `lodash modularize exports="es" -o ./`
+   * Build: `lodash modularize exports="es" --repo lodash/lodash#4.18.1 -o ./`
    * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
    * Released under MIT license <https://lodash.com/license>
    * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
    * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
    *)
 */
+//# sourceMappingURL=index.js.map