@loopstack/loopstack-studio 0.20.2 → 0.21.0-rc.0

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

@@ -0,0 +1,275 @@
+import { stream } from "../utils/stream.js";
+import { isAbstractParserRule, isAction, isAlternatives, isAssignment, isBooleanLiteral, isConjunction, isCrossReference, isDisjunction, isEndOfFile, isGroup, isInfixRule, isKeyword, isNegation, isParameterReference, isParserRule, isRuleCall, isTerminalRule, isUnorderedGroup } from "../languages/generated/ast.js";
+import { ErrorWithLocation, assertUnreachable } from "../utils/errors.js";
+import { findNameAssignment, getAllReachableRules, getTypeName } from "../utils/grammar-utils.js";
+import { EOF } from "../../../chevrotain/lib/src/scan/tokens_public.js";
+import { EMPTY_ALT } from "../../../chevrotain/lib/src/parse/parser/parser.js";
+import "../../../chevrotain/lib/src/api.js";
+function createParser(d, P, F) {
+	return buildRules({
+		parser: P,
+		tokens: F,
+		ruleNames: /* @__PURE__ */ new Map()
+	}, d), P;
+}
+function buildRules(P, F) {
+	let I = getAllReachableRules(F, !1), L = stream(F.rules).filter(isParserRule).filter((d) => I.has(d));
+	for (let d of L) {
+		let F = {
+			...P,
+			consume: 1,
+			optional: 1,
+			subrule: 1,
+			many: 1,
+			or: 1
+		};
+		P.parser.rule(d, buildElement(F, d.definition));
+	}
+	let R = stream(F.rules).filter(isInfixRule).filter((d) => I.has(d));
+	for (let d of R) P.parser.rule(d, buildInfixRule(P, d));
+}
+function buildInfixRule(d, P) {
+	let F = P.call.rule.ref;
+	if (!F) throw Error("Could not resolve reference to infix operator rule: " + P.call.rule.$refText);
+	if (isTerminalRule(F)) throw Error("Cannot use terminal rule in infix expression");
+	let I = P.operators.precedences.flatMap((d) => d.operators), L = {
+		$type: "Group",
+		elements: []
+	}, R = {
+		$container: L,
+		$type: "Assignment",
+		feature: "parts",
+		operator: "+=",
+		terminal: P.call
+	}, z = {
+		$container: L,
+		$type: "Group",
+		elements: [],
+		cardinality: "*"
+	};
+	L.elements.push(R, z);
+	let B = {
+		$container: z,
+		$type: "Assignment",
+		feature: "operators",
+		operator: "+=",
+		terminal: {
+			$type: "Alternatives",
+			elements: I
+		}
+	}, V = {
+		...R,
+		$container: z
+	};
+	z.elements.push(B, V);
+	let H = I.map((P) => d.tokens[P.value]).map((P, F) => ({ ALT: () => d.parser.consume(F, P, B) })), U;
+	return (P) => {
+		U ??= getRule(d, F), d.parser.subrule(0, U, !1, R, P), d.parser.many(0, { DEF: () => {
+			d.parser.alternatives(0, H), d.parser.subrule(1, U, !1, V, P);
+		} });
+	};
+}
+function buildElement(d, P, R = !1) {
+	let z;
+	if (isKeyword(P)) z = buildKeyword(d, P);
+	else if (isAction(P)) z = buildAction(d, P);
+	else if (isAssignment(P)) z = buildElement(d, P.terminal);
+	else if (isCrossReference(P)) z = buildCrossReference(d, P);
+	else if (isRuleCall(P)) z = buildRuleCall(d, P);
+	else if (isAlternatives(P)) z = buildAlternatives(d, P);
+	else if (isUnorderedGroup(P)) z = buildUnorderedGroup(d, P);
+	else if (isGroup(P)) z = buildGroup(d, P);
+	else if (isEndOfFile(P)) {
+		let F = d.consume++;
+		z = () => d.parser.consume(F, EOF, P);
+	} else throw new ErrorWithLocation(P.$cstNode, `Unexpected element type: ${P.$type}`);
+	return wrap(d, R ? void 0 : getGuardCondition(P), z, P.cardinality);
+}
+function buildAction(d, P) {
+	let F = getTypeName(P);
+	return () => d.parser.action(F, P);
+}
+function buildRuleCall(d, F) {
+	let I = F.rule.ref;
+	if (isAbstractParserRule(I)) {
+		let P = d.subrule++, L = isParserRule(I) && I.fragment, R = F.arguments.length > 0 ? buildRuleCallPredicate(I, F.arguments) : () => ({}), z;
+		return (B) => {
+			z ??= getRule(d, I), d.parser.subrule(P, z, L, F, R(B));
+		};
+	} else if (isTerminalRule(I)) {
+		let P = d.consume++, L = getToken(d, I.name);
+		return () => d.parser.consume(P, L, F);
+	} else if (I) assertUnreachable(I);
+	else throw new ErrorWithLocation(F.$cstNode, `Undefined rule: ${F.rule.$refText}`);
+}
+function buildRuleCallPredicate(d, P) {
+	if (P.some((d) => d.calledByName)) {
+		let d = P.map((d) => ({
+			parameterName: d.parameter?.ref?.name,
+			predicate: buildPredicate(d.value)
+		}));
+		return (P) => {
+			let F = {};
+			for (let { parameterName: I, predicate: L } of d) I && (F[I] = L(P));
+			return F;
+		};
+	} else {
+		let F = P.map((d) => buildPredicate(d.value));
+		return (P) => {
+			let I = {};
+			for (let L = 0; L < F.length; L++) if (L < d.parameters.length) {
+				let R = d.parameters[L].name, z = F[L];
+				I[R] = z(P);
+			}
+			return I;
+		};
+	}
+}
+function buildPredicate(d) {
+	if (isDisjunction(d)) {
+		let P = buildPredicate(d.left), F = buildPredicate(d.right);
+		return (d) => P(d) || F(d);
+	} else if (isConjunction(d)) {
+		let P = buildPredicate(d.left), F = buildPredicate(d.right);
+		return (d) => P(d) && F(d);
+	} else if (isNegation(d)) {
+		let P = buildPredicate(d.value);
+		return (d) => !P(d);
+	} else if (isParameterReference(d)) {
+		let P = d.parameter.ref.name;
+		return (d) => d !== void 0 && d[P] === !0;
+	} else if (isBooleanLiteral(d)) {
+		let P = !!d.true;
+		return () => P;
+	}
+	assertUnreachable(d);
+}
+function buildAlternatives(d, P) {
+	if (P.elements.length === 1) return buildElement(d, P.elements[0]);
+	{
+		let F = [];
+		for (let I of P.elements) {
+			let P = { ALT: buildElement(d, I, !0) }, L = getGuardCondition(I);
+			L && (P.GATE = buildPredicate(L)), F.push(P);
+		}
+		let I = d.or++;
+		return (P) => d.parser.alternatives(I, F.map((d) => {
+			let F = { ALT: () => d.ALT(P) }, I = d.GATE;
+			return I && (F.GATE = () => I(P)), F;
+		}));
+	}
+}
+function buildUnorderedGroup(d, P) {
+	if (P.elements.length === 1) return buildElement(d, P.elements[0]);
+	let F = [];
+	for (let I of P.elements) {
+		let P = { ALT: buildElement(d, I, !0) }, L = getGuardCondition(I);
+		L && (P.GATE = buildPredicate(L)), F.push(P);
+	}
+	let I = d.or++, L = (d, P) => `uGroup_${d}_${P.getRuleStack().join("-")}`, R = wrap(d, getGuardCondition(P), (P) => d.parser.alternatives(I, F.map((F, R) => {
+		let z = { ALT: () => !0 }, B = d.parser;
+		z.ALT = () => {
+			if (F.ALT(P), !B.isRecording()) {
+				let d = L(I, B);
+				B.unorderedGroups.get(d) || B.unorderedGroups.set(d, []);
+				let P = B.unorderedGroups.get(d);
+				P?.[R] === void 0 && (P[R] = !0);
+			}
+		};
+		let V = F.GATE;
+		return V ? z.GATE = () => V(P) : z.GATE = () => !B.unorderedGroups.get(L(I, B))?.[R], z;
+	})), "*");
+	return (P) => {
+		R(P), d.parser.isRecording() || d.parser.unorderedGroups.delete(L(I, d.parser));
+	};
+}
+function buildGroup(d, P) {
+	let F = P.elements.map((P) => buildElement(d, P));
+	return (d) => F.forEach((P) => P(d));
+}
+function getGuardCondition(d) {
+	if (isGroup(d)) return d.guardCondition;
+}
+function buildCrossReference(d, P, F = P.terminal) {
+	if (F) if (isRuleCall(F) && isParserRule(F.rule.ref)) {
+		let I = F.rule.ref, L = d.subrule++, R;
+		return (F) => {
+			R ??= getRule(d, I), d.parser.subrule(L, R, !1, P, F);
+		};
+	} else if (isRuleCall(F) && isTerminalRule(F.rule.ref)) {
+		let I = d.consume++, L = getToken(d, F.rule.ref.name);
+		return () => d.parser.consume(I, L, P);
+	} else if (isKeyword(F)) {
+		let I = d.consume++, L = getToken(d, F.value);
+		return () => d.parser.consume(I, L, P);
+	} else throw Error("Could not build cross reference parser");
+	else {
+		if (!P.type.ref) throw Error("Could not resolve reference to type: " + P.type.$refText);
+		let F = findNameAssignment(P.type.ref)?.terminal;
+		if (!F) throw Error("Could not find name assignment for type: " + getTypeName(P.type.ref));
+		return buildCrossReference(d, P, F);
+	}
+}
+function buildKeyword(d, P) {
+	let F = d.consume++, I = d.tokens[P.value];
+	if (!I) throw Error("Could not find token for keyword: " + P.value);
+	return () => d.parser.consume(F, I, P);
+}
+function wrap(d, P, F, I) {
+	let L = P && buildPredicate(P);
+	if (!I) if (L) {
+		let P = d.or++;
+		return (I) => d.parser.alternatives(P, [{
+			ALT: () => F(I),
+			GATE: () => L(I)
+		}, {
+			ALT: EMPTY_ALT(),
+			GATE: () => !L(I)
+		}]);
+	} else return F;
+	if (I === "*") {
+		let P = d.many++;
+		return (I) => d.parser.many(P, {
+			DEF: () => F(I),
+			GATE: L ? () => L(I) : void 0
+		});
+	} else if (I === "+") {
+		let P = d.many++;
+		if (L) {
+			let I = d.or++;
+			return (R) => d.parser.alternatives(I, [{
+				ALT: () => d.parser.atLeastOne(P, { DEF: () => F(R) }),
+				GATE: () => L(R)
+			}, {
+				ALT: EMPTY_ALT(),
+				GATE: () => !L(R)
+			}]);
+		} else return (I) => d.parser.atLeastOne(P, { DEF: () => F(I) });
+	} else if (I === "?") {
+		let P = d.optional++;
+		return (I) => d.parser.optional(P, {
+			DEF: () => F(I),
+			GATE: L ? () => L(I) : void 0
+		});
+	} else assertUnreachable(I);
+}
+function getRule(d, P) {
+	let F = getRuleName(d, P), I = d.parser.getRule(F);
+	if (!I) throw Error(`Rule "${F}" not found."`);
+	return I;
+}
+function getRuleName(d, F) {
+	if (isAbstractParserRule(F)) return F.name;
+	if (d.ruleNames.has(F)) return d.ruleNames.get(F);
+	{
+		let P = F, L = P.$container, R = F.$type;
+		for (; !isParserRule(L);) (isGroup(L) || isAlternatives(L) || isUnorderedGroup(L)) && (R = L.elements.indexOf(P).toString() + ":" + R), P = L, L = L.$container;
+		return R = L.name + ":" + R, d.ruleNames.set(F, R), R;
+	}
+}
+function getToken(d, P) {
+	let F = d.tokens[P];
+	if (!F) throw Error(`Token "${P}" not found."`);
+	return F;
+}
+export { createParser };

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

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

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

@@ -0,0 +1,78 @@
+import { isCrossReference, isRuleCall } from "../languages/generated/ast.js";
+import { getCrossReferenceTerminal, getRuleType } from "../utils/grammar-utils.js";
+var DefaultValueConverter = class {
+	convert(r, i) {
+		let a = i.grammarSource;
+		if (isCrossReference(a) && (a = getCrossReferenceTerminal(a)), isRuleCall(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 ValueConverter.convertInt(t);
+			case "STRING": return ValueConverter.convertString(t);
+			case "ID": return ValueConverter.convertID(t);
+		}
+		switch (getRuleType(e)?.toLowerCase()) {
+			case "number": return ValueConverter.convertNumber(t);
+			case "boolean": return ValueConverter.convertBoolean(t);
+			case "bigint": return ValueConverter.convertBigint(t);
+			case "date": return ValueConverter.convertDate(t);
+			default: return t;
+		}
+	}
+}, ValueConverter;
+(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;
+})(ValueConverter ||= {});
+export { DefaultValueConverter, ValueConverter };

package/dist/node_modules/langium/lib/references/linker.js

@@ -0,0 +1,190 @@
+import { isAstNode, isAstNodeDescription, isLinkingError } from "../syntax-tree.js";
+import { findRootNode, streamAst, streamReferences } from "../utils/ast-utils.js";
+import { cancellation_exports } from "../utils/cancellation.js";
+import { interruptAndCheck } from "../utils/promise-utils.js";
+import { DocumentState } from "../workspace/documents.js";
+const RefResolving = Symbol("RefResolving");
+var DefaultLinker = class {
+	constructor(e) {
+		this.reflection = e.shared.AstReflection, this.langiumDocuments = () => e.shared.workspace.LangiumDocuments, this.scopeProvider = e.references.ScopeProvider, this.astNodeLocator = e.workspace.AstNodeLocator, this.profiler = e.shared.profilers.LangiumProfiler, this.languageId = e.LanguageMetaData.languageId;
+	}
+	async link(e, n = cancellation_exports.CancellationToken.None) {
+		if (this.profiler?.isActive("linking")) {
+			let r = this.profiler.createTask("linking", this.languageId);
+			r.start();
+			try {
+				for (let i of streamAst(e.parseResult.value)) await interruptAndCheck(n), streamReferences(i).forEach((n) => {
+					let a = `${i.$type}:${n.property}`;
+					r.startSubTask(a);
+					try {
+						this.doLink(n, e);
+					} finally {
+						r.stopSubTask(a);
+					}
+				});
+			} finally {
+				r.stop();
+			}
+		} else for (let r of streamAst(e.parseResult.value)) await interruptAndCheck(n), streamReferences(r).forEach((n) => this.doLink(n, e));
+	}
+	doLink(e, n) {
+		let i = e.reference;
+		if ("_ref" in i && i._ref === void 0) {
+			i._ref = RefResolving;
+			try {
+				let n = this.getCandidate(e);
+				isLinkingError(n) ? i._ref = n : (i._nodeDescription = n, i._ref = this.loadAstNode(n) ?? this.createLinkingError(e, n));
+			} catch (n) {
+				console.error(`An error occurred while resolving reference to '${i.$refText}':`, n);
+				let r = n.message ?? String(n);
+				i._ref = {
+					info: e,
+					message: `An error occurred while resolving reference to '${i.$refText}': ${r}`
+				};
+			}
+			n.references.push(i);
+		} else if ("_items" in i && i._items === void 0) {
+			i._items = RefResolving;
+			try {
+				let n = this.getCandidates(e), a = [];
+				if (isLinkingError(n)) i._linkingError = n;
+				else for (let e of n) {
+					let n = this.loadAstNode(e);
+					n && a.push({
+						ref: n,
+						$nodeDescription: e
+					});
+				}
+				i._items = a;
+			} catch (n) {
+				i._linkingError = {
+					info: e,
+					message: `An error occurred while resolving reference to '${i.$refText}': ${n}`
+				}, i._items = [];
+			}
+			n.references.push(i);
+		}
+	}
+	unlink(e) {
+		for (let n of e.references) "_ref" in n ? (n._ref = void 0, delete n._nodeDescription) : "_items" in n && (n._items = void 0, delete n._linkingError);
+		e.references = [];
+	}
+	getCandidate(e) {
+		return this.scopeProvider.getScope(e).getElement(e.reference.$refText) ?? this.createLinkingError(e);
+	}
+	getCandidates(e) {
+		let n = this.scopeProvider.getScope(e).getElements(e.reference.$refText).distinct((e) => `${e.documentUri}#${e.path}`).toArray();
+		return n.length > 0 ? n : this.createLinkingError(e);
+	}
+	buildReference(a, o, s, c) {
+		let u = this, d = {
+			$refNode: s,
+			$refText: c,
+			_ref: void 0,
+			get ref() {
+				if (isAstNode(this._ref)) return this._ref;
+				if (isAstNodeDescription(this._nodeDescription)) this._ref = u.loadAstNode(this._nodeDescription) ?? u.createLinkingError({
+					reference: d,
+					container: a,
+					property: o
+				}, this._nodeDescription);
+				else if (this._ref === void 0) {
+					this._ref = RefResolving;
+					let e = findRootNode(a).$document, n = u.getLinkedNode({
+						reference: d,
+						container: a,
+						property: o
+					});
+					if (n.error && e && e.state < DocumentState.ComputedScopes) {
+						this._ref = void 0;
+						return;
+					}
+					this._ref = n.node ?? n.error, this._nodeDescription = n.descr, e?.references.push(this);
+				} else this._ref === RefResolving && u.throwCyclicReferenceError(a, o, c);
+				return isAstNode(this._ref) ? this._ref : void 0;
+			},
+			get $nodeDescription() {
+				return this._nodeDescription;
+			},
+			get error() {
+				return isLinkingError(this._ref) ? this._ref : void 0;
+			}
+		};
+		return d;
+	}
+	buildMultiReference(e, n, a, o) {
+		let s = this, c = {
+			$refNode: a,
+			$refText: o,
+			_items: void 0,
+			get items() {
+				if (Array.isArray(this._items)) return this._items;
+				if (this._items === void 0) {
+					this._items = RefResolving;
+					let a = findRootNode(e).$document, o = s.getCandidates({
+						reference: c,
+						container: e,
+						property: n
+					}), l = [];
+					if (isLinkingError(o)) this._linkingError = o;
+					else for (let e of o) {
+						let n = s.loadAstNode(e);
+						n && l.push({
+							ref: n,
+							$nodeDescription: e
+						});
+					}
+					this._items = l, a?.references.push(this);
+				} else this._items === RefResolving && s.throwCyclicReferenceError(e, n, o);
+				return Array.isArray(this._items) ? this._items : [];
+			},
+			get error() {
+				if (this._linkingError) return this._linkingError;
+				if (!(this.items.length > 0)) return this._linkingError = s.createLinkingError({
+					reference: c,
+					container: e,
+					property: n
+				});
+			}
+		};
+		return c;
+	}
+	throwCyclicReferenceError(e, n, r) {
+		throw Error(`Cyclic reference resolution detected: ${this.astNodeLocator.getAstNodePath(e)}/${n} (symbol '${r}')`);
+	}
+	getLinkedNode(e) {
+		try {
+			let n = this.getCandidate(e);
+			if (isLinkingError(n)) return { error: n };
+			let i = this.loadAstNode(n);
+			return i ? {
+				node: i,
+				descr: n
+			} : {
+				descr: n,
+				error: this.createLinkingError(e, n)
+			};
+		} catch (n) {
+			console.error(`An error occurred while resolving reference to '${e.reference.$refText}':`, n);
+			let r = n.message ?? String(n);
+			return { error: {
+				info: e,
+				message: `An error occurred while resolving reference to '${e.reference.$refText}': ${r}`
+			} };
+		}
+	}
+	loadAstNode(e) {
+		if (e.node) return e.node;
+		let n = this.langiumDocuments().getDocument(e.documentUri);
+		if (n) return this.astNodeLocator.getAstNode(n.parseResult.value, e.path);
+	}
+	createLinkingError(e, n) {
+		let r = findRootNode(e.container).$document;
+		return r && r.state < DocumentState.ComputedScopes && console.warn(`Attempted reference resolution before document reached ComputedScopes state (${r.uri}).`), {
+			info: e,
+			message: `Could not resolve reference to ${this.reflection.getReferenceType(e)} named '${e.reference.$refText}'.`,
+			targetDescription: n
+		};
+	}
+};
+export { DefaultLinker, RefResolving };

package/dist/node_modules/langium/lib/references/name-provider.js

@@ -0,0 +1,13 @@
+import { findNodeForProperty } from "../utils/grammar-utils.js";
+function isNamed(e) {
+	return typeof e.name == "string";
+}
+var DefaultNameProvider = class {
+	getName(e) {
+		if (isNamed(e)) return e.name;
+	}
+	getNameNode(n) {
+		return findNodeForProperty(n.$cstNode, "name");
+	}
+};
+export { DefaultNameProvider, isNamed };

package/dist/node_modules/langium/lib/references/references.js

@@ -0,0 +1,76 @@
+import { isMultiReference, isReference } from "../syntax-tree.js";
+import { stream } from "../utils/stream.js";
+import { getDocument, getReferenceNodes, streamAst, streamReferences } from "../utils/ast-utils.js";
+import { isCrossReference } from "../languages/generated/ast.js";
+import { isChildNode, toDocumentSegment } from "../utils/cst-utils.js";
+import { findAssignment } from "../utils/grammar-utils.js";
+import { UriUtils } from "../utils/uri-utils.js";
+var DefaultReferences = class {
+	constructor(e) {
+		this.nameProvider = e.references.NameProvider, this.index = e.shared.workspace.IndexManager, this.nodeLocator = e.workspace.AstNodeLocator, this.documents = e.shared.workspace.LangiumDocuments, this.hasMultiReference = streamAst(e.Grammar).some((e) => isCrossReference(e) && e.isMulti);
+	}
+	findDeclarations(c) {
+		if (c) {
+			let l = findAssignment(c), d = c.astNode;
+			if (l && d) {
+				let f = d[l.feature];
+				if (isReference(f) || isMultiReference(f)) return getReferenceNodes(f);
+				if (Array.isArray(f)) {
+					for (let l of f) if ((isReference(l) || isMultiReference(l)) && l.$refNode && l.$refNode.offset <= c.offset && l.$refNode.end >= c.end) return getReferenceNodes(l);
+				}
+			}
+			if (d) {
+				let e = this.nameProvider.getNameNode(d);
+				if (e && (e === c || isChildNode(c, e))) return this.getSelfNodes(d);
+			}
+		}
+		return [];
+	}
+	getSelfNodes(s) {
+		if (this.hasMultiReference) {
+			let c = this.index.findAllReferences(s, this.nodeLocator.getAstNodePath(s)), l = this.getNodeFromReferenceDescription(c.head());
+			if (l) {
+				for (let c of streamReferences(l)) if (isMultiReference(c.reference) && c.reference.items.some((e) => e.ref === s)) return c.reference.items.map((e) => e.ref);
+			}
+			return [s];
+		} else return [s];
+	}
+	getNodeFromReferenceDescription(e) {
+		if (!e) return;
+		let s = this.documents.getDocument(e.sourceUri);
+		if (s) return this.nodeLocator.getAstNode(s.parseResult.value, e.sourcePath);
+	}
+	findDeclarationNodes(e) {
+		let s = this.findDeclarations(e), c = [];
+		for (let e of s) {
+			let s = this.nameProvider.getNameNode(e) ?? e.$cstNode;
+			s && c.push(s);
+		}
+		return c;
+	}
+	findReferences(e, s) {
+		let l = [];
+		s.includeDeclaration && l.push(...this.getSelfReferences(e));
+		let u = this.index.findAllReferences(e, this.nodeLocator.getAstNodePath(e));
+		return s.documentUri && (u = u.filter((e) => UriUtils.equals(e.sourceUri, s.documentUri))), l.push(...u), stream(l);
+	}
+	getSelfReferences(e) {
+		let s = this.getSelfNodes(e), c = [];
+		for (let e of s) {
+			let s = this.nameProvider.getNameNode(e);
+			if (s) {
+				let u = getDocument(e), d = this.nodeLocator.getAstNodePath(e);
+				c.push({
+					sourceUri: u.uri,
+					sourcePath: d,
+					targetUri: u.uri,
+					targetPath: d,
+					segment: toDocumentSegment(s),
+					local: !0
+				});
+			}
+		}
+		return c;
+	}
+};
+export { DefaultReferences };