@windrun-huaiin/third-ui 13.0.1 → 13.1.0

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/lookahead.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/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/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;

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

@@ -197,14 +197,14 @@ class GastRecorder {
     }
     subruleInternalRecord(ruleToCall, occurrence, options) {
         assertMethodIdxIsValid(occurrence);
-        if (!ruleToCall || has(ruleToCall, "ruleName") === false) {
+        if (!ruleToCall || has.default(ruleToCall, "ruleName") === false) {
             const error = new Error(`<SUBRULE${getIdxSuffix(occurrence)}> argument is invalid` +
                 ` expecting a Parser method reference but got: <${JSON.stringify(ruleToCall)}>` +
                 `\n inside top level rule: <${this.recordingProdStack[0].name}>`);
             error.KNOWN_RECORDER_ERROR = true;
             throw error;
         }
-        const prevProd = last(this.recordingProdStack);
+        const prevProd = last.default(this.recordingProdStack);
         const ruleName = ruleToCall.ruleName;
         const newNoneTerminal = new model.NonTerminal({
             idx: occurrence,
@@ -227,7 +227,7 @@ class GastRecorder {
             error.KNOWN_RECORDER_ERROR = true;
             throw error;
         }
-        const prevProd = last(this.recordingProdStack);
+        const prevProd = last.default(this.recordingProdStack);
         const newNoneTerminal = new model.Terminal({
             idx: occurrence,
             terminalType: tokType,
@@ -239,13 +239,13 @@ class GastRecorder {
 }
 function recordProd(prodConstructor, mainProdArg, occurrence, handleSep = false) {
     assertMethodIdxIsValid(occurrence);
-    const prevProd = last(this.recordingProdStack);
-    const grammarAction = isFunction(mainProdArg) ? mainProdArg : mainProdArg.DEF;
+    const prevProd = last.default(this.recordingProdStack);
+    const grammarAction = isFunction.default(mainProdArg) ? mainProdArg : mainProdArg.DEF;
     const newProd = new prodConstructor({ definition: [], idx: occurrence });
     if (handleSep) {
         newProd.separator = mainProdArg.SEP;
     }
-    if (has(mainProdArg, "MAX_LOOKAHEAD")) {
+    if (has.default(mainProdArg, "MAX_LOOKAHEAD")) {
         newProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
     }
     this.recordingProdStack.push(newProd);
@@ -256,29 +256,29 @@ function recordProd(prodConstructor, mainProdArg, occurrence, handleSep = false)
 }
 function recordOrProd(mainProdArg, occurrence) {
     assertMethodIdxIsValid(occurrence);
-    const prevProd = last(this.recordingProdStack);
+    const prevProd = last.default(this.recordingProdStack);
     // Only an array of alternatives
-    const hasOptions = isArray(mainProdArg) === false;
+    const hasOptions = isArray.default(mainProdArg) === false;
     const alts = hasOptions === false ? mainProdArg : mainProdArg.DEF;
     const newOrProd = new model.Alternation({
         definition: [],
         idx: occurrence,
         ignoreAmbiguities: hasOptions && mainProdArg.IGNORE_AMBIGUITIES === true,
     });
-    if (has(mainProdArg, "MAX_LOOKAHEAD")) {
+    if (has.default(mainProdArg, "MAX_LOOKAHEAD")) {
         newOrProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
     }
-    const hasPredicates = some(alts, (currAlt) => isFunction(currAlt.GATE));
+    const hasPredicates = some.default(alts, (currAlt) => isFunction.default(currAlt.GATE));
     newOrProd.hasPredicates = hasPredicates;
     prevProd.definition.push(newOrProd);
-    forEach(alts, (currAlt) => {
+    forEach.default(alts, (currAlt) => {
         const currAltFlat = new model.Alternative({ definition: [] });
         newOrProd.definition.push(currAltFlat);
-        if (has(currAlt, "IGNORE_AMBIGUITIES")) {
+        if (has.default(currAlt, "IGNORE_AMBIGUITIES")) {
             currAltFlat.ignoreAmbiguities = currAlt.IGNORE_AMBIGUITIES; // assumes end user provides the correct config value/type
         }
         // **implicit** ignoreAmbiguities due to usage of gate
-        else if (has(currAlt, "GATE")) {
+        else if (has.default(currAlt, "GATE")) {
             currAltFlat.ignoreAmbiguities = true;
         }
         this.recordingProdStack.push(currAltFlat);

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

@@ -13,22 +13,22 @@ var forEach = require('../../../../../../../../lodash-es@4.17.21/node_modules/lo
  */
 class LooksAhead {
     initLooksAhead(config) {
-        this.dynamicTokensEnabled = has(config, "dynamicTokensEnabled")
+        this.dynamicTokensEnabled = has.default(config, "dynamicTokensEnabled")
             ? config.dynamicTokensEnabled // assumes end user provides the correct config value/type
             : parser.DEFAULT_PARSER_CONFIG.dynamicTokensEnabled;
-        this.maxLookahead = has(config, "maxLookahead")
+        this.maxLookahead = has.default(config, "maxLookahead")
             ? config.maxLookahead // assumes end user provides the correct config value/type
             : parser.DEFAULT_PARSER_CONFIG.maxLookahead;
-        this.lookaheadStrategy = has(config, "lookaheadStrategy")
+        this.lookaheadStrategy = has.default(config, "lookaheadStrategy")
             ? config.lookaheadStrategy // assumes end user provides the correct config value/type
             : new llk_lookahead.LLkLookaheadStrategy({ maxLookahead: this.maxLookahead });
         this.lookAheadFuncsCache = new Map();
     }
     preComputeLookaheadFunctions(rules) {
-        forEach(rules, (currRule) => {
+        forEach.default(rules, (currRule) => {
             this.TRACE_INIT(`${currRule.name} Rule Lookahead`, () => {
                 const { alternation, repetition, option, repetitionMandatory, repetitionMandatoryWithSeparator, repetitionWithSeparator, } = collectMethods(currRule);
-                forEach(alternation, (currProd) => {
+                forEach.default(alternation, (currProd) => {
                     const prodIdx = currProd.idx === 0 ? "" : currProd.idx;
                     this.TRACE_INIT(`${helpers.getProductionDslName(currProd)}${prodIdx}`, () => {
                         const laFunc = this.lookaheadStrategy.buildLookaheadForAlternation({
@@ -42,19 +42,19 @@ class LooksAhead {
                         this.setLaFuncCache(key, laFunc);
                     });
                 });
-                forEach(repetition, (currProd) => {
+                forEach.default(repetition, (currProd) => {
                     this.computeLookaheadFunc(currRule, currProd.idx, keys.MANY_IDX, "Repetition", currProd.maxLookahead, helpers.getProductionDslName(currProd));
                 });
-                forEach(option, (currProd) => {
+                forEach.default(option, (currProd) => {
                     this.computeLookaheadFunc(currRule, currProd.idx, keys.OPTION_IDX, "Option", currProd.maxLookahead, helpers.getProductionDslName(currProd));
                 });
-                forEach(repetitionMandatory, (currProd) => {
+                forEach.default(repetitionMandatory, (currProd) => {
                     this.computeLookaheadFunc(currRule, currProd.idx, keys.AT_LEAST_ONE_IDX, "RepetitionMandatory", currProd.maxLookahead, helpers.getProductionDslName(currProd));
                 });
-                forEach(repetitionMandatoryWithSeparator, (currProd) => {
+                forEach.default(repetitionMandatoryWithSeparator, (currProd) => {
                     this.computeLookaheadFunc(currRule, currProd.idx, keys.AT_LEAST_ONE_SEP_IDX, "RepetitionMandatoryWithSeparator", currProd.maxLookahead, helpers.getProductionDslName(currProd));
                 });
-                forEach(repetitionWithSeparator, (currProd) => {
+                forEach.default(repetitionWithSeparator, (currProd) => {
                     this.computeLookaheadFunc(currRule, currProd.idx, keys.MANY_SEP_IDX, "RepetitionWithSeparator", currProd.maxLookahead, helpers.getProductionDslName(currProd));
                 });
             });

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

@@ -9,7 +9,7 @@ var has = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash
  */
 class PerformanceTracer {
     initPerformanceTracer(config) {
-        if (has(config, "traceInitPerf")) {
+        if (has.default(config, "traceInitPerf")) {
             const userTraceInitPerf = config.traceInitPerf;
             const traceIsNumber = typeof userTraceInitPerf === "number";
             this.traceInitMaxIdent = traceIsNumber

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

@@ -279,7 +279,7 @@ class RecognizerApi {
         this.atLeastOneSepFirstInternal(9, options);
     }
     RULE(name, implementation, config = parser.DEFAULT_RULE_CONFIG) {
-        if (includes(this.definedRulesNames, name)) {
+        if (includes.default(this.definedRulesNames, name)) {
             const errMsg = errors_public.defaultGrammarValidatorErrorProvider.buildDuplicateRuleNameError({
                 topLevelRule: name,
                 grammarName: this.className,
@@ -332,7 +332,7 @@ class RecognizerApi {
         return this.gastProductionsCache;
     }
     getSerializedGastProductions() {
-        return model.serializeGrammar(values(this.gastProductionsCache));
+        return model.serializeGrammar(values.default(this.gastProductionsCache));
     }
 }
 

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

@@ -38,16 +38,16 @@ class RecognizerEngine {
         this.RULE_STACK = [];
         this.RULE_OCCURRENCE_STACK = [];
         this.gastProductionsCache = {};
-        if (has(config, "serializedGrammar")) {
+        if (has.default(config, "serializedGrammar")) {
             throw Error("The Parser's configuration can no longer contain a <serializedGrammar> property.\n" +
                 "\tSee: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_6-0-0\n" +
                 "\tFor Further details.");
         }
-        if (isArray(tokenVocabulary)) {
+        if (isArray.default(tokenVocabulary)) {
             // This only checks for Token vocabularies provided as arrays.
             // That is good enough because the main objective is to detect users of pre-V4.0 APIs
             // rather than all edge cases of empty Token vocabularies.
-            if (isEmpty(tokenVocabulary)) {
+            if (isEmpty.default(tokenVocabulary)) {
                 throw Error("A Token Vocabulary cannot be empty.\n" +
                     "\tNote that the first argument for the parser constructor\n" +
                     "\tis no longer a Token vector (since v4.0).");
@@ -58,23 +58,23 @@ class RecognizerEngine {
                     "\tFor Further details.");
             }
         }
-        if (isArray(tokenVocabulary)) {
-            this.tokensMap = reduce(tokenVocabulary, (acc, tokType) => {
+        if (isArray.default(tokenVocabulary)) {
+            this.tokensMap = reduce.default(tokenVocabulary, (acc, tokType) => {
                 acc[tokType.name] = tokType;
                 return acc;
             }, {});
         }
-        else if (has(tokenVocabulary, "modes") &&
-            every(flatten(values(tokenVocabulary.modes)), tokens.isTokenType)) {
-            const allTokenTypes = flatten(values(tokenVocabulary.modes));
-            const uniqueTokens = uniq(allTokenTypes);
-            this.tokensMap = reduce(uniqueTokens, (acc, tokType) => {
+        else if (has.default(tokenVocabulary, "modes") &&
+            every.default(flatten.default(values.default(tokenVocabulary.modes)), tokens.isTokenType)) {
+            const allTokenTypes = flatten.default(values.default(tokenVocabulary.modes));
+            const uniqueTokens = uniq.default(allTokenTypes);
+            this.tokensMap = reduce.default(uniqueTokens, (acc, tokType) => {
                 acc[tokType.name] = tokType;
                 return acc;
             }, {});
         }
-        else if (isObject(tokenVocabulary)) {
-            this.tokensMap = clone(tokenVocabulary);
+        else if (isObject.default(tokenVocabulary)) {
+            this.tokensMap = clone.default(tokenVocabulary);
         }
         else {
             throw new Error("<tokensDictionary> argument must be An Array of Token constructors," +
@@ -83,27 +83,27 @@ class RecognizerEngine {
         // always add EOF to the tokenNames -> constructors map. it is useful to assure all the input has been
         // parsed with a clear error message ("expecting EOF but found ...")
         this.tokensMap["EOF"] = tokens_public.EOF;
-        const allTokenTypes = has(tokenVocabulary, "modes")
-            ? flatten(values(tokenVocabulary.modes))
-            : values(tokenVocabulary);
-        const noTokenCategoriesUsed = every(allTokenTypes, (tokenConstructor) => isEmpty(tokenConstructor.categoryMatches));
+        const allTokenTypes = has.default(tokenVocabulary, "modes")
+            ? flatten.default(values.default(tokenVocabulary.modes))
+            : values.default(tokenVocabulary);
+        const noTokenCategoriesUsed = every.default(allTokenTypes, (tokenConstructor) => isEmpty.default(tokenConstructor.categoryMatches));
         this.tokenMatcher = noTokenCategoriesUsed
             ? tokens.tokenStructuredMatcherNoCategories
             : tokens.tokenStructuredMatcher;
         // Because ES2015+ syntax should be supported for creating Token classes
         // We cannot assume that the Token classes were created using the "extendToken" utilities
         // Therefore we must augment the Token classes both on Lexer initialization and on Parser initialization
-        tokens.augmentTokenTypes(values(this.tokensMap));
+        tokens.augmentTokenTypes(values.default(this.tokensMap));
     }
     defineRule(ruleName, impl, config) {
         if (this.selfAnalysisDone) {
             throw Error(`Grammar rule <${ruleName}> may not be defined after the 'performSelfAnalysis' method has been called'\n` +
                 `Make sure that all grammar rule definitions are done before 'performSelfAnalysis' is called.`);
         }
-        const resyncEnabled = has(config, "resyncEnabled")
+        const resyncEnabled = has.default(config, "resyncEnabled")
             ? config.resyncEnabled // assumes end user provides the correct config value/type
             : parser.DEFAULT_RULE_CONFIG.resyncEnabled;
-        const recoveryValueFunc = has(config, "recoveryValueFunc")
+        const recoveryValueFunc = has.default(config, "recoveryValueFunc")
             ? config.recoveryValueFunc // assumes end user provides the correct config value/type
             : parser.DEFAULT_RULE_CONFIG.recoveryValueFunc;
         // performance optimization: Use small integers as keys for the longer human readable "full" rule names.
@@ -396,7 +396,7 @@ class RecognizerEngine {
     }
     orInternal(altsOrOpts, occurrence) {
         const laKey = this.getKeyForAutomaticLookahead(keys.OR_IDX, occurrence);
-        const alts = isArray(altsOrOpts) ? altsOrOpts : altsOrOpts.DEF;
+        const alts = isArray.default(altsOrOpts) ? altsOrOpts : altsOrOpts.DEF;
         const laFunc = this.getLaFuncFromCache(laKey);
         const altIdxToTake = laFunc.call(this, alts);
         if (altIdxToTake !== undefined) {
@@ -508,7 +508,7 @@ class RecognizerEngine {
     saveRecogState() {
         // errors is a getter which will clone the errors array
         const savedErrors = this.errors;
-        const savedRuleStack = clone(this.RULE_STACK);
+        const savedRuleStack = clone.default(this.RULE_STACK);
         return {
             errors: savedErrors,
             lexerState: this.exportLexerState(),