@windrun-huaiin/third-ui 13.0.0 → 13.1.0

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

@@ -5,8 +5,8 @@ var rest = require('./rest.js');
 var model = require('../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.js');
 var clone = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clone.js');
 var forEach = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.js');
-var isEmpty = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.js');
 var drop = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/drop.js');
+var isEmpty = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.js');
 var dropRight = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/dropRight.js');
 var last = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/last.js');
 var head = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/head.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/interpreter.mjs

@@ -3,8 +3,8 @@ import { RestWalker } from './rest.mjs';
 import { Alternative, NonTerminal, Option, RepetitionMandatory, Repetition, RepetitionMandatoryWithSeparator, Terminal, RepetitionWithSeparator, Alternation, Rule } from '../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs';
 import clone from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clone.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 drop from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/drop.mjs';
+import isEmpty from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.mjs';
 import dropRight from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/dropRight.mjs';
 import last from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/last.mjs';
 import head from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/head.mjs';

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);

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

@@ -6,8 +6,8 @@ var tokens = require('../../scan/tokens.js');
 var model = require('../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.js');
 var visitor = require('../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/visitor.js');
 var every = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/every.js');
-var isEmpty = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.js');
 var map = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.js');
+var isEmpty = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.js');
 var forEach = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.js');
 var flatten = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.js');
 var reduce = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/reduce.js');
@@ -87,8 +87,8 @@ function buildLookaheadFuncForOptionalProd(occurrence, ruleGrammar, k, dynamicTo
 }
 function buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher, dynamicTokensEnabled) {
     const numOfAlts = alts.length;
-    const areAllOneTokenLookahead = every(alts, (currAlt) => {
-        return every(currAlt, (currPath) => {
+    const areAllOneTokenLookahead = every.default(alts, (currAlt) => {
+        return every.default(currAlt, (currPath) => {
             return currPath.length === 1;
         });
     });
@@ -101,7 +101,7 @@ function buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher, dynam
             // unfortunately the predicates must be extracted every single time
             // as they cannot be cached due to references to parameters(vars) which are no longer valid.
             // note that in the common case of no predicates, no cpu time will be wasted on this (see else block)
-            const predicates = map(orAlts, (currAlt) => currAlt.GATE);
+            const predicates = map.default(orAlts, (currAlt) => currAlt.GATE);
             for (let t = 0; t < numOfAlts; t++) {
                 const currAlt = alts[t];
                 const currNumOfPaths = currAlt.length;
@@ -135,16 +135,16 @@ function buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher, dynam
     else if (areAllOneTokenLookahead && !dynamicTokensEnabled) {
         // optimized (common) case of all the lookaheads paths requiring only
         // a single token lookahead. These Optimizations cannot work if dynamically defined Tokens are used.
-        const singleTokenAlts = map(alts, (currAlt) => {
-            return flatten(currAlt);
+        const singleTokenAlts = map.default(alts, (currAlt) => {
+            return flatten.default(currAlt);
         });
-        const choiceToAlt = reduce(singleTokenAlts, (result, currAlt, idx) => {
-            forEach(currAlt, (currTokType) => {
-                if (!has(result, currTokType.tokenTypeIdx)) {
+        const choiceToAlt = reduce.default(singleTokenAlts, (result, currAlt, idx) => {
+            forEach.default(currAlt, (currTokType) => {
+                if (!has.default(result, currTokType.tokenTypeIdx)) {
                     result[currTokType.tokenTypeIdx] = idx;
                 }
-                forEach(currTokType.categoryMatches, (currExtendingType) => {
-                    if (!has(result, currExtendingType)) {
+                forEach.default(currTokType.categoryMatches, (currExtendingType) => {
+                    if (!has.default(result, currExtendingType)) {
                         result[currExtendingType] = idx;
                     }
                 });
@@ -193,16 +193,16 @@ function buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher, dynam
     }
 }
 function buildSingleAlternativeLookaheadFunction(alt, tokenMatcher, dynamicTokensEnabled) {
-    const areAllOneTokenLookahead = every(alt, (currPath) => {
+    const areAllOneTokenLookahead = every.default(alt, (currPath) => {
         return currPath.length === 1;
     });
     const numOfPaths = alt.length;
     // optimized (common) case of all the lookaheads paths requiring only
     // a single token lookahead.
     if (areAllOneTokenLookahead && !dynamicTokensEnabled) {
-        const singleTokensTypes = flatten(alt);
+        const singleTokensTypes = flatten.default(alt);
         if (singleTokensTypes.length === 1 &&
-            isEmpty(singleTokensTypes[0].categoryMatches)) {
+            isEmpty.default(singleTokensTypes[0].categoryMatches)) {
             const expectedTokenType = singleTokensTypes[0];
             const expectedTokenUniqueKey = expectedTokenType.tokenTypeIdx;
             return function () {
@@ -210,9 +210,9 @@ function buildSingleAlternativeLookaheadFunction(alt, tokenMatcher, dynamicToken
             };
         }
         else {
-            const choiceToAlt = reduce(singleTokensTypes, (result, currTokType, idx) => {
+            const choiceToAlt = reduce.default(singleTokensTypes, (result, currTokType, idx) => {
                 result[currTokType.tokenTypeIdx] = true;
-                forEach(currTokType.categoryMatches, (currExtendingType) => {
+                forEach.default(currTokType.categoryMatches, (currExtendingType) => {
                     result[currExtendingType] = true;
                 });
                 return result;
@@ -377,13 +377,13 @@ function isUniquePrefixHash(altKnownPathsKeys, searchPathKeys, idx) {
     return true;
 }
 function lookAheadSequenceFromAlternatives(altsDefs, k) {
-    const partialAlts = map(altsDefs, (currAlt) => interpreter.possiblePathsFrom([currAlt], 1));
+    const partialAlts = map.default(altsDefs, (currAlt) => interpreter.possiblePathsFrom([currAlt], 1));
     const finalResult = initializeArrayOfArrays(partialAlts.length);
-    const altsHashes = map(partialAlts, (currAltPaths) => {
+    const altsHashes = map.default(partialAlts, (currAltPaths) => {
         const dict = {};
-        forEach(currAltPaths, (item) => {
+        forEach.default(currAltPaths, (item) => {
             const keys = pathToHashKeys(item.partialPath);
-            forEach(keys, (currKey) => {
+            forEach.default(keys, (currKey) => {
                 dict[currKey] = true;
             });
         });
@@ -404,7 +404,7 @@ function lookAheadSequenceFromAlternatives(altsDefs, k) {
                 const prefixKeys = pathToHashKeys(currPathPrefix);
                 const isUnique = isUniquePrefixHash(altsHashes, prefixKeys, altIdx);
                 // End of the line for this path.
-                if (isUnique || isEmpty(suffixDef) || currPathPrefix.length === k) {
+                if (isUnique || isEmpty.default(suffixDef) || currPathPrefix.length === k) {
                     const currAltResult = finalResult[altIdx];
                     // TODO: Can we implement a containsPath using Maps/Dictionaries?
                     if (containsPath(currAltResult, currPathPrefix) === false) {
@@ -421,9 +421,9 @@ function lookAheadSequenceFromAlternatives(altsDefs, k) {
                     const newPartialPathsAndSuffixes = interpreter.possiblePathsFrom(suffixDef, pathLength + 1, currPathPrefix);
                     newData[altIdx] = newData[altIdx].concat(newPartialPathsAndSuffixes);
                     // Update keys for new known paths
-                    forEach(newPartialPathsAndSuffixes, (item) => {
+                    forEach.default(newPartialPathsAndSuffixes, (item) => {
                         const prefixKeys = pathToHashKeys(item.partialPath);
-                        forEach(prefixKeys, (key) => {
+                        forEach.default(prefixKeys, (key) => {
                             altsHashes[altIdx][key] = true;
                         });
                     });
@@ -469,14 +469,14 @@ function containsPath(alternative, searchPath) {
 }
 function isStrictPrefixOfPath(prefix, other) {
     return (prefix.length < other.length &&
-        every(prefix, (tokType, idx) => {
+        every.default(prefix, (tokType, idx) => {
             const otherTokType = other[idx];
             return (tokType === otherTokType ||
                 otherTokType.categoryMatchesMap[tokType.tokenTypeIdx]);
         }));
 }
 function areTokenCategoriesNotUsed(lookAheadPaths) {
-    return every(lookAheadPaths, (singleAltPaths) => every(singleAltPaths, (singlePath) => every(singlePath, (token) => isEmpty(token.categoryMatches))));
+    return every.default(lookAheadPaths, (singleAltPaths) => every.default(singleAltPaths, (singlePath) => every.default(singlePath, (token) => isEmpty.default(token.categoryMatches))));
 }
 
 exports.areTokenCategoriesNotUsed = areTokenCategoriesNotUsed;

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/lookahead.mjs

@@ -4,8 +4,8 @@ import { tokenStructuredMatcherNoCategories, tokenStructuredMatcher } from '../.
 import { Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Alternation, Alternative } from '../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs';
 import { GAstVisitor } from '../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/visitor.mjs';
 import every from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/every.mjs';
-import isEmpty from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.mjs';
 import map from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs';
+import isEmpty from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.mjs';
 import forEach from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs';
 import flatten from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.mjs';
 import reduce from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/reduce.mjs';

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

@@ -18,7 +18,7 @@ class GastRefResolverVisitor extends visitor.GAstVisitor {
         this.errors = [];
     }
     resolveRefs() {
-        forEach(values(this.nameToTopRule), (prod) => {
+        forEach.default(values.default(this.nameToTopRule), (prod) => {
             this.currTopLevel = prod;
             prod.accept(this);
         });

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

@@ -9,8 +9,8 @@ var drop = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-e
  */
 class RestWalker {
     walk(prod, prevRest = []) {
-        forEach(prod.definition, (subProd, index) => {
-            const currRest = drop(prod.definition, index + 1);
+        forEach.default(prod.definition, (subProd, index) => {
+            const currRest = drop.default(prod.definition, index + 1);
             /* istanbul ignore else */
             if (subProd instanceof model.NonTerminal) {
                 this.walkProdRef(subProd, currRest, prevRest);
@@ -84,7 +84,7 @@ class RestWalker {
         // 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) => {
+        forEach.default(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

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/rest.mjs

@@ -1,4 +1,4 @@
-import { NonTerminal, Terminal, Alternative, Option, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Repetition, Alternation } from '../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs';
+import { Option, Terminal, NonTerminal, Alternative, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Repetition, Alternation } from '../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs';
 import forEach from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs';
 import drop from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/drop.mjs';
 

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

@@ -85,7 +85,7 @@ class Parser {
                 try {
                     this.enableRecording();
                     // Building the GAST
-                    forEach(this.definedRulesNames, (currRuleName) => {
+                    forEach.default(this.definedRulesNames, (currRuleName) => {
                         const wrappedRule = this[currRuleName];
                         const originalGrammarAction = wrappedRule["originalGrammarAction"];
                         let recordedRuleGast;
@@ -102,49 +102,49 @@ class Parser {
             let resolverErrors = [];
             this.TRACE_INIT("Grammar Resolving", () => {
                 resolverErrors = gast_resolver_public.resolveGrammar({
-                    rules: values(this.gastProductionsCache),
+                    rules: values.default(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) {
+                if (isEmpty.default(resolverErrors) && this.skipValidations === false) {
                     const validationErrors = gast_resolver_public.validateGrammar({
-                        rules: values(this.gastProductionsCache),
-                        tokenTypes: values(this.tokensMap),
+                        rules: values.default(this.gastProductionsCache),
+                        tokenTypes: values.default(this.tokensMap),
                         errMsgProvider: errors_public.defaultGrammarValidatorErrorProvider,
                         grammarName: className,
                     });
                     const lookaheadValidationErrors = checks.validateLookahead({
                         lookaheadStrategy: this.lookaheadStrategy,
-                        rules: values(this.gastProductionsCache),
-                        tokenTypes: values(this.tokensMap),
+                        rules: values.default(this.gastProductionsCache),
+                        tokenTypes: values.default(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)) {
+            if (isEmpty.default(this.definitionErrors)) {
                 // The results of these computations are not needed unless error recovery is enabled.
                 if (this.recoveryEnabled) {
                     this.TRACE_INIT("computeAllProdsFollows", () => {
-                        const allFollows = follow.computeAllProdsFollows(values(this.gastProductionsCache));
+                        const allFollows = follow.computeAllProdsFollows(values.default(this.gastProductionsCache));
                         this.resyncFollows = allFollows;
                     });
                 }
                 this.TRACE_INIT("ComputeLookaheadFunctions", () => {
                     var _a, _b;
                     (_b = (_a = this.lookaheadStrategy).initialize) === null || _b === void 0 ? void 0 : _b.call(_a, {
-                        rules: values(this.gastProductionsCache),
+                        rules: values.default(this.gastProductionsCache),
                     });
-                    this.preComputeLookaheadFunctions(values(this.gastProductionsCache));
+                    this.preComputeLookaheadFunctions(values.default(this.gastProductionsCache));
                 });
             }
             if (!Parser.DEFER_DEFINITION_ERRORS_HANDLING &&
-                !isEmpty(this.definitionErrors)) {
-                defErrorsMsgs = map(this.definitionErrors, (defError) => defError.message);
+                !isEmpty.default(this.definitionErrors)) {
+                defErrorsMsgs = map.default(this.definitionErrors, (defError) => defError.message);
                 throw new Error(`Parser Definition Errors detected:\n ${defErrorsMsgs.join("\n-------------------------------\n")}`);
             }
         });
@@ -162,13 +162,13 @@ class Parser {
         that.initContentAssist();
         that.initGastRecorder(config);
         that.initPerformanceTracer(config);
-        if (has(config, "ignoredIssues")) {
+        if (has.default(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")
+        this.skipValidations = has.default(config, "skipValidations")
             ? config.skipValidations // casting assumes the end user passing the correct type
             : DEFAULT_PARSER_CONFIG.skipValidations;
     }
@@ -194,7 +194,7 @@ apply_mixins.applyMixins(Parser, [
 ]);
 class EmbeddedActionsParser extends Parser {
     constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {
-        const configClone = clone(config);
+        const configClone = clone.default(config);
         configClone.outputCst = false;
         super(tokenVocabulary, configClone);
     }

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/context_assist.js

@@ -8,7 +8,7 @@ class ContentAssist {
     initContentAssist() { }
     computeContentAssist(startRuleName, precedingInput) {
         const startRuleGast = this.gastProductionsCache[startRuleName];
-        if (isUndefined(startRuleGast)) {
+        if (isUndefined.default(startRuleGast)) {
             throw Error(`Rule ->${startRuleName}<- does not exist in this grammar.`);
         }
         return interpreter.nextPossibleTokensAfter([startRuleGast], precedingInput, this.tokenMatcher, this.maxLookahead);
@@ -16,7 +16,7 @@ class ContentAssist {
     // 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?
     getNextPossibleTokenTypes(grammarPath) {
-        const topRuleName = head(grammarPath.ruleStack);
+        const topRuleName = head.default(grammarPath.ruleStack);
         const gastProductions = this.getGAstProductions();
         const topProduction = gastProductions[topRuleName];
         const nextPossibleTokenTypes = new interpreter.NextAfterTokenWalker(topProduction, grammarPath).startWalking();

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js

@@ -12,7 +12,7 @@ var clone = require('../../../../../../../../lodash-es@4.17.21/node_modules/loda
 class ErrorHandler {
     initErrorHandler(config) {
         this._errors = [];
-        this.errorMessageProvider = has(config, "errorMessageProvider")
+        this.errorMessageProvider = has.default(config, "errorMessageProvider")
             ? config.errorMessageProvider // assumes end user provides the correct config value/type
             : parser.DEFAULT_PARSER_CONFIG.errorMessageProvider;
     }
@@ -20,7 +20,7 @@ class ErrorHandler {
         if (exceptions_public.isRecognitionException(error)) {
             error.context = {
                 ruleStack: this.getHumanReadableRuleStack(),
-                ruleOccurrenceStack: clone(this.RULE_OCCURRENCE_STACK),
+                ruleOccurrenceStack: clone.default(this.RULE_OCCURRENCE_STACK),
             };
             this._errors.push(error);
             return error;
@@ -30,7 +30,7 @@ class ErrorHandler {
         }
     }
     get errors() {
-        return clone(this._errors);
+        return clone.default(this._errors);
     }
     set errors(newErrors) {
         this._errors = newErrors;