@loopstack/loopstack-studio 0.25.0 → 0.25.1

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

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

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

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