@plumile/ui 0.1.112 → 0.1.114

package/lib/esm/node_modules/chevrotain/lib/src/scan/lexer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lexer.js","names":[],"sources":["../../../../../../../../../node_modules/chevrotain/lib/src/scan/lexer.js"],"sourcesContent":["import { BaseRegExpVisitor } from \"@chevrotain/regexp-to-ast\";\nimport { Lexer, LexerDefinitionErrorType, } from \"./lexer_public.js\";\nimport { PRINT_ERROR } from \"@chevrotain/utils\";\nimport { canMatchCharCode, failedOptimizationPrefixMsg, getOptimizedStartCodesIndices, } from \"./reg_exp.js\";\nimport { getRegExpAst } from \"./reg_exp_parser.js\";\nconst PATTERN = \"PATTERN\";\nexport const DEFAULT_MODE = \"defaultMode\";\nexport const MODES = \"modes\";\nexport function analyzeTokenTypes(tokenTypes, options) {\n    options = Object.assign({ safeMode: false, positionTracking: \"full\", lineTerminatorCharacters: [\"\\r\", \"\\n\"], tracer: (msg, action) => action() }, options);\n    const tracer = options.tracer;\n    tracer(\"initCharCodeToOptimizedIndexMap\", () => {\n        initCharCodeToOptimizedIndexMap();\n    });\n    let onlyRelevantTypes;\n    tracer(\"Reject Lexer.NA\", () => {\n        onlyRelevantTypes = tokenTypes.filter((currType) => {\n            return currType[PATTERN] !== Lexer.NA;\n        });\n    });\n    let hasCustom = false;\n    let allTransformedPatterns;\n    tracer(\"Transform Patterns\", () => {\n        hasCustom = false;\n        allTransformedPatterns = onlyRelevantTypes.map((currType) => {\n            const currPattern = currType[PATTERN];\n            /* istanbul ignore else */\n            if (currPattern instanceof RegExp) {\n                const regExpSource = currPattern.source;\n                if (regExpSource.length === 1 &&\n                    // only these regExp meta characters which can appear in a length one regExp\n                    regExpSource !== \"^\" &&\n                    regExpSource !== \"$\" &&\n                    regExpSource !== \".\" &&\n                    !currPattern.ignoreCase) {\n                    return regExpSource;\n                }\n                else if (regExpSource.length === 2 &&\n                    regExpSource[0] === \"\\\\\" &&\n                    // not a meta character\n                    ![\n                        \"d\",\n                        \"D\",\n                        \"s\",\n                        \"S\",\n                        \"t\",\n                        \"r\",\n                        \"n\",\n                        \"t\",\n                        \"0\",\n                        \"c\",\n                        \"b\",\n                        \"B\",\n                        \"f\",\n                        \"v\",\n                        \"w\",\n                        \"W\",\n                    ].includes(regExpSource[1])) {\n                    // escaped meta Characters: /\\+/ /\\[/\n                    // or redundant escaping: /\\a/\n                    // without the escaping \"\\\"\n                    return regExpSource[1];\n                }\n                else {\n                    return addStickyFlag(currPattern);\n                }\n            }\n            else if (typeof currPattern === \"function\") {\n                hasCustom = true;\n                // CustomPatternMatcherFunc - custom patterns do not require any transformations, only wrapping in a RegExp Like object\n                return { exec: currPattern };\n            }\n            else if (typeof currPattern === \"object\") {\n                hasCustom = true;\n                // ICustomPattern\n                return currPattern;\n            }\n            else if (typeof currPattern === \"string\") {\n                if (currPattern.length === 1) {\n                    return currPattern;\n                }\n                else {\n                    const escapedRegExpString = currPattern.replace(/[\\\\^$.*+?()[\\]{}|]/g, \"\\\\$&\");\n                    const wrappedRegExp = new RegExp(escapedRegExpString);\n                    return addStickyFlag(wrappedRegExp);\n                }\n            }\n            else {\n                throw Error(\"non exhaustive match\");\n            }\n        });\n    });\n    let patternIdxToType;\n    let patternIdxToGroup;\n    let patternIdxToLongerAltIdxArr;\n    let patternIdxToPushMode;\n    let patternIdxToPopMode;\n    tracer(\"misc mapping\", () => {\n        patternIdxToType = onlyRelevantTypes.map((currType) => currType.tokenTypeIdx);\n        patternIdxToGroup = onlyRelevantTypes.map((clazz) => {\n            const groupName = clazz.GROUP;\n            /* istanbul ignore next */\n            if (groupName === Lexer.SKIPPED) {\n                return undefined;\n            }\n            else if (typeof groupName === \"string\") {\n                return groupName;\n            }\n            else if (groupName === undefined) {\n                return false;\n            }\n            else {\n                throw Error(\"non exhaustive match\");\n            }\n        });\n        patternIdxToLongerAltIdxArr = onlyRelevantTypes.map((clazz) => {\n            const longerAltType = clazz.LONGER_ALT;\n            if (longerAltType) {\n                const longerAltIdxArr = Array.isArray(longerAltType)\n                    ? longerAltType.map((type) => onlyRelevantTypes.indexOf(type))\n                    : [onlyRelevantTypes.indexOf(longerAltType)];\n                return longerAltIdxArr;\n            }\n        });\n        patternIdxToPushMode = onlyRelevantTypes.map((clazz) => clazz.PUSH_MODE);\n        patternIdxToPopMode = onlyRelevantTypes.map((clazz) => Object.hasOwn(clazz, \"POP_MODE\"));\n    });\n    let patternIdxToCanLineTerminator;\n    tracer(\"Line Terminator Handling\", () => {\n        const lineTerminatorCharCodes = getCharCodes(options.lineTerminatorCharacters);\n        patternIdxToCanLineTerminator = onlyRelevantTypes.map((tokType) => false);\n        if (options.positionTracking !== \"onlyOffset\") {\n            patternIdxToCanLineTerminator = onlyRelevantTypes.map((tokType) => {\n                if (Object.hasOwn(tokType, \"LINE_BREAKS\")) {\n                    return !!tokType.LINE_BREAKS;\n                }\n                else {\n                    return (checkLineBreaksIssues(tokType, lineTerminatorCharCodes) === false &&\n                        canMatchCharCode(lineTerminatorCharCodes, tokType.PATTERN));\n                }\n            });\n        }\n    });\n    let patternIdxToIsCustom;\n    let patternIdxToShort;\n    let emptyGroups;\n    let patternIdxToConfig;\n    tracer(\"Misc Mapping #2\", () => {\n        patternIdxToIsCustom = onlyRelevantTypes.map(isCustomPattern);\n        patternIdxToShort = allTransformedPatterns.map(isShortPattern);\n        emptyGroups = onlyRelevantTypes.reduce((acc, clazz) => {\n            const groupName = clazz.GROUP;\n            if (typeof groupName === \"string\" && !(groupName === Lexer.SKIPPED)) {\n                acc[groupName] = [];\n            }\n            return acc;\n        }, {});\n        patternIdxToConfig = allTransformedPatterns.map((x, idx) => {\n            return {\n                pattern: allTransformedPatterns[idx],\n                longerAlt: patternIdxToLongerAltIdxArr[idx],\n                canLineTerminator: patternIdxToCanLineTerminator[idx],\n                isCustom: patternIdxToIsCustom[idx],\n                short: patternIdxToShort[idx],\n                group: patternIdxToGroup[idx],\n                push: patternIdxToPushMode[idx],\n                pop: patternIdxToPopMode[idx],\n                tokenTypeIdx: patternIdxToType[idx],\n                tokenType: onlyRelevantTypes[idx],\n            };\n        });\n    });\n    let canBeOptimized = true;\n    let charCodeToPatternIdxToConfig = [];\n    if (!options.safeMode) {\n        tracer(\"First Char Optimization\", () => {\n            charCodeToPatternIdxToConfig = onlyRelevantTypes.reduce((result, currTokType, idx) => {\n                if (typeof currTokType.PATTERN === \"string\") {\n                    const charCode = currTokType.PATTERN.charCodeAt(0);\n                    const optimizedIdx = charCodeToOptimizedIndex(charCode);\n                    addToMapOfArrays(result, optimizedIdx, patternIdxToConfig[idx]);\n                }\n                else if (Array.isArray(currTokType.START_CHARS_HINT)) {\n                    let lastOptimizedIdx;\n                    currTokType.START_CHARS_HINT.forEach((charOrInt) => {\n                        const charCode = typeof charOrInt === \"string\"\n                            ? charOrInt.charCodeAt(0)\n                            : charOrInt;\n                        const currOptimizedIdx = charCodeToOptimizedIndex(charCode);\n                        // Avoid adding the config multiple times\n                        /* istanbul ignore else */\n                        // - Difficult to check this scenario effects as it is only a performance\n                        //   optimization that does not change correctness\n                        if (lastOptimizedIdx !== currOptimizedIdx) {\n                            lastOptimizedIdx = currOptimizedIdx;\n                            addToMapOfArrays(result, currOptimizedIdx, patternIdxToConfig[idx]);\n                        }\n                    });\n                }\n                else if (currTokType.PATTERN instanceof RegExp) {\n                    if (currTokType.PATTERN.unicode) {\n                        canBeOptimized = false;\n                        if (options.ensureOptimizations) {\n                            PRINT_ERROR(`${failedOptimizationPrefixMsg}` +\n                                `\\tUnable to analyze < ${currTokType.PATTERN.toString()} > pattern.\\n` +\n                                \"\\tThe regexp unicode flag is not currently supported by the regexp-to-ast library.\\n\" +\n                                \"\\tThis will disable the lexer's first char optimizations.\\n\" +\n                                \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNICODE_OPTIMIZE\");\n                        }\n                    }\n                    else {\n                        const optimizedCodes = getOptimizedStartCodesIndices(currTokType.PATTERN, options.ensureOptimizations);\n                        /* istanbul ignore if */\n                        // start code will only be empty given an empty regExp or failure of regexp-to-ast library\n                        // the first should be a different validation and the second cannot be tested.\n                        if (optimizedCodes.length === 0) {\n                            // we cannot understand what codes may start possible matches\n                            // The optimization correctness requires knowing start codes for ALL patterns.\n                            // Not actually sure this is an error, no debug message\n                            canBeOptimized = false;\n                        }\n                        optimizedCodes.forEach((code) => {\n                            addToMapOfArrays(result, code, patternIdxToConfig[idx]);\n                        });\n                    }\n                }\n                else {\n                    if (options.ensureOptimizations) {\n                        PRINT_ERROR(`${failedOptimizationPrefixMsg}` +\n                            `\\tTokenType: <${currTokType.name}> is using a custom token pattern without providing <start_chars_hint> parameter.\\n` +\n                            \"\\tThis will disable the lexer's first char optimizations.\\n\" +\n                            \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#CUSTOM_OPTIMIZE\");\n                    }\n                    canBeOptimized = false;\n                }\n                return result;\n            }, []);\n        });\n    }\n    return {\n        emptyGroups: emptyGroups,\n        patternIdxToConfig: patternIdxToConfig,\n        charCodeToPatternIdxToConfig: charCodeToPatternIdxToConfig,\n        hasCustom: hasCustom,\n        canBeOptimized: canBeOptimized,\n    };\n}\nexport function validatePatterns(tokenTypes, validModesNames) {\n    let errors = [];\n    const missingResult = findMissingPatterns(tokenTypes);\n    errors = errors.concat(missingResult.errors);\n    const invalidResult = findInvalidPatterns(missingResult.valid);\n    const validTokenTypes = invalidResult.valid;\n    errors = errors.concat(invalidResult.errors);\n    errors = errors.concat(validateRegExpPattern(validTokenTypes));\n    errors = errors.concat(findInvalidGroupType(validTokenTypes));\n    errors = errors.concat(findModesThatDoNotExist(validTokenTypes, validModesNames));\n    errors = errors.concat(findUnreachablePatterns(validTokenTypes));\n    return errors;\n}\nfunction validateRegExpPattern(tokenTypes) {\n    let errors = [];\n    const withRegExpPatterns = tokenTypes.filter((currTokType) => currTokType[PATTERN] instanceof RegExp);\n    errors = errors.concat(findEndOfInputAnchor(withRegExpPatterns));\n    errors = errors.concat(findStartOfInputAnchor(withRegExpPatterns));\n    errors = errors.concat(findUnsupportedFlags(withRegExpPatterns));\n    errors = errors.concat(findDuplicatePatterns(withRegExpPatterns));\n    errors = errors.concat(findEmptyMatchRegExps(withRegExpPatterns));\n    return errors;\n}\nexport function findMissingPatterns(tokenTypes) {\n    const tokenTypesWithMissingPattern = tokenTypes.filter((currType) => {\n        return !Object.hasOwn(currType, PATTERN);\n    });\n    const errors = tokenTypesWithMissingPattern.map((currType) => {\n        return {\n            message: \"Token Type: ->\" +\n                currType.name +\n                \"<- missing static 'PATTERN' property\",\n            type: LexerDefinitionErrorType.MISSING_PATTERN,\n            tokenTypes: [currType],\n        };\n    });\n    const valid = tokenTypes.filter((x) => !tokenTypesWithMissingPattern.includes(x));\n    return { errors, valid };\n}\nexport function findInvalidPatterns(tokenTypes) {\n    const tokenTypesWithInvalidPattern = tokenTypes.filter((currType) => {\n        const pattern = currType[PATTERN];\n        return (!(pattern instanceof RegExp) &&\n            !(typeof pattern === \"function\") &&\n            !Object.hasOwn(pattern, \"exec\") &&\n            !(typeof pattern === \"string\"));\n    });\n    const errors = tokenTypesWithInvalidPattern.map((currType) => {\n        return {\n            message: \"Token Type: ->\" +\n                currType.name +\n                \"<- static 'PATTERN' can only be a RegExp, a\" +\n                \" Function matching the {CustomPatternMatcherFunc} type or an Object matching the {ICustomPattern} interface.\",\n            type: LexerDefinitionErrorType.INVALID_PATTERN,\n            tokenTypes: [currType],\n        };\n    });\n    const valid = tokenTypes.filter((x) => !tokenTypesWithInvalidPattern.includes(x));\n    return { errors, valid };\n}\nconst end_of_input = /[^\\\\][$]/;\nexport function findEndOfInputAnchor(tokenTypes) {\n    class EndAnchorFinder extends BaseRegExpVisitor {\n        constructor() {\n            super(...arguments);\n            this.found = false;\n        }\n        visitEndAnchor(node) {\n            this.found = true;\n        }\n    }\n    const invalidRegex = tokenTypes.filter((currType) => {\n        const pattern = currType.PATTERN;\n        try {\n            const regexpAst = getRegExpAst(pattern);\n            const endAnchorVisitor = new EndAnchorFinder();\n            endAnchorVisitor.visit(regexpAst);\n            return endAnchorVisitor.found;\n        }\n        catch (e) {\n            // old behavior in case of runtime exceptions with regexp-to-ast.\n            /* istanbul ignore next - cannot ensure an error in regexp-to-ast*/\n            return end_of_input.test(pattern.source);\n        }\n    });\n    const errors = invalidRegex.map((currType) => {\n        return {\n            message: \"Unexpected RegExp Anchor Error:\\n\" +\n                \"\\tToken Type: ->\" +\n                currType.name +\n                \"<- static 'PATTERN' cannot contain end of input anchor '$'\\n\" +\n                \"\\tSee chevrotain.io/docs/guide/resolving_lexer_errors.html#ANCHORS\" +\n                \"\\tfor details.\",\n            type: LexerDefinitionErrorType.EOI_ANCHOR_FOUND,\n            tokenTypes: [currType],\n        };\n    });\n    return errors;\n}\nexport function findEmptyMatchRegExps(tokenTypes) {\n    const matchesEmptyString = tokenTypes.filter((currType) => {\n        const pattern = currType.PATTERN;\n        return pattern.test(\"\");\n    });\n    const errors = matchesEmptyString.map((currType) => {\n        return {\n            message: \"Token Type: ->\" +\n                currType.name +\n                \"<- static 'PATTERN' must not match an empty string\",\n            type: LexerDefinitionErrorType.EMPTY_MATCH_PATTERN,\n            tokenTypes: [currType],\n        };\n    });\n    return errors;\n}\nconst start_of_input = /[^\\\\[][\\^]|^\\^/;\nexport function findStartOfInputAnchor(tokenTypes) {\n    class StartAnchorFinder extends BaseRegExpVisitor {\n        constructor() {\n            super(...arguments);\n            this.found = false;\n        }\n        visitStartAnchor(node) {\n            this.found = true;\n        }\n    }\n    const invalidRegex = tokenTypes.filter((currType) => {\n        const pattern = currType.PATTERN;\n        try {\n            const regexpAst = getRegExpAst(pattern);\n            const startAnchorVisitor = new StartAnchorFinder();\n            startAnchorVisitor.visit(regexpAst);\n            return startAnchorVisitor.found;\n        }\n        catch (e) {\n            // old behavior in case of runtime exceptions with regexp-to-ast.\n            /* istanbul ignore next - cannot ensure an error in regexp-to-ast*/\n            return start_of_input.test(pattern.source);\n        }\n    });\n    const errors = invalidRegex.map((currType) => {\n        return {\n            message: \"Unexpected RegExp Anchor Error:\\n\" +\n                \"\\tToken Type: ->\" +\n                currType.name +\n                \"<- static 'PATTERN' cannot contain start of input anchor '^'\\n\" +\n                \"\\tSee https://chevrotain.io/docs/guide/resolving_lexer_errors.html#ANCHORS\" +\n                \"\\tfor details.\",\n            type: LexerDefinitionErrorType.SOI_ANCHOR_FOUND,\n            tokenTypes: [currType],\n        };\n    });\n    return errors;\n}\nexport function findUnsupportedFlags(tokenTypes) {\n    const invalidFlags = tokenTypes.filter((currType) => {\n        const pattern = currType[PATTERN];\n        return pattern instanceof RegExp && (pattern.multiline || pattern.global);\n    });\n    const errors = invalidFlags.map((currType) => {\n        return {\n            message: \"Token Type: ->\" +\n                currType.name +\n                \"<- static 'PATTERN' may NOT contain global('g') or multiline('m')\",\n            type: LexerDefinitionErrorType.UNSUPPORTED_FLAGS_FOUND,\n            tokenTypes: [currType],\n        };\n    });\n    return errors;\n}\n// This can only test for identical duplicate RegExps, not semantically equivalent ones.\nexport function findDuplicatePatterns(tokenTypes) {\n    const found = [];\n    let identicalPatterns = tokenTypes.map((outerType) => {\n        return tokenTypes.reduce((result, innerType) => {\n            if (outerType.PATTERN.source === innerType.PATTERN.source &&\n                !found.includes(innerType) &&\n                innerType.PATTERN !== Lexer.NA) {\n                // this avoids duplicates in the result, each Token Type may only appear in one \"set\"\n                // in essence we are creating Equivalence classes on equality relation.\n                found.push(innerType);\n                result.push(innerType);\n                return result;\n            }\n            return result;\n        }, []);\n    });\n    identicalPatterns = identicalPatterns.filter(Boolean);\n    const duplicatePatterns = identicalPatterns.filter((currIdenticalSet) => {\n        return currIdenticalSet.length > 1;\n    });\n    const errors = duplicatePatterns.map((setOfIdentical) => {\n        const tokenTypeNames = setOfIdentical.map((currType) => {\n            return currType.name;\n        });\n        const dupPatternSrc = setOfIdentical[0].PATTERN;\n        return {\n            message: `The same RegExp pattern ->${dupPatternSrc}<-` +\n                `has been used in all of the following Token Types: ${tokenTypeNames.join(\", \")} <-`,\n            type: LexerDefinitionErrorType.DUPLICATE_PATTERNS_FOUND,\n            tokenTypes: setOfIdentical,\n        };\n    });\n    return errors;\n}\nexport function findInvalidGroupType(tokenTypes) {\n    const invalidTypes = tokenTypes.filter((clazz) => {\n        if (!Object.hasOwn(clazz, \"GROUP\")) {\n            return false;\n        }\n        const group = clazz.GROUP;\n        return (group !== Lexer.SKIPPED &&\n            group !== Lexer.NA &&\n            !(typeof group === \"string\"));\n    });\n    const errors = invalidTypes.map((currType) => {\n        return {\n            message: \"Token Type: ->\" +\n                currType.name +\n                \"<- static 'GROUP' can only be Lexer.SKIPPED/Lexer.NA/A String\",\n            type: LexerDefinitionErrorType.INVALID_GROUP_TYPE_FOUND,\n            tokenTypes: [currType],\n        };\n    });\n    return errors;\n}\nexport function findModesThatDoNotExist(tokenTypes, validModes) {\n    const invalidModes = tokenTypes.filter((clazz) => {\n        return (clazz.PUSH_MODE !== undefined && !validModes.includes(clazz.PUSH_MODE));\n    });\n    const errors = invalidModes.map((tokType) => {\n        const msg = `Token Type: ->${tokType.name}<- static 'PUSH_MODE' value cannot refer to a Lexer Mode ->${tokType.PUSH_MODE}<-` +\n            `which does not exist`;\n        return {\n            message: msg,\n            type: LexerDefinitionErrorType.PUSH_MODE_DOES_NOT_EXIST,\n            tokenTypes: [tokType],\n        };\n    });\n    return errors;\n}\nexport function findUnreachablePatterns(tokenTypes) {\n    const errors = [];\n    const canBeTested = tokenTypes.reduce((result, tokType, idx) => {\n        const pattern = tokType.PATTERN;\n        if (pattern === Lexer.NA) {\n            return result;\n        }\n        // a more comprehensive validation for all forms of regExps would require\n        // deeper regExp analysis capabilities\n        if (typeof pattern === \"string\") {\n            result.push({ str: pattern, idx, tokenType: tokType });\n        }\n        else if (pattern instanceof RegExp && noMetaChar(pattern)) {\n            result.push({ str: pattern.source, idx, tokenType: tokType });\n        }\n        return result;\n    }, []);\n    tokenTypes.forEach((aTokType, aIdx) => {\n        canBeTested.forEach(({ str: bStr, idx: bIdx, tokenType: bTokType }) => {\n            if (aIdx < bIdx && tryToMatchStrToPattern(bStr, aTokType.PATTERN)) {\n                const msg = `Token: ->${bTokType.name}<- can never be matched.\\n` +\n                    `Because it appears AFTER the Token Type ->${aTokType.name}<-` +\n                    `in the lexer's definition.\\n` +\n                    `See https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNREACHABLE`;\n                errors.push({\n                    message: msg,\n                    type: LexerDefinitionErrorType.UNREACHABLE_PATTERN,\n                    tokenTypes: [aTokType, bTokType],\n                });\n            }\n        });\n    });\n    return errors;\n}\nfunction tryToMatchStrToPattern(str, pattern) {\n    if (pattern instanceof RegExp) {\n        if (usesLookAheadOrBehind(pattern)) {\n            // if lookahead or lookbehind assertions are used\n            // we assume they would be responsible for disambiguating the match\n            // The alternative is to risk false positive unreachable pattern errors.\n            // e.g.: /(?<!a)b/ and /b/ tokens would cause such false positives.\n            return false;\n        }\n        const regExpArray = pattern.exec(str);\n        return regExpArray !== null && regExpArray.index === 0;\n    }\n    else if (typeof pattern === \"function\") {\n        // maintain the API of custom patterns\n        return pattern(str, 0, [], {});\n    }\n    else if (Object.hasOwn(pattern, \"exec\")) {\n        // maintain the API of custom patterns\n        return pattern.exec(str, 0, [], {});\n    }\n    else if (typeof pattern === \"string\") {\n        return pattern === str;\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\nfunction noMetaChar(regExp) {\n    //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp\n    const metaChars = [\n        \".\",\n        \"\\\\\",\n        \"[\",\n        \"]\",\n        \"|\",\n        \"^\",\n        \"$\",\n        \"(\",\n        \")\",\n        \"?\",\n        \"*\",\n        \"+\",\n        \"{\",\n    ];\n    return (metaChars.find((char) => regExp.source.indexOf(char) !== -1) === undefined);\n}\nfunction usesLookAheadOrBehind(regExp) {\n    return /(\\(\\?=)|(\\(\\?!)|(\\(\\?<=)|(\\(\\?<!)/.test(regExp.source);\n}\nexport function addStartOfInput(pattern) {\n    const flags = pattern.ignoreCase ? \"i\" : \"\";\n    // always wrapping in a none capturing group preceded by '^' to make sure matching can only work on start of input.\n    // duplicate/redundant start of input markers have no meaning (/^^^^A/ === /^A/)\n    return new RegExp(`^(?:${pattern.source})`, flags);\n}\nexport function addStickyFlag(pattern) {\n    const flags = pattern.ignoreCase ? \"iy\" : \"y\";\n    return new RegExp(`${pattern.source}`, flags);\n}\nexport function performRuntimeChecks(lexerDefinition, trackLines, lineTerminatorCharacters) {\n    const errors = [];\n    // some run time checks to help the end users.\n    if (!Object.hasOwn(lexerDefinition, DEFAULT_MODE)) {\n        errors.push({\n            message: \"A MultiMode Lexer cannot be initialized without a <\" +\n                DEFAULT_MODE +\n                \"> property in its definition\\n\",\n            type: LexerDefinitionErrorType.MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE,\n        });\n    }\n    if (!Object.hasOwn(lexerDefinition, MODES)) {\n        errors.push({\n            message: \"A MultiMode Lexer cannot be initialized without a <\" +\n                MODES +\n                \"> property in its definition\\n\",\n            type: LexerDefinitionErrorType.MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY,\n        });\n    }\n    if (Object.hasOwn(lexerDefinition, MODES) &&\n        Object.hasOwn(lexerDefinition, DEFAULT_MODE) &&\n        !Object.hasOwn(lexerDefinition.modes, lexerDefinition.defaultMode)) {\n        errors.push({\n            message: `A MultiMode Lexer cannot be initialized with a ${DEFAULT_MODE}: <${lexerDefinition.defaultMode}>` +\n                `which does not exist\\n`,\n            type: LexerDefinitionErrorType.MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST,\n        });\n    }\n    if (Object.hasOwn(lexerDefinition, MODES)) {\n        Object.keys(lexerDefinition.modes).forEach((currModeName) => {\n            const currModeValue = lexerDefinition.modes[currModeName];\n            currModeValue.forEach((currTokType, currIdx) => {\n                if (currTokType === undefined) {\n                    errors.push({\n                        message: `A Lexer cannot be initialized using an undefined Token Type. Mode:` +\n                            `<${currModeName}> at index: <${currIdx}>\\n`,\n                        type: LexerDefinitionErrorType.LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED,\n                    });\n                }\n                else if (Object.hasOwn(currTokType, \"LONGER_ALT\")) {\n                    const longerAlt = Array.isArray(currTokType.LONGER_ALT)\n                        ? currTokType.LONGER_ALT\n                        : [currTokType.LONGER_ALT];\n                    longerAlt.forEach((currLongerAlt) => {\n                        if (currLongerAlt !== undefined &&\n                            !currModeValue.includes(currLongerAlt)) {\n                            errors.push({\n                                message: `A MultiMode Lexer cannot be initialized with a longer_alt <${currLongerAlt.name}> on token <${currTokType.name}> outside of mode <${currModeName}>\\n`,\n                                type: LexerDefinitionErrorType.MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE,\n                            });\n                        }\n                    });\n                }\n            });\n        });\n    }\n    return errors;\n}\nexport function performWarningRuntimeChecks(lexerDefinition, trackLines, lineTerminatorCharacters) {\n    const warnings = [];\n    let hasAnyLineBreak = false;\n    const allTokenTypes = Object.values(lexerDefinition.modes || {})\n        .flat()\n        .filter(Boolean);\n    const concreteTokenTypes = allTokenTypes.filter((currType) => currType[PATTERN] !== Lexer.NA);\n    const terminatorCharCodes = getCharCodes(lineTerminatorCharacters);\n    if (trackLines) {\n        concreteTokenTypes.forEach((tokType) => {\n            const currIssue = checkLineBreaksIssues(tokType, terminatorCharCodes);\n            if (currIssue !== false) {\n                const message = buildLineBreakIssueMessage(tokType, currIssue);\n                const warningDescriptor = {\n                    message,\n                    type: currIssue.issue,\n                    tokenType: tokType,\n                };\n                warnings.push(warningDescriptor);\n            }\n            else {\n                // we don't want to attempt to scan if the user explicitly specified the line_breaks option.\n                if (Object.hasOwn(tokType, \"LINE_BREAKS\")) {\n                    if (tokType.LINE_BREAKS === true) {\n                        hasAnyLineBreak = true;\n                    }\n                }\n                else {\n                    if (canMatchCharCode(terminatorCharCodes, tokType.PATTERN)) {\n                        hasAnyLineBreak = true;\n                    }\n                }\n            }\n        });\n    }\n    if (trackLines && !hasAnyLineBreak) {\n        warnings.push({\n            message: \"Warning: No LINE_BREAKS Found.\\n\" +\n                \"\\tThis Lexer has been defined to track line and column information,\\n\" +\n                \"\\tBut none of the Token Types can be identified as matching a line terminator.\\n\" +\n                \"\\tSee https://chevrotain.io/docs/guide/resolving_lexer_errors.html#LINE_BREAKS \\n\" +\n                \"\\tfor details.\",\n            type: LexerDefinitionErrorType.NO_LINE_BREAKS_FLAGS,\n        });\n    }\n    return warnings;\n}\nexport function cloneEmptyGroups(emptyGroups) {\n    const clonedResult = {};\n    const groupKeys = Object.keys(emptyGroups);\n    groupKeys.forEach((currKey) => {\n        const currGroupValue = emptyGroups[currKey];\n        /* istanbul ignore else */\n        if (Array.isArray(currGroupValue)) {\n            clonedResult[currKey] = [];\n        }\n        else {\n            throw Error(\"non exhaustive match\");\n        }\n    });\n    return clonedResult;\n}\n// TODO: refactor to avoid duplication\nexport function isCustomPattern(tokenType) {\n    const pattern = tokenType.PATTERN;\n    /* istanbul ignore else */\n    if (pattern instanceof RegExp) {\n        return false;\n    }\n    else if (typeof pattern === \"function\") {\n        // CustomPatternMatcherFunc - custom patterns do not require any transformations, only wrapping in a RegExp Like object\n        return true;\n    }\n    else if (Object.hasOwn(pattern, \"exec\")) {\n        // ICustomPattern\n        return true;\n    }\n    else if (typeof pattern === \"string\") {\n        return false;\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\nexport function isShortPattern(pattern) {\n    if (typeof pattern === \"string\" && pattern.length === 1) {\n        return pattern.charCodeAt(0);\n    }\n    else {\n        return false;\n    }\n}\n/**\n * Faster than using a RegExp for default newline detection during lexing.\n */\nexport const LineTerminatorOptimizedTester = {\n    // implements /\\n|\\r\\n?/g.test\n    test: function (text) {\n        const len = text.length;\n        for (let i = this.lastIndex; i < len; i++) {\n            const c = text.charCodeAt(i);\n            if (c === 10) {\n                this.lastIndex = i + 1;\n                return true;\n            }\n            else if (c === 13) {\n                if (text.charCodeAt(i + 1) === 10) {\n                    this.lastIndex = i + 2;\n                }\n                else {\n                    this.lastIndex = i + 1;\n                }\n                return true;\n            }\n        }\n        return false;\n    },\n    lastIndex: 0,\n};\nfunction checkLineBreaksIssues(tokType, lineTerminatorCharCodes) {\n    if (Object.hasOwn(tokType, \"LINE_BREAKS\")) {\n        // if the user explicitly declared the line_breaks option we will respect their choice\n        // and assume it is correct.\n        return false;\n    }\n    else {\n        /* istanbul ignore else */\n        if (tokType.PATTERN instanceof RegExp) {\n            try {\n                // TODO: why is the casting suddenly needed?\n                canMatchCharCode(lineTerminatorCharCodes, tokType.PATTERN);\n            }\n            catch (e) {\n                /* istanbul ignore next - to test this we would have to mock <canMatchCharCode> to throw an error */\n                return {\n                    issue: LexerDefinitionErrorType.IDENTIFY_TERMINATOR,\n                    errMsg: e.message,\n                };\n            }\n            return false;\n        }\n        else if (typeof tokType.PATTERN === \"string\") {\n            // string literal patterns can always be analyzed to detect line terminator usage\n            return false;\n        }\n        else if (isCustomPattern(tokType)) {\n            // custom token types\n            return { issue: LexerDefinitionErrorType.CUSTOM_LINE_BREAK };\n        }\n        else {\n            throw Error(\"non exhaustive match\");\n        }\n    }\n}\nexport function buildLineBreakIssueMessage(tokType, details) {\n    /* istanbul ignore else */\n    if (details.issue === LexerDefinitionErrorType.IDENTIFY_TERMINATOR) {\n        return (\"Warning: unable to identify line terminator usage in pattern.\\n\" +\n            `\\tThe problem is in the <${tokType.name}> Token Type\\n` +\n            `\\t Root cause: ${details.errMsg}.\\n` +\n            \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#IDENTIFY_TERMINATOR\");\n    }\n    else if (details.issue === LexerDefinitionErrorType.CUSTOM_LINE_BREAK) {\n        return (\"Warning: A Custom Token Pattern should specify the <line_breaks> option.\\n\" +\n            `\\tThe problem is in the <${tokType.name}> Token Type\\n` +\n            \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#CUSTOM_LINE_BREAK\");\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\nfunction getCharCodes(charsOrCodes) {\n    const charCodes = charsOrCodes.map((numOrString) => {\n        if (typeof numOrString === \"string\") {\n            return numOrString.charCodeAt(0);\n        }\n        else {\n            return numOrString;\n        }\n    });\n    return charCodes;\n}\nfunction addToMapOfArrays(map, key, value) {\n    if (map[key] === undefined) {\n        map[key] = [value];\n    }\n    else {\n        map[key].push(value);\n    }\n}\nexport const minOptimizationVal = 256;\n/**\n * We are mapping charCode above ASCI (256) into buckets each in the size of 256.\n * This is because ASCI are the most common start chars so each one of those will get its own\n * possible token configs vector.\n *\n * Tokens starting with charCodes \"above\" ASCI are uncommon, so we can \"afford\"\n * to place these into buckets of possible token configs, What we gain from\n * this is avoiding the case of creating an optimization 'charCodeToPatternIdxToConfig'\n * which would contain 10,000+ arrays of small size (e.g unicode Identifiers scenario).\n * Our 'charCodeToPatternIdxToConfig' max size will now be:\n * 256 + (2^16 / 2^8) - 1 === 511\n *\n * note the hack for fast division integer part extraction\n * See: https://stackoverflow.com/a/4228528\n */\nlet charCodeToOptimizedIdxMap = [];\nexport function charCodeToOptimizedIndex(charCode) {\n    return charCode < minOptimizationVal\n        ? charCode\n        : charCodeToOptimizedIdxMap[charCode];\n}\n/**\n * This is a compromise between cold start / hot running performance\n * Creating this array takes ~3ms on a modern machine,\n * But if we perform the computation at runtime as needed the CSS Lexer benchmark\n * performance degrades by ~10%\n *\n * TODO: Perhaps it should be lazy initialized only if a charCode > 255 is used.\n */\nfunction initCharCodeToOptimizedIndexMap() {\n    if (charCodeToOptimizedIdxMap.length === 0) {\n        charCodeToOptimizedIdxMap = new Array(65536);\n        for (let i = 0; i < 65536; i++) {\n            charCodeToOptimizedIdxMap[i] = i > 255 ? 255 + ~~(i / 255) : i;\n        }\n    }\n}\n//# sourceMappingURL=lexer.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/lib/esm/node_modules/chevrotain/lib/src/scan/lexer_errors_public.js

@@ -1,13 +0,0 @@
-//#region ../../node_modules/chevrotain/lib/src/scan/lexer_errors_public.js
-var e = {
-	buildUnableToPopLexerModeMessage(e) {
-		return `Unable to pop Lexer Mode after encountering Token ->${e.image}<- The Mode Stack is empty`;
-	},
-	buildUnexpectedCharactersMessage(e, t, n, r, i, a) {
-		return `unexpected character: ->${e.charAt(t)}<- at offset: ${t}, skipped ${n} characters.`;
-	}
-};
-//#endregion
-export { e as defaultLexerErrorProvider };
-
-//# sourceMappingURL=lexer_errors_public.js.map

package/lib/esm/node_modules/chevrotain/lib/src/scan/lexer_errors_public.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lexer_errors_public.js","names":[],"sources":["../../../../../../../../../node_modules/chevrotain/lib/src/scan/lexer_errors_public.js"],"sourcesContent":["export const defaultLexerErrorProvider = {\n    buildUnableToPopLexerModeMessage(token) {\n        return `Unable to pop Lexer Mode after encountering Token ->${token.image}<- The Mode Stack is empty`;\n    },\n    buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column, mode) {\n        return (`unexpected character: ->${fullText.charAt(startOffset)}<- at offset: ${startOffset},` + ` skipped ${length} characters.`);\n    },\n};\n//# sourceMappingURL=lexer_errors_public.js.map"],"x_google_ignoreList":[0],"mappings":";AAAA,IAAa,IAA4B;CACrC,iCAAiC,GAAO;EACpC,OAAO,uDAAuD,EAAM,MAAM;;CAE9E,iCAAiC,GAAU,GAAa,GAAQ,GAAM,GAAQ,GAAM;EAChF,OAAQ,2BAA2B,EAAS,OAAO,EAAY,CAAC,gBAAgB,EAAY,YAAiB,EAAO;;CAE3H"}

package/lib/esm/node_modules/chevrotain/lib/src/scan/lexer_public.js

@@ -1,257 +0,0 @@
-import { PRINT_WARNING as e } from "../../../../@chevrotain/utils/lib/src/print.js";
-import { timer as t } from "../../../../@chevrotain/utils/lib/src/timer.js";
-import { toFastProperties as n } from "../../../../@chevrotain/utils/lib/src/to-fast-properties.js";
-import { clearRegExpParserCache as r } from "./reg_exp_parser.js";
-import { DEFAULT_MODE as i, LineTerminatorOptimizedTester as a, analyzeTokenTypes as o, charCodeToOptimizedIndex as s, cloneEmptyGroups as c, performRuntimeChecks as l, performWarningRuntimeChecks as u, validatePatterns as d } from "./lexer.js";
-import { augmentTokenTypes as f } from "./tokens.js";
-import { defaultLexerErrorProvider as p } from "./lexer_errors_public.js";
-//#region ../../node_modules/chevrotain/lib/src/scan/lexer_public.js
-var m;
-(function(e) {
-	e[e.MISSING_PATTERN = 0] = "MISSING_PATTERN", e[e.INVALID_PATTERN = 1] = "INVALID_PATTERN", e[e.EOI_ANCHOR_FOUND = 2] = "EOI_ANCHOR_FOUND", e[e.UNSUPPORTED_FLAGS_FOUND = 3] = "UNSUPPORTED_FLAGS_FOUND", e[e.DUPLICATE_PATTERNS_FOUND = 4] = "DUPLICATE_PATTERNS_FOUND", e[e.INVALID_GROUP_TYPE_FOUND = 5] = "INVALID_GROUP_TYPE_FOUND", e[e.PUSH_MODE_DOES_NOT_EXIST = 6] = "PUSH_MODE_DOES_NOT_EXIST", e[e.MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE = 7] = "MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE", e[e.MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY = 8] = "MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY", e[e.MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST = 9] = "MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST", e[e.LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED = 10] = "LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED", e[e.SOI_ANCHOR_FOUND = 11] = "SOI_ANCHOR_FOUND", e[e.EMPTY_MATCH_PATTERN = 12] = "EMPTY_MATCH_PATTERN", e[e.NO_LINE_BREAKS_FLAGS = 13] = "NO_LINE_BREAKS_FLAGS", e[e.UNREACHABLE_PATTERN = 14] = "UNREACHABLE_PATTERN", e[e.IDENTIFY_TERMINATOR = 15] = "IDENTIFY_TERMINATOR", e[e.CUSTOM_LINE_BREAK = 16] = "CUSTOM_LINE_BREAK", e[e.MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE = 17] = "MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE";
-})(m ||= {});
-var h = {
-	deferDefinitionErrorsHandling: !1,
-	positionTracking: "full",
-	lineTerminatorsPattern: /\n|\r\n?/g,
-	lineTerminatorCharacters: ["\n", "\r"],
-	ensureOptimizations: !1,
-	safeMode: !1,
-	errorMessageProvider: p,
-	traceInitPerf: !1,
-	skipValidations: !1,
-	recoveryEnabled: !0
-};
-Object.freeze(h);
-var g = class {
-	constructor(s, c = h) {
-		if (this.lexerDefinition = s, this.lexerDefinitionErrors = [], this.lexerDefinitionWarning = [], this.patternIdxToConfig = {}, this.charCodeToPatternIdxToConfig = {}, this.modes = [], this.emptyGroups = {}, this.trackStartLines = !0, this.trackEndLines = !0, this.hasCustom = !1, this.canModeBeOptimized = {}, this.TRACE_INIT = (e, n) => {
-			if (this.traceInitPerf === !0) {
-				this.traceInitIndent++;
-				let r = Array(this.traceInitIndent + 1).join("	");
-				this.traceInitIndent < this.traceInitMaxIdent && console.log(`${r}--> <${e}>`);
-				let { time: i, value: a } = t(n), o = i > 10 ? console.warn : console.log;
-				return this.traceInitIndent < this.traceInitMaxIdent && o(`${r}<-- <${e}> time: ${i}ms`), this.traceInitIndent--, a;
-			} else return n();
-		}, typeof c == "boolean") throw Error("The second argument to the Lexer constructor is now an ILexerConfig Object.\na boolean 2nd argument is no longer supported");
-		this.config = Object.assign({}, h, c);
-		let p = this.config.traceInitPerf;
-		p === !0 ? (this.traceInitMaxIdent = Infinity, this.traceInitPerf = !0) : typeof p == "number" && (this.traceInitMaxIdent = p, this.traceInitPerf = !0), this.traceInitIndent = -1, this.TRACE_INIT("Lexer Constructor", () => {
-			let t, p = !0;
-			this.TRACE_INIT("Lexer Config handling", () => {
-				if (this.config.lineTerminatorsPattern === h.lineTerminatorsPattern) this.config.lineTerminatorsPattern = a;
-				else if (this.config.lineTerminatorCharacters === h.lineTerminatorCharacters) throw Error("Error: Missing <lineTerminatorCharacters> property on the Lexer config.\n	For details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#MISSING_LINE_TERM_CHARS");
-				if (c.safeMode && c.ensureOptimizations) throw Error("\"safeMode\" and \"ensureOptimizations\" flags are mutually exclusive.");
-				this.trackStartLines = /full|onlyStart/i.test(this.config.positionTracking), this.trackEndLines = /full/i.test(this.config.positionTracking), Array.isArray(s) ? t = {
-					modes: { defaultMode: [...s] },
-					defaultMode: i
-				} : (p = !1, t = Object.assign({}, s));
-			}), this.config.skipValidations === !1 && (this.TRACE_INIT("performRuntimeChecks", () => {
-				this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(l(t, this.trackStartLines, this.config.lineTerminatorCharacters));
-			}), this.TRACE_INIT("performWarningRuntimeChecks", () => {
-				this.lexerDefinitionWarning = this.lexerDefinitionWarning.concat(u(t, this.trackStartLines, this.config.lineTerminatorCharacters));
-			})), t.modes = t.modes ? t.modes : {}, Object.entries(t.modes).forEach(([e, n]) => {
-				t.modes[e] = n.filter((e) => e !== void 0);
-			});
-			let m = Object.keys(t.modes);
-			if (Object.entries(t.modes).forEach(([e, t]) => {
-				this.TRACE_INIT(`Mode: <${e}> processing`, () => {
-					if (this.modes.push(e), this.config.skipValidations === !1 && this.TRACE_INIT("validatePatterns", () => {
-						this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(d(t, m));
-					}), this.lexerDefinitionErrors.length === 0) {
-						f(t);
-						let n;
-						this.TRACE_INIT("analyzeTokenTypes", () => {
-							n = o(t, {
-								lineTerminatorCharacters: this.config.lineTerminatorCharacters,
-								positionTracking: c.positionTracking,
-								ensureOptimizations: c.ensureOptimizations,
-								safeMode: c.safeMode,
-								tracer: this.TRACE_INIT
-							});
-						}), this.patternIdxToConfig[e] = n.patternIdxToConfig, this.charCodeToPatternIdxToConfig[e] = n.charCodeToPatternIdxToConfig, this.emptyGroups = Object.assign({}, this.emptyGroups, n.emptyGroups), this.hasCustom = n.hasCustom || this.hasCustom, this.canModeBeOptimized[e] = n.canBeOptimized;
-					}
-				});
-			}), this.defaultMode = t.defaultMode, this.lexerDefinitionErrors.length > 0 && !this.config.deferDefinitionErrorsHandling) {
-				let e = this.lexerDefinitionErrors.map((e) => e.message).join("-----------------------\n");
-				throw Error("Errors detected in definition of Lexer:\n" + e);
-			}
-			this.lexerDefinitionWarning.forEach((t) => {
-				e(t.message);
-			}), this.TRACE_INIT("Choosing sub-methods implementations", () => {
-				if (p && (this.handleModes = () => {}), this.trackStartLines === !1 && (this.computeNewColumn = (e) => e), this.trackEndLines === !1 && (this.updateTokenEndLineColumnLocation = () => {}), /full/i.test(this.config.positionTracking)) this.createTokenInstance = this.createFullToken;
-				else if (/onlyStart/i.test(this.config.positionTracking)) this.createTokenInstance = this.createStartOnlyToken;
-				else if (/onlyOffset/i.test(this.config.positionTracking)) this.createTokenInstance = this.createOffsetOnlyToken;
-				else throw Error(`Invalid <positionTracking> config option: "${this.config.positionTracking}"`);
-				this.hasCustom ? (this.addToken = this.addTokenUsingPush, this.handlePayload = this.handlePayloadWithCustom) : (this.addToken = this.addTokenUsingMemberAccess, this.handlePayload = this.handlePayloadNoCustom);
-			}), this.TRACE_INIT("Failed Optimization Warnings", () => {
-				let e = Object.entries(this.canModeBeOptimized).reduce((e, [t, n]) => (n === !1 && e.push(t), e), []);
-				if (c.ensureOptimizations && e.length > 0) throw Error(`Lexer Modes: < ${e.join(", ")} > cannot be optimized.\n	 Disable the "ensureOptimizations" lexer config flag to silently ignore this and run the lexer in an un-optimized mode.
-	 Or inspect the console log for details on how to resolve these issues.`);
-			}), this.TRACE_INIT("clearRegExpParserCache", () => {
-				r();
-			}), this.TRACE_INIT("toFastProperties", () => {
-				n(this);
-			});
-		});
-	}
-	tokenize(e, t = this.defaultMode) {
-		if (this.lexerDefinitionErrors.length > 0) {
-			let e = this.lexerDefinitionErrors.map((e) => e.message).join("-----------------------\n");
-			throw Error("Unable to Tokenize because Errors detected in definition of Lexer:\n" + e);
-		}
-		return this.tokenizeInternal(e, t);
-	}
-	tokenizeInternal(e, t) {
-		let n, r, i, a, o, l, u, d, f, p, m, h, g, _, v, y = e, b = y.length, x = 0, S = 0, C = this.hasCustom ? 0 : Math.floor(e.length / 10), w = Array(C), T = [], E = this.trackStartLines ? 1 : void 0, D = this.trackStartLines ? 1 : void 0, O = c(this.emptyGroups), k = this.trackStartLines, A = this.config.lineTerminatorsPattern, j = 0, M = [], N = [], P = [], F = [];
-		Object.freeze(F);
-		let I = !1, L = (e) => {
-			if (P.length === 1 && e.tokenType.PUSH_MODE === void 0) {
-				let t = this.config.errorMessageProvider.buildUnableToPopLexerModeMessage(e);
-				T.push({
-					offset: e.startOffset,
-					line: e.startLine,
-					column: e.startColumn,
-					length: e.image.length,
-					message: t
-				});
-			} else {
-				P.pop();
-				let e = P.at(-1);
-				M = this.patternIdxToConfig[e], N = this.charCodeToPatternIdxToConfig[e], j = M.length;
-				let t = this.canModeBeOptimized[e] && this.config.safeMode === !1;
-				I = !!(N && t);
-			}
-		};
-		function R(e) {
-			P.push(e), N = this.charCodeToPatternIdxToConfig[e], M = this.patternIdxToConfig[e], j = M.length, j = M.length;
-			let t = this.canModeBeOptimized[e] && this.config.safeMode === !1;
-			I = !!(N && t);
-		}
-		R.call(this, t);
-		let z, B = this.config.recoveryEnabled;
-		for (; x < b;) {
-			l = null, f = -1;
-			let t = y.charCodeAt(x), c;
-			if (I) {
-				let e = s(t), n = N[e];
-				c = n === void 0 ? F : n;
-			} else c = M;
-			let C = c.length;
-			for (n = 0; n < C; n++) {
-				z = c[n];
-				let r = z.pattern;
-				u = null;
-				let s = z.short;
-				if (s === !1 ? z.isCustom === !0 ? (v = r.exec(y, x, w, O), v === null ? l = null : (l = v[0], f = l.length, v.payload !== void 0 && (u = v.payload))) : (r.lastIndex = x, f = this.matchLength(r, e, x)) : t === s && (f = 1, l = r), f !== -1) {
-					if (o = z.longerAlt, o !== void 0) {
-						l = e.substring(x, x + f);
-						let t = o.length;
-						for (i = 0; i < t; i++) {
-							let t = M[o[i]], n = t.pattern;
-							if (d = null, t.isCustom === !0 ? (v = n.exec(y, x, w, O), v === null ? a = null : (a = v[0], v.payload !== void 0 && (d = v.payload))) : (n.lastIndex = x, a = this.match(n, e, x)), a && a.length > l.length) {
-								l = a, f = a.length, u = d, z = t;
-								break;
-							}
-						}
-					}
-					break;
-				}
-			}
-			if (f !== -1) {
-				if (p = z.group, p !== void 0 && (l = l === null ? e.substring(x, x + f) : l, m = z.tokenTypeIdx, h = this.createTokenInstance(l, x, m, z.tokenType, E, D, f), this.handlePayload(h, u), p === !1 ? S = this.addToken(w, S, h) : O[p].push(h)), k === !0 && z.canLineTerminator === !0) {
-					let t = 0, n, r;
-					A.lastIndex = 0;
-					do
-						l = l === null ? e.substring(x, x + f) : l, n = A.test(l), n === !0 && (r = A.lastIndex - 1, t++);
-					while (n === !0);
-					t === 0 ? D = this.computeNewColumn(D, f) : (E += t, D = f - r, this.updateTokenEndLineColumnLocation(h, p, r, t, E, D, f));
-				} else D = this.computeNewColumn(D, f);
-				x += f, this.handleModes(z, L, R, h);
-			} else {
-				let t = x, n = E, i = D, a = B === !1;
-				for (; a === !1 && x < b;) for (x++, r = 0; r < j; r++) {
-					let t = M[r], n = t.pattern, i = t.short;
-					if (i === !1 ? t.isCustom === !0 ? a = n.exec(y, x, w, O) !== null : (n.lastIndex = x, a = n.exec(e) !== null) : y.charCodeAt(x) === i && (a = !0), a === !0) break;
-				}
-				if (g = x - t, D = this.computeNewColumn(D, g), _ = this.config.errorMessageProvider.buildUnexpectedCharactersMessage(y, t, g, n, i, P.at(-1)), T.push({
-					offset: t,
-					line: n,
-					column: i,
-					length: g,
-					message: _
-				}), B === !1) break;
-			}
-		}
-		return this.hasCustom || (w.length = S), {
-			tokens: w,
-			groups: O,
-			errors: T
-		};
-	}
-	handleModes(e, t, n, r) {
-		if (e.pop === !0) {
-			let i = e.push;
-			t(r), i !== void 0 && n.call(this, i);
-		} else e.push !== void 0 && n.call(this, e.push);
-	}
-	updateTokenEndLineColumnLocation(e, t, n, r, i, a, o) {
-		let s, c;
-		t !== void 0 && (s = n === o - 1, c = s ? -1 : 0, r === 1 && s === !0 || (e.endLine = i + c, e.endColumn = a - 1 + -c));
-	}
-	computeNewColumn(e, t) {
-		return e + t;
-	}
-	createOffsetOnlyToken(e, t, n, r) {
-		return {
-			image: e,
-			startOffset: t,
-			tokenTypeIdx: n,
-			tokenType: r
-		};
-	}
-	createStartOnlyToken(e, t, n, r, i, a) {
-		return {
-			image: e,
-			startOffset: t,
-			startLine: i,
-			startColumn: a,
-			tokenTypeIdx: n,
-			tokenType: r
-		};
-	}
-	createFullToken(e, t, n, r, i, a, o) {
-		return {
-			image: e,
-			startOffset: t,
-			endOffset: t + o - 1,
-			startLine: i,
-			endLine: i,
-			startColumn: a,
-			endColumn: a + o - 1,
-			tokenTypeIdx: n,
-			tokenType: r
-		};
-	}
-	addTokenUsingPush(e, t, n) {
-		return e.push(n), t;
-	}
-	addTokenUsingMemberAccess(e, t, n) {
-		return e[t] = n, t++, t;
-	}
-	handlePayloadNoCustom(e, t) {}
-	handlePayloadWithCustom(e, t) {
-		t !== null && (e.payload = t);
-	}
-	match(e, t, n) {
-		return e.test(t) === !0 ? t.substring(n, e.lastIndex) : null;
-	}
-	matchLength(e, t, n) {
-		return e.test(t) === !0 ? e.lastIndex - n : -1;
-	}
-};
-g.SKIPPED = "This marks a skipped Token pattern, this means each token identified by it will be consumed and then thrown into oblivion, this can be used to for example to completely ignore whitespace.", g.NA = /NOT_APPLICABLE/;
-//#endregion
-export { g as Lexer, m as LexerDefinitionErrorType };
-
-//# sourceMappingURL=lexer_public.js.map

package/lib/esm/node_modules/chevrotain/lib/src/scan/lexer_public.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lexer_public.js","names":[],"sources":["../../../../../../../../../node_modules/chevrotain/lib/src/scan/lexer_public.js"],"sourcesContent":["import { analyzeTokenTypes, charCodeToOptimizedIndex, cloneEmptyGroups, DEFAULT_MODE, LineTerminatorOptimizedTester, performRuntimeChecks, performWarningRuntimeChecks, validatePatterns, } from \"./lexer.js\";\nimport { PRINT_WARNING, timer, toFastProperties } from \"@chevrotain/utils\";\nimport { augmentTokenTypes } from \"./tokens.js\";\nimport { defaultLexerErrorProvider } from \"./lexer_errors_public.js\";\nimport { clearRegExpParserCache } from \"./reg_exp_parser.js\";\nexport var LexerDefinitionErrorType;\n(function (LexerDefinitionErrorType) {\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"MISSING_PATTERN\"] = 0] = \"MISSING_PATTERN\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"INVALID_PATTERN\"] = 1] = \"INVALID_PATTERN\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"EOI_ANCHOR_FOUND\"] = 2] = \"EOI_ANCHOR_FOUND\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"UNSUPPORTED_FLAGS_FOUND\"] = 3] = \"UNSUPPORTED_FLAGS_FOUND\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"DUPLICATE_PATTERNS_FOUND\"] = 4] = \"DUPLICATE_PATTERNS_FOUND\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"INVALID_GROUP_TYPE_FOUND\"] = 5] = \"INVALID_GROUP_TYPE_FOUND\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"PUSH_MODE_DOES_NOT_EXIST\"] = 6] = \"PUSH_MODE_DOES_NOT_EXIST\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE\"] = 7] = \"MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY\"] = 8] = \"MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST\"] = 9] = \"MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED\"] = 10] = \"LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"SOI_ANCHOR_FOUND\"] = 11] = \"SOI_ANCHOR_FOUND\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"EMPTY_MATCH_PATTERN\"] = 12] = \"EMPTY_MATCH_PATTERN\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"NO_LINE_BREAKS_FLAGS\"] = 13] = \"NO_LINE_BREAKS_FLAGS\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"UNREACHABLE_PATTERN\"] = 14] = \"UNREACHABLE_PATTERN\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"IDENTIFY_TERMINATOR\"] = 15] = \"IDENTIFY_TERMINATOR\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"CUSTOM_LINE_BREAK\"] = 16] = \"CUSTOM_LINE_BREAK\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE\"] = 17] = \"MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE\";\n})(LexerDefinitionErrorType || (LexerDefinitionErrorType = {}));\nconst DEFAULT_LEXER_CONFIG = {\n    deferDefinitionErrorsHandling: false,\n    positionTracking: \"full\",\n    lineTerminatorsPattern: /\\n|\\r\\n?/g,\n    lineTerminatorCharacters: [\"\\n\", \"\\r\"],\n    ensureOptimizations: false,\n    safeMode: false,\n    errorMessageProvider: defaultLexerErrorProvider,\n    traceInitPerf: false,\n    skipValidations: false,\n    recoveryEnabled: true,\n};\nObject.freeze(DEFAULT_LEXER_CONFIG);\nexport class Lexer {\n    constructor(lexerDefinition, config = DEFAULT_LEXER_CONFIG) {\n        this.lexerDefinition = lexerDefinition;\n        this.lexerDefinitionErrors = [];\n        this.lexerDefinitionWarning = [];\n        this.patternIdxToConfig = {};\n        this.charCodeToPatternIdxToConfig = {};\n        this.modes = [];\n        this.emptyGroups = {};\n        this.trackStartLines = true;\n        this.trackEndLines = true;\n        this.hasCustom = false;\n        this.canModeBeOptimized = {};\n        // Duplicated from the parser's perf trace trait to allow future extraction\n        // of the lexer to a separate package.\n        this.TRACE_INIT = (phaseDesc, phaseImpl) => {\n            // No need to optimize this using NOOP pattern because\n            // It is not called in a hot spot...\n            if (this.traceInitPerf === true) {\n                this.traceInitIndent++;\n                const indent = new Array(this.traceInitIndent + 1).join(\"\\t\");\n                if (this.traceInitIndent < this.traceInitMaxIdent) {\n                    console.log(`${indent}--> <${phaseDesc}>`);\n                }\n                const { time, value } = timer(phaseImpl);\n                /* istanbul ignore next - Difficult to reproduce specific performance behavior (>10ms) in tests */\n                const traceMethod = time > 10 ? console.warn : console.log;\n                if (this.traceInitIndent < this.traceInitMaxIdent) {\n                    traceMethod(`${indent}<-- <${phaseDesc}> time: ${time}ms`);\n                }\n                this.traceInitIndent--;\n                return value;\n            }\n            else {\n                return phaseImpl();\n            }\n        };\n        if (typeof config === \"boolean\") {\n            throw Error(\"The second argument to the Lexer constructor is now an ILexerConfig Object.\\n\" +\n                \"a boolean 2nd argument is no longer supported\");\n        }\n        this.config = Object.assign({}, DEFAULT_LEXER_CONFIG, config);\n        const traceInitVal = this.config.traceInitPerf;\n        if (traceInitVal === true) {\n            this.traceInitMaxIdent = Infinity;\n            this.traceInitPerf = true;\n        }\n        else if (typeof traceInitVal === \"number\") {\n            this.traceInitMaxIdent = traceInitVal;\n            this.traceInitPerf = true;\n        }\n        this.traceInitIndent = -1;\n        this.TRACE_INIT(\"Lexer Constructor\", () => {\n            let actualDefinition;\n            let hasOnlySingleMode = true;\n            this.TRACE_INIT(\"Lexer Config handling\", () => {\n                if (this.config.lineTerminatorsPattern ===\n                    DEFAULT_LEXER_CONFIG.lineTerminatorsPattern) {\n                    // optimized built-in implementation for the defaults definition of lineTerminators\n                    this.config.lineTerminatorsPattern = LineTerminatorOptimizedTester;\n                }\n                else {\n                    if (this.config.lineTerminatorCharacters ===\n                        DEFAULT_LEXER_CONFIG.lineTerminatorCharacters) {\n                        throw Error(\"Error: Missing <lineTerminatorCharacters> property on the Lexer config.\\n\" +\n                            \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#MISSING_LINE_TERM_CHARS\");\n                    }\n                }\n                if (config.safeMode && config.ensureOptimizations) {\n                    throw Error('\"safeMode\" and \"ensureOptimizations\" flags are mutually exclusive.');\n                }\n                this.trackStartLines = /full|onlyStart/i.test(this.config.positionTracking);\n                this.trackEndLines = /full/i.test(this.config.positionTracking);\n                // Convert SingleModeLexerDefinition into a IMultiModeLexerDefinition.\n                if (Array.isArray(lexerDefinition)) {\n                    actualDefinition = {\n                        modes: { defaultMode: [...lexerDefinition] },\n                        defaultMode: DEFAULT_MODE,\n                    };\n                }\n                else {\n                    // no conversion needed, input should already be a IMultiModeLexerDefinition\n                    hasOnlySingleMode = false;\n                    actualDefinition = Object.assign({}, lexerDefinition);\n                }\n            });\n            if (this.config.skipValidations === false) {\n                this.TRACE_INIT(\"performRuntimeChecks\", () => {\n                    this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(performRuntimeChecks(actualDefinition, this.trackStartLines, this.config.lineTerminatorCharacters));\n                });\n                this.TRACE_INIT(\"performWarningRuntimeChecks\", () => {\n                    this.lexerDefinitionWarning = this.lexerDefinitionWarning.concat(performWarningRuntimeChecks(actualDefinition, this.trackStartLines, this.config.lineTerminatorCharacters));\n                });\n            }\n            // for extra robustness to avoid throwing a none informative error message\n            actualDefinition.modes = actualDefinition.modes\n                ? actualDefinition.modes\n                : {};\n            // an error of undefined TokenTypes will be detected in \"performRuntimeChecks\" above.\n            // this transformation is to increase robustness in the case of partially invalid lexer definition.\n            Object.entries(actualDefinition.modes).forEach(([currModeName, currModeValue]) => {\n                actualDefinition.modes[currModeName] = currModeValue.filter((currTokType) => currTokType !== undefined);\n            });\n            const allModeNames = Object.keys(actualDefinition.modes);\n            Object.entries(actualDefinition.modes).forEach(([currModName, currModDef]) => {\n                this.TRACE_INIT(`Mode: <${currModName}> processing`, () => {\n                    this.modes.push(currModName);\n                    if (this.config.skipValidations === false) {\n                        this.TRACE_INIT(`validatePatterns`, () => {\n                            this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(validatePatterns(currModDef, allModeNames));\n                        });\n                    }\n                    // If definition errors were encountered, the analysis phase may fail unexpectedly/\n                    // Considering a lexer with definition errors may never be used, there is no point\n                    // to performing the analysis anyhow...\n                    if (this.lexerDefinitionErrors.length === 0) {\n                        augmentTokenTypes(currModDef);\n                        let currAnalyzeResult;\n                        this.TRACE_INIT(`analyzeTokenTypes`, () => {\n                            currAnalyzeResult = analyzeTokenTypes(currModDef, {\n                                lineTerminatorCharacters: this.config.lineTerminatorCharacters,\n                                positionTracking: config.positionTracking,\n                                ensureOptimizations: config.ensureOptimizations,\n                                safeMode: config.safeMode,\n                                tracer: this.TRACE_INIT,\n                            });\n                        });\n                        this.patternIdxToConfig[currModName] =\n                            currAnalyzeResult.patternIdxToConfig;\n                        this.charCodeToPatternIdxToConfig[currModName] =\n                            currAnalyzeResult.charCodeToPatternIdxToConfig;\n                        this.emptyGroups = Object.assign({}, this.emptyGroups, currAnalyzeResult.emptyGroups);\n                        this.hasCustom = currAnalyzeResult.hasCustom || this.hasCustom;\n                        this.canModeBeOptimized[currModName] =\n                            currAnalyzeResult.canBeOptimized;\n                    }\n                });\n            });\n            this.defaultMode = actualDefinition.defaultMode;\n            if (this.lexerDefinitionErrors.length > 0 &&\n                !this.config.deferDefinitionErrorsHandling) {\n                const allErrMessages = this.lexerDefinitionErrors.map((error) => {\n                    return error.message;\n                });\n                const allErrMessagesString = allErrMessages.join(\"-----------------------\\n\");\n                throw new Error(\"Errors detected in definition of Lexer:\\n\" + allErrMessagesString);\n            }\n            // Only print warning if there are no errors, This will avoid pl\n            this.lexerDefinitionWarning.forEach((warningDescriptor) => {\n                PRINT_WARNING(warningDescriptor.message);\n            });\n            this.TRACE_INIT(\"Choosing sub-methods implementations\", () => {\n                // Choose the relevant internal implementations for this specific parser.\n                // These implementations should be in-lined by the JavaScript engine\n                // to provide optimal performance in each scenario.\n                if (hasOnlySingleMode) {\n                    this.handleModes = () => { };\n                }\n                if (this.trackStartLines === false) {\n                    this.computeNewColumn = (x) => x;\n                }\n                if (this.trackEndLines === false) {\n                    this.updateTokenEndLineColumnLocation = () => { };\n                }\n                if (/full/i.test(this.config.positionTracking)) {\n                    this.createTokenInstance = this.createFullToken;\n                }\n                else if (/onlyStart/i.test(this.config.positionTracking)) {\n                    this.createTokenInstance = this.createStartOnlyToken;\n                }\n                else if (/onlyOffset/i.test(this.config.positionTracking)) {\n                    this.createTokenInstance = this.createOffsetOnlyToken;\n                }\n                else {\n                    throw Error(`Invalid <positionTracking> config option: \"${this.config.positionTracking}\"`);\n                }\n                if (this.hasCustom) {\n                    this.addToken = this.addTokenUsingPush;\n                    this.handlePayload = this.handlePayloadWithCustom;\n                }\n                else {\n                    this.addToken = this.addTokenUsingMemberAccess;\n                    this.handlePayload = this.handlePayloadNoCustom;\n                }\n            });\n            this.TRACE_INIT(\"Failed Optimization Warnings\", () => {\n                const unOptimizedModes = Object.entries(this.canModeBeOptimized).reduce((cannotBeOptimized, [modeName, canBeOptimized]) => {\n                    if (canBeOptimized === false) {\n                        cannotBeOptimized.push(modeName);\n                    }\n                    return cannotBeOptimized;\n                }, []);\n                if (config.ensureOptimizations && unOptimizedModes.length > 0) {\n                    throw Error(`Lexer Modes: < ${unOptimizedModes.join(\", \")} > cannot be optimized.\\n` +\n                        '\\t Disable the \"ensureOptimizations\" lexer config flag to silently ignore this and run the lexer in an un-optimized mode.\\n' +\n                        \"\\t Or inspect the console log for details on how to resolve these issues.\");\n                }\n            });\n            this.TRACE_INIT(\"clearRegExpParserCache\", () => {\n                clearRegExpParserCache();\n            });\n            this.TRACE_INIT(\"toFastProperties\", () => {\n                toFastProperties(this);\n            });\n        });\n    }\n    tokenize(text, initialMode = this.defaultMode) {\n        if (this.lexerDefinitionErrors.length > 0) {\n            const allErrMessages = this.lexerDefinitionErrors.map((error) => {\n                return error.message;\n            });\n            const allErrMessagesString = allErrMessages.join(\"-----------------------\\n\");\n            throw new Error(\"Unable to Tokenize because Errors detected in definition of Lexer:\\n\" +\n                allErrMessagesString);\n        }\n        return this.tokenizeInternal(text, initialMode);\n    }\n    // There is quite a bit of duplication between this and \"tokenizeInternalLazy\"\n    // This is intentional due to performance considerations.\n    // this method also used quite a bit of `!` none null assertions because it is too optimized\n    // for `tsc` to always understand it is \"safe\"\n    tokenizeInternal(text, initialMode) {\n        let i, j, k, matchAltImage, longerAlt, matchedImage, payload, altPayload, imageLength, group, tokType, newToken, errLength, msg, match;\n        const orgText = text;\n        const orgLength = orgText.length;\n        let offset = 0;\n        let matchedTokensIndex = 0;\n        // initializing the tokensArray to the \"guessed\" size.\n        // guessing too little will still reduce the number of array re-sizes on pushes.\n        // guessing too large (Tested by guessing x4 too large) may cost a bit more of memory\n        // but would still have a faster runtime by avoiding (All but one) array resizing.\n        const guessedNumberOfTokens = this.hasCustom\n            ? 0 // will break custom token pattern APIs the matchedTokens array will contain undefined elements.\n            : Math.floor(text.length / 10);\n        const matchedTokens = new Array(guessedNumberOfTokens);\n        const errors = [];\n        let line = this.trackStartLines ? 1 : undefined;\n        let column = this.trackStartLines ? 1 : undefined;\n        const groups = cloneEmptyGroups(this.emptyGroups);\n        const trackLines = this.trackStartLines;\n        const lineTerminatorPattern = this.config.lineTerminatorsPattern;\n        let currModePatternsLength = 0;\n        let patternIdxToConfig = [];\n        let currCharCodeToPatternIdxToConfig = [];\n        const modeStack = [];\n        const emptyArray = [];\n        Object.freeze(emptyArray);\n        let isOptimizedMode = false;\n        const pop_mode = (popToken) => {\n            // TODO: perhaps avoid this error in the edge case there is no more input?\n            if (modeStack.length === 1 &&\n                // if we have both a POP_MODE and a PUSH_MODE this is in-fact a \"transition\"\n                // So no error should occur.\n                popToken.tokenType.PUSH_MODE === undefined) {\n                // if we try to pop the last mode there lexer will no longer have ANY mode.\n                // thus the pop is ignored, an error will be created and the lexer will continue parsing in the previous mode.\n                const msg = this.config.errorMessageProvider.buildUnableToPopLexerModeMessage(popToken);\n                errors.push({\n                    offset: popToken.startOffset,\n                    line: popToken.startLine,\n                    column: popToken.startColumn,\n                    length: popToken.image.length,\n                    message: msg,\n                });\n            }\n            else {\n                modeStack.pop();\n                const newMode = modeStack.at(-1);\n                patternIdxToConfig = this.patternIdxToConfig[newMode];\n                currCharCodeToPatternIdxToConfig =\n                    this.charCodeToPatternIdxToConfig[newMode];\n                currModePatternsLength = patternIdxToConfig.length;\n                const modeCanBeOptimized = this.canModeBeOptimized[newMode] && this.config.safeMode === false;\n                if (currCharCodeToPatternIdxToConfig && modeCanBeOptimized) {\n                    isOptimizedMode = true;\n                }\n                else {\n                    isOptimizedMode = false;\n                }\n            }\n        };\n        function push_mode(newMode) {\n            modeStack.push(newMode);\n            currCharCodeToPatternIdxToConfig =\n                this.charCodeToPatternIdxToConfig[newMode];\n            patternIdxToConfig = this.patternIdxToConfig[newMode];\n            currModePatternsLength = patternIdxToConfig.length;\n            currModePatternsLength = patternIdxToConfig.length;\n            const modeCanBeOptimized = this.canModeBeOptimized[newMode] && this.config.safeMode === false;\n            if (currCharCodeToPatternIdxToConfig && modeCanBeOptimized) {\n                isOptimizedMode = true;\n            }\n            else {\n                isOptimizedMode = false;\n            }\n        }\n        // this pattern seems to avoid a V8 de-optimization, although that de-optimization does not\n        // seem to matter performance wise.\n        push_mode.call(this, initialMode);\n        let currConfig;\n        const recoveryEnabled = this.config.recoveryEnabled;\n        while (offset < orgLength) {\n            matchedImage = null;\n            imageLength = -1;\n            const nextCharCode = orgText.charCodeAt(offset);\n            let chosenPatternIdxToConfig;\n            if (isOptimizedMode) {\n                const optimizedCharIdx = charCodeToOptimizedIndex(nextCharCode);\n                const possiblePatterns = currCharCodeToPatternIdxToConfig[optimizedCharIdx];\n                chosenPatternIdxToConfig =\n                    possiblePatterns !== undefined ? possiblePatterns : emptyArray;\n            }\n            else {\n                chosenPatternIdxToConfig = patternIdxToConfig;\n            }\n            const chosenPatternsLength = chosenPatternIdxToConfig.length;\n            for (i = 0; i < chosenPatternsLength; i++) {\n                currConfig = chosenPatternIdxToConfig[i];\n                const currPattern = currConfig.pattern;\n                payload = null;\n                // manually in-lined because > 600 chars won't be in-lined in V8\n                const singleCharCode = currConfig.short;\n                if (singleCharCode !== false) {\n                    if (nextCharCode === singleCharCode) {\n                        // single character string\n                        imageLength = 1;\n                        matchedImage = currPattern;\n                    }\n                }\n                else if (currConfig.isCustom === true) {\n                    match = currPattern.exec(orgText, offset, matchedTokens, groups);\n                    if (match !== null) {\n                        matchedImage = match[0];\n                        imageLength = matchedImage.length;\n                        if (match.payload !== undefined) {\n                            payload = match.payload;\n                        }\n                    }\n                    else {\n                        matchedImage = null;\n                    }\n                }\n                else {\n                    currPattern.lastIndex = offset;\n                    imageLength = this.matchLength(currPattern, text, offset);\n                }\n                // longer alts handling\n                if (imageLength !== -1) {\n                    // even though this pattern matched we must try a another longer alternative.\n                    // this can be used to prioritize keywords over identifiers\n                    longerAlt = currConfig.longerAlt;\n                    if (longerAlt !== undefined) {\n                        matchedImage = text.substring(offset, offset + imageLength);\n                        const longerAltLength = longerAlt.length;\n                        for (k = 0; k < longerAltLength; k++) {\n                            const longerAltConfig = patternIdxToConfig[longerAlt[k]];\n                            const longerAltPattern = longerAltConfig.pattern;\n                            altPayload = null;\n                            // single Char can never be a longer alt so no need to test it.\n                            // manually in-lined because > 600 chars won't be in-lined in V8\n                            if (longerAltConfig.isCustom === true) {\n                                match = longerAltPattern.exec(orgText, offset, matchedTokens, groups);\n                                if (match !== null) {\n                                    matchAltImage = match[0];\n                                    if (match.payload !== undefined) {\n                                        altPayload = match.payload;\n                                    }\n                                }\n                                else {\n                                    matchAltImage = null;\n                                }\n                            }\n                            else {\n                                longerAltPattern.lastIndex = offset;\n                                matchAltImage = this.match(longerAltPattern, text, offset);\n                            }\n                            if (matchAltImage && matchAltImage.length > matchedImage.length) {\n                                matchedImage = matchAltImage;\n                                imageLength = matchAltImage.length;\n                                payload = altPayload;\n                                currConfig = longerAltConfig;\n                                // Exit the loop early after matching one of the longer alternatives\n                                // The first matched alternative takes precedence\n                                break;\n                            }\n                        }\n                    }\n                    break;\n                }\n            }\n            // successful match\n            if (imageLength !== -1) {\n                group = currConfig.group;\n                if (group !== undefined) {\n                    matchedImage =\n                        matchedImage !== null\n                            ? matchedImage // for custom Tokens we will already have the `matchedImage`\n                            : text.substring(offset, offset + imageLength);\n                    tokType = currConfig.tokenTypeIdx;\n                    newToken = this.createTokenInstance(matchedImage, offset, tokType, currConfig.tokenType, line, column, imageLength);\n                    this.handlePayload(newToken, payload);\n                    if (group === false) {\n                        matchedTokensIndex = this.addToken(matchedTokens, matchedTokensIndex, newToken);\n                    }\n                    else {\n                        groups[group].push(newToken);\n                    }\n                }\n                // line terminator handling\n                if (trackLines === true && currConfig.canLineTerminator === true) {\n                    let numOfLTsInMatch = 0;\n                    let foundTerminator;\n                    let lastLTEndOffset;\n                    lineTerminatorPattern.lastIndex = 0;\n                    do {\n                        // only for skipped tokens the matchedImage may be null at this point\n                        matchedImage =\n                            matchedImage !== null\n                                ? matchedImage\n                                : text.substring(offset, offset + imageLength);\n                        foundTerminator = lineTerminatorPattern.test(matchedImage);\n                        if (foundTerminator === true) {\n                            lastLTEndOffset = lineTerminatorPattern.lastIndex - 1;\n                            numOfLTsInMatch++;\n                        }\n                    } while (foundTerminator === true);\n                    if (numOfLTsInMatch !== 0) {\n                        line = line + numOfLTsInMatch;\n                        column = imageLength - lastLTEndOffset;\n                        this.updateTokenEndLineColumnLocation(newToken, group, lastLTEndOffset, numOfLTsInMatch, line, column, imageLength);\n                    }\n                    else {\n                        column = this.computeNewColumn(column, imageLength);\n                    }\n                }\n                else {\n                    column = this.computeNewColumn(column, imageLength);\n                }\n                offset = offset + imageLength;\n                // will be NOOP if no modes present\n                this.handleModes(currConfig, pop_mode, push_mode, newToken);\n            }\n            else {\n                // error recovery, drop characters until we identify a valid token's start point\n                const errorStartOffset = offset;\n                const errorLine = line;\n                const errorColumn = column;\n                let foundResyncPoint = recoveryEnabled === false;\n                while (foundResyncPoint === false && offset < orgLength) {\n                    offset++;\n                    for (j = 0; j < currModePatternsLength; j++) {\n                        const currConfig = patternIdxToConfig[j];\n                        const currPattern = currConfig.pattern;\n                        // manually in-lined because > 600 chars won't be in-lined in V8\n                        const singleCharCode = currConfig.short;\n                        if (singleCharCode !== false) {\n                            if (orgText.charCodeAt(offset) === singleCharCode) {\n                                // single character string\n                                foundResyncPoint = true;\n                            }\n                        }\n                        else if (currConfig.isCustom === true) {\n                            foundResyncPoint =\n                                currPattern.exec(orgText, offset, matchedTokens, groups) !== null;\n                        }\n                        else {\n                            currPattern.lastIndex = offset;\n                            foundResyncPoint = currPattern.exec(text) !== null;\n                        }\n                        if (foundResyncPoint === true) {\n                            break;\n                        }\n                    }\n                }\n                errLength = offset - errorStartOffset;\n                column = this.computeNewColumn(column, errLength);\n                // at this point we either re-synced or reached the end of the input text\n                msg = this.config.errorMessageProvider.buildUnexpectedCharactersMessage(orgText, errorStartOffset, errLength, errorLine, errorColumn, modeStack.at(-1));\n                errors.push({\n                    offset: errorStartOffset,\n                    line: errorLine,\n                    column: errorColumn,\n                    length: errLength,\n                    message: msg,\n                });\n                if (recoveryEnabled === false) {\n                    break;\n                }\n            }\n        }\n        // if we do have custom patterns which push directly into the\n        // TODO: custom tokens should not push directly??\n        if (!this.hasCustom) {\n            // if we guessed a too large size for the tokens array this will shrink it to the right size.\n            matchedTokens.length = matchedTokensIndex;\n        }\n        return {\n            tokens: matchedTokens,\n            groups: groups,\n            errors: errors,\n        };\n    }\n    handleModes(config, pop_mode, push_mode, newToken) {\n        if (config.pop === true) {\n            // need to save the PUSH_MODE property as if the mode is popped\n            // patternIdxToPopMode is updated to reflect the new mode after popping the stack\n            const pushMode = config.push;\n            pop_mode(newToken);\n            if (pushMode !== undefined) {\n                push_mode.call(this, pushMode);\n            }\n        }\n        else if (config.push !== undefined) {\n            push_mode.call(this, config.push);\n        }\n    }\n    // TODO: decrease this under 600 characters? inspect stripping comments option in TSC compiler\n    updateTokenEndLineColumnLocation(newToken, group, lastLTIdx, numOfLTsInMatch, line, column, imageLength) {\n        let lastCharIsLT, fixForEndingInLT;\n        if (group !== undefined) {\n            // a none skipped multi line Token, need to update endLine/endColumn\n            lastCharIsLT = lastLTIdx === imageLength - 1;\n            fixForEndingInLT = lastCharIsLT ? -1 : 0;\n            if (!(numOfLTsInMatch === 1 && lastCharIsLT === true)) {\n                // if a token ends in a LT that last LT only affects the line numbering of following Tokens\n                newToken.endLine = line + fixForEndingInLT;\n                // the last LT in a token does not affect the endColumn either as the [columnStart ... columnEnd)\n                // inclusive to exclusive range.\n                newToken.endColumn = column - 1 + -fixForEndingInLT;\n            }\n            // else single LT in the last character of a token, no need to modify the endLine/EndColumn\n        }\n    }\n    computeNewColumn(oldColumn, imageLength) {\n        return oldColumn + imageLength;\n    }\n    createOffsetOnlyToken(image, startOffset, tokenTypeIdx, tokenType) {\n        return {\n            image,\n            startOffset,\n            tokenTypeIdx,\n            tokenType,\n        };\n    }\n    createStartOnlyToken(image, startOffset, tokenTypeIdx, tokenType, startLine, startColumn) {\n        return {\n            image,\n            startOffset,\n            startLine,\n            startColumn,\n            tokenTypeIdx,\n            tokenType,\n        };\n    }\n    createFullToken(image, startOffset, tokenTypeIdx, tokenType, startLine, startColumn, imageLength) {\n        return {\n            image,\n            startOffset,\n            endOffset: startOffset + imageLength - 1,\n            startLine,\n            endLine: startLine,\n            startColumn,\n            endColumn: startColumn + imageLength - 1,\n            tokenTypeIdx,\n            tokenType,\n        };\n    }\n    addTokenUsingPush(tokenVector, index, tokenToAdd) {\n        tokenVector.push(tokenToAdd);\n        return index;\n    }\n    addTokenUsingMemberAccess(tokenVector, index, tokenToAdd) {\n        tokenVector[index] = tokenToAdd;\n        index++;\n        return index;\n    }\n    handlePayloadNoCustom(token, payload) { }\n    handlePayloadWithCustom(token, payload) {\n        if (payload !== null) {\n            token.payload = payload;\n        }\n    }\n    match(pattern, text, offset) {\n        const found = pattern.test(text);\n        if (found === true) {\n            return text.substring(offset, pattern.lastIndex);\n        }\n        return null;\n    }\n    matchLength(pattern, text, offset) {\n        const found = pattern.test(text);\n        if (found === true) {\n            return pattern.lastIndex - offset;\n        }\n        return -1;\n    }\n}\nLexer.SKIPPED = \"This marks a skipped Token pattern, this means each token identified by it will \" +\n    \"be consumed and then thrown into oblivion, this can be used to for example to completely ignore whitespace.\";\nLexer.NA = /NOT_APPLICABLE/;\n//# sourceMappingURL=lexer_public.js.map"],"x_google_ignoreList":[0],"mappings":"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"}