@loopstack/loopstack-studio 0.28.0 → 0.29.0

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

@@ -1,275 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,190 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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 };