@plumile/ui 0.1.112 → 0.1.114

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

@@ -1,157 +0,0 @@
-import { BaseRegExpVisitor as e } from "../../../../@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.js";
-import "../../../../@chevrotain/regexp-to-ast/lib/src/api.js";
-import { PRINT_ERROR as t, PRINT_WARNING as n } from "../../../../@chevrotain/utils/lib/src/print.js";
-import { getRegExpAst as r } from "./reg_exp_parser.js";
-import { charCodeToOptimizedIndex as i } from "./lexer.js";
-//#region ../../node_modules/chevrotain/lib/src/scan/reg_exp.js
-var a = "Complement Sets are not supported for first char optimization", o = "Unable to use \"first char\" lexer optimizations:\n";
-function s(e, i = !1) {
-	try {
-		let t = r(e);
-		return c(t.value, {}, t.flags.ignoreCase);
-	} catch (r) {
-		/* istanbul ignore next */
-		if (r.message === a) i && n(`${o}\tUnable to optimize: < ${e.toString()} >\n	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 n = "";
-			i && (n = "\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."), t(`${o}\n\tFailed parsing: < ${e.toString()} >\n\tUsing the @chevrotain/regexp-to-ast library\n	Please open an issue at: https://github.com/chevrotain/chevrotain/issues` + n);
-		}
-	}
-	return [];
-}
-function c(e, t, n) {
-	switch (e.type) {
-		case "Disjunction":
-			for (let r = 0; r < e.value.length; r++) c(e.value[r], t, n);
-			break;
-		case "Alternative":
-			let r = e.value;
-			for (let e = 0; e < r.length; e++) {
-				let o = r[e];
-				switch (o.type) {
-					case "EndAnchor":
-					case "GroupBackReference":
-					case "Lookahead":
-					case "NegativeLookahead":
-					case "Lookbehind":
-					case "NegativeLookbehind":
-					case "StartAnchor":
-					case "WordBoundary":
-					case "NonWordBoundary": continue;
-				}
-				let s = o;
-				switch (s.type) {
-					case "Character":
-						l(s.value, t, n);
-						break;
-					case "Set":
-						if (s.complement === !0) throw Error(a);
-						s.value.forEach((e) => {
-							if (typeof e == "number") l(e, t, n);
-							else {
-								let r = e;
-								if (n === !0) for (let e = r.from; e <= r.to; e++) l(e, t, n);
-								else {
-									for (let e = r.from; e <= r.to && e < 256; e++) l(e, t, n);
-									if (r.to >= 256) {
-										let e = r.from >= 256 ? r.from : 256, n = r.to, a = i(e), o = i(n);
-										for (let e = a; e <= o; e++) t[e] = e;
-									}
-								}
-							}
-						});
-						break;
-					case "Group":
-						c(s.value, t, n);
-						break;
-					/* istanbul ignore next */
-					default: throw Error("Non Exhaustive Match");
-				}
-				let u = s.quantifier !== void 0 && s.quantifier.atLeast === 0;
-				if (s.type === "Group" && f(s) === !1 || s.type !== "Group" && u === !1) break;
-			}
-			break;
-		/* istanbul ignore next */
-		default: throw Error("non exhaustive match!");
-	}
-	return Object.values(t);
-}
-function l(e, t, n) {
-	let r = i(e);
-	t[r] = r, n === !0 && u(e, t);
-}
-function u(e, t) {
-	let n = String.fromCharCode(e), r = n.toUpperCase();
-	/* istanbul ignore else */
-	if (r !== n) {
-		let e = i(r.charCodeAt(0));
-		t[e] = e;
-	} else {
-		let e = n.toLowerCase();
-		if (e !== n) {
-			let n = i(e.charCodeAt(0));
-			t[n] = n;
-		}
-	}
-}
-function d(e, t) {
-	return e.value.find((e) => {
-		if (typeof e == "number") return t.includes(e);
-		{
-			let n = e;
-			return t.find((e) => n.from <= e && e <= n.to) !== void 0;
-		}
-	});
-}
-function f(e) {
-	let t = e.quantifier;
-	return t && t.atLeast === 0 ? !0 : e.value ? Array.isArray(e.value) ? e.value.every(f) : f(e.value) : !1;
-}
-var p = class extends e {
-	constructor(e) {
-		super(), this.targetCharCodes = e, this.found = !1;
-	}
-	visitChildren(e) {
-		if (this.found !== !0) {
-			switch (e.type) {
-				case "Lookahead":
-					this.visitLookahead(e);
-					return;
-				case "NegativeLookahead":
-					this.visitNegativeLookahead(e);
-					return;
-				case "Lookbehind":
-					this.visitLookbehind(e);
-					return;
-				case "NegativeLookbehind":
-					this.visitNegativeLookbehind(e);
-					return;
-			}
-			super.visitChildren(e);
-		}
-	}
-	visitCharacter(e) {
-		this.targetCharCodes.includes(e.value) && (this.found = !0);
-	}
-	visitSet(e) {
-		e.complement ? d(e, this.targetCharCodes) === void 0 && (this.found = !0) : d(e, this.targetCharCodes) !== void 0 && (this.found = !0);
-	}
-};
-function m(e, t) {
-	if (t instanceof RegExp) {
-		let n = r(t), i = new p(e);
-		return i.visit(n), i.found;
-	} else {
-		for (let n of t) {
-			let t = n.charCodeAt(0);
-			if (e.includes(t)) return !0;
-		}
-		return !1;
-	}
-}
-//#endregion
-export { m as canMatchCharCode, o as failedOptimizationPrefixMsg, s as getOptimizedStartCodesIndices };
-
-//# sourceMappingURL=reg_exp.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"reg_exp.js","names":[],"sources":["../../../../../../../../../node_modules/chevrotain/lib/src/scan/reg_exp.js"],"sourcesContent":["import { BaseRegExpVisitor, } from \"@chevrotain/regexp-to-ast\";\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 \"Lookbehind\":\n                    case \"NegativeLookbehind\":\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                        atom.value.forEach((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 Object.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 setNode.value.find((codeOrRange) => {\n        if (typeof codeOrRange === \"number\") {\n            return targetCharCodes.includes(codeOrRange);\n        }\n        else {\n            // range\n            const range = codeOrRange;\n            return (targetCharCodes.find((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 Array.isArray(ast.value)\n        ? ast.value.every(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 / lookbehinds 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            case \"Lookbehind\":\n                this.visitLookbehind(node);\n                return;\n            case \"NegativeLookbehind\":\n                this.visitNegativeLookbehind(node);\n                return;\n        }\n        super.visitChildren(node);\n    }\n    visitCharacter(node) {\n        if (this.targetCharCodes.includes(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        for (const char of pattern) {\n            const charCode = char.charCodeAt(0);\n            if (charCodes.includes(charCode)) {\n                return true;\n            }\n        }\n        return false;\n    }\n}\n//# sourceMappingURL=reg_exp.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

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

@@ -1,19 +0,0 @@
-import { RegExpParser as e } from "../../../../@chevrotain/regexp-to-ast/lib/src/regexp-parser.js";
-import "../../../../@chevrotain/regexp-to-ast/lib/src/api.js";
-//#region ../../node_modules/chevrotain/lib/src/scan/reg_exp_parser.js
-var t = {}, n = new e();
-function r(e) {
-	let r = e.toString();
-	if (t.hasOwnProperty(r)) return t[r];
-	{
-		let e = n.pattern(r);
-		return t[r] = e, e;
-	}
-}
-function i() {
-	t = {};
-}
-//#endregion
-export { i as clearRegExpParserCache, r as getRegExpAst };
-
-//# sourceMappingURL=reg_exp_parser.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"reg_exp_parser.js","names":[],"sources":["../../../../../../../../../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"],"x_google_ignoreList":[0],"mappings":";;;AACA,IAAI,IAAiB,EAAE,EACjB,IAAe,IAAI,GAAc;AACvC,SAAgB,EAAa,GAAQ;CACjC,IAAM,IAAY,EAAO,UAAU;CACnC,IAAI,EAAe,eAAe,EAAU,EACxC,OAAO,EAAe;CAErB;EACD,IAAM,IAAY,EAAa,QAAQ,EAAU;EAEjD,OADA,EAAe,KAAa,GACrB;;;AAGf,SAAgB,IAAyB;CACrC,IAAiB,EAAE"}

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

@@ -1,68 +0,0 @@
-//#region ../../node_modules/chevrotain/lib/src/scan/tokens.js
-function e(e, t) {
-	let n = e.tokenTypeIdx;
-	return n === t.tokenTypeIdx ? !0 : t.isParent === !0 && t.categoryMatchesMap[n] === !0;
-}
-function t(e, t) {
-	return e.tokenTypeIdx === t.tokenTypeIdx;
-}
-var n = 1, r = {};
-function i(e) {
-	let t = a(e);
-	o(t), c(t), s(t), t.forEach((e) => {
-		e.isParent = e.categoryMatches.length > 0;
-	});
-}
-function a(e) {
-	let t = [...e], n = e, r = !0;
-	for (; r;) {
-		n = n.map((e) => e.CATEGORIES).flat().filter(Boolean);
-		let e = n.filter((e) => !t.includes(e));
-		t = t.concat(e), e.length === 0 ? r = !1 : n = e;
-	}
-	return t;
-}
-function o(e) {
-	e.forEach((e) => {
-		u(e) || (r[n] = e, e.tokenTypeIdx = n++), d(e) && !Array.isArray(e.CATEGORIES) && (e.CATEGORIES = [e.CATEGORIES]), d(e) || (e.CATEGORIES = []), f(e) || (e.categoryMatches = []), p(e) || (e.categoryMatchesMap = {});
-	});
-}
-function s(e) {
-	e.forEach((e) => {
-		e.categoryMatches = [], Object.keys(e.categoryMatchesMap).forEach((t) => {
-			e.categoryMatches.push(r[t].tokenTypeIdx);
-		});
-	});
-}
-function c(e) {
-	e.forEach((e) => {
-		l([], e);
-	});
-}
-function l(e, t) {
-	e.forEach((e) => {
-		t.categoryMatchesMap[e.tokenTypeIdx] = !0;
-	}), t.CATEGORIES.forEach((n) => {
-		let r = e.concat(t);
-		r.includes(n) || l(r, n);
-	});
-}
-function u(e) {
-	return Object.hasOwn(e ?? {}, "tokenTypeIdx");
-}
-function d(e) {
-	return Object.hasOwn(e ?? {}, "CATEGORIES");
-}
-function f(e) {
-	return Object.hasOwn(e ?? {}, "categoryMatches");
-}
-function p(e) {
-	return Object.hasOwn(e ?? {}, "categoryMatchesMap");
-}
-function m(e) {
-	return Object.hasOwn(e ?? {}, "tokenTypeIdx");
-}
-//#endregion
-export { i as augmentTokenTypes, u as hasShortKeyProperty, m as isTokenType, e as tokenStructuredMatcher, t as tokenStructuredMatcherNoCategories };
-
-//# sourceMappingURL=tokens.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tokens.js","names":[],"sources":["../../../../../../../../../node_modules/chevrotain/lib/src/scan/tokens.js"],"sourcesContent":["export 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    tokenTypesAndParents.forEach((tokType) => {\n        tokType.isParent = tokType.categoryMatches.length > 0;\n    });\n}\nexport function expandCategories(tokenTypes) {\n    let result = [...tokenTypes];\n    let categories = tokenTypes;\n    let searching = true;\n    while (searching) {\n        categories = categories\n            .map((currTokType) => currTokType.CATEGORIES)\n            .flat()\n            .filter(Boolean);\n        const newCategories = categories.filter((x) => !result.includes(x));\n        result = result.concat(newCategories);\n        if (newCategories.length === 0) {\n            searching = false;\n        }\n        else {\n            categories = newCategories;\n        }\n    }\n    return result;\n}\nexport function assignTokenDefaultProps(tokenTypes) {\n    tokenTypes.forEach((currTokType) => {\n        if (!hasShortKeyProperty(currTokType)) {\n            tokenIdxToClass[tokenShortNameIdx] = currTokType;\n            currTokType.tokenTypeIdx = tokenShortNameIdx++;\n        }\n        // CATEGORIES? : TokenType | TokenType[]\n        if (hasCategoriesProperty(currTokType) &&\n            !Array.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    tokenTypes.forEach((currTokType) => {\n        // avoid duplications\n        currTokType.categoryMatches = [];\n        Object.keys(currTokType.categoryMatchesMap).forEach((key) => {\n            currTokType.categoryMatches.push(tokenIdxToClass[key].tokenTypeIdx);\n        });\n    });\n}\nexport function assignCategoriesMapProp(tokenTypes) {\n    tokenTypes.forEach((currTokType) => {\n        singleAssignCategoriesToksMap([], currTokType);\n    });\n}\nexport function singleAssignCategoriesToksMap(path, nextNode) {\n    path.forEach((pathNode) => {\n        nextNode.categoryMatchesMap[pathNode.tokenTypeIdx] = true;\n    });\n    nextNode.CATEGORIES.forEach((nextCategory) => {\n        const newPath = path.concat(nextNode);\n        // avoids infinite loops due to cyclic categories.\n        if (!newPath.includes(nextCategory)) {\n            singleAssignCategoriesToksMap(newPath, nextCategory);\n        }\n    });\n}\nexport function hasShortKeyProperty(tokType) {\n    return Object.hasOwn(tokType !== null && tokType !== void 0 ? tokType : {}, \"tokenTypeIdx\");\n}\nexport function hasCategoriesProperty(tokType) {\n    return Object.hasOwn(tokType !== null && tokType !== void 0 ? tokType : {}, \"CATEGORIES\");\n}\nexport function hasExtendingTokensTypesProperty(tokType) {\n    return Object.hasOwn(tokType !== null && tokType !== void 0 ? tokType : {}, \"categoryMatches\");\n}\nexport function hasExtendingTokensTypesMapProperty(tokType) {\n    return Object.hasOwn(tokType !== null && tokType !== void 0 ? tokType : {}, \"categoryMatchesMap\");\n}\nexport function isTokenType(tokType) {\n    return Object.hasOwn(tokType !== null && tokType !== void 0 ? tokType : {}, \"tokenTypeIdx\");\n}\n//# sourceMappingURL=tokens.js.map"],"x_google_ignoreList":[0],"mappings":";AAAA,SAAgB,EAAuB,GAAa,GAAgB;CAChE,IAAM,IAAe,EAAY;CAK7B,OAJA,MAAiB,EAAe,eACzB,KAGC,EAAe,aAAa,MAChC,EAAe,mBAAmB,OAAkB;;AAKhE,SAAgB,EAAmC,GAAO,GAAS;CAC/D,OAAO,EAAM,iBAAiB,EAAQ;;AAE1C,IAAW,IAAoB,GAClB,IAAkB,EAAE;AACjC,SAAgB,EAAkB,GAAY;CAE1C,IAAM,IAAuB,EAAiB,EAAW;CAMzD,AAJA,EAAwB,EAAqB,EAE7C,EAAwB,EAAqB,EAC7C,EAA2B,EAAqB,EAChD,EAAqB,SAAS,MAAY;EACtC,EAAQ,WAAW,EAAQ,gBAAgB,SAAS;GACtD;;AAEN,SAAgB,EAAiB,GAAY;CACzC,IAAI,IAAS,CAAC,GAAG,EAAW,EACxB,IAAa,GACb,IAAY;CAChB,OAAO,IAAW;EACd,IAAa,EACR,KAAK,MAAgB,EAAY,WAAW,CAC5C,MAAM,CACN,OAAO,QAAQ;EACpB,IAAM,IAAgB,EAAW,QAAQ,MAAM,CAAC,EAAO,SAAS,EAAE,CAAC;EAEnE,AADA,IAAS,EAAO,OAAO,EAAc,EACjC,EAAc,WAAW,IACzB,IAAY,KAGZ,IAAa;;CAGrB,OAAO;;AAEX,SAAgB,EAAwB,GAAY;CAChD,EAAW,SAAS,MAAgB;EAmBhC,AAlBK,EAAoB,EAAY,KACjC,EAAgB,KAAqB,GACrC,EAAY,eAAe,MAG3B,EAAsB,EAAY,IAClC,CAAC,MAAM,QAAQ,EAAY,WAAW,KAItC,EAAY,aAAa,CAAC,EAAY,WAAW,GAEhD,EAAsB,EAAY,KACnC,EAAY,aAAa,EAAE,GAE1B,EAAgC,EAAY,KAC7C,EAAY,kBAAkB,EAAE,GAE/B,EAAmC,EAAY,KAChD,EAAY,qBAAqB,EAAE;GAEzC;;AAEN,SAAgB,EAA2B,GAAY;CACnD,EAAW,SAAS,MAAgB;EAGhC,AADA,EAAY,kBAAkB,EAAE,EAChC,OAAO,KAAK,EAAY,mBAAmB,CAAC,SAAS,MAAQ;GACzD,EAAY,gBAAgB,KAAK,EAAgB,GAAK,aAAa;IACrE;GACJ;;AAEN,SAAgB,EAAwB,GAAY;CAChD,EAAW,SAAS,MAAgB;EAChC,EAA8B,EAAE,EAAE,EAAY;GAChD;;AAEN,SAAgB,EAA8B,GAAM,GAAU;CAI1D,AAHA,EAAK,SAAS,MAAa;EACvB,EAAS,mBAAmB,EAAS,gBAAgB;GACvD,EACF,EAAS,WAAW,SAAS,MAAiB;EAC1C,IAAM,IAAU,EAAK,OAAO,EAAS;EAErC,AAAK,EAAQ,SAAS,EAAa,IAC/B,EAA8B,GAAS,EAAa;GAE1D;;AAEN,SAAgB,EAAoB,GAAS;CACzC,OAAO,OAAO,OAAO,KAAmD,EAAE,EAAE,eAAe;;AAE/F,SAAgB,EAAsB,GAAS;CAC3C,OAAO,OAAO,OAAO,KAAmD,EAAE,EAAE,aAAa;;AAE7F,SAAgB,EAAgC,GAAS;CACrD,OAAO,OAAO,OAAO,KAAmD,EAAE,EAAE,kBAAkB;;AAElG,SAAgB,EAAmC,GAAS;CACxD,OAAO,OAAO,OAAO,KAAmD,EAAE,EAAE,qBAAqB;;AAErG,SAAgB,EAAY,GAAS;CACjC,OAAO,OAAO,OAAO,KAAmD,EAAE,EAAE,eAAe"}

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

@@ -1,43 +0,0 @@
-import { augmentTokenTypes as e, tokenStructuredMatcher as t } from "./tokens.js";
-import { Lexer as n } from "./lexer_public.js";
-//#region ../../node_modules/chevrotain/lib/src/scan/tokens_public.js
-function r(e) {
-	return i(e) ? e.LABEL : e.name;
-}
-function i(e) {
-	return typeof e.LABEL == "string" && e.LABEL !== "";
-}
-var a = "parent", o = "categories", s = "label", c = "group", l = "push_mode", u = "pop_mode", d = "longer_alt", f = "line_breaks", p = "start_chars_hint";
-function m(e) {
-	return h(e);
-}
-function h(t) {
-	let n = t.pattern, r = {};
-	if (r.name = t.name, n !== void 0 && (r.PATTERN = n), Object.hasOwn(t, a)) throw "The parent property is no longer supported.\nSee: https://github.com/chevrotain/chevrotain/issues/564#issuecomment-349062346 for details.";
-	return Object.hasOwn(t, o) && (r.CATEGORIES = t[o]), e([r]), Object.hasOwn(t, s) && (r.LABEL = t[s]), Object.hasOwn(t, c) && (r.GROUP = t[c]), Object.hasOwn(t, u) && (r.POP_MODE = t[u]), Object.hasOwn(t, l) && (r.PUSH_MODE = t[l]), Object.hasOwn(t, d) && (r.LONGER_ALT = t[d]), Object.hasOwn(t, f) && (r.LINE_BREAKS = t[f]), Object.hasOwn(t, p) && (r.START_CHARS_HINT = t[p]), r;
-}
-var g = m({
-	name: "EOF",
-	pattern: n.NA
-});
-e([g]);
-function _(e, t, n, r, i, a, o, s) {
-	return {
-		image: t,
-		startOffset: n,
-		endOffset: r,
-		startLine: i,
-		endLine: a,
-		startColumn: o,
-		endColumn: s,
-		tokenTypeIdx: e.tokenTypeIdx,
-		tokenType: e
-	};
-}
-function v(e, n) {
-	return t(e, n);
-}
-//#endregion
-export { g as EOF, m as createToken, _ as createTokenInstance, i as hasTokenLabel, r as tokenLabel, v as tokenMatcher };
-
-//# sourceMappingURL=tokens_public.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tokens_public.js","names":[],"sources":["../../../../../../../../../node_modules/chevrotain/lib/src/scan/tokens_public.js"],"sourcesContent":["import { 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 typeof obj.LABEL === \"string\" && 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 (pattern !== undefined) {\n        tokenType.PATTERN = pattern;\n    }\n    if (Object.hasOwn(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 (Object.hasOwn(config, CATEGORIES)) {\n        // casting to ANY as this will be fixed inside `augmentTokenTypes``\n        tokenType.CATEGORIES = config[CATEGORIES];\n    }\n    augmentTokenTypes([tokenType]);\n    if (Object.hasOwn(config, LABEL)) {\n        tokenType.LABEL = config[LABEL];\n    }\n    if (Object.hasOwn(config, GROUP)) {\n        tokenType.GROUP = config[GROUP];\n    }\n    if (Object.hasOwn(config, POP_MODE)) {\n        tokenType.POP_MODE = config[POP_MODE];\n    }\n    if (Object.hasOwn(config, PUSH_MODE)) {\n        tokenType.PUSH_MODE = config[PUSH_MODE];\n    }\n    if (Object.hasOwn(config, LONGER_ALT)) {\n        tokenType.LONGER_ALT = config[LONGER_ALT];\n    }\n    if (Object.hasOwn(config, LINE_BREAKS)) {\n        tokenType.LINE_BREAKS = config[LINE_BREAKS];\n    }\n    if (Object.hasOwn(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"],"x_google_ignoreList":[0],"mappings":";;;AAEA,SAAgB,EAAW,GAAS;CAK5B,OAJA,EAAc,EAAQ,GACf,EAAQ,QAGR,EAAQ;;AAMvB,SAAgB,EAAc,GAAK;CAC/B,OAAO,OAAO,EAAI,SAAU,YAAY,EAAI,UAAU;;AAE1D,IAAM,IAAS,UACT,IAAa,cACb,IAAQ,SACR,IAAQ,SACR,IAAY,aACZ,IAAW,YACX,IAAa,cACb,IAAc,eACd,IAAmB;AACzB,SAAgB,EAAY,GAAQ;CAChC,OAAO,EAAoB,EAAO;;AAEtC,SAAS,EAAoB,GAAQ;CACjC,IAAM,IAAU,EAAO,SACjB,IAAY,EAAE;CAKpB,IAJA,EAAU,OAAO,EAAO,MACpB,MAAY,KAAA,MACZ,EAAU,UAAU,IAEpB,OAAO,OAAO,GAAQ,EAAO,EAC7B,MAAO;CA6BX,OA1BI,OAAO,OAAO,GAAQ,EAAW,KAEjC,EAAU,aAAa,EAAO,KAElC,EAAkB,CAAC,EAAU,CAAC,EAC1B,OAAO,OAAO,GAAQ,EAAM,KAC5B,EAAU,QAAQ,EAAO,KAEzB,OAAO,OAAO,GAAQ,EAAM,KAC5B,EAAU,QAAQ,EAAO,KAEzB,OAAO,OAAO,GAAQ,EAAS,KAC/B,EAAU,WAAW,EAAO,KAE5B,OAAO,OAAO,GAAQ,EAAU,KAChC,EAAU,YAAY,EAAO,KAE7B,OAAO,OAAO,GAAQ,EAAW,KACjC,EAAU,aAAa,EAAO,KAE9B,OAAO,OAAO,GAAQ,EAAY,KAClC,EAAU,cAAc,EAAO,KAE/B,OAAO,OAAO,GAAQ,EAAiB,KACvC,EAAU,mBAAmB,EAAO,KAEjC;;AAEX,IAAa,IAAM,EAAY;CAAE,MAAM;CAAO,SAAS,EAAM;CAAI,CAAC;AAClE,EAAkB,CAAC,EAAI,CAAC;AACxB,SAAgB,EAAoB,GAAS,GAAO,GAAa,GAAW,GAAW,GAAS,GAAa,GAAW;CACpH,OAAO;EACH;EACA;EACA;EACA;EACA;EACA;EACA;EACA,cAAc,EAAQ;EACtB,WAAW;EACd;;AAEL,SAAgB,EAAa,GAAO,GAAS;CACzC,OAAO,EAAuB,GAAO,EAAQ"}