@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/cst/cst_visitor.js

@@ -12,7 +12,7 @@ var isFunction = require('../../../../../../../lodash-es@4.17.21/node_modules/lo
 var compact = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/compact.js');
 
 function defaultVisit(ctx, param) {
-    const childrenNames = keys(ctx);
+    const childrenNames = keys.default(ctx);
     const childrenNamesLength = childrenNames.length;
     for (let i = 0; i < childrenNamesLength; i++) {
         const currChildName = childrenNames[i];
@@ -37,21 +37,21 @@ function createBaseSemanticVisitorConstructor(grammarName, ruleNames) {
     const semanticProto = {
         visit: function (cstNode, param) {
             // enables writing more concise visitor methods when CstNode has only a single child
-            if (isArray(cstNode)) {
+            if (isArray.default(cstNode)) {
                 // A CST Node's children dictionary can never have empty arrays as values
                 // If a key is defined there will be at least one element in the corresponding value array.
                 cstNode = cstNode[0];
             }
             // enables passing optional CstNodes concisely.
-            if (isUndefined(cstNode)) {
+            if (isUndefined.default(cstNode)) {
                 return undefined;
             }
             return this[cstNode.name](cstNode.children, param);
         },
         validateVisitor: function () {
             const semanticDefinitionErrors = validateVisitor(this, ruleNames);
-            if (!isEmpty(semanticDefinitionErrors)) {
-                const errorMessages = map(semanticDefinitionErrors, (currDefError) => currDefError.msg);
+            if (!isEmpty.default(semanticDefinitionErrors)) {
+                const errorMessages = map.default(semanticDefinitionErrors, (currDefError) => currDefError.msg);
                 throw Error(`Errors Detected in CST Visitor <${this.constructor.name}>:\n\t` +
                     `${errorMessages.join("\n\n").replace(/\n/g, "\n\t")}`);
             }
@@ -69,7 +69,7 @@ function createBaseVisitorConstructorWithDefaults(grammarName, ruleNames, baseCo
     // name?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FFunction%2Fname
     lang_extensions.defineNameProp(derivedConstructor, grammarName + "BaseSemanticsWithDefaults");
     const withDefaultsProto = Object.create(baseConstructor.prototype);
-    forEach(ruleNames, (ruleName) => {
+    forEach.default(ruleNames, (ruleName) => {
         withDefaultsProto[ruleName] = defaultVisit;
     });
     derivedConstructor.prototype = withDefaultsProto;
@@ -86,17 +86,17 @@ function validateVisitor(visitorInstance, ruleNames) {
     return missingErrors;
 }
 function validateMissingCstMethods(visitorInstance, ruleNames) {
-    const missingRuleNames = filter(ruleNames, (currRuleName) => {
-        return isFunction(visitorInstance[currRuleName]) === false;
+    const missingRuleNames = filter.default(ruleNames, (currRuleName) => {
+        return isFunction.default(visitorInstance[currRuleName]) === false;
     });
-    const errors = map(missingRuleNames, (currRuleName) => {
+    const errors = map.default(missingRuleNames, (currRuleName) => {
         return {
             msg: `Missing visitor method: <${currRuleName}> on ${(visitorInstance.constructor.name)} CST Visitor.`,
             type: exports.CstVisitorDefinitionError.MISSING_METHOD,
             methodName: currRuleName,
         };
     });
-    return compact(errors);
+    return compact.default(errors);
 }
 
 exports.createBaseSemanticVisitorConstructor = createBaseSemanticVisitorConstructor;

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

@@ -22,15 +22,15 @@ const defaultParserErrorProvider = {
     buildNoViableAltMessage({ expectedPathsPerAlt, actual, previous, customUserDescription, ruleName, }) {
         const errPrefix = "Expecting: ";
         // TODO: issue: No Viable Alternative Error may have incomplete details. #502
-        const actualText = head(actual).image;
+        const actualText = head.default(actual).image;
         const errSuffix = "\nbut found: '" + actualText + "'";
         if (customUserDescription) {
             return errPrefix + customUserDescription + errSuffix;
         }
         else {
-            const allLookAheadPaths = reduce(expectedPathsPerAlt, (result, currAltPaths) => result.concat(currAltPaths), []);
-            const nextValidTokenSequences = map(allLookAheadPaths, (currPath) => `[${map(currPath, (currTokenType) => tokens_public.tokenLabel(currTokenType)).join(", ")}]`);
-            const nextValidSequenceItems = map(nextValidTokenSequences, (itemMsg, idx) => `  ${idx + 1}. ${itemMsg}`);
+            const allLookAheadPaths = reduce.default(expectedPathsPerAlt, (result, currAltPaths) => result.concat(currAltPaths), []);
+            const nextValidTokenSequences = map.default(allLookAheadPaths, (currPath) => `[${map.default(currPath, (currTokenType) => tokens_public.tokenLabel(currTokenType)).join(", ")}]`);
+            const nextValidSequenceItems = map.default(nextValidTokenSequences, (itemMsg, idx) => `  ${idx + 1}. ${itemMsg}`);
             const calculatedDescription = `one of these possible Token sequences:\n${nextValidSequenceItems.join("\n")}`;
             return errPrefix + calculatedDescription + errSuffix;
         }
@@ -38,13 +38,13 @@ const defaultParserErrorProvider = {
     buildEarlyExitMessage({ expectedIterationPaths, actual, customUserDescription, ruleName, }) {
         const errPrefix = "Expecting: ";
         // TODO: issue: No Viable Alternative Error may have incomplete details. #502
-        const actualText = head(actual).image;
+        const actualText = head.default(actual).image;
         const errSuffix = "\nbut found: '" + actualText + "'";
         if (customUserDescription) {
             return errPrefix + customUserDescription + errSuffix;
         }
         else {
-            const nextValidTokenSequences = map(expectedIterationPaths, (currPath) => `[${map(currPath, (currTokenType) => tokens_public.tokenLabel(currTokenType)).join(",")}]`);
+            const nextValidTokenSequences = map.default(expectedIterationPaths, (currPath) => `[${map.default(currPath, (currTokenType) => tokens_public.tokenLabel(currTokenType)).join(",")}]`);
             const calculatedDescription = `expecting at least one iteration which starts with one of these possible Token sequences::\n  ` +
                 `<${nextValidTokenSequences.join(" ,")}>`;
             return errPrefix + calculatedDescription + errSuffix;
@@ -77,7 +77,7 @@ const defaultGrammarValidatorErrorProvider = {
             }
         }
         const topLevelName = topLevelRule.name;
-        const duplicateProd = head(duplicateProds);
+        const duplicateProd = head.default(duplicateProds);
         const index = duplicateProd.idx;
         const dslName = helpers.getProductionDslName(duplicateProd);
         const extraArgument = getExtraProductionArgument(duplicateProd);
@@ -100,7 +100,7 @@ const defaultGrammarValidatorErrorProvider = {
         return errMsg;
     },
     buildAlternationPrefixAmbiguityError(options) {
-        const pathMsg = map(options.prefixPath, (currTok) => tokens_public.tokenLabel(currTok)).join(", ");
+        const pathMsg = map.default(options.prefixPath, (currTok) => tokens_public.tokenLabel(currTok)).join(", ");
         const occurrence = options.alternation.idx === 0 ? "" : options.alternation.idx;
         const errMsg = `Ambiguous alternatives: <${options.ambiguityIndices.join(" ,")}> due to common lookahead prefix\n` +
             `in <OR${occurrence}> inside <${options.topLevelRule.name}> Rule,\n` +
@@ -110,7 +110,7 @@ const defaultGrammarValidatorErrorProvider = {
         return errMsg;
     },
     buildAlternationAmbiguityError(options) {
-        const pathMsg = map(options.prefixPath, (currtok) => tokens_public.tokenLabel(currtok)).join(", ");
+        const pathMsg = map.default(options.prefixPath, (currtok) => tokens_public.tokenLabel(currtok)).join(", ");
         const occurrence = options.alternation.idx === 0 ? "" : options.alternation.idx;
         let currMessage = `Ambiguous Alternatives Detected: <${options.ambiguityIndices.join(" ,")}> in <OR${occurrence}>` +
             ` inside <${options.topLevelRule.name}> Rule,\n` +
@@ -149,7 +149,7 @@ const defaultGrammarValidatorErrorProvider = {
     },
     buildLeftRecursionError(options) {
         const ruleName = options.topLevelRule.name;
-        const pathNames = map(options.leftRecursionPath, (currRule) => currRule.name);
+        const pathNames = map.default(options.leftRecursionPath, (currRule) => currRule.name);
         const leftRecursivePath = `${ruleName} --> ${pathNames
             .concat([ruleName])
             .join(" --> ")}`;

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

@@ -1,4 +1,4 @@
-import { tokenLabel, hasTokenLabel } from '../scan/tokens_public.mjs';
+import { hasTokenLabel, tokenLabel } from '../scan/tokens_public.mjs';
 import { Rule, Terminal, NonTerminal } from '../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs';
 import { getProductionDslName } from '../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/helpers.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/exceptions_public.js

@@ -16,7 +16,7 @@ Object.freeze(RECOGNITION_EXCEPTION_NAMES);
 // hacks to bypass no support for custom Errors in javascript/typescript
 function isRecognitionException(error) {
     // can't do instanceof on hacked custom js exceptions
-    return includes(RECOGNITION_EXCEPTION_NAMES, error.name);
+    return includes.default(RECOGNITION_EXCEPTION_NAMES, error.name);
 }
 class RecognitionException extends Error {
     constructor(message, token) {

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

@@ -8,16 +8,16 @@ var lookahead = require('./lookahead.js');
 var interpreter = require('./interpreter.js');
 var tokens = require('../../scan/tokens.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 flatten = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.js');
 var map = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.js');
 var flatMap = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatMap.js');
 var groupBy = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/groupBy.js');
 var pickBy = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/pickBy.js');
 var head = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/head.js');
 var values = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/values.js');
-var includes = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/includes.js');
 var reduce = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/reduce.js');
+var isEmpty = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.js');
+var flatten = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.js');
+var includes = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/includes.js');
 var difference = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/difference.js');
 var clone = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clone.js');
 var dropRight = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/dropRight.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/checks.mjs

@@ -6,16 +6,16 @@ import { getProdType, getLookaheadPathsForOptionalProd, getLookaheadPathsForOr,
 import { nextPossibleTokensAfter } from './interpreter.mjs';
 import { tokenStructuredMatcher } from '../../scan/tokens.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 flatten from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.mjs';
 import map from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs';
 import flatMap from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatMap.mjs';
 import groupBy from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/groupBy.mjs';
 import pickBy from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/pickBy.mjs';
 import head from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/head.mjs';
 import values from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/values.mjs';
-import includes from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/includes.mjs';
 import reduce from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/reduce.mjs';
+import isEmpty from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.mjs';
+import flatten from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.mjs';
+import includes from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/includes.mjs';
 import difference from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/difference.mjs';
 import clone from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clone.mjs';
 import dropRight from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/dropRight.mjs';

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