@plumile/ui 0.1.113 → 0.1.114

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

@@ -1,279 +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";
-import { GAstVisitor as l } from "../../../../../@chevrotain/gast/lib/src/visitor.js";
-import { getProductionDslName as u, isOptionalProd as d } from "../../../../../@chevrotain/gast/lib/src/helpers.js";
-import { tokenStructuredMatcher as f } from "../../scan/tokens.js";
-import { nextPossibleTokensAfter as p } from "./interpreter.js";
-import { containsPath as m, getLookaheadPathsForOptionalProd as h, getLookaheadPathsForOr as g, getProdType as _, isStrictPrefixOfPath as v } from "./lookahead.js";
-import { ParserDefinitionErrorType as y } from "../parser/parser.js";
-//#region ../../node_modules/chevrotain/lib/src/parse/grammar/checks.js
-function b(e) {
-	return e.lookaheadStrategy.validate({
-		rules: e.rules,
-		tokenTypes: e.tokenTypes,
-		grammarName: e.grammarName
-	}).map((e) => Object.assign({ type: y.CUSTOM_LOOKAHEAD_VALIDATION }, e));
-}
-function x(e, t, n, r) {
-	let i = e.flatMap((e) => S(e, n)), a = R(e, t, n), o = e.flatMap((e) => P(e, n)), s = e.flatMap((t) => E(t, e, r, n));
-	return i.concat(a, o, s);
-}
-function S(e, t) {
-	let n = new T();
-	e.accept(n);
-	let r = n.allProductions, i = Object.groupBy(r, C), a = Object.fromEntries(Object.entries(i).filter(([e, t]) => t.length > 1));
-	return Object.values(a).map((n) => {
-		let r = n[0], i = t.buildDuplicateFoundError(e, n), a = u(r), o = {
-			message: i,
-			type: y.DUPLICATE_PRODUCTIONS,
-			ruleName: e.name,
-			dslName: a,
-			occurrence: r.idx
-		}, s = w(r);
-		return s && (o.parameter = s), o;
-	});
-}
-function C(e) {
-	return `${u(e)}_#_${e.idx}_#_${w(e)}`;
-}
-function w(e) {
-	return e instanceof c ? e.terminalType.name : e instanceof n ? e.nonTerminalName : "";
-}
-var T = class extends l {
-	constructor() {
-		super(...arguments), this.allProductions = [];
-	}
-	visitNonTerminal(e) {
-		this.allProductions.push(e);
-	}
-	visitOption(e) {
-		this.allProductions.push(e);
-	}
-	visitRepetitionWithSeparator(e) {
-		this.allProductions.push(e);
-	}
-	visitRepetitionMandatory(e) {
-		this.allProductions.push(e);
-	}
-	visitRepetitionMandatoryWithSeparator(e) {
-		this.allProductions.push(e);
-	}
-	visitRepetition(e) {
-		this.allProductions.push(e);
-	}
-	visitAlternation(e) {
-		this.allProductions.push(e);
-	}
-	visitTerminal(e) {
-		this.allProductions.push(e);
-	}
-};
-function E(e, t, n, r) {
-	let i = [];
-	if (t.reduce((t, n) => n.name === e.name ? t + 1 : t, 0) > 1) {
-		let t = r.buildDuplicateRuleNameError({
-			topLevelRule: e,
-			grammarName: n
-		});
-		i.push({
-			message: t,
-			type: y.DUPLICATE_RULE_NAME,
-			ruleName: e.name
-		});
-	}
-	return i;
-}
-function D(e, t, n) {
-	let r = [], i;
-	return t.includes(e) || (i = `Invalid rule override, rule: ->${e}<- cannot be overridden in the grammar: ->${n}<-as it is not defined in any of the super grammars `, r.push({
-		message: i,
-		type: y.INVALID_RULE_OVERRIDE,
-		ruleName: e
-	})), r;
-}
-function O(e, t, n, r = []) {
-	let i = [], a = k(t.definition);
-	if (a.length === 0) return [];
-	{
-		let t = e.name;
-		a.includes(e) && i.push({
-			message: n.buildLeftRecursionError({
-				topLevelRule: e,
-				leftRecursionPath: r
-			}),
-			type: y.LEFT_RECURSION,
-			ruleName: t
-		});
-		let o = r.concat([e]), s = a.filter((e) => !o.includes(e)).flatMap((t) => {
-			let i = [...r];
-			return i.push(t), O(e, t, n, i);
-		});
-		return i.concat(s);
-	}
-}
-function k(l) {
-	let u = [];
-	if (l.length === 0) return u;
-	let f = l[0];
-	/* istanbul ignore else */
-	if (f instanceof n) u.push(f.referencedRule);
-	else if (f instanceof t || f instanceof r || f instanceof a || f instanceof o || f instanceof s || f instanceof i) u = u.concat(k(f.definition));
-	else if (f instanceof e) u = f.definition.map((e) => k(e.definition)).flat();
-	else if (!(f instanceof c)) throw Error("non exhaustive match");
-	let p = d(f), m = l.length > 1;
-	if (p && m) {
-		let e = l.slice(1);
-		return u.concat(k(e));
-	} else return u;
-}
-var A = class extends l {
-	constructor() {
-		super(...arguments), this.alternations = [];
-	}
-	visitAlternation(e) {
-		this.alternations.push(e);
-	}
-};
-function j(e, t) {
-	let n = new A();
-	return e.accept(n), n.alternations.flatMap((n) => n.definition.slice(0, -1).flatMap((r, i) => p([r], [], f, 1).length === 0 ? [{
-		message: t.buildEmptyAlternationError({
-			topLevelRule: e,
-			alternation: n,
-			emptyChoiceIdx: i
-		}),
-		type: y.NONE_LAST_EMPTY_ALT,
-		ruleName: e.name,
-		occurrence: n.idx,
-		alternative: i + 1
-	}] : []));
-}
-function M(e, t, n) {
-	let r = new A();
-	e.accept(r);
-	let i = r.alternations;
-	return i = i.filter((e) => e.ignoreAmbiguities !== !0), i.flatMap((r) => {
-		let i = r.idx, a = g(i, e, r.maxLookahead || t, r), o = I(a, r, e, n), s = L(a, r, e, n);
-		return o.concat(s);
-	});
-}
-var N = class extends l {
-	constructor() {
-		super(...arguments), this.allProductions = [];
-	}
-	visitRepetitionWithSeparator(e) {
-		this.allProductions.push(e);
-	}
-	visitRepetitionMandatory(e) {
-		this.allProductions.push(e);
-	}
-	visitRepetitionMandatoryWithSeparator(e) {
-		this.allProductions.push(e);
-	}
-	visitRepetition(e) {
-		this.allProductions.push(e);
-	}
-};
-function P(e, t) {
-	let n = new A();
-	return e.accept(n), n.alternations.flatMap((n) => n.definition.length > 255 ? [{
-		message: t.buildTooManyAlternativesError({
-			topLevelRule: e,
-			alternation: n
-		}),
-		type: y.TOO_MANY_ALTS,
-		ruleName: e.name,
-		occurrence: n.idx
-	}] : []);
-}
-function F(e, t, n) {
-	let r = [];
-	return e.forEach((e) => {
-		let i = new N();
-		e.accept(i), i.allProductions.forEach((i) => {
-			let a = _(i), o = i.maxLookahead || t, s = i.idx;
-			if (h(s, e, a, o)[0].flat().length === 0) {
-				let t = n.buildEmptyRepetitionError({
-					topLevelRule: e,
-					repetition: i
-				});
-				r.push({
-					message: t,
-					type: y.NO_NON_EMPTY_LOOKAHEAD,
-					ruleName: e.name
-				});
-			}
-		});
-	}), r;
-}
-function I(e, t, n, r) {
-	let i = [];
-	return e.reduce((n, r, a) => (t.definition[a].ignoreAmbiguities === !0 || r.forEach((r) => {
-		let o = [a];
-		e.forEach((e, n) => {
-			a !== n && m(e, r) && t.definition[n].ignoreAmbiguities !== !0 && o.push(n);
-		}), o.length > 1 && !m(i, r) && (i.push(r), n.push({
-			alts: o,
-			path: r
-		}));
-	}), n), []).map((e) => {
-		let i = e.alts.map((e) => e + 1);
-		return {
-			message: r.buildAlternationAmbiguityError({
-				topLevelRule: n,
-				alternation: t,
-				ambiguityIndices: i,
-				prefixPath: e.path
-			}),
-			type: y.AMBIGUOUS_ALTS,
-			ruleName: n.name,
-			occurrence: t.idx,
-			alternatives: e.alts
-		};
-	});
-}
-function L(e, t, n, r) {
-	let i = e.reduce((e, t, n) => {
-		let r = t.map((e) => ({
-			idx: n,
-			path: e
-		}));
-		return e.concat(r);
-	}, []);
-	return i.flatMap((e) => {
-		if (t.definition[e.idx].ignoreAmbiguities === !0) return [];
-		let a = e.idx, o = e.path;
-		return i.filter((e) => t.definition[e.idx].ignoreAmbiguities !== !0 && e.idx < a && v(e.path, o)).map((e) => {
-			let i = [e.idx + 1, a + 1], o = t.idx === 0 ? "" : t.idx;
-			return {
-				message: r.buildAlternationPrefixAmbiguityError({
-					topLevelRule: n,
-					alternation: t,
-					ambiguityIndices: i,
-					prefixPath: e.path
-				}),
-				type: y.AMBIGUOUS_PREFIX_ALTS,
-				ruleName: n.name,
-				occurrence: o,
-				alternatives: i
-			};
-		});
-	});
-}
-function R(e, t, n) {
-	let r = [], i = t.map((e) => e.name);
-	return e.forEach((e) => {
-		let t = e.name;
-		if (i.includes(t)) {
-			let i = n.buildNamespaceConflictError(e);
-			r.push({
-				message: i,
-				type: y.CONFLICT_TOKENS_RULES_NAMESPACE,
-				ruleName: t
-			});
-		}
-	}), r;
-}
-//#endregion
-export { M as validateAmbiguousAlternationAlternatives, j as validateEmptyOrAlternative, x as validateGrammar, b as validateLookahead, O as validateNoLeftRecursion, D as validateRuleIsOverridden, F as validateSomeNonEmptyLookaheadPath };
-
-//# sourceMappingURL=checks.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"checks.js","names":["AlternativeGAST"],"sources":["../../../../../../../../../../node_modules/chevrotain/lib/src/parse/grammar/checks.js"],"sourcesContent":["import { ParserDefinitionErrorType, } from \"../parser/parser.js\";\nimport { Alternation, Alternative as AlternativeGAST, GAstVisitor, getProductionDslName, isOptionalProd, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Terminal, } from \"@chevrotain/gast\";\nimport { containsPath, getLookaheadPathsForOptionalProd, getLookaheadPathsForOr, getProdType, isStrictPrefixOfPath, } from \"./lookahead.js\";\nimport { nextPossibleTokensAfter } from \"./interpreter.js\";\nimport { tokenStructuredMatcher } from \"../../scan/tokens.js\";\nexport function validateLookahead(options) {\n    const lookaheadValidationErrorMessages = options.lookaheadStrategy.validate({\n        rules: options.rules,\n        tokenTypes: options.tokenTypes,\n        grammarName: options.grammarName,\n    });\n    return lookaheadValidationErrorMessages.map((errorMessage) => (Object.assign({ type: ParserDefinitionErrorType.CUSTOM_LOOKAHEAD_VALIDATION }, errorMessage)));\n}\nexport function validateGrammar(topLevels, tokenTypes, errMsgProvider, grammarName) {\n    const duplicateErrors = topLevels.flatMap((currTopLevel) => validateDuplicateProductions(currTopLevel, errMsgProvider));\n    const termsNamespaceConflictErrors = checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider);\n    const tooManyAltsErrors = topLevels.flatMap((curRule) => validateTooManyAlts(curRule, errMsgProvider));\n    const duplicateRulesError = topLevels.flatMap((curRule) => validateRuleDoesNotAlreadyExist(curRule, topLevels, grammarName, errMsgProvider));\n    return duplicateErrors.concat(termsNamespaceConflictErrors, tooManyAltsErrors, duplicateRulesError);\n}\nfunction validateDuplicateProductions(topLevelRule, errMsgProvider) {\n    const collectorVisitor = new OccurrenceValidationCollector();\n    topLevelRule.accept(collectorVisitor);\n    const allRuleProductions = collectorVisitor.allProductions;\n    const productionGroups = Object.groupBy(allRuleProductions, identifyProductionForDuplicates);\n    const duplicates = Object.fromEntries(Object.entries(productionGroups).filter(([_k, currGroup]) => currGroup.length > 1));\n    const errors = Object.values(duplicates).map((currDuplicates) => {\n        const firstProd = currDuplicates[0];\n        const msg = errMsgProvider.buildDuplicateFoundError(topLevelRule, currDuplicates);\n        const dslName = getProductionDslName(firstProd);\n        const defError = {\n            message: msg,\n            type: ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,\n            ruleName: topLevelRule.name,\n            dslName: dslName,\n            occurrence: firstProd.idx,\n        };\n        const param = getExtraProductionArgument(firstProd);\n        if (param) {\n            defError.parameter = param;\n        }\n        return defError;\n    });\n    return errors;\n}\nexport function identifyProductionForDuplicates(prod) {\n    return `${getProductionDslName(prod)}_#_${prod.idx}_#_${getExtraProductionArgument(prod)}`;\n}\nfunction getExtraProductionArgument(prod) {\n    if (prod instanceof Terminal) {\n        return prod.terminalType.name;\n    }\n    else if (prod instanceof NonTerminal) {\n        return prod.nonTerminalName;\n    }\n    else {\n        return \"\";\n    }\n}\nexport class OccurrenceValidationCollector extends GAstVisitor {\n    constructor() {\n        super(...arguments);\n        this.allProductions = [];\n    }\n    visitNonTerminal(subrule) {\n        this.allProductions.push(subrule);\n    }\n    visitOption(option) {\n        this.allProductions.push(option);\n    }\n    visitRepetitionWithSeparator(manySep) {\n        this.allProductions.push(manySep);\n    }\n    visitRepetitionMandatory(atLeastOne) {\n        this.allProductions.push(atLeastOne);\n    }\n    visitRepetitionMandatoryWithSeparator(atLeastOneSep) {\n        this.allProductions.push(atLeastOneSep);\n    }\n    visitRepetition(many) {\n        this.allProductions.push(many);\n    }\n    visitAlternation(or) {\n        this.allProductions.push(or);\n    }\n    visitTerminal(terminal) {\n        this.allProductions.push(terminal);\n    }\n}\nexport function validateRuleDoesNotAlreadyExist(rule, allRules, className, errMsgProvider) {\n    const errors = [];\n    const occurrences = allRules.reduce((result, curRule) => {\n        if (curRule.name === rule.name) {\n            return result + 1;\n        }\n        return result;\n    }, 0);\n    if (occurrences > 1) {\n        const errMsg = errMsgProvider.buildDuplicateRuleNameError({\n            topLevelRule: rule,\n            grammarName: className,\n        });\n        errors.push({\n            message: errMsg,\n            type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,\n            ruleName: rule.name,\n        });\n    }\n    return errors;\n}\n// TODO: is there anyway to get only the rule names of rules inherited from the super grammars?\n// This is not part of the IGrammarErrorProvider because the validation cannot be performed on\n// The grammar structure, only at runtime.\nexport function validateRuleIsOverridden(ruleName, definedRulesNames, className) {\n    const errors = [];\n    let errMsg;\n    if (!definedRulesNames.includes(ruleName)) {\n        errMsg =\n            `Invalid rule override, rule: ->${ruleName}<- cannot be overridden in the grammar: ->${className}<-` +\n                `as it is not defined in any of the super grammars `;\n        errors.push({\n            message: errMsg,\n            type: ParserDefinitionErrorType.INVALID_RULE_OVERRIDE,\n            ruleName: ruleName,\n        });\n    }\n    return errors;\n}\nexport function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path = []) {\n    const errors = [];\n    const nextNonTerminals = getFirstNoneTerminal(currRule.definition);\n    if (nextNonTerminals.length === 0) {\n        return [];\n    }\n    else {\n        const ruleName = topRule.name;\n        const foundLeftRecursion = nextNonTerminals.includes(topRule);\n        if (foundLeftRecursion) {\n            errors.push({\n                message: errMsgProvider.buildLeftRecursionError({\n                    topLevelRule: topRule,\n                    leftRecursionPath: path,\n                }),\n                type: ParserDefinitionErrorType.LEFT_RECURSION,\n                ruleName: ruleName,\n            });\n        }\n        // we are only looking for cyclic paths leading back to the specific topRule\n        // other cyclic paths are ignored, we still need this difference to avoid infinite loops...\n        const excluded = path.concat([topRule]);\n        const validNextSteps = nextNonTerminals.filter((x) => !excluded.includes(x));\n        const errorsFromNextSteps = validNextSteps.flatMap((currRefRule) => {\n            const newPath = [...path];\n            newPath.push(currRefRule);\n            return validateNoLeftRecursion(topRule, currRefRule, errMsgProvider, newPath);\n        });\n        return errors.concat(errorsFromNextSteps);\n    }\n}\nexport function getFirstNoneTerminal(definition) {\n    let result = [];\n    if (definition.length === 0) {\n        return result;\n    }\n    const firstProd = definition[0];\n    /* istanbul ignore else */\n    if (firstProd instanceof NonTerminal) {\n        result.push(firstProd.referencedRule);\n    }\n    else if (firstProd instanceof AlternativeGAST ||\n        firstProd instanceof Option ||\n        firstProd instanceof RepetitionMandatory ||\n        firstProd instanceof RepetitionMandatoryWithSeparator ||\n        firstProd instanceof RepetitionWithSeparator ||\n        firstProd instanceof Repetition) {\n        result = result.concat(getFirstNoneTerminal(firstProd.definition));\n    }\n    else if (firstProd instanceof Alternation) {\n        // each sub definition in alternation is a FLAT\n        result = firstProd.definition\n            .map((currSubDef) => getFirstNoneTerminal(currSubDef.definition))\n            .flat();\n    }\n    else if (firstProd instanceof Terminal) {\n        // nothing to see, move along\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n    const isFirstOptional = isOptionalProd(firstProd);\n    const hasMore = definition.length > 1;\n    if (isFirstOptional && hasMore) {\n        const rest = definition.slice(1);\n        return result.concat(getFirstNoneTerminal(rest));\n    }\n    else {\n        return result;\n    }\n}\nclass OrCollector extends GAstVisitor {\n    constructor() {\n        super(...arguments);\n        this.alternations = [];\n    }\n    visitAlternation(node) {\n        this.alternations.push(node);\n    }\n}\nexport function validateEmptyOrAlternative(topLevelRule, errMsgProvider) {\n    const orCollector = new OrCollector();\n    topLevelRule.accept(orCollector);\n    const ors = orCollector.alternations;\n    const errors = ors.flatMap((currOr) => {\n        const exceptLast = currOr.definition.slice(0, -1);\n        return exceptLast.flatMap((currAlternative, currAltIdx) => {\n            const possibleFirstInAlt = nextPossibleTokensAfter([currAlternative], [], tokenStructuredMatcher, 1);\n            if (possibleFirstInAlt.length === 0) {\n                return [\n                    {\n                        message: errMsgProvider.buildEmptyAlternationError({\n                            topLevelRule: topLevelRule,\n                            alternation: currOr,\n                            emptyChoiceIdx: currAltIdx,\n                        }),\n                        type: ParserDefinitionErrorType.NONE_LAST_EMPTY_ALT,\n                        ruleName: topLevelRule.name,\n                        occurrence: currOr.idx,\n                        alternative: currAltIdx + 1,\n                    },\n                ];\n            }\n            else {\n                return [];\n            }\n        });\n    });\n    return errors;\n}\nexport function validateAmbiguousAlternationAlternatives(topLevelRule, globalMaxLookahead, errMsgProvider) {\n    const orCollector = new OrCollector();\n    topLevelRule.accept(orCollector);\n    let ors = orCollector.alternations;\n    // New Handling of ignoring ambiguities\n    // - https://github.com/chevrotain/chevrotain/issues/869\n    ors = ors.filter((currOr) => currOr.ignoreAmbiguities !== true);\n    const errors = ors.flatMap((currOr) => {\n        const currOccurrence = currOr.idx;\n        const actualMaxLookahead = currOr.maxLookahead || globalMaxLookahead;\n        const alternatives = getLookaheadPathsForOr(currOccurrence, topLevelRule, actualMaxLookahead, currOr);\n        const altsAmbiguityErrors = checkAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);\n        const altsPrefixAmbiguityErrors = checkPrefixAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);\n        return altsAmbiguityErrors.concat(altsPrefixAmbiguityErrors);\n    });\n    return errors;\n}\nexport class RepetitionCollector extends GAstVisitor {\n    constructor() {\n        super(...arguments);\n        this.allProductions = [];\n    }\n    visitRepetitionWithSeparator(manySep) {\n        this.allProductions.push(manySep);\n    }\n    visitRepetitionMandatory(atLeastOne) {\n        this.allProductions.push(atLeastOne);\n    }\n    visitRepetitionMandatoryWithSeparator(atLeastOneSep) {\n        this.allProductions.push(atLeastOneSep);\n    }\n    visitRepetition(many) {\n        this.allProductions.push(many);\n    }\n}\nexport function validateTooManyAlts(topLevelRule, errMsgProvider) {\n    const orCollector = new OrCollector();\n    topLevelRule.accept(orCollector);\n    const ors = orCollector.alternations;\n    const errors = ors.flatMap((currOr) => {\n        if (currOr.definition.length > 255) {\n            return [\n                {\n                    message: errMsgProvider.buildTooManyAlternativesError({\n                        topLevelRule: topLevelRule,\n                        alternation: currOr,\n                    }),\n                    type: ParserDefinitionErrorType.TOO_MANY_ALTS,\n                    ruleName: topLevelRule.name,\n                    occurrence: currOr.idx,\n                },\n            ];\n        }\n        else {\n            return [];\n        }\n    });\n    return errors;\n}\nexport function validateSomeNonEmptyLookaheadPath(topLevelRules, maxLookahead, errMsgProvider) {\n    const errors = [];\n    topLevelRules.forEach((currTopRule) => {\n        const collectorVisitor = new RepetitionCollector();\n        currTopRule.accept(collectorVisitor);\n        const allRuleProductions = collectorVisitor.allProductions;\n        allRuleProductions.forEach((currProd) => {\n            const prodType = getProdType(currProd);\n            const actualMaxLookahead = currProd.maxLookahead || maxLookahead;\n            const currOccurrence = currProd.idx;\n            const paths = getLookaheadPathsForOptionalProd(currOccurrence, currTopRule, prodType, actualMaxLookahead);\n            const pathsInsideProduction = paths[0];\n            if (pathsInsideProduction.flat().length === 0) {\n                const errMsg = errMsgProvider.buildEmptyRepetitionError({\n                    topLevelRule: currTopRule,\n                    repetition: currProd,\n                });\n                errors.push({\n                    message: errMsg,\n                    type: ParserDefinitionErrorType.NO_NON_EMPTY_LOOKAHEAD,\n                    ruleName: currTopRule.name,\n                });\n            }\n        });\n    });\n    return errors;\n}\nfunction checkAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {\n    const foundAmbiguousPaths = [];\n    const identicalAmbiguities = alternatives.reduce((result, currAlt, currAltIdx) => {\n        // ignore (skip) ambiguities with this alternative\n        if (alternation.definition[currAltIdx].ignoreAmbiguities === true) {\n            return result;\n        }\n        currAlt.forEach((currPath) => {\n            const altsCurrPathAppearsIn = [currAltIdx];\n            alternatives.forEach((currOtherAlt, currOtherAltIdx) => {\n                if (currAltIdx !== currOtherAltIdx &&\n                    containsPath(currOtherAlt, currPath) &&\n                    // ignore (skip) ambiguities with this \"other\" alternative\n                    alternation.definition[currOtherAltIdx].ignoreAmbiguities !== true) {\n                    altsCurrPathAppearsIn.push(currOtherAltIdx);\n                }\n            });\n            if (altsCurrPathAppearsIn.length > 1 &&\n                !containsPath(foundAmbiguousPaths, currPath)) {\n                foundAmbiguousPaths.push(currPath);\n                result.push({\n                    alts: altsCurrPathAppearsIn,\n                    path: currPath,\n                });\n            }\n        });\n        return result;\n    }, []);\n    const currErrors = identicalAmbiguities.map((currAmbDescriptor) => {\n        const ambgIndices = currAmbDescriptor.alts.map((currAltIdx) => currAltIdx + 1);\n        const currMessage = errMsgProvider.buildAlternationAmbiguityError({\n            topLevelRule: rule,\n            alternation: alternation,\n            ambiguityIndices: ambgIndices,\n            prefixPath: currAmbDescriptor.path,\n        });\n        return {\n            message: currMessage,\n            type: ParserDefinitionErrorType.AMBIGUOUS_ALTS,\n            ruleName: rule.name,\n            occurrence: alternation.idx,\n            alternatives: currAmbDescriptor.alts,\n        };\n    });\n    return currErrors;\n}\nexport function checkPrefixAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {\n    // flatten\n    const pathsAndIndices = alternatives.reduce((result, currAlt, idx) => {\n        const currPathsAndIdx = currAlt.map((currPath) => {\n            return { idx: idx, path: currPath };\n        });\n        return result.concat(currPathsAndIdx);\n    }, []);\n    const errors = pathsAndIndices.flatMap((currPathAndIdx) => {\n        const alternativeGast = alternation.definition[currPathAndIdx.idx];\n        // ignore (skip) ambiguities with this alternative\n        if (alternativeGast.ignoreAmbiguities === true) {\n            return [];\n        }\n        const targetIdx = currPathAndIdx.idx;\n        const targetPath = currPathAndIdx.path;\n        const prefixAmbiguitiesPathsAndIndices = pathsAndIndices.filter((searchPathAndIdx) => {\n            // prefix ambiguity can only be created from lower idx (higher priority) path\n            return (\n            // ignore (skip) ambiguities with this \"other\" alternative\n            alternation.definition[searchPathAndIdx.idx].ignoreAmbiguities !==\n                true &&\n                searchPathAndIdx.idx < targetIdx &&\n                // checking for strict prefix because identical lookaheads\n                // will be be detected using a different validation.\n                isStrictPrefixOfPath(searchPathAndIdx.path, targetPath));\n        });\n        const currPathPrefixErrors = prefixAmbiguitiesPathsAndIndices.map((currAmbPathAndIdx) => {\n            const ambgIndices = [currAmbPathAndIdx.idx + 1, targetIdx + 1];\n            const occurrence = alternation.idx === 0 ? \"\" : alternation.idx;\n            const message = errMsgProvider.buildAlternationPrefixAmbiguityError({\n                topLevelRule: rule,\n                alternation: alternation,\n                ambiguityIndices: ambgIndices,\n                prefixPath: currAmbPathAndIdx.path,\n            });\n            return {\n                message: message,\n                type: ParserDefinitionErrorType.AMBIGUOUS_PREFIX_ALTS,\n                ruleName: rule.name,\n                occurrence: occurrence,\n                alternatives: ambgIndices,\n            };\n        });\n        return currPathPrefixErrors;\n    });\n    return errors;\n}\nfunction checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider) {\n    const errors = [];\n    const tokenNames = tokenTypes.map((currToken) => currToken.name);\n    topLevels.forEach((currRule) => {\n        const currRuleName = currRule.name;\n        if (tokenNames.includes(currRuleName)) {\n            const errMsg = errMsgProvider.buildNamespaceConflictError(currRule);\n            errors.push({\n                message: errMsg,\n                type: ParserDefinitionErrorType.CONFLICT_TOKENS_RULES_NAMESPACE,\n                ruleName: currRuleName,\n            });\n        }\n    });\n    return errors;\n}\n//# sourceMappingURL=checks.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;AAKA,SAAgB,EAAkB,GAAS;CAMvC,OALyC,EAAQ,kBAAkB,SAAS;EACxE,OAAO,EAAQ;EACf,YAAY,EAAQ;EACpB,aAAa,EAAQ;EACxB,CACsC,CAAC,KAAK,MAAkB,OAAO,OAAO,EAAE,MAAM,EAA0B,6BAA6B,EAAE,EAAa,CAAE;;AAEjK,SAAgB,EAAgB,GAAW,GAAY,GAAgB,GAAa;CAChF,IAAM,IAAkB,EAAU,SAAS,MAAiB,EAA6B,GAAc,EAAe,CAAC,EACjH,IAA+B,EAAuC,GAAW,GAAY,EAAe,EAC5G,IAAoB,EAAU,SAAS,MAAY,EAAoB,GAAS,EAAe,CAAC,EAChG,IAAsB,EAAU,SAAS,MAAY,EAAgC,GAAS,GAAW,GAAa,EAAe,CAAC;CAC5I,OAAO,EAAgB,OAAO,GAA8B,GAAmB,EAAoB;;AAEvG,SAAS,EAA6B,GAAc,GAAgB;CAChE,IAAM,IAAmB,IAAI,GAA+B;CAC5D,EAAa,OAAO,EAAiB;CACrC,IAAM,IAAqB,EAAiB,gBACtC,IAAmB,OAAO,QAAQ,GAAoB,EAAgC,EACtF,IAAa,OAAO,YAAY,OAAO,QAAQ,EAAiB,CAAC,QAAQ,CAAC,GAAI,OAAe,EAAU,SAAS,EAAE,CAAC;CAkBzH,OAjBe,OAAO,OAAO,EAAW,CAAC,KAAK,MAAmB;EAC7D,IAAM,IAAY,EAAe,IAC3B,IAAM,EAAe,yBAAyB,GAAc,EAAe,EAC3E,IAAU,EAAqB,EAAU,EACzC,IAAW;GACb,SAAS;GACT,MAAM,EAA0B;GAChC,UAAU,EAAa;GACd;GACT,YAAY,EAAU;GACzB,EACK,IAAQ,EAA2B,EAAU;EAInD,OAHI,MACA,EAAS,YAAY,IAElB;GAEE;;AAEjB,SAAgB,EAAgC,GAAM;CAClD,OAAO,GAAG,EAAqB,EAAK,CAAC,KAAK,EAAK,IAAI,KAAK,EAA2B,EAAK;;AAE5F,SAAS,EAA2B,GAAM;CAQlC,OAPA,aAAgB,IACT,EAAK,aAAa,OAEpB,aAAgB,IACd,EAAK,kBAGL;;AAGf,IAAa,IAAb,cAAmD,EAAY;CAC3D,cAAc;EAEV,AADA,MAAM,GAAG,UAAU,EACnB,KAAK,iBAAiB,EAAE;;CAE5B,iBAAiB,GAAS;EACtB,KAAK,eAAe,KAAK,EAAQ;;CAErC,YAAY,GAAQ;EAChB,KAAK,eAAe,KAAK,EAAO;;CAEpC,6BAA6B,GAAS;EAClC,KAAK,eAAe,KAAK,EAAQ;;CAErC,yBAAyB,GAAY;EACjC,KAAK,eAAe,KAAK,EAAW;;CAExC,sCAAsC,GAAe;EACjD,KAAK,eAAe,KAAK,EAAc;;CAE3C,gBAAgB,GAAM;EAClB,KAAK,eAAe,KAAK,EAAK;;CAElC,iBAAiB,GAAI;EACjB,KAAK,eAAe,KAAK,EAAG;;CAEhC,cAAc,GAAU;EACpB,KAAK,eAAe,KAAK,EAAS;;;AAG1C,SAAgB,EAAgC,GAAM,GAAU,GAAW,GAAgB;CACvF,IAAM,IAAS,EAAE;CAOjB,IANoB,EAAS,QAAQ,GAAQ,MACrC,EAAQ,SAAS,EAAK,OACf,IAAS,IAEb,GACR,EACY,GAAG,GAAG;EACjB,IAAM,IAAS,EAAe,4BAA4B;GACtD,cAAc;GACd,aAAa;GAChB,CAAC;EACF,EAAO,KAAK;GACR,SAAS;GACT,MAAM,EAA0B;GAChC,UAAU,EAAK;GAClB,CAAC;;CAEN,OAAO;;AAKX,SAAgB,EAAyB,GAAU,GAAmB,GAAW;CAC7E,IAAM,IAAS,EAAE,EACb;CAWJ,OAVK,EAAkB,SAAS,EAAS,KACrC,IACI,kCAAkC,EAAS,4CAA4C,EAAU,uDAErG,EAAO,KAAK;EACR,SAAS;EACT,MAAM,EAA0B;EACtB;EACb,CAAC,GAEC;;AAEX,SAAgB,EAAwB,GAAS,GAAU,GAAgB,IAAO,EAAE,EAAE;CAClF,IAAM,IAAS,EAAE,EACX,IAAmB,EAAqB,EAAS,WAAW;CAClE,IAAI,EAAiB,WAAW,GAC5B,OAAO,EAAE;CAER;EACD,IAAM,IAAW,EAAQ;EAEzB,AAD2B,EAAiB,SAAS,EAC/B,IAClB,EAAO,KAAK;GACR,SAAS,EAAe,wBAAwB;IAC5C,cAAc;IACd,mBAAmB;IACtB,CAAC;GACF,MAAM,EAA0B;GACtB;GACb,CAAC;EAIN,IAAM,IAAW,EAAK,OAAO,CAAC,EAAQ,CAAC,EAEjC,IADiB,EAAiB,QAAQ,MAAM,CAAC,EAAS,SAAS,EAAE,CACjC,CAAC,SAAS,MAAgB;GAChE,IAAM,IAAU,CAAC,GAAG,EAAK;GAEzB,OADA,EAAQ,KAAK,EAAY,EAClB,EAAwB,GAAS,GAAa,GAAgB,EAAQ;IAC/E;EACF,OAAO,EAAO,OAAO,EAAoB;;;AAGjD,SAAgB,EAAqB,GAAY;CAC7C,IAAI,IAAS,EAAE;CACf,IAAI,EAAW,WAAW,GACtB,OAAO;CAEX,IAAM,IAAY,EAAW;;CAE7B,IAAI,aAAqB,GACrB,EAAO,KAAK,EAAU,eAAe;MAEpC,IAAI,aAAqBA,KAC1B,aAAqB,KACrB,aAAqB,KACrB,aAAqB,KACrB,aAAqB,KACrB,aAAqB,GACrB,IAAS,EAAO,OAAO,EAAqB,EAAU,WAAW,CAAC;MAEjE,IAAI,aAAqB,GAE1B,IAAS,EAAU,WACd,KAAK,MAAe,EAAqB,EAAW,WAAW,CAAC,CAChE,MAAM;MAEV,IAAI,eAAqB,IAI1B,MAAM,MAAM,uBAAuB;CAEvC,IAAM,IAAkB,EAAe,EAAU,EAC3C,IAAU,EAAW,SAAS;CACpC,IAAI,KAAmB,GAAS;EAC5B,IAAM,IAAO,EAAW,MAAM,EAAE;EAChC,OAAO,EAAO,OAAO,EAAqB,EAAK,CAAC;QAGhD,OAAO;;AAGf,IAAM,IAAN,cAA0B,EAAY;CAClC,cAAc;EAEV,AADA,MAAM,GAAG,UAAU,EACnB,KAAK,eAAe,EAAE;;CAE1B,iBAAiB,GAAM;EACnB,KAAK,aAAa,KAAK,EAAK;;;AAGpC,SAAgB,EAA2B,GAAc,GAAgB;CACrE,IAAM,IAAc,IAAI,GAAa;CA2BrC,OA1BA,EAAa,OAAO,EAAY,EACpB,EAAY,aACL,SAAS,MACL,EAAO,WAAW,MAAM,GAAG,GAC7B,CAAC,SAAS,GAAiB,MACb,EAAwB,CAAC,EAAgB,EAAE,EAAE,EAAE,GAAwB,EAC5E,CAAC,WAAW,IACvB,CACH;EACI,SAAS,EAAe,2BAA2B;GACjC;GACd,aAAa;GACb,gBAAgB;GACnB,CAAC;EACF,MAAM,EAA0B;EAChC,UAAU,EAAa;EACvB,YAAY,EAAO;EACnB,aAAa,IAAa;EAC7B,CACJ,GAGM,EAAE,CAEf,CAEO;;AAEjB,SAAgB,EAAyC,GAAc,GAAoB,GAAgB;CACvG,IAAM,IAAc,IAAI,GAAa;CACrC,EAAa,OAAO,EAAY;CAChC,IAAI,IAAM,EAAY;CAYtB,OATA,IAAM,EAAI,QAAQ,MAAW,EAAO,sBAAsB,GAAK,EAChD,EAAI,SAAS,MAAW;EACnC,IAAM,IAAiB,EAAO,KAExB,IAAe,EAAuB,GAAgB,GADjC,EAAO,gBAAgB,GAC4C,EAAO,EAC/F,IAAsB,EAA6B,GAAc,GAAQ,GAAc,EAAe,EACtG,IAA4B,EAAmC,GAAc,GAAQ,GAAc,EAAe;EACxH,OAAO,EAAoB,OAAO,EAA0B;GAEnD;;AAEjB,IAAa,IAAb,cAAyC,EAAY;CACjD,cAAc;EAEV,AADA,MAAM,GAAG,UAAU,EACnB,KAAK,iBAAiB,EAAE;;CAE5B,6BAA6B,GAAS;EAClC,KAAK,eAAe,KAAK,EAAQ;;CAErC,yBAAyB,GAAY;EACjC,KAAK,eAAe,KAAK,EAAW;;CAExC,sCAAsC,GAAe;EACjD,KAAK,eAAe,KAAK,EAAc;;CAE3C,gBAAgB,GAAM;EAClB,KAAK,eAAe,KAAK,EAAK;;;AAGtC,SAAgB,EAAoB,GAAc,GAAgB;CAC9D,IAAM,IAAc,IAAI,GAAa;CAqBrC,OApBA,EAAa,OAAO,EAAY,EACpB,EAAY,aACL,SAAS,MACpB,EAAO,WAAW,SAAS,MACpB,CACH;EACI,SAAS,EAAe,8BAA8B;GACpC;GACd,aAAa;GAChB,CAAC;EACF,MAAM,EAA0B;EAChC,UAAU,EAAa;EACvB,YAAY,EAAO;EACtB,CACJ,GAGM,EAAE,CAGJ;;AAEjB,SAAgB,EAAkC,GAAe,GAAc,GAAgB;CAC3F,IAAM,IAAS,EAAE;CAwBjB,OAvBA,EAAc,SAAS,MAAgB;EACnC,IAAM,IAAmB,IAAI,GAAqB;EAGlD,AAFA,EAAY,OAAO,EAAiB,EAEpC,EAD4C,eACzB,SAAS,MAAa;GACrC,IAAM,IAAW,EAAY,EAAS,EAChC,IAAqB,EAAS,gBAAgB,GAC9C,IAAiB,EAAS;GAGhC,IAFc,EAAiC,GAAgB,GAAa,GAAU,EACnD,CAAC,GACV,MAAM,CAAC,WAAW,GAAG;IAC3C,IAAM,IAAS,EAAe,0BAA0B;KACpD,cAAc;KACd,YAAY;KACf,CAAC;IACF,EAAO,KAAK;KACR,SAAS;KACT,MAAM,EAA0B;KAChC,UAAU,EAAY;KACzB,CAAC;;IAER;GACJ,EACK;;AAEX,SAAS,EAA6B,GAAc,GAAa,GAAM,GAAgB;CACnF,IAAM,IAAsB,EAAE;CA2C9B,OA1C6B,EAAa,QAAQ,GAAQ,GAAS,OAE3D,EAAY,WAAW,GAAY,sBAAsB,MAG7D,EAAQ,SAAS,MAAa;EAC1B,IAAM,IAAwB,CAAC,EAAW;EAS1C,AARA,EAAa,SAAS,GAAc,MAAoB;GACpD,AAAI,MAAe,KACf,EAAa,GAAc,EAAS,IAEpC,EAAY,WAAW,GAAiB,sBAAsB,MAC9D,EAAsB,KAAK,EAAgB;IAEjD,EACE,EAAsB,SAAS,KAC/B,CAAC,EAAa,GAAqB,EAAS,KAC5C,EAAoB,KAAK,EAAS,EAClC,EAAO,KAAK;GACR,MAAM;GACN,MAAM;GACT,CAAC;GAER,EApBS,IAsBZ,EAAE,CACkC,CAAC,KAAK,MAAsB;EAC/D,IAAM,IAAc,EAAkB,KAAK,KAAK,MAAe,IAAa,EAAE;EAO9E,OAAO;GACH,SAPgB,EAAe,+BAA+B;IAC9D,cAAc;IACD;IACb,kBAAkB;IAClB,YAAY,EAAkB;IACjC,CAEuB;GACpB,MAAM,EAA0B;GAChC,UAAU,EAAK;GACf,YAAY,EAAY;GACxB,cAAc,EAAkB;GACnC;GAEY;;AAErB,SAAgB,EAAmC,GAAc,GAAa,GAAM,GAAgB;CAEhG,IAAM,IAAkB,EAAa,QAAQ,GAAQ,GAAS,MAAQ;EAClE,IAAM,IAAkB,EAAQ,KAAK,OAC1B;GAAO;GAAK,MAAM;GAAU,EACrC;EACF,OAAO,EAAO,OAAO,EAAgB;IACtC,EAAE,CAAC;CAuCN,OAtCe,EAAgB,SAAS,MAAmB;EAGvD,IAFwB,EAAY,WAAW,EAAe,KAE1C,sBAAsB,IACtC,OAAO,EAAE;EAEb,IAAM,IAAY,EAAe,KAC3B,IAAa,EAAe;EA6BlC,OA5ByC,EAAgB,QAAQ,MAI7D,EAAY,WAAW,EAAiB,KAAK,sBACzC,MACA,EAAiB,MAAM,KAGvB,EAAqB,EAAiB,MAAM,EAAW,CAEF,CAAC,KAAK,MAAsB;GACrF,IAAM,IAAc,CAAC,EAAkB,MAAM,GAAG,IAAY,EAAE,EACxD,IAAa,EAAY,QAAQ,IAAI,KAAK,EAAY;GAO5D,OAAO;IACH,SAPY,EAAe,qCAAqC;KAChE,cAAc;KACD;KACb,kBAAkB;KAClB,YAAY,EAAkB;KACjC,CAEmB;IAChB,MAAM,EAA0B;IAChC,UAAU,EAAK;IACH;IACZ,cAAc;IACjB;IAEsB;GAElB;;AAEjB,SAAS,EAAuC,GAAW,GAAY,GAAgB;CACnF,IAAM,IAAS,EAAE,EACX,IAAa,EAAW,KAAK,MAAc,EAAU,KAAK;CAYhE,OAXA,EAAU,SAAS,MAAa;EAC5B,IAAM,IAAe,EAAS;EAC9B,IAAI,EAAW,SAAS,EAAa,EAAE;GACnC,IAAM,IAAS,EAAe,4BAA4B,EAAS;GACnE,EAAO,KAAK;IACR,SAAS;IACT,MAAM,EAA0B;IAChC,UAAU;IACb,CAAC;;GAER,EACK"}

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

@@ -1,27 +0,0 @@
-import { NonTerminal as e, Terminal as t } from "../../../../../@chevrotain/gast/lib/src/model.js";
-import { isBranchingProd as n, isOptionalProd as r, isSequenceProd as i } from "../../../../../@chevrotain/gast/lib/src/helpers.js";
-//#region ../../node_modules/chevrotain/lib/src/parse/grammar/first.js
-function a(r) {
-	/* istanbul ignore else */
-	if (r instanceof e) return a(r.referencedRule);
-	if (r instanceof t) return c(r);
-	if (i(r)) return o(r);
-	if (n(r)) return s(r);
-	throw Error("non exhaustive match");
-}
-function o(e) {
-	let t = [], n = e.definition, i = 0, o = n.length > i, s, c = !0;
-	for (; o && c;) s = n[i], c = r(s), t = t.concat(a(s)), i += 1, o = n.length > i;
-	return [...new Set(t)];
-}
-function s(e) {
-	let t = e.definition.map((e) => a(e));
-	return [...new Set(t.flat())];
-}
-function c(e) {
-	return [e.terminalType];
-}
-//#endregion
-export { a as first };
-
-//# sourceMappingURL=first.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"first.js","names":[],"sources":["../../../../../../../../../../node_modules/chevrotain/lib/src/parse/grammar/first.js"],"sourcesContent":["import { isBranchingProd, isOptionalProd, isSequenceProd, NonTerminal, Terminal, } from \"@chevrotain/gast\";\nexport function first(prod) {\n    /* istanbul ignore else */\n    if (prod instanceof NonTerminal) {\n        // this could in theory cause infinite loops if\n        // (1) prod A refs prod B.\n        // (2) prod B refs prod A\n        // (3) AB can match the empty set\n        // in other words a cycle where everything is optional so the first will keep\n        // looking ahead for the next optional part and will never exit\n        // currently there is no safeguard for this unique edge case because\n        // (1) not sure a grammar in which this can happen is useful for anything (productive)\n        return first(prod.referencedRule);\n    }\n    else if (prod instanceof Terminal) {\n        return firstForTerminal(prod);\n    }\n    else if (isSequenceProd(prod)) {\n        return firstForSequence(prod);\n    }\n    else if (isBranchingProd(prod)) {\n        return firstForBranching(prod);\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\nexport function firstForSequence(prod) {\n    let firstSet = [];\n    const seq = prod.definition;\n    let nextSubProdIdx = 0;\n    let hasInnerProdsRemaining = seq.length > nextSubProdIdx;\n    let currSubProd;\n    // so we enter the loop at least once (if the definition is not empty\n    let isLastInnerProdOptional = true;\n    // scan a sequence until it's end or until we have found a NONE optional production in it\n    while (hasInnerProdsRemaining && isLastInnerProdOptional) {\n        currSubProd = seq[nextSubProdIdx];\n        isLastInnerProdOptional = isOptionalProd(currSubProd);\n        firstSet = firstSet.concat(first(currSubProd));\n        nextSubProdIdx = nextSubProdIdx + 1;\n        hasInnerProdsRemaining = seq.length > nextSubProdIdx;\n    }\n    return [...new Set(firstSet)];\n}\nexport function firstForBranching(prod) {\n    const allAlternativesFirsts = prod.definition.map((innerProd) => {\n        return first(innerProd);\n    });\n    return [...new Set(allAlternativesFirsts.flat())];\n}\nexport function firstForTerminal(terminal) {\n    return [terminal.terminalType];\n}\n//# sourceMappingURL=first.js.map"],"x_google_ignoreList":[0],"mappings":";;;AACA,SAAgB,EAAM,GAAM;;CAExB,IAAI,aAAgB,GAShB,OAAO,EAAM,EAAK,eAAe;CAEhC,IAAI,aAAgB,GACrB,OAAO,EAAiB,EAAK;CAE5B,IAAI,EAAe,EAAK,EACzB,OAAO,EAAiB,EAAK;CAE5B,IAAI,EAAgB,EAAK,EAC1B,OAAO,EAAkB,EAAK;CAG9B,MAAM,MAAM,uBAAuB;;AAG3C,SAAgB,EAAiB,GAAM;CACnC,IAAI,IAAW,EAAE,EACX,IAAM,EAAK,YACb,IAAiB,GACjB,IAAyB,EAAI,SAAS,GACtC,GAEA,IAA0B;CAE9B,OAAO,KAA0B,IAK7B,AAJA,IAAc,EAAI,IAClB,IAA0B,EAAe,EAAY,EACrD,IAAW,EAAS,OAAO,EAAM,EAAY,CAAC,EAC9C,KAAkC,GAClC,IAAyB,EAAI,SAAS;CAE1C,OAAO,CAAC,GAAG,IAAI,IAAI,EAAS,CAAC;;AAEjC,SAAgB,EAAkB,GAAM;CACpC,IAAM,IAAwB,EAAK,WAAW,KAAK,MACxC,EAAM,EAAU,CACzB;CACF,OAAO,CAAC,GAAG,IAAI,IAAI,EAAsB,MAAM,CAAC,CAAC;;AAErD,SAAgB,EAAiB,GAAU;CACvC,OAAO,CAAC,EAAS,aAAa"}

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

@@ -1,32 +0,0 @@
-import { Alternative as e } from "../../../../../@chevrotain/gast/lib/src/model.js";
-import { RestWalker as t } from "./rest.js";
-import { first as n } from "./first.js";
-import { IN as r } from "../constants.js";
-//#region ../../node_modules/chevrotain/lib/src/parse/grammar/follow.js
-var i = class extends t {
-	constructor(e) {
-		super(), this.topProd = e, this.follows = {};
-	}
-	startWalking() {
-		return this.walk(this.topProd), this.follows;
-	}
-	walkTerminal(e, t, n) {}
-	walkProdRef(t, r, i) {
-		let a = o(t.referencedRule, t.idx) + this.topProd.name, s = n(new e({ definition: r.concat(i) }));
-		this.follows[a] = s;
-	}
-};
-function a(e) {
-	let t = {};
-	return e.forEach((e) => {
-		let n = new i(e).startWalking();
-		Object.assign(t, n);
-	}), t;
-}
-function o(e, t) {
-	return e.name + t + r;
-}
-//#endregion
-export { a as computeAllProdsFollows };
-
-//# sourceMappingURL=follow.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"follow.js","names":[],"sources":["../../../../../../../../../../node_modules/chevrotain/lib/src/parse/grammar/follow.js"],"sourcesContent":["import { RestWalker } from \"./rest.js\";\nimport { first } from \"./first.js\";\nimport { IN } from \"../constants.js\";\nimport { Alternative } from \"@chevrotain/gast\";\n// This ResyncFollowsWalker computes all of the follows required for RESYNC\n// (skipping reference production).\nexport class ResyncFollowsWalker extends RestWalker {\n    constructor(topProd) {\n        super();\n        this.topProd = topProd;\n        this.follows = {};\n    }\n    startWalking() {\n        this.walk(this.topProd);\n        return this.follows;\n    }\n    walkTerminal(terminal, currRest, prevRest) {\n        // do nothing! just like in the public sector after 13:00\n    }\n    walkProdRef(refProd, currRest, prevRest) {\n        const followName = buildBetweenProdsFollowPrefix(refProd.referencedRule, refProd.idx) +\n            this.topProd.name;\n        const fullRest = currRest.concat(prevRest);\n        const restProd = new Alternative({ definition: fullRest });\n        const t_in_topProd_follows = first(restProd);\n        this.follows[followName] = t_in_topProd_follows;\n    }\n}\nexport function computeAllProdsFollows(topProductions) {\n    const reSyncFollows = {};\n    topProductions.forEach((topProd) => {\n        const currRefsFollow = new ResyncFollowsWalker(topProd).startWalking();\n        Object.assign(reSyncFollows, currRefsFollow);\n    });\n    return reSyncFollows;\n}\nexport function buildBetweenProdsFollowPrefix(inner, occurenceInParent) {\n    return inner.name + occurenceInParent + IN;\n}\nexport function buildInProdFollowPrefix(terminal) {\n    const terminalName = terminal.terminalType.name;\n    return terminalName + terminal.idx + IN;\n}\n//# sourceMappingURL=follow.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;AAMA,IAAa,IAAb,cAAyC,EAAW;CAChD,YAAY,GAAS;EAGjB,AAFA,OAAO,EACP,KAAK,UAAU,GACf,KAAK,UAAU,EAAE;;CAErB,eAAe;EAEX,OADA,KAAK,KAAK,KAAK,QAAQ,EAChB,KAAK;;CAEhB,aAAa,GAAU,GAAU,GAAU;CAG3C,YAAY,GAAS,GAAU,GAAU;EACrC,IAAM,IAAa,EAA8B,EAAQ,gBAAgB,EAAQ,IAAI,GACjF,KAAK,QAAQ,MAGX,IAAuB,EAAM,IADd,EAAY,EAAE,YADlB,EAAS,OAAO,EACsB,EAAE,CACd,CAAC;EAC5C,KAAK,QAAQ,KAAc;;;AAGnC,SAAgB,EAAuB,GAAgB;CACnD,IAAM,IAAgB,EAAE;CAKxB,OAJA,EAAe,SAAS,MAAY;EAChC,IAAM,IAAiB,IAAI,EAAoB,EAAQ,CAAC,cAAc;EACtE,OAAO,OAAO,GAAe,EAAe;GAC9C,EACK;;AAEX,SAAgB,EAA8B,GAAO,GAAmB;CACpE,OAAO,EAAM,OAAO,IAAoB"}

package/lib/esm/node_modules/chevrotain/lib/src/parse/grammar/gast/gast_resolver_public.js

@@ -1,18 +0,0 @@
-import { defaultGrammarResolverErrorProvider as e, defaultGrammarValidatorErrorProvider as t } from "../../errors_public.js";
-import { resolveGrammar as n } from "../resolver.js";
-import { validateGrammar as r } from "../checks.js";
-//#region ../../node_modules/chevrotain/lib/src/parse/grammar/gast/gast_resolver_public.js
-function i(t) {
-	let r = Object.assign({ errMsgProvider: e }, t), i = {};
-	return t.rules.forEach((e) => {
-		i[e.name] = e;
-	}), n(i, r.errMsgProvider);
-}
-function a(e) {
-	let n = e.errMsgProvider ?? t;
-	return r(e.rules, e.tokenTypes, n, e.grammarName);
-}
-//#endregion
-export { i as resolveGrammar, a as validateGrammar };
-
-//# sourceMappingURL=gast_resolver_public.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"gast_resolver_public.js","names":["orgResolveGrammar","orgValidateGrammar"],"sources":["../../../../../../../../../../../node_modules/chevrotain/lib/src/parse/grammar/gast/gast_resolver_public.js"],"sourcesContent":["import { resolveGrammar as orgResolveGrammar } from \"../resolver.js\";\nimport { validateGrammar as orgValidateGrammar } from \"../checks.js\";\nimport { defaultGrammarResolverErrorProvider, defaultGrammarValidatorErrorProvider, } from \"../../errors_public.js\";\nexport function resolveGrammar(options) {\n    const actualOptions = Object.assign({ errMsgProvider: defaultGrammarResolverErrorProvider }, options);\n    const topRulesTable = {};\n    options.rules.forEach((rule) => {\n        topRulesTable[rule.name] = rule;\n    });\n    return orgResolveGrammar(topRulesTable, actualOptions.errMsgProvider);\n}\nexport function validateGrammar(options) {\n    var _a;\n    const errMsgProvider = (_a = options.errMsgProvider) !== null && _a !== void 0 ? _a : defaultGrammarValidatorErrorProvider;\n    return orgValidateGrammar(options.rules, options.tokenTypes, errMsgProvider, options.grammarName);\n}\n//# sourceMappingURL=gast_resolver_public.js.map"],"x_google_ignoreList":[0],"mappings":";;;;AAGA,SAAgB,EAAe,GAAS;CACpC,IAAM,IAAgB,OAAO,OAAO,EAAE,gBAAgB,GAAqC,EAAE,EAAQ,EAC/F,IAAgB,EAAE;CAIxB,OAHA,EAAQ,MAAM,SAAS,MAAS;EAC5B,EAAc,EAAK,QAAQ;GAC7B,EACKA,EAAkB,GAAe,EAAc,eAAe;;AAEzE,SAAgB,EAAgB,GAAS;CAErC,IAAM,IAAuB,EAAQ,kBAAiD;CACtF,OAAOC,EAAmB,EAAQ,OAAO,EAAQ,YAAY,GAAgB,EAAQ,YAAY"}