@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/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(),

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

@@ -28,7 +28,7 @@ class Recoverable {
     initRecoverable(config) {
         this.firstAfterRepMap = {};
         this.resyncFollows = {};
-        this.recoveryEnabled = has(config, "recoveryEnabled")
+        this.recoveryEnabled = has.default(config, "recoveryEnabled")
             ? config.recoveryEnabled // assumes end user provides the correct config value/type
             : parser.DEFAULT_PARSER_CONFIG.recoveryEnabled;
         // performance optimization, NOOP will be inlined which
@@ -69,7 +69,7 @@ class Recoverable {
             });
             const error = new exceptions_public.MismatchedTokenException(msg, nextTokenWithoutResync, this.LA(0));
             // the first token here will be the original cause of the error, this is not part of the resyncedTokens property.
-            error.resyncedTokens = dropRight(resyncedTokens);
+            error.resyncedTokens = dropRight.default(resyncedTokens);
             this.SAVE_ERROR(error);
         };
         while (!passedResyncPoint) {
@@ -148,11 +148,11 @@ class Recoverable {
             return false;
         }
         // must know the possible following tokens to perform single token insertion
-        if (isEmpty(follows)) {
+        if (isEmpty.default(follows)) {
             return false;
         }
         const mismatchedTok = this.LA(1);
-        const isMisMatchedTokInFollows = find(follows, (possibleFollowsTokType) => {
+        const isMisMatchedTokInFollows = find.default(follows, (possibleFollowsTokType) => {
             return this.tokenMatcher(mismatchedTok, possibleFollowsTokType);
         }) !== undefined;
         return isMisMatchedTokInFollows;
@@ -167,7 +167,7 @@ class Recoverable {
     isInCurrentRuleReSyncSet(tokenTypeIdx) {
         const followKey = this.getCurrFollowKey();
         const currentRuleReSyncSet = this.getFollowSetFromFollowKey(followKey);
-        return includes(currentRuleReSyncSet, tokenTypeIdx);
+        return includes.default(currentRuleReSyncSet, tokenTypeIdx);
     }
     findReSyncTokenType() {
         const allPossibleReSyncTokTypes = this.flattenFollowSet();
@@ -175,7 +175,7 @@ class Recoverable {
         let nextToken = this.LA(1);
         let k = 2;
         while (true) {
-            const foundMatch = find(allPossibleReSyncTokTypes, (resyncTokType) => {
+            const foundMatch = find.default(allPossibleReSyncTokTypes, (resyncTokType) => {
                 const canMatch = tokens_public.tokenMatcher(nextToken, resyncTokType);
                 return canMatch;
             });
@@ -203,7 +203,7 @@ class Recoverable {
     buildFullFollowKeyStack() {
         const explicitRuleStack = this.RULE_STACK;
         const explicitOccurrenceStack = this.RULE_OCCURRENCE_STACK;
-        return map(explicitRuleStack, (ruleName, idx) => {
+        return map.default(explicitRuleStack, (ruleName, idx) => {
             if (idx === 0) {
                 return EOF_FOLLOW_KEY;
             }
@@ -215,10 +215,10 @@ class Recoverable {
         });
     }
     flattenFollowSet() {
-        const followStack = map(this.buildFullFollowKeyStack(), (currKey) => {
+        const followStack = map.default(this.buildFullFollowKeyStack(), (currKey) => {
             return this.getFollowSetFromFollowKey(currKey);
         });
-        return flatten(followStack);
+        return flatten.default(followStack);
     }
     getFollowSetFromFollowKey(followKey) {
         if (followKey === EOF_FOLLOW_KEY) {
@@ -243,7 +243,7 @@ class Recoverable {
             this.addToResyncTokens(nextTok, resyncedTokens);
         }
         // the last token is not part of the error.
-        return dropRight(resyncedTokens);
+        return dropRight.default(resyncedTokens);
     }
     attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {
         // by default this is a NO-OP
@@ -251,7 +251,7 @@ class Recoverable {
     }
     getCurrentGrammarPath(tokType, tokIdxInRule) {
         const pathRuleStack = this.getHumanReadableRuleStack();
-        const pathOccurrenceStack = clone(this.RULE_OCCURRENCE_STACK);
+        const pathOccurrenceStack = clone.default(this.RULE_OCCURRENCE_STACK);
         const grammarPath = {
             ruleStack: pathRuleStack,
             occurrenceStack: pathOccurrenceStack,
@@ -261,7 +261,7 @@ class Recoverable {
         return grammarPath;
     }
     getHumanReadableRuleStack() {
-        return map(this.RULE_STACK, (currShortName) => this.shortRuleNameToFullName(currShortName));
+        return map.default(this.RULE_STACK, (currShortName) => this.shortRuleNameToFullName(currShortName));
     }
 }
 function attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {

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

@@ -16,27 +16,27 @@ class TreeBuilder {
         this.CST_STACK = [];
         // outputCst is no longer exposed/defined in the pubic API
         this.outputCst = config.outputCst;
-        this.nodeLocationTracking = has(config, "nodeLocationTracking")
+        this.nodeLocationTracking = has.default(config, "nodeLocationTracking")
             ? config.nodeLocationTracking // assumes end user provides the correct config value/type
             : parser.DEFAULT_PARSER_CONFIG.nodeLocationTracking;
         if (!this.outputCst) {
-            this.cstInvocationStateUpdate = noop;
-            this.cstFinallyStateUpdate = noop;
-            this.cstPostTerminal = noop;
-            this.cstPostNonTerminal = noop;
-            this.cstPostRule = noop;
+            this.cstInvocationStateUpdate = noop.default;
+            this.cstFinallyStateUpdate = noop.default;
+            this.cstPostTerminal = noop.default;
+            this.cstPostNonTerminal = noop.default;
+            this.cstPostRule = noop.default;
         }
         else {
             if (/full/i.test(this.nodeLocationTracking)) {
                 if (this.recoveryEnabled) {
                     this.setNodeLocationFromToken = cst.setNodeLocationFull;
                     this.setNodeLocationFromNode = cst.setNodeLocationFull;
-                    this.cstPostRule = noop;
+                    this.cstPostRule = noop.default;
                     this.setInitialNodeLocation = this.setInitialNodeLocationFullRecovery;
                 }
                 else {
-                    this.setNodeLocationFromToken = noop;
-                    this.setNodeLocationFromNode = noop;
+                    this.setNodeLocationFromToken = noop.default;
+                    this.setNodeLocationFromNode = noop.default;
                     this.cstPostRule = this.cstPostRuleFull;
                     this.setInitialNodeLocation = this.setInitialNodeLocationFullRegular;
                 }
@@ -45,23 +45,23 @@ class TreeBuilder {
                 if (this.recoveryEnabled) {
                     this.setNodeLocationFromToken = cst.setNodeLocationOnlyOffset;
                     this.setNodeLocationFromNode = cst.setNodeLocationOnlyOffset;
-                    this.cstPostRule = noop;
+                    this.cstPostRule = noop.default;
                     this.setInitialNodeLocation =
                         this.setInitialNodeLocationOnlyOffsetRecovery;
                 }
                 else {
-                    this.setNodeLocationFromToken = noop;
-                    this.setNodeLocationFromNode = noop;
+                    this.setNodeLocationFromToken = noop.default;
+                    this.setNodeLocationFromNode = noop.default;
                     this.cstPostRule = this.cstPostRuleOnlyOffset;
                     this.setInitialNodeLocation =
                         this.setInitialNodeLocationOnlyOffsetRegular;
                 }
             }
             else if (/none/i.test(this.nodeLocationTracking)) {
-                this.setNodeLocationFromToken = noop;
-                this.setNodeLocationFromNode = noop;
-                this.cstPostRule = noop;
-                this.setInitialNodeLocation = noop;
+                this.setNodeLocationFromToken = noop.default;
+                this.setNodeLocationFromNode = noop.default;
+                this.cstPostRule = noop.default;
+                this.setInitialNodeLocation = noop.default;
             }
             else {
                 throw Error(`Invalid <nodeLocationTracking> config option: "${config.nodeLocationTracking}"`);
@@ -166,16 +166,16 @@ class TreeBuilder {
         this.setNodeLocationFromNode(preCstNode.location, ruleCstResult.location);
     }
     getBaseCstVisitorConstructor() {
-        if (isUndefined(this.baseCstVisitorConstructor)) {
-            const newBaseCstVisitorConstructor = cst_visitor.createBaseSemanticVisitorConstructor(this.className, keys(this.gastProductionsCache));
+        if (isUndefined.default(this.baseCstVisitorConstructor)) {
+            const newBaseCstVisitorConstructor = cst_visitor.createBaseSemanticVisitorConstructor(this.className, keys.default(this.gastProductionsCache));
             this.baseCstVisitorConstructor = newBaseCstVisitorConstructor;
             return newBaseCstVisitorConstructor;
         }
         return this.baseCstVisitorConstructor;
     }
     getBaseCstVisitorConstructorWithDefaults() {
-        if (isUndefined(this.baseCstVisitorWithDefaultsConstructor)) {
-            const newConstructor = cst_visitor.createBaseVisitorConstructorWithDefaults(this.className, keys(this.gastProductionsCache), this.getBaseCstVisitorConstructor());
+        if (isUndefined.default(this.baseCstVisitorWithDefaultsConstructor)) {
+            const newConstructor = cst_visitor.createBaseVisitorConstructorWithDefaults(this.className, keys.default(this.gastProductionsCache), this.getBaseCstVisitorConstructor());
             this.baseCstVisitorWithDefaultsConstructor = newConstructor;
             return newConstructor;
         }