qidian-vue-ui 1.1.55 → 1.1.57

package/dist/node_modules/.pnpm/chevrotain-allstar@0.3.1_chevrotain@11.0.3/node_modules/chevrotain-allstar/lib/all-star-lookahead.mjs

@@ -1,531 +0,0 @@
-import "../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/parser.mjs";
-import "../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/lexer_public.mjs";
-import { tokenMatcher, tokenLabel } from "../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens_public.mjs";
-import { getLookaheadPaths } from "../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/lookahead.mjs";
-import { LLkLookaheadStrategy } from "../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.mjs";
-import "../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/errors_public.mjs";
-import "../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/exceptions_public.mjs";
-import { NonTerminal, Option, Alternation, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Repetition, Terminal } from "../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs";
-import { createATN, buildATNKey, ATN_RULE_STOP, AtomTransition, EpsilonTransition, RuleTransition } from "./atn.mjs";
-import { ATNConfigSet, DFA_ERROR, getATNConfigKey } from "./dfa.mjs";
-import min from "../../../../lodash-es@4.17.21/node_modules/lodash-es/min.mjs";
-import flatMap from "../../../../lodash-es@4.17.21/node_modules/lodash-es/flatMap.mjs";
-import uniqBy from "../../../../lodash-es@4.17.21/node_modules/lodash-es/uniqBy.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 forEach from "../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
-import isEmpty from "../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.mjs";
-import reduce from "../../../../lodash-es@4.17.21/node_modules/lodash-es/reduce.mjs";
-function createDFACache(startState, decision) {
-  const map2 = {};
-  return (predicateSet) => {
-    const key = predicateSet.toString();
-    let existing = map2[key];
-    if (existing !== void 0) {
-      return existing;
-    } else {
-      existing = {
-        atnStartState: startState,
-        decision,
-        states: {}
-      };
-      map2[key] = existing;
-      return existing;
-    }
-  };
-}
-class PredicateSet {
-  constructor() {
-    this.predicates = [];
-  }
-  is(index) {
-    return index >= this.predicates.length || this.predicates[index];
-  }
-  set(index, value) {
-    this.predicates[index] = value;
-  }
-  toString() {
-    let value = "";
-    const size = this.predicates.length;
-    for (let i = 0; i < size; i++) {
-      value += this.predicates[i] === true ? "1" : "0";
-    }
-    return value;
-  }
-}
-const EMPTY_PREDICATES = new PredicateSet();
-class LLStarLookaheadStrategy extends LLkLookaheadStrategy {
-  constructor(options) {
-    var _a;
-    super();
-    this.logging = (_a = options === null || options === void 0 ? void 0 : options.logging) !== null && _a !== void 0 ? _a : ((message) => console.log(message));
-  }
-  initialize(options) {
-    this.atn = createATN(options.rules);
-    this.dfas = initATNSimulator(this.atn);
-  }
-  validateAmbiguousAlternationAlternatives() {
-    return [];
-  }
-  validateEmptyOrAlternatives() {
-    return [];
-  }
-  buildLookaheadForAlternation(options) {
-    const { prodOccurrence, rule, hasPredicates, dynamicTokensEnabled } = options;
-    const dfas = this.dfas;
-    const logging = this.logging;
-    const key = buildATNKey(rule, "Alternation", prodOccurrence);
-    const decisionState = this.atn.decisionMap[key];
-    const decisionIndex = decisionState.decision;
-    const partialAlts = map(getLookaheadPaths({
-      maxLookahead: 1,
-      occurrence: prodOccurrence,
-      prodType: "Alternation",
-      rule
-    }), (currAlt) => map(currAlt, (path) => path[0]));
-    if (isLL1Sequence(partialAlts, false) && !dynamicTokensEnabled) {
-      const choiceToAlt = reduce(partialAlts, (result, currAlt, idx) => {
-        forEach(currAlt, (currTokType) => {
-          if (currTokType) {
-            result[currTokType.tokenTypeIdx] = idx;
-            forEach(currTokType.categoryMatches, (currExtendingType) => {
-              result[currExtendingType] = idx;
-            });
-          }
-        });
-        return result;
-      }, {});
-      if (hasPredicates) {
-        return function(orAlts) {
-          var _a;
-          const nextToken = this.LA(1);
-          const prediction = choiceToAlt[nextToken.tokenTypeIdx];
-          if (orAlts !== void 0 && prediction !== void 0) {
-            const gate = (_a = orAlts[prediction]) === null || _a === void 0 ? void 0 : _a.GATE;
-            if (gate !== void 0 && gate.call(this) === false) {
-              return void 0;
-            }
-          }
-          return prediction;
-        };
-      } else {
-        return function() {
-          const nextToken = this.LA(1);
-          return choiceToAlt[nextToken.tokenTypeIdx];
-        };
-      }
-    } else if (hasPredicates) {
-      return function(orAlts) {
-        const predicates = new PredicateSet();
-        const length = orAlts === void 0 ? 0 : orAlts.length;
-        for (let i = 0; i < length; i++) {
-          const gate = orAlts === null || orAlts === void 0 ? void 0 : orAlts[i].GATE;
-          predicates.set(i, gate === void 0 || gate.call(this));
-        }
-        const result = adaptivePredict.call(this, dfas, decisionIndex, predicates, logging);
-        return typeof result === "number" ? result : void 0;
-      };
-    } else {
-      return function() {
-        const result = adaptivePredict.call(this, dfas, decisionIndex, EMPTY_PREDICATES, logging);
-        return typeof result === "number" ? result : void 0;
-      };
-    }
-  }
-  buildLookaheadForOptional(options) {
-    const { prodOccurrence, rule, prodType, dynamicTokensEnabled } = options;
-    const dfas = this.dfas;
-    const logging = this.logging;
-    const key = buildATNKey(rule, prodType, prodOccurrence);
-    const decisionState = this.atn.decisionMap[key];
-    const decisionIndex = decisionState.decision;
-    const alts = map(getLookaheadPaths({
-      maxLookahead: 1,
-      occurrence: prodOccurrence,
-      prodType,
-      rule
-    }), (e) => {
-      return map(e, (g) => g[0]);
-    });
-    if (isLL1Sequence(alts) && alts[0][0] && !dynamicTokensEnabled) {
-      const alt = alts[0];
-      const singleTokensTypes = flatten(alt);
-      if (singleTokensTypes.length === 1 && isEmpty(singleTokensTypes[0].categoryMatches)) {
-        const expectedTokenType = singleTokensTypes[0];
-        const expectedTokenUniqueKey = expectedTokenType.tokenTypeIdx;
-        return function() {
-          return this.LA(1).tokenTypeIdx === expectedTokenUniqueKey;
-        };
-      } else {
-        const choiceToAlt = reduce(singleTokensTypes, (result, currTokType) => {
-          if (currTokType !== void 0) {
-            result[currTokType.tokenTypeIdx] = true;
-            forEach(currTokType.categoryMatches, (currExtendingType) => {
-              result[currExtendingType] = true;
-            });
-          }
-          return result;
-        }, {});
-        return function() {
-          const nextToken = this.LA(1);
-          return choiceToAlt[nextToken.tokenTypeIdx] === true;
-        };
-      }
-    }
-    return function() {
-      const result = adaptivePredict.call(this, dfas, decisionIndex, EMPTY_PREDICATES, logging);
-      return typeof result === "object" ? false : result === 0;
-    };
-  }
-}
-function isLL1Sequence(sequences, allowEmpty = true) {
-  const fullSet = /* @__PURE__ */ new Set();
-  for (const alt of sequences) {
-    const altSet = /* @__PURE__ */ new Set();
-    for (const tokType of alt) {
-      if (tokType === void 0) {
-        if (allowEmpty) {
-          break;
-        } else {
-          return false;
-        }
-      }
-      const indices = [tokType.tokenTypeIdx].concat(tokType.categoryMatches);
-      for (const index of indices) {
-        if (fullSet.has(index)) {
-          if (!altSet.has(index)) {
-            return false;
-          }
-        } else {
-          fullSet.add(index);
-          altSet.add(index);
-        }
-      }
-    }
-  }
-  return true;
-}
-function initATNSimulator(atn) {
-  const decisionLength = atn.decisionStates.length;
-  const decisionToDFA = Array(decisionLength);
-  for (let i = 0; i < decisionLength; i++) {
-    decisionToDFA[i] = createDFACache(atn.decisionStates[i], i);
-  }
-  return decisionToDFA;
-}
-function adaptivePredict(dfaCaches, decision, predicateSet, logging) {
-  const dfa = dfaCaches[decision](predicateSet);
-  let start = dfa.start;
-  if (start === void 0) {
-    const closure2 = computeStartState(dfa.atnStartState);
-    start = addDFAState(dfa, newDFAState(closure2));
-    dfa.start = start;
-  }
-  const alt = performLookahead.apply(this, [dfa, start, predicateSet, logging]);
-  return alt;
-}
-function performLookahead(dfa, s0, predicateSet, logging) {
-  let previousD = s0;
-  let i = 1;
-  const path = [];
-  let t = this.LA(i++);
-  while (true) {
-    let d = getExistingTargetState(previousD, t);
-    if (d === void 0) {
-      d = computeLookaheadTarget.apply(this, [dfa, previousD, t, i, predicateSet, logging]);
-    }
-    if (d === DFA_ERROR) {
-      return buildAdaptivePredictError(path, previousD, t);
-    }
-    if (d.isAcceptState === true) {
-      return d.prediction;
-    }
-    previousD = d;
-    path.push(t);
-    t = this.LA(i++);
-  }
-}
-function computeLookaheadTarget(dfa, previousD, token, lookahead, predicateSet, logging) {
-  const reach = computeReachSet(previousD.configs, token, predicateSet);
-  if (reach.size === 0) {
-    addDFAEdge(dfa, previousD, token, DFA_ERROR);
-    return DFA_ERROR;
-  }
-  let newState = newDFAState(reach);
-  const predictedAlt = getUniqueAlt(reach, predicateSet);
-  if (predictedAlt !== void 0) {
-    newState.isAcceptState = true;
-    newState.prediction = predictedAlt;
-    newState.configs.uniqueAlt = predictedAlt;
-  } else if (hasConflictTerminatingPrediction(reach)) {
-    const prediction = min(reach.alts);
-    newState.isAcceptState = true;
-    newState.prediction = prediction;
-    newState.configs.uniqueAlt = prediction;
-    reportLookaheadAmbiguity.apply(this, [dfa, lookahead, reach.alts, logging]);
-  }
-  newState = addDFAEdge(dfa, previousD, token, newState);
-  return newState;
-}
-function reportLookaheadAmbiguity(dfa, lookahead, ambiguityIndices, logging) {
-  const prefixPath = [];
-  for (let i = 1; i <= lookahead; i++) {
-    prefixPath.push(this.LA(i).tokenType);
-  }
-  const atnState = dfa.atnStartState;
-  const topLevelRule = atnState.rule;
-  const production = atnState.production;
-  const message = buildAmbiguityError({
-    topLevelRule,
-    ambiguityIndices,
-    production,
-    prefixPath
-  });
-  logging(message);
-}
-function buildAmbiguityError(options) {
-  const pathMsg = map(options.prefixPath, (currtok) => tokenLabel(currtok)).join(", ");
-  const occurrence = options.production.idx === 0 ? "" : options.production.idx;
-  let currMessage = `Ambiguous Alternatives Detected: <${options.ambiguityIndices.join(", ")}> in <${getProductionDslName(options.production)}${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
-For Further details.`;
-  return currMessage;
-}
-function getProductionDslName(prod) {
-  if (prod instanceof NonTerminal) {
-    return "SUBRULE";
-  } else if (prod instanceof Option) {
-    return "OPTION";
-  } else if (prod instanceof Alternation) {
-    return "OR";
-  } else if (prod instanceof RepetitionMandatory) {
-    return "AT_LEAST_ONE";
-  } else if (prod instanceof RepetitionMandatoryWithSeparator) {
-    return "AT_LEAST_ONE_SEP";
-  } else if (prod instanceof RepetitionWithSeparator) {
-    return "MANY_SEP";
-  } else if (prod instanceof Repetition) {
-    return "MANY";
-  } else if (prod instanceof Terminal) {
-    return "CONSUME";
-  } else {
-    throw Error("non exhaustive match");
-  }
-}
-function buildAdaptivePredictError(path, previous, current) {
-  const nextTransitions = flatMap(previous.configs.elements, (e) => e.state.transitions);
-  const nextTokenTypes = uniqBy(nextTransitions.filter((e) => e instanceof AtomTransition).map((e) => e.tokenType), (e) => e.tokenTypeIdx);
-  return {
-    actualToken: current,
-    possibleTokenTypes: nextTokenTypes,
-    tokenPath: path
-  };
-}
-function getExistingTargetState(state, token) {
-  return state.edges[token.tokenTypeIdx];
-}
-function computeReachSet(configs, token, predicateSet) {
-  const intermediate = new ATNConfigSet();
-  const skippedStopStates = [];
-  for (const c of configs.elements) {
-    if (predicateSet.is(c.alt) === false) {
-      continue;
-    }
-    if (c.state.type === ATN_RULE_STOP) {
-      skippedStopStates.push(c);
-      continue;
-    }
-    const transitionLength = c.state.transitions.length;
-    for (let i = 0; i < transitionLength; i++) {
-      const transition = c.state.transitions[i];
-      const target = getReachableTarget(transition, token);
-      if (target !== void 0) {
-        intermediate.add({
-          state: target,
-          alt: c.alt,
-          stack: c.stack
-        });
-      }
-    }
-  }
-  let reach;
-  if (skippedStopStates.length === 0 && intermediate.size === 1) {
-    reach = intermediate;
-  }
-  if (reach === void 0) {
-    reach = new ATNConfigSet();
-    for (const c of intermediate.elements) {
-      closure(c, reach);
-    }
-  }
-  if (skippedStopStates.length > 0 && !hasConfigInRuleStopState(reach)) {
-    for (const c of skippedStopStates) {
-      reach.add(c);
-    }
-  }
-  return reach;
-}
-function getReachableTarget(transition, token) {
-  if (transition instanceof AtomTransition && tokenMatcher(token, transition.tokenType)) {
-    return transition.target;
-  }
-  return void 0;
-}
-function getUniqueAlt(configs, predicateSet) {
-  let alt;
-  for (const c of configs.elements) {
-    if (predicateSet.is(c.alt) === true) {
-      if (alt === void 0) {
-        alt = c.alt;
-      } else if (alt !== c.alt) {
-        return void 0;
-      }
-    }
-  }
-  return alt;
-}
-function newDFAState(closure2) {
-  return {
-    configs: closure2,
-    edges: {},
-    isAcceptState: false,
-    prediction: -1
-  };
-}
-function addDFAEdge(dfa, from, token, to) {
-  to = addDFAState(dfa, to);
-  from.edges[token.tokenTypeIdx] = to;
-  return to;
-}
-function addDFAState(dfa, state) {
-  if (state === DFA_ERROR) {
-    return state;
-  }
-  const mapKey = state.configs.key;
-  const existing = dfa.states[mapKey];
-  if (existing !== void 0) {
-    return existing;
-  }
-  state.configs.finalize();
-  dfa.states[mapKey] = state;
-  return state;
-}
-function computeStartState(atnState) {
-  const configs = new ATNConfigSet();
-  const numberOfTransitions = atnState.transitions.length;
-  for (let i = 0; i < numberOfTransitions; i++) {
-    const target = atnState.transitions[i].target;
-    const config = {
-      state: target,
-      alt: i,
-      stack: []
-    };
-    closure(config, configs);
-  }
-  return configs;
-}
-function closure(config, configs) {
-  const p = config.state;
-  if (p.type === ATN_RULE_STOP) {
-    if (config.stack.length > 0) {
-      const atnStack = [...config.stack];
-      const followState = atnStack.pop();
-      const followConfig = {
-        state: followState,
-        alt: config.alt,
-        stack: atnStack
-      };
-      closure(followConfig, configs);
-    } else {
-      configs.add(config);
-    }
-    return;
-  }
-  if (!p.epsilonOnlyTransitions) {
-    configs.add(config);
-  }
-  const transitionLength = p.transitions.length;
-  for (let i = 0; i < transitionLength; i++) {
-    const transition = p.transitions[i];
-    const c = getEpsilonTarget(config, transition);
-    if (c !== void 0) {
-      closure(c, configs);
-    }
-  }
-}
-function getEpsilonTarget(config, transition) {
-  if (transition instanceof EpsilonTransition) {
-    return {
-      state: transition.target,
-      alt: config.alt,
-      stack: config.stack
-    };
-  } else if (transition instanceof RuleTransition) {
-    const stack = [...config.stack, transition.followState];
-    return {
-      state: transition.target,
-      alt: config.alt,
-      stack
-    };
-  }
-  return void 0;
-}
-function hasConfigInRuleStopState(configs) {
-  for (const c of configs.elements) {
-    if (c.state.type === ATN_RULE_STOP) {
-      return true;
-    }
-  }
-  return false;
-}
-function allConfigsInRuleStopStates(configs) {
-  for (const c of configs.elements) {
-    if (c.state.type !== ATN_RULE_STOP) {
-      return false;
-    }
-  }
-  return true;
-}
-function hasConflictTerminatingPrediction(configs) {
-  if (allConfigsInRuleStopStates(configs)) {
-    return true;
-  }
-  const altSets = getConflictingAltSets(configs.elements);
-  const heuristic = hasConflictingAltSet(altSets) && !hasStateAssociatedWithOneAlt(altSets);
-  return heuristic;
-}
-function getConflictingAltSets(configs) {
-  const configToAlts = /* @__PURE__ */ new Map();
-  for (const c of configs) {
-    const key = getATNConfigKey(c, false);
-    let alts = configToAlts.get(key);
-    if (alts === void 0) {
-      alts = {};
-      configToAlts.set(key, alts);
-    }
-    alts[c.alt] = true;
-  }
-  return configToAlts;
-}
-function hasConflictingAltSet(altSets) {
-  for (const value of Array.from(altSets.values())) {
-    if (Object.keys(value).length > 1) {
-      return true;
-    }
-  }
-  return false;
-}
-function hasStateAssociatedWithOneAlt(altSets) {
-  for (const value of Array.from(altSets.values())) {
-    if (Object.keys(value).length === 1) {
-      return true;
-    }
-  }
-  return false;
-}
-export {
-  LLStarLookaheadStrategy
-};
-//# sourceMappingURL=all-star-lookahead.mjs.map

package/dist/node_modules/.pnpm/chevrotain-allstar@0.3.1_chevrotain@11.0.3/node_modules/chevrotain-allstar/lib/all-star-lookahead.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"all-star-lookahead.mjs","sources":["../../../../../../../../../node_modules/.pnpm/chevrotain-allstar@0.3.1_chevrotain@11.0.3/node_modules/chevrotain-allstar/lib/all-star-lookahead.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { tokenMatcher, tokenLabel, NonTerminal, Alternation, Option, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Repetition, Terminal, LLkLookaheadStrategy, getLookaheadPaths } from \"chevrotain\";\nimport { ATN_RULE_STOP, AtomTransition, buildATNKey, createATN, EpsilonTransition, RuleTransition } from \"./atn.js\";\nimport { ATNConfigSet, DFA_ERROR, getATNConfigKey } from \"./dfa.js\";\nimport min from \"lodash-es/min.js\";\nimport flatMap from \"lodash-es/flatMap.js\";\nimport uniqBy from \"lodash-es/uniqBy.js\";\nimport map from \"lodash-es/map.js\";\nimport flatten from \"lodash-es/flatten.js\";\nimport forEach from \"lodash-es/forEach.js\";\nimport isEmpty from \"lodash-es/isEmpty.js\";\nimport reduce from \"lodash-es/reduce.js\";\nfunction createDFACache(startState, decision) {\n    const map = {};\n    return (predicateSet) => {\n        const key = predicateSet.toString();\n        let existing = map[key];\n        if (existing !== undefined) {\n            return existing;\n        }\n        else {\n            existing = {\n                atnStartState: startState,\n                decision,\n                states: {}\n            };\n            map[key] = existing;\n            return existing;\n        }\n    };\n}\nclass PredicateSet {\n    constructor() {\n        this.predicates = [];\n    }\n    is(index) {\n        return index >= this.predicates.length || this.predicates[index];\n    }\n    set(index, value) {\n        this.predicates[index] = value;\n    }\n    toString() {\n        let value = \"\";\n        const size = this.predicates.length;\n        for (let i = 0; i < size; i++) {\n            value += this.predicates[i] === true ? \"1\" : \"0\";\n        }\n        return value;\n    }\n}\nconst EMPTY_PREDICATES = new PredicateSet();\nexport class LLStarLookaheadStrategy extends LLkLookaheadStrategy {\n    constructor(options) {\n        var _a;\n        super();\n        this.logging = (_a = options === null || options === void 0 ? void 0 : options.logging) !== null && _a !== void 0 ? _a : ((message) => console.log(message));\n    }\n    initialize(options) {\n        this.atn = createATN(options.rules);\n        this.dfas = initATNSimulator(this.atn);\n    }\n    validateAmbiguousAlternationAlternatives() {\n        return [];\n    }\n    validateEmptyOrAlternatives() {\n        return [];\n    }\n    buildLookaheadForAlternation(options) {\n        const { prodOccurrence, rule, hasPredicates, dynamicTokensEnabled } = options;\n        const dfas = this.dfas;\n        const logging = this.logging;\n        const key = buildATNKey(rule, 'Alternation', prodOccurrence);\n        const decisionState = this.atn.decisionMap[key];\n        const decisionIndex = decisionState.decision;\n        const partialAlts = map(getLookaheadPaths({\n            maxLookahead: 1,\n            occurrence: prodOccurrence,\n            prodType: \"Alternation\",\n            rule: rule\n        }), (currAlt) => map(currAlt, (path) => path[0]));\n        if (isLL1Sequence(partialAlts, false) && !dynamicTokensEnabled) {\n            const choiceToAlt = reduce(partialAlts, (result, currAlt, idx) => {\n                forEach(currAlt, (currTokType) => {\n                    if (currTokType) {\n                        result[currTokType.tokenTypeIdx] = idx;\n                        forEach(currTokType.categoryMatches, (currExtendingType) => {\n                            result[currExtendingType] = idx;\n                        });\n                    }\n                });\n                return result;\n            }, {});\n            if (hasPredicates) {\n                return function (orAlts) {\n                    var _a;\n                    const nextToken = this.LA(1);\n                    const prediction = choiceToAlt[nextToken.tokenTypeIdx];\n                    if (orAlts !== undefined && prediction !== undefined) {\n                        const gate = (_a = orAlts[prediction]) === null || _a === void 0 ? void 0 : _a.GATE;\n                        if (gate !== undefined && gate.call(this) === false) {\n                            return undefined;\n                        }\n                    }\n                    return prediction;\n                };\n            }\n            else {\n                return function () {\n                    const nextToken = this.LA(1);\n                    return choiceToAlt[nextToken.tokenTypeIdx];\n                };\n            }\n        }\n        else if (hasPredicates) {\n            return function (orAlts) {\n                const predicates = new PredicateSet();\n                const length = orAlts === undefined ? 0 : orAlts.length;\n                for (let i = 0; i < length; i++) {\n                    const gate = orAlts === null || orAlts === void 0 ? void 0 : orAlts[i].GATE;\n                    predicates.set(i, gate === undefined || gate.call(this));\n                }\n                const result = adaptivePredict.call(this, dfas, decisionIndex, predicates, logging);\n                return typeof result === 'number' ? result : undefined;\n            };\n        }\n        else {\n            return function () {\n                const result = adaptivePredict.call(this, dfas, decisionIndex, EMPTY_PREDICATES, logging);\n                return typeof result === 'number' ? result : undefined;\n            };\n        }\n    }\n    buildLookaheadForOptional(options) {\n        const { prodOccurrence, rule, prodType, dynamicTokensEnabled } = options;\n        const dfas = this.dfas;\n        const logging = this.logging;\n        const key = buildATNKey(rule, prodType, prodOccurrence);\n        const decisionState = this.atn.decisionMap[key];\n        const decisionIndex = decisionState.decision;\n        const alts = map(getLookaheadPaths({\n            maxLookahead: 1,\n            occurrence: prodOccurrence,\n            prodType,\n            rule\n        }), (e) => {\n            return map(e, (g) => g[0]);\n        });\n        if (isLL1Sequence(alts) && alts[0][0] && !dynamicTokensEnabled) {\n            const alt = alts[0];\n            const singleTokensTypes = flatten(alt);\n            if (singleTokensTypes.length === 1 &&\n                isEmpty(singleTokensTypes[0].categoryMatches)) {\n                const expectedTokenType = singleTokensTypes[0];\n                const expectedTokenUniqueKey = expectedTokenType.tokenTypeIdx;\n                return function () {\n                    return this.LA(1).tokenTypeIdx === expectedTokenUniqueKey;\n                };\n            }\n            else {\n                const choiceToAlt = reduce(singleTokensTypes, (result, currTokType) => {\n                    if (currTokType !== undefined) {\n                        result[currTokType.tokenTypeIdx] = true;\n                        forEach(currTokType.categoryMatches, (currExtendingType) => {\n                            result[currExtendingType] = true;\n                        });\n                    }\n                    return result;\n                }, {});\n                return function () {\n                    const nextToken = this.LA(1);\n                    return choiceToAlt[nextToken.tokenTypeIdx] === true;\n                };\n            }\n        }\n        return function () {\n            const result = adaptivePredict.call(this, dfas, decisionIndex, EMPTY_PREDICATES, logging);\n            return typeof result === \"object\" ? false : result === 0;\n        };\n    }\n}\nfunction isLL1Sequence(sequences, allowEmpty = true) {\n    const fullSet = new Set();\n    for (const alt of sequences) {\n        const altSet = new Set();\n        for (const tokType of alt) {\n            if (tokType === undefined) {\n                if (allowEmpty) {\n                    // Epsilon production encountered\n                    break;\n                }\n                else {\n                    return false;\n                }\n            }\n            const indices = [tokType.tokenTypeIdx].concat(tokType.categoryMatches);\n            for (const index of indices) {\n                if (fullSet.has(index)) {\n                    if (!altSet.has(index)) {\n                        return false;\n                    }\n                }\n                else {\n                    fullSet.add(index);\n                    altSet.add(index);\n                }\n            }\n        }\n    }\n    return true;\n}\nfunction initATNSimulator(atn) {\n    const decisionLength = atn.decisionStates.length;\n    const decisionToDFA = Array(decisionLength);\n    for (let i = 0; i < decisionLength; i++) {\n        decisionToDFA[i] = createDFACache(atn.decisionStates[i], i);\n    }\n    return decisionToDFA;\n}\nfunction adaptivePredict(dfaCaches, decision, predicateSet, logging) {\n    const dfa = dfaCaches[decision](predicateSet);\n    let start = dfa.start;\n    if (start === undefined) {\n        const closure = computeStartState(dfa.atnStartState);\n        start = addDFAState(dfa, newDFAState(closure));\n        dfa.start = start;\n    }\n    const alt = performLookahead.apply(this, [dfa, start, predicateSet, logging]);\n    return alt;\n}\nfunction performLookahead(dfa, s0, predicateSet, logging) {\n    let previousD = s0;\n    let i = 1;\n    const path = [];\n    let t = this.LA(i++);\n    while (true) {\n        let d = getExistingTargetState(previousD, t);\n        if (d === undefined) {\n            d = computeLookaheadTarget.apply(this, [dfa, previousD, t, i, predicateSet, logging]);\n        }\n        if (d === DFA_ERROR) {\n            return buildAdaptivePredictError(path, previousD, t);\n        }\n        if (d.isAcceptState === true) {\n            return d.prediction;\n        }\n        previousD = d;\n        path.push(t);\n        t = this.LA(i++);\n    }\n}\nfunction computeLookaheadTarget(dfa, previousD, token, lookahead, predicateSet, logging) {\n    const reach = computeReachSet(previousD.configs, token, predicateSet);\n    if (reach.size === 0) {\n        addDFAEdge(dfa, previousD, token, DFA_ERROR);\n        return DFA_ERROR;\n    }\n    let newState = newDFAState(reach);\n    const predictedAlt = getUniqueAlt(reach, predicateSet);\n    if (predictedAlt !== undefined) {\n        newState.isAcceptState = true;\n        newState.prediction = predictedAlt;\n        newState.configs.uniqueAlt = predictedAlt;\n    }\n    else if (hasConflictTerminatingPrediction(reach)) {\n        const prediction = min(reach.alts);\n        newState.isAcceptState = true;\n        newState.prediction = prediction;\n        newState.configs.uniqueAlt = prediction;\n        reportLookaheadAmbiguity.apply(this, [dfa, lookahead, reach.alts, logging]);\n    }\n    newState = addDFAEdge(dfa, previousD, token, newState);\n    return newState;\n}\nfunction reportLookaheadAmbiguity(dfa, lookahead, ambiguityIndices, logging) {\n    const prefixPath = [];\n    for (let i = 1; i <= lookahead; i++) {\n        prefixPath.push(this.LA(i).tokenType);\n    }\n    const atnState = dfa.atnStartState;\n    const topLevelRule = atnState.rule;\n    const production = atnState.production;\n    const message = buildAmbiguityError({\n        topLevelRule,\n        ambiguityIndices,\n        production,\n        prefixPath\n    });\n    logging(message);\n}\nfunction buildAmbiguityError(options) {\n    const pathMsg = map(options.prefixPath, (currtok) => tokenLabel(currtok)).join(\", \");\n    const occurrence = options.production.idx === 0 ? \"\" : options.production.idx;\n    let currMessage = `Ambiguous Alternatives Detected: <${options.ambiguityIndices.join(\", \")}> in <${getProductionDslName(options.production)}${occurrence}>` +\n        ` inside <${options.topLevelRule.name}> Rule,\\n` +\n        `<${pathMsg}> may appears as a prefix path in all these alternatives.\\n`;\n    currMessage =\n        currMessage +\n            `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES\\n` +\n            `For Further details.`;\n    return currMessage;\n}\nfunction getProductionDslName(prod) {\n    if (prod instanceof NonTerminal) {\n        return \"SUBRULE\";\n    }\n    else if (prod instanceof Option) {\n        return \"OPTION\";\n    }\n    else if (prod instanceof Alternation) {\n        return \"OR\";\n    }\n    else if (prod instanceof RepetitionMandatory) {\n        return \"AT_LEAST_ONE\";\n    }\n    else if (prod instanceof RepetitionMandatoryWithSeparator) {\n        return \"AT_LEAST_ONE_SEP\";\n    }\n    else if (prod instanceof RepetitionWithSeparator) {\n        return \"MANY_SEP\";\n    }\n    else if (prod instanceof Repetition) {\n        return \"MANY\";\n    }\n    else if (prod instanceof Terminal) {\n        return \"CONSUME\";\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\nfunction buildAdaptivePredictError(path, previous, current) {\n    const nextTransitions = flatMap(previous.configs.elements, (e) => e.state.transitions);\n    const nextTokenTypes = uniqBy(nextTransitions\n        .filter((e) => e instanceof AtomTransition)\n        .map((e) => e.tokenType), (e) => e.tokenTypeIdx);\n    return {\n        actualToken: current,\n        possibleTokenTypes: nextTokenTypes,\n        tokenPath: path\n    };\n}\nfunction getExistingTargetState(state, token) {\n    return state.edges[token.tokenTypeIdx];\n}\nfunction computeReachSet(configs, token, predicateSet) {\n    const intermediate = new ATNConfigSet();\n    const skippedStopStates = [];\n    for (const c of configs.elements) {\n        if (predicateSet.is(c.alt) === false) {\n            continue;\n        }\n        if (c.state.type === ATN_RULE_STOP) {\n            skippedStopStates.push(c);\n            continue;\n        }\n        const transitionLength = c.state.transitions.length;\n        for (let i = 0; i < transitionLength; i++) {\n            const transition = c.state.transitions[i];\n            const target = getReachableTarget(transition, token);\n            if (target !== undefined) {\n                intermediate.add({\n                    state: target,\n                    alt: c.alt,\n                    stack: c.stack\n                });\n            }\n        }\n    }\n    let reach;\n    if (skippedStopStates.length === 0 && intermediate.size === 1) {\n        reach = intermediate;\n    }\n    if (reach === undefined) {\n        reach = new ATNConfigSet();\n        for (const c of intermediate.elements) {\n            closure(c, reach);\n        }\n    }\n    if (skippedStopStates.length > 0 && !hasConfigInRuleStopState(reach)) {\n        for (const c of skippedStopStates) {\n            reach.add(c);\n        }\n    }\n    return reach;\n}\nfunction getReachableTarget(transition, token) {\n    if (transition instanceof AtomTransition &&\n        tokenMatcher(token, transition.tokenType)) {\n        return transition.target;\n    }\n    return undefined;\n}\nfunction getUniqueAlt(configs, predicateSet) {\n    let alt;\n    for (const c of configs.elements) {\n        if (predicateSet.is(c.alt) === true) {\n            if (alt === undefined) {\n                alt = c.alt;\n            }\n            else if (alt !== c.alt) {\n                return undefined;\n            }\n        }\n    }\n    return alt;\n}\nfunction newDFAState(closure) {\n    return {\n        configs: closure,\n        edges: {},\n        isAcceptState: false,\n        prediction: -1\n    };\n}\nfunction addDFAEdge(dfa, from, token, to) {\n    to = addDFAState(dfa, to);\n    from.edges[token.tokenTypeIdx] = to;\n    return to;\n}\nfunction addDFAState(dfa, state) {\n    if (state === DFA_ERROR) {\n        return state;\n    }\n    // Repetitions have the same config set\n    // Therefore, storing the key of the config in a map allows us to create a loop in our DFA\n    const mapKey = state.configs.key;\n    const existing = dfa.states[mapKey];\n    if (existing !== undefined) {\n        return existing;\n    }\n    state.configs.finalize();\n    dfa.states[mapKey] = state;\n    return state;\n}\nfunction computeStartState(atnState) {\n    const configs = new ATNConfigSet();\n    const numberOfTransitions = atnState.transitions.length;\n    for (let i = 0; i < numberOfTransitions; i++) {\n        const target = atnState.transitions[i].target;\n        const config = {\n            state: target,\n            alt: i,\n            stack: []\n        };\n        closure(config, configs);\n    }\n    return configs;\n}\nfunction closure(config, configs) {\n    const p = config.state;\n    if (p.type === ATN_RULE_STOP) {\n        if (config.stack.length > 0) {\n            const atnStack = [...config.stack];\n            const followState = atnStack.pop();\n            const followConfig = {\n                state: followState,\n                alt: config.alt,\n                stack: atnStack\n            };\n            closure(followConfig, configs);\n        }\n        else {\n            // Dipping into outer context, simply add the config\n            // This will stop computation once every config is at the rule stop state\n            configs.add(config);\n        }\n        return;\n    }\n    if (!p.epsilonOnlyTransitions) {\n        configs.add(config);\n    }\n    const transitionLength = p.transitions.length;\n    for (let i = 0; i < transitionLength; i++) {\n        const transition = p.transitions[i];\n        const c = getEpsilonTarget(config, transition);\n        if (c !== undefined) {\n            closure(c, configs);\n        }\n    }\n}\nfunction getEpsilonTarget(config, transition) {\n    if (transition instanceof EpsilonTransition) {\n        return {\n            state: transition.target,\n            alt: config.alt,\n            stack: config.stack\n        };\n    }\n    else if (transition instanceof RuleTransition) {\n        const stack = [...config.stack, transition.followState];\n        return {\n            state: transition.target,\n            alt: config.alt,\n            stack\n        };\n    }\n    return undefined;\n}\nfunction hasConfigInRuleStopState(configs) {\n    for (const c of configs.elements) {\n        if (c.state.type === ATN_RULE_STOP) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction allConfigsInRuleStopStates(configs) {\n    for (const c of configs.elements) {\n        if (c.state.type !== ATN_RULE_STOP) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction hasConflictTerminatingPrediction(configs) {\n    if (allConfigsInRuleStopStates(configs)) {\n        return true;\n    }\n    const altSets = getConflictingAltSets(configs.elements);\n    const heuristic = hasConflictingAltSet(altSets) && !hasStateAssociatedWithOneAlt(altSets);\n    return heuristic;\n}\nfunction getConflictingAltSets(configs) {\n    const configToAlts = new Map();\n    for (const c of configs) {\n        const key = getATNConfigKey(c, false);\n        let alts = configToAlts.get(key);\n        if (alts === undefined) {\n            alts = {};\n            configToAlts.set(key, alts);\n        }\n        alts[c.alt] = true;\n    }\n    return configToAlts;\n}\nfunction hasConflictingAltSet(altSets) {\n    for (const value of Array.from(altSets.values())) {\n        if (Object.keys(value).length > 1) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction hasStateAssociatedWithOneAlt(altSets) {\n    for (const value of Array.from(altSets.values())) {\n        if (Object.keys(value).length === 1) {\n            return true;\n        }\n    }\n    return false;\n}\n//# sourceMappingURL=all-star-lookahead.js.map"],"names":["map","closure"],"mappings":"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","x_google_ignoreList":[0]}