npm - qidian-vue-ui - Versions diffs - 1.1.50 → 1.1.51 - Mend

qidian-vue-ui 1.1.50 → 1.1.51

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2239) hide show

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/lexer_public.mjs.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"lexer_public.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/lexer_public.js"],"sourcesContent":["import { analyzeTokenTypes, charCodeToOptimizedIndex, cloneEmptyGroups, DEFAULT_MODE, LineTerminatorOptimizedTester, performRuntimeChecks, performWarningRuntimeChecks, SUPPORT_STICKY, validatePatterns, } from \"./lexer.js\";\nimport { assign, clone, forEach, identity, isArray, isEmpty, isUndefined, keys, last, map, noop, reduce, reject, } from \"lodash-es\";\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 // todo: defaults func?\n this.config = 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 (isArray(lexerDefinition)) {\n actualDefinition = {\n modes: { defaultMode: clone(lexerDefinition) },\n defaultMode: DEFAULT_MODE,\n };\n }\n else {\n // no conversion needed, input should already be a IMultiModeLexerDefinition\n hasOnlySingleMode = false;\n actualDefinition = clone(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 an 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 forEach(actualDefinition.modes, (currModeValue, currModeName) => {\n actualDefinition.modes[currModeName] = reject(currModeValue, (currTokType) => isUndefined(currTokType));\n });\n const allModeNames = keys(actualDefinition.modes);\n forEach(actualDefinition.modes, (currModDef, currModName) => {\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 (isEmpty(this.lexerDefinitionErrors)) {\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 = 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 (!isEmpty(this.lexerDefinitionErrors) &&\n !this.config.deferDefinitionErrorsHandling) {\n const allErrMessages = map(this.lexerDefinitionErrors, (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 forEach(this.lexerDefinitionWarning, (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 (SUPPORT_STICKY) {\n this.chopInput = identity;\n this.match = this.matchWithTest;\n }\n else {\n this.updateLastIndex = noop;\n this.match = this.matchWithExec;\n }\n if (hasOnlySingleMode) {\n this.handleModes = noop;\n }\n if (this.trackStartLines === false) {\n this.computeNewColumn = identity;\n }\n if (this.trackEndLines === false) {\n this.updateTokenEndLineColumnLocation = noop;\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 = reduce(this.canModeBeOptimized, (cannotBeOptimized, canBeOptimized, modeName) => {\n if (canBeOptimized === false) {\n cannotBeOptimized.push(modeName);\n }\n return cannotBeOptimized;\n }, []);\n if (config.ensureOptimizations && !isEmpty(unOptimizedModes)) {\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 (!isEmpty(this.lexerDefinitionErrors)) {\n const allErrMessages = map(this.lexerDefinitionErrors, (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, droppedChar, 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 getPossiblePatterns;\n function getPossiblePatternsSlow() {\n return patternIdxToConfig;\n }\n function getPossiblePatternsOptimized(charCode) {\n const optimizedCharIdx = charCodeToOptimizedIndex(charCode);\n const possiblePatterns = currCharCodeToPatternIdxToConfig[optimizedCharIdx];\n if (possiblePatterns === undefined) {\n return emptyArray;\n }\n else {\n return possiblePatterns;\n }\n }\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 = last(modeStack);\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 getPossiblePatterns = getPossiblePatternsOptimized;\n }\n else {\n getPossiblePatterns = getPossiblePatternsSlow;\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 getPossiblePatterns = getPossiblePatternsOptimized;\n }\n else {\n getPossiblePatterns = getPossiblePatternsSlow;\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 const nextCharCode = orgText.charCodeAt(offset);\n const chosenPatternIdxToConfig = getPossiblePatterns(nextCharCode);\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 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 if (match.payload !== undefined) {\n payload = match.payload;\n }\n }\n else {\n matchedImage = null;\n }\n }\n else {\n this.updateLastIndex(currPattern, offset);\n matchedImage = this.match(currPattern, text, offset);\n }\n if (matchedImage !== null) {\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 // TODO: micro optimize, avoid extra prop access\n // by saving/linking longerAlt on the original config?\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 this.updateLastIndex(longerAltPattern, offset);\n matchAltImage = this.match(longerAltPattern, text, offset);\n }\n if (matchAltImage && matchAltImage.length > matchedImage.length) {\n matchedImage = matchAltImage;\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 (matchedImage !== null) {\n imageLength = matchedImage.length;\n group = currConfig.group;\n if (group !== undefined) {\n tokType = currConfig.tokenTypeIdx;\n // TODO: \"offset + imageLength\" and the new column may be computed twice in case of \"full\" location information inside\n // createFullToken method\n newToken = this.createTokenInstance(matchedImage, offset, tokType, currConfig.tokenType, line, column, imageLength);\n this.handlePayload(newToken, payload);\n // TODO: optimize NOOP in case there are no special groups?\n if (group === false) {\n matchedTokensIndex = this.addToken(matchedTokens, matchedTokensIndex, newToken);\n }\n else {\n groups[group].push(newToken);\n }\n }\n text = this.chopInput(text, imageLength);\n offset = offset + imageLength;\n // TODO: with newlines the column may be assigned twice\n column = this.computeNewColumn(column, imageLength);\n if (trackLines === true && currConfig.canLineTerminator === true) {\n let numOfLTsInMatch = 0;\n let foundTerminator;\n let lastLTEndOffset;\n lineTerminatorPattern.lastIndex = 0;\n do {\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 }\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 // Identity Func (when sticky flag is enabled)\n text = this.chopInput(text, 1);\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 this.updateLastIndex(currPattern, 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);\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 chopInput(text, length) {\n return text.substring(length);\n }\n updateLastIndex(regExp, newLastIndex) {\n regExp.lastIndex = newLastIndex;\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 matchWithTest(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 matchWithExec(pattern, text) {\n const regExpArray = pattern.exec(text);\n return regExpArray !== null ? regExpArray[0] : null;\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"],"names":["LexerDefinitionErrorType","msg","currConfig"],"mappings":";;;;;;;;;;;;;;;;;;;;AAMU,IAAC;AAAA,CACV,SAAUA,2BAA0B;AACjC,EAAAA,0BAAyBA,0BAAyB,iBAAiB,IAAI,CAAC,IAAI;AAC5E,EAAAA,0BAAyBA,0BAAyB,iBAAiB,IAAI,CAAC,IAAI;AAC5E,EAAAA,0BAAyBA,0BAAyB,kBAAkB,IAAI,CAAC,IAAI;AAC7E,EAAAA,0BAAyBA,0BAAyB,yBAAyB,IAAI,CAAC,IAAI;AACpF,EAAAA,0BAAyBA,0BAAyB,0BAA0B,IAAI,CAAC,IAAI;AACrF,EAAAA,0BAAyBA,0BAAyB,0BAA0B,IAAI,CAAC,IAAI;AACrF,EAAAA,0BAAyBA,0BAAyB,0BAA0B,IAAI,CAAC,IAAI;AACrF,EAAAA,0BAAyBA,0BAAyB,uCAAuC,IAAI,CAAC,IAAI;AAClG,EAAAA,0BAAyBA,0BAAyB,yCAAyC,IAAI,CAAC,IAAI;AACpG,EAAAA,0BAAyBA,0BAAyB,oDAAoD,IAAI,CAAC,IAAI;AAC/G,EAAAA,0BAAyBA,0BAAyB,2CAA2C,IAAI,EAAE,IAAI;AACvG,EAAAA,0BAAyBA,0BAAyB,kBAAkB,IAAI,EAAE,IAAI;AAC9E,EAAAA,0BAAyBA,0BAAyB,qBAAqB,IAAI,EAAE,IAAI;AACjF,EAAAA,0BAAyBA,0BAAyB,sBAAsB,IAAI,EAAE,IAAI;AAClF,EAAAA,0BAAyBA,0BAAyB,qBAAqB,IAAI,EAAE,IAAI;AACjF,EAAAA,0BAAyBA,0BAAyB,qBAAqB,IAAI,EAAE,IAAI;AACjF,EAAAA,0BAAyBA,0BAAyB,mBAAmB,IAAI,EAAE,IAAI;AAC/E,EAAAA,0BAAyBA,0BAAyB,iDAAiD,IAAI,EAAE,IAAI;AACjH,GAAG,6BAA6B,2BAA2B,CAAA,EAAG;AAC9D,MAAM,uBAAuB;AAAA,EACzB,+BAA+B;AAAA,EAC/B,kBAAkB;AAAA,EAClB,wBAAwB;AAAA,EACxB,0BAA0B,CAAC,MAAM,IAAI;AAAA,EACrC,qBAAqB;AAAA,EACrB,UAAU;AAAA,EACV,sBAAsB;AAAA,EACtB,eAAe;AAAA,EACf,iBAAiB;AAAA,EACjB,iBAAiB;AACrB;AACA,OAAO,OAAO,oBAAoB;AAC3B,MAAM,MAAM;AAAA,EACf,YAAY,iBAAiB,SAAS,sBAAsB;AACxD,SAAK,kBAAkB;AACvB,SAAK,wBAAwB,CAAA;AAC7B,SAAK,yBAAyB,CAAA;AAC9B,SAAK,qBAAqB,CAAA;AAC1B,SAAK,+BAA+B,CAAA;AACpC,SAAK,QAAQ,CAAA;AACb,SAAK,cAAc,CAAA;AACnB,SAAK,kBAAkB;AACvB,SAAK,gBAAgB;AACrB,SAAK,YAAY;AACjB,SAAK,qBAAqB,CAAA;AAG1B,SAAK,aAAa,CAAC,WAAW,cAAc;AAGxC,UAAI,KAAK,kBAAkB,MAAM;AAC7B,aAAK;AACL,cAAM,SAAS,IAAI,MAAM,KAAK,kBAAkB,CAAC,EAAE,KAAK,GAAI;AAC5D,YAAI,KAAK,kBAAkB,KAAK,mBAAmB;AAC/C,kBAAQ,IAAI,GAAG,MAAM,QAAQ,SAAS,GAAG;AAAA,QAC7C;AACA,cAAM,EAAE,MAAM,UAAU,MAAM,SAAS;AAEvC,cAAM,cAAc,OAAO,KAAK,QAAQ,OAAO,QAAQ;AACvD,YAAI,KAAK,kBAAkB,KAAK,mBAAmB;AAC/C,sBAAY,GAAG,MAAM,QAAQ,SAAS,WAAW,IAAI,IAAI;AAAA,QAC7D;AACA,aAAK;AACL,eAAO;AAAA,MACX,OACK;AACD,eAAO,UAAS;AAAA,MACpB;AAAA,IACJ;AACA,QAAI,OAAO,WAAW,WAAW;AAC7B,YAAM,MAAM,4HACuC;AAAA,IACvD;AAEA,SAAK,SAAS,OAAO,CAAA,GAAI,sBAAsB,MAAM;AACrD,UAAM,eAAe,KAAK,OAAO;AACjC,QAAI,iBAAiB,MAAM;AACvB,WAAK,oBAAoB;AACzB,WAAK,gBAAgB;AAAA,IACzB,WACS,OAAO,iBAAiB,UAAU;AACvC,WAAK,oBAAoB;AACzB,WAAK,gBAAgB;AAAA,IACzB;AACA,SAAK,kBAAkB;AACvB,SAAK,WAAW,qBAAqB,MAAM;AACvC,UAAI;AACJ,UAAI,oBAAoB;AACxB,WAAK,WAAW,yBAAyB,MAAM;AAC3C,YAAI,KAAK,OAAO,2BACZ,qBAAqB,wBAAwB;AAE7C,eAAK,OAAO,yBAAyB;AAAA,QACzC,OACK;AACD,cAAI,KAAK,OAAO,6BACZ,qBAAqB,0BAA0B;AAC/C,kBAAM,MAAM,iLACiG;AAAA,UACjH;AAAA,QACJ;AACA,YAAI,OAAO,YAAY,OAAO,qBAAqB;AAC/C,gBAAM,MAAM,oEAAoE;AAAA,QACpF;AACA,aAAK,kBAAkB,kBAAkB,KAAK,KAAK,OAAO,gBAAgB;AAC1E,aAAK,gBAAgB,QAAQ,KAAK,KAAK,OAAO,gBAAgB;AAE9D,YAAI,QAAQ,eAAe,GAAG;AAC1B,6BAAmB;AAAA,YACf,OAAO,EAAE,aAAa,MAAM,eAAe,EAAC;AAAA,YAC5C,aAAa;AAAA,UACrC;AAAA,QACgB,OACK;AAED,8BAAoB;AACpB,6BAAmB,MAAM,eAAe;AAAA,QAC5C;AAAA,MACJ,CAAC;AACD,UAAI,KAAK,OAAO,oBAAoB,OAAO;AACvC,aAAK,WAAW,wBAAwB,MAAM;AAC1C,eAAK,wBAAwB,KAAK,sBAAsB,OAAO,qBAAqB,kBAAkB,KAAK,iBAAiB,KAAK,OAAO,wBAAwB,CAAC;AAAA,QACrK,CAAC;AACD,aAAK,WAAW,+BAA+B,MAAM;AACjD,eAAK,yBAAyB,KAAK,uBAAuB,OAAO,4BAA4B,kBAAkB,KAAK,iBAAiB,KAAK,OAAO,wBAAwB,CAAC;AAAA,QAC9K,CAAC;AAAA,MACL;AAEA,uBAAiB,QAAQ,iBAAiB,QACpC,iBAAiB,QACjB,CAAA;AAGN,cAAQ,iBAAiB,OAAO,CAAC,eAAe,iBAAiB;AAC7D,yBAAiB,MAAM,YAAY,IAAI,OAAO,eAAe,CAAC,gBAAgB,YAAY,WAAW,CAAC;AAAA,MAC1G,CAAC;AACD,YAAM,eAAe,KAAK,iBAAiB,KAAK;AAChD,cAAQ,iBAAiB,OAAO,CAAC,YAAY,gBAAgB;AACzD,aAAK,WAAW,UAAU,WAAW,gBAAgB,MAAM;AACvD,eAAK,MAAM,KAAK,WAAW;AAC3B,cAAI,KAAK,OAAO,oBAAoB,OAAO;AACvC,iBAAK,WAAW,oBAAoB,MAAM;AACtC,mBAAK,wBAAwB,KAAK,sBAAsB,OAAO,iBAAiB,YAAY,YAAY,CAAC;AAAA,YAC7G,CAAC;AAAA,UACL;AAIA,cAAI,QAAQ,KAAK,qBAAqB,GAAG;AACrC,8BAAkB,UAAU;AAC5B,gBAAI;AACJ,iBAAK,WAAW,qBAAqB,MAAM;AACvC,kCAAoB,kBAAkB,YAAY;AAAA,gBAC9C,0BAA0B,KAAK,OAAO;AAAA,gBACtC,kBAAkB,OAAO;AAAA,gBACzB,qBAAqB,OAAO;AAAA,gBAC5B,UAAU,OAAO;AAAA,gBACjB,QAAQ,KAAK;AAAA,cAC7C,CAA6B;AAAA,YACL,CAAC;AACD,iBAAK,mBAAmB,WAAW,IAC/B,kBAAkB;AACtB,iBAAK,6BAA6B,WAAW,IACzC,kBAAkB;AACtB,iBAAK,cAAc,OAAO,CAAA,GAAI,KAAK,aAAa,kBAAkB,WAAW;AAC7E,iBAAK,YAAY,kBAAkB,aAAa,KAAK;AACrD,iBAAK,mBAAmB,WAAW,IAC/B,kBAAkB;AAAA,UAC1B;AAAA,QACJ,CAAC;AAAA,MACL,CAAC;AACD,WAAK,cAAc,iBAAiB;AACpC,UAAI,CAAC,QAAQ,KAAK,qBAAqB,KACnC,CAAC,KAAK,OAAO,+BAA+B;AAC5C,cAAM,iBAAiB,IAAI,KAAK,uBAAuB,CAAC,UAAU;AAC9D,iBAAO,MAAM;AAAA,QACjB,CAAC;AACD,cAAM,uBAAuB,eAAe,KAAK,2BAA2B;AAC5E,cAAM,IAAI,MAAM,8CAA8C,oBAAoB;AAAA,MACtF;AAEA,cAAQ,KAAK,wBAAwB,CAAC,sBAAsB;AACxD,sBAAc,kBAAkB,OAAO;AAAA,MAC3C,CAAC;AACD,WAAK,WAAW,wCAAwC,MAAM;AAI1D,YAAI,gBAAgB;AAChB,eAAK,YAAY;AACjB,eAAK,QAAQ,KAAK;AAAA,QACtB,OACK;AACD,eAAK,kBAAkB;AACvB,eAAK,QAAQ,KAAK;AAAA,QACtB;AACA,YAAI,mBAAmB;AACnB,eAAK,cAAc;AAAA,QACvB;AACA,YAAI,KAAK,oBAAoB,OAAO;AAChC,eAAK,mBAAmB;AAAA,QAC5B;AACA,YAAI,KAAK,kBAAkB,OAAO;AAC9B,eAAK,mCAAmC;AAAA,QAC5C;AACA,YAAI,QAAQ,KAAK,KAAK,OAAO,gBAAgB,GAAG;AAC5C,eAAK,sBAAsB,KAAK;AAAA,QACpC,WACS,aAAa,KAAK,KAAK,OAAO,gBAAgB,GAAG;AACtD,eAAK,sBAAsB,KAAK;AAAA,QACpC,WACS,cAAc,KAAK,KAAK,OAAO,gBAAgB,GAAG;AACvD,eAAK,sBAAsB,KAAK;AAAA,QACpC,OACK;AACD,gBAAM,MAAM,8CAA8C,KAAK,OAAO,gBAAgB,GAAG;AAAA,QAC7F;AACA,YAAI,KAAK,WAAW;AAChB,eAAK,WAAW,KAAK;AACrB,eAAK,gBAAgB,KAAK;AAAA,QAC9B,OACK;AACD,eAAK,WAAW,KAAK;AACrB,eAAK,gBAAgB,KAAK;AAAA,QAC9B;AAAA,MACJ,CAAC;AACD,WAAK,WAAW,gCAAgC,MAAM;AAClD,cAAM,mBAAmB,OAAO,KAAK,oBAAoB,CAAC,mBAAmB,gBAAgB,aAAa;AACtG,cAAI,mBAAmB,OAAO;AAC1B,8BAAkB,KAAK,QAAQ;AAAA,UACnC;AACA,iBAAO;AAAA,QACX,GAAG,CAAA,CAAE;AACL,YAAI,OAAO,uBAAuB,CAAC,QAAQ,gBAAgB,GAAG;AAC1D,gBAAM,MAAM,kBAAkB,iBAAiB,KAAK,IAAI,CAAC;AAAA;AAAA,yEAEsB;AAAA,QACnF;AAAA,MACJ,CAAC;AACD,WAAK,WAAW,0BAA0B,MAAM;AAC5C,+BAAsB;AAAA,MAC1B,CAAC;AACD,WAAK,WAAW,oBAAoB,MAAM;AACtC,yBAAiB,IAAI;AAAA,MACzB,CAAC;AAAA,IACL,CAAC;AAAA,EACL;AAAA,EACA,SAAS,MAAM,cAAc,KAAK,aAAa;AAC3C,QAAI,CAAC,QAAQ,KAAK,qBAAqB,GAAG;AACtC,YAAM,iBAAiB,IAAI,KAAK,uBAAuB,CAAC,UAAU;AAC9D,eAAO,MAAM;AAAA,MACjB,CAAC;AACD,YAAM,uBAAuB,eAAe,KAAK,2BAA2B;AAC5E,YAAM,IAAI,MAAM,yEACZ,oBAAoB;AAAA,IAC5B;AACA,WAAO,KAAK,iBAAiB,MAAM,WAAW;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,iBAAiB,MAAM,aAAa;AAC7B,QAAC,GAAG,GAAG,GAAG,eAAe,WAAW,cAAc,SAAS,YAAY,aAAa,OAAO,SAAS,UAAU,WAAwB,KAAK;AAC9I,UAAM,UAAU;AAChB,UAAM,YAAY,QAAQ;AAC1B,QAAI,SAAS;AACb,QAAI,qBAAqB;AAKzB,UAAM,wBAAwB,KAAK,YAC7B,IACA,KAAK,MAAM,KAAK,SAAS,EAAE;AACjC,UAAM,gBAAgB,IAAI,MAAM,qBAAqB;AACrD,UAAM,SAAS,CAAA;AACf,QAAI,OAAO,KAAK,kBAAkB,IAAI;AACtC,QAAI,SAAS,KAAK,kBAAkB,IAAI;AACxC,UAAM,SAAS,iBAAiB,KAAK,WAAW;AAChD,UAAM,aAAa,KAAK;AACxB,UAAM,wBAAwB,KAAK,OAAO;AAC1C,QAAI,yBAAyB;AAC7B,QAAI,qBAAqB,CAAA;AACzB,QAAI,mCAAmC,CAAA;AACvC,UAAM,YAAY,CAAA;AAClB,UAAM,aAAa,CAAA;AACnB,WAAO,OAAO,UAAU;AACxB,QAAI;AACJ,aAAS,0BAA0B;AAC/B,aAAO;AAAA,IACX;AACA,aAAS,6BAA6B,UAAU;AAC5C,YAAM,mBAAmB,yBAAyB,QAAQ;AAC1D,YAAM,mBAAmB,iCAAiC,gBAAgB;AAC1E,UAAI,qBAAqB,QAAW;AAChC,eAAO;AAAA,MACX,OACK;AACD,eAAO;AAAA,MACX;AAAA,IACJ;AACA,UAAM,WAAW,CAAC,aAAa;AAE3B,UAAI,UAAU,WAAW;AAAA;AAAA,MAGrB,SAAS,UAAU,cAAc,QAAW;AAG5C,cAAMC,OAAM,KAAK,OAAO,qBAAqB,iCAAiC,QAAQ;AACtF,eAAO,KAAK;AAAA,UACR,QAAQ,SAAS;AAAA,UACjB,MAAM,SAAS;AAAA,UACf,QAAQ,SAAS;AAAA,UACjB,QAAQ,SAAS,MAAM;AAAA,UACvB,SAASA;AAAA,QAC7B,CAAiB;AAAA,MACL,OACK;AACD,kBAAU,IAAG;AACb,cAAM,UAAU,KAAK,SAAS;AAC9B,6BAAqB,KAAK,mBAAmB,OAAO;AACpD,2CACI,KAAK,6BAA6B,OAAO;AAC7C,iCAAyB,mBAAmB;AAC5C,cAAM,qBAAqB,KAAK,mBAAmB,OAAO,KAAK,KAAK,OAAO,aAAa;AACxF,YAAI,oCAAoC,oBAAoB;AACxD,gCAAsB;AAAA,QAC1B,OACK;AACD,gCAAsB;AAAA,QAC1B;AAAA,MACJ;AAAA,IACJ;AACA,aAAS,UAAU,SAAS;AACxB,gBAAU,KAAK,OAAO;AACtB,yCACI,KAAK,6BAA6B,OAAO;AAC7C,2BAAqB,KAAK,mBAAmB,OAAO;AACpD,+BAAyB,mBAAmB;AAC5C,+BAAyB,mBAAmB;AAC5C,YAAM,qBAAqB,KAAK,mBAAmB,OAAO,KAAK,KAAK,OAAO,aAAa;AACxF,UAAI,oCAAoC,oBAAoB;AACxD,8BAAsB;AAAA,MAC1B,OACK;AACD,8BAAsB;AAAA,MAC1B;AAAA,IACJ;AAGA,cAAU,KAAK,MAAM,WAAW;AAChC,QAAI;AACJ,UAAM,kBAAkB,KAAK,OAAO;AACpC,WAAO,SAAS,WAAW;AACvB,qBAAe;AACf,YAAM,eAAe,QAAQ,WAAW,MAAM;AAC9C,YAAM,2BAA2B,oBAAoB,YAAY;AACjE,YAAM,uBAAuB,yBAAyB;AACtD,WAAK,IAAI,GAAG,IAAI,sBAAsB,KAAK;AACvC,qBAAa,yBAAyB,CAAC;AACvC,cAAM,cAAc,WAAW;AAC/B,kBAAU;AAEV,cAAM,iBAAiB,WAAW;AAClC,YAAI,mBAAmB,OAAO;AAC1B,cAAI,iBAAiB,gBAAgB;AAEjC,2BAAe;AAAA,UACnB;AAAA,QACJ,WACS,WAAW,aAAa,MAAM;AACnC,kBAAQ,YAAY,KAAK,SAAS,QAAQ,eAAe,MAAM;AAC/D,cAAI,UAAU,MAAM;AAChB,2BAAe,MAAM,CAAC;AACtB,gBAAI,MAAM,YAAY,QAAW;AAC7B,wBAAU,MAAM;AAAA,YACpB;AAAA,UACJ,OACK;AACD,2BAAe;AAAA,UACnB;AAAA,QACJ,OACK;AACD,eAAK,gBAAgB,aAAa,MAAM;AACxC,yBAAe,KAAK,MAAM,aAAa,MAAM,MAAM;AAAA,QACvD;AACA,YAAI,iBAAiB,MAAM;AAGvB,sBAAY,WAAW;AACvB,cAAI,cAAc,QAAW;AAGzB,kBAAM,kBAAkB,UAAU;AAClC,iBAAK,IAAI,GAAG,IAAI,iBAAiB,KAAK;AAClC,oBAAM,kBAAkB,mBAAmB,UAAU,CAAC,CAAC;AACvD,oBAAM,mBAAmB,gBAAgB;AACzC,2BAAa;AAGb,kBAAI,gBAAgB,aAAa,MAAM;AACnC,wBAAQ,iBAAiB,KAAK,SAAS,QAAQ,eAAe,MAAM;AACpE,oBAAI,UAAU,MAAM;AAChB,kCAAgB,MAAM,CAAC;AACvB,sBAAI,MAAM,YAAY,QAAW;AAC7B,iCAAa,MAAM;AAAA,kBACvB;AAAA,gBACJ,OACK;AACD,kCAAgB;AAAA,gBACpB;AAAA,cACJ,OACK;AACD,qBAAK,gBAAgB,kBAAkB,MAAM;AAC7C,gCAAgB,KAAK,MAAM,kBAAkB,MAAM,MAAM;AAAA,cAC7D;AACA,kBAAI,iBAAiB,cAAc,SAAS,aAAa,QAAQ;AAC7D,+BAAe;AACf,0BAAU;AACV,6BAAa;AAGb;AAAA,cACJ;AAAA,YACJ;AAAA,UACJ;AACA;AAAA,QACJ;AAAA,MACJ;AAEA,UAAI,iBAAiB,MAAM;AACvB,sBAAc,aAAa;AAC3B,gBAAQ,WAAW;AACnB,YAAI,UAAU,QAAW;AACrB,oBAAU,WAAW;AAGrB,qBAAW,KAAK,oBAAoB,cAAc,QAAQ,SAAS,WAAW,WAAW,MAAM,QAAQ,WAAW;AAClH,eAAK,cAAc,UAAU,OAAO;AAEpC,cAAI,UAAU,OAAO;AACjB,iCAAqB,KAAK,SAAS,eAAe,oBAAoB,QAAQ;AAAA,UAClF,OACK;AACD,mBAAO,KAAK,EAAE,KAAK,QAAQ;AAAA,UAC/B;AAAA,QACJ;AACA,eAAO,KAAK,UAAU,MAAM,WAAW;AACvC,iBAAS,SAAS;AAElB,iBAAS,KAAK,iBAAiB,QAAQ,WAAW;AAClD,YAAI,eAAe,QAAQ,WAAW,sBAAsB,MAAM;AAC9D,cAAI,kBAAkB;AACtB,cAAI;AACJ,cAAI;AACJ,gCAAsB,YAAY;AAClC,aAAG;AACC,8BAAkB,sBAAsB,KAAK,YAAY;AACzD,gBAAI,oBAAoB,MAAM;AAC1B,gCAAkB,sBAAsB,YAAY;AACpD;AAAA,YACJ;AAAA,UACJ,SAAS,oBAAoB;AAC7B,cAAI,oBAAoB,GAAG;AACvB,mBAAO,OAAO;AACd,qBAAS,cAAc;AACvB,iBAAK,iCAAiC,UAAU,OAAO,iBAAiB,iBAAiB,MAAM,QAAQ,WAAW;AAAA,UACtH;AAAA,QACJ;AAEA,aAAK,YAAY,YAAY,UAAU,WAAW,QAAQ;AAAA,MAC9D,OACK;AAED,cAAM,mBAAmB;AACzB,cAAM,YAAY;AAClB,cAAM,cAAc;AACpB,YAAI,mBAAmB,oBAAoB;AAC3C,eAAO,qBAAqB,SAAS,SAAS,WAAW;AAErD,iBAAO,KAAK,UAAU,MAAM,CAAC;AAC7B;AACA,eAAK,IAAI,GAAG,IAAI,wBAAwB,KAAK;AACzC,kBAAMC,cAAa,mBAAmB,CAAC;AACvC,kBAAM,cAAcA,YAAW;AAE/B,kBAAM,iBAAiBA,YAAW;AAClC,gBAAI,mBAAmB,OAAO;AAC1B,kBAAI,QAAQ,WAAW,MAAM,MAAM,gBAAgB;AAE/C,mCAAmB;AAAA,cACvB;AAAA,YACJ,WACSA,YAAW,aAAa,MAAM;AACnC,iCACI,YAAY,KAAK,SAAS,QAAQ,eAAe,MAAM,MAAM;AAAA,YACrE,OACK;AACD,mBAAK,gBAAgB,aAAa,MAAM;AACxC,iCAAmB,YAAY,KAAK,IAAI,MAAM;AAAA,YAClD;AACA,gBAAI,qBAAqB,MAAM;AAC3B;AAAA,YACJ;AAAA,UACJ;AAAA,QACJ;AACA,oBAAY,SAAS;AACrB,iBAAS,KAAK,iBAAiB,QAAQ,SAAS;AAEhD,cAAM,KAAK,OAAO,qBAAqB,iCAAiC,SAAS,kBAAkB,WAAW,WAAW,WAAW;AACpI,eAAO,KAAK;AAAA,UACR,QAAQ;AAAA,UACR,MAAM;AAAA,UACN,QAAQ;AAAA,UACR,QAAQ;AAAA,UACR,SAAS;AAAA,QAC7B,CAAiB;AACD,YAAI,oBAAoB,OAAO;AAC3B;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ;AAGA,QAAI,CAAC,KAAK,WAAW;AAEjB,oBAAc,SAAS;AAAA,IAC3B;AACA,WAAO;AAAA,MACH,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,IACZ;AAAA,EACI;AAAA,EACA,YAAY,QAAQ,UAAU,WAAW,UAAU;AAC/C,QAAI,OAAO,QAAQ,MAAM;AAGrB,YAAM,WAAW,OAAO;AACxB,eAAS,QAAQ;AACjB,UAAI,aAAa,QAAW;AACxB,kBAAU,KAAK,MAAM,QAAQ;AAAA,MACjC;AAAA,IACJ,WACS,OAAO,SAAS,QAAW;AAChC,gBAAU,KAAK,MAAM,OAAO,IAAI;AAAA,IACpC;AAAA,EACJ;AAAA,EACA,UAAU,MAAM,QAAQ;AACpB,WAAO,KAAK,UAAU,MAAM;AAAA,EAChC;AAAA,EACA,gBAAgB,QAAQ,cAAc;AAClC,WAAO,YAAY;AAAA,EACvB;AAAA;AAAA,EAEA,iCAAiC,UAAU,OAAO,WAAW,iBAAiB,MAAM,QAAQ,aAAa;AACrG,QAAI,cAAc;AAClB,QAAI,UAAU,QAAW;AAErB,qBAAe,cAAc,cAAc;AAC3C,yBAAmB,eAAe,KAAK;AACvC,UAAI,EAAE,oBAAoB,KAAK,iBAAiB,OAAO;AAEnD,iBAAS,UAAU,OAAO;AAG1B,iBAAS,YAAY,SAAS,IAAI,CAAC;AAAA,MACvC;AAAA,IAEJ;AAAA,EACJ;AAAA,EACA,iBAAiB,WAAW,aAAa;AACrC,WAAO,YAAY;AAAA,EACvB;AAAA,EACA,sBAAsB,OAAO,aAAa,cAAc,WAAW;AAC/D,WAAO;AAAA,MACH;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACZ;AAAA,EACI;AAAA,EACA,qBAAqB,OAAO,aAAa,cAAc,WAAW,WAAW,aAAa;AACtF,WAAO;AAAA,MACH;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACZ;AAAA,EACI;AAAA,EACA,gBAAgB,OAAO,aAAa,cAAc,WAAW,WAAW,aAAa,aAAa;AAC9F,WAAO;AAAA,MACH;AAAA,MACA;AAAA,MACA,WAAW,cAAc,cAAc;AAAA,MACvC;AAAA,MACA,SAAS;AAAA,MACT;AAAA,MACA,WAAW,cAAc,cAAc;AAAA,MACvC;AAAA,MACA;AAAA,IACZ;AAAA,EACI;AAAA,EACA,kBAAkB,aAAa,OAAO,YAAY;AAC9C,gBAAY,KAAK,UAAU;AAC3B,WAAO;AAAA,EACX;AAAA,EACA,0BAA0B,aAAa,OAAO,YAAY;AACtD,gBAAY,KAAK,IAAI;AACrB;AACA,WAAO;AAAA,EACX;AAAA,EACA,sBAAsB,OAAO,SAAS;AAAA,EAAE;AAAA,EACxC,wBAAwB,OAAO,SAAS;AACpC,QAAI,YAAY,MAAM;AAClB,YAAM,UAAU;AAAA,IACpB;AAAA,EACJ;AAAA,EACA,cAAc,SAAS,MAAM,QAAQ;AACjC,UAAM,QAAQ,QAAQ,KAAK,IAAI;AAC/B,QAAI,UAAU,MAAM;AAChB,aAAO,KAAK,UAAU,QAAQ,QAAQ,SAAS;AAAA,IACnD;AACA,WAAO;AAAA,EACX;AAAA,EACA,cAAc,SAAS,MAAM;AACzB,UAAM,cAAc,QAAQ,KAAK,IAAI;AACrC,WAAO,gBAAgB,OAAO,YAAY,CAAC,IAAI;AAAA,EACnD;AACJ;AACA,MAAM,UAAU;AAEhB,MAAM,KAAK;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/reg_exp.mjs ADDED Viewed

@@ -0,0 +1,220 @@
+import "../../../../../../@chevrotain_regexp-to-ast@11.0.3/node_modules/@chevrotain/regexp-to-ast/lib/src/character-classes.mjs";
+import { BaseRegExpVisitor } from "../../../../../../@chevrotain_regexp-to-ast@11.0.3/node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.mjs";
+import { PRINT_WARNING, PRINT_ERROR } from "../../../../../../@chevrotain_utils@11.0.3/node_modules/@chevrotain/utils/lib/src/print.mjs";
+import { getRegExpAst } from "./reg_exp_parser.mjs";
+import { minOptimizationVal, charCodeToOptimizedIndex } from "./lexer.mjs";
+import find from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/find.mjs";
+import includes from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/includes.mjs";
+import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+import values from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/values.mjs";
+import every from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/every.mjs";
+import isArray from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isArray.mjs";
+const complementErrorMessage = "Complement Sets are not supported for first char optimization";
+const failedOptimizationPrefixMsg = 'Unable to use "first char" lexer optimizations:\n';
+function getOptimizedStartCodesIndices(regExp, ensureOptimizations = false) {
+  try {
+    const ast = getRegExpAst(regExp);
+    const firstChars = firstCharOptimizedIndices(ast.value, {}, ast.flags.ignoreCase);
+    return firstChars;
+  } catch (e) {
+    if (e.message === complementErrorMessage) {
+      if (ensureOptimizations) {
+        PRINT_WARNING(`${failedOptimizationPrefixMsg}	Unable to optimize: < ${regExp.toString()} >
+	Complement Sets cannot be automatically optimized.
+	This will disable the lexer's first char optimizations.
+	See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#COMPLEMENT for details.`);
+      }
+    } else {
+      let msgSuffix = "";
+      if (ensureOptimizations) {
+        msgSuffix = "\n	This will disable the lexer's first char optimizations.\n	See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#REGEXP_PARSING for details.";
+      }
+      PRINT_ERROR(`${failedOptimizationPrefixMsg}
+	Failed parsing: < ${regExp.toString()} >
+	Using the @chevrotain/regexp-to-ast library
+	Please open an issue at: https://github.com/chevrotain/chevrotain/issues` + msgSuffix);
+    }
+  }
+  return [];
+}
+function firstCharOptimizedIndices(ast, result, ignoreCase) {
+  switch (ast.type) {
+    case "Disjunction":
+      for (let i = 0; i < ast.value.length; i++) {
+        firstCharOptimizedIndices(ast.value[i], result, ignoreCase);
+      }
+      break;
+    case "Alternative":
+      const terms = ast.value;
+      for (let i = 0; i < terms.length; i++) {
+        const term = terms[i];
+        switch (term.type) {
+          case "EndAnchor":
+          // A group back reference cannot affect potential starting char.
+          // because if a back reference is the first production than automatically
+          // the group being referenced has had to come BEFORE so its codes have already been added
+          case "GroupBackReference":
+          // assertions do not affect potential starting codes
+          case "Lookahead":
+          case "NegativeLookahead":
+          case "StartAnchor":
+          case "WordBoundary":
+          case "NonWordBoundary":
+            continue;
+        }
+        const atom = term;
+        switch (atom.type) {
+          case "Character":
+            addOptimizedIdxToResult(atom.value, result, ignoreCase);
+            break;
+          case "Set":
+            if (atom.complement === true) {
+              throw Error(complementErrorMessage);
+            }
+            forEach(atom.value, (code) => {
+              if (typeof code === "number") {
+                addOptimizedIdxToResult(code, result, ignoreCase);
+              } else {
+                const range = code;
+                if (ignoreCase === true) {
+                  for (let rangeCode = range.from; rangeCode <= range.to; rangeCode++) {
+                    addOptimizedIdxToResult(rangeCode, result, ignoreCase);
+                  }
+                } else {
+                  for (let rangeCode = range.from; rangeCode <= range.to && rangeCode < minOptimizationVal; rangeCode++) {
+                    addOptimizedIdxToResult(rangeCode, result, ignoreCase);
+                  }
+                  if (range.to >= minOptimizationVal) {
+                    const minUnOptVal = range.from >= minOptimizationVal ? range.from : minOptimizationVal;
+                    const maxUnOptVal = range.to;
+                    const minOptIdx = charCodeToOptimizedIndex(minUnOptVal);
+                    const maxOptIdx = charCodeToOptimizedIndex(maxUnOptVal);
+                    for (let currOptIdx = minOptIdx; currOptIdx <= maxOptIdx; currOptIdx++) {
+                      result[currOptIdx] = currOptIdx;
+                    }
+                  }
+                }
+              }
+            });
+            break;
+          case "Group":
+            firstCharOptimizedIndices(atom.value, result, ignoreCase);
+            break;
+          /* istanbul ignore next */
+          default:
+            throw Error("Non Exhaustive Match");
+        }
+        const isOptionalQuantifier = atom.quantifier !== void 0 && atom.quantifier.atLeast === 0;
+        if (
+          // A group may be optional due to empty contents /(?:)/
+          // or if everything inside it is optional /((a)?)/
+          atom.type === "Group" && isWholeOptional(atom) === false || // If this term is not a group it may only be optional if it has an optional quantifier
+          atom.type !== "Group" && isOptionalQuantifier === false
+        ) {
+          break;
+        }
+      }
+      break;
+    /* istanbul ignore next */
+    default:
+      throw Error("non exhaustive match!");
+  }
+  return values(result);
+}
+function addOptimizedIdxToResult(code, result, ignoreCase) {
+  const optimizedCharIdx = charCodeToOptimizedIndex(code);
+  result[optimizedCharIdx] = optimizedCharIdx;
+  if (ignoreCase === true) {
+    handleIgnoreCase(code, result);
+  }
+}
+function handleIgnoreCase(code, result) {
+  const char = String.fromCharCode(code);
+  const upperChar = char.toUpperCase();
+  if (upperChar !== char) {
+    const optimizedCharIdx = charCodeToOptimizedIndex(upperChar.charCodeAt(0));
+    result[optimizedCharIdx] = optimizedCharIdx;
+  } else {
+    const lowerChar = char.toLowerCase();
+    if (lowerChar !== char) {
+      const optimizedCharIdx = charCodeToOptimizedIndex(lowerChar.charCodeAt(0));
+      result[optimizedCharIdx] = optimizedCharIdx;
+    }
+  }
+}
+function findCode(setNode, targetCharCodes) {
+  return find(setNode.value, (codeOrRange) => {
+    if (typeof codeOrRange === "number") {
+      return includes(targetCharCodes, codeOrRange);
+    } else {
+      const range = codeOrRange;
+      return find(targetCharCodes, (targetCode) => range.from <= targetCode && targetCode <= range.to) !== void 0;
+    }
+  });
+}
+function isWholeOptional(ast) {
+  const quantifier = ast.quantifier;
+  if (quantifier && quantifier.atLeast === 0) {
+    return true;
+  }
+  if (!ast.value) {
+    return false;
+  }
+  return isArray(ast.value) ? every(ast.value, isWholeOptional) : isWholeOptional(ast.value);
+}
+class CharCodeFinder extends BaseRegExpVisitor {
+  constructor(targetCharCodes) {
+    super();
+    this.targetCharCodes = targetCharCodes;
+    this.found = false;
+  }
+  visitChildren(node) {
+    if (this.found === true) {
+      return;
+    }
+    switch (node.type) {
+      case "Lookahead":
+        this.visitLookahead(node);
+        return;
+      case "NegativeLookahead":
+        this.visitNegativeLookahead(node);
+        return;
+    }
+    super.visitChildren(node);
+  }
+  visitCharacter(node) {
+    if (includes(this.targetCharCodes, node.value)) {
+      this.found = true;
+    }
+  }
+  visitSet(node) {
+    if (node.complement) {
+      if (findCode(node, this.targetCharCodes) === void 0) {
+        this.found = true;
+      }
+    } else {
+      if (findCode(node, this.targetCharCodes) !== void 0) {
+        this.found = true;
+      }
+    }
+  }
+}
+function canMatchCharCode(charCodes, pattern) {
+  if (pattern instanceof RegExp) {
+    const ast = getRegExpAst(pattern);
+    const charCodeFinder = new CharCodeFinder(charCodes);
+    charCodeFinder.visit(ast);
+    return charCodeFinder.found;
+  } else {
+    return find(pattern, (char) => {
+      return includes(charCodes, char.charCodeAt(0));
+    }) !== void 0;
+  }
+}
+export {
+  canMatchCharCode,
+  failedOptimizationPrefixMsg,
+  firstCharOptimizedIndices,
+  getOptimizedStartCodesIndices
+};
+//# sourceMappingURL=reg_exp.mjs.map

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/reg_exp.mjs.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"reg_exp.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/reg_exp.js"],"sourcesContent":["import { BaseRegExpVisitor, } from \"@chevrotain/regexp-to-ast\";\nimport { every, find, forEach, includes, isArray, values } from \"lodash-es\";\nimport { PRINT_ERROR, PRINT_WARNING } from \"@chevrotain/utils\";\nimport { getRegExpAst } from \"./reg_exp_parser.js\";\nimport { charCodeToOptimizedIndex, minOptimizationVal } from \"./lexer.js\";\nconst complementErrorMessage = \"Complement Sets are not supported for first char optimization\";\nexport const failedOptimizationPrefixMsg = 'Unable to use \"first char\" lexer optimizations:\\n';\nexport function getOptimizedStartCodesIndices(regExp, ensureOptimizations = false) {\n try {\n const ast = getRegExpAst(regExp);\n const firstChars = firstCharOptimizedIndices(ast.value, {}, ast.flags.ignoreCase);\n return firstChars;\n }\n catch (e) {\n /* istanbul ignore next */\n // Testing this relies on the regexp-to-ast library having a bug... */\n // TODO: only the else branch needs to be ignored, try to fix with newer prettier / tsc\n if (e.message === complementErrorMessage) {\n if (ensureOptimizations) {\n PRINT_WARNING(`${failedOptimizationPrefixMsg}` +\n `\\tUnable to optimize: < ${regExp.toString()} >\\n` +\n \"\\tComplement Sets cannot be automatically optimized.\\n\" +\n \"\\tThis will disable the lexer's first char optimizations.\\n\" +\n \"\\tSee: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#COMPLEMENT for details.\");\n }\n }\n else {\n let msgSuffix = \"\";\n if (ensureOptimizations) {\n msgSuffix =\n \"\\n\\tThis will disable the lexer's first char optimizations.\\n\" +\n \"\\tSee: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#REGEXP_PARSING for details.\";\n }\n PRINT_ERROR(`${failedOptimizationPrefixMsg}\\n` +\n `\\tFailed parsing: < ${regExp.toString()} >\\n` +\n `\\tUsing the @chevrotain/regexp-to-ast library\\n` +\n \"\\tPlease open an issue at: https://github.com/chevrotain/chevrotain/issues\" +\n msgSuffix);\n }\n }\n return [];\n}\nexport function firstCharOptimizedIndices(ast, result, ignoreCase) {\n switch (ast.type) {\n case \"Disjunction\":\n for (let i = 0; i < ast.value.length; i++) {\n firstCharOptimizedIndices(ast.value[i], result, ignoreCase);\n }\n break;\n case \"Alternative\":\n const terms = ast.value;\n for (let i = 0; i < terms.length; i++) {\n const term = terms[i];\n // skip terms that cannot effect the first char results\n switch (term.type) {\n case \"EndAnchor\":\n // A group back reference cannot affect potential starting char.\n // because if a back reference is the first production than automatically\n // the group being referenced has had to come BEFORE so its codes have already been added\n case \"GroupBackReference\":\n // assertions do not affect potential starting codes\n case \"Lookahead\":\n case \"NegativeLookahead\":\n case \"StartAnchor\":\n case \"WordBoundary\":\n case \"NonWordBoundary\":\n continue;\n }\n const atom = term;\n switch (atom.type) {\n case \"Character\":\n addOptimizedIdxToResult(atom.value, result, ignoreCase);\n break;\n case \"Set\":\n if (atom.complement === true) {\n throw Error(complementErrorMessage);\n }\n forEach(atom.value, (code) => {\n if (typeof code === \"number\") {\n addOptimizedIdxToResult(code, result, ignoreCase);\n }\n else {\n // range\n const range = code;\n // cannot optimize when ignoreCase is\n if (ignoreCase === true) {\n for (let rangeCode = range.from; rangeCode <= range.to; rangeCode++) {\n addOptimizedIdxToResult(rangeCode, result, ignoreCase);\n }\n }\n // Optimization (2 orders of magnitude less work for very large ranges)\n else {\n // handle unoptimized values\n for (let rangeCode = range.from; rangeCode <= range.to && rangeCode < minOptimizationVal; rangeCode++) {\n addOptimizedIdxToResult(rangeCode, result, ignoreCase);\n }\n // Less common charCode where we optimize for faster init time, by using larger \"buckets\"\n if (range.to >= minOptimizationVal) {\n const minUnOptVal = range.from >= minOptimizationVal\n ? range.from\n : minOptimizationVal;\n const maxUnOptVal = range.to;\n const minOptIdx = charCodeToOptimizedIndex(minUnOptVal);\n const maxOptIdx = charCodeToOptimizedIndex(maxUnOptVal);\n for (let currOptIdx = minOptIdx; currOptIdx <= maxOptIdx; currOptIdx++) {\n result[currOptIdx] = currOptIdx;\n }\n }\n }\n }\n });\n break;\n case \"Group\":\n firstCharOptimizedIndices(atom.value, result, ignoreCase);\n break;\n /* istanbul ignore next */\n default:\n throw Error(\"Non Exhaustive Match\");\n }\n // reached a mandatory production, no more **start** codes can be found on this alternative\n const isOptionalQuantifier = atom.quantifier !== undefined && atom.quantifier.atLeast === 0;\n if (\n // A group may be optional due to empty contents /(?:)/\n // or if everything inside it is optional /((a)?)/\n (atom.type === \"Group\" && isWholeOptional(atom) === false) ||\n // If this term is not a group it may only be optional if it has an optional quantifier\n (atom.type !== \"Group\" && isOptionalQuantifier === false)) {\n break;\n }\n }\n break;\n /* istanbul ignore next */\n default:\n throw Error(\"non exhaustive match!\");\n }\n // console.log(Object.keys(result).length)\n return values(result);\n}\nfunction addOptimizedIdxToResult(code, result, ignoreCase) {\n const optimizedCharIdx = charCodeToOptimizedIndex(code);\n result[optimizedCharIdx] = optimizedCharIdx;\n if (ignoreCase === true) {\n handleIgnoreCase(code, result);\n }\n}\nfunction handleIgnoreCase(code, result) {\n const char = String.fromCharCode(code);\n const upperChar = char.toUpperCase();\n /* istanbul ignore else */\n if (upperChar !== char) {\n const optimizedCharIdx = charCodeToOptimizedIndex(upperChar.charCodeAt(0));\n result[optimizedCharIdx] = optimizedCharIdx;\n }\n else {\n const lowerChar = char.toLowerCase();\n if (lowerChar !== char) {\n const optimizedCharIdx = charCodeToOptimizedIndex(lowerChar.charCodeAt(0));\n result[optimizedCharIdx] = optimizedCharIdx;\n }\n }\n}\nfunction findCode(setNode, targetCharCodes) {\n return find(setNode.value, (codeOrRange) => {\n if (typeof codeOrRange === \"number\") {\n return includes(targetCharCodes, codeOrRange);\n }\n else {\n // range\n const range = codeOrRange;\n return (find(targetCharCodes, (targetCode) => range.from <= targetCode && targetCode <= range.to) !== undefined);\n }\n });\n}\nfunction isWholeOptional(ast) {\n const quantifier = ast.quantifier;\n if (quantifier && quantifier.atLeast === 0) {\n return true;\n }\n if (!ast.value) {\n return false;\n }\n return isArray(ast.value)\n ? every(ast.value, isWholeOptional)\n : isWholeOptional(ast.value);\n}\nclass CharCodeFinder extends BaseRegExpVisitor {\n constructor(targetCharCodes) {\n super();\n this.targetCharCodes = targetCharCodes;\n this.found = false;\n }\n visitChildren(node) {\n // No need to keep looking...\n if (this.found === true) {\n return;\n }\n // switch lookaheads as they do not actually consume any characters thus\n // finding a charCode at lookahead context does not mean that regexp can actually contain it in a match.\n switch (node.type) {\n case \"Lookahead\":\n this.visitLookahead(node);\n return;\n case \"NegativeLookahead\":\n this.visitNegativeLookahead(node);\n return;\n }\n super.visitChildren(node);\n }\n visitCharacter(node) {\n if (includes(this.targetCharCodes, node.value)) {\n this.found = true;\n }\n }\n visitSet(node) {\n if (node.complement) {\n if (findCode(node, this.targetCharCodes) === undefined) {\n this.found = true;\n }\n }\n else {\n if (findCode(node, this.targetCharCodes) !== undefined) {\n this.found = true;\n }\n }\n }\n}\nexport function canMatchCharCode(charCodes, pattern) {\n if (pattern instanceof RegExp) {\n const ast = getRegExpAst(pattern);\n const charCodeFinder = new CharCodeFinder(charCodes);\n charCodeFinder.visit(ast);\n return charCodeFinder.found;\n }\n else {\n return (find(pattern, (char) => {\n return includes(charCodes, char.charCodeAt(0));\n }) !== undefined);\n }\n}\n//# sourceMappingURL=reg_exp.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/reg_exp_parser.mjs ADDED Viewed

@@ -0,0 +1,21 @@
+import { RegExpParser } from "../../../../../../@chevrotain_regexp-to-ast@11.0.3/node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.mjs";
+let regExpAstCache = {};
+const regExpParser = new RegExpParser();
+function getRegExpAst(regExp) {
+  const regExpStr = regExp.toString();
+  if (regExpAstCache.hasOwnProperty(regExpStr)) {
+    return regExpAstCache[regExpStr];
+  } else {
+    const regExpAst = regExpParser.pattern(regExpStr);
+    regExpAstCache[regExpStr] = regExpAst;
+    return regExpAst;
+  }
+}
+function clearRegExpParserCache() {
+  regExpAstCache = {};
+}
+export {
+  clearRegExpParserCache,
+  getRegExpAst
+};
+//# sourceMappingURL=reg_exp_parser.mjs.map

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/reg_exp_parser.mjs.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"reg_exp_parser.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/reg_exp_parser.js"],"sourcesContent":["import { RegExpParser, } from \"@chevrotain/regexp-to-ast\";\nlet regExpAstCache = {};\nconst regExpParser = new RegExpParser();\nexport function getRegExpAst(regExp) {\n const regExpStr = regExp.toString();\n if (regExpAstCache.hasOwnProperty(regExpStr)) {\n return regExpAstCache[regExpStr];\n }\n else {\n const regExpAst = regExpParser.pattern(regExpStr);\n regExpAstCache[regExpStr] = regExpAst;\n return regExpAst;\n }\n}\nexport function clearRegExpParserCache() {\n regExpAstCache = {};\n}\n//# sourceMappingURL=reg_exp_parser.js.map"],"names":[],"mappings":";AACA,IAAI,iBAAiB,CAAA;AACrB,MAAM,eAAe,IAAI,aAAY;AAC9B,SAAS,aAAa,QAAQ;AACjC,QAAM,YAAY,OAAO,SAAQ;AACjC,MAAI,eAAe,eAAe,SAAS,GAAG;AAC1C,WAAO,eAAe,SAAS;AAAA,EACnC,OACK;AACD,UAAM,YAAY,aAAa,QAAQ,SAAS;AAChD,mBAAe,SAAS,IAAI;AAC5B,WAAO;AAAA,EACX;AACJ;AACO,SAAS,yBAAyB;AACrC,mBAAiB,CAAA;AACrB;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens.mjs ADDED Viewed

@@ -0,0 +1,125 @@
+import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+import clone from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clone.mjs";
+import compact from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/compact.mjs";
+import flatten from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.mjs";
+import map from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs";
+import difference from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/difference.mjs";
+import isEmpty from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.mjs";
+import isArray from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isArray.mjs";
+import has from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.mjs";
+import includes from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/includes.mjs";
+function tokenStructuredMatcher(tokInstance, tokConstructor) {
+  const instanceType = tokInstance.tokenTypeIdx;
+  if (instanceType === tokConstructor.tokenTypeIdx) {
+    return true;
+  } else {
+    return tokConstructor.isParent === true && tokConstructor.categoryMatchesMap[instanceType] === true;
+  }
+}
+function tokenStructuredMatcherNoCategories(token, tokType) {
+  return token.tokenTypeIdx === tokType.tokenTypeIdx;
+}
+let tokenShortNameIdx = 1;
+const tokenIdxToClass = {};
+function augmentTokenTypes(tokenTypes) {
+  const tokenTypesAndParents = expandCategories(tokenTypes);
+  assignTokenDefaultProps(tokenTypesAndParents);
+  assignCategoriesMapProp(tokenTypesAndParents);
+  assignCategoriesTokensProp(tokenTypesAndParents);
+  forEach(tokenTypesAndParents, (tokType) => {
+    tokType.isParent = tokType.categoryMatches.length > 0;
+  });
+}
+function expandCategories(tokenTypes) {
+  let result = clone(tokenTypes);
+  let categories = tokenTypes;
+  let searching = true;
+  while (searching) {
+    categories = compact(flatten(map(categories, (currTokType) => currTokType.CATEGORIES)));
+    const newCategories = difference(categories, result);
+    result = result.concat(newCategories);
+    if (isEmpty(newCategories)) {
+      searching = false;
+    } else {
+      categories = newCategories;
+    }
+  }
+  return result;
+}
+function assignTokenDefaultProps(tokenTypes) {
+  forEach(tokenTypes, (currTokType) => {
+    if (!hasShortKeyProperty(currTokType)) {
+      tokenIdxToClass[tokenShortNameIdx] = currTokType;
+      currTokType.tokenTypeIdx = tokenShortNameIdx++;
+    }
+    if (hasCategoriesProperty(currTokType) && !isArray(currTokType.CATEGORIES)) {
+      currTokType.CATEGORIES = [currTokType.CATEGORIES];
+    }
+    if (!hasCategoriesProperty(currTokType)) {
+      currTokType.CATEGORIES = [];
+    }
+    if (!hasExtendingTokensTypesProperty(currTokType)) {
+      currTokType.categoryMatches = [];
+    }
+    if (!hasExtendingTokensTypesMapProperty(currTokType)) {
+      currTokType.categoryMatchesMap = {};
+    }
+  });
+}
+function assignCategoriesTokensProp(tokenTypes) {
+  forEach(tokenTypes, (currTokType) => {
+    currTokType.categoryMatches = [];
+    forEach(currTokType.categoryMatchesMap, (val, key) => {
+      currTokType.categoryMatches.push(tokenIdxToClass[key].tokenTypeIdx);
+    });
+  });
+}
+function assignCategoriesMapProp(tokenTypes) {
+  forEach(tokenTypes, (currTokType) => {
+    singleAssignCategoriesToksMap([], currTokType);
+  });
+}
+function singleAssignCategoriesToksMap(path, nextNode) {
+  forEach(path, (pathNode) => {
+    nextNode.categoryMatchesMap[pathNode.tokenTypeIdx] = true;
+  });
+  forEach(nextNode.CATEGORIES, (nextCategory) => {
+    const newPath = path.concat(nextNode);
+    if (!includes(newPath, nextCategory)) {
+      singleAssignCategoriesToksMap(newPath, nextCategory);
+    }
+  });
+}
+function hasShortKeyProperty(tokType) {
+  return has(tokType, "tokenTypeIdx");
+}
+function hasCategoriesProperty(tokType) {
+  return has(tokType, "CATEGORIES");
+}
+function hasExtendingTokensTypesProperty(tokType) {
+  return has(tokType, "categoryMatches");
+}
+function hasExtendingTokensTypesMapProperty(tokType) {
+  return has(tokType, "categoryMatchesMap");
+}
+function isTokenType(tokType) {
+  return has(tokType, "tokenTypeIdx");
+}
+export {
+  assignCategoriesMapProp,
+  assignCategoriesTokensProp,
+  assignTokenDefaultProps,
+  augmentTokenTypes,
+  expandCategories,
+  hasCategoriesProperty,
+  hasExtendingTokensTypesMapProperty,
+  hasExtendingTokensTypesProperty,
+  hasShortKeyProperty,
+  isTokenType,
+  singleAssignCategoriesToksMap,
+  tokenIdxToClass,
+  tokenShortNameIdx,
+  tokenStructuredMatcher,
+  tokenStructuredMatcherNoCategories
+};
+//# sourceMappingURL=tokens.mjs.map

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens.mjs.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"tokens.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens.js"],"sourcesContent":["import { clone, compact, difference, flatten, forEach, has, includes, isArray, isEmpty, map, } from \"lodash-es\";\nexport function tokenStructuredMatcher(tokInstance, tokConstructor) {\n const instanceType = tokInstance.tokenTypeIdx;\n if (instanceType === tokConstructor.tokenTypeIdx) {\n return true;\n }\n else {\n return (tokConstructor.isParent === true &&\n tokConstructor.categoryMatchesMap[instanceType] === true);\n }\n}\n// Optimized tokenMatcher in case our grammar does not use token categories\n// Being so tiny it is much more likely to be in-lined and this avoid the function call overhead\nexport function tokenStructuredMatcherNoCategories(token, tokType) {\n return token.tokenTypeIdx === tokType.tokenTypeIdx;\n}\nexport let tokenShortNameIdx = 1;\nexport const tokenIdxToClass = {};\nexport function augmentTokenTypes(tokenTypes) {\n // collect the parent Token Types as well.\n const tokenTypesAndParents = expandCategories(tokenTypes);\n // add required tokenType and categoryMatches properties\n assignTokenDefaultProps(tokenTypesAndParents);\n // fill up the categoryMatches\n assignCategoriesMapProp(tokenTypesAndParents);\n assignCategoriesTokensProp(tokenTypesAndParents);\n forEach(tokenTypesAndParents, (tokType) => {\n tokType.isParent = tokType.categoryMatches.length > 0;\n });\n}\nexport function expandCategories(tokenTypes) {\n let result = clone(tokenTypes);\n let categories = tokenTypes;\n let searching = true;\n while (searching) {\n categories = compact(flatten(map(categories, (currTokType) => currTokType.CATEGORIES)));\n const newCategories = difference(categories, result);\n result = result.concat(newCategories);\n if (isEmpty(newCategories)) {\n searching = false;\n }\n else {\n categories = newCategories;\n }\n }\n return result;\n}\nexport function assignTokenDefaultProps(tokenTypes) {\n forEach(tokenTypes, (currTokType) => {\n if (!hasShortKeyProperty(currTokType)) {\n tokenIdxToClass[tokenShortNameIdx] = currTokType;\n currTokType.tokenTypeIdx = tokenShortNameIdx++;\n }\n // CATEGORIES? : TokenType | TokenType[]\n if (hasCategoriesProperty(currTokType) &&\n !isArray(currTokType.CATEGORIES)\n // &&\n // !isUndefined(currTokType.CATEGORIES.PATTERN)\n ) {\n currTokType.CATEGORIES = [currTokType.CATEGORIES];\n }\n if (!hasCategoriesProperty(currTokType)) {\n currTokType.CATEGORIES = [];\n }\n if (!hasExtendingTokensTypesProperty(currTokType)) {\n currTokType.categoryMatches = [];\n }\n if (!hasExtendingTokensTypesMapProperty(currTokType)) {\n currTokType.categoryMatchesMap = {};\n }\n });\n}\nexport function assignCategoriesTokensProp(tokenTypes) {\n forEach(tokenTypes, (currTokType) => {\n // avoid duplications\n currTokType.categoryMatches = [];\n forEach(currTokType.categoryMatchesMap, (val, key) => {\n currTokType.categoryMatches.push(tokenIdxToClass[key].tokenTypeIdx);\n });\n });\n}\nexport function assignCategoriesMapProp(tokenTypes) {\n forEach(tokenTypes, (currTokType) => {\n singleAssignCategoriesToksMap([], currTokType);\n });\n}\nexport function singleAssignCategoriesToksMap(path, nextNode) {\n forEach(path, (pathNode) => {\n nextNode.categoryMatchesMap[pathNode.tokenTypeIdx] = true;\n });\n forEach(nextNode.CATEGORIES, (nextCategory) => {\n const newPath = path.concat(nextNode);\n // avoids infinite loops due to cyclic categories.\n if (!includes(newPath, nextCategory)) {\n singleAssignCategoriesToksMap(newPath, nextCategory);\n }\n });\n}\nexport function hasShortKeyProperty(tokType) {\n return has(tokType, \"tokenTypeIdx\");\n}\nexport function hasCategoriesProperty(tokType) {\n return has(tokType, \"CATEGORIES\");\n}\nexport function hasExtendingTokensTypesProperty(tokType) {\n return has(tokType, \"categoryMatches\");\n}\nexport function hasExtendingTokensTypesMapProperty(tokType) {\n return has(tokType, \"categoryMatchesMap\");\n}\nexport function isTokenType(tokType) {\n return has(tokType, \"tokenTypeIdx\");\n}\n//# sourceMappingURL=tokens.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens_public.mjs ADDED Viewed

@@ -0,0 +1,91 @@
+import { Lexer } from "./lexer_public.mjs";
+import { tokenStructuredMatcher, augmentTokenTypes } from "./tokens.mjs";
+import isString from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isString.mjs";
+import isUndefined from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isUndefined.mjs";
+import has from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.mjs";
+function tokenLabel(tokType) {
+  if (hasTokenLabel(tokType)) {
+    return tokType.LABEL;
+  } else {
+    return tokType.name;
+  }
+}
+function hasTokenLabel(obj) {
+  return isString(obj.LABEL) && obj.LABEL !== "";
+}
+const PARENT = "parent";
+const CATEGORIES = "categories";
+const LABEL = "label";
+const GROUP = "group";
+const PUSH_MODE = "push_mode";
+const POP_MODE = "pop_mode";
+const LONGER_ALT = "longer_alt";
+const LINE_BREAKS = "line_breaks";
+const START_CHARS_HINT = "start_chars_hint";
+function createToken(config) {
+  return createTokenInternal(config);
+}
+function createTokenInternal(config) {
+  const pattern = config.pattern;
+  const tokenType = {};
+  tokenType.name = config.name;
+  if (!isUndefined(pattern)) {
+    tokenType.PATTERN = pattern;
+  }
+  if (has(config, PARENT)) {
+    throw "The parent property is no longer supported.\nSee: https://github.com/chevrotain/chevrotain/issues/564#issuecomment-349062346 for details.";
+  }
+  if (has(config, CATEGORIES)) {
+    tokenType.CATEGORIES = config[CATEGORIES];
+  }
+  augmentTokenTypes([tokenType]);
+  if (has(config, LABEL)) {
+    tokenType.LABEL = config[LABEL];
+  }
+  if (has(config, GROUP)) {
+    tokenType.GROUP = config[GROUP];
+  }
+  if (has(config, POP_MODE)) {
+    tokenType.POP_MODE = config[POP_MODE];
+  }
+  if (has(config, PUSH_MODE)) {
+    tokenType.PUSH_MODE = config[PUSH_MODE];
+  }
+  if (has(config, LONGER_ALT)) {
+    tokenType.LONGER_ALT = config[LONGER_ALT];
+  }
+  if (has(config, LINE_BREAKS)) {
+    tokenType.LINE_BREAKS = config[LINE_BREAKS];
+  }
+  if (has(config, START_CHARS_HINT)) {
+    tokenType.START_CHARS_HINT = config[START_CHARS_HINT];
+  }
+  return tokenType;
+}
+const EOF = createToken({ name: "EOF", pattern: Lexer.NA });
+augmentTokenTypes([EOF]);
+function createTokenInstance(tokType, image, startOffset, endOffset, startLine, endLine, startColumn, endColumn) {
+  return {
+    image,
+    startOffset,
+    endOffset,
+    startLine,
+    endLine,
+    startColumn,
+    endColumn,
+    tokenTypeIdx: tokType.tokenTypeIdx,
+    tokenType: tokType
+  };
+}
+function tokenMatcher(token, tokType) {
+  return tokenStructuredMatcher(token, tokType);
+}
+export {
+  EOF,
+  createToken,
+  createTokenInstance,
+  hasTokenLabel,
+  tokenLabel,
+  tokenMatcher
+};
+//# sourceMappingURL=tokens_public.mjs.map

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens_public.mjs.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"tokens_public.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens_public.js"],"sourcesContent":["import { has, isString, isUndefined } from \"lodash-es\";\nimport { Lexer } from \"./lexer_public.js\";\nimport { augmentTokenTypes, tokenStructuredMatcher } from \"./tokens.js\";\nexport function tokenLabel(tokType) {\n if (hasTokenLabel(tokType)) {\n return tokType.LABEL;\n }\n else {\n return tokType.name;\n }\n}\nexport function tokenName(tokType) {\n return tokType.name;\n}\nexport function hasTokenLabel(obj) {\n return isString(obj.LABEL) && obj.LABEL !== \"\";\n}\nconst PARENT = \"parent\";\nconst CATEGORIES = \"categories\";\nconst LABEL = \"label\";\nconst GROUP = \"group\";\nconst PUSH_MODE = \"push_mode\";\nconst POP_MODE = \"pop_mode\";\nconst LONGER_ALT = \"longer_alt\";\nconst LINE_BREAKS = \"line_breaks\";\nconst START_CHARS_HINT = \"start_chars_hint\";\nexport function createToken(config) {\n return createTokenInternal(config);\n}\nfunction createTokenInternal(config) {\n const pattern = config.pattern;\n const tokenType = {};\n tokenType.name = config.name;\n if (!isUndefined(pattern)) {\n tokenType.PATTERN = pattern;\n }\n if (has(config, PARENT)) {\n throw (\"The parent property is no longer supported.\\n\" +\n \"See: https://github.com/chevrotain/chevrotain/issues/564#issuecomment-349062346 for details.\");\n }\n if (has(config, CATEGORIES)) {\n // casting to ANY as this will be fixed inside `augmentTokenTypes``\n tokenType.CATEGORIES = config[CATEGORIES];\n }\n augmentTokenTypes([tokenType]);\n if (has(config, LABEL)) {\n tokenType.LABEL = config[LABEL];\n }\n if (has(config, GROUP)) {\n tokenType.GROUP = config[GROUP];\n }\n if (has(config, POP_MODE)) {\n tokenType.POP_MODE = config[POP_MODE];\n }\n if (has(config, PUSH_MODE)) {\n tokenType.PUSH_MODE = config[PUSH_MODE];\n }\n if (has(config, LONGER_ALT)) {\n tokenType.LONGER_ALT = config[LONGER_ALT];\n }\n if (has(config, LINE_BREAKS)) {\n tokenType.LINE_BREAKS = config[LINE_BREAKS];\n }\n if (has(config, START_CHARS_HINT)) {\n tokenType.START_CHARS_HINT = config[START_CHARS_HINT];\n }\n return tokenType;\n}\nexport const EOF = createToken({ name: \"EOF\", pattern: Lexer.NA });\naugmentTokenTypes([EOF]);\nexport function createTokenInstance(tokType, image, startOffset, endOffset, startLine, endLine, startColumn, endColumn) {\n return {\n image,\n startOffset,\n endOffset,\n startLine,\n endLine,\n startColumn,\n endColumn,\n tokenTypeIdx: tokType.tokenTypeIdx,\n tokenType: tokType,\n };\n}\nexport function tokenMatcher(token, tokType) {\n return tokenStructuredMatcher(token, tokType);\n}\n//# sourceMappingURL=tokens_public.js.map"],"names":[],"mappings":";;;;;AAGO,SAAS,WAAW,SAAS;AAChC,MAAI,cAAc,OAAO,GAAG;AACxB,WAAO,QAAQ;AAAA,EACnB,OACK;AACD,WAAO,QAAQ;AAAA,EACnB;AACJ;AAIO,SAAS,cAAc,KAAK;AAC/B,SAAO,SAAS,IAAI,KAAK,KAAK,IAAI,UAAU;AAChD;AACA,MAAM,SAAS;AACf,MAAM,aAAa;AACnB,MAAM,QAAQ;AACd,MAAM,QAAQ;AACd,MAAM,YAAY;AAClB,MAAM,WAAW;AACjB,MAAM,aAAa;AACnB,MAAM,cAAc;AACpB,MAAM,mBAAmB;AAClB,SAAS,YAAY,QAAQ;AAChC,SAAO,oBAAoB,MAAM;AACrC;AACA,SAAS,oBAAoB,QAAQ;AACjC,QAAM,UAAU,OAAO;AACvB,QAAM,YAAY,CAAA;AAClB,YAAU,OAAO,OAAO;AACxB,MAAI,CAAC,YAAY,OAAO,GAAG;AACvB,cAAU,UAAU;AAAA,EACxB;AACA,MAAI,IAAI,QAAQ,MAAM,GAAG;AACrB,UAAO;AAAA,EAEX;AACA,MAAI,IAAI,QAAQ,UAAU,GAAG;AAEzB,cAAU,aAAa,OAAO,UAAU;AAAA,EAC5C;AACA,oBAAkB,CAAC,SAAS,CAAC;AAC7B,MAAI,IAAI,QAAQ,KAAK,GAAG;AACpB,cAAU,QAAQ,OAAO,KAAK;AAAA,EAClC;AACA,MAAI,IAAI,QAAQ,KAAK,GAAG;AACpB,cAAU,QAAQ,OAAO,KAAK;AAAA,EAClC;AACA,MAAI,IAAI,QAAQ,QAAQ,GAAG;AACvB,cAAU,WAAW,OAAO,QAAQ;AAAA,EACxC;AACA,MAAI,IAAI,QAAQ,SAAS,GAAG;AACxB,cAAU,YAAY,OAAO,SAAS;AAAA,EAC1C;AACA,MAAI,IAAI,QAAQ,UAAU,GAAG;AACzB,cAAU,aAAa,OAAO,UAAU;AAAA,EAC5C;AACA,MAAI,IAAI,QAAQ,WAAW,GAAG;AAC1B,cAAU,cAAc,OAAO,WAAW;AAAA,EAC9C;AACA,MAAI,IAAI,QAAQ,gBAAgB,GAAG;AAC/B,cAAU,mBAAmB,OAAO,gBAAgB;AAAA,EACxD;AACA,SAAO;AACX;AACY,MAAC,MAAM,YAAY,EAAE,MAAM,OAAO,SAAS,MAAM,GAAE,CAAE;AACjE,kBAAkB,CAAC,GAAG,CAAC;AAChB,SAAS,oBAAoB,SAAS,OAAO,aAAa,WAAW,WAAW,SAAS,aAAa,WAAW;AACpH,SAAO;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,cAAc,QAAQ;AAAA,IACtB,WAAW;AAAA,EACnB;AACA;AACO,SAAS,aAAa,OAAO,SAAS;AACzC,SAAO,uBAAuB,OAAO,OAAO;AAChD;","x_google_ignoreList":[0]}