@plumile/ui 0.1.113 → 0.1.115

package/lib/esm/node_modules/chevrotain/lib/src/parse/grammar/lookahead.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lookahead.js","names":["AlternativeGAST"],"sources":["../../../../../../../../../../node_modules/chevrotain/lib/src/parse/grammar/lookahead.js"],"sourcesContent":["import { possiblePathsFrom } from \"./interpreter.js\";\nimport { RestWalker } from \"./rest.js\";\nimport { tokenStructuredMatcher, tokenStructuredMatcherNoCategories, } from \"../../scan/tokens.js\";\nimport { Alternation, Alternative as AlternativeGAST, GAstVisitor, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, } from \"@chevrotain/gast\";\nexport var PROD_TYPE;\n(function (PROD_TYPE) {\n    PROD_TYPE[PROD_TYPE[\"OPTION\"] = 0] = \"OPTION\";\n    PROD_TYPE[PROD_TYPE[\"REPETITION\"] = 1] = \"REPETITION\";\n    PROD_TYPE[PROD_TYPE[\"REPETITION_MANDATORY\"] = 2] = \"REPETITION_MANDATORY\";\n    PROD_TYPE[PROD_TYPE[\"REPETITION_MANDATORY_WITH_SEPARATOR\"] = 3] = \"REPETITION_MANDATORY_WITH_SEPARATOR\";\n    PROD_TYPE[PROD_TYPE[\"REPETITION_WITH_SEPARATOR\"] = 4] = \"REPETITION_WITH_SEPARATOR\";\n    PROD_TYPE[PROD_TYPE[\"ALTERNATION\"] = 5] = \"ALTERNATION\";\n})(PROD_TYPE || (PROD_TYPE = {}));\nexport function getProdType(prod) {\n    /* istanbul ignore else */\n    if (prod instanceof Option || prod === \"Option\") {\n        return PROD_TYPE.OPTION;\n    }\n    else if (prod instanceof Repetition || prod === \"Repetition\") {\n        return PROD_TYPE.REPETITION;\n    }\n    else if (prod instanceof RepetitionMandatory ||\n        prod === \"RepetitionMandatory\") {\n        return PROD_TYPE.REPETITION_MANDATORY;\n    }\n    else if (prod instanceof RepetitionMandatoryWithSeparator ||\n        prod === \"RepetitionMandatoryWithSeparator\") {\n        return PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR;\n    }\n    else if (prod instanceof RepetitionWithSeparator ||\n        prod === \"RepetitionWithSeparator\") {\n        return PROD_TYPE.REPETITION_WITH_SEPARATOR;\n    }\n    else if (prod instanceof Alternation || prod === \"Alternation\") {\n        return PROD_TYPE.ALTERNATION;\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\nexport function getLookaheadPaths(options) {\n    const { occurrence, rule, prodType, maxLookahead } = options;\n    const type = getProdType(prodType);\n    if (type === PROD_TYPE.ALTERNATION) {\n        return getLookaheadPathsForOr(occurrence, rule, maxLookahead);\n    }\n    else {\n        return getLookaheadPathsForOptionalProd(occurrence, rule, type, maxLookahead);\n    }\n}\nexport function buildLookaheadFuncForOr(occurrence, ruleGrammar, maxLookahead, hasPredicates, dynamicTokensEnabled, laFuncBuilder) {\n    const lookAheadPaths = getLookaheadPathsForOr(occurrence, ruleGrammar, maxLookahead);\n    const tokenMatcher = areTokenCategoriesNotUsed(lookAheadPaths)\n        ? tokenStructuredMatcherNoCategories\n        : tokenStructuredMatcher;\n    return laFuncBuilder(lookAheadPaths, hasPredicates, tokenMatcher, dynamicTokensEnabled);\n}\n/**\n *  When dealing with an Optional production (OPTION/MANY/2nd iteration of AT_LEAST_ONE/...) we need to compare\n *  the lookahead \"inside\" the production and the lookahead immediately \"after\" it in the same top level rule (context free).\n *\n *  Example: given a production:\n *  ABC(DE)?DF\n *\n *  The optional '(DE)?' should only be entered if we see 'DE'. a single Token 'D' is not sufficient to distinguish between the two\n *  alternatives.\n *\n *  @returns A Lookahead function which will return true IFF the parser should parse the Optional production.\n */\nexport function buildLookaheadFuncForOptionalProd(occurrence, ruleGrammar, k, dynamicTokensEnabled, prodType, lookaheadBuilder) {\n    const lookAheadPaths = getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, k);\n    const tokenMatcher = areTokenCategoriesNotUsed(lookAheadPaths)\n        ? tokenStructuredMatcherNoCategories\n        : tokenStructuredMatcher;\n    return lookaheadBuilder(lookAheadPaths[0], tokenMatcher, dynamicTokensEnabled);\n}\nexport function buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher, dynamicTokensEnabled) {\n    const numOfAlts = alts.length;\n    const areAllOneTokenLookahead = alts.every((currAlt) => {\n        return currAlt.every((currPath) => {\n            return currPath.length === 1;\n        });\n    });\n    // This version takes into account the predicates as well.\n    if (hasPredicates) {\n        /**\n         * @returns {number} - The chosen alternative index\n         */\n        return function (orAlts) {\n            // unfortunately the predicates must be extracted every single time\n            // as they cannot be cached due to references to parameters(vars) which are no longer valid.\n            // note that in the common case of no predicates, no cpu time will be wasted on this (see else block)\n            const predicates = orAlts.map((currAlt) => currAlt.GATE);\n            for (let t = 0; t < numOfAlts; t++) {\n                const currAlt = alts[t];\n                const currNumOfPaths = currAlt.length;\n                const currPredicate = predicates[t];\n                if (currPredicate !== undefined && currPredicate.call(this) === false) {\n                    // if the predicate does not match there is no point in checking the paths\n                    continue;\n                }\n                nextPath: for (let j = 0; j < currNumOfPaths; j++) {\n                    const currPath = currAlt[j];\n                    const currPathLength = currPath.length;\n                    for (let i = 0; i < currPathLength; i++) {\n                        const nextToken = this.LA_FAST(i + 1);\n                        if (tokenMatcher(nextToken, currPath[i]) === false) {\n                            // mismatch in current path\n                            // try the next pth\n                            continue nextPath;\n                        }\n                    }\n                    // found a full path that matches.\n                    // this will also work for an empty ALT as the loop will be skipped\n                    return t;\n                }\n                // none of the paths for the current alternative matched\n                // try the next alternative\n            }\n            // none of the alternatives could be matched\n            return undefined;\n        };\n    }\n    else if (areAllOneTokenLookahead && !dynamicTokensEnabled) {\n        // optimized (common) case of all the lookaheads paths requiring only\n        // a single token lookahead. These Optimizations cannot work if dynamically defined Tokens are used.\n        const singleTokenAlts = alts.map((currAlt) => {\n            return currAlt.flat();\n        });\n        const choiceToAlt = singleTokenAlts.reduce((result, currAlt, idx) => {\n            currAlt.forEach((currTokType) => {\n                if (!(currTokType.tokenTypeIdx in result)) {\n                    result[currTokType.tokenTypeIdx] = idx;\n                }\n                currTokType.categoryMatches.forEach((currExtendingType) => {\n                    if (!Object.hasOwn(result, currExtendingType)) {\n                        result[currExtendingType] = idx;\n                    }\n                });\n            });\n            return result;\n        }, {});\n        /**\n         * @returns {number} - The chosen alternative index\n         */\n        return function () {\n            const nextToken = this.LA_FAST(1);\n            return choiceToAlt[nextToken.tokenTypeIdx];\n        };\n    }\n    else {\n        // optimized lookahead without needing to check the predicates at all.\n        // this causes code duplication which is intentional to improve performance.\n        /**\n         * @returns {number} - The chosen alternative index\n         */\n        return function () {\n            for (let t = 0; t < numOfAlts; t++) {\n                const currAlt = alts[t];\n                const currNumOfPaths = currAlt.length;\n                nextPath: for (let j = 0; j < currNumOfPaths; j++) {\n                    const currPath = currAlt[j];\n                    const currPathLength = currPath.length;\n                    for (let i = 0; i < currPathLength; i++) {\n                        const nextToken = this.LA_FAST(i + 1);\n                        if (tokenMatcher(nextToken, currPath[i]) === false) {\n                            // mismatch in current path\n                            // try the next pth\n                            continue nextPath;\n                        }\n                    }\n                    // found a full path that matches.\n                    // this will also work for an empty ALT as the loop will be skipped\n                    return t;\n                }\n                // none of the paths for the current alternative matched\n                // try the next alternative\n            }\n            // none of the alternatives could be matched\n            return undefined;\n        };\n    }\n}\nexport function buildSingleAlternativeLookaheadFunction(alt, tokenMatcher, dynamicTokensEnabled) {\n    const areAllOneTokenLookahead = alt.every((currPath) => {\n        return currPath.length === 1;\n    });\n    const numOfPaths = alt.length;\n    // optimized (common) case of all the lookaheads paths requiring only\n    // a single token lookahead.\n    if (areAllOneTokenLookahead && !dynamicTokensEnabled) {\n        const singleTokensTypes = alt.flat();\n        if (singleTokensTypes.length === 1 &&\n            singleTokensTypes[0].categoryMatches.length === 0) {\n            const expectedTokenType = singleTokensTypes[0];\n            const expectedTokenUniqueKey = expectedTokenType.tokenTypeIdx;\n            return function () {\n                return this.LA_FAST(1).tokenTypeIdx === expectedTokenUniqueKey;\n            };\n        }\n        else {\n            const choiceToAlt = singleTokensTypes.reduce((result, currTokType, idx) => {\n                result[currTokType.tokenTypeIdx] = true;\n                currTokType.categoryMatches.forEach((currExtendingType) => {\n                    result[currExtendingType] = true;\n                });\n                return result;\n            }, []);\n            return function () {\n                const nextToken = this.LA_FAST(1);\n                return choiceToAlt[nextToken.tokenTypeIdx] === true;\n            };\n        }\n    }\n    else {\n        return function () {\n            nextPath: for (let j = 0; j < numOfPaths; j++) {\n                const currPath = alt[j];\n                const currPathLength = currPath.length;\n                for (let i = 0; i < currPathLength; i++) {\n                    const nextToken = this.LA_FAST(i + 1);\n                    if (tokenMatcher(nextToken, currPath[i]) === false) {\n                        // mismatch in current path\n                        // try the next pth\n                        continue nextPath;\n                    }\n                }\n                // found a full path that matches.\n                return true;\n            }\n            // none of the paths matched\n            return false;\n        };\n    }\n}\nclass RestDefinitionFinderWalker extends RestWalker {\n    constructor(topProd, targetOccurrence, targetProdType) {\n        super();\n        this.topProd = topProd;\n        this.targetOccurrence = targetOccurrence;\n        this.targetProdType = targetProdType;\n    }\n    startWalking() {\n        this.walk(this.topProd);\n        return this.restDef;\n    }\n    checkIsTarget(node, expectedProdType, currRest, prevRest) {\n        if (node.idx === this.targetOccurrence &&\n            this.targetProdType === expectedProdType) {\n            this.restDef = currRest.concat(prevRest);\n            return true;\n        }\n        // performance optimization, do not iterate over the entire Grammar ast after we have found the target\n        return false;\n    }\n    walkOption(optionProd, currRest, prevRest) {\n        if (!this.checkIsTarget(optionProd, PROD_TYPE.OPTION, currRest, prevRest)) {\n            super.walkOption(optionProd, currRest, prevRest);\n        }\n    }\n    walkAtLeastOne(atLeastOneProd, currRest, prevRest) {\n        if (!this.checkIsTarget(atLeastOneProd, PROD_TYPE.REPETITION_MANDATORY, currRest, prevRest)) {\n            super.walkOption(atLeastOneProd, currRest, prevRest);\n        }\n    }\n    walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) {\n        if (!this.checkIsTarget(atLeastOneSepProd, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, currRest, prevRest)) {\n            super.walkOption(atLeastOneSepProd, currRest, prevRest);\n        }\n    }\n    walkMany(manyProd, currRest, prevRest) {\n        if (!this.checkIsTarget(manyProd, PROD_TYPE.REPETITION, currRest, prevRest)) {\n            super.walkOption(manyProd, currRest, prevRest);\n        }\n    }\n    walkManySep(manySepProd, currRest, prevRest) {\n        if (!this.checkIsTarget(manySepProd, PROD_TYPE.REPETITION_WITH_SEPARATOR, currRest, prevRest)) {\n            super.walkOption(manySepProd, currRest, prevRest);\n        }\n    }\n}\n/**\n * Returns the definition of a target production in a top level level rule.\n */\nclass InsideDefinitionFinderVisitor extends GAstVisitor {\n    constructor(targetOccurrence, targetProdType, targetRef) {\n        super();\n        this.targetOccurrence = targetOccurrence;\n        this.targetProdType = targetProdType;\n        this.targetRef = targetRef;\n        this.result = [];\n    }\n    checkIsTarget(node, expectedProdName) {\n        if (node.idx === this.targetOccurrence &&\n            this.targetProdType === expectedProdName &&\n            (this.targetRef === undefined || node === this.targetRef)) {\n            this.result = node.definition;\n        }\n    }\n    visitOption(node) {\n        this.checkIsTarget(node, PROD_TYPE.OPTION);\n    }\n    visitRepetition(node) {\n        this.checkIsTarget(node, PROD_TYPE.REPETITION);\n    }\n    visitRepetitionMandatory(node) {\n        this.checkIsTarget(node, PROD_TYPE.REPETITION_MANDATORY);\n    }\n    visitRepetitionMandatoryWithSeparator(node) {\n        this.checkIsTarget(node, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR);\n    }\n    visitRepetitionWithSeparator(node) {\n        this.checkIsTarget(node, PROD_TYPE.REPETITION_WITH_SEPARATOR);\n    }\n    visitAlternation(node) {\n        this.checkIsTarget(node, PROD_TYPE.ALTERNATION);\n    }\n}\nfunction initializeArrayOfArrays(size) {\n    const result = new Array(size);\n    for (let i = 0; i < size; i++) {\n        result[i] = [];\n    }\n    return result;\n}\n/**\n * A sort of hash function between a Path in the grammar and a string.\n * Note that this returns multiple \"hashes\" to support the scenario of token categories.\n * -  A single path with categories may match multiple **actual** paths.\n */\nfunction pathToHashKeys(path) {\n    let keys = [\"\"];\n    for (let i = 0; i < path.length; i++) {\n        const tokType = path[i];\n        const longerKeys = [];\n        for (let j = 0; j < keys.length; j++) {\n            const currShorterKey = keys[j];\n            longerKeys.push(currShorterKey + \"_\" + tokType.tokenTypeIdx);\n            for (let t = 0; t < tokType.categoryMatches.length; t++) {\n                const categoriesKeySuffix = \"_\" + tokType.categoryMatches[t];\n                longerKeys.push(currShorterKey + categoriesKeySuffix);\n            }\n        }\n        keys = longerKeys;\n    }\n    return keys;\n}\n/**\n * Imperative style due to being called from a hot spot\n */\nfunction isUniquePrefixHash(altKnownPathsKeys, searchPathKeys, idx) {\n    for (let currAltIdx = 0; currAltIdx < altKnownPathsKeys.length; currAltIdx++) {\n        // We only want to test vs the other alternatives\n        if (currAltIdx === idx) {\n            continue;\n        }\n        const otherAltKnownPathsKeys = altKnownPathsKeys[currAltIdx];\n        for (let searchIdx = 0; searchIdx < searchPathKeys.length; searchIdx++) {\n            const searchKey = searchPathKeys[searchIdx];\n            if (otherAltKnownPathsKeys[searchKey] === true) {\n                return false;\n            }\n        }\n    }\n    // None of the SearchPathKeys were found in any of the other alternatives\n    return true;\n}\nexport function lookAheadSequenceFromAlternatives(altsDefs, k) {\n    const partialAlts = altsDefs.map((currAlt) => possiblePathsFrom([currAlt], 1));\n    const finalResult = initializeArrayOfArrays(partialAlts.length);\n    const altsHashes = partialAlts.map((currAltPaths) => {\n        const dict = {};\n        currAltPaths.forEach((item) => {\n            const keys = pathToHashKeys(item.partialPath);\n            keys.forEach((currKey) => {\n                dict[currKey] = true;\n            });\n        });\n        return dict;\n    });\n    let newData = partialAlts;\n    // maxLookahead loop\n    for (let pathLength = 1; pathLength <= k; pathLength++) {\n        const currDataset = newData;\n        newData = initializeArrayOfArrays(currDataset.length);\n        // alternatives loop\n        for (let altIdx = 0; altIdx < currDataset.length; altIdx++) {\n            const currAltPathsAndSuffixes = currDataset[altIdx];\n            // paths in current alternative loop\n            for (let currPathIdx = 0; currPathIdx < currAltPathsAndSuffixes.length; currPathIdx++) {\n                const currPathPrefix = currAltPathsAndSuffixes[currPathIdx].partialPath;\n                const suffixDef = currAltPathsAndSuffixes[currPathIdx].suffixDef;\n                const prefixKeys = pathToHashKeys(currPathPrefix);\n                const isUnique = isUniquePrefixHash(altsHashes, prefixKeys, altIdx);\n                // End of the line for this path.\n                if (isUnique || suffixDef.length === 0 || currPathPrefix.length === k) {\n                    const currAltResult = finalResult[altIdx];\n                    // TODO: Can we implement a containsPath using Maps/Dictionaries?\n                    if (containsPath(currAltResult, currPathPrefix) === false) {\n                        currAltResult.push(currPathPrefix);\n                        // Update all new  keys for the current path.\n                        for (let j = 0; j < prefixKeys.length; j++) {\n                            const currKey = prefixKeys[j];\n                            altsHashes[altIdx][currKey] = true;\n                        }\n                    }\n                }\n                // Expand longer paths\n                else {\n                    const newPartialPathsAndSuffixes = possiblePathsFrom(suffixDef, pathLength + 1, currPathPrefix);\n                    newData[altIdx] = newData[altIdx].concat(newPartialPathsAndSuffixes);\n                    // Update keys for new known paths\n                    newPartialPathsAndSuffixes.forEach((item) => {\n                        const prefixKeys = pathToHashKeys(item.partialPath);\n                        prefixKeys.forEach((key) => {\n                            altsHashes[altIdx][key] = true;\n                        });\n                    });\n                }\n            }\n        }\n    }\n    return finalResult;\n}\nexport function getLookaheadPathsForOr(occurrence, ruleGrammar, k, orProd) {\n    const visitor = new InsideDefinitionFinderVisitor(occurrence, PROD_TYPE.ALTERNATION, orProd);\n    ruleGrammar.accept(visitor);\n    return lookAheadSequenceFromAlternatives(visitor.result, k);\n}\nexport function getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, k) {\n    const insideDefVisitor = new InsideDefinitionFinderVisitor(occurrence, prodType);\n    ruleGrammar.accept(insideDefVisitor);\n    const insideDef = insideDefVisitor.result;\n    const afterDefWalker = new RestDefinitionFinderWalker(ruleGrammar, occurrence, prodType);\n    const afterDef = afterDefWalker.startWalking();\n    const insideFlat = new AlternativeGAST({ definition: insideDef });\n    const afterFlat = new AlternativeGAST({ definition: afterDef });\n    return lookAheadSequenceFromAlternatives([insideFlat, afterFlat], k);\n}\nexport function containsPath(alternative, searchPath) {\n    compareOtherPath: for (let i = 0; i < alternative.length; i++) {\n        const otherPath = alternative[i];\n        if (otherPath.length !== searchPath.length) {\n            continue;\n        }\n        for (let j = 0; j < otherPath.length; j++) {\n            const searchTok = searchPath[j];\n            const otherTok = otherPath[j];\n            const matchingTokens = searchTok === otherTok ||\n                otherTok.categoryMatchesMap[searchTok.tokenTypeIdx] !== undefined;\n            if (matchingTokens === false) {\n                continue compareOtherPath;\n            }\n        }\n        return true;\n    }\n    return false;\n}\nexport function isStrictPrefixOfPath(prefix, other) {\n    return (prefix.length < other.length &&\n        prefix.every((tokType, idx) => {\n            const otherTokType = other[idx];\n            return (tokType === otherTokType ||\n                otherTokType.categoryMatchesMap[tokType.tokenTypeIdx]);\n        }));\n}\nexport function areTokenCategoriesNotUsed(lookAheadPaths) {\n    return lookAheadPaths.every((singleAltPaths) => singleAltPaths.every((singlePath) => singlePath.every((token) => token.categoryMatches.length === 0)));\n}\n//# sourceMappingURL=lookahead.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/lib/esm/node_modules/chevrotain/lib/src/parse/grammar/resolver.js

@@ -1,34 +0,0 @@
-import { GAstVisitor as e } from "../../../../../@chevrotain/gast/lib/src/visitor.js";
-import { ParserDefinitionErrorType as t } from "../parser/parser.js";
-//#region ../../node_modules/chevrotain/lib/src/parse/grammar/resolver.js
-function n(e, t) {
-	let n = new r(e, t);
-	return n.resolveRefs(), n.errors;
-}
-var r = class extends e {
-	constructor(e, t) {
-		super(), this.nameToTopRule = e, this.errMsgProvider = t, this.errors = [];
-	}
-	resolveRefs() {
-		Object.values(this.nameToTopRule).forEach((e) => {
-			this.currTopLevel = e, e.accept(this);
-		});
-	}
-	visitNonTerminal(e) {
-		let n = this.nameToTopRule[e.nonTerminalName];
-		if (n) e.referencedRule = n;
-		else {
-			let n = this.errMsgProvider.buildRuleNotFoundError(this.currTopLevel, e);
-			this.errors.push({
-				message: n,
-				type: t.UNRESOLVED_SUBRULE_REF,
-				ruleName: this.currTopLevel.name,
-				unresolvedRefName: e.nonTerminalName
-			});
-		}
-	}
-};
-//#endregion
-export { n as resolveGrammar };
-
-//# sourceMappingURL=resolver.js.map

package/lib/esm/node_modules/chevrotain/lib/src/parse/grammar/resolver.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolver.js","names":[],"sources":["../../../../../../../../../../node_modules/chevrotain/lib/src/parse/grammar/resolver.js"],"sourcesContent":["import { ParserDefinitionErrorType, } from \"../parser/parser.js\";\nimport { GAstVisitor } from \"@chevrotain/gast\";\nexport function resolveGrammar(topLevels, errMsgProvider) {\n    const refResolver = new GastRefResolverVisitor(topLevels, errMsgProvider);\n    refResolver.resolveRefs();\n    return refResolver.errors;\n}\nexport class GastRefResolverVisitor extends GAstVisitor {\n    constructor(nameToTopRule, errMsgProvider) {\n        super();\n        this.nameToTopRule = nameToTopRule;\n        this.errMsgProvider = errMsgProvider;\n        this.errors = [];\n    }\n    resolveRefs() {\n        Object.values(this.nameToTopRule).forEach((prod) => {\n            this.currTopLevel = prod;\n            prod.accept(this);\n        });\n    }\n    visitNonTerminal(node) {\n        const ref = this.nameToTopRule[node.nonTerminalName];\n        if (!ref) {\n            const msg = this.errMsgProvider.buildRuleNotFoundError(this.currTopLevel, node);\n            this.errors.push({\n                message: msg,\n                type: ParserDefinitionErrorType.UNRESOLVED_SUBRULE_REF,\n                ruleName: this.currTopLevel.name,\n                unresolvedRefName: node.nonTerminalName,\n            });\n        }\n        else {\n            node.referencedRule = ref;\n        }\n    }\n}\n//# sourceMappingURL=resolver.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAEA,SAAgB,EAAe,GAAW,GAAgB;CACtD,IAAM,IAAc,IAAI,EAAuB,GAAW,EAAe;CAEzE,OADA,EAAY,aAAa,EAClB,EAAY;;AAEvB,IAAa,IAAb,cAA4C,EAAY;CACpD,YAAY,GAAe,GAAgB;EAIvC,AAHA,OAAO,EACP,KAAK,gBAAgB,GACrB,KAAK,iBAAiB,GACtB,KAAK,SAAS,EAAE;;CAEpB,cAAc;EACV,OAAO,OAAO,KAAK,cAAc,CAAC,SAAS,MAAS;GAEhD,AADA,KAAK,eAAe,GACpB,EAAK,OAAO,KAAK;IACnB;;CAEN,iBAAiB,GAAM;EACnB,IAAM,IAAM,KAAK,cAAc,EAAK;EACpC,IAAK,GAUD,EAAK,iBAAiB;OAVhB;GACN,IAAM,IAAM,KAAK,eAAe,uBAAuB,KAAK,cAAc,EAAK;GAC/E,KAAK,OAAO,KAAK;IACb,SAAS;IACT,MAAM,EAA0B;IAChC,UAAU,KAAK,aAAa;IAC5B,mBAAmB,EAAK;IAC3B,CAAC"}

package/lib/esm/node_modules/chevrotain/lib/src/parse/grammar/rest.js

@@ -1,60 +0,0 @@
-import { Alternation as e, Alternative as t, NonTerminal as n, Option as r, Repetition as i, RepetitionMandatory as a, RepetitionMandatoryWithSeparator as o, RepetitionWithSeparator as s, Terminal as c } from "../../../../../@chevrotain/gast/lib/src/model.js";
-//#region ../../node_modules/chevrotain/lib/src/parse/grammar/rest.js
-var l = class {
-	walk(l, u = []) {
-		l.definition.forEach((d, f) => {
-			let p = l.definition.slice(f + 1);
-			/* istanbul ignore else */
-			if (d instanceof n) this.walkProdRef(d, p, u);
-			else if (d instanceof c) this.walkTerminal(d, p, u);
-			else if (d instanceof t) this.walkFlat(d, p, u);
-			else if (d instanceof r) this.walkOption(d, p, u);
-			else if (d instanceof a) this.walkAtLeastOne(d, p, u);
-			else if (d instanceof o) this.walkAtLeastOneSep(d, p, u);
-			else if (d instanceof s) this.walkManySep(d, p, u);
-			else if (d instanceof i) this.walkMany(d, p, u);
-			else if (d instanceof e) this.walkOr(d, p, u);
-			else throw Error("non exhaustive match");
-		});
-	}
-	walkTerminal(e, t, n) {}
-	walkProdRef(e, t, n) {}
-	walkFlat(e, t, n) {
-		let r = t.concat(n);
-		this.walk(e, r);
-	}
-	walkOption(e, t, n) {
-		let r = t.concat(n);
-		this.walk(e, r);
-	}
-	walkAtLeastOne(e, t, n) {
-		let i = [new r({ definition: e.definition })].concat(t, n);
-		this.walk(e, i);
-	}
-	walkAtLeastOneSep(e, t, n) {
-		let r = u(e, t, n);
-		this.walk(e, r);
-	}
-	walkMany(e, t, n) {
-		let i = [new r({ definition: e.definition })].concat(t, n);
-		this.walk(e, i);
-	}
-	walkManySep(e, t, n) {
-		let r = u(e, t, n);
-		this.walk(e, r);
-	}
-	walkOr(e, n, r) {
-		let i = n.concat(r);
-		e.definition.forEach((e) => {
-			let n = new t({ definition: [e] });
-			this.walk(n, i);
-		});
-	}
-};
-function u(e, t, n) {
-	return [new r({ definition: [new c({ terminalType: e.separator })].concat(e.definition) })].concat(t, n);
-}
-//#endregion
-export { l as RestWalker };
-
-//# sourceMappingURL=rest.js.map

package/lib/esm/node_modules/chevrotain/lib/src/parse/grammar/rest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rest.js","names":[],"sources":["../../../../../../../../../../node_modules/chevrotain/lib/src/parse/grammar/rest.js"],"sourcesContent":["import { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Terminal, } from \"@chevrotain/gast\";\n/**\n *  A Grammar Walker that computes the \"remaining\" grammar \"after\" a productions in the grammar.\n */\nexport class RestWalker {\n    walk(prod, prevRest = []) {\n        prod.definition.forEach((subProd, index) => {\n            const currRest = prod.definition.slice(index + 1);\n            /* istanbul ignore else */\n            if (subProd instanceof NonTerminal) {\n                this.walkProdRef(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof Terminal) {\n                this.walkTerminal(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof Alternative) {\n                this.walkFlat(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof Option) {\n                this.walkOption(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof RepetitionMandatory) {\n                this.walkAtLeastOne(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof RepetitionMandatoryWithSeparator) {\n                this.walkAtLeastOneSep(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof RepetitionWithSeparator) {\n                this.walkManySep(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof Repetition) {\n                this.walkMany(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof Alternation) {\n                this.walkOr(subProd, currRest, prevRest);\n            }\n            else {\n                throw Error(\"non exhaustive match\");\n            }\n        });\n    }\n    walkTerminal(terminal, currRest, prevRest) { }\n    walkProdRef(refProd, currRest, prevRest) { }\n    walkFlat(flatProd, currRest, prevRest) {\n        // ABCDEF => after the D the rest is EF\n        const fullOrRest = currRest.concat(prevRest);\n        this.walk(flatProd, fullOrRest);\n    }\n    walkOption(optionProd, currRest, prevRest) {\n        // ABC(DE)?F => after the (DE)? the rest is F\n        const fullOrRest = currRest.concat(prevRest);\n        this.walk(optionProd, fullOrRest);\n    }\n    walkAtLeastOne(atLeastOneProd, currRest, prevRest) {\n        // ABC(DE)+F => after the (DE)+ the rest is (DE)?F\n        const fullAtLeastOneRest = [\n            new Option({ definition: atLeastOneProd.definition }),\n        ].concat(currRest, prevRest);\n        this.walk(atLeastOneProd, fullAtLeastOneRest);\n    }\n    walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) {\n        // ABC DE(,DE)* F => after the (,DE)+ the rest is (,DE)?F\n        const fullAtLeastOneSepRest = restForRepetitionWithSeparator(atLeastOneSepProd, currRest, prevRest);\n        this.walk(atLeastOneSepProd, fullAtLeastOneSepRest);\n    }\n    walkMany(manyProd, currRest, prevRest) {\n        // ABC(DE)*F => after the (DE)* the rest is (DE)?F\n        const fullManyRest = [\n            new Option({ definition: manyProd.definition }),\n        ].concat(currRest, prevRest);\n        this.walk(manyProd, fullManyRest);\n    }\n    walkManySep(manySepProd, currRest, prevRest) {\n        // ABC (DE(,DE)*)? F => after the (,DE)* the rest is (,DE)?F\n        const fullManySepRest = restForRepetitionWithSeparator(manySepProd, currRest, prevRest);\n        this.walk(manySepProd, fullManySepRest);\n    }\n    walkOr(orProd, currRest, prevRest) {\n        // ABC(D|E|F)G => when finding the (D|E|F) the rest is G\n        const fullOrRest = currRest.concat(prevRest);\n        // walk all different alternatives\n        orProd.definition.forEach((alt) => {\n            // wrapping each alternative in a single definition wrapper\n            // to avoid errors in computing the rest of that alternative in the invocation to computeInProdFollows\n            // (otherwise for OR([alt1,alt2]) alt2 will be considered in 'rest' of alt1\n            const prodWrapper = new Alternative({ definition: [alt] });\n            this.walk(prodWrapper, fullOrRest);\n        });\n    }\n}\nfunction restForRepetitionWithSeparator(repSepProd, currRest, prevRest) {\n    const repSepRest = [\n        new Option({\n            definition: [\n                new Terminal({ terminalType: repSepProd.separator }),\n            ].concat(repSepProd.definition),\n        }),\n    ];\n    const fullRepSepRest = repSepRest.concat(currRest, prevRest);\n    return fullRepSepRest;\n}\n//# sourceMappingURL=rest.js.map"],"x_google_ignoreList":[0],"mappings":";;AAIA,IAAa,IAAb,MAAwB;CACpB,KAAK,GAAM,IAAW,EAAE,EAAE;EACtB,EAAK,WAAW,SAAS,GAAS,MAAU;GACxC,IAAM,IAAW,EAAK,WAAW,MAAM,IAAQ,EAAE;;GAEjD,IAAI,aAAmB,GACnB,KAAK,YAAY,GAAS,GAAU,EAAS;QAE5C,IAAI,aAAmB,GACxB,KAAK,aAAa,GAAS,GAAU,EAAS;QAE7C,IAAI,aAAmB,GACxB,KAAK,SAAS,GAAS,GAAU,EAAS;QAEzC,IAAI,aAAmB,GACxB,KAAK,WAAW,GAAS,GAAU,EAAS;QAE3C,IAAI,aAAmB,GACxB,KAAK,eAAe,GAAS,GAAU,EAAS;QAE/C,IAAI,aAAmB,GACxB,KAAK,kBAAkB,GAAS,GAAU,EAAS;QAElD,IAAI,aAAmB,GACxB,KAAK,YAAY,GAAS,GAAU,EAAS;QAE5C,IAAI,aAAmB,GACxB,KAAK,SAAS,GAAS,GAAU,EAAS;QAEzC,IAAI,aAAmB,GACxB,KAAK,OAAO,GAAS,GAAU,EAAS;QAGxC,MAAM,MAAM,uBAAuB;IAEzC;;CAEN,aAAa,GAAU,GAAU,GAAU;CAC3C,YAAY,GAAS,GAAU,GAAU;CACzC,SAAS,GAAU,GAAU,GAAU;EAEnC,IAAM,IAAa,EAAS,OAAO,EAAS;EAC5C,KAAK,KAAK,GAAU,EAAW;;CAEnC,WAAW,GAAY,GAAU,GAAU;EAEvC,IAAM,IAAa,EAAS,OAAO,EAAS;EAC5C,KAAK,KAAK,GAAY,EAAW;;CAErC,eAAe,GAAgB,GAAU,GAAU;EAE/C,IAAM,IAAqB,CACvB,IAAI,EAAO,EAAE,YAAY,EAAe,YAAY,CAAC,CACxD,CAAC,OAAO,GAAU,EAAS;EAC5B,KAAK,KAAK,GAAgB,EAAmB;;CAEjD,kBAAkB,GAAmB,GAAU,GAAU;EAErD,IAAM,IAAwB,EAA+B,GAAmB,GAAU,EAAS;EACnG,KAAK,KAAK,GAAmB,EAAsB;;CAEvD,SAAS,GAAU,GAAU,GAAU;EAEnC,IAAM,IAAe,CACjB,IAAI,EAAO,EAAE,YAAY,EAAS,YAAY,CAAC,CAClD,CAAC,OAAO,GAAU,EAAS;EAC5B,KAAK,KAAK,GAAU,EAAa;;CAErC,YAAY,GAAa,GAAU,GAAU;EAEzC,IAAM,IAAkB,EAA+B,GAAa,GAAU,EAAS;EACvF,KAAK,KAAK,GAAa,EAAgB;;CAE3C,OAAO,GAAQ,GAAU,GAAU;EAE/B,IAAM,IAAa,EAAS,OAAO,EAAS;EAE5C,EAAO,WAAW,SAAS,MAAQ;GAI/B,IAAM,IAAc,IAAI,EAAY,EAAE,YAAY,CAAC,EAAI,EAAE,CAAC;GAC1D,KAAK,KAAK,GAAa,EAAW;IACpC;;;AAGV,SAAS,EAA+B,GAAY,GAAU,GAAU;CASpE,OADuB,CANnB,IAAI,EAAO,EACP,YAAY,CACR,IAAI,EAAS,EAAE,cAAc,EAAW,WAAW,CAAC,CACvD,CAAC,OAAO,EAAW,WAAW,EAClC,CAAC,CAE2B,CAAC,OAAO,GAAU,EAC9B"}

package/lib/esm/node_modules/chevrotain/lib/src/parse/parser/parser.js

@@ -1,118 +0,0 @@
-import { toFastProperties as e } from "../../../../../@chevrotain/utils/lib/src/to-fast-properties.js";
-import { computeAllProdsFollows as t } from "../grammar/follow.js";
-import { EOF as n, createTokenInstance as r } from "../../scan/tokens_public.js";
-import { defaultGrammarValidatorErrorProvider as i, defaultParserErrorProvider as a } from "../errors_public.js";
-import { validateLookahead as o } from "../grammar/checks.js";
-import { resolveGrammar as s, validateGrammar as c } from "../grammar/gast/gast_resolver_public.js";
-import { Recoverable as l } from "./traits/recoverable.js";
-import { LooksAhead as u } from "./traits/looksahead.js";
-import { TreeBuilder as d } from "./traits/tree_builder.js";
-import { LexerAdapter as f } from "./traits/lexer_adapter.js";
-import { RecognizerApi as p } from "./traits/recognizer_api.js";
-import { RecognizerEngine as m } from "./traits/recognizer_engine.js";
-import { ErrorHandler as h } from "./traits/error_handler.js";
-import { GastRecorder as g } from "./traits/gast_recorder.js";
-import { PerformanceTracer as _ } from "./traits/perf_tracer.js";
-import { applyMixins as v } from "./utils/apply_mixins.js";
-//#region ../../node_modules/chevrotain/lib/src/parse/parser/parser.js
-var y = r(n, "", NaN, NaN, NaN, NaN, NaN, NaN);
-Object.freeze(y);
-var b = Object.freeze({
-	recoveryEnabled: !1,
-	maxLookahead: 3,
-	dynamicTokensEnabled: !1,
-	outputCst: !0,
-	errorMessageProvider: a,
-	nodeLocationTracking: "none",
-	traceInitPerf: !1,
-	skipValidations: !1
-}), x = Object.freeze({
-	recoveryValueFunc: () => void 0,
-	resyncEnabled: !0
-}), S;
-(function(e) {
-	e[e.INVALID_RULE_NAME = 0] = "INVALID_RULE_NAME", e[e.DUPLICATE_RULE_NAME = 1] = "DUPLICATE_RULE_NAME", e[e.INVALID_RULE_OVERRIDE = 2] = "INVALID_RULE_OVERRIDE", e[e.DUPLICATE_PRODUCTIONS = 3] = "DUPLICATE_PRODUCTIONS", e[e.UNRESOLVED_SUBRULE_REF = 4] = "UNRESOLVED_SUBRULE_REF", e[e.LEFT_RECURSION = 5] = "LEFT_RECURSION", e[e.NONE_LAST_EMPTY_ALT = 6] = "NONE_LAST_EMPTY_ALT", e[e.AMBIGUOUS_ALTS = 7] = "AMBIGUOUS_ALTS", e[e.CONFLICT_TOKENS_RULES_NAMESPACE = 8] = "CONFLICT_TOKENS_RULES_NAMESPACE", e[e.INVALID_TOKEN_NAME = 9] = "INVALID_TOKEN_NAME", e[e.NO_NON_EMPTY_LOOKAHEAD = 10] = "NO_NON_EMPTY_LOOKAHEAD", e[e.AMBIGUOUS_PREFIX_ALTS = 11] = "AMBIGUOUS_PREFIX_ALTS", e[e.TOO_MANY_ALTS = 12] = "TOO_MANY_ALTS", e[e.CUSTOM_LOOKAHEAD_VALIDATION = 13] = "CUSTOM_LOOKAHEAD_VALIDATION";
-})(S ||= {});
-function C(e = void 0) {
-	return function() {
-		return e;
-	};
-}
-var w = class n {
-	static performSelfAnalysis(e) {
-		throw Error("The **static** `performSelfAnalysis` method has been deprecated.	\nUse the **instance** method with the same name instead.");
-	}
-	performSelfAnalysis() {
-		this.TRACE_INIT("performSelfAnalysis", () => {
-			let r;
-			this.selfAnalysisDone = !0;
-			let a = this.className;
-			this.TRACE_INIT("toFastProps", () => {
-				e(this);
-			}), this.TRACE_INIT("Grammar Recording", () => {
-				try {
-					this.enableRecording(), this.definedRulesNames.forEach((e) => {
-						let t = this[e].originalGrammarAction, n;
-						this.TRACE_INIT(`${e} Rule`, () => {
-							n = this.topLevelRuleRecord(e, t);
-						}), this.gastProductionsCache[e] = n;
-					});
-				} finally {
-					this.disableRecording();
-				}
-			});
-			let l = [];
-			if (this.TRACE_INIT("Grammar Resolving", () => {
-				l = s({ rules: Object.values(this.gastProductionsCache) }), this.definitionErrors = this.definitionErrors.concat(l);
-			}), this.TRACE_INIT("Grammar Validations", () => {
-				if (l.length === 0 && this.skipValidations === !1) {
-					let e = c({
-						rules: Object.values(this.gastProductionsCache),
-						tokenTypes: Object.values(this.tokensMap),
-						errMsgProvider: i,
-						grammarName: a
-					}), t = o({
-						lookaheadStrategy: this.lookaheadStrategy,
-						rules: Object.values(this.gastProductionsCache),
-						tokenTypes: Object.values(this.tokensMap),
-						grammarName: a
-					});
-					this.definitionErrors = this.definitionErrors.concat(e, t);
-				}
-			}), this.definitionErrors.length === 0 && (this.recoveryEnabled && this.TRACE_INIT("computeAllProdsFollows", () => {
-				let e = t(Object.values(this.gastProductionsCache));
-				this.resyncFollows = e;
-			}), this.TRACE_INIT("ComputeLookaheadFunctions", () => {
-				var e, t;
-				(t = (e = this.lookaheadStrategy).initialize) == null || t.call(e, { rules: Object.values(this.gastProductionsCache) }), this.preComputeLookaheadFunctions(Object.values(this.gastProductionsCache));
-			})), !n.DEFER_DEFINITION_ERRORS_HANDLING && this.definitionErrors.length !== 0) throw r = this.definitionErrors.map((e) => e.message), Error(`Parser Definition Errors detected:\n ${r.join("\n-------------------------------\n")}`);
-		});
-	}
-	constructor(e, t) {
-		this.definitionErrors = [], this.selfAnalysisDone = !1;
-		let n = this;
-		if (n.initErrorHandler(t), n.initLexerAdapter(), n.initLooksAhead(t), n.initRecognizerEngine(e, t), n.initRecoverable(t), n.initTreeBuilder(t), n.initGastRecorder(t), n.initPerformanceTracer(t), Object.hasOwn(t, "ignoredIssues")) throw Error("The <ignoredIssues> IParserConfig property has been deprecated.\n	Please use the <IGNORE_AMBIGUITIES> flag on the relevant DSL method instead.\n	See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES\n	For further details.");
-		this.skipValidations = Object.hasOwn(t, "skipValidations") ? t.skipValidations : b.skipValidations;
-	}
-};
-w.DEFER_DEFINITION_ERRORS_HANDLING = !1, v(w, [
-	l,
-	u,
-	d,
-	f,
-	m,
-	p,
-	h,
-	g,
-	_
-]);
-var T = class extends w {
-	constructor(e, t = b) {
-		let n = Object.assign({}, t);
-		n.outputCst = !1, super(e, n);
-	}
-};
-//#endregion
-export { b as DEFAULT_PARSER_CONFIG, x as DEFAULT_RULE_CONFIG, C as EMPTY_ALT, y as END_OF_FILE, T as EmbeddedActionsParser, S as ParserDefinitionErrorType };
-
-//# sourceMappingURL=parser.js.map

package/lib/esm/node_modules/chevrotain/lib/src/parse/parser/parser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parser.js","names":[],"sources":["../../../../../../../../../../node_modules/chevrotain/lib/src/parse/parser/parser.js"],"sourcesContent":["import { toFastProperties } from \"@chevrotain/utils\";\nimport { computeAllProdsFollows } from \"../grammar/follow.js\";\nimport { createTokenInstance, EOF } from \"../../scan/tokens_public.js\";\nimport { defaultGrammarValidatorErrorProvider, defaultParserErrorProvider, } from \"../errors_public.js\";\nimport { resolveGrammar, validateGrammar, } from \"../grammar/gast/gast_resolver_public.js\";\nimport { Recoverable } from \"./traits/recoverable.js\";\nimport { LooksAhead } from \"./traits/looksahead.js\";\nimport { TreeBuilder } from \"./traits/tree_builder.js\";\nimport { LexerAdapter } from \"./traits/lexer_adapter.js\";\nimport { RecognizerApi } from \"./traits/recognizer_api.js\";\nimport { RecognizerEngine } from \"./traits/recognizer_engine.js\";\nimport { ErrorHandler } from \"./traits/error_handler.js\";\nimport { GastRecorder } from \"./traits/gast_recorder.js\";\nimport { PerformanceTracer } from \"./traits/perf_tracer.js\";\nimport { applyMixins } from \"./utils/apply_mixins.js\";\nimport { validateLookahead } from \"../grammar/checks.js\";\nexport const END_OF_FILE = createTokenInstance(EOF, \"\", NaN, NaN, NaN, NaN, NaN, NaN);\nObject.freeze(END_OF_FILE);\nexport const DEFAULT_PARSER_CONFIG = Object.freeze({\n    recoveryEnabled: false,\n    maxLookahead: 3,\n    dynamicTokensEnabled: false,\n    outputCst: true,\n    errorMessageProvider: defaultParserErrorProvider,\n    nodeLocationTracking: \"none\",\n    traceInitPerf: false,\n    skipValidations: false,\n});\nexport const DEFAULT_RULE_CONFIG = Object.freeze({\n    recoveryValueFunc: () => undefined,\n    resyncEnabled: true,\n});\nexport var ParserDefinitionErrorType;\n(function (ParserDefinitionErrorType) {\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"INVALID_RULE_NAME\"] = 0] = \"INVALID_RULE_NAME\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"DUPLICATE_RULE_NAME\"] = 1] = \"DUPLICATE_RULE_NAME\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"INVALID_RULE_OVERRIDE\"] = 2] = \"INVALID_RULE_OVERRIDE\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"DUPLICATE_PRODUCTIONS\"] = 3] = \"DUPLICATE_PRODUCTIONS\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"UNRESOLVED_SUBRULE_REF\"] = 4] = \"UNRESOLVED_SUBRULE_REF\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"LEFT_RECURSION\"] = 5] = \"LEFT_RECURSION\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"NONE_LAST_EMPTY_ALT\"] = 6] = \"NONE_LAST_EMPTY_ALT\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"AMBIGUOUS_ALTS\"] = 7] = \"AMBIGUOUS_ALTS\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"CONFLICT_TOKENS_RULES_NAMESPACE\"] = 8] = \"CONFLICT_TOKENS_RULES_NAMESPACE\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"INVALID_TOKEN_NAME\"] = 9] = \"INVALID_TOKEN_NAME\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"NO_NON_EMPTY_LOOKAHEAD\"] = 10] = \"NO_NON_EMPTY_LOOKAHEAD\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"AMBIGUOUS_PREFIX_ALTS\"] = 11] = \"AMBIGUOUS_PREFIX_ALTS\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"TOO_MANY_ALTS\"] = 12] = \"TOO_MANY_ALTS\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"CUSTOM_LOOKAHEAD_VALIDATION\"] = 13] = \"CUSTOM_LOOKAHEAD_VALIDATION\";\n})(ParserDefinitionErrorType || (ParserDefinitionErrorType = {}));\nexport function EMPTY_ALT(value = undefined) {\n    return function () {\n        return value;\n    };\n}\nexport class Parser {\n    /**\n     *  @deprecated use the **instance** method with the same name instead\n     */\n    static performSelfAnalysis(parserInstance) {\n        throw Error(\"The **static** `performSelfAnalysis` method has been deprecated.\" +\n            \"\\t\\nUse the **instance** method with the same name instead.\");\n    }\n    performSelfAnalysis() {\n        this.TRACE_INIT(\"performSelfAnalysis\", () => {\n            let defErrorsMsgs;\n            this.selfAnalysisDone = true;\n            const className = this.className;\n            this.TRACE_INIT(\"toFastProps\", () => {\n                // Without this voodoo magic the parser would be x3-x4 slower\n                // It seems it is better to invoke `toFastProperties` **before**\n                // Any manipulations of the `this` object done during the recording phase.\n                toFastProperties(this);\n            });\n            this.TRACE_INIT(\"Grammar Recording\", () => {\n                try {\n                    this.enableRecording();\n                    // Building the GAST\n                    this.definedRulesNames.forEach((currRuleName) => {\n                        const wrappedRule = this[currRuleName];\n                        const originalGrammarAction = wrappedRule[\"originalGrammarAction\"];\n                        let recordedRuleGast;\n                        this.TRACE_INIT(`${currRuleName} Rule`, () => {\n                            recordedRuleGast = this.topLevelRuleRecord(currRuleName, originalGrammarAction);\n                        });\n                        this.gastProductionsCache[currRuleName] = recordedRuleGast;\n                    });\n                }\n                finally {\n                    this.disableRecording();\n                }\n            });\n            let resolverErrors = [];\n            this.TRACE_INIT(\"Grammar Resolving\", () => {\n                resolverErrors = resolveGrammar({\n                    rules: Object.values(this.gastProductionsCache),\n                });\n                this.definitionErrors = this.definitionErrors.concat(resolverErrors);\n            });\n            this.TRACE_INIT(\"Grammar Validations\", () => {\n                // only perform additional grammar validations IFF no resolving errors have occurred.\n                // as unresolved grammar may lead to unhandled runtime exceptions in the follow up validations.\n                if (resolverErrors.length === 0 && this.skipValidations === false) {\n                    const validationErrors = validateGrammar({\n                        rules: Object.values(this.gastProductionsCache),\n                        tokenTypes: Object.values(this.tokensMap),\n                        errMsgProvider: defaultGrammarValidatorErrorProvider,\n                        grammarName: className,\n                    });\n                    const lookaheadValidationErrors = validateLookahead({\n                        lookaheadStrategy: this.lookaheadStrategy,\n                        rules: Object.values(this.gastProductionsCache),\n                        tokenTypes: Object.values(this.tokensMap),\n                        grammarName: className,\n                    });\n                    this.definitionErrors = this.definitionErrors.concat(validationErrors, lookaheadValidationErrors);\n                }\n            });\n            // this analysis may fail if the grammar is not perfectly valid\n            if (this.definitionErrors.length === 0) {\n                // The results of these computations are not needed unless error recovery is enabled.\n                if (this.recoveryEnabled) {\n                    this.TRACE_INIT(\"computeAllProdsFollows\", () => {\n                        const allFollows = computeAllProdsFollows(Object.values(this.gastProductionsCache));\n                        this.resyncFollows = allFollows;\n                    });\n                }\n                this.TRACE_INIT(\"ComputeLookaheadFunctions\", () => {\n                    var _a, _b;\n                    (_b = (_a = this.lookaheadStrategy).initialize) === null || _b === void 0 ? void 0 : _b.call(_a, {\n                        rules: Object.values(this.gastProductionsCache),\n                    });\n                    this.preComputeLookaheadFunctions(Object.values(this.gastProductionsCache));\n                });\n            }\n            if (!Parser.DEFER_DEFINITION_ERRORS_HANDLING &&\n                this.definitionErrors.length !== 0) {\n                defErrorsMsgs = this.definitionErrors.map((defError) => defError.message);\n                throw new Error(`Parser Definition Errors detected:\\n ${defErrorsMsgs.join(\"\\n-------------------------------\\n\")}`);\n            }\n        });\n    }\n    constructor(tokenVocabulary, config) {\n        this.definitionErrors = [];\n        this.selfAnalysisDone = false;\n        const that = this;\n        that.initErrorHandler(config);\n        that.initLexerAdapter();\n        that.initLooksAhead(config);\n        that.initRecognizerEngine(tokenVocabulary, config);\n        that.initRecoverable(config);\n        that.initTreeBuilder(config);\n        that.initGastRecorder(config);\n        that.initPerformanceTracer(config);\n        if (Object.hasOwn(config, \"ignoredIssues\")) {\n            throw new Error(\"The <ignoredIssues> IParserConfig property has been deprecated.\\n\\t\" +\n                \"Please use the <IGNORE_AMBIGUITIES> flag on the relevant DSL method instead.\\n\\t\" +\n                \"See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES\\n\\t\" +\n                \"For further details.\");\n        }\n        this.skipValidations = Object.hasOwn(config, \"skipValidations\")\n            ? config.skipValidations // casting assumes the end user passing the correct type\n            : DEFAULT_PARSER_CONFIG.skipValidations;\n    }\n}\n// Set this flag to true if you don't want the Parser to throw error when problems in it's definition are detected.\n// (normally during the parser's constructor).\n// This is a design time flag, it will not affect the runtime error handling of the parser, just design time errors,\n// for example: duplicate rule names, referencing an unresolved subrule, etc...\n// This flag should not be enabled during normal usage, it is used in special situations, for example when\n// needing to display the parser definition errors in some GUI(online playground).\nParser.DEFER_DEFINITION_ERRORS_HANDLING = false;\napplyMixins(Parser, [\n    Recoverable,\n    LooksAhead,\n    TreeBuilder,\n    LexerAdapter,\n    RecognizerEngine,\n    RecognizerApi,\n    ErrorHandler,\n    GastRecorder,\n    PerformanceTracer,\n]);\nexport class CstParser extends Parser {\n    constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {\n        const configClone = Object.assign({}, config);\n        configClone.outputCst = true;\n        super(tokenVocabulary, configClone);\n    }\n}\nexport class EmbeddedActionsParser extends Parser {\n    constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {\n        const configClone = Object.assign({}, config);\n        configClone.outputCst = false;\n        super(tokenVocabulary, configClone);\n    }\n}\n//# sourceMappingURL=parser.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/lib/esm/node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js

@@ -1,50 +0,0 @@
-import { getLookaheadPathsForOptionalProd as e, getLookaheadPathsForOr as t } from "../../grammar/lookahead.js";
-import { EarlyExitException as n, NoViableAltException as r, isRecognitionException as i } from "../../exceptions_public.js";
-import { DEFAULT_PARSER_CONFIG as a } from "../parser.js";
-//#region ../../node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js
-var o = class {
-	initErrorHandler(e) {
-		this._errors = [], this.errorMessageProvider = Object.hasOwn(e, "errorMessageProvider") ? e.errorMessageProvider : a.errorMessageProvider;
-	}
-	SAVE_ERROR(e) {
-		if (i(e)) return e.context = {
-			ruleStack: this.getHumanReadableRuleStack(),
-			ruleOccurrenceStack: this.RULE_OCCURRENCE_STACK.slice(0, this.RULE_OCCURRENCE_STACK_IDX + 1)
-		}, this._errors.push(e), e;
-		throw Error("Trying to save an Error which is not a RecognitionException");
-	}
-	get errors() {
-		return [...this._errors];
-	}
-	set errors(e) {
-		this._errors = e;
-	}
-	raiseEarlyExitException(t, r, i) {
-		let a = this.getCurrRuleFullName(), o = this.getGAstProductions()[a], s = e(t, o, r, this.maxLookahead)[0], c = [];
-		for (let e = 1; e <= this.maxLookahead; e++) c.push(this.LA(e));
-		let l = this.errorMessageProvider.buildEarlyExitMessage({
-			expectedIterationPaths: s,
-			actual: c,
-			previous: this.LA(0),
-			customUserDescription: i,
-			ruleName: a
-		});
-		throw this.SAVE_ERROR(new n(l, this.LA(1), this.LA(0)));
-	}
-	raiseNoAltException(e, n) {
-		let i = this.getCurrRuleFullName(), a = this.getGAstProductions()[i], o = t(e, a, this.maxLookahead), s = [];
-		for (let e = 1; e <= this.maxLookahead; e++) s.push(this.LA(e));
-		let c = this.LA(0), l = this.errorMessageProvider.buildNoViableAltMessage({
-			expectedPathsPerAlt: o,
-			actual: s,
-			previous: c,
-			customUserDescription: n,
-			ruleName: this.getCurrRuleFullName()
-		});
-		throw this.SAVE_ERROR(new r(l, this.LA(1), c));
-	}
-};
-//#endregion
-export { o as ErrorHandler };
-
-//# sourceMappingURL=error_handler.js.map

package/lib/esm/node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"error_handler.js","names":[],"sources":["../../../../../../../../../../../node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js"],"sourcesContent":["import { EarlyExitException, isRecognitionException, NoViableAltException, } from \"../../exceptions_public.js\";\nimport { getLookaheadPathsForOptionalProd, getLookaheadPathsForOr, } from \"../../grammar/lookahead.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\n/**\n * Trait responsible for runtime parsing errors.\n */\nexport class ErrorHandler {\n    initErrorHandler(config) {\n        this._errors = [];\n        this.errorMessageProvider = Object.hasOwn(config, \"errorMessageProvider\")\n            ? config.errorMessageProvider // assumes end user provides the correct config value/type\n            : DEFAULT_PARSER_CONFIG.errorMessageProvider;\n    }\n    SAVE_ERROR(error) {\n        if (isRecognitionException(error)) {\n            error.context = {\n                ruleStack: this.getHumanReadableRuleStack(),\n                ruleOccurrenceStack: this.RULE_OCCURRENCE_STACK.slice(0, this.RULE_OCCURRENCE_STACK_IDX + 1),\n            };\n            this._errors.push(error);\n            return error;\n        }\n        else {\n            throw Error(\"Trying to save an Error which is not a RecognitionException\");\n        }\n    }\n    get errors() {\n        return [...this._errors];\n    }\n    set errors(newErrors) {\n        this._errors = newErrors;\n    }\n    // TODO: consider caching the error message computed information\n    raiseEarlyExitException(occurrence, prodType, userDefinedErrMsg) {\n        const ruleName = this.getCurrRuleFullName();\n        const ruleGrammar = this.getGAstProductions()[ruleName];\n        const lookAheadPathsPerAlternative = getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, this.maxLookahead);\n        const insideProdPaths = lookAheadPathsPerAlternative[0];\n        const actualTokens = [];\n        for (let i = 1; i <= this.maxLookahead; i++) {\n            actualTokens.push(this.LA(i));\n        }\n        const msg = this.errorMessageProvider.buildEarlyExitMessage({\n            expectedIterationPaths: insideProdPaths,\n            actual: actualTokens,\n            previous: this.LA(0),\n            customUserDescription: userDefinedErrMsg,\n            ruleName: ruleName,\n        });\n        throw this.SAVE_ERROR(new EarlyExitException(msg, this.LA(1), this.LA(0)));\n    }\n    // TODO: consider caching the error message computed information\n    raiseNoAltException(occurrence, errMsgTypes) {\n        const ruleName = this.getCurrRuleFullName();\n        const ruleGrammar = this.getGAstProductions()[ruleName];\n        // TODO: getLookaheadPathsForOr can be slow for large enough maxLookahead and certain grammars, consider caching ?\n        const lookAheadPathsPerAlternative = getLookaheadPathsForOr(occurrence, ruleGrammar, this.maxLookahead);\n        const actualTokens = [];\n        for (let i = 1; i <= this.maxLookahead; i++) {\n            actualTokens.push(this.LA(i));\n        }\n        const previousToken = this.LA(0);\n        const errMsg = this.errorMessageProvider.buildNoViableAltMessage({\n            expectedPathsPerAlt: lookAheadPathsPerAlternative,\n            actual: actualTokens,\n            previous: previousToken,\n            customUserDescription: errMsgTypes,\n            ruleName: this.getCurrRuleFullName(),\n        });\n        throw this.SAVE_ERROR(new NoViableAltException(errMsg, this.LA(1), previousToken));\n    }\n}\n//# sourceMappingURL=error_handler.js.map"],"x_google_ignoreList":[0],"mappings":";;;;AAMA,IAAa,IAAb,MAA0B;CACtB,iBAAiB,GAAQ;EAErB,AADA,KAAK,UAAU,EAAE,EACjB,KAAK,uBAAuB,OAAO,OAAO,GAAQ,uBAAuB,GACnE,EAAO,uBACP,EAAsB;;CAEhC,WAAW,GAAO;EACd,IAAI,EAAuB,EAAM,EAM7B,OALA,EAAM,UAAU;GACZ,WAAW,KAAK,2BAA2B;GAC3C,qBAAqB,KAAK,sBAAsB,MAAM,GAAG,KAAK,4BAA4B,EAAE;GAC/F,EACD,KAAK,QAAQ,KAAK,EAAM,EACjB;EAGP,MAAM,MAAM,8DAA8D;;CAGlF,IAAI,SAAS;EACT,OAAO,CAAC,GAAG,KAAK,QAAQ;;CAE5B,IAAI,OAAO,GAAW;EAClB,KAAK,UAAU;;CAGnB,wBAAwB,GAAY,GAAU,GAAmB;EAC7D,IAAM,IAAW,KAAK,qBAAqB,EACrC,IAAc,KAAK,oBAAoB,CAAC,IAExC,IAD+B,EAAiC,GAAY,GAAa,GAAU,KAAK,aAC1D,CAAC,IAC/C,IAAe,EAAE;EACvB,KAAK,IAAI,IAAI,GAAG,KAAK,KAAK,cAAc,KACpC,EAAa,KAAK,KAAK,GAAG,EAAE,CAAC;EAEjC,IAAM,IAAM,KAAK,qBAAqB,sBAAsB;GACxD,wBAAwB;GACxB,QAAQ;GACR,UAAU,KAAK,GAAG,EAAE;GACpB,uBAAuB;GACb;GACb,CAAC;EACF,MAAM,KAAK,WAAW,IAAI,EAAmB,GAAK,KAAK,GAAG,EAAE,EAAE,KAAK,GAAG,EAAE,CAAC,CAAC;;CAG9E,oBAAoB,GAAY,GAAa;EACzC,IAAM,IAAW,KAAK,qBAAqB,EACrC,IAAc,KAAK,oBAAoB,CAAC,IAExC,IAA+B,EAAuB,GAAY,GAAa,KAAK,aAAa,EACjG,IAAe,EAAE;EACvB,KAAK,IAAI,IAAI,GAAG,KAAK,KAAK,cAAc,KACpC,EAAa,KAAK,KAAK,GAAG,EAAE,CAAC;EAEjC,IAAM,IAAgB,KAAK,GAAG,EAAE,EAC1B,IAAS,KAAK,qBAAqB,wBAAwB;GAC7D,qBAAqB;GACrB,QAAQ;GACR,UAAU;GACV,uBAAuB;GACvB,UAAU,KAAK,qBAAqB;GACvC,CAAC;EACF,MAAM,KAAK,WAAW,IAAI,EAAqB,GAAQ,KAAK,GAAG,EAAE,EAAE,EAAc,CAAC"}

package/lib/esm/node_modules/chevrotain/lib/src/parse/parser/traits/gast_recorder.js

@@ -1,170 +0,0 @@
-import { Alternation as e, Alternative as t, NonTerminal as n, Option as r, Repetition as i, RepetitionMandatory as a, RepetitionMandatoryWithSeparator as o, RepetitionWithSeparator as s, Rule as c, Terminal as l } from "../../../../../../@chevrotain/gast/lib/src/model.js";
-import { augmentTokenTypes as u, hasShortKeyProperty as d } from "../../../scan/tokens.js";
-import { Lexer as f } from "../../../scan/lexer_public.js";
-import { createToken as p, createTokenInstance as m } from "../../../scan/tokens_public.js";
-import "../../grammar/keys.js";
-import { END_OF_FILE as h } from "../parser.js";
-//#region ../../node_modules/chevrotain/lib/src/parse/parser/traits/gast_recorder.js
-var g = { description: "This Object indicates the Parser is during Recording Phase" };
-Object.freeze(g);
-var _ = !0, v = 2 ** 8 - 1, y = p({
-	name: "RECORDING_PHASE_TOKEN",
-	pattern: f.NA
-});
-u([y]);
-var b = m(y, "This IToken indicates the Parser is in Recording Phase\n	See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details", -1, -1, -1, -1, -1, -1);
-Object.freeze(b);
-var x = {
-	name: "This CSTNode indicates the Parser is in Recording Phase\n	See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details",
-	children: {}
-}, S = class {
-	initGastRecorder(e) {
-		this.recordingProdStack = [], this.RECORDING_PHASE = !1;
-	}
-	enableRecording() {
-		this.RECORDING_PHASE = !0, this.TRACE_INIT("Enable Recording", () => {
-			for (let e = 0; e < 10; e++) {
-				let t = e > 0 ? e : "";
-				this[`CONSUME${t}`] = function(t, n) {
-					return this.consumeInternalRecord(t, e, n);
-				}, this[`SUBRULE${t}`] = function(t, n) {
-					return this.subruleInternalRecord(t, e, n);
-				}, this[`OPTION${t}`] = function(t) {
-					return this.optionInternalRecord(t, e);
-				}, this[`OR${t}`] = function(t) {
-					return this.orInternalRecord(t, e);
-				}, this[`MANY${t}`] = function(t) {
-					this.manyInternalRecord(e, t);
-				}, this[`MANY_SEP${t}`] = function(t) {
-					this.manySepFirstInternalRecord(e, t);
-				}, this[`AT_LEAST_ONE${t}`] = function(t) {
-					this.atLeastOneInternalRecord(e, t);
-				}, this[`AT_LEAST_ONE_SEP${t}`] = function(t) {
-					this.atLeastOneSepFirstInternalRecord(e, t);
-				};
-			}
-			this.consume = function(e, t, n) {
-				return this.consumeInternalRecord(t, e, n);
-			}, this.subrule = function(e, t, n) {
-				return this.subruleInternalRecord(t, e, n);
-			}, this.option = function(e, t) {
-				return this.optionInternalRecord(t, e);
-			}, this.or = function(e, t) {
-				return this.orInternalRecord(t, e);
-			}, this.many = function(e, t) {
-				this.manyInternalRecord(e, t);
-			}, this.atLeastOne = function(e, t) {
-				this.atLeastOneInternalRecord(e, t);
-			}, this.ACTION = this.ACTION_RECORD, this.BACKTRACK = this.BACKTRACK_RECORD, this.LA = this.LA_RECORD;
-		});
-	}
-	disableRecording() {
-		this.RECORDING_PHASE = !1, this.TRACE_INIT("Deleting Recording methods", () => {
-			let e = this;
-			for (let t = 0; t < 10; t++) {
-				let n = t > 0 ? t : "";
-				delete e[`CONSUME${n}`], delete e[`SUBRULE${n}`], delete e[`OPTION${n}`], delete e[`OR${n}`], delete e[`MANY${n}`], delete e[`MANY_SEP${n}`], delete e[`AT_LEAST_ONE${n}`], delete e[`AT_LEAST_ONE_SEP${n}`];
-			}
-			delete e.consume, delete e.subrule, delete e.option, delete e.or, delete e.many, delete e.atLeastOne, delete e.ACTION, delete e.BACKTRACK, delete e.LA;
-		});
-	}
-	ACTION_RECORD(e) {}
-	BACKTRACK_RECORD(e, t) {
-		return () => !0;
-	}
-	LA_RECORD(e) {
-		return h;
-	}
-	topLevelRuleRecord(e, t) {
-		try {
-			let n = new c({
-				definition: [],
-				name: e
-			});
-			return n.name = e, this.recordingProdStack.push(n), t.call(this), this.recordingProdStack.pop(), n;
-		} catch (e) {
-			if (e.KNOWN_RECORDER_ERROR !== !0) try {
-				e.message += "\n	 This error was thrown during the \"grammar recording phase\" For more info see:\n	https://chevrotain.io/docs/guide/internals.html#grammar-recording";
-			} catch {
-				throw e;
-			}
-			throw e;
-		}
-	}
-	optionInternalRecord(e, t) {
-		return C.call(this, r, e, t);
-	}
-	atLeastOneInternalRecord(e, t) {
-		C.call(this, a, t, e);
-	}
-	atLeastOneSepFirstInternalRecord(e, t) {
-		C.call(this, o, t, e, _);
-	}
-	manyInternalRecord(e, t) {
-		C.call(this, i, t, e);
-	}
-	manySepFirstInternalRecord(e, t) {
-		C.call(this, s, t, e, _);
-	}
-	orInternalRecord(e, t) {
-		return w.call(this, e, t);
-	}
-	subruleInternalRecord(e, t, r) {
-		if (E(t), !e || !Object.hasOwn(e, "ruleName")) {
-			let n = /* @__PURE__ */ Error(`<SUBRULE${T(t)}> argument is invalid expecting a Parser method reference but got: <${JSON.stringify(e)}>\n inside top level rule: <${this.recordingProdStack[0].name}>`);
-			throw n.KNOWN_RECORDER_ERROR = !0, n;
-		}
-		let i = this.recordingProdStack.at(-1), a = e.ruleName, o = new n({
-			idx: t,
-			nonTerminalName: a,
-			label: r?.LABEL,
-			referencedRule: void 0
-		});
-		return i.definition.push(o), this.outputCst ? x : g;
-	}
-	consumeInternalRecord(e, t, n) {
-		if (E(t), !d(e)) {
-			let n = /* @__PURE__ */ Error(`<CONSUME${T(t)}> argument is invalid expecting a TokenType reference but got: <${JSON.stringify(e)}>\n inside top level rule: <${this.recordingProdStack[0].name}>`);
-			throw n.KNOWN_RECORDER_ERROR = !0, n;
-		}
-		let r = this.recordingProdStack.at(-1), i = new l({
-			idx: t,
-			terminalType: e,
-			label: n?.LABEL
-		});
-		return r.definition.push(i), b;
-	}
-};
-function C(e, t, n, r = !1) {
-	E(n);
-	let i = this.recordingProdStack.at(-1), a = typeof t == "function" ? t : t.DEF, o = new e({
-		definition: [],
-		idx: n
-	});
-	return r && (o.separator = t.SEP), Object.hasOwn(t, "MAX_LOOKAHEAD") && (o.maxLookahead = t.MAX_LOOKAHEAD), this.recordingProdStack.push(o), a.call(this), i.definition.push(o), this.recordingProdStack.pop(), g;
-}
-function w(n, r) {
-	E(r);
-	let i = this.recordingProdStack.at(-1), a = Array.isArray(n) === !1, o = a === !1 ? n : n.DEF, s = new e({
-		definition: [],
-		idx: r,
-		ignoreAmbiguities: a && n.IGNORE_AMBIGUITIES === !0
-	});
-	return Object.hasOwn(n, "MAX_LOOKAHEAD") && (s.maxLookahead = n.MAX_LOOKAHEAD), s.hasPredicates = o.some((e) => typeof e.GATE == "function"), i.definition.push(s), o.forEach((e) => {
-		let n = new t({ definition: [] });
-		s.definition.push(n), Object.hasOwn(e, "IGNORE_AMBIGUITIES") ? n.ignoreAmbiguities = e.IGNORE_AMBIGUITIES : Object.hasOwn(e, "GATE") && (n.ignoreAmbiguities = !0), this.recordingProdStack.push(n), e.ALT.call(this), this.recordingProdStack.pop();
-	}), g;
-}
-function T(e) {
-	return e === 0 ? "" : `${e}`;
-}
-function E(e) {
-	if (e < 0 || e > v) {
-		let t = /* @__PURE__ */ Error(`Invalid DSL Method idx value: <${e}>\n\tIdx value must be a none negative value smaller than ${v + 1}`);
-		throw t.KNOWN_RECORDER_ERROR = !0, t;
-	}
-}
-//#endregion
-export { S as GastRecorder };
-
-//# sourceMappingURL=gast_recorder.js.map

package/lib/esm/node_modules/chevrotain/lib/src/parse/parser/traits/gast_recorder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gast_recorder.js","names":[],"sources":["../../../../../../../../../../../node_modules/chevrotain/lib/src/parse/parser/traits/gast_recorder.js"],"sourcesContent":["import { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal, } from \"@chevrotain/gast\";\nimport { Lexer } from \"../../../scan/lexer_public.js\";\nimport { augmentTokenTypes, hasShortKeyProperty, } from \"../../../scan/tokens.js\";\nimport { createToken, createTokenInstance, } from \"../../../scan/tokens_public.js\";\nimport { END_OF_FILE } from \"../parser.js\";\nimport { BITS_FOR_OCCURRENCE_IDX } from \"../../grammar/keys.js\";\nconst RECORDING_NULL_OBJECT = {\n    description: \"This Object indicates the Parser is during Recording Phase\",\n};\nObject.freeze(RECORDING_NULL_OBJECT);\nconst HANDLE_SEPARATOR = true;\nconst MAX_METHOD_IDX = Math.pow(2, BITS_FOR_OCCURRENCE_IDX) - 1;\nconst RFT = createToken({ name: \"RECORDING_PHASE_TOKEN\", pattern: Lexer.NA });\naugmentTokenTypes([RFT]);\nconst RECORDING_PHASE_TOKEN = createTokenInstance(RFT, \"This IToken indicates the Parser is in Recording Phase\\n\\t\" +\n    \"\" +\n    \"See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details\", \n// Using \"-1\" instead of NaN (as in EOF) because an actual number is less likely to\n// cause errors if the output of LA or CONSUME would be (incorrectly) used during the recording phase.\n-1, -1, -1, -1, -1, -1);\nObject.freeze(RECORDING_PHASE_TOKEN);\nconst RECORDING_PHASE_CSTNODE = {\n    name: \"This CSTNode indicates the Parser is in Recording Phase\\n\\t\" +\n        \"See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details\",\n    children: {},\n};\n/**\n * This trait handles the creation of the GAST structure for Chevrotain Grammars\n */\nexport class GastRecorder {\n    initGastRecorder(config) {\n        this.recordingProdStack = [];\n        this.RECORDING_PHASE = false;\n    }\n    enableRecording() {\n        this.RECORDING_PHASE = true;\n        this.TRACE_INIT(\"Enable Recording\", () => {\n            /**\n             * Warning Dark Voodoo Magic upcoming!\n             * We are \"replacing\" the public parsing DSL methods API\n             * With **new** alternative implementations on the Parser **instance**\n             *\n             * So far this is the only way I've found to avoid performance regressions during parsing time.\n             * - Approx 30% performance regression was measured on Chrome 75 Canary when attempting to replace the \"internal\"\n             *   implementations directly instead.\n             */\n            for (let i = 0; i < 10; i++) {\n                const idx = i > 0 ? i : \"\";\n                this[`CONSUME${idx}`] = function (arg1, arg2) {\n                    return this.consumeInternalRecord(arg1, i, arg2);\n                };\n                this[`SUBRULE${idx}`] = function (arg1, arg2) {\n                    return this.subruleInternalRecord(arg1, i, arg2);\n                };\n                this[`OPTION${idx}`] = function (arg1) {\n                    return this.optionInternalRecord(arg1, i);\n                };\n                this[`OR${idx}`] = function (arg1) {\n                    return this.orInternalRecord(arg1, i);\n                };\n                this[`MANY${idx}`] = function (arg1) {\n                    this.manyInternalRecord(i, arg1);\n                };\n                this[`MANY_SEP${idx}`] = function (arg1) {\n                    this.manySepFirstInternalRecord(i, arg1);\n                };\n                this[`AT_LEAST_ONE${idx}`] = function (arg1) {\n                    this.atLeastOneInternalRecord(i, arg1);\n                };\n                this[`AT_LEAST_ONE_SEP${idx}`] = function (arg1) {\n                    this.atLeastOneSepFirstInternalRecord(i, arg1);\n                };\n            }\n            // DSL methods with the idx(suffix) as an argument\n            this[`consume`] = function (idx, arg1, arg2) {\n                return this.consumeInternalRecord(arg1, idx, arg2);\n            };\n            this[`subrule`] = function (idx, arg1, arg2) {\n                return this.subruleInternalRecord(arg1, idx, arg2);\n            };\n            this[`option`] = function (idx, arg1) {\n                return this.optionInternalRecord(arg1, idx);\n            };\n            this[`or`] = function (idx, arg1) {\n                return this.orInternalRecord(arg1, idx);\n            };\n            this[`many`] = function (idx, arg1) {\n                this.manyInternalRecord(idx, arg1);\n            };\n            this[`atLeastOne`] = function (idx, arg1) {\n                this.atLeastOneInternalRecord(idx, arg1);\n            };\n            this.ACTION = this.ACTION_RECORD;\n            this.BACKTRACK = this.BACKTRACK_RECORD;\n            this.LA = this.LA_RECORD;\n        });\n    }\n    disableRecording() {\n        this.RECORDING_PHASE = false;\n        // By deleting these **instance** properties, any future invocation\n        // will be deferred to the original methods on the **prototype** object\n        // This seems to get rid of any incorrect optimizations that V8 may\n        // do during the recording phase.\n        this.TRACE_INIT(\"Deleting Recording methods\", () => {\n            const that = this;\n            for (let i = 0; i < 10; i++) {\n                const idx = i > 0 ? i : \"\";\n                delete that[`CONSUME${idx}`];\n                delete that[`SUBRULE${idx}`];\n                delete that[`OPTION${idx}`];\n                delete that[`OR${idx}`];\n                delete that[`MANY${idx}`];\n                delete that[`MANY_SEP${idx}`];\n                delete that[`AT_LEAST_ONE${idx}`];\n                delete that[`AT_LEAST_ONE_SEP${idx}`];\n            }\n            delete that[`consume`];\n            delete that[`subrule`];\n            delete that[`option`];\n            delete that[`or`];\n            delete that[`many`];\n            delete that[`atLeastOne`];\n            delete that.ACTION;\n            delete that.BACKTRACK;\n            delete that.LA;\n        });\n    }\n    //   Parser methods are called inside an ACTION?\n    //   Maybe try/catch/finally on ACTIONS while disabling the recorders state changes?\n    // @ts-expect-error -- noop place holder\n    ACTION_RECORD(impl) {\n        // NO-OP during recording\n    }\n    // Executing backtracking logic will break our recording logic assumptions\n    BACKTRACK_RECORD(grammarRule, args) {\n        return () => true;\n    }\n    // LA is part of the official API and may be used for custom lookahead logic\n    // by end users who may forget to wrap it in ACTION or inside a GATE\n    LA_RECORD(howMuch) {\n        // We cannot use the RECORD_PHASE_TOKEN here because someone may depend\n        // On LA return EOF at the end of the input so an infinite loop may occur.\n        return END_OF_FILE;\n    }\n    topLevelRuleRecord(name, def) {\n        try {\n            const newTopLevelRule = new Rule({ definition: [], name: name });\n            newTopLevelRule.name = name;\n            this.recordingProdStack.push(newTopLevelRule);\n            def.call(this);\n            this.recordingProdStack.pop();\n            return newTopLevelRule;\n        }\n        catch (originalError) {\n            if (originalError.KNOWN_RECORDER_ERROR !== true) {\n                try {\n                    originalError.message =\n                        originalError.message +\n                            '\\n\\t This error was thrown during the \"grammar recording phase\" For more info see:\\n\\t' +\n                            \"https://chevrotain.io/docs/guide/internals.html#grammar-recording\";\n                }\n                catch (mutabilityError) {\n                    // We may not be able to modify the original error object\n                    throw originalError;\n                }\n            }\n            throw originalError;\n        }\n    }\n    // Implementation of parsing DSL\n    optionInternalRecord(actionORMethodDef, occurrence) {\n        return recordProd.call(this, Option, actionORMethodDef, occurrence);\n    }\n    atLeastOneInternalRecord(occurrence, actionORMethodDef) {\n        recordProd.call(this, RepetitionMandatory, actionORMethodDef, occurrence);\n    }\n    atLeastOneSepFirstInternalRecord(occurrence, options) {\n        recordProd.call(this, RepetitionMandatoryWithSeparator, options, occurrence, HANDLE_SEPARATOR);\n    }\n    manyInternalRecord(occurrence, actionORMethodDef) {\n        recordProd.call(this, Repetition, actionORMethodDef, occurrence);\n    }\n    manySepFirstInternalRecord(occurrence, options) {\n        recordProd.call(this, RepetitionWithSeparator, options, occurrence, HANDLE_SEPARATOR);\n    }\n    orInternalRecord(altsOrOpts, occurrence) {\n        return recordOrProd.call(this, altsOrOpts, occurrence);\n    }\n    subruleInternalRecord(ruleToCall, occurrence, options) {\n        assertMethodIdxIsValid(occurrence);\n        if (!ruleToCall || !Object.hasOwn(ruleToCall, \"ruleName\")) {\n            const error = new Error(`<SUBRULE${getIdxSuffix(occurrence)}> argument is invalid` +\n                ` expecting a Parser method reference but got: <${JSON.stringify(ruleToCall)}>` +\n                `\\n inside top level rule: <${this.recordingProdStack[0].name}>`);\n            error.KNOWN_RECORDER_ERROR = true;\n            throw error;\n        }\n        const prevProd = this.recordingProdStack.at(-1);\n        const ruleName = ruleToCall.ruleName;\n        const newNoneTerminal = new NonTerminal({\n            idx: occurrence,\n            nonTerminalName: ruleName,\n            label: options === null || options === void 0 ? void 0 : options.LABEL,\n            // The resolving of the `referencedRule` property will be done once all the Rule's GASTs have been created\n            referencedRule: undefined,\n        });\n        prevProd.definition.push(newNoneTerminal);\n        return this.outputCst\n            ? RECORDING_PHASE_CSTNODE\n            : RECORDING_NULL_OBJECT;\n    }\n    consumeInternalRecord(tokType, occurrence, options) {\n        assertMethodIdxIsValid(occurrence);\n        if (!hasShortKeyProperty(tokType)) {\n            const error = new Error(`<CONSUME${getIdxSuffix(occurrence)}> argument is invalid` +\n                ` expecting a TokenType reference but got: <${JSON.stringify(tokType)}>` +\n                `\\n inside top level rule: <${this.recordingProdStack[0].name}>`);\n            error.KNOWN_RECORDER_ERROR = true;\n            throw error;\n        }\n        const prevProd = this.recordingProdStack.at(-1);\n        const newNoneTerminal = new Terminal({\n            idx: occurrence,\n            terminalType: tokType,\n            label: options === null || options === void 0 ? void 0 : options.LABEL,\n        });\n        prevProd.definition.push(newNoneTerminal);\n        return RECORDING_PHASE_TOKEN;\n    }\n}\nfunction recordProd(prodConstructor, mainProdArg, occurrence, handleSep = false) {\n    assertMethodIdxIsValid(occurrence);\n    const prevProd = this.recordingProdStack.at(-1);\n    const grammarAction = typeof mainProdArg === \"function\" ? mainProdArg : mainProdArg.DEF;\n    const newProd = new prodConstructor({ definition: [], idx: occurrence });\n    if (handleSep) {\n        newProd.separator = mainProdArg.SEP;\n    }\n    if (Object.hasOwn(mainProdArg, \"MAX_LOOKAHEAD\")) {\n        newProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;\n    }\n    this.recordingProdStack.push(newProd);\n    grammarAction.call(this);\n    prevProd.definition.push(newProd);\n    this.recordingProdStack.pop();\n    return RECORDING_NULL_OBJECT;\n}\nfunction recordOrProd(mainProdArg, occurrence) {\n    assertMethodIdxIsValid(occurrence);\n    const prevProd = this.recordingProdStack.at(-1);\n    // Only an array of alternatives\n    const hasOptions = Array.isArray(mainProdArg) === false;\n    const alts = hasOptions === false ? mainProdArg : mainProdArg.DEF;\n    const newOrProd = new Alternation({\n        definition: [],\n        idx: occurrence,\n        ignoreAmbiguities: hasOptions && mainProdArg.IGNORE_AMBIGUITIES === true,\n    });\n    if (Object.hasOwn(mainProdArg, \"MAX_LOOKAHEAD\")) {\n        newOrProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;\n    }\n    const hasPredicates = alts.some((currAlt) => typeof currAlt.GATE === \"function\");\n    newOrProd.hasPredicates = hasPredicates;\n    prevProd.definition.push(newOrProd);\n    alts.forEach((currAlt) => {\n        const currAltFlat = new Alternative({ definition: [] });\n        newOrProd.definition.push(currAltFlat);\n        if (Object.hasOwn(currAlt, \"IGNORE_AMBIGUITIES\")) {\n            currAltFlat.ignoreAmbiguities = currAlt.IGNORE_AMBIGUITIES; // assumes end user provides the correct config value/type\n        }\n        // **implicit** ignoreAmbiguities due to usage of gate\n        else if (Object.hasOwn(currAlt, \"GATE\")) {\n            currAltFlat.ignoreAmbiguities = true;\n        }\n        this.recordingProdStack.push(currAltFlat);\n        currAlt.ALT.call(this);\n        this.recordingProdStack.pop();\n    });\n    return RECORDING_NULL_OBJECT;\n}\nfunction getIdxSuffix(idx) {\n    return idx === 0 ? \"\" : `${idx}`;\n}\nfunction assertMethodIdxIsValid(idx) {\n    if (idx < 0 || idx > MAX_METHOD_IDX) {\n        const error = new Error(\n        // The stack trace will contain all the needed details\n        `Invalid DSL Method idx value: <${idx}>\\n\\t` +\n            `Idx value must be a none negative value smaller than ${MAX_METHOD_IDX + 1}`);\n        error.KNOWN_RECORDER_ERROR = true;\n        throw error;\n    }\n}\n//# sourceMappingURL=gast_recorder.js.map"],"x_google_ignoreList":[0],"mappings":"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"}