@plumile/ui 0.1.113 → 0.1.114

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

@@ -1,397 +0,0 @@
-import { assignMandatoryProperties as e, getContainerOfType as t, linkContentToContainer as n } from "../utils/ast-utils.js";
-import { isAssignment as r, isCrossReference as i, isInfixRule as a, isKeyword as o, isParserRule as s } from "../languages/generated/ast.js";
-import { getTypeName as c, isDataTypeRule as l } from "../utils/grammar-utils.js";
-import { defaultParserErrorProvider as u } from "../../../chevrotain/lib/src/parse/errors_public.js";
-import { LLkLookaheadStrategy as d } from "../../../chevrotain/lib/src/parse/grammar/llk_lookahead.js";
-import { EmbeddedActionsParser as f } from "../../../chevrotain/lib/src/parse/parser/parser.js";
-import "../../../chevrotain/lib/src/api.js";
-import { LLStarLookaheadStrategy as p } from "../../../chevrotain-allstar/lib/all-star-lookahead.js";
-import "../../../chevrotain-allstar/lib/index.js";
-import { CstNodeBuilder as m } from "./cst-node-builder.js";
-//#region ../../node_modules/langium/lib/parser/langium-parser.js
-var h = Symbol("Datatype");
-function g(e) {
-	return e.$type === h;
-}
-var _ = "​", v = (e) => e.endsWith(_) ? e : e + _, y = class {
-	constructor(e, t) {
-		this._unorderedGroups = /* @__PURE__ */ new Map(), this.allRules = /* @__PURE__ */ new Map(), this.lexer = e.parser.Lexer;
-		let n = this.lexer.definition, r = e.LanguageMetaData.mode === "production";
-		e.shared.profilers.LangiumProfiler?.isActive("parsing") ? this.wrapper = new E(n, {
-			...e.parser.ParserConfig,
-			skipValidations: r,
-			errorMessageProvider: e.parser.ParserErrorMessageProvider
-		}, t, e.shared.profilers.LangiumProfiler.createTask("parsing", e.LanguageMetaData.languageId)) : this.wrapper = new T(n, {
-			...e.parser.ParserConfig,
-			skipValidations: r,
-			errorMessageProvider: e.parser.ParserErrorMessageProvider
-		}, t);
-	}
-	alternatives(e, t) {
-		this.wrapper.wrapOr(e, t);
-	}
-	optional(e, t) {
-		this.wrapper.wrapOption(e, t);
-	}
-	many(e, t) {
-		this.wrapper.wrapMany(e, t);
-	}
-	atLeastOne(e, t) {
-		this.wrapper.wrapAtLeastOne(e, t);
-	}
-	getRule(e) {
-		return this.allRules.get(e);
-	}
-	isRecording() {
-		return this.wrapper.IS_RECORDING;
-	}
-	get unorderedGroups() {
-		return this._unorderedGroups;
-	}
-	getRuleStack() {
-		return this.wrapper.RULE_STACK;
-	}
-	finalize() {
-		this.wrapper.wrapSelfAnalysis();
-	}
-}, b = class extends y {
-	get current() {
-		return this.stack[this.stack.length - 1];
-	}
-	constructor(e) {
-		super(e, !1), this.nodeBuilder = new m(), this.stack = [], this.assignmentMap = /* @__PURE__ */ new Map(), this.operatorPrecedence = /* @__PURE__ */ new Map(), this.linker = e.references.Linker, this.converter = e.parser.ValueConverter, this.astReflection = e.shared.AstReflection;
-	}
-	rule(e, t) {
-		let n = this.computeRuleType(e), r;
-		a(e) && (r = e.name, this.registerPrecedenceMap(e));
-		let i = this.wrapper.DEFINE_RULE(v(e.name), this.startImplementation(n, r, t).bind(this));
-		return this.allRules.set(e.name, i), s(e) && e.entry && (this.mainRule = i), i;
-	}
-	registerPrecedenceMap(e) {
-		let t = e.name, n = /* @__PURE__ */ new Map();
-		for (let t = 0; t < e.operators.precedences.length; t++) {
-			let r = e.operators.precedences[t];
-			for (let e of r.operators) n.set(e.value, {
-				precedence: t,
-				rightAssoc: r.associativity === "right"
-			});
-		}
-		this.operatorPrecedence.set(t, n);
-	}
-	computeRuleType(e) {
-		return a(e) ? c(e) : e.fragment ? void 0 : l(e) ? h : c(e);
-	}
-	parse(e, t = {}) {
-		this.nodeBuilder.buildRootNode(e);
-		let r = this.lexerResult = this.lexer.tokenize(e);
-		this.wrapper.input = r.tokens;
-		let i = t.rule ? this.allRules.get(t.rule) : this.mainRule;
-		if (!i) throw Error(t.rule ? `No rule found with name '${t.rule}'` : "No main rule available.");
-		let a = this.doParse(i);
-		return this.nodeBuilder.addHiddenNodes(r.hidden), this.unorderedGroups.clear(), this.lexerResult = void 0, n(a, { deep: !0 }), {
-			value: a,
-			lexerErrors: r.errors,
-			lexerReport: r.report,
-			parserErrors: this.wrapper.errors
-		};
-	}
-	doParse(e) {
-		let t = this.wrapper.rule(e);
-		if (this.stack.length > 0 && (t = this.construct()), t === void 0) throw Error("No result from parser");
-		if (this.stack.length > 0) throw Error("Parser stack is not empty after parsing");
-		return t;
-	}
-	startImplementation(e, t, n) {
-		return (r) => {
-			let i = !this.isRecording() && e !== void 0;
-			if (i) {
-				let n = { $type: e };
-				this.stack.push(n), e === h ? n.value = "" : t !== void 0 && (n.$infixName = t);
-			}
-			return n(r), i ? this.construct() : void 0;
-		};
-	}
-	extractHiddenTokens(e) {
-		let t = this.lexerResult.hidden;
-		if (!t.length) return [];
-		let n = e.startOffset;
-		for (let e = 0; e < t.length; e++) if (t[e].startOffset > n) return t.splice(0, e);
-		return t.splice(0, t.length);
-	}
-	consume(e, t, n) {
-		let r = this.wrapper.wrapConsume(e, t);
-		if (!this.isRecording() && this.isValidToken(r)) {
-			let e = this.extractHiddenTokens(r);
-			this.nodeBuilder.addHiddenNodes(e);
-			let t = this.nodeBuilder.buildLeafNode(r, n), { assignment: i, crossRef: a } = this.getAssignment(n), s = this.current;
-			if (i) {
-				let e = o(n) ? r.image : this.converter.convert(r.image, t);
-				this.assign(i.operator, i.feature, e, t, a);
-			} else if (g(s)) {
-				let e = r.image;
-				o(n) || (e = this.converter.convert(e, t).toString()), s.value += e;
-			}
-		}
-	}
-	isValidToken(e) {
-		return !e.isInsertedInRecovery && !isNaN(e.startOffset) && typeof e.endOffset == "number" && !isNaN(e.endOffset);
-	}
-	subrule(e, t, n, r, i) {
-		let a;
-		!this.isRecording() && !n && (a = this.nodeBuilder.buildCompositeNode(r));
-		let o;
-		try {
-			o = this.wrapper.wrapSubrule(e, t, i);
-		} finally {
-			this.isRecording() || (o === void 0 && !n && (o = this.construct()), o !== void 0 && a && a.length > 0 && this.performSubruleAssignment(o, r, a));
-		}
-	}
-	performSubruleAssignment(e, t, n) {
-		let { assignment: r, crossRef: i } = this.getAssignment(t);
-		if (r) this.assign(r.operator, r.feature, e, n, i);
-		else if (!r) {
-			let t = this.current;
-			if (g(t)) t.value += e.toString();
-			else if (typeof e == "object" && e) {
-				let n = this.assignWithoutOverride(e, t);
-				this.stack.pop(), this.stack.push(n);
-			}
-		}
-	}
-	action(e, t) {
-		if (!this.isRecording()) {
-			let n = this.current;
-			if (t.feature && t.operator) {
-				n = this.construct(), this.nodeBuilder.removeNode(n.$cstNode), this.nodeBuilder.buildCompositeNode(t).content.push(n.$cstNode);
-				let r = { $type: e };
-				this.stack.push(r), this.assign(t.operator, t.feature, n, n.$cstNode);
-			} else n.$type = e;
-		}
-	}
-	construct() {
-		if (this.isRecording()) return;
-		let t = this.stack.pop();
-		return this.nodeBuilder.construct(t), "$infixName" in t ? this.constructInfix(t, this.operatorPrecedence.get(t.$infixName)) : g(t) ? this.converter.convert(t.value, t.$cstNode) : (e(this.astReflection, t), t);
-	}
-	constructInfix(e, t) {
-		let n = e.parts;
-		if (!Array.isArray(n) || n.length === 0) return;
-		let r = e.operators;
-		if (!Array.isArray(r) || n.length < 2) return n[0];
-		let i = 0, a = -1;
-		for (let e = 0; e < r.length; e++) {
-			let n = r[e], o = t.get(n) ?? {
-				precedence: Infinity,
-				rightAssoc: !1
-			};
-			o.precedence > a ? (a = o.precedence, i = e) : o.precedence === a && (o.rightAssoc || (i = e));
-		}
-		let o = r.slice(0, i), s = r.slice(i + 1), c = n.slice(0, i + 1), l = n.slice(i + 1), u = {
-			$infixName: e.$infixName,
-			$type: e.$type,
-			$cstNode: e.$cstNode,
-			parts: c,
-			operators: o
-		}, d = {
-			$infixName: e.$infixName,
-			$type: e.$type,
-			$cstNode: e.$cstNode,
-			parts: l,
-			operators: s
-		}, f = this.constructInfix(u, t), p = this.constructInfix(d, t);
-		return {
-			$type: e.$type,
-			$cstNode: e.$cstNode,
-			left: f,
-			operator: r[i],
-			right: p
-		};
-	}
-	getAssignment(e) {
-		if (!this.assignmentMap.has(e)) {
-			let n = t(e, r);
-			this.assignmentMap.set(e, {
-				assignment: n,
-				crossRef: n && i(n.terminal) ? n.terminal.isMulti ? "multi" : "single" : void 0
-			});
-		}
-		return this.assignmentMap.get(e);
-	}
-	assign(e, t, n, r, i) {
-		let a = this.current, o;
-		switch (o = i === "single" && typeof n == "string" ? this.linker.buildReference(a, t, r, n) : i === "multi" && typeof n == "string" ? this.linker.buildMultiReference(a, t, r, n) : n, e) {
-			case "=":
-				a[t] = o;
-				break;
-			case "?=":
-				a[t] = !0;
-				break;
-			case "+=": Array.isArray(a[t]) || (a[t] = []), a[t].push(o);
-		}
-	}
-	assignWithoutOverride(e, t) {
-		for (let [n, r] of Object.entries(t)) {
-			let t = e[n];
-			t === void 0 ? e[n] = r : Array.isArray(t) && Array.isArray(r) && (r.push(...t), e[n] = r);
-		}
-		let n = e.$cstNode;
-		return n && (n.astNode = void 0, e.$cstNode = void 0), e;
-	}
-	get definitionErrors() {
-		return this.wrapper.definitionErrors;
-	}
-}, x = class {
-	buildMismatchTokenMessage(e) {
-		return u.buildMismatchTokenMessage(e);
-	}
-	buildNotAllInputParsedMessage(e) {
-		return u.buildNotAllInputParsedMessage(e);
-	}
-	buildNoViableAltMessage(e) {
-		return u.buildNoViableAltMessage(e);
-	}
-	buildEarlyExitMessage(e) {
-		return u.buildEarlyExitMessage(e);
-	}
-}, S = class extends x {
-	buildMismatchTokenMessage({ expected: e, actual: t }) {
-		return `Expecting ${e.LABEL ? "`" + e.LABEL + "`" : e.name.endsWith(":KW") ? `keyword '${e.name.substring(0, e.name.length - 3)}'` : `token of type '${e.name}'`} but found \`${t.image}\`.`;
-	}
-	buildNotAllInputParsedMessage({ firstRedundant: e }) {
-		return `Expecting end of file but found \`${e.image}\`.`;
-	}
-}, C = class extends y {
-	constructor(e) {
-		super(e, !0), this.tokens = [], this.elementStack = [], this.lastElementStack = [], this.nextTokenIndex = 0, this.stackSize = 0;
-	}
-	action() {}
-	construct() {}
-	parse(e) {
-		this.resetState();
-		let t = this.lexer.tokenize(e, { mode: "partial" });
-		return this.tokens = t.tokens, this.wrapper.input = [...this.tokens], this.mainRule.call(this.wrapper, {}), this.unorderedGroups.clear(), {
-			tokens: this.tokens,
-			elementStack: [...this.lastElementStack],
-			tokenIndex: this.nextTokenIndex
-		};
-	}
-	rule(e, t) {
-		let n = this.wrapper.DEFINE_RULE(v(e.name), this.startImplementation(t).bind(this));
-		return this.allRules.set(e.name, n), e.entry && (this.mainRule = n), n;
-	}
-	resetState() {
-		this.elementStack = [], this.lastElementStack = [], this.nextTokenIndex = 0, this.stackSize = 0;
-	}
-	startImplementation(e) {
-		return (t) => {
-			let n = this.keepStackSize();
-			try {
-				e(t);
-			} finally {
-				this.resetStackSize(n);
-			}
-		};
-	}
-	removeUnexpectedElements() {
-		this.elementStack.splice(this.stackSize);
-	}
-	keepStackSize() {
-		let e = this.elementStack.length;
-		return this.stackSize = e, e;
-	}
-	resetStackSize(e) {
-		this.removeUnexpectedElements(), this.stackSize = e;
-	}
-	consume(e, t, n) {
-		this.wrapper.wrapConsume(e, t), this.isRecording() || (this.lastElementStack = [...this.elementStack, n], this.nextTokenIndex = this.currIdx + 1);
-	}
-	subrule(e, t, n, r, i) {
-		this.before(r), this.wrapper.wrapSubrule(e, t, i), this.after(r);
-	}
-	before(e) {
-		this.isRecording() || this.elementStack.push(e);
-	}
-	after(e) {
-		if (!this.isRecording()) {
-			let t = this.elementStack.lastIndexOf(e);
-			t >= 0 && this.elementStack.splice(t);
-		}
-	}
-	get currIdx() {
-		return this.wrapper.currIdx;
-	}
-}, w = {
-	recoveryEnabled: !0,
-	nodeLocationTracking: "full",
-	skipValidations: !0,
-	errorMessageProvider: new S()
-}, T = class extends f {
-	constructor(e, t, n) {
-		let r = t && "maxLookahead" in t;
-		super(e, {
-			...w,
-			lookaheadStrategy: r ? new d({ maxLookahead: t.maxLookahead }) : new p({
-				logging: t.skipValidations ? () => {} : void 0,
-				incomplete: n
-			}),
-			...t
-		});
-	}
-	get IS_RECORDING() {
-		return this.RECORDING_PHASE;
-	}
-	DEFINE_RULE(e, t, n) {
-		return this.RULE(e, t, n);
-	}
-	wrapSelfAnalysis() {
-		this.performSelfAnalysis();
-	}
-	wrapConsume(e, t) {
-		return this.consume(e, t, void 0);
-	}
-	wrapSubrule(e, t, n) {
-		return this.subrule(e, t, { ARGS: [n] });
-	}
-	wrapOr(e, t) {
-		this.or(e, t);
-	}
-	wrapOption(e, t) {
-		this.option(e, t);
-	}
-	wrapMany(e, t) {
-		this.many(e, t);
-	}
-	wrapAtLeastOne(e, t) {
-		this.atLeastOne(e, t);
-	}
-	rule(e) {
-		return e.call(this, {});
-	}
-}, E = class extends T {
-	constructor(e, t, n, r) {
-		super(e, t, n), this.task = r;
-	}
-	rule(e) {
-		this.task.start(), this.task.startSubTask(this.ruleName(e));
-		try {
-			return super.rule(e);
-		} finally {
-			this.task.stopSubTask(this.ruleName(e)), this.task.stop();
-		}
-	}
-	ruleName(e) {
-		return e.ruleName;
-	}
-	subrule(e, t, n) {
-		this.task.startSubTask(this.ruleName(t));
-		try {
-			return super.subrule(e, t, n);
-		} finally {
-			this.task.stopSubTask(this.ruleName(t));
-		}
-	}
-};
-//#endregion
-export { C as LangiumCompletionParser, b as LangiumParser, S as LangiumParserErrorMessageProvider };
-
-//# sourceMappingURL=langium-parser.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"langium-parser.js","names":[],"sources":["../../../../../../../../node_modules/langium/lib/parser/langium-parser.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 ******************************************************************************/\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { isInfixRule } from '../languages/generated/ast.js';\nimport { defaultParserErrorProvider, EmbeddedActionsParser, LLkLookaheadStrategy } from 'chevrotain';\nimport { LLStarLookaheadStrategy } from 'chevrotain-allstar';\nimport { isAssignment, isCrossReference, isKeyword, isParserRule } from '../languages/generated/ast.js';\nimport { getTypeName, isDataTypeRule } from '../utils/grammar-utils.js';\nimport { assignMandatoryProperties, getContainerOfType, linkContentToContainer } from '../utils/ast-utils.js';\nimport { CstNodeBuilder } from './cst-node-builder.js';\nexport const DatatypeSymbol = Symbol('Datatype');\nfunction isDataTypeNode(node) {\n    return node.$type === DatatypeSymbol;\n}\nconst ruleSuffix = '\\u200B';\nconst withRuleSuffix = (name) => name.endsWith(ruleSuffix) ? name : name + ruleSuffix;\nexport class AbstractLangiumParser {\n    constructor(services, incomplete) {\n        this._unorderedGroups = new Map();\n        this.allRules = new Map();\n        this.lexer = services.parser.Lexer;\n        const tokens = this.lexer.definition;\n        const production = services.LanguageMetaData.mode === 'production';\n        if (services.shared.profilers.LangiumProfiler?.isActive('parsing')) {\n            this.wrapper = new ProfilerWrapper(tokens, {\n                ...services.parser.ParserConfig,\n                skipValidations: production,\n                errorMessageProvider: services.parser.ParserErrorMessageProvider\n            }, incomplete, services.shared.profilers.LangiumProfiler.createTask('parsing', services.LanguageMetaData.languageId));\n        }\n        else {\n            this.wrapper = new ChevrotainWrapper(tokens, {\n                ...services.parser.ParserConfig,\n                skipValidations: production,\n                errorMessageProvider: services.parser.ParserErrorMessageProvider\n            }, incomplete);\n        }\n    }\n    alternatives(idx, choices) {\n        this.wrapper.wrapOr(idx, choices);\n    }\n    optional(idx, callback) {\n        this.wrapper.wrapOption(idx, callback);\n    }\n    many(idx, callback) {\n        this.wrapper.wrapMany(idx, callback);\n    }\n    atLeastOne(idx, callback) {\n        this.wrapper.wrapAtLeastOne(idx, callback);\n    }\n    getRule(name) {\n        return this.allRules.get(name);\n    }\n    isRecording() {\n        return this.wrapper.IS_RECORDING;\n    }\n    get unorderedGroups() {\n        return this._unorderedGroups;\n    }\n    getRuleStack() {\n        return this.wrapper.RULE_STACK;\n    }\n    finalize() {\n        this.wrapper.wrapSelfAnalysis();\n    }\n}\nexport class LangiumParser extends AbstractLangiumParser {\n    get current() {\n        return this.stack[this.stack.length - 1];\n    }\n    constructor(services) {\n        super(services, false);\n        this.nodeBuilder = new CstNodeBuilder();\n        this.stack = [];\n        this.assignmentMap = new Map();\n        this.operatorPrecedence = new Map();\n        this.linker = services.references.Linker;\n        this.converter = services.parser.ValueConverter;\n        this.astReflection = services.shared.AstReflection;\n    }\n    rule(rule, impl) {\n        const type = this.computeRuleType(rule);\n        let infixName = undefined;\n        if (isInfixRule(rule)) {\n            infixName = rule.name;\n            this.registerPrecedenceMap(rule);\n        }\n        const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(type, infixName, impl).bind(this));\n        this.allRules.set(rule.name, ruleMethod);\n        if (isParserRule(rule) && rule.entry) {\n            this.mainRule = ruleMethod;\n        }\n        return ruleMethod;\n    }\n    registerPrecedenceMap(rule) {\n        const name = rule.name;\n        const map = new Map();\n        for (let i = 0; i < rule.operators.precedences.length; i++) {\n            const precedence = rule.operators.precedences[i];\n            for (const keyword of precedence.operators) {\n                map.set(keyword.value, {\n                    precedence: i,\n                    rightAssoc: precedence.associativity === 'right'\n                });\n            }\n        }\n        this.operatorPrecedence.set(name, map);\n    }\n    computeRuleType(rule) {\n        if (isInfixRule(rule)) {\n            return getTypeName(rule);\n        }\n        else if (rule.fragment) {\n            return undefined;\n        }\n        else if (isDataTypeRule(rule)) {\n            return DatatypeSymbol;\n        }\n        else {\n            return getTypeName(rule);\n        }\n    }\n    parse(input, options = {}) {\n        this.nodeBuilder.buildRootNode(input);\n        const lexerResult = this.lexerResult = this.lexer.tokenize(input);\n        this.wrapper.input = lexerResult.tokens;\n        const ruleMethod = options.rule ? this.allRules.get(options.rule) : this.mainRule;\n        if (!ruleMethod) {\n            throw new Error(options.rule ? `No rule found with name '${options.rule}'` : 'No main rule available.');\n        }\n        const result = this.doParse(ruleMethod);\n        this.nodeBuilder.addHiddenNodes(lexerResult.hidden);\n        this.unorderedGroups.clear();\n        this.lexerResult = undefined;\n        linkContentToContainer(result, { deep: true });\n        return {\n            value: result,\n            lexerErrors: lexerResult.errors,\n            lexerReport: lexerResult.report,\n            parserErrors: this.wrapper.errors\n        };\n    }\n    doParse(rule) {\n        let result = this.wrapper.rule(rule);\n        if (this.stack.length > 0) {\n            // In case the parser throws on the entry rule, `construct` is not called\n            // We need to call it manually here\n            result = this.construct();\n        }\n        // Perform some sanity checking\n        if (result === undefined) {\n            throw new Error('No result from parser');\n        }\n        else if (this.stack.length > 0) {\n            throw new Error('Parser stack is not empty after parsing');\n        }\n        return result;\n    }\n    startImplementation($type, infixName, implementation) {\n        return (args) => {\n            // Only create a new AST node in case the calling rule is not a fragment rule\n            const createNode = !this.isRecording() && $type !== undefined;\n            if (createNode) {\n                const node = { $type };\n                this.stack.push(node);\n                if ($type === DatatypeSymbol) {\n                    node.value = '';\n                }\n                else if (infixName !== undefined) {\n                    node.$infixName = infixName;\n                }\n            }\n            // Execute the actual rule implementation\n            // The `implementation` never returns anything and only manipulates the parser state.\n            implementation(args);\n            // Once the rule implementation is done, we need to construct the AST node\n            // If the implementation throws (likely a recognition error), we relay the construction to the `subrule` method\n            return createNode ? this.construct() : undefined;\n        };\n    }\n    extractHiddenTokens(token) {\n        const hiddenTokens = this.lexerResult.hidden;\n        if (!hiddenTokens.length) {\n            return [];\n        }\n        const offset = token.startOffset;\n        for (let i = 0; i < hiddenTokens.length; i++) {\n            const token = hiddenTokens[i];\n            if (token.startOffset > offset) {\n                return hiddenTokens.splice(0, i);\n            }\n        }\n        return hiddenTokens.splice(0, hiddenTokens.length);\n    }\n    consume(idx, tokenType, feature) {\n        const token = this.wrapper.wrapConsume(idx, tokenType);\n        if (!this.isRecording() && this.isValidToken(token)) {\n            // Before inserting the current token into the CST, we want add the hidden tokens (i.e. comments)\n            // These are located directly before the current token, but are not part of the token stream.\n            // Adding the hidden tokens to the CST requires searching through the CST and finding the correct position.\n            // Performing this work here is more efficient than doing it later on.\n            const hiddenTokens = this.extractHiddenTokens(token);\n            this.nodeBuilder.addHiddenNodes(hiddenTokens);\n            const leafNode = this.nodeBuilder.buildLeafNode(token, feature);\n            const { assignment, crossRef } = this.getAssignment(feature);\n            const current = this.current;\n            if (assignment) {\n                const convertedValue = isKeyword(feature) ? token.image : this.converter.convert(token.image, leafNode);\n                this.assign(assignment.operator, assignment.feature, convertedValue, leafNode, crossRef);\n            }\n            else if (isDataTypeNode(current)) {\n                let text = token.image;\n                if (!isKeyword(feature)) {\n                    text = this.converter.convert(text, leafNode).toString();\n                }\n                current.value += text;\n            }\n        }\n    }\n    /**\n     * Most consumed parser tokens are valid. However there are two cases in which they are not valid:\n     *\n     * 1. They were inserted during error recovery by the parser. These tokens don't really exist and should not be further processed\n     * 2. They contain invalid token ranges. This might include the special EOF token, or other tokens produced by invalid token builders.\n     */\n    isValidToken(token) {\n        return !token.isInsertedInRecovery && !isNaN(token.startOffset) && typeof token.endOffset === 'number' && !isNaN(token.endOffset);\n    }\n    subrule(idx, rule, fragment, feature, args) {\n        let cstNode;\n        if (!this.isRecording() && !fragment) {\n            // We only want to create a new CST node if the subrule actually creates a new AST node.\n            // In other cases like calls of fragment rules the current CST/AST is populated further.\n            // Note that skipping this initialization and leaving cstNode unassigned also skips the subrule assignment later on.\n            // This is intended, as fragment rules only enrich the current AST node\n            cstNode = this.nodeBuilder.buildCompositeNode(feature);\n        }\n        let result;\n        try {\n            result = this.wrapper.wrapSubrule(idx, rule, args);\n        }\n        finally {\n            if (!this.isRecording()) {\n                // Calling `subrule` on chevrotain parsers can result in a recognition error\n                // This likely means that we encounter a syntax error in the input.\n                // In this case, the result of the subrule is `undefined` and we need to call `construct` manually.\n                if (result === undefined && !fragment) {\n                    result = this.construct();\n                }\n                // We want to perform the subrule assignment regardless of the recognition error\n                // But only if the subrule call actually consumed any tokens\n                if (result !== undefined && cstNode && cstNode.length > 0) {\n                    this.performSubruleAssignment(result, feature, cstNode);\n                }\n            }\n            // We don't have a catch block in here because we want to propagate the recognition error to the caller\n            // This results in much better error recovery and error messages from chevrotain\n        }\n    }\n    performSubruleAssignment(result, feature, cstNode) {\n        const { assignment, crossRef } = this.getAssignment(feature);\n        if (assignment) {\n            this.assign(assignment.operator, assignment.feature, result, cstNode, crossRef);\n        }\n        else if (!assignment) {\n            // If we call a subrule without an assignment we either:\n            // 1. append the result of the subrule (data type rule)\n            // 2. override the current object with the newly parsed object\n            // If the current element is an AST node and the result of the subrule\n            // is a data type rule, we can safely discard the results.\n            const current = this.current;\n            if (isDataTypeNode(current)) {\n                current.value += result.toString();\n            }\n            else if (typeof result === 'object' && result) {\n                const object = this.assignWithoutOverride(result, current);\n                const newItem = object;\n                this.stack.pop();\n                this.stack.push(newItem);\n            }\n        }\n    }\n    action($type, action) {\n        if (!this.isRecording()) {\n            let last = this.current;\n            if (action.feature && action.operator) {\n                last = this.construct();\n                this.nodeBuilder.removeNode(last.$cstNode);\n                const node = this.nodeBuilder.buildCompositeNode(action);\n                node.content.push(last.$cstNode);\n                const newItem = { $type };\n                this.stack.push(newItem);\n                this.assign(action.operator, action.feature, last, last.$cstNode);\n            }\n            else {\n                last.$type = $type;\n            }\n        }\n    }\n    construct() {\n        if (this.isRecording()) {\n            return undefined;\n        }\n        const obj = this.stack.pop();\n        this.nodeBuilder.construct(obj);\n        if ('$infixName' in obj) {\n            return this.constructInfix(obj, this.operatorPrecedence.get(obj.$infixName));\n        }\n        else if (isDataTypeNode(obj)) {\n            return this.converter.convert(obj.value, obj.$cstNode);\n        }\n        else {\n            assignMandatoryProperties(this.astReflection, obj);\n        }\n        return obj;\n    }\n    constructInfix(obj, precedence) {\n        const parts = obj.parts;\n        if (!Array.isArray(parts) || parts.length === 0) {\n            // Likely the result of a syntax error, simply return undefined\n            return undefined;\n        }\n        const operators = obj.operators;\n        if (!Array.isArray(operators) || parts.length < 2) {\n            // Captured just a single, non-binary expression\n            // Simply return the expression as is.\n            return parts[0];\n        }\n        // Find the operator with the lowest precedence (highest value in precedence map)\n        let lowestPrecedenceIdx = 0;\n        let lowestPrecedenceValue = -1;\n        for (let i = 0; i < operators.length; i++) {\n            const operator = operators[i];\n            const opPrecedence = precedence.get(operator) ?? {\n                precedence: Infinity,\n                rightAssoc: false\n            };\n            // For equal precedence, use associativity to determine which operator to pick\n            if (opPrecedence.precedence > lowestPrecedenceValue) {\n                // Always pick operators with lower precedence (higher precedence value)\n                lowestPrecedenceValue = opPrecedence.precedence;\n                lowestPrecedenceIdx = i;\n            }\n            else if (opPrecedence.precedence === lowestPrecedenceValue) {\n                // Check associativity when precedence is equal\n                if (!opPrecedence.rightAssoc) {\n                    // For left associative operators (default), pick the leftmost one\n                    // This means choosing the rightmost equal-precedence operator when working backwards\n                    lowestPrecedenceIdx = i;\n                }\n                // For right associative operators with equal precedence,\n                // we keep the previous (rightmost) index\n            }\n        }\n        // Split the expression at the lowest precedence operator\n        const leftOperators = operators.slice(0, lowestPrecedenceIdx);\n        const rightOperators = operators.slice(lowestPrecedenceIdx + 1);\n        const leftParts = parts.slice(0, lowestPrecedenceIdx + 1);\n        const rightParts = parts.slice(lowestPrecedenceIdx + 1);\n        // Create sub-expressions\n        const leftInfix = {\n            $infixName: obj.$infixName,\n            $type: obj.$type,\n            $cstNode: obj.$cstNode,\n            parts: leftParts,\n            operators: leftOperators\n        };\n        const rightInfix = {\n            $infixName: obj.$infixName,\n            $type: obj.$type,\n            $cstNode: obj.$cstNode,\n            parts: rightParts,\n            operators: rightOperators\n        };\n        // Recursively build the left and right subtrees\n        const leftTree = this.constructInfix(leftInfix, precedence);\n        const rightTree = this.constructInfix(rightInfix, precedence);\n        // Create the final binary expression\n        return {\n            $type: obj.$type,\n            $cstNode: obj.$cstNode,\n            left: leftTree,\n            operator: operators[lowestPrecedenceIdx],\n            right: rightTree\n        };\n    }\n    getAssignment(feature) {\n        if (!this.assignmentMap.has(feature)) {\n            const assignment = getContainerOfType(feature, isAssignment);\n            this.assignmentMap.set(feature, {\n                assignment: assignment,\n                crossRef: assignment && isCrossReference(assignment.terminal) ? (assignment.terminal.isMulti ? 'multi' : 'single') : undefined\n            });\n        }\n        return this.assignmentMap.get(feature);\n    }\n    assign(operator, feature, value, cstNode, crossRef) {\n        const obj = this.current;\n        let item;\n        if (crossRef === 'single' && typeof value === 'string') {\n            item = this.linker.buildReference(obj, feature, cstNode, value);\n        }\n        else if (crossRef === 'multi' && typeof value === 'string') {\n            item = this.linker.buildMultiReference(obj, feature, cstNode, value);\n        }\n        else {\n            item = value;\n        }\n        switch (operator) {\n            case '=': {\n                obj[feature] = item;\n                break;\n            }\n            case '?=': {\n                obj[feature] = true;\n                break;\n            }\n            case '+=': {\n                if (!Array.isArray(obj[feature])) {\n                    obj[feature] = [];\n                }\n                obj[feature].push(item);\n            }\n        }\n    }\n    assignWithoutOverride(target, source) {\n        for (const [name, existingValue] of Object.entries(source)) {\n            const newValue = target[name];\n            if (newValue === undefined) {\n                target[name] = existingValue;\n            }\n            else if (Array.isArray(newValue) && Array.isArray(existingValue)) {\n                existingValue.push(...newValue);\n                target[name] = existingValue;\n            }\n        }\n        // The target was parsed from a unassigned subrule\n        // After the subrule construction, it received a cst node\n        // This CST node will later be overriden by the cst node builder\n        // To prevent references to stale AST nodes in the CST,\n        // we need to remove the reference here\n        const targetCstNode = target.$cstNode;\n        if (targetCstNode) {\n            targetCstNode.astNode = undefined;\n            target.$cstNode = undefined;\n        }\n        return target;\n    }\n    get definitionErrors() {\n        return this.wrapper.definitionErrors;\n    }\n}\nexport class AbstractParserErrorMessageProvider {\n    buildMismatchTokenMessage(options) {\n        return defaultParserErrorProvider.buildMismatchTokenMessage(options);\n    }\n    buildNotAllInputParsedMessage(options) {\n        return defaultParserErrorProvider.buildNotAllInputParsedMessage(options);\n    }\n    buildNoViableAltMessage(options) {\n        return defaultParserErrorProvider.buildNoViableAltMessage(options);\n    }\n    buildEarlyExitMessage(options) {\n        return defaultParserErrorProvider.buildEarlyExitMessage(options);\n    }\n}\nexport class LangiumParserErrorMessageProvider extends AbstractParserErrorMessageProvider {\n    buildMismatchTokenMessage({ expected, actual }) {\n        const expectedMsg = expected.LABEL\n            ? '`' + expected.LABEL + '`'\n            : expected.name.endsWith(':KW')\n                ? `keyword '${expected.name.substring(0, expected.name.length - 3)}'`\n                : `token of type '${expected.name}'`;\n        return `Expecting ${expectedMsg} but found \\`${actual.image}\\`.`;\n    }\n    buildNotAllInputParsedMessage({ firstRedundant }) {\n        return `Expecting end of file but found \\`${firstRedundant.image}\\`.`;\n    }\n}\nexport class LangiumCompletionParser extends AbstractLangiumParser {\n    constructor(services) {\n        super(services, true);\n        this.tokens = [];\n        this.elementStack = [];\n        this.lastElementStack = [];\n        this.nextTokenIndex = 0;\n        this.stackSize = 0;\n    }\n    action() {\n        // NOOP\n    }\n    construct() {\n        // NOOP\n        return undefined;\n    }\n    parse(input) {\n        this.resetState();\n        const tokens = this.lexer.tokenize(input, { mode: 'partial' });\n        this.tokens = tokens.tokens;\n        this.wrapper.input = [...this.tokens];\n        this.mainRule.call(this.wrapper, {});\n        this.unorderedGroups.clear();\n        return {\n            tokens: this.tokens,\n            elementStack: [...this.lastElementStack],\n            tokenIndex: this.nextTokenIndex\n        };\n    }\n    rule(rule, impl) {\n        const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(impl).bind(this));\n        this.allRules.set(rule.name, ruleMethod);\n        if (rule.entry) {\n            this.mainRule = ruleMethod;\n        }\n        return ruleMethod;\n    }\n    resetState() {\n        this.elementStack = [];\n        this.lastElementStack = [];\n        this.nextTokenIndex = 0;\n        this.stackSize = 0;\n    }\n    startImplementation(implementation) {\n        return (args) => {\n            const size = this.keepStackSize();\n            try {\n                implementation(args);\n            }\n            finally {\n                this.resetStackSize(size);\n            }\n        };\n    }\n    removeUnexpectedElements() {\n        this.elementStack.splice(this.stackSize);\n    }\n    keepStackSize() {\n        const size = this.elementStack.length;\n        this.stackSize = size;\n        return size;\n    }\n    resetStackSize(size) {\n        this.removeUnexpectedElements();\n        this.stackSize = size;\n    }\n    consume(idx, tokenType, feature) {\n        this.wrapper.wrapConsume(idx, tokenType);\n        if (!this.isRecording()) {\n            this.lastElementStack = [...this.elementStack, feature];\n            this.nextTokenIndex = this.currIdx + 1;\n        }\n    }\n    subrule(idx, rule, fragment, feature, args) {\n        this.before(feature);\n        this.wrapper.wrapSubrule(idx, rule, args);\n        this.after(feature);\n    }\n    before(element) {\n        if (!this.isRecording()) {\n            this.elementStack.push(element);\n        }\n    }\n    after(element) {\n        if (!this.isRecording()) {\n            const index = this.elementStack.lastIndexOf(element);\n            if (index >= 0) {\n                this.elementStack.splice(index);\n            }\n        }\n    }\n    get currIdx() {\n        return this.wrapper.currIdx;\n    }\n}\nconst defaultConfig = {\n    recoveryEnabled: true,\n    nodeLocationTracking: 'full',\n    skipValidations: true,\n    errorMessageProvider: new LangiumParserErrorMessageProvider()\n};\n/**\n * This class wraps the embedded actions parser of chevrotain and exposes protected methods.\n * This way, we can build the `LangiumParser` as a composition.\n */\nclass ChevrotainWrapper extends EmbeddedActionsParser {\n    constructor(tokens, config, incomplete) {\n        const useDefaultLookahead = config && 'maxLookahead' in config;\n        super(tokens, {\n            ...defaultConfig,\n            lookaheadStrategy: useDefaultLookahead\n                ? new LLkLookaheadStrategy({ maxLookahead: config.maxLookahead })\n                : new LLStarLookaheadStrategy({\n                    // If validations are skipped, don't log the lookahead warnings\n                    logging: config.skipValidations ? () => { } : undefined,\n                    incomplete,\n                }),\n            ...config,\n        });\n    }\n    get IS_RECORDING() {\n        return this.RECORDING_PHASE;\n    }\n    DEFINE_RULE(name, impl, config) {\n        return this.RULE(name, impl, config);\n    }\n    wrapSelfAnalysis() {\n        this.performSelfAnalysis();\n    }\n    wrapConsume(idx, tokenType) {\n        return this.consume(idx, tokenType, undefined);\n    }\n    wrapSubrule(idx, rule, args) {\n        return this.subrule(idx, rule, {\n            ARGS: [args]\n        });\n    }\n    wrapOr(idx, choices) {\n        this.or(idx, choices);\n    }\n    wrapOption(idx, callback) {\n        this.option(idx, callback);\n    }\n    wrapMany(idx, callback) {\n        this.many(idx, callback);\n    }\n    wrapAtLeastOne(idx, callback) {\n        this.atLeastOne(idx, callback);\n    }\n    rule(rule) {\n        return rule.call(this, {});\n    }\n}\nclass ProfilerWrapper extends ChevrotainWrapper {\n    constructor(tokens, config, incomplete, task) {\n        super(tokens, config, incomplete);\n        this.task = task;\n    }\n    rule(rule) {\n        this.task.start();\n        this.task.startSubTask(this.ruleName(rule));\n        try {\n            return super.rule(rule);\n        }\n        finally {\n            this.task.stopSubTask(this.ruleName(rule));\n            this.task.stop();\n        }\n    }\n    ruleName(rule) {\n        return rule.ruleName;\n    }\n    subrule(idx, ruleToCall, options) {\n        this.task.startSubTask(this.ruleName(ruleToCall));\n        try {\n            return super.subrule(idx, ruleToCall, options);\n        }\n        finally {\n            this.task.stopSubTask(this.ruleName(ruleToCall));\n        }\n    }\n}\n//# sourceMappingURL=langium-parser.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/lib/esm/node_modules/langium/lib/parser/lexer.js

@@ -1,54 +0,0 @@
-import { defaultLexerErrorProvider as e } from "../../../chevrotain/lib/src/scan/lexer_errors_public.js";
-import { Lexer as t } from "../../../chevrotain/lib/src/scan/lexer_public.js";
-import "../../../chevrotain/lib/src/api.js";
-//#region ../../node_modules/langium/lib/parser/lexer.js
-var n = class {
-	buildUnexpectedCharactersMessage(t, n, r, i, a) {
-		return e.buildUnexpectedCharactersMessage(t, n, r, i, a);
-	}
-	buildUnableToPopLexerModeMessage(t) {
-		return e.buildUnableToPopLexerModeMessage(t);
-	}
-}, r = { mode: "full" }, i = class {
-	constructor(e) {
-		this.errorMessageProvider = e.parser.LexerErrorMessageProvider, this.tokenBuilder = e.parser.TokenBuilder;
-		let n = this.tokenBuilder.buildTokens(e.Grammar, { caseInsensitive: e.LanguageMetaData.caseInsensitive });
-		this.tokenTypes = this.toTokenTypeDictionary(n);
-		let r = s(n) ? Object.values(n) : n, i = e.LanguageMetaData.mode === "production";
-		this.chevrotainLexer = new t(r, {
-			positionTracking: "full",
-			skipValidations: i,
-			errorMessageProvider: this.errorMessageProvider
-		});
-	}
-	get definition() {
-		return this.tokenTypes;
-	}
-	tokenize(e, t = r) {
-		let n = this.chevrotainLexer.tokenize(e);
-		return {
-			tokens: n.tokens,
-			errors: n.errors,
-			hidden: n.groups.hidden ?? [],
-			report: this.tokenBuilder.flushLexingReport?.(e)
-		};
-	}
-	toTokenTypeDictionary(e) {
-		if (s(e)) return e;
-		let t = o(e) ? Object.values(e.modes).flat() : e, n = {};
-		return t.forEach((e) => n[e.name] = e), n;
-	}
-};
-function a(e) {
-	return Array.isArray(e) && (e.length === 0 || "name" in e[0]);
-}
-function o(e) {
-	return e && "modes" in e && "defaultMode" in e;
-}
-function s(e) {
-	return !a(e) && !o(e);
-}
-//#endregion
-export { i as DefaultLexer, n as DefaultLexerErrorMessageProvider };
-
-//# sourceMappingURL=lexer.js.map

package/lib/esm/node_modules/langium/lib/parser/lexer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lexer.js","names":["ChevrotainLexer"],"sources":["../../../../../../../../node_modules/langium/lib/parser/lexer.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 { Lexer as ChevrotainLexer, defaultLexerErrorProvider } from 'chevrotain';\nexport class DefaultLexerErrorMessageProvider {\n    buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column) {\n        return defaultLexerErrorProvider.buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column);\n    }\n    buildUnableToPopLexerModeMessage(token) {\n        return defaultLexerErrorProvider.buildUnableToPopLexerModeMessage(token);\n    }\n}\nexport const DEFAULT_TOKENIZE_OPTIONS = { mode: 'full' };\nexport class DefaultLexer {\n    constructor(services) {\n        this.errorMessageProvider = services.parser.LexerErrorMessageProvider;\n        this.tokenBuilder = services.parser.TokenBuilder;\n        const tokens = this.tokenBuilder.buildTokens(services.Grammar, {\n            caseInsensitive: services.LanguageMetaData.caseInsensitive\n        });\n        this.tokenTypes = this.toTokenTypeDictionary(tokens);\n        const lexerTokens = isTokenTypeDictionary(tokens) ? Object.values(tokens) : tokens;\n        const production = services.LanguageMetaData.mode === 'production';\n        this.chevrotainLexer = new ChevrotainLexer(lexerTokens, {\n            positionTracking: 'full',\n            skipValidations: production,\n            errorMessageProvider: this.errorMessageProvider\n        });\n    }\n    get definition() {\n        return this.tokenTypes;\n    }\n    tokenize(text, _options = DEFAULT_TOKENIZE_OPTIONS) {\n        const chevrotainResult = this.chevrotainLexer.tokenize(text);\n        return {\n            tokens: chevrotainResult.tokens,\n            errors: chevrotainResult.errors,\n            hidden: chevrotainResult.groups.hidden ?? [],\n            report: this.tokenBuilder.flushLexingReport?.(text)\n        };\n    }\n    toTokenTypeDictionary(buildTokens) {\n        if (isTokenTypeDictionary(buildTokens))\n            return buildTokens;\n        const tokens = isIMultiModeLexerDefinition(buildTokens) ? Object.values(buildTokens.modes).flat() : buildTokens;\n        const res = {};\n        tokens.forEach(token => res[token.name] = token);\n        return res;\n    }\n}\n/**\n * Returns a check whether the given TokenVocabulary is TokenType array\n */\nexport function isTokenTypeArray(tokenVocabulary) {\n    return Array.isArray(tokenVocabulary) && (tokenVocabulary.length === 0 || 'name' in tokenVocabulary[0]);\n}\n/**\n * Returns a check whether the given TokenVocabulary is IMultiModeLexerDefinition\n */\nexport function isIMultiModeLexerDefinition(tokenVocabulary) {\n    return tokenVocabulary && 'modes' in tokenVocabulary && 'defaultMode' in tokenVocabulary;\n}\n/**\n * Returns a check whether the given TokenVocabulary is TokenTypeDictionary\n */\nexport function isTokenTypeDictionary(tokenVocabulary) {\n    return !isTokenTypeArray(tokenVocabulary) && !isIMultiModeLexerDefinition(tokenVocabulary);\n}\n//# sourceMappingURL=lexer.js.map"],"x_google_ignoreList":[0],"mappings":";;;;AAMA,IAAa,IAAb,MAA8C;CAC1C,iCAAiC,GAAU,GAAa,GAAQ,GAAM,GAAQ;EAC1E,OAAO,EAA0B,iCAAiC,GAAU,GAAa,GAAQ,GAAM,EAAO;;CAElH,iCAAiC,GAAO;EACpC,OAAO,EAA0B,iCAAiC,EAAM;;GAGnE,IAA2B,EAAE,MAAM,QAAQ,EAC3C,IAAb,MAA0B;CACtB,YAAY,GAAU;EAElB,AADA,KAAK,uBAAuB,EAAS,OAAO,2BAC5C,KAAK,eAAe,EAAS,OAAO;EACpC,IAAM,IAAS,KAAK,aAAa,YAAY,EAAS,SAAS,EAC3D,iBAAiB,EAAS,iBAAiB,iBAC9C,CAAC;EACF,KAAK,aAAa,KAAK,sBAAsB,EAAO;EACpD,IAAM,IAAc,EAAsB,EAAO,GAAG,OAAO,OAAO,EAAO,GAAG,GACtE,IAAa,EAAS,iBAAiB,SAAS;EACtD,KAAK,kBAAkB,IAAIA,EAAgB,GAAa;GACpD,kBAAkB;GAClB,iBAAiB;GACjB,sBAAsB,KAAK;GAC9B,CAAC;;CAEN,IAAI,aAAa;EACb,OAAO,KAAK;;CAEhB,SAAS,GAAM,IAAW,GAA0B;EAChD,IAAM,IAAmB,KAAK,gBAAgB,SAAS,EAAK;EAC5D,OAAO;GACH,QAAQ,EAAiB;GACzB,QAAQ,EAAiB;GACzB,QAAQ,EAAiB,OAAO,UAAU,EAAE;GAC5C,QAAQ,KAAK,aAAa,oBAAoB,EAAK;GACtD;;CAEL,sBAAsB,GAAa;EAC/B,IAAI,EAAsB,EAAY,EAClC,OAAO;EACX,IAAM,IAAS,EAA4B,EAAY,GAAG,OAAO,OAAO,EAAY,MAAM,CAAC,MAAM,GAAG,GAC9F,IAAM,EAAE;EAEd,OADA,EAAO,SAAQ,MAAS,EAAI,EAAM,QAAQ,EAAM,EACzC;;;AAMf,SAAgB,EAAiB,GAAiB;CAC9C,OAAO,MAAM,QAAQ,EAAgB,KAAK,EAAgB,WAAW,KAAK,UAAU,EAAgB;;AAKxG,SAAgB,EAA4B,GAAiB;CACzD,OAAO,KAAmB,WAAW,KAAmB,iBAAiB;;AAK7E,SAAgB,EAAsB,GAAiB;CACnD,OAAO,CAAC,EAAiB,EAAgB,IAAI,CAAC,EAA4B,EAAgB"}