@windrun-huaiin/third-ui 13.0.1 → 13.1.1

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/lexer.js

@@ -34,7 +34,7 @@ const DEFAULT_MODE = "defaultMode";
 const MODES = "modes";
 let SUPPORT_STICKY = typeof new RegExp("(?:)").sticky === "boolean";
 function analyzeTokenTypes(tokenTypes, options) {
-    options = defaults(options, {
+    options = defaults.default(options, {
         useSticky: SUPPORT_STICKY,
         debug: false,
         safeMode: false,
@@ -48,7 +48,7 @@ function analyzeTokenTypes(tokenTypes, options) {
     });
     let onlyRelevantTypes;
     tracer("Reject Lexer.NA", () => {
-        onlyRelevantTypes = reject(tokenTypes, (currType) => {
+        onlyRelevantTypes = reject.default(tokenTypes, (currType) => {
             return currType[PATTERN] === lexer_public.Lexer.NA;
         });
     });
@@ -56,10 +56,10 @@ function analyzeTokenTypes(tokenTypes, options) {
     let allTransformedPatterns;
     tracer("Transform Patterns", () => {
         hasCustom = false;
-        allTransformedPatterns = map(onlyRelevantTypes, (currType) => {
+        allTransformedPatterns = map.default(onlyRelevantTypes, (currType) => {
             const currPattern = currType[PATTERN];
             /* istanbul ignore else */
-            if (isRegExp(currPattern)) {
+            if (isRegExp.default(currPattern)) {
                 const regExpSource = currPattern.source;
                 if (regExpSource.length === 1 &&
                     // only these regExp meta characters which can appear in a length one regExp
@@ -72,7 +72,7 @@ function analyzeTokenTypes(tokenTypes, options) {
                 else if (regExpSource.length === 2 &&
                     regExpSource[0] === "\\" &&
                     // not a meta character
-                    !includes([
+                    !includes.default([
                         "d",
                         "D",
                         "s",
@@ -101,7 +101,7 @@ function analyzeTokenTypes(tokenTypes, options) {
                         : addStartOfInput(currPattern);
                 }
             }
-            else if (isFunction(currPattern)) {
+            else if (isFunction.default(currPattern)) {
                 hasCustom = true;
                 // CustomPatternMatcherFunc - custom patterns do not require any transformations, only wrapping in a RegExp Like object
                 return { exec: currPattern };
@@ -134,42 +134,42 @@ function analyzeTokenTypes(tokenTypes, options) {
     let patternIdxToPushMode;
     let patternIdxToPopMode;
     tracer("misc mapping", () => {
-        patternIdxToType = map(onlyRelevantTypes, (currType) => currType.tokenTypeIdx);
-        patternIdxToGroup = map(onlyRelevantTypes, (clazz) => {
+        patternIdxToType = map.default(onlyRelevantTypes, (currType) => currType.tokenTypeIdx);
+        patternIdxToGroup = map.default(onlyRelevantTypes, (clazz) => {
             const groupName = clazz.GROUP;
             /* istanbul ignore next */
             if (groupName === lexer_public.Lexer.SKIPPED) {
                 return undefined;
             }
-            else if (isString(groupName)) {
+            else if (isString.default(groupName)) {
                 return groupName;
             }
-            else if (isUndefined(groupName)) {
+            else if (isUndefined.default(groupName)) {
                 return false;
             }
             else {
                 throw Error("non exhaustive match");
             }
         });
-        patternIdxToLongerAltIdxArr = map(onlyRelevantTypes, (clazz) => {
+        patternIdxToLongerAltIdxArr = map.default(onlyRelevantTypes, (clazz) => {
             const longerAltType = clazz.LONGER_ALT;
             if (longerAltType) {
-                const longerAltIdxArr = isArray(longerAltType)
-                    ? map(longerAltType, (type) => indexOf(onlyRelevantTypes, type))
-                    : [indexOf(onlyRelevantTypes, longerAltType)];
+                const longerAltIdxArr = isArray.default(longerAltType)
+                    ? map.default(longerAltType, (type) => indexOf.default(onlyRelevantTypes, type))
+                    : [indexOf.default(onlyRelevantTypes, longerAltType)];
                 return longerAltIdxArr;
             }
         });
-        patternIdxToPushMode = map(onlyRelevantTypes, (clazz) => clazz.PUSH_MODE);
-        patternIdxToPopMode = map(onlyRelevantTypes, (clazz) => has(clazz, "POP_MODE"));
+        patternIdxToPushMode = map.default(onlyRelevantTypes, (clazz) => clazz.PUSH_MODE);
+        patternIdxToPopMode = map.default(onlyRelevantTypes, (clazz) => has.default(clazz, "POP_MODE"));
     });
     let patternIdxToCanLineTerminator;
     tracer("Line Terminator Handling", () => {
         const lineTerminatorCharCodes = getCharCodes(options.lineTerminatorCharacters);
-        patternIdxToCanLineTerminator = map(onlyRelevantTypes, (tokType) => false);
+        patternIdxToCanLineTerminator = map.default(onlyRelevantTypes, (tokType) => false);
         if (options.positionTracking !== "onlyOffset") {
-            patternIdxToCanLineTerminator = map(onlyRelevantTypes, (tokType) => {
-                if (has(tokType, "LINE_BREAKS")) {
+            patternIdxToCanLineTerminator = map.default(onlyRelevantTypes, (tokType) => {
+                if (has.default(tokType, "LINE_BREAKS")) {
                     return !!tokType.LINE_BREAKS;
                 }
                 else {
@@ -184,16 +184,16 @@ function analyzeTokenTypes(tokenTypes, options) {
     let emptyGroups;
     let patternIdxToConfig;
     tracer("Misc Mapping #2", () => {
-        patternIdxToIsCustom = map(onlyRelevantTypes, isCustomPattern);
-        patternIdxToShort = map(allTransformedPatterns, isShortPattern);
-        emptyGroups = reduce(onlyRelevantTypes, (acc, clazz) => {
+        patternIdxToIsCustom = map.default(onlyRelevantTypes, isCustomPattern);
+        patternIdxToShort = map.default(allTransformedPatterns, isShortPattern);
+        emptyGroups = reduce.default(onlyRelevantTypes, (acc, clazz) => {
             const groupName = clazz.GROUP;
-            if (isString(groupName) && !(groupName === lexer_public.Lexer.SKIPPED)) {
+            if (isString.default(groupName) && !(groupName === lexer_public.Lexer.SKIPPED)) {
                 acc[groupName] = [];
             }
             return acc;
         }, {});
-        patternIdxToConfig = map(allTransformedPatterns, (x, idx) => {
+        patternIdxToConfig = map.default(allTransformedPatterns, (x, idx) => {
             return {
                 pattern: allTransformedPatterns[idx],
                 longerAlt: patternIdxToLongerAltIdxArr[idx],
@@ -212,15 +212,15 @@ function analyzeTokenTypes(tokenTypes, options) {
     let charCodeToPatternIdxToConfig = [];
     if (!options.safeMode) {
         tracer("First Char Optimization", () => {
-            charCodeToPatternIdxToConfig = reduce(onlyRelevantTypes, (result, currTokType, idx) => {
+            charCodeToPatternIdxToConfig = reduce.default(onlyRelevantTypes, (result, currTokType, idx) => {
                 if (typeof currTokType.PATTERN === "string") {
                     const charCode = currTokType.PATTERN.charCodeAt(0);
                     const optimizedIdx = charCodeToOptimizedIndex(charCode);
                     addToMapOfArrays(result, optimizedIdx, patternIdxToConfig[idx]);
                 }
-                else if (isArray(currTokType.START_CHARS_HINT)) {
+                else if (isArray.default(currTokType.START_CHARS_HINT)) {
                     let lastOptimizedIdx;
-                    forEach(currTokType.START_CHARS_HINT, (charOrInt) => {
+                    forEach.default(currTokType.START_CHARS_HINT, (charOrInt) => {
                         const charCode = typeof charOrInt === "string"
                             ? charOrInt.charCodeAt(0)
                             : charOrInt;
@@ -235,7 +235,7 @@ function analyzeTokenTypes(tokenTypes, options) {
                         }
                     });
                 }
-                else if (isRegExp(currTokType.PATTERN)) {
+                else if (isRegExp.default(currTokType.PATTERN)) {
                     if (currTokType.PATTERN.unicode) {
                         canBeOptimized = false;
                         if (options.ensureOptimizations) {
@@ -251,13 +251,13 @@ function analyzeTokenTypes(tokenTypes, options) {
                         /* istanbul ignore if */
                         // start code will only be empty given an empty regExp or failure of regexp-to-ast library
                         // the first should be a different validation and the second cannot be tested.
-                        if (isEmpty(optimizedCodes)) {
+                        if (isEmpty.default(optimizedCodes)) {
                             // we cannot understand what codes may start possible matches
                             // The optimization correctness requires knowing start codes for ALL patterns.
                             // Not actually sure this is an error, no debug message
                             canBeOptimized = false;
                         }
-                        forEach(optimizedCodes, (code) => {
+                        forEach.default(optimizedCodes, (code) => {
                             addToMapOfArrays(result, code, patternIdxToConfig[idx]);
                         });
                     }
@@ -298,7 +298,7 @@ function validatePatterns(tokenTypes, validModesNames) {
 }
 function validateRegExpPattern(tokenTypes) {
     let errors = [];
-    const withRegExpPatterns = filter(tokenTypes, (currTokType) => isRegExp(currTokType[PATTERN]));
+    const withRegExpPatterns = filter.default(tokenTypes, (currTokType) => isRegExp.default(currTokType[PATTERN]));
     errors = errors.concat(findEndOfInputAnchor(withRegExpPatterns));
     errors = errors.concat(findStartOfInputAnchor(withRegExpPatterns));
     errors = errors.concat(findUnsupportedFlags(withRegExpPatterns));
@@ -307,10 +307,10 @@ function validateRegExpPattern(tokenTypes) {
     return errors;
 }
 function findMissingPatterns(tokenTypes) {
-    const tokenTypesWithMissingPattern = filter(tokenTypes, (currType) => {
-        return !has(currType, PATTERN);
+    const tokenTypesWithMissingPattern = filter.default(tokenTypes, (currType) => {
+        return !has.default(currType, PATTERN);
     });
-    const errors = map(tokenTypesWithMissingPattern, (currType) => {
+    const errors = map.default(tokenTypesWithMissingPattern, (currType) => {
         return {
             message: "Token Type: ->" +
                 currType.name +
@@ -319,18 +319,18 @@ function findMissingPatterns(tokenTypes) {
             tokenTypes: [currType],
         };
     });
-    const valid = difference(tokenTypes, tokenTypesWithMissingPattern);
+    const valid = difference.default(tokenTypes, tokenTypesWithMissingPattern);
     return { errors, valid };
 }
 function findInvalidPatterns(tokenTypes) {
-    const tokenTypesWithInvalidPattern = filter(tokenTypes, (currType) => {
+    const tokenTypesWithInvalidPattern = filter.default(tokenTypes, (currType) => {
         const pattern = currType[PATTERN];
-        return (!isRegExp(pattern) &&
-            !isFunction(pattern) &&
-            !has(pattern, "exec") &&
-            !isString(pattern));
+        return (!isRegExp.default(pattern) &&
+            !isFunction.default(pattern) &&
+            !has.default(pattern, "exec") &&
+            !isString.default(pattern));
     });
-    const errors = map(tokenTypesWithInvalidPattern, (currType) => {
+    const errors = map.default(tokenTypesWithInvalidPattern, (currType) => {
         return {
             message: "Token Type: ->" +
                 currType.name +
@@ -340,7 +340,7 @@ function findInvalidPatterns(tokenTypes) {
             tokenTypes: [currType],
         };
     });
-    const valid = difference(tokenTypes, tokenTypesWithInvalidPattern);
+    const valid = difference.default(tokenTypes, tokenTypesWithInvalidPattern);
     return { errors, valid };
 }
 const end_of_input = /[^\\][$]/;
@@ -354,7 +354,7 @@ function findEndOfInputAnchor(tokenTypes) {
             this.found = true;
         }
     }
-    const invalidRegex = filter(tokenTypes, (currType) => {
+    const invalidRegex = filter.default(tokenTypes, (currType) => {
         const pattern = currType.PATTERN;
         try {
             const regexpAst = reg_exp_parser.getRegExpAst(pattern);
@@ -368,7 +368,7 @@ function findEndOfInputAnchor(tokenTypes) {
             return end_of_input.test(pattern.source);
         }
     });
-    const errors = map(invalidRegex, (currType) => {
+    const errors = map.default(invalidRegex, (currType) => {
         return {
             message: "Unexpected RegExp Anchor Error:\n" +
                 "\tToken Type: ->" +
@@ -383,11 +383,11 @@ function findEndOfInputAnchor(tokenTypes) {
     return errors;
 }
 function findEmptyMatchRegExps(tokenTypes) {
-    const matchesEmptyString = filter(tokenTypes, (currType) => {
+    const matchesEmptyString = filter.default(tokenTypes, (currType) => {
         const pattern = currType.PATTERN;
         return pattern.test("");
     });
-    const errors = map(matchesEmptyString, (currType) => {
+    const errors = map.default(matchesEmptyString, (currType) => {
         return {
             message: "Token Type: ->" +
                 currType.name +
@@ -409,7 +409,7 @@ function findStartOfInputAnchor(tokenTypes) {
             this.found = true;
         }
     }
-    const invalidRegex = filter(tokenTypes, (currType) => {
+    const invalidRegex = filter.default(tokenTypes, (currType) => {
         const pattern = currType.PATTERN;
         try {
             const regexpAst = reg_exp_parser.getRegExpAst(pattern);
@@ -423,7 +423,7 @@ function findStartOfInputAnchor(tokenTypes) {
             return start_of_input.test(pattern.source);
         }
     });
-    const errors = map(invalidRegex, (currType) => {
+    const errors = map.default(invalidRegex, (currType) => {
         return {
             message: "Unexpected RegExp Anchor Error:\n" +
                 "\tToken Type: ->" +
@@ -438,11 +438,11 @@ function findStartOfInputAnchor(tokenTypes) {
     return errors;
 }
 function findUnsupportedFlags(tokenTypes) {
-    const invalidFlags = filter(tokenTypes, (currType) => {
+    const invalidFlags = filter.default(tokenTypes, (currType) => {
         const pattern = currType[PATTERN];
         return pattern instanceof RegExp && (pattern.multiline || pattern.global);
     });
-    const errors = map(invalidFlags, (currType) => {
+    const errors = map.default(invalidFlags, (currType) => {
         return {
             message: "Token Type: ->" +
                 currType.name +
@@ -456,10 +456,10 @@ function findUnsupportedFlags(tokenTypes) {
 // This can only test for identical duplicate RegExps, not semantically equivalent ones.
 function findDuplicatePatterns(tokenTypes) {
     const found = [];
-    let identicalPatterns = map(tokenTypes, (outerType) => {
-        return reduce(tokenTypes, (result, innerType) => {
+    let identicalPatterns = map.default(tokenTypes, (outerType) => {
+        return reduce.default(tokenTypes, (result, innerType) => {
             if (outerType.PATTERN.source === innerType.PATTERN.source &&
-                !includes(found, innerType) &&
+                !includes.default(found, innerType) &&
                 innerType.PATTERN !== lexer_public.Lexer.NA) {
                 // this avoids duplicates in the result, each Token Type may only appear in one "set"
                 // in essence we are creating Equivalence classes on equality relation.
@@ -470,15 +470,15 @@ function findDuplicatePatterns(tokenTypes) {
             return result;
         }, []);
     });
-    identicalPatterns = compact(identicalPatterns);
-    const duplicatePatterns = filter(identicalPatterns, (currIdenticalSet) => {
+    identicalPatterns = compact.default(identicalPatterns);
+    const duplicatePatterns = filter.default(identicalPatterns, (currIdenticalSet) => {
         return currIdenticalSet.length > 1;
     });
-    const errors = map(duplicatePatterns, (setOfIdentical) => {
-        const tokenTypeNames = map(setOfIdentical, (currType) => {
+    const errors = map.default(duplicatePatterns, (setOfIdentical) => {
+        const tokenTypeNames = map.default(setOfIdentical, (currType) => {
             return currType.name;
         });
-        const dupPatternSrc = head(setOfIdentical).PATTERN;
+        const dupPatternSrc = head.default(setOfIdentical).PATTERN;
         return {
             message: `The same RegExp pattern ->${dupPatternSrc}<-` +
                 `has been used in all of the following Token Types: ${tokenTypeNames.join(", ")} <-`,
@@ -489,14 +489,14 @@ function findDuplicatePatterns(tokenTypes) {
     return errors;
 }
 function findInvalidGroupType(tokenTypes) {
-    const invalidTypes = filter(tokenTypes, (clazz) => {
-        if (!has(clazz, "GROUP")) {
+    const invalidTypes = filter.default(tokenTypes, (clazz) => {
+        if (!has.default(clazz, "GROUP")) {
             return false;
         }
         const group = clazz.GROUP;
-        return group !== lexer_public.Lexer.SKIPPED && group !== lexer_public.Lexer.NA && !isString(group);
+        return group !== lexer_public.Lexer.SKIPPED && group !== lexer_public.Lexer.NA && !isString.default(group);
     });
-    const errors = map(invalidTypes, (currType) => {
+    const errors = map.default(invalidTypes, (currType) => {
         return {
             message: "Token Type: ->" +
                 currType.name +
@@ -508,10 +508,10 @@ function findInvalidGroupType(tokenTypes) {
     return errors;
 }
 function findModesThatDoNotExist(tokenTypes, validModes) {
-    const invalidModes = filter(tokenTypes, (clazz) => {
-        return (clazz.PUSH_MODE !== undefined && !includes(validModes, clazz.PUSH_MODE));
+    const invalidModes = filter.default(tokenTypes, (clazz) => {
+        return (clazz.PUSH_MODE !== undefined && !includes.default(validModes, clazz.PUSH_MODE));
     });
-    const errors = map(invalidModes, (tokType) => {
+    const errors = map.default(invalidModes, (tokType) => {
         const msg = `Token Type: ->${tokType.name}<- static 'PUSH_MODE' value cannot refer to a Lexer Mode ->${tokType.PUSH_MODE}<-` +
             `which does not exist`;
         return {
@@ -524,23 +524,23 @@ function findModesThatDoNotExist(tokenTypes, validModes) {
 }
 function findUnreachablePatterns(tokenTypes) {
     const errors = [];
-    const canBeTested = reduce(tokenTypes, (result, tokType, idx) => {
+    const canBeTested = reduce.default(tokenTypes, (result, tokType, idx) => {
         const pattern = tokType.PATTERN;
         if (pattern === lexer_public.Lexer.NA) {
             return result;
         }
         // a more comprehensive validation for all forms of regExps would require
         // deeper regExp analysis capabilities
-        if (isString(pattern)) {
+        if (isString.default(pattern)) {
             result.push({ str: pattern, idx, tokenType: tokType });
         }
-        else if (isRegExp(pattern) && noMetaChar(pattern)) {
+        else if (isRegExp.default(pattern) && noMetaChar(pattern)) {
             result.push({ str: pattern.source, idx, tokenType: tokType });
         }
         return result;
     }, []);
-    forEach(tokenTypes, (tokType, testIdx) => {
-        forEach(canBeTested, ({ str, idx, tokenType }) => {
+    forEach.default(tokenTypes, (tokType, testIdx) => {
+        forEach.default(canBeTested, ({ str, idx, tokenType }) => {
             if (testIdx < idx && testTokenType(str, tokType.PATTERN)) {
                 const msg = `Token: ->${tokenType.name}<- can never be matched.\n` +
                     `Because it appears AFTER the Token Type ->${tokType.name}<-` +
@@ -558,15 +558,15 @@ function findUnreachablePatterns(tokenTypes) {
 }
 function testTokenType(str, pattern) {
     /* istanbul ignore else */
-    if (isRegExp(pattern)) {
+    if (isRegExp.default(pattern)) {
         const regExpArray = pattern.exec(str);
         return regExpArray !== null && regExpArray.index === 0;
     }
-    else if (isFunction(pattern)) {
+    else if (isFunction.default(pattern)) {
         // maintain the API of custom patterns
         return pattern(str, 0, [], {});
     }
-    else if (has(pattern, "exec")) {
+    else if (has.default(pattern, "exec")) {
         // maintain the API of custom patterns
         return pattern.exec(str, 0, [], {});
     }
@@ -594,7 +594,7 @@ function noMetaChar(regExp) {
         "+",
         "{",
     ];
-    return (find(metaChars, (char) => regExp.source.indexOf(char) !== -1) === undefined);
+    return (find.default(metaChars, (char) => regExp.source.indexOf(char) !== -1) === undefined);
 }
 function addStartOfInput(pattern) {
     const flags = pattern.ignoreCase ? "i" : "";
@@ -611,7 +611,7 @@ function addStickyFlag(pattern) {
 function performRuntimeChecks(lexerDefinition, trackLines, lineTerminatorCharacters) {
     const errors = [];
     // some run time checks to help the end users.
-    if (!has(lexerDefinition, DEFAULT_MODE)) {
+    if (!has.default(lexerDefinition, DEFAULT_MODE)) {
         errors.push({
             message: "A MultiMode Lexer cannot be initialized without a <" +
                 DEFAULT_MODE +
@@ -619,7 +619,7 @@ function performRuntimeChecks(lexerDefinition, trackLines, lineTerminatorCharact
             type: lexer_public.LexerDefinitionErrorType.MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE,
         });
     }
-    if (!has(lexerDefinition, MODES)) {
+    if (!has.default(lexerDefinition, MODES)) {
         errors.push({
             message: "A MultiMode Lexer cannot be initialized without a <" +
                 MODES +
@@ -627,32 +627,32 @@ function performRuntimeChecks(lexerDefinition, trackLines, lineTerminatorCharact
             type: lexer_public.LexerDefinitionErrorType.MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY,
         });
     }
-    if (has(lexerDefinition, MODES) &&
-        has(lexerDefinition, DEFAULT_MODE) &&
-        !has(lexerDefinition.modes, lexerDefinition.defaultMode)) {
+    if (has.default(lexerDefinition, MODES) &&
+        has.default(lexerDefinition, DEFAULT_MODE) &&
+        !has.default(lexerDefinition.modes, lexerDefinition.defaultMode)) {
         errors.push({
             message: `A MultiMode Lexer cannot be initialized with a ${DEFAULT_MODE}: <${lexerDefinition.defaultMode}>` +
                 `which does not exist\n`,
             type: lexer_public.LexerDefinitionErrorType.MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST,
         });
     }
-    if (has(lexerDefinition, MODES)) {
-        forEach(lexerDefinition.modes, (currModeValue, currModeName) => {
-            forEach(currModeValue, (currTokType, currIdx) => {
-                if (isUndefined(currTokType)) {
+    if (has.default(lexerDefinition, MODES)) {
+        forEach.default(lexerDefinition.modes, (currModeValue, currModeName) => {
+            forEach.default(currModeValue, (currTokType, currIdx) => {
+                if (isUndefined.default(currTokType)) {
                     errors.push({
                         message: `A Lexer cannot be initialized using an undefined Token Type. Mode:` +
                             `<${currModeName}> at index: <${currIdx}>\n`,
                         type: lexer_public.LexerDefinitionErrorType.LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED,
                     });
                 }
-                else if (has(currTokType, "LONGER_ALT")) {
-                    const longerAlt = isArray(currTokType.LONGER_ALT)
+                else if (has.default(currTokType, "LONGER_ALT")) {
+                    const longerAlt = isArray.default(currTokType.LONGER_ALT)
                         ? currTokType.LONGER_ALT
                         : [currTokType.LONGER_ALT];
-                    forEach(longerAlt, (currLongerAlt) => {
-                        if (!isUndefined(currLongerAlt) &&
-                            !includes(currModeValue, currLongerAlt)) {
+                    forEach.default(longerAlt, (currLongerAlt) => {
+                        if (!isUndefined.default(currLongerAlt) &&
+                            !includes.default(currModeValue, currLongerAlt)) {
                             errors.push({
                                 message: `A MultiMode Lexer cannot be initialized with a longer_alt <${currLongerAlt.name}> on token <${currTokType.name}> outside of mode <${currModeName}>\n`,
                                 type: lexer_public.LexerDefinitionErrorType.MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE,
@@ -668,11 +668,11 @@ function performRuntimeChecks(lexerDefinition, trackLines, lineTerminatorCharact
 function performWarningRuntimeChecks(lexerDefinition, trackLines, lineTerminatorCharacters) {
     const warnings = [];
     let hasAnyLineBreak = false;
-    const allTokenTypes = compact(flatten(values(lexerDefinition.modes)));
-    const concreteTokenTypes = reject(allTokenTypes, (currType) => currType[PATTERN] === lexer_public.Lexer.NA);
+    const allTokenTypes = compact.default(flatten.default(values.default(lexerDefinition.modes)));
+    const concreteTokenTypes = reject.default(allTokenTypes, (currType) => currType[PATTERN] === lexer_public.Lexer.NA);
     const terminatorCharCodes = getCharCodes(lineTerminatorCharacters);
     if (trackLines) {
-        forEach(concreteTokenTypes, (tokType) => {
+        forEach.default(concreteTokenTypes, (tokType) => {
             const currIssue = checkLineBreaksIssues(tokType, terminatorCharCodes);
             if (currIssue !== false) {
                 const message = buildLineBreakIssueMessage(tokType, currIssue);
@@ -685,7 +685,7 @@ function performWarningRuntimeChecks(lexerDefinition, trackLines, lineTerminator
             }
             else {
                 // we don't want to attempt to scan if the user explicitly specified the line_breaks option.
-                if (has(tokType, "LINE_BREAKS")) {
+                if (has.default(tokType, "LINE_BREAKS")) {
                     if (tokType.LINE_BREAKS === true) {
                         hasAnyLineBreak = true;
                     }
@@ -712,11 +712,11 @@ function performWarningRuntimeChecks(lexerDefinition, trackLines, lineTerminator
 }
 function cloneEmptyGroups(emptyGroups) {
     const clonedResult = {};
-    const groupKeys = keys(emptyGroups);
-    forEach(groupKeys, (currKey) => {
+    const groupKeys = keys.default(emptyGroups);
+    forEach.default(groupKeys, (currKey) => {
         const currGroupValue = emptyGroups[currKey];
         /* istanbul ignore else */
-        if (isArray(currGroupValue)) {
+        if (isArray.default(currGroupValue)) {
             clonedResult[currKey] = [];
         }
         else {
@@ -729,18 +729,18 @@ function cloneEmptyGroups(emptyGroups) {
 function isCustomPattern(tokenType) {
     const pattern = tokenType.PATTERN;
     /* istanbul ignore else */
-    if (isRegExp(pattern)) {
+    if (isRegExp.default(pattern)) {
         return false;
     }
-    else if (isFunction(pattern)) {
+    else if (isFunction.default(pattern)) {
         // CustomPatternMatcherFunc - custom patterns do not require any transformations, only wrapping in a RegExp Like object
         return true;
     }
-    else if (has(pattern, "exec")) {
+    else if (has.default(pattern, "exec")) {
         // ICustomPattern
         return true;
     }
-    else if (isString(pattern)) {
+    else if (isString.default(pattern)) {
         return false;
     }
     else {
@@ -748,7 +748,7 @@ function isCustomPattern(tokenType) {
     }
 }
 function isShortPattern(pattern) {
-    if (isString(pattern) && pattern.length === 1) {
+    if (isString.default(pattern) && pattern.length === 1) {
         return pattern.charCodeAt(0);
     }
     else {
@@ -783,14 +783,14 @@ const LineTerminatorOptimizedTester = {
     lastIndex: 0,
 };
 function checkLineBreaksIssues(tokType, lineTerminatorCharCodes) {
-    if (has(tokType, "LINE_BREAKS")) {
+    if (has.default(tokType, "LINE_BREAKS")) {
         // if the user explicitly declared the line_breaks option we will respect their choice
         // and assume it is correct.
         return false;
     }
     else {
         /* istanbul ignore else */
-        if (isRegExp(tokType.PATTERN)) {
+        if (isRegExp.default(tokType.PATTERN)) {
             try {
                 // TODO: why is the casting suddenly needed?
                 reg_exp.canMatchCharCode(lineTerminatorCharCodes, tokType.PATTERN);
@@ -804,7 +804,7 @@ function checkLineBreaksIssues(tokType, lineTerminatorCharCodes) {
             }
             return false;
         }
-        else if (isString(tokType.PATTERN)) {
+        else if (isString.default(tokType.PATTERN)) {
             // string literal patterns can always be analyzed to detect line terminator usage
             return false;
         }
@@ -835,8 +835,8 @@ function buildLineBreakIssueMessage(tokType, details) {
     }
 }
 function getCharCodes(charsOrCodes) {
-    const charCodes = map(charsOrCodes, (numOrString) => {
-        if (isString(numOrString)) {
+    const charCodes = map.default(charsOrCodes, (numOrString) => {
+        if (isString.default(numOrString)) {
             return numOrString.charCodeAt(0);
         }
         else {
@@ -884,7 +884,7 @@ function charCodeToOptimizedIndex(charCode) {
  * TODO: Perhaps it should be lazy initialized only if a charCode > 255 is used.
  */
 function initCharCodeToOptimizedIndexMap() {
-    if (isEmpty(charCodeToOptimizedIdxMap)) {
+    if (isEmpty.default(charCodeToOptimizedIdxMap)) {
         charCodeToOptimizedIdxMap = new Array(65536);
         for (let i = 0; i < 65536; i++) {
             charCodeToOptimizedIdxMap[i] = i > 255 ? 255 + ~~(i / 255) : i;