@windrun-huaiin/third-ui 13.0.1 → 13.1.1

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/checks.js

@@ -32,25 +32,25 @@ function validateLookahead(options) {
         tokenTypes: options.tokenTypes,
         grammarName: options.grammarName,
     });
-    return map(lookaheadValidationErrorMessages, (errorMessage) => (Object.assign({ type: parser.ParserDefinitionErrorType.CUSTOM_LOOKAHEAD_VALIDATION }, errorMessage)));
+    return map.default(lookaheadValidationErrorMessages, (errorMessage) => (Object.assign({ type: parser.ParserDefinitionErrorType.CUSTOM_LOOKAHEAD_VALIDATION }, errorMessage)));
 }
 function validateGrammar(topLevels, tokenTypes, errMsgProvider, grammarName) {
-    const duplicateErrors = flatMap(topLevels, (currTopLevel) => validateDuplicateProductions(currTopLevel, errMsgProvider));
+    const duplicateErrors = flatMap.default(topLevels, (currTopLevel) => validateDuplicateProductions(currTopLevel, errMsgProvider));
     const termsNamespaceConflictErrors = checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider);
-    const tooManyAltsErrors = flatMap(topLevels, (curRule) => validateTooManyAlts(curRule, errMsgProvider));
-    const duplicateRulesError = flatMap(topLevels, (curRule) => validateRuleDoesNotAlreadyExist(curRule, topLevels, grammarName, errMsgProvider));
+    const tooManyAltsErrors = flatMap.default(topLevels, (curRule) => validateTooManyAlts(curRule, errMsgProvider));
+    const duplicateRulesError = flatMap.default(topLevels, (curRule) => validateRuleDoesNotAlreadyExist(curRule, topLevels, grammarName, errMsgProvider));
     return duplicateErrors.concat(termsNamespaceConflictErrors, tooManyAltsErrors, duplicateRulesError);
 }
 function validateDuplicateProductions(topLevelRule, errMsgProvider) {
     const collectorVisitor = new OccurrenceValidationCollector();
     topLevelRule.accept(collectorVisitor);
     const allRuleProductions = collectorVisitor.allProductions;
-    const productionGroups = groupBy(allRuleProductions, identifyProductionForDuplicates);
-    const duplicates = pickBy(productionGroups, (currGroup) => {
+    const productionGroups = groupBy.default(allRuleProductions, identifyProductionForDuplicates);
+    const duplicates = pickBy.default(productionGroups, (currGroup) => {
         return currGroup.length > 1;
     });
-    const errors = map(values(duplicates), (currDuplicates) => {
-        const firstProd = head(currDuplicates);
+    const errors = map.default(values.default(duplicates), (currDuplicates) => {
+        const firstProd = head.default(currDuplicates);
         const msg = errMsgProvider.buildDuplicateFoundError(topLevelRule, currDuplicates);
         const dslName = helpers.getProductionDslName(firstProd);
         const defError = {
@@ -114,7 +114,7 @@ class OccurrenceValidationCollector extends visitor.GAstVisitor {
 }
 function validateRuleDoesNotAlreadyExist(rule, allRules, className, errMsgProvider) {
     const errors = [];
-    const occurrences = reduce(allRules, (result, curRule) => {
+    const occurrences = reduce.default(allRules, (result, curRule) => {
         if (curRule.name === rule.name) {
             return result + 1;
         }
@@ -139,7 +139,7 @@ function validateRuleDoesNotAlreadyExist(rule, allRules, className, errMsgProvid
 function validateRuleIsOverridden(ruleName, definedRulesNames, className) {
     const errors = [];
     let errMsg;
-    if (!includes(definedRulesNames, ruleName)) {
+    if (!includes.default(definedRulesNames, ruleName)) {
         errMsg =
             `Invalid rule override, rule: ->${ruleName}<- cannot be overridden in the grammar: ->${className}<-` +
                 `as it is not defined in any of the super grammars `;
@@ -154,12 +154,12 @@ function validateRuleIsOverridden(ruleName, definedRulesNames, className) {
 function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path = []) {
     const errors = [];
     const nextNonTerminals = getFirstNoneTerminal(currRule.definition);
-    if (isEmpty(nextNonTerminals)) {
+    if (isEmpty.default(nextNonTerminals)) {
         return [];
     }
     else {
         const ruleName = topRule.name;
-        const foundLeftRecursion = includes(nextNonTerminals, topRule);
+        const foundLeftRecursion = includes.default(nextNonTerminals, topRule);
         if (foundLeftRecursion) {
             errors.push({
                 message: errMsgProvider.buildLeftRecursionError({
@@ -172,9 +172,9 @@ function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path = []) {
         }
         // we are only looking for cyclic paths leading back to the specific topRule
         // other cyclic paths are ignored, we still need this difference to avoid infinite loops...
-        const validNextSteps = difference(nextNonTerminals, path.concat([topRule]));
-        const errorsFromNextSteps = flatMap(validNextSteps, (currRefRule) => {
-            const newPath = clone(path);
+        const validNextSteps = difference.default(nextNonTerminals, path.concat([topRule]));
+        const errorsFromNextSteps = flatMap.default(validNextSteps, (currRefRule) => {
+            const newPath = clone.default(path);
             newPath.push(currRefRule);
             return validateNoLeftRecursion(topRule, currRefRule, errMsgProvider, newPath);
         });
@@ -183,10 +183,10 @@ function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path = []) {
 }
 function getFirstNoneTerminal(definition) {
     let result = [];
-    if (isEmpty(definition)) {
+    if (isEmpty.default(definition)) {
         return result;
     }
-    const firstProd = head(definition);
+    const firstProd = head.default(definition);
     /* istanbul ignore else */
     if (firstProd instanceof model.NonTerminal) {
         result.push(firstProd.referencedRule);
@@ -201,7 +201,7 @@ function getFirstNoneTerminal(definition) {
     }
     else if (firstProd instanceof model.Alternation) {
         // each sub definition in alternation is a FLAT
-        result = flatten(map(firstProd.definition, (currSubDef) => getFirstNoneTerminal(currSubDef.definition)));
+        result = flatten.default(map.default(firstProd.definition, (currSubDef) => getFirstNoneTerminal(currSubDef.definition)));
     }
     else if (firstProd instanceof model.Terminal) ;
     else {
@@ -210,7 +210,7 @@ function getFirstNoneTerminal(definition) {
     const isFirstOptional = helpers.isOptionalProd(firstProd);
     const hasMore = definition.length > 1;
     if (isFirstOptional && hasMore) {
-        const rest = drop(definition);
+        const rest = drop.default(definition);
         return result.concat(getFirstNoneTerminal(rest));
     }
     else {
@@ -230,11 +230,11 @@ function validateEmptyOrAlternative(topLevelRule, errMsgProvider) {
     const orCollector = new OrCollector();
     topLevelRule.accept(orCollector);
     const ors = orCollector.alternations;
-    const errors = flatMap(ors, (currOr) => {
-        const exceptLast = dropRight(currOr.definition);
-        return flatMap(exceptLast, (currAlternative, currAltIdx) => {
+    const errors = flatMap.default(ors, (currOr) => {
+        const exceptLast = dropRight.default(currOr.definition);
+        return flatMap.default(exceptLast, (currAlternative, currAltIdx) => {
             const possibleFirstInAlt = interpreter.nextPossibleTokensAfter([currAlternative], [], tokens.tokenStructuredMatcher, 1);
-            if (isEmpty(possibleFirstInAlt)) {
+            if (isEmpty.default(possibleFirstInAlt)) {
                 return [
                     {
                         message: errMsgProvider.buildEmptyAlternationError({
@@ -262,8 +262,8 @@ function validateAmbiguousAlternationAlternatives(topLevelRule, globalMaxLookahe
     let ors = orCollector.alternations;
     // New Handling of ignoring ambiguities
     // - https://github.com/chevrotain/chevrotain/issues/869
-    ors = reject(ors, (currOr) => currOr.ignoreAmbiguities === true);
-    const errors = flatMap(ors, (currOr) => {
+    ors = reject.default(ors, (currOr) => currOr.ignoreAmbiguities === true);
+    const errors = flatMap.default(ors, (currOr) => {
         const currOccurrence = currOr.idx;
         const actualMaxLookahead = currOr.maxLookahead || globalMaxLookahead;
         const alternatives = lookahead.getLookaheadPathsForOr(currOccurrence, topLevelRule, actualMaxLookahead, currOr);
@@ -295,7 +295,7 @@ function validateTooManyAlts(topLevelRule, errMsgProvider) {
     const orCollector = new OrCollector();
     topLevelRule.accept(orCollector);
     const ors = orCollector.alternations;
-    const errors = flatMap(ors, (currOr) => {
+    const errors = flatMap.default(ors, (currOr) => {
         if (currOr.definition.length > 255) {
             return [
                 {
@@ -317,17 +317,17 @@ function validateTooManyAlts(topLevelRule, errMsgProvider) {
 }
 function validateSomeNonEmptyLookaheadPath(topLevelRules, maxLookahead, errMsgProvider) {
     const errors = [];
-    forEach(topLevelRules, (currTopRule) => {
+    forEach.default(topLevelRules, (currTopRule) => {
         const collectorVisitor = new RepetitionCollector();
         currTopRule.accept(collectorVisitor);
         const allRuleProductions = collectorVisitor.allProductions;
-        forEach(allRuleProductions, (currProd) => {
+        forEach.default(allRuleProductions, (currProd) => {
             const prodType = lookahead.getProdType(currProd);
             const actualMaxLookahead = currProd.maxLookahead || maxLookahead;
             const currOccurrence = currProd.idx;
             const paths = lookahead.getLookaheadPathsForOptionalProd(currOccurrence, currTopRule, prodType, actualMaxLookahead);
             const pathsInsideProduction = paths[0];
-            if (isEmpty(flatten(pathsInsideProduction))) {
+            if (isEmpty.default(flatten.default(pathsInsideProduction))) {
                 const errMsg = errMsgProvider.buildEmptyRepetitionError({
                     topLevelRule: currTopRule,
                     repetition: currProd,
@@ -344,14 +344,14 @@ function validateSomeNonEmptyLookaheadPath(topLevelRules, maxLookahead, errMsgPr
 }
 function checkAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {
     const foundAmbiguousPaths = [];
-    const identicalAmbiguities = reduce(alternatives, (result, currAlt, currAltIdx) => {
+    const identicalAmbiguities = reduce.default(alternatives, (result, currAlt, currAltIdx) => {
         // ignore (skip) ambiguities with this alternative
         if (alternation.definition[currAltIdx].ignoreAmbiguities === true) {
             return result;
         }
-        forEach(currAlt, (currPath) => {
+        forEach.default(currAlt, (currPath) => {
             const altsCurrPathAppearsIn = [currAltIdx];
-            forEach(alternatives, (currOtherAlt, currOtherAltIdx) => {
+            forEach.default(alternatives, (currOtherAlt, currOtherAltIdx) => {
                 if (currAltIdx !== currOtherAltIdx &&
                     lookahead.containsPath(currOtherAlt, currPath) &&
                     // ignore (skip) ambiguities with this "other" alternative
@@ -370,8 +370,8 @@ function checkAlternativesAmbiguities(alternatives, alternation, rule, errMsgPro
         });
         return result;
     }, []);
-    const currErrors = map(identicalAmbiguities, (currAmbDescriptor) => {
-        const ambgIndices = map(currAmbDescriptor.alts, (currAltIdx) => currAltIdx + 1);
+    const currErrors = map.default(identicalAmbiguities, (currAmbDescriptor) => {
+        const ambgIndices = map.default(currAmbDescriptor.alts, (currAltIdx) => currAltIdx + 1);
         const currMessage = errMsgProvider.buildAlternationAmbiguityError({
             topLevelRule: rule,
             alternation: alternation,
@@ -390,13 +390,13 @@ function checkAlternativesAmbiguities(alternatives, alternation, rule, errMsgPro
 }
 function checkPrefixAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {
     // flatten
-    const pathsAndIndices = reduce(alternatives, (result, currAlt, idx) => {
-        const currPathsAndIdx = map(currAlt, (currPath) => {
+    const pathsAndIndices = reduce.default(alternatives, (result, currAlt, idx) => {
+        const currPathsAndIdx = map.default(currAlt, (currPath) => {
             return { idx: idx, path: currPath };
         });
         return result.concat(currPathsAndIdx);
     }, []);
-    const errors = compact(flatMap(pathsAndIndices, (currPathAndIdx) => {
+    const errors = compact.default(flatMap.default(pathsAndIndices, (currPathAndIdx) => {
         const alternativeGast = alternation.definition[currPathAndIdx.idx];
         // ignore (skip) ambiguities with this alternative
         if (alternativeGast.ignoreAmbiguities === true) {
@@ -404,7 +404,7 @@ function checkPrefixAlternativesAmbiguities(alternatives, alternation, rule, err
         }
         const targetIdx = currPathAndIdx.idx;
         const targetPath = currPathAndIdx.path;
-        const prefixAmbiguitiesPathsAndIndices = filter(pathsAndIndices, (searchPathAndIdx) => {
+        const prefixAmbiguitiesPathsAndIndices = filter.default(pathsAndIndices, (searchPathAndIdx) => {
             // prefix ambiguity can only be created from lower idx (higher priority) path
             return (
             // ignore (skip) ambiguities with this "other" alternative
@@ -415,7 +415,7 @@ function checkPrefixAlternativesAmbiguities(alternatives, alternation, rule, err
                 // will be be detected using a different validation.
                 lookahead.isStrictPrefixOfPath(searchPathAndIdx.path, targetPath));
         });
-        const currPathPrefixErrors = map(prefixAmbiguitiesPathsAndIndices, (currAmbPathAndIdx) => {
+        const currPathPrefixErrors = map.default(prefixAmbiguitiesPathsAndIndices, (currAmbPathAndIdx) => {
             const ambgIndices = [currAmbPathAndIdx.idx + 1, targetIdx + 1];
             const occurrence = alternation.idx === 0 ? "" : alternation.idx;
             const message = errMsgProvider.buildAlternationPrefixAmbiguityError({
@@ -438,10 +438,10 @@ function checkPrefixAlternativesAmbiguities(alternatives, alternation, rule, err
 }
 function checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider) {
     const errors = [];
-    const tokenNames = map(tokenTypes, (currToken) => currToken.name);
-    forEach(topLevels, (currRule) => {
+    const tokenNames = map.default(tokenTypes, (currToken) => currToken.name);
+    forEach.default(topLevels, (currRule) => {
         const currRuleName = currRule.name;
-        if (includes(tokenNames, currRuleName)) {
+        if (includes.default(tokenNames, currRuleName)) {
             const errMsg = errMsgProvider.buildNamespaceConflictError(currRule);
             errors.push({
                 message: errMsg,

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/first.js

@@ -48,13 +48,13 @@ function firstForSequence(prod) {
         nextSubProdIdx = nextSubProdIdx + 1;
         hasInnerProdsRemaining = seq.length > nextSubProdIdx;
     }
-    return uniq(firstSet);
+    return uniq.default(firstSet);
 }
 function firstForBranching(prod) {
-    const allAlternativesFirsts = map(prod.definition, (innerProd) => {
+    const allAlternativesFirsts = map.default(prod.definition, (innerProd) => {
         return first(innerProd);
     });
-    return uniq(flatten(allAlternativesFirsts));
+    return uniq.default(flatten.default(allAlternativesFirsts));
 }
 function firstForTerminal(terminal) {
     return [terminal.terminalType];

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/follow.js

@@ -33,9 +33,9 @@ class ResyncFollowsWalker extends rest.RestWalker {
 }
 function computeAllProdsFollows(topProductions) {
     const reSyncFollows = {};
-    forEach(topProductions, (topProd) => {
+    forEach.default(topProductions, (topProd) => {
         const currRefsFollow = new ResyncFollowsWalker(topProd).startWalking();
-        assign(reSyncFollows, currRefsFollow);
+        assign.default(reSyncFollows, currRefsFollow);
     });
     return reSyncFollows;
 }

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/gast/gast_resolver_public.js

@@ -7,17 +7,17 @@ var defaults = require('../../../../../../../../lodash-es@4.17.21/node_modules/l
 var forEach = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.js');
 
 function resolveGrammar(options) {
-    const actualOptions = defaults(options, {
+    const actualOptions = defaults.default(options, {
         errMsgProvider: errors_public.defaultGrammarResolverErrorProvider,
     });
     const topRulesTable = {};
-    forEach(options.rules, (rule) => {
+    forEach.default(options.rules, (rule) => {
         topRulesTable[rule.name] = rule;
     });
     return resolver.resolveGrammar(topRulesTable, actualOptions.errMsgProvider);
 }
 function validateGrammar(options) {
-    options = defaults(options, {
+    options = defaults.default(options, {
         errMsgProvider: errors_public.defaultGrammarValidatorErrorProvider,
     });
     return checks.validateGrammar(options.rules, options.tokenTypes, options.errMsgProvider, options.grammarName);

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

@@ -28,8 +28,8 @@ class AbstractNextPossibleTokensWalker extends rest.RestWalker {
             throw Error("The path does not start with the walker's top Rule!");
         }
         // immutable for the win
-        this.ruleStack = clone(this.path.ruleStack).reverse(); // intelij bug requires assertion
-        this.occurrenceStack = clone(this.path.occurrenceStack).reverse(); // intelij bug requires assertion
+        this.ruleStack = clone.default(this.path.ruleStack).reverse(); // intelij bug requires assertion
+        this.occurrenceStack = clone.default(this.path.occurrenceStack).reverse(); // intelij bug requires assertion
         // already verified that the first production is valid, we now seek the 2nd production
         this.ruleStack.pop();
         this.occurrenceStack.pop();
@@ -54,7 +54,7 @@ class AbstractNextPossibleTokensWalker extends rest.RestWalker {
     }
     updateExpectedNext() {
         // need to consume the Terminal
-        if (isEmpty(this.ruleStack)) {
+        if (isEmpty.default(this.ruleStack)) {
             // must reset nextProductionXXX to avoid walking down another Top Level production while what we are
             // really seeking is the last Terminal...
             this.nextProductionName = "";
@@ -111,7 +111,7 @@ class AbstractNextTerminalAfterProductionWalker extends rest.RestWalker {
 class NextTerminalAfterManyWalker extends AbstractNextTerminalAfterProductionWalker {
     walkMany(manyProd, currRest, prevRest) {
         if (manyProd.idx === this.occurrence) {
-            const firstAfterMany = head(currRest.concat(prevRest));
+            const firstAfterMany = head.default(currRest.concat(prevRest));
             this.result.isEndOfRule = firstAfterMany === undefined;
             if (firstAfterMany instanceof model.Terminal) {
                 this.result.token = firstAfterMany.terminalType;
@@ -126,7 +126,7 @@ class NextTerminalAfterManyWalker extends AbstractNextTerminalAfterProductionWal
 class NextTerminalAfterManySepWalker extends AbstractNextTerminalAfterProductionWalker {
     walkManySep(manySepProd, currRest, prevRest) {
         if (manySepProd.idx === this.occurrence) {
-            const firstAfterManySep = head(currRest.concat(prevRest));
+            const firstAfterManySep = head.default(currRest.concat(prevRest));
             this.result.isEndOfRule = firstAfterManySep === undefined;
             if (firstAfterManySep instanceof model.Terminal) {
                 this.result.token = firstAfterManySep.terminalType;
@@ -141,7 +141,7 @@ class NextTerminalAfterManySepWalker extends AbstractNextTerminalAfterProduction
 class NextTerminalAfterAtLeastOneWalker extends AbstractNextTerminalAfterProductionWalker {
     walkAtLeastOne(atLeastOneProd, currRest, prevRest) {
         if (atLeastOneProd.idx === this.occurrence) {
-            const firstAfterAtLeastOne = head(currRest.concat(prevRest));
+            const firstAfterAtLeastOne = head.default(currRest.concat(prevRest));
             this.result.isEndOfRule = firstAfterAtLeastOne === undefined;
             if (firstAfterAtLeastOne instanceof model.Terminal) {
                 this.result.token = firstAfterAtLeastOne.terminalType;
@@ -157,7 +157,7 @@ class NextTerminalAfterAtLeastOneWalker extends AbstractNextTerminalAfterProduct
 class NextTerminalAfterAtLeastOneSepWalker extends AbstractNextTerminalAfterProductionWalker {
     walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest) {
         if (atleastOneSepProd.idx === this.occurrence) {
-            const firstAfterfirstAfterAtLeastOneSep = head(currRest.concat(prevRest));
+            const firstAfterfirstAfterAtLeastOneSep = head.default(currRest.concat(prevRest));
             this.result.isEndOfRule = firstAfterfirstAfterAtLeastOneSep === undefined;
             if (firstAfterfirstAfterAtLeastOneSep instanceof model.Terminal) {
                 this.result.token = firstAfterfirstAfterAtLeastOneSep.terminalType;
@@ -171,12 +171,12 @@ class NextTerminalAfterAtLeastOneSepWalker extends AbstractNextTerminalAfterProd
 }
 function possiblePathsFrom(targetDef, maxLength, currPath = []) {
     // avoid side effects
-    currPath = clone(currPath);
+    currPath = clone.default(currPath);
     let result = [];
     let i = 0;
     // TODO: avoid inner funcs
     function remainingPathWith(nextDef) {
-        return nextDef.concat(drop(targetDef, i + 1));
+        return nextDef.concat(drop.default(targetDef, i + 1));
     }
     // TODO: avoid inner funcs
     function getAlternativesForProd(definition) {
@@ -236,11 +236,11 @@ function possiblePathsFrom(targetDef, maxLength, currPath = []) {
             result = getAlternativesForProd(newDef);
         }
         else if (prod instanceof model.Alternation) {
-            forEach(prod.definition, (currAlt) => {
+            forEach.default(prod.definition, (currAlt) => {
                 // TODO: this is a limited check for empty alternatives
                 //   It would prevent a common case of infinite loops during parser initialization.
                 //   However **in-directly** empty alternatives may still cause issues.
-                if (isEmpty(currAlt.definition) === false) {
+                if (isEmpty.default(currAlt.definition) === false) {
                     result = getAlternativesForProd(currAlt.definition);
                 }
             });
@@ -256,7 +256,7 @@ function possiblePathsFrom(targetDef, maxLength, currPath = []) {
     }
     result.push({
         partialPath: currPath,
-        suffixDef: drop(targetDef, i),
+        suffixDef: drop.default(targetDef, i),
     });
     return result;
 }
@@ -276,12 +276,12 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
         ruleStack: [],
         occurrenceStack: [],
     });
-    while (!isEmpty(possiblePaths)) {
+    while (!isEmpty.default(possiblePaths)) {
         const currPath = possiblePaths.pop();
         // skip alternatives if no more results can be found (assuming deterministic grammar with fixed lookahead)
         if (currPath === EXIT_ALTERNATIVE) {
             if (foundCompletePath &&
-                last(possiblePaths).idx <= minimalAlternativesIndex) {
+                last.default(possiblePaths).idx <= minimalAlternativesIndex) {
                 // remove irrelevant alternative
                 possiblePaths.pop();
             }
@@ -292,7 +292,7 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
         const currRuleStack = currPath.ruleStack;
         const currOccurrenceStack = currPath.occurrenceStack;
         // For Example: an empty path could exist in a valid grammar in the case of an EMPTY_ALT
-        if (isEmpty(currDef)) {
+        if (isEmpty.default(currDef)) {
             continue;
         }
         const prod = currDef[0];
@@ -300,9 +300,9 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
         if (prod === EXIT_NON_TERMINAL) {
             const nextPath = {
                 idx: currIdx,
-                def: drop(currDef),
-                ruleStack: dropRight(currRuleStack),
-                occurrenceStack: dropRight(currOccurrenceStack),
+                def: drop.default(currDef),
+                ruleStack: dropRight.default(currRuleStack),
+                occurrenceStack: dropRight.default(currOccurrenceStack),
             };
             possiblePaths.push(nextPath);
         }
@@ -314,7 +314,7 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
                 if (tokMatcher(actualToken, prod.terminalType)) {
                     const nextPath = {
                         idx: nextIdx,
-                        def: drop(currDef),
+                        def: drop.default(currDef),
                         ruleStack: currRuleStack,
                         occurrenceStack: currOccurrenceStack,
                     };
@@ -337,13 +337,13 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
             }
         }
         else if (prod instanceof model.NonTerminal) {
-            const newRuleStack = clone(currRuleStack);
+            const newRuleStack = clone.default(currRuleStack);
             newRuleStack.push(prod.nonTerminalName);
-            const newOccurrenceStack = clone(currOccurrenceStack);
+            const newOccurrenceStack = clone.default(currOccurrenceStack);
             newOccurrenceStack.push(prod.idx);
             const nextPath = {
                 idx: currIdx,
-                def: prod.definition.concat(EXIT_NON_TERMINAL_ARR, drop(currDef)),
+                def: prod.definition.concat(EXIT_NON_TERMINAL_ARR, drop.default(currDef)),
                 ruleStack: newRuleStack,
                 occurrenceStack: newOccurrenceStack,
             };
@@ -353,7 +353,7 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
             // the order of alternatives is meaningful, FILO (Last path will be traversed first).
             const nextPathWithout = {
                 idx: currIdx,
-                def: drop(currDef),
+                def: drop.default(currDef),
                 ruleStack: currRuleStack,
                 occurrenceStack: currOccurrenceStack,
             };
@@ -362,7 +362,7 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
             possiblePaths.push(EXIT_ALTERNATIVE);
             const nextPathWith = {
                 idx: currIdx,
-                def: prod.definition.concat(drop(currDef)),
+                def: prod.definition.concat(drop.default(currDef)),
                 ruleStack: currRuleStack,
                 occurrenceStack: currOccurrenceStack,
             };
@@ -374,7 +374,7 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
                 definition: prod.definition,
                 idx: prod.idx,
             });
-            const nextDef = prod.definition.concat([secondIteration], drop(currDef));
+            const nextDef = prod.definition.concat([secondIteration], drop.default(currDef));
             const nextPath = {
                 idx: currIdx,
                 def: nextDef,
@@ -392,7 +392,7 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
                 definition: [separatorGast].concat(prod.definition),
                 idx: prod.idx,
             });
-            const nextDef = prod.definition.concat([secondIteration], drop(currDef));
+            const nextDef = prod.definition.concat([secondIteration], drop.default(currDef));
             const nextPath = {
                 idx: currIdx,
                 def: nextDef,
@@ -405,7 +405,7 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
             // the order of alternatives is meaningful, FILO (Last path will be traversed first).
             const nextPathWithout = {
                 idx: currIdx,
-                def: drop(currDef),
+                def: drop.default(currDef),
                 ruleStack: currRuleStack,
                 occurrenceStack: currOccurrenceStack,
             };
@@ -419,7 +419,7 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
                 definition: [separatorGast].concat(prod.definition),
                 idx: prod.idx,
             });
-            const nextDef = prod.definition.concat([nthRepetition], drop(currDef));
+            const nextDef = prod.definition.concat([nthRepetition], drop.default(currDef));
             const nextPathWith = {
                 idx: currIdx,
                 def: nextDef,
@@ -432,7 +432,7 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
             // the order of alternatives is meaningful, FILO (Last path will be traversed first).
             const nextPathWithout = {
                 idx: currIdx,
-                def: drop(currDef),
+                def: drop.default(currDef),
                 ruleStack: currRuleStack,
                 occurrenceStack: currOccurrenceStack,
             };
@@ -444,7 +444,7 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
                 definition: prod.definition,
                 idx: prod.idx,
             });
-            const nextDef = prod.definition.concat([nthRepetition], drop(currDef));
+            const nextDef = prod.definition.concat([nthRepetition], drop.default(currDef));
             const nextPathWith = {
                 idx: currIdx,
                 def: nextDef,
@@ -459,7 +459,7 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
                 const currAlt = prod.definition[i];
                 const currAltPath = {
                     idx: currIdx,
-                    def: currAlt.definition.concat(drop(currDef)),
+                    def: currAlt.definition.concat(drop.default(currDef)),
                     ruleStack: currRuleStack,
                     occurrenceStack: currOccurrenceStack,
                 };
@@ -470,7 +470,7 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
         else if (prod instanceof model.Alternative) {
             possiblePaths.push({
                 idx: currIdx,
-                def: prod.definition.concat(drop(currDef)),
+                def: prod.definition.concat(drop.default(currDef)),
                 ruleStack: currRuleStack,
                 occurrenceStack: currOccurrenceStack,
             });
@@ -486,9 +486,9 @@ function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhe
     return result;
 }
 function expandTopLevelRule(topRule, currIdx, currRuleStack, currOccurrenceStack) {
-    const newRuleStack = clone(currRuleStack);
+    const newRuleStack = clone.default(currRuleStack);
     newRuleStack.push(topRule.name);
-    const newCurrOccurrenceStack = clone(currOccurrenceStack);
+    const newCurrOccurrenceStack = clone.default(currOccurrenceStack);
     // top rule is always assumed to have been called with occurrence index 1
     newCurrOccurrenceStack.push(1);
     return {

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.js

@@ -15,7 +15,7 @@ class LLkLookaheadStrategy {
     }
     validate(options) {
         const leftRecursionErrors = this.validateNoLeftRecursion(options.rules);
-        if (isEmpty(leftRecursionErrors)) {
+        if (isEmpty.default(leftRecursionErrors)) {
             const emptyAltErrors = this.validateEmptyOrAlternatives(options.rules);
             const ambiguousAltsErrors = this.validateAmbiguousAlternationAlternatives(options.rules, this.maxLookahead);
             const emptyRepetitionErrors = this.validateSomeNonEmptyLookaheadPath(options.rules, this.maxLookahead);
@@ -30,13 +30,13 @@ class LLkLookaheadStrategy {
         return leftRecursionErrors;
     }
     validateNoLeftRecursion(rules) {
-        return flatMap(rules, (currTopRule) => checks.validateNoLeftRecursion(currTopRule, currTopRule, errors_public.defaultGrammarValidatorErrorProvider));
+        return flatMap.default(rules, (currTopRule) => checks.validateNoLeftRecursion(currTopRule, currTopRule, errors_public.defaultGrammarValidatorErrorProvider));
     }
     validateEmptyOrAlternatives(rules) {
-        return flatMap(rules, (currTopRule) => checks.validateEmptyOrAlternative(currTopRule, errors_public.defaultGrammarValidatorErrorProvider));
+        return flatMap.default(rules, (currTopRule) => checks.validateEmptyOrAlternative(currTopRule, errors_public.defaultGrammarValidatorErrorProvider));
     }
     validateAmbiguousAlternationAlternatives(rules, maxLookahead) {
-        return flatMap(rules, (currTopRule) => checks.validateAmbiguousAlternationAlternatives(currTopRule, maxLookahead, errors_public.defaultGrammarValidatorErrorProvider));
+        return flatMap.default(rules, (currTopRule) => checks.validateAmbiguousAlternationAlternatives(currTopRule, maxLookahead, errors_public.defaultGrammarValidatorErrorProvider));
     }
     validateSomeNonEmptyLookaheadPath(rules, maxLookahead) {
         return checks.validateSomeNonEmptyLookaheadPath(rules, maxLookahead, errors_public.defaultGrammarValidatorErrorProvider);