qidian-vue-ui 1.1.50 → 1.1.51

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

@@ -0,0 +1 @@
+{"version":3,"file":"lexer.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/lexer.js"],"sourcesContent":["import { BaseRegExpVisitor } from \"@chevrotain/regexp-to-ast\";\nimport { Lexer, LexerDefinitionErrorType, } from \"./lexer_public.js\";\nimport { compact, defaults, difference, filter, find, first, flatten, forEach, has, includes, indexOf, isArray, isEmpty, isFunction, isRegExp, isString, isUndefined, keys, map, reduce, reject, values, } from \"lodash-es\";\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 let SUPPORT_STICKY = typeof new RegExp(\"(?:)\").sticky === \"boolean\";\nexport function disableSticky() {\n    SUPPORT_STICKY = false;\n}\nexport function enableSticky() {\n    SUPPORT_STICKY = true;\n}\nexport function analyzeTokenTypes(tokenTypes, options) {\n    options = defaults(options, {\n        useSticky: SUPPORT_STICKY,\n        debug: false,\n        safeMode: false,\n        positionTracking: \"full\",\n        lineTerminatorCharacters: [\"\\r\", \"\\n\"],\n        tracer: (msg, action) => action(),\n    });\n    const tracer = options.tracer;\n    tracer(\"initCharCodeToOptimizedIndexMap\", () => {\n        initCharCodeToOptimizedIndexMap();\n    });\n    let onlyRelevantTypes;\n    tracer(\"Reject Lexer.NA\", () => {\n        onlyRelevantTypes = reject(tokenTypes, (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 = map(onlyRelevantTypes, (currType) => {\n            const currPattern = currType[PATTERN];\n            /* istanbul ignore else */\n            if (isRegExp(currPattern)) {\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                    !includes([\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                    ], regExpSource[1])) {\n                    // escaped meta Characters: /\\+/ /\\[/\n                    // or redundant escaping: /\\a/\n                    // without the escaping \"\\\"\n                    return regExpSource[1];\n                }\n                else {\n                    return options.useSticky\n                        ? addStickyFlag(currPattern)\n                        : addStartOfInput(currPattern);\n                }\n            }\n            else if (isFunction(currPattern)) {\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 options.useSticky\n                        ? addStickyFlag(wrappedRegExp)\n                        : addStartOfInput(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 = map(onlyRelevantTypes, (currType) => currType.tokenTypeIdx);\n        patternIdxToGroup = map(onlyRelevantTypes, (clazz) => {\n            const groupName = clazz.GROUP;\n            /* istanbul ignore next */\n            if (groupName === Lexer.SKIPPED) {\n                return undefined;\n            }\n            else if (isString(groupName)) {\n                return groupName;\n            }\n            else if (isUndefined(groupName)) {\n                return false;\n            }\n            else {\n                throw Error(\"non exhaustive match\");\n            }\n        });\n        patternIdxToLongerAltIdxArr = map(onlyRelevantTypes, (clazz) => {\n            const longerAltType = clazz.LONGER_ALT;\n            if (longerAltType) {\n                const longerAltIdxArr = isArray(longerAltType)\n                    ? map(longerAltType, (type) => indexOf(onlyRelevantTypes, type))\n                    : [indexOf(onlyRelevantTypes, longerAltType)];\n                return longerAltIdxArr;\n            }\n        });\n        patternIdxToPushMode = map(onlyRelevantTypes, (clazz) => clazz.PUSH_MODE);\n        patternIdxToPopMode = map(onlyRelevantTypes, (clazz) => has(clazz, \"POP_MODE\"));\n    });\n    let patternIdxToCanLineTerminator;\n    tracer(\"Line Terminator Handling\", () => {\n        const lineTerminatorCharCodes = getCharCodes(options.lineTerminatorCharacters);\n        patternIdxToCanLineTerminator = map(onlyRelevantTypes, (tokType) => false);\n        if (options.positionTracking !== \"onlyOffset\") {\n            patternIdxToCanLineTerminator = map(onlyRelevantTypes, (tokType) => {\n                if (has(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 = map(onlyRelevantTypes, isCustomPattern);\n        patternIdxToShort = map(allTransformedPatterns, isShortPattern);\n        emptyGroups = reduce(onlyRelevantTypes, (acc, clazz) => {\n            const groupName = clazz.GROUP;\n            if (isString(groupName) && !(groupName === Lexer.SKIPPED)) {\n                acc[groupName] = [];\n            }\n            return acc;\n        }, {});\n        patternIdxToConfig = map(allTransformedPatterns, (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 = reduce(onlyRelevantTypes, (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 (isArray(currTokType.START_CHARS_HINT)) {\n                    let lastOptimizedIdx;\n                    forEach(currTokType.START_CHARS_HINT, (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 (isRegExp(currTokType.PATTERN)) {\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 (isEmpty(optimizedCodes)) {\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                        forEach(optimizedCodes, (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 = filter(tokenTypes, (currTokType) => isRegExp(currTokType[PATTERN]));\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 = filter(tokenTypes, (currType) => {\n        return !has(currType, PATTERN);\n    });\n    const errors = map(tokenTypesWithMissingPattern, (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 = difference(tokenTypes, tokenTypesWithMissingPattern);\n    return { errors, valid };\n}\nexport function findInvalidPatterns(tokenTypes) {\n    const tokenTypesWithInvalidPattern = filter(tokenTypes, (currType) => {\n        const pattern = currType[PATTERN];\n        return (!isRegExp(pattern) &&\n            !isFunction(pattern) &&\n            !has(pattern, \"exec\") &&\n            !isString(pattern));\n    });\n    const errors = map(tokenTypesWithInvalidPattern, (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 = difference(tokenTypes, tokenTypesWithInvalidPattern);\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 = filter(tokenTypes, (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 = map(invalidRegex, (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 = filter(tokenTypes, (currType) => {\n        const pattern = currType.PATTERN;\n        return pattern.test(\"\");\n    });\n    const errors = map(matchesEmptyString, (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 = filter(tokenTypes, (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 = map(invalidRegex, (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 = filter(tokenTypes, (currType) => {\n        const pattern = currType[PATTERN];\n        return pattern instanceof RegExp && (pattern.multiline || pattern.global);\n    });\n    const errors = map(invalidFlags, (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 = map(tokenTypes, (outerType) => {\n        return reduce(tokenTypes, (result, innerType) => {\n            if (outerType.PATTERN.source === innerType.PATTERN.source &&\n                !includes(found, 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 = compact(identicalPatterns);\n    const duplicatePatterns = filter(identicalPatterns, (currIdenticalSet) => {\n        return currIdenticalSet.length > 1;\n    });\n    const errors = map(duplicatePatterns, (setOfIdentical) => {\n        const tokenTypeNames = map(setOfIdentical, (currType) => {\n            return currType.name;\n        });\n        const dupPatternSrc = first(setOfIdentical).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 = filter(tokenTypes, (clazz) => {\n        if (!has(clazz, \"GROUP\")) {\n            return false;\n        }\n        const group = clazz.GROUP;\n        return group !== Lexer.SKIPPED && group !== Lexer.NA && !isString(group);\n    });\n    const errors = map(invalidTypes, (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 = filter(tokenTypes, (clazz) => {\n        return (clazz.PUSH_MODE !== undefined && !includes(validModes, clazz.PUSH_MODE));\n    });\n    const errors = map(invalidModes, (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 = reduce(tokenTypes, (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 (isString(pattern)) {\n            result.push({ str: pattern, idx, tokenType: tokType });\n        }\n        else if (isRegExp(pattern) && noMetaChar(pattern)) {\n            result.push({ str: pattern.source, idx, tokenType: tokType });\n        }\n        return result;\n    }, []);\n    forEach(tokenTypes, (tokType, testIdx) => {\n        forEach(canBeTested, ({ str, idx, tokenType }) => {\n            if (testIdx < idx && testTokenType(str, tokType.PATTERN)) {\n                const msg = `Token: ->${tokenType.name}<- can never be matched.\\n` +\n                    `Because it appears AFTER the Token Type ->${tokType.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: [tokType, tokenType],\n                });\n            }\n        });\n    });\n    return errors;\n}\nfunction testTokenType(str, pattern) {\n    /* istanbul ignore else */\n    if (isRegExp(pattern)) {\n        const regExpArray = pattern.exec(str);\n        return regExpArray !== null && regExpArray.index === 0;\n    }\n    else if (isFunction(pattern)) {\n        // maintain the API of custom patterns\n        return pattern(str, 0, [], {});\n    }\n    else if (has(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 (find(metaChars, (char) => regExp.source.indexOf(char) !== -1) === undefined);\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    // 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 performRuntimeChecks(lexerDefinition, trackLines, lineTerminatorCharacters) {\n    const errors = [];\n    // some run time checks to help the end users.\n    if (!has(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 (!has(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 (has(lexerDefinition, MODES) &&\n        has(lexerDefinition, DEFAULT_MODE) &&\n        !has(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 (has(lexerDefinition, MODES)) {\n        forEach(lexerDefinition.modes, (currModeValue, currModeName) => {\n            forEach(currModeValue, (currTokType, currIdx) => {\n                if (isUndefined(currTokType)) {\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 (has(currTokType, \"LONGER_ALT\")) {\n                    const longerAlt = isArray(currTokType.LONGER_ALT)\n                        ? currTokType.LONGER_ALT\n                        : [currTokType.LONGER_ALT];\n                    forEach(longerAlt, (currLongerAlt) => {\n                        if (!isUndefined(currLongerAlt) &&\n                            !includes(currModeValue, 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 = compact(flatten(values(lexerDefinition.modes)));\n    const concreteTokenTypes = reject(allTokenTypes, (currType) => currType[PATTERN] === Lexer.NA);\n    const terminatorCharCodes = getCharCodes(lineTerminatorCharacters);\n    if (trackLines) {\n        forEach(concreteTokenTypes, (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 (has(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 = keys(emptyGroups);\n    forEach(groupKeys, (currKey) => {\n        const currGroupValue = emptyGroups[currKey];\n        /* istanbul ignore else */\n        if (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 (isRegExp(pattern)) {\n        return false;\n    }\n    else if (isFunction(pattern)) {\n        // CustomPatternMatcherFunc - custom patterns do not require any transformations, only wrapping in a RegExp Like object\n        return true;\n    }\n    else if (has(pattern, \"exec\")) {\n        // ICustomPattern\n        return true;\n    }\n    else if (isString(pattern)) {\n        return false;\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\nexport function isShortPattern(pattern) {\n    if (isString(pattern) && 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 (has(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 (isRegExp(tokType.PATTERN)) {\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 (isString(tokType.PATTERN)) {\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 = map(charsOrCodes, (numOrString) => {\n        if (isString(numOrString)) {\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 (isEmpty(charCodeToOptimizedIdxMap)) {\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"],"names":["first","map"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/lexer_errors_public.mjs

@@ -0,0 +1,12 @@
+const defaultLexerErrorProvider = {
+  buildUnableToPopLexerModeMessage(token) {
+    return `Unable to pop Lexer Mode after encountering Token ->${token.image}<- The Mode Stack is empty`;
+  },
+  buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column) {
+    return `unexpected character: ->${fullText.charAt(startOffset)}<- at offset: ${startOffset}, skipped ${length} characters.`;
+  }
+};
+export {
+  defaultLexerErrorProvider
+};
+//# sourceMappingURL=lexer_errors_public.mjs.map

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/lexer_errors_public.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexer_errors_public.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/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) {\n        return (`unexpected character: ->${fullText.charAt(startOffset)}<- at offset: ${startOffset},` + ` skipped ${length} characters.`);\n    },\n};\n//# sourceMappingURL=lexer_errors_public.js.map"],"names":[],"mappings":"AAAY,MAAC,4BAA4B;AAAA,EACrC,iCAAiC,OAAO;AACpC,WAAO,uDAAuD,MAAM,KAAK;AAAA,EAC7E;AAAA,EACA,iCAAiC,UAAU,aAAa,QAAQ,MAAM,QAAQ;AAC1E,WAAQ,2BAA2B,SAAS,OAAO,WAAW,CAAC,iBAAiB,WAAW,aAAkB,MAAM;AAAA,EACvH;AACJ;","x_google_ignoreList":[0]}