@clear-capabilities/agentic-security-scanner 0.149.0 → 0.149.4

package/vendor/java-parser/node_modules/chevrotain/src/parse/grammar/resolver.ts

@@ -0,0 +1,57 @@
+import {
+  IParserUnresolvedRefDefinitionError,
+  ParserDefinitionErrorType,
+} from "../parser/parser.js";
+import { forEach, values } from "lodash-es";
+import { GAstVisitor, NonTerminal, Rule } from "@chevrotain/gast";
+import {
+  IGrammarResolverErrorMessageProvider,
+  IParserDefinitionError,
+} from "./types.js";
+
+export function resolveGrammar(
+  topLevels: Record<string, Rule>,
+  errMsgProvider: IGrammarResolverErrorMessageProvider,
+): IParserDefinitionError[] {
+  const refResolver = new GastRefResolverVisitor(topLevels, errMsgProvider);
+  refResolver.resolveRefs();
+  return refResolver.errors;
+}
+
+export class GastRefResolverVisitor extends GAstVisitor {
+  public errors: IParserUnresolvedRefDefinitionError[] = [];
+  private currTopLevel: Rule;
+
+  constructor(
+    private nameToTopRule: Record<string, Rule>,
+    private errMsgProvider: IGrammarResolverErrorMessageProvider,
+  ) {
+    super();
+  }
+
+  public resolveRefs(): void {
+    forEach(values(this.nameToTopRule), (prod) => {
+      this.currTopLevel = prod;
+      prod.accept(this);
+    });
+  }
+
+  public visitNonTerminal(node: NonTerminal): void {
+    const ref = this.nameToTopRule[node.nonTerminalName];
+
+    if (!ref) {
+      const msg = this.errMsgProvider.buildRuleNotFoundError(
+        this.currTopLevel,
+        node,
+      );
+      this.errors.push({
+        message: msg,
+        type: ParserDefinitionErrorType.UNRESOLVED_SUBRULE_REF,
+        ruleName: this.currTopLevel.name,
+        unresolvedRefName: node.nonTerminalName,
+      });
+    } else {
+      node.referencedRule = ref;
+    }
+  }
+}

package/vendor/java-parser/node_modules/chevrotain/src/parse/grammar/rest.ts

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

package/vendor/java-parser/node_modules/chevrotain/src/parse/grammar/types.ts

@@ -0,0 +1,97 @@
+import {
+  Alternation,
+  IProductionWithOccurrence,
+  NonTerminal,
+  Rule,
+  TokenType,
+} from "@chevrotain/types";
+
+export interface IParserDefinitionError {
+  message: string;
+  type: ParserDefinitionErrorType;
+  ruleName?: string;
+}
+
+export declare enum ParserDefinitionErrorType {
+  INVALID_RULE_NAME = 0,
+  DUPLICATE_RULE_NAME = 1,
+  INVALID_RULE_OVERRIDE = 2,
+  DUPLICATE_PRODUCTIONS = 3,
+  UNRESOLVED_SUBRULE_REF = 4,
+  LEFT_RECURSION = 5,
+  NONE_LAST_EMPTY_ALT = 6,
+  AMBIGUOUS_ALTS = 7,
+  CONFLICT_TOKENS_RULES_NAMESPACE = 8,
+  INVALID_TOKEN_NAME = 9,
+  NO_NON_EMPTY_LOOKAHEAD = 10,
+  AMBIGUOUS_PREFIX_ALTS = 11,
+  TOO_MANY_ALTS = 12,
+  CUSTOM_LOOKAHEAD_VALIDATION = 13,
+}
+
+export interface IGrammarValidatorErrorMessageProvider {
+  buildDuplicateFoundError(
+    topLevelRule: Rule,
+    duplicateProds: IProductionWithOccurrence[],
+  ): string;
+  buildNamespaceConflictError(topLevelRule: Rule): string;
+  buildAlternationPrefixAmbiguityError(options: {
+    topLevelRule: Rule;
+    prefixPath: TokenType[];
+    ambiguityIndices: number[];
+    alternation: Alternation;
+  }): string;
+  buildAlternationAmbiguityError(options: {
+    topLevelRule: Rule;
+    prefixPath: TokenType[];
+    ambiguityIndices: number[];
+    alternation: Alternation;
+  }): string;
+  buildEmptyRepetitionError(options: {
+    topLevelRule: Rule;
+    repetition: IProductionWithOccurrence;
+  }): string;
+  /**
+   * @deprecated - There are no longer constraints on Token names
+   *               This method will be removed from the interface in future versions.
+   *               Providing it will currently have no impact on the runtime.
+   */
+  buildTokenNameError(options: {
+    tokenType: TokenType;
+    expectedPattern: RegExp;
+  }): any;
+
+  buildEmptyAlternationError(options: {
+    topLevelRule: Rule;
+    alternation: Alternation;
+    emptyChoiceIdx: number;
+  }): any;
+  buildTooManyAlternativesError(options: {
+    topLevelRule: Rule;
+    alternation: Alternation;
+  }): string;
+  buildLeftRecursionError(options: {
+    topLevelRule: Rule;
+    leftRecursionPath: Rule[];
+  }): string;
+  /**
+   * @deprecated - There are no longer constraints on Rule names
+   *               This method will be removed from the interface in future versions.
+   *               Providing it will currently have no impact on the runtime.
+   */
+  buildInvalidRuleNameError(options: {
+    topLevelRule: Rule;
+    expectedPattern: RegExp;
+  }): string;
+  buildDuplicateRuleNameError(options: {
+    topLevelRule: Rule | string;
+    grammarName: string;
+  }): string;
+}
+
+export interface IGrammarResolverErrorMessageProvider {
+  buildRuleNotFoundError(
+    topLevelRule: Rule,
+    undefinedRule: NonTerminal,
+  ): string;
+}

package/vendor/java-parser/node_modules/chevrotain/src/parse/parser/parser.ts

@@ -0,0 +1,318 @@
+import { clone, forEach, has, isEmpty, map, values } from "lodash-es";
+import { toFastProperties } from "@chevrotain/utils";
+import { computeAllProdsFollows } from "../grammar/follow.js";
+import { createTokenInstance, EOF } from "../../scan/tokens_public.js";
+import {
+  defaultGrammarValidatorErrorProvider,
+  defaultParserErrorProvider,
+} from "../errors_public.js";
+import {
+  resolveGrammar,
+  validateGrammar,
+} from "../grammar/gast/gast_resolver_public.js";
+import {
+  CstNode,
+  IParserConfig,
+  IRecognitionException,
+  IRuleConfig,
+  IToken,
+  TokenType,
+  TokenVocabulary,
+} from "@chevrotain/types";
+import { Recoverable } from "./traits/recoverable.js";
+import { LooksAhead } from "./traits/looksahead.js";
+import { TreeBuilder } from "./traits/tree_builder.js";
+import { LexerAdapter } from "./traits/lexer_adapter.js";
+import { RecognizerApi } from "./traits/recognizer_api.js";
+import { RecognizerEngine } from "./traits/recognizer_engine.js";
+
+import { ErrorHandler } from "./traits/error_handler.js";
+import { MixedInParser } from "./traits/parser_traits.js";
+import { ContentAssist } from "./traits/context_assist.js";
+import { GastRecorder } from "./traits/gast_recorder.js";
+import { PerformanceTracer } from "./traits/perf_tracer.js";
+import { applyMixins } from "./utils/apply_mixins.js";
+import { IParserDefinitionError } from "../grammar/types.js";
+import { Rule } from "@chevrotain/gast";
+import { IParserConfigInternal, ParserMethodInternal } from "./types.js";
+import { validateLookahead } from "../grammar/checks.js";
+
+export const END_OF_FILE = createTokenInstance(
+  EOF,
+  "",
+  NaN,
+  NaN,
+  NaN,
+  NaN,
+  NaN,
+  NaN,
+);
+Object.freeze(END_OF_FILE);
+
+export type TokenMatcher = (token: IToken, tokType: TokenType) => boolean;
+
+export const DEFAULT_PARSER_CONFIG: Required<
+  Omit<IParserConfigInternal, "lookaheadStrategy">
+> = Object.freeze({
+  recoveryEnabled: false,
+  maxLookahead: 3,
+  dynamicTokensEnabled: false,
+  outputCst: true,
+  errorMessageProvider: defaultParserErrorProvider,
+  nodeLocationTracking: "none",
+  traceInitPerf: false,
+  skipValidations: false,
+});
+
+export const DEFAULT_RULE_CONFIG: Required<IRuleConfig<any>> = Object.freeze({
+  recoveryValueFunc: () => undefined,
+  resyncEnabled: true,
+});
+
+export enum ParserDefinitionErrorType {
+  INVALID_RULE_NAME = 0,
+  DUPLICATE_RULE_NAME = 1,
+  INVALID_RULE_OVERRIDE = 2,
+  DUPLICATE_PRODUCTIONS = 3,
+  UNRESOLVED_SUBRULE_REF = 4,
+  LEFT_RECURSION = 5,
+  NONE_LAST_EMPTY_ALT = 6,
+  AMBIGUOUS_ALTS = 7,
+  CONFLICT_TOKENS_RULES_NAMESPACE = 8,
+  INVALID_TOKEN_NAME = 9,
+  NO_NON_EMPTY_LOOKAHEAD = 10,
+  AMBIGUOUS_PREFIX_ALTS = 11,
+  TOO_MANY_ALTS = 12,
+  CUSTOM_LOOKAHEAD_VALIDATION = 13,
+}
+
+export interface IParserDuplicatesDefinitionError
+  extends IParserDefinitionError {
+  dslName: string;
+  occurrence: number;
+  parameter?: string;
+}
+
+export interface IParserEmptyAlternativeDefinitionError
+  extends IParserDefinitionError {
+  occurrence: number;
+  alternative: number;
+}
+
+export interface IParserAmbiguousAlternativesDefinitionError
+  extends IParserDefinitionError {
+  occurrence: number | string;
+  alternatives: number[];
+}
+
+export interface IParserUnresolvedRefDefinitionError
+  extends IParserDefinitionError {
+  unresolvedRefName: string;
+}
+
+export interface IParserState {
+  errors: IRecognitionException[];
+  lexerState: any;
+  RULE_STACK: number[];
+  CST_STACK: CstNode[];
+}
+
+export type Predicate = () => boolean;
+
+export function EMPTY_ALT(): () => undefined;
+export function EMPTY_ALT<T>(value: T): () => T;
+export function EMPTY_ALT(value: any = undefined) {
+  return function () {
+    return value;
+  };
+}
+
+export class Parser {
+  // Set this flag to true if you don't want the Parser to throw error when problems in it's definition are detected.
+  // (normally during the parser's constructor).
+  // This is a design time flag, it will not affect the runtime error handling of the parser, just design time errors,
+  // for example: duplicate rule names, referencing an unresolved subrule, ect...
+  // This flag should not be enabled during normal usage, it is used in special situations, for example when
+  // needing to display the parser definition errors in some GUI(online playground).
+  static DEFER_DEFINITION_ERRORS_HANDLING: boolean = false;
+
+  /**
+   *  @deprecated use the **instance** method with the same name instead
+   */
+  static performSelfAnalysis(parserInstance: Parser): void {
+    throw Error(
+      "The **static** `performSelfAnalysis` method has been deprecated." +
+        "\t\nUse the **instance** method with the same name instead.",
+    );
+  }
+
+  public performSelfAnalysis(this: MixedInParser): void {
+    this.TRACE_INIT("performSelfAnalysis", () => {
+      let defErrorsMsgs;
+
+      this.selfAnalysisDone = true;
+      const className = this.className;
+
+      this.TRACE_INIT("toFastProps", () => {
+        // Without this voodoo magic the parser would be x3-x4 slower
+        // It seems it is better to invoke `toFastProperties` **before**
+        // Any manipulations of the `this` object done during the recording phase.
+        toFastProperties(this);
+      });
+
+      this.TRACE_INIT("Grammar Recording", () => {
+        try {
+          this.enableRecording();
+          // Building the GAST
+          forEach(this.definedRulesNames, (currRuleName) => {
+            const wrappedRule = (this as any)[
+              currRuleName
+            ] as ParserMethodInternal<unknown[], unknown>;
+            const originalGrammarAction = wrappedRule["originalGrammarAction"];
+            let recordedRuleGast!: Rule;
+            this.TRACE_INIT(`${currRuleName} Rule`, () => {
+              recordedRuleGast = this.topLevelRuleRecord(
+                currRuleName,
+                originalGrammarAction,
+              );
+            });
+            this.gastProductionsCache[currRuleName] = recordedRuleGast;
+          });
+        } finally {
+          this.disableRecording();
+        }
+      });
+
+      let resolverErrors: IParserDefinitionError[] = [];
+      this.TRACE_INIT("Grammar Resolving", () => {
+        resolverErrors = resolveGrammar({
+          rules: values(this.gastProductionsCache),
+        });
+        this.definitionErrors = this.definitionErrors.concat(resolverErrors);
+      });
+
+      this.TRACE_INIT("Grammar Validations", () => {
+        // only perform additional grammar validations IFF no resolving errors have occurred.
+        // as unresolved grammar may lead to unhandled runtime exceptions in the follow up validations.
+        if (isEmpty(resolverErrors) && this.skipValidations === false) {
+          const validationErrors = validateGrammar({
+            rules: values(this.gastProductionsCache),
+            tokenTypes: values(this.tokensMap),
+            errMsgProvider: defaultGrammarValidatorErrorProvider,
+            grammarName: className,
+          });
+          const lookaheadValidationErrors = validateLookahead({
+            lookaheadStrategy: this.lookaheadStrategy,
+            rules: values(this.gastProductionsCache),
+            tokenTypes: values(this.tokensMap),
+            grammarName: className,
+          });
+          this.definitionErrors = this.definitionErrors.concat(
+            validationErrors,
+            lookaheadValidationErrors,
+          );
+        }
+      });
+
+      // this analysis may fail if the grammar is not perfectly valid
+      if (isEmpty(this.definitionErrors)) {
+        // The results of these computations are not needed unless error recovery is enabled.
+        if (this.recoveryEnabled) {
+          this.TRACE_INIT("computeAllProdsFollows", () => {
+            const allFollows = computeAllProdsFollows(
+              values(this.gastProductionsCache),
+            );
+            this.resyncFollows = allFollows;
+          });
+        }
+
+        this.TRACE_INIT("ComputeLookaheadFunctions", () => {
+          this.lookaheadStrategy.initialize?.({
+            rules: values(this.gastProductionsCache),
+          });
+          this.preComputeLookaheadFunctions(values(this.gastProductionsCache));
+        });
+      }
+
+      if (
+        !Parser.DEFER_DEFINITION_ERRORS_HANDLING &&
+        !isEmpty(this.definitionErrors)
+      ) {
+        defErrorsMsgs = map(
+          this.definitionErrors,
+          (defError) => defError.message,
+        );
+        throw new Error(
+          `Parser Definition Errors detected:\n ${defErrorsMsgs.join(
+            "\n-------------------------------\n",
+          )}`,
+        );
+      }
+    });
+  }
+
+  definitionErrors: IParserDefinitionError[] = [];
+  selfAnalysisDone = false;
+  protected skipValidations: boolean;
+
+  constructor(tokenVocabulary: TokenVocabulary, config: IParserConfig) {
+    const that: MixedInParser = this as any;
+    that.initErrorHandler(config);
+    that.initLexerAdapter();
+    that.initLooksAhead(config);
+    that.initRecognizerEngine(tokenVocabulary, config);
+    that.initRecoverable(config);
+    that.initTreeBuilder(config);
+    that.initContentAssist();
+    that.initGastRecorder(config);
+    that.initPerformanceTracer(config);
+
+    if (has(config, "ignoredIssues")) {
+      throw new Error(
+        "The <ignoredIssues> IParserConfig property has been deprecated.\n\t" +
+          "Please use the <IGNORE_AMBIGUITIES> flag on the relevant DSL method instead.\n\t" +
+          "See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES\n\t" +
+          "For further details.",
+      );
+    }
+
+    this.skipValidations = has(config, "skipValidations")
+      ? (config.skipValidations as boolean) // casting assumes the end user passing the correct type
+      : DEFAULT_PARSER_CONFIG.skipValidations;
+  }
+}
+
+applyMixins(Parser, [
+  Recoverable,
+  LooksAhead,
+  TreeBuilder,
+  LexerAdapter,
+  RecognizerEngine,
+  RecognizerApi,
+  ErrorHandler,
+  ContentAssist,
+  GastRecorder,
+  PerformanceTracer,
+]);
+
+export class CstParser extends Parser {
+  constructor(
+    tokenVocabulary: TokenVocabulary,
+    config: IParserConfigInternal = DEFAULT_PARSER_CONFIG,
+  ) {
+    const configClone = clone(config);
+    configClone.outputCst = true;
+    super(tokenVocabulary, configClone);
+  }
+}
+
+export class EmbeddedActionsParser extends Parser {
+  constructor(
+    tokenVocabulary: TokenVocabulary,
+    config: IParserConfigInternal = DEFAULT_PARSER_CONFIG,
+  ) {
+    const configClone = clone(config);
+    configClone.outputCst = false;
+    super(tokenVocabulary, configClone);
+  }
+}

package/vendor/java-parser/node_modules/chevrotain/src/parse/parser/traits/context_assist.ts

@@ -0,0 +1,51 @@
+import {
+  ISyntacticContentAssistPath,
+  IToken,
+  ITokenGrammarPath,
+  TokenType,
+} from "@chevrotain/types";
+import {
+  NextAfterTokenWalker,
+  nextPossibleTokensAfter,
+} from "../../grammar/interpreter.js";
+import { first, isUndefined } from "lodash-es";
+import { MixedInParser } from "./parser_traits.js";
+
+export class ContentAssist {
+  initContentAssist() {}
+
+  public computeContentAssist(
+    this: MixedInParser,
+    startRuleName: string,
+    precedingInput: IToken[],
+  ): ISyntacticContentAssistPath[] {
+    const startRuleGast = this.gastProductionsCache[startRuleName];
+
+    if (isUndefined(startRuleGast)) {
+      throw Error(`Rule ->${startRuleName}<- does not exist in this grammar.`);
+    }
+
+    return nextPossibleTokensAfter(
+      [startRuleGast],
+      precedingInput,
+      this.tokenMatcher,
+      this.maxLookahead,
+    );
+  }
+
+  // TODO: should this be a member method or a utility? it does not have any state or usage of 'this'...
+  // TODO: should this be more explicitly part of the public API?
+  public getNextPossibleTokenTypes(
+    this: MixedInParser,
+    grammarPath: ITokenGrammarPath,
+  ): TokenType[] {
+    const topRuleName = first(grammarPath.ruleStack)!;
+    const gastProductions = this.getGAstProductions();
+    const topProduction = gastProductions[topRuleName];
+    const nextPossibleTokenTypes = new NextAfterTokenWalker(
+      topProduction,
+      grammarPath,
+    ).startWalking();
+    return nextPossibleTokenTypes;
+  }
+}