@plumile/ui 0.1.112 → 0.1.114

package/lib/esm/node_modules/langium/lib/parser/parser-builder-base.js

@@ -1,278 +0,0 @@
-import { stream as e } from "../utils/stream.js";
-import { isAbstractParserRule as t, isAction as n, isAlternatives as r, isAssignment as i, isBooleanLiteral as a, isConjunction as o, isCrossReference as s, isDisjunction as c, isEndOfFile as l, isGroup as u, isInfixRule as d, isKeyword as f, isNegation as p, isParameterReference as m, isParserRule as h, isRuleCall as g, isTerminalRule as _, isUnorderedGroup as v } from "../languages/generated/ast.js";
-import { ErrorWithLocation as y, assertUnreachable as b } from "../utils/errors.js";
-import { findNameAssignment as x, getAllReachableRules as S, getTypeName as C } from "../utils/grammar-utils.js";
-import { EOF as w } from "../../../chevrotain/lib/src/scan/tokens_public.js";
-import { EMPTY_ALT as T } from "../../../chevrotain/lib/src/parse/parser/parser.js";
-import "../../../chevrotain/lib/src/api.js";
-//#region ../../node_modules/langium/lib/parser/parser-builder-base.js
-function E(e, t, n) {
-	return D({
-		parser: t,
-		tokens: n,
-		ruleNames: /* @__PURE__ */ new Map()
-	}, e), t;
-}
-function D(t, n) {
-	let r = S(n, !1), i = e(n.rules).filter(h).filter((e) => r.has(e));
-	for (let e of i) {
-		let n = {
-			...t,
-			consume: 1,
-			optional: 1,
-			subrule: 1,
-			many: 1,
-			or: 1
-		};
-		t.parser.rule(e, k(n, e.definition));
-	}
-	let a = e(n.rules).filter(d).filter((e) => r.has(e));
-	for (let e of a) t.parser.rule(e, O(t, e));
-}
-function O(e, t) {
-	let n = t.call.rule.ref;
-	if (!n) throw Error("Could not resolve reference to infix operator rule: " + t.call.rule.$refText);
-	if (_(n)) throw Error("Cannot use terminal rule in infix expression");
-	let r = t.operators.precedences.flatMap((e) => e.operators), i = {
-		$type: "Group",
-		elements: []
-	}, a = {
-		$container: i,
-		$type: "Assignment",
-		feature: "parts",
-		operator: "+=",
-		terminal: t.call
-	}, o = {
-		$container: i,
-		$type: "Group",
-		elements: [],
-		cardinality: "*"
-	};
-	i.elements.push(a, o);
-	let s = {
-		$container: o,
-		$type: "Assignment",
-		feature: "operators",
-		operator: "+=",
-		terminal: {
-			$type: "Alternatives",
-			elements: r
-		}
-	}, c = {
-		...a,
-		$container: o
-	};
-	o.elements.push(s, c);
-	let l = r.map((t) => e.tokens[t.value]).map((t, n) => ({ ALT: () => e.parser.consume(n, t, s) })), u;
-	return (t) => {
-		u ??= V(e, n), e.parser.subrule(0, u, !1, a, t), e.parser.many(0, { DEF: () => {
-			e.parser.alternatives(0, l), e.parser.subrule(1, u, !1, c, t);
-		} });
-	};
-}
-function k(e, t, a = !1) {
-	let o;
-	if (f(t)) o = z(e, t);
-	else if (n(t)) o = A(e, t);
-	else if (i(t)) o = k(e, t.terminal);
-	else if (s(t)) o = R(e, t);
-	else if (g(t)) o = j(e, t);
-	else if (r(t)) o = P(e, t);
-	else if (v(t)) o = F(e, t);
-	else if (u(t)) o = I(e, t);
-	else if (l(t)) {
-		let n = e.consume++;
-		o = () => e.parser.consume(n, w, t);
-	} else throw new y(t.$cstNode, `Unexpected element type: ${t.$type}`);
-	return B(e, a ? void 0 : L(t), o, t.cardinality);
-}
-function A(e, t) {
-	let n = C(t);
-	return () => e.parser.action(n, t);
-}
-function j(e, n) {
-	let r = n.rule.ref;
-	if (t(r)) {
-		let t = e.subrule++, i = h(r) && r.fragment, a = n.arguments.length > 0 ? M(r, n.arguments) : () => ({}), o;
-		return (s) => {
-			o ??= V(e, r), e.parser.subrule(t, o, i, n, a(s));
-		};
-	} else if (_(r)) {
-		let t = e.consume++, i = U(e, r.name);
-		return () => e.parser.consume(t, i, n);
-	} else if (r) b(r);
-	else throw new y(n.$cstNode, `Undefined rule: ${n.rule.$refText}`);
-}
-function M(e, t) {
-	if (t.some((e) => e.calledByName)) {
-		let e = t.map((e) => ({
-			parameterName: e.parameter?.ref?.name,
-			predicate: N(e.value)
-		}));
-		return (t) => {
-			let n = {};
-			for (let { parameterName: r, predicate: i } of e) r && (n[r] = i(t));
-			return n;
-		};
-	} else {
-		let n = t.map((e) => N(e.value));
-		return (t) => {
-			let r = {};
-			for (let i = 0; i < n.length; i++) if (i < e.parameters.length) {
-				let a = e.parameters[i].name, o = n[i];
-				r[a] = o(t);
-			}
-			return r;
-		};
-	}
-}
-function N(e) {
-	if (c(e)) {
-		let t = N(e.left), n = N(e.right);
-		return (e) => t(e) || n(e);
-	} else if (o(e)) {
-		let t = N(e.left), n = N(e.right);
-		return (e) => t(e) && n(e);
-	} else if (p(e)) {
-		let t = N(e.value);
-		return (e) => !t(e);
-	} else if (m(e)) {
-		let t = e.parameter.ref.name;
-		return (e) => e !== void 0 && e[t] === !0;
-	} else if (a(e)) {
-		let t = !!e.true;
-		return () => t;
-	}
-	b(e);
-}
-function P(e, t) {
-	if (t.elements.length === 1) return k(e, t.elements[0]);
-	{
-		let n = [];
-		for (let r of t.elements) {
-			let t = { ALT: k(e, r, !0) }, i = L(r);
-			i && (t.GATE = N(i)), n.push(t);
-		}
-		let r = e.or++;
-		return (t) => e.parser.alternatives(r, n.map((e) => {
-			let n = { ALT: () => e.ALT(t) }, r = e.GATE;
-			return r && (n.GATE = () => r(t)), n;
-		}));
-	}
-}
-function F(e, t) {
-	if (t.elements.length === 1) return k(e, t.elements[0]);
-	let n = [];
-	for (let r of t.elements) {
-		let t = { ALT: k(e, r, !0) }, i = L(r);
-		i && (t.GATE = N(i)), n.push(t);
-	}
-	let r = e.or++, i = (e, t) => `uGroup_${e}_${t.getRuleStack().join("-")}`, a = B(e, L(t), (t) => e.parser.alternatives(r, n.map((n, a) => {
-		let o = { ALT: () => !0 }, s = e.parser;
-		o.ALT = () => {
-			if (n.ALT(t), !s.isRecording()) {
-				let e = i(r, s);
-				s.unorderedGroups.get(e) || s.unorderedGroups.set(e, []);
-				let t = s.unorderedGroups.get(e);
-				t?.[a] === void 0 && (t[a] = !0);
-			}
-		};
-		let c = n.GATE;
-		return c ? o.GATE = () => c(t) : o.GATE = () => !s.unorderedGroups.get(i(r, s))?.[a], o;
-	})), "*");
-	return (t) => {
-		a(t), e.parser.isRecording() || e.parser.unorderedGroups.delete(i(r, e.parser));
-	};
-}
-function I(e, t) {
-	let n = t.elements.map((t) => k(e, t));
-	return (e) => n.forEach((t) => t(e));
-}
-function L(e) {
-	if (u(e)) return e.guardCondition;
-}
-function R(e, t, n = t.terminal) {
-	if (!n) {
-		if (!t.type.ref) throw Error("Could not resolve reference to type: " + t.type.$refText);
-		let n = x(t.type.ref)?.terminal;
-		if (!n) throw Error("Could not find name assignment for type: " + C(t.type.ref));
-		return R(e, t, n);
-	} else if (g(n) && h(n.rule.ref)) {
-		let r = n.rule.ref, i = e.subrule++, a;
-		return (n) => {
-			a ??= V(e, r), e.parser.subrule(i, a, !1, t, n);
-		};
-	} else if (g(n) && _(n.rule.ref)) {
-		let r = e.consume++, i = U(e, n.rule.ref.name);
-		return () => e.parser.consume(r, i, t);
-	} else if (f(n)) {
-		let r = e.consume++, i = U(e, n.value);
-		return () => e.parser.consume(r, i, t);
-	} else throw Error("Could not build cross reference parser");
-}
-function z(e, t) {
-	let n = e.consume++, r = e.tokens[t.value];
-	if (!r) throw Error("Could not find token for keyword: " + t.value);
-	return () => e.parser.consume(n, r, t);
-}
-function B(e, t, n, r) {
-	let i = t && N(t);
-	if (!r) if (i) {
-		let t = e.or++;
-		return (r) => e.parser.alternatives(t, [{
-			ALT: () => n(r),
-			GATE: () => i(r)
-		}, {
-			ALT: T(),
-			GATE: () => !i(r)
-		}]);
-	} else return n;
-	if (r === "*") {
-		let t = e.many++;
-		return (r) => e.parser.many(t, {
-			DEF: () => n(r),
-			GATE: i ? () => i(r) : void 0
-		});
-	} else if (r === "+") {
-		let t = e.many++;
-		if (i) {
-			let r = e.or++;
-			return (a) => e.parser.alternatives(r, [{
-				ALT: () => e.parser.atLeastOne(t, { DEF: () => n(a) }),
-				GATE: () => i(a)
-			}, {
-				ALT: T(),
-				GATE: () => !i(a)
-			}]);
-		} else return (r) => e.parser.atLeastOne(t, { DEF: () => n(r) });
-	} else if (r === "?") {
-		let t = e.optional++;
-		return (r) => e.parser.optional(t, {
-			DEF: () => n(r),
-			GATE: i ? () => i(r) : void 0
-		});
-	} else b(r);
-}
-function V(e, t) {
-	let n = H(e, t), r = e.parser.getRule(n);
-	if (!r) throw Error(`Rule "${n}" not found."`);
-	return r;
-}
-function H(e, n) {
-	if (t(n)) return n.name;
-	if (e.ruleNames.has(n)) return e.ruleNames.get(n);
-	{
-		let t = n, i = t.$container, a = n.$type;
-		for (; !h(i);) (u(i) || r(i) || v(i)) && (a = i.elements.indexOf(t).toString() + ":" + a), t = i, i = i.$container;
-		return a = i.name + ":" + a, e.ruleNames.set(n, a), a;
-	}
-}
-function U(e, t) {
-	let n = e.tokens[t];
-	if (!n) throw Error(`Token "${t}" not found."`);
-	return n;
-}
-//#endregion
-export { E as createParser };
-
-//# sourceMappingURL=parser-builder-base.js.map

package/lib/esm/node_modules/langium/lib/parser/parser-builder-base.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parser-builder-base.js","names":["rule"],"sources":["../../../../../../../../node_modules/langium/lib/parser/parser-builder-base.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { EMPTY_ALT, EOF } from 'chevrotain';\nimport { isAction, isAlternatives, isEndOfFile, isAssignment, isConjunction, isCrossReference, isDisjunction, isGroup, isKeyword, isNegation, isParameterReference, isParserRule, isRuleCall, isTerminalRule, isUnorderedGroup, isBooleanLiteral, isInfixRule, isAbstractParserRule } from '../languages/generated/ast.js';\nimport { assertUnreachable, ErrorWithLocation } from '../utils/errors.js';\nimport { stream } from '../utils/stream.js';\nimport { findNameAssignment, getAllReachableRules, getTypeName } from '../utils/grammar-utils.js';\nexport function createParser(grammar, parser, tokens) {\n    const parserContext = {\n        parser,\n        tokens,\n        ruleNames: new Map()\n    };\n    buildRules(parserContext, grammar);\n    return parser;\n}\nfunction buildRules(parserContext, grammar) {\n    const reachable = getAllReachableRules(grammar, false);\n    const parserRules = stream(grammar.rules).filter(isParserRule).filter(rule => reachable.has(rule));\n    for (const rule of parserRules) {\n        const ctx = {\n            ...parserContext,\n            consume: 1,\n            optional: 1,\n            subrule: 1,\n            many: 1,\n            or: 1\n        };\n        parserContext.parser.rule(rule, buildElement(ctx, rule.definition));\n    }\n    const infixRules = stream(grammar.rules).filter(isInfixRule).filter(rule => reachable.has(rule));\n    for (const rule of infixRules) {\n        parserContext.parser.rule(rule, buildInfixRule(parserContext, rule));\n    }\n}\nfunction buildInfixRule(ctx, rule) {\n    const expressionRule = rule.call.rule.ref;\n    if (!expressionRule) {\n        throw new Error('Could not resolve reference to infix operator rule: ' + rule.call.rule.$refText);\n    }\n    if (isTerminalRule(expressionRule)) {\n        throw new Error('Cannot use terminal rule in infix expression');\n    }\n    // We need to construct a bunch of synthetic grammar AST nodes here\n    // This ensures that the CST and completion engine get populated as expected\n    const allKeywords = rule.operators.precedences.flatMap(e => e.operators);\n    // The outer group represents the first expression call and the whole (optional) loop\n    const outerGroup = {\n        $type: 'Group',\n        elements: []\n    };\n    const part1Assignment = {\n        $container: outerGroup,\n        $type: 'Assignment',\n        feature: 'parts',\n        operator: '+=',\n        terminal: rule.call\n    };\n    // The inner group represents the loop that contains the operator and expression call\n    // It can be infinitely repeated\n    const innerGroup = {\n        $container: outerGroup,\n        $type: 'Group',\n        elements: [],\n        cardinality: '*'\n    };\n    outerGroup.elements.push(part1Assignment, innerGroup);\n    // Store all operator keywords in one alternative/assignment\n    const alternatives = {\n        $type: 'Alternatives',\n        elements: allKeywords\n    };\n    const operatorAssignment = {\n        $container: innerGroup,\n        $type: 'Assignment',\n        feature: 'operators',\n        operator: '+=',\n        terminal: alternatives\n    };\n    // We need a second assignment of the called expression here\n    const part2Assignment = {\n        ...part1Assignment,\n        $container: innerGroup\n    };\n    innerGroup.elements.push(operatorAssignment, part2Assignment);\n    const tokens = allKeywords.map(e => ctx.tokens[e.value]);\n    const orAlts = tokens.map((token, index) => ({\n        ALT: () => ctx.parser.consume(index, token, operatorAssignment)\n    }));\n    let subrule;\n    return (args) => {\n        subrule ?? (subrule = getRule(ctx, expressionRule));\n        ctx.parser.subrule(0, subrule, false, part1Assignment, args);\n        ctx.parser.many(0, {\n            DEF: () => {\n                ctx.parser.alternatives(0, orAlts);\n                ctx.parser.subrule(1, subrule, false, part2Assignment, args);\n            }\n        });\n    };\n}\nfunction buildElement(ctx, element, ignoreGuard = false) {\n    let method;\n    if (isKeyword(element)) {\n        method = buildKeyword(ctx, element);\n    }\n    else if (isAction(element)) {\n        method = buildAction(ctx, element);\n    }\n    else if (isAssignment(element)) {\n        method = buildElement(ctx, element.terminal);\n    }\n    else if (isCrossReference(element)) {\n        method = buildCrossReference(ctx, element);\n    }\n    else if (isRuleCall(element)) {\n        method = buildRuleCall(ctx, element);\n    }\n    else if (isAlternatives(element)) {\n        method = buildAlternatives(ctx, element);\n    }\n    else if (isUnorderedGroup(element)) {\n        method = buildUnorderedGroup(ctx, element);\n    }\n    else if (isGroup(element)) {\n        method = buildGroup(ctx, element);\n    }\n    else if (isEndOfFile(element)) {\n        const idx = ctx.consume++;\n        method = () => ctx.parser.consume(idx, EOF, element);\n    }\n    else {\n        throw new ErrorWithLocation(element.$cstNode, `Unexpected element type: ${element.$type}`);\n    }\n    return wrap(ctx, ignoreGuard ? undefined : getGuardCondition(element), method, element.cardinality);\n}\nfunction buildAction(ctx, action) {\n    const actionType = getTypeName(action);\n    return () => ctx.parser.action(actionType, action);\n}\nfunction buildRuleCall(ctx, ruleCall) {\n    const rule = ruleCall.rule.ref;\n    if (isAbstractParserRule(rule)) {\n        const idx = ctx.subrule++;\n        const fragment = isParserRule(rule) && rule.fragment;\n        const predicate = ruleCall.arguments.length > 0 ? buildRuleCallPredicate(rule, ruleCall.arguments) : () => ({});\n        let subrule;\n        return (args) => {\n            subrule ?? (subrule = getRule(ctx, rule));\n            ctx.parser.subrule(idx, subrule, fragment, ruleCall, predicate(args));\n        };\n    }\n    else if (isTerminalRule(rule)) {\n        const idx = ctx.consume++;\n        const method = getToken(ctx, rule.name);\n        return () => ctx.parser.consume(idx, method, ruleCall);\n    }\n    else if (!rule) {\n        throw new ErrorWithLocation(ruleCall.$cstNode, `Undefined rule: ${ruleCall.rule.$refText}`);\n    }\n    else {\n        assertUnreachable(rule);\n    }\n}\nfunction buildRuleCallPredicate(rule, namedArgs) {\n    const hasNamedArguments = namedArgs.some(arg => arg.calledByName);\n    if (hasNamedArguments) {\n        const namedPredicates = namedArgs.map(arg => ({\n            parameterName: arg.parameter?.ref?.name,\n            predicate: buildPredicate(arg.value)\n        }));\n        return (args) => {\n            const ruleArgs = {};\n            for (const { parameterName, predicate } of namedPredicates) {\n                if (parameterName) {\n                    ruleArgs[parameterName] = predicate(args);\n                }\n            }\n            return ruleArgs;\n        };\n    }\n    else {\n        const predicates = namedArgs.map(arg => buildPredicate(arg.value));\n        return (args) => {\n            const ruleArgs = {};\n            for (let i = 0; i < predicates.length; i++) {\n                if (i < rule.parameters.length) {\n                    const parameterName = rule.parameters[i].name;\n                    const predicate = predicates[i];\n                    ruleArgs[parameterName] = predicate(args);\n                }\n            }\n            return ruleArgs;\n        };\n    }\n}\nfunction buildPredicate(condition) {\n    if (isDisjunction(condition)) {\n        const left = buildPredicate(condition.left);\n        const right = buildPredicate(condition.right);\n        return (args) => (left(args) || right(args));\n    }\n    else if (isConjunction(condition)) {\n        const left = buildPredicate(condition.left);\n        const right = buildPredicate(condition.right);\n        return (args) => (left(args) && right(args));\n    }\n    else if (isNegation(condition)) {\n        const value = buildPredicate(condition.value);\n        return (args) => !value(args);\n    }\n    else if (isParameterReference(condition)) {\n        const name = condition.parameter.ref.name;\n        return (args) => args !== undefined && args[name] === true;\n    }\n    else if (isBooleanLiteral(condition)) {\n        const value = Boolean(condition.true);\n        return () => value;\n    }\n    assertUnreachable(condition);\n}\nfunction buildAlternatives(ctx, alternatives) {\n    if (alternatives.elements.length === 1) {\n        return buildElement(ctx, alternatives.elements[0]);\n    }\n    else {\n        const methods = [];\n        for (const element of alternatives.elements) {\n            const predicatedMethod = {\n                // Since we handle the guard condition in the alternative already\n                // We can ignore the group guard condition inside\n                ALT: buildElement(ctx, element, true)\n            };\n            const guard = getGuardCondition(element);\n            if (guard) {\n                predicatedMethod.GATE = buildPredicate(guard);\n            }\n            methods.push(predicatedMethod);\n        }\n        const idx = ctx.or++;\n        return (args) => ctx.parser.alternatives(idx, methods.map(method => {\n            const alt = {\n                ALT: () => method.ALT(args)\n            };\n            const gate = method.GATE;\n            if (gate) {\n                alt.GATE = () => gate(args);\n            }\n            return alt;\n        }));\n    }\n}\nfunction buildUnorderedGroup(ctx, group) {\n    if (group.elements.length === 1) {\n        return buildElement(ctx, group.elements[0]);\n    }\n    const methods = [];\n    for (const element of group.elements) {\n        const predicatedMethod = {\n            // Since we handle the guard condition in the alternative already\n            // We can ignore the group guard condition inside\n            ALT: buildElement(ctx, element, true)\n        };\n        const guard = getGuardCondition(element);\n        if (guard) {\n            predicatedMethod.GATE = buildPredicate(guard);\n        }\n        methods.push(predicatedMethod);\n    }\n    const orIdx = ctx.or++;\n    const idFunc = (groupIdx, lParser) => {\n        const stackId = lParser.getRuleStack().join('-');\n        return `uGroup_${groupIdx}_${stackId}`;\n    };\n    const alternatives = (args) => ctx.parser.alternatives(orIdx, methods.map((method, idx) => {\n        const alt = { ALT: () => true };\n        const parser = ctx.parser;\n        alt.ALT = () => {\n            method.ALT(args);\n            if (!parser.isRecording()) {\n                const key = idFunc(orIdx, parser);\n                if (!parser.unorderedGroups.get(key)) {\n                    // init after clear state\n                    parser.unorderedGroups.set(key, []);\n                }\n                const groupState = parser.unorderedGroups.get(key);\n                if (typeof groupState?.[idx] === 'undefined') {\n                    // Not accessed yet\n                    groupState[idx] = true;\n                }\n            }\n        };\n        const gate = method.GATE;\n        if (gate) {\n            alt.GATE = () => gate(args);\n        }\n        else {\n            alt.GATE = () => {\n                const trackedAlternatives = parser.unorderedGroups.get(idFunc(orIdx, parser));\n                const allow = !trackedAlternatives?.[idx];\n                return allow;\n            };\n        }\n        return alt;\n    }));\n    const wrapped = wrap(ctx, getGuardCondition(group), alternatives, '*');\n    return (args) => {\n        wrapped(args);\n        if (!ctx.parser.isRecording()) {\n            ctx.parser.unorderedGroups.delete(idFunc(orIdx, ctx.parser));\n        }\n    };\n}\nfunction buildGroup(ctx, group) {\n    const methods = group.elements.map(e => buildElement(ctx, e));\n    return (args) => methods.forEach(method => method(args));\n}\nfunction getGuardCondition(element) {\n    if (isGroup(element)) {\n        return element.guardCondition;\n    }\n    return undefined;\n}\nfunction buildCrossReference(ctx, crossRef, terminal = crossRef.terminal) {\n    if (!terminal) {\n        if (!crossRef.type.ref) {\n            throw new Error('Could not resolve reference to type: ' + crossRef.type.$refText);\n        }\n        const assignment = findNameAssignment(crossRef.type.ref);\n        const assignTerminal = assignment?.terminal;\n        if (!assignTerminal) {\n            throw new Error('Could not find name assignment for type: ' + getTypeName(crossRef.type.ref));\n        }\n        return buildCrossReference(ctx, crossRef, assignTerminal);\n    }\n    else if (isRuleCall(terminal) && isParserRule(terminal.rule.ref)) {\n        // The terminal is a data type rule here. Everything else will result in a validation error.\n        const rule = terminal.rule.ref;\n        const idx = ctx.subrule++;\n        let subrule;\n        return (args) => {\n            subrule ?? (subrule = getRule(ctx, rule));\n            ctx.parser.subrule(idx, subrule, false, crossRef, args);\n        };\n    }\n    else if (isRuleCall(terminal) && isTerminalRule(terminal.rule.ref)) {\n        const idx = ctx.consume++;\n        const terminalRule = getToken(ctx, terminal.rule.ref.name);\n        return () => ctx.parser.consume(idx, terminalRule, crossRef);\n    }\n    else if (isKeyword(terminal)) {\n        const idx = ctx.consume++;\n        const keyword = getToken(ctx, terminal.value);\n        return () => ctx.parser.consume(idx, keyword, crossRef);\n    }\n    else {\n        throw new Error('Could not build cross reference parser');\n    }\n}\nfunction buildKeyword(ctx, keyword) {\n    const idx = ctx.consume++;\n    const token = ctx.tokens[keyword.value];\n    if (!token) {\n        throw new Error('Could not find token for keyword: ' + keyword.value);\n    }\n    return () => ctx.parser.consume(idx, token, keyword);\n}\nfunction wrap(ctx, guard, method, cardinality) {\n    const gate = guard && buildPredicate(guard);\n    if (!cardinality) {\n        if (gate) {\n            const idx = ctx.or++;\n            return (args) => ctx.parser.alternatives(idx, [\n                {\n                    ALT: () => method(args),\n                    GATE: () => gate(args)\n                },\n                {\n                    ALT: EMPTY_ALT(),\n                    GATE: () => !gate(args)\n                }\n            ]);\n        }\n        else {\n            return method;\n        }\n    }\n    if (cardinality === '*') {\n        const idx = ctx.many++;\n        return (args) => ctx.parser.many(idx, {\n            DEF: () => method(args),\n            GATE: gate ? () => gate(args) : undefined\n        });\n    }\n    else if (cardinality === '+') {\n        const idx = ctx.many++;\n        if (gate) {\n            const orIdx = ctx.or++;\n            // In the case of a guard condition for the `+` group\n            // We combine it with an empty alternative\n            // If the condition returns true, it needs to parse at least a single iteration\n            // If its false, it is not allowed to parse anything\n            return (args) => ctx.parser.alternatives(orIdx, [\n                {\n                    ALT: () => ctx.parser.atLeastOne(idx, {\n                        DEF: () => method(args)\n                    }),\n                    GATE: () => gate(args)\n                },\n                {\n                    ALT: EMPTY_ALT(),\n                    GATE: () => !gate(args)\n                }\n            ]);\n        }\n        else {\n            return (args) => ctx.parser.atLeastOne(idx, {\n                DEF: () => method(args),\n            });\n        }\n    }\n    else if (cardinality === '?') {\n        const idx = ctx.optional++;\n        return (args) => ctx.parser.optional(idx, {\n            DEF: () => method(args),\n            GATE: gate ? () => gate(args) : undefined\n        });\n    }\n    else {\n        assertUnreachable(cardinality);\n    }\n}\nfunction getRule(ctx, element) {\n    const name = getRuleName(ctx, element);\n    const rule = ctx.parser.getRule(name);\n    if (!rule)\n        throw new Error(`Rule \"${name}\" not found.\"`);\n    return rule;\n}\nfunction getRuleName(ctx, element) {\n    if (isAbstractParserRule(element)) {\n        return element.name;\n    }\n    else if (ctx.ruleNames.has(element)) {\n        return ctx.ruleNames.get(element);\n    }\n    else {\n        let item = element;\n        let parent = item.$container;\n        let ruleName = element.$type;\n        while (!isParserRule(parent)) {\n            if (isGroup(parent) || isAlternatives(parent) || isUnorderedGroup(parent)) {\n                const index = parent.elements.indexOf(item);\n                ruleName = index.toString() + ':' + ruleName;\n            }\n            item = parent;\n            parent = parent.$container;\n        }\n        const rule = parent;\n        ruleName = rule.name + ':' + ruleName;\n        ctx.ruleNames.set(element, ruleName);\n        return ruleName;\n    }\n}\nfunction getToken(ctx, name) {\n    const token = ctx.tokens[name];\n    if (!token)\n        throw new Error(`Token \"${name}\" not found.\"`);\n    return token;\n}\n//# sourceMappingURL=parser-builder-base.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/lib/esm/node_modules/langium/lib/parser/token-builder.js

@@ -1,65 +0,0 @@
-import { stream as e } from "../utils/stream.js";
-import { streamAllContents as t } from "../utils/ast-utils.js";
-import { isAbstractParserRule as n, isKeyword as r, isTerminalRule as i } from "../languages/generated/ast.js";
-import { escapeRegExp as a, isWhitespace as o, partialMatches as s } from "../utils/regexp-utils.js";
-import { getAllReachableRules as c, terminalRegex as l } from "../utils/grammar-utils.js";
-import { Lexer as u } from "../../../chevrotain/lib/src/scan/lexer_public.js";
-import "../../../chevrotain/lib/src/api.js";
-//#region ../../node_modules/langium/lib/parser/token-builder.js
-var d = class {
-	constructor() {
-		this.diagnostics = [];
-	}
-	buildTokens(t, n) {
-		let r = e(c(t, !1)), i = this.buildTerminalTokens(r), a = this.buildKeywordTokens(r, i, n);
-		return a.push(...i), a;
-	}
-	flushLexingReport(e) {
-		return { diagnostics: this.popDiagnostics() };
-	}
-	popDiagnostics() {
-		let e = [...this.diagnostics];
-		return this.diagnostics = [], e;
-	}
-	buildTerminalTokens(e) {
-		return e.filter(i).filter((e) => !e.fragment).map((e) => this.buildTerminalToken(e)).toArray();
-	}
-	buildTerminalToken(e) {
-		let t = l(e), n = this.requiresCustomPattern(t) ? this.regexPatternFunction(t) : t, r = {
-			name: e.name,
-			PATTERN: n
-		};
-		return typeof n == "function" && (r.LINE_BREAKS = !0), e.hidden && (r.GROUP = o(t) ? u.SKIPPED : "hidden"), r;
-	}
-	requiresCustomPattern(e) {
-		return !!(e.flags.includes("u") || e.flags.includes("s"));
-	}
-	regexPatternFunction(e) {
-		let t = new RegExp(e, e.flags + "y");
-		return (e, n) => (t.lastIndex = n, t.exec(e));
-	}
-	buildKeywordTokens(e, i, a) {
-		return e.filter(n).flatMap((e) => t(e).filter(r)).distinct((e) => e.value).toArray().sort((e, t) => t.value.length - e.value.length).map((e) => this.buildKeywordToken(e, i, !!a?.caseInsensitive));
-	}
-	buildKeywordToken(e, t, n) {
-		let r = this.buildKeywordPattern(e, n), i = {
-			name: e.value,
-			PATTERN: r,
-			LONGER_ALT: this.findLongerAlt(e, t)
-		};
-		return typeof r == "function" && (i.LINE_BREAKS = !0), i;
-	}
-	buildKeywordPattern(e, t) {
-		return t ? new RegExp(a(e.value), "i") : e.value;
-	}
-	findLongerAlt(e, t) {
-		return t.reduce((t, n) => {
-			let r = n?.PATTERN;
-			return r?.source && s("^" + r.source + "$", e.value) && t.push(n), t;
-		}, []);
-	}
-};
-//#endregion
-export { d as DefaultTokenBuilder };
-
-//# sourceMappingURL=token-builder.js.map

package/lib/esm/node_modules/langium/lib/parser/token-builder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"token-builder.js","names":[],"sources":["../../../../../../../../node_modules/langium/lib/parser/token-builder.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Lexer } from 'chevrotain';\nimport { isAbstractParserRule, isKeyword, isTerminalRule } from '../languages/generated/ast.js';\nimport { streamAllContents } from '../utils/ast-utils.js';\nimport { getAllReachableRules, terminalRegex } from '../utils/grammar-utils.js';\nimport { escapeRegExp, isWhitespace, partialMatches } from '../utils/regexp-utils.js';\nimport { stream } from '../utils/stream.js';\nexport class DefaultTokenBuilder {\n    constructor() {\n        /**\n         * The list of diagnostics stored during the lexing process of a single text.\n         */\n        this.diagnostics = [];\n    }\n    buildTokens(grammar, options) {\n        const reachableRules = stream(getAllReachableRules(grammar, false));\n        const terminalTokens = this.buildTerminalTokens(reachableRules);\n        const tokens = this.buildKeywordTokens(reachableRules, terminalTokens, options);\n        // Add all terminals tokens to the end in the order they were defined\n        // Chevrotain documentation recommends to add Whitespace-like tokens at the start\n        // However, assuming the lexer is able to optimize the tokens, it should not matter\n        tokens.push(...terminalTokens);\n        // We don't need to add the EOF token explicitly.\n        // It is automatically available at the end of the token stream.\n        return tokens;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    flushLexingReport(text) {\n        return { diagnostics: this.popDiagnostics() };\n    }\n    popDiagnostics() {\n        const diagnostics = [...this.diagnostics];\n        this.diagnostics = [];\n        return diagnostics;\n    }\n    buildTerminalTokens(rules) {\n        return rules.filter(isTerminalRule).filter(e => !e.fragment)\n            .map(terminal => this.buildTerminalToken(terminal)).toArray();\n    }\n    buildTerminalToken(terminal) {\n        const regex = terminalRegex(terminal);\n        const pattern = this.requiresCustomPattern(regex) ? this.regexPatternFunction(regex) : regex;\n        const tokenType = {\n            name: terminal.name,\n            PATTERN: pattern,\n        };\n        if (typeof pattern === 'function') {\n            tokenType.LINE_BREAKS = true;\n        }\n        if (terminal.hidden) {\n            // Only skip tokens that are able to accept whitespace\n            tokenType.GROUP = isWhitespace(regex) ? Lexer.SKIPPED : 'hidden';\n        }\n        return tokenType;\n    }\n    requiresCustomPattern(regex) {\n        if (regex.flags.includes('u') || regex.flags.includes('s')) {\n            // Unicode and dotall regexes are not supported by Chevrotain.\n            return true;\n        }\n        else {\n            return false;\n        }\n    }\n    regexPatternFunction(regex) {\n        const stickyRegex = new RegExp(regex, regex.flags + 'y');\n        return (text, offset) => {\n            stickyRegex.lastIndex = offset;\n            const execResult = stickyRegex.exec(text);\n            return execResult;\n        };\n    }\n    buildKeywordTokens(rules, terminalTokens, options) {\n        return rules\n            // We filter by parser rules, since keywords in terminal rules get transformed into regex and are not actual tokens\n            .filter(isAbstractParserRule)\n            .flatMap(rule => streamAllContents(rule).filter(isKeyword))\n            .distinct(e => e.value).toArray()\n            // Sort keywords by descending length\n            .sort((a, b) => b.value.length - a.value.length)\n            .map(keyword => this.buildKeywordToken(keyword, terminalTokens, Boolean(options?.caseInsensitive)));\n    }\n    buildKeywordToken(keyword, terminalTokens, caseInsensitive) {\n        const keywordPattern = this.buildKeywordPattern(keyword, caseInsensitive);\n        const tokenType = {\n            name: keyword.value,\n            PATTERN: keywordPattern,\n            LONGER_ALT: this.findLongerAlt(keyword, terminalTokens)\n        };\n        if (typeof keywordPattern === 'function') {\n            tokenType.LINE_BREAKS = true;\n        }\n        return tokenType;\n    }\n    buildKeywordPattern(keyword, caseInsensitive) {\n        return caseInsensitive ?\n            new RegExp(escapeRegExp(keyword.value), 'i') :\n            keyword.value;\n    }\n    findLongerAlt(keyword, terminalTokens) {\n        return terminalTokens.reduce((longerAlts, token) => {\n            const pattern = token?.PATTERN;\n            if (pattern?.source && partialMatches('^' + pattern.source + '$', keyword.value)) {\n                longerAlts.push(token);\n            }\n            return longerAlts;\n        }, []);\n    }\n}\n//# sourceMappingURL=token-builder.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;AAWA,IAAa,IAAb,MAAiC;CAC7B,cAAc;EAIV,KAAK,cAAc,EAAE;;CAEzB,YAAY,GAAS,GAAS;EAC1B,IAAM,IAAiB,EAAO,EAAqB,GAAS,GAAM,CAAC,EAC7D,IAAiB,KAAK,oBAAoB,EAAe,EACzD,IAAS,KAAK,mBAAmB,GAAgB,GAAgB,EAAQ;EAO/E,OAHA,EAAO,KAAK,GAAG,EAAe,EAGvB;;CAGX,kBAAkB,GAAM;EACpB,OAAO,EAAE,aAAa,KAAK,gBAAgB,EAAE;;CAEjD,iBAAiB;EACb,IAAM,IAAc,CAAC,GAAG,KAAK,YAAY;EAEzC,OADA,KAAK,cAAc,EAAE,EACd;;CAEX,oBAAoB,GAAO;EACvB,OAAO,EAAM,OAAO,EAAe,CAAC,QAAO,MAAK,CAAC,EAAE,SAAS,CACvD,KAAI,MAAY,KAAK,mBAAmB,EAAS,CAAC,CAAC,SAAS;;CAErE,mBAAmB,GAAU;EACzB,IAAM,IAAQ,EAAc,EAAS,EAC/B,IAAU,KAAK,sBAAsB,EAAM,GAAG,KAAK,qBAAqB,EAAM,GAAG,GACjF,IAAY;GACd,MAAM,EAAS;GACf,SAAS;GACZ;EAQD,OAPI,OAAO,KAAY,eACnB,EAAU,cAAc,KAExB,EAAS,WAET,EAAU,QAAQ,EAAa,EAAM,GAAG,EAAM,UAAU,WAErD;;CAEX,sBAAsB,GAAO;EAMrB,OALJ,GAAI,EAAM,MAAM,SAAS,IAAI,IAAI,EAAM,MAAM,SAAS,IAAI;;CAQ9D,qBAAqB,GAAO;EACxB,IAAM,IAAc,IAAI,OAAO,GAAO,EAAM,QAAQ,IAAI;EACxD,QAAQ,GAAM,OACV,EAAY,YAAY,GACL,EAAY,KAAK,EACnB;;CAGzB,mBAAmB,GAAO,GAAgB,GAAS;EAC/C,OAAO,EAEF,OAAO,EAAqB,CAC5B,SAAQ,MAAQ,EAAkB,EAAK,CAAC,OAAO,EAAU,CAAC,CAC1D,UAAS,MAAK,EAAE,MAAM,CAAC,SAAS,CAEhC,MAAM,GAAG,MAAM,EAAE,MAAM,SAAS,EAAE,MAAM,OAAO,CAC/C,KAAI,MAAW,KAAK,kBAAkB,GAAS,GAAgB,EAAQ,GAAS,gBAAiB,CAAC;;CAE3G,kBAAkB,GAAS,GAAgB,GAAiB;EACxD,IAAM,IAAiB,KAAK,oBAAoB,GAAS,EAAgB,EACnE,IAAY;GACd,MAAM,EAAQ;GACd,SAAS;GACT,YAAY,KAAK,cAAc,GAAS,EAAe;GAC1D;EAID,OAHI,OAAO,KAAmB,eAC1B,EAAU,cAAc,KAErB;;CAEX,oBAAoB,GAAS,GAAiB;EAC1C,OAAO,IACH,IAAI,OAAO,EAAa,EAAQ,MAAM,EAAE,IAAI,GAC5C,EAAQ;;CAEhB,cAAc,GAAS,GAAgB;EACnC,OAAO,EAAe,QAAQ,GAAY,MAAU;GAChD,IAAM,IAAU,GAAO;GAIvB,OAHI,GAAS,UAAU,EAAe,MAAM,EAAQ,SAAS,KAAK,EAAQ,MAAM,IAC5E,EAAW,KAAK,EAAM,EAEnB;KACR,EAAE,CAAC"}

package/lib/esm/node_modules/langium/lib/parser/value-converter.js

@@ -1,82 +0,0 @@
-import { isCrossReference as e, isRuleCall as t } from "../languages/generated/ast.js";
-import { getCrossReferenceTerminal as n, getRuleType as r } from "../utils/grammar-utils.js";
-//#region ../../node_modules/langium/lib/parser/value-converter.js
-var i = class {
-	convert(r, i) {
-		let a = i.grammarSource;
-		if (e(a) && (a = n(a)), t(a)) {
-			let e = a.rule.ref;
-			if (!e) throw Error("This cst node was not parsed by a rule.");
-			return this.runConverter(e, r, i);
-		}
-		return r;
-	}
-	runConverter(e, t, n) {
-		switch (e.name.toUpperCase()) {
-			case "INT": return a.convertInt(t);
-			case "STRING": return a.convertString(t);
-			case "ID": return a.convertID(t);
-		}
-		switch (r(e)?.toLowerCase()) {
-			case "number": return a.convertNumber(t);
-			case "boolean": return a.convertBoolean(t);
-			case "bigint": return a.convertBigint(t);
-			case "date": return a.convertDate(t);
-			default: return t;
-		}
-	}
-}, a;
-(function(e) {
-	function t(e) {
-		let t = "";
-		for (let r = 1; r < e.length - 1; r++) {
-			let i = e.charAt(r);
-			if (i === "\\") {
-				let i = e.charAt(++r);
-				t += n(i);
-			} else t += i;
-		}
-		return t;
-	}
-	e.convertString = t;
-	function n(e) {
-		switch (e) {
-			case "b": return "\b";
-			case "f": return "\f";
-			case "n": return "\n";
-			case "r": return "\r";
-			case "t": return "	";
-			case "v": return "\v";
-			case "0": return "\0";
-			default: return e;
-		}
-	}
-	function r(e) {
-		return e.charAt(0) === "^" ? e.substring(1) : e;
-	}
-	e.convertID = r;
-	function i(e) {
-		return parseInt(e);
-	}
-	e.convertInt = i;
-	function a(e) {
-		return BigInt(e);
-	}
-	e.convertBigint = a;
-	function o(e) {
-		return new Date(e);
-	}
-	e.convertDate = o;
-	function s(e) {
-		return Number(e);
-	}
-	e.convertNumber = s;
-	function c(e) {
-		return e.toLowerCase() === "true";
-	}
-	e.convertBoolean = c;
-})(a ||= {});
-//#endregion
-export { i as DefaultValueConverter };
-
-//# sourceMappingURL=value-converter.js.map

package/lib/esm/node_modules/langium/lib/parser/value-converter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"value-converter.js","names":[],"sources":["../../../../../../../../node_modules/langium/lib/parser/value-converter.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { isCrossReference, isRuleCall } from '../languages/generated/ast.js';\nimport { getCrossReferenceTerminal, getRuleType } from '../utils/grammar-utils.js';\nexport class DefaultValueConverter {\n    convert(input, cstNode) {\n        let feature = cstNode.grammarSource;\n        if (isCrossReference(feature)) {\n            feature = getCrossReferenceTerminal(feature);\n        }\n        if (isRuleCall(feature)) {\n            const rule = feature.rule.ref;\n            if (!rule) {\n                throw new Error('This cst node was not parsed by a rule.');\n            }\n            return this.runConverter(rule, input, cstNode);\n        }\n        return input;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    runConverter(rule, input, cstNode) {\n        switch (rule.name.toUpperCase()) {\n            case 'INT': return ValueConverter.convertInt(input);\n            case 'STRING': return ValueConverter.convertString(input);\n            case 'ID': return ValueConverter.convertID(input);\n        }\n        switch (getRuleType(rule)?.toLowerCase()) {\n            case 'number': return ValueConverter.convertNumber(input);\n            case 'boolean': return ValueConverter.convertBoolean(input);\n            case 'bigint': return ValueConverter.convertBigint(input);\n            case 'date': return ValueConverter.convertDate(input);\n            default: return input;\n        }\n    }\n}\nexport var ValueConverter;\n(function (ValueConverter) {\n    function convertString(input) {\n        let result = '';\n        for (let i = 1; i < input.length - 1; i++) {\n            const c = input.charAt(i);\n            if (c === '\\\\') {\n                const c1 = input.charAt(++i);\n                result += convertEscapeCharacter(c1);\n            }\n            else {\n                result += c;\n            }\n        }\n        return result;\n    }\n    ValueConverter.convertString = convertString;\n    function convertEscapeCharacter(char) {\n        switch (char) {\n            case 'b': return '\\b';\n            case 'f': return '\\f';\n            case 'n': return '\\n';\n            case 'r': return '\\r';\n            case 't': return '\\t';\n            case 'v': return '\\v';\n            case '0': return '\\0';\n            default: return char;\n        }\n    }\n    function convertID(input) {\n        if (input.charAt(0) === '^') {\n            return input.substring(1);\n        }\n        else {\n            return input;\n        }\n    }\n    ValueConverter.convertID = convertID;\n    function convertInt(input) {\n        return parseInt(input);\n    }\n    ValueConverter.convertInt = convertInt;\n    function convertBigint(input) {\n        return BigInt(input);\n    }\n    ValueConverter.convertBigint = convertBigint;\n    function convertDate(input) {\n        return new Date(input);\n    }\n    ValueConverter.convertDate = convertDate;\n    function convertNumber(input) {\n        return Number(input);\n    }\n    ValueConverter.convertNumber = convertNumber;\n    function convertBoolean(input) {\n        return input.toLowerCase() === 'true';\n    }\n    ValueConverter.convertBoolean = convertBoolean;\n})(ValueConverter || (ValueConverter = {}));\n//# sourceMappingURL=value-converter.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAOA,IAAa,IAAb,MAAmC;CAC/B,QAAQ,GAAO,GAAS;EACpB,IAAI,IAAU,EAAQ;EAItB,IAHI,EAAiB,EAAQ,KACzB,IAAU,EAA0B,EAAQ,GAE5C,EAAW,EAAQ,EAAE;GACrB,IAAM,IAAO,EAAQ,KAAK;GAC1B,IAAI,CAAC,GACD,MAAU,MAAM,0CAA0C;GAE9D,OAAO,KAAK,aAAa,GAAM,GAAO,EAAQ;;EAElD,OAAO;;CAGX,aAAa,GAAM,GAAO,GAAS;EAC/B,QAAQ,EAAK,KAAK,aAAa,EAA/B;GACI,KAAK,OAAO,OAAO,EAAe,WAAW,EAAM;GACnD,KAAK,UAAU,OAAO,EAAe,cAAc,EAAM;GACzD,KAAK,MAAM,OAAO,EAAe,UAAU,EAAM;;EAErD,QAAQ,EAAY,EAAK,EAAE,aAAa,EAAxC;GACI,KAAK,UAAU,OAAO,EAAe,cAAc,EAAM;GACzD,KAAK,WAAW,OAAO,EAAe,eAAe,EAAM;GAC3D,KAAK,UAAU,OAAO,EAAe,cAAc,EAAM;GACzD,KAAK,QAAQ,OAAO,EAAe,YAAY,EAAM;GACrD,SAAS,OAAO;;;GAIjB;CACV,SAAU,GAAgB;CACvB,SAAS,EAAc,GAAO;EAC1B,IAAI,IAAS;EACb,KAAK,IAAI,IAAI,GAAG,IAAI,EAAM,SAAS,GAAG,KAAK;GACvC,IAAM,IAAI,EAAM,OAAO,EAAE;GACzB,IAAI,MAAM,MAAM;IACZ,IAAM,IAAK,EAAM,OAAO,EAAE,EAAE;IAC5B,KAAU,EAAuB,EAAG;UAGpC,KAAU;;EAGlB,OAAO;;CAEX,EAAe,gBAAgB;CAC/B,SAAS,EAAuB,GAAM;EAClC,QAAQ,GAAR;GACI,KAAK,KAAK,OAAO;GACjB,KAAK,KAAK,OAAO;GACjB,KAAK,KAAK,OAAO;GACjB,KAAK,KAAK,OAAO;GACjB,KAAK,KAAK,OAAO;GACjB,KAAK,KAAK,OAAO;GACjB,KAAK,KAAK,OAAO;GACjB,SAAS,OAAO;;;CAGxB,SAAS,EAAU,GAAO;EAKlB,OAJA,EAAM,OAAO,EAAE,KAAK,MACb,EAAM,UAAU,EAAE,GAGlB;;CAGf,EAAe,YAAY;CAC3B,SAAS,EAAW,GAAO;EACvB,OAAO,SAAS,EAAM;;CAE1B,EAAe,aAAa;CAC5B,SAAS,EAAc,GAAO;EAC1B,OAAO,OAAO,EAAM;;CAExB,EAAe,gBAAgB;CAC/B,SAAS,EAAY,GAAO;EACxB,OAAO,IAAI,KAAK,EAAM;;CAE1B,EAAe,cAAc;CAC7B,SAAS,EAAc,GAAO;EAC1B,OAAO,OAAO,EAAM;;CAExB,EAAe,gBAAgB;CAC/B,SAAS,EAAe,GAAO;EAC3B,OAAO,EAAM,aAAa,KAAK;;CAEnC,EAAe,iBAAiB;GACjC,AAAmB,MAAiB,EAAE,CAAE"}