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

package/dist/node_modules/langium/lib/references/scope-computation.js

@@ -0,0 +1,35 @@
+import { streamAllContents, streamContents } from "../utils/ast-utils.js";
+import { cancellation_exports } from "../utils/cancellation.js";
+import { interruptAndCheck } from "../utils/promise-utils.js";
+import { MultiMap } from "../utils/collections.js";
+var DefaultScopeComputation = class {
+	constructor(e) {
+		this.nameProvider = e.references.NameProvider, this.descriptions = e.workspace.AstNodeDescriptionProvider;
+	}
+	async collectExportedSymbols(e, t = cancellation_exports.CancellationToken.None) {
+		return this.collectExportedSymbolsForNode(e.parseResult.value, e, void 0, t);
+	}
+	async collectExportedSymbolsForNode(e, i, a = streamContents, o = cancellation_exports.CancellationToken.None) {
+		let s = [];
+		this.addExportedSymbol(e, s, i);
+		for (let t of a(e)) await interruptAndCheck(o), this.addExportedSymbol(t, s, i);
+		return s;
+	}
+	addExportedSymbol(e, t, n) {
+		let r = this.nameProvider.getName(e);
+		r && t.push(this.descriptions.createDescription(e, r, n));
+	}
+	async collectLocalSymbols(t, a = cancellation_exports.CancellationToken.None) {
+		let o = t.parseResult.value, s = new MultiMap();
+		for (let n of streamAllContents(o)) await interruptAndCheck(a), this.addLocalSymbol(n, t, s);
+		return s;
+	}
+	addLocalSymbol(e, t, n) {
+		let r = e.$container;
+		if (r) {
+			let i = this.nameProvider.getName(e);
+			i && n.add(r, this.descriptions.createDescription(e, i, t));
+		}
+	}
+};
+export { DefaultScopeComputation };

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

@@ -0,0 +1,34 @@
+import { stream } from "../utils/stream.js";
+import { getDocument } from "../utils/ast-utils.js";
+import { MultiMapScope, StreamScope } from "./scope.js";
+import { WorkspaceCache } from "../utils/caching.js";
+var DefaultScopeProvider = class {
+	constructor(e) {
+		this.reflection = e.shared.AstReflection, this.nameProvider = e.references.NameProvider, this.descriptions = e.workspace.AstNodeDescriptionProvider, this.indexManager = e.shared.workspace.IndexManager, this.globalScopeCache = new WorkspaceCache(e.shared);
+	}
+	getScope(e) {
+		let n = [], r = this.reflection.getReferenceType(e), i = getDocument(e.container).localSymbols;
+		if (i) {
+			let t = e.container;
+			do
+				i.has(t) && n.push(i.getStream(t).filter((e) => this.reflection.isSubtype(e.type, r))), t = t.$container;
+			while (t);
+		}
+		let a = this.getGlobalScope(r, e);
+		for (let e = n.length - 1; e >= 0; e--) a = this.createScope(n[e], a);
+		return a;
+	}
+	createScope(t, n, i) {
+		return new StreamScope(stream(t), n, i);
+	}
+	createScopeForNodes(t, n, i) {
+		return new StreamScope(stream(t).map((e) => {
+			let t = this.nameProvider.getName(e);
+			if (t) return this.descriptions.createDescription(e, t);
+		}).nonNullable(), n, i);
+	}
+	getGlobalScope(e, t) {
+		return this.globalScopeCache.get(e, () => new MultiMapScope(this.indexManager.allElements(e)));
+	}
+};
+export { DefaultScopeProvider };

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

@@ -0,0 +1,73 @@
+import { EMPTY_STREAM, stream } from "../utils/stream.js";
+import { MultiMap } from "../utils/collections.js";
+var StreamScope = class {
+	constructor(e, r, i) {
+		this.elements = e, this.outerScope = r, this.caseInsensitive = i?.caseInsensitive ?? !1, this.concatOuterScope = i?.concatOuterScope ?? !0;
+	}
+	getAllElements() {
+		return this.outerScope ? this.elements.concat(this.outerScope.getAllElements()) : this.elements;
+	}
+	getElement(e) {
+		let r = this.caseInsensitive ? e.toLowerCase() : e, i = this.caseInsensitive ? this.elements.find((e) => e.name.toLowerCase() === r) : this.elements.find((r) => r.name === e);
+		if (i) return i;
+		if (this.outerScope) return this.outerScope.getElement(e);
+	}
+	getElements(e) {
+		let r = this.caseInsensitive ? e.toLowerCase() : e, i = this.caseInsensitive ? this.elements.filter((e) => e.name.toLowerCase() === r) : this.elements.filter((r) => r.name === e);
+		return (this.concatOuterScope || i.isEmpty()) && this.outerScope ? i.concat(this.outerScope.getElements(e)) : i;
+	}
+}, MapScope = class {
+	constructor(e, r, i) {
+		this.elements = /* @__PURE__ */ new Map(), this.caseInsensitive = i?.caseInsensitive ?? !1, this.concatOuterScope = i?.concatOuterScope ?? !0;
+		for (let r of e) {
+			let e = this.caseInsensitive ? r.name.toLowerCase() : r.name;
+			this.elements.set(e, r);
+		}
+		this.outerScope = r;
+	}
+	getElement(e) {
+		let r = this.caseInsensitive ? e.toLowerCase() : e, i = this.elements.get(r);
+		if (i) return i;
+		if (this.outerScope) return this.outerScope.getElement(e);
+	}
+	getElements(e) {
+		let i = this.caseInsensitive ? e.toLowerCase() : e, a = this.elements.get(i), o = a ? [a] : [];
+		return (this.concatOuterScope || o.length > 0) && this.outerScope ? stream(o).concat(this.outerScope.getElements(e)) : stream(o);
+	}
+	getAllElements() {
+		let e = stream(this.elements.values());
+		return this.outerScope && (e = e.concat(this.outerScope.getAllElements())), e;
+	}
+}, MultiMapScope = class {
+	constructor(e, r, a) {
+		this.elements = new MultiMap(), this.caseInsensitive = a?.caseInsensitive ?? !1, this.concatOuterScope = a?.concatOuterScope ?? !0;
+		for (let r of e) {
+			let e = this.caseInsensitive ? r.name.toLowerCase() : r.name;
+			this.elements.add(e, r);
+		}
+		this.outerScope = r;
+	}
+	getElement(e) {
+		let r = this.caseInsensitive ? e.toLowerCase() : e, i = this.elements.get(r)[0];
+		if (i) return i;
+		if (this.outerScope) return this.outerScope.getElement(e);
+	}
+	getElements(e) {
+		let i = this.caseInsensitive ? e.toLowerCase() : e, a = this.elements.get(i);
+		return (this.concatOuterScope || a.length === 0) && this.outerScope ? stream(a).concat(this.outerScope.getElements(e)) : stream(a);
+	}
+	getAllElements() {
+		let e = stream(this.elements.values());
+		return this.outerScope && (e = e.concat(this.outerScope.getAllElements())), e;
+	}
+};
+const EMPTY_SCOPE = {
+	getElement() {},
+	getElements() {
+		return EMPTY_STREAM;
+	},
+	getAllElements() {
+		return EMPTY_STREAM;
+	}
+};
+export { EMPTY_SCOPE, MapScope, MultiMapScope, StreamScope };

package/dist/node_modules/langium/lib/serializer/hydrator.js

@@ -0,0 +1,125 @@
+import { isAstNode, isCompositeCstNode, isLeafCstNode, isReference, isRootCstNode } from "../syntax-tree.js";
+import { streamAst } from "../utils/ast-utils.js";
+import { isAbstractElement } from "../languages/generated/ast.js";
+import { streamCst } from "../utils/cst-utils.js";
+import { CompositeCstNodeImpl, LeafCstNodeImpl, RootCstNodeImpl } from "../parser/cst-node-builder.js";
+import { BiMap } from "../utils/collections.js";
+var DefaultHydrator = class {
+	constructor(e) {
+		this.grammarElementIdMap = new BiMap(), this.tokenTypeIdMap = new BiMap(), this.grammar = e.Grammar, this.lexer = e.parser.Lexer, this.linker = e.references.Linker;
+	}
+	dehydrate(e) {
+		return {
+			lexerErrors: e.lexerErrors,
+			lexerReport: e.lexerReport ? this.dehydrateLexerReport(e.lexerReport) : void 0,
+			parserErrors: e.parserErrors.map((e) => ({
+				...e,
+				message: e.message
+			})),
+			value: this.dehydrateAstNode(e.value, this.createDehyrationContext(e.value))
+		};
+	}
+	dehydrateLexerReport(e) {
+		return e;
+	}
+	createDehyrationContext(e) {
+		let a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
+		for (let o of streamAst(e)) a.set(o, {});
+		if (e.$cstNode) for (let a of streamCst(e.$cstNode)) o.set(a, {});
+		return {
+			astNodes: a,
+			cstNodes: o
+		};
+	}
+	dehydrateAstNode(a, o) {
+		let c = o.astNodes.get(a);
+		c.$type = a.$type, c.$containerIndex = a.$containerIndex, c.$containerProperty = a.$containerProperty, a.$cstNode !== void 0 && (c.$cstNode = this.dehydrateCstNode(a.$cstNode, o));
+		for (let [l, u] of Object.entries(a)) if (!l.startsWith("$")) if (Array.isArray(u)) {
+			let a = [];
+			c[l] = a;
+			for (let c of u) isAstNode(c) ? a.push(this.dehydrateAstNode(c, o)) : isReference(c) ? a.push(this.dehydrateReference(c, o)) : a.push(c);
+		} else isAstNode(u) ? c[l] = this.dehydrateAstNode(u, o) : isReference(u) ? c[l] = this.dehydrateReference(u, o) : u !== void 0 && (c[l] = u);
+		return c;
+	}
+	dehydrateReference(e, a) {
+		let o = {};
+		return o.$refText = e.$refText, e.$refNode && (o.$refNode = a.cstNodes.get(e.$refNode)), o;
+	}
+	dehydrateCstNode(e, s) {
+		let l = s.cstNodes.get(e);
+		return isRootCstNode(e) ? l.fullText = e.fullText : l.grammarSource = this.getGrammarElementId(e.grammarSource), l.hidden = e.hidden, l.astNode = s.astNodes.get(e.astNode), isCompositeCstNode(e) ? l.content = e.content.map((e) => this.dehydrateCstNode(e, s)) : isLeafCstNode(e) && (l.tokenType = e.tokenType.name, l.offset = e.offset, l.length = e.length, l.startLine = e.range.start.line, l.startColumn = e.range.start.character, l.endLine = e.range.end.line, l.endColumn = e.range.end.character), l;
+	}
+	hydrate(e) {
+		let a = e.value, o = this.createHydrationContext(a);
+		return "$cstNode" in a && this.hydrateCstNode(a.$cstNode, o), {
+			lexerErrors: e.lexerErrors,
+			lexerReport: e.lexerReport,
+			parserErrors: e.parserErrors,
+			value: this.hydrateAstNode(a, o)
+		};
+	}
+	createHydrationContext(e) {
+		let a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
+		for (let o of streamAst(e)) a.set(o, {});
+		let s;
+		if (e.$cstNode) for (let a of streamCst(e.$cstNode)) {
+			let e;
+			"fullText" in a ? (e = new RootCstNodeImpl(a.fullText), s = e) : "content" in a ? e = new CompositeCstNodeImpl() : "tokenType" in a && (e = this.hydrateCstLeafNode(a)), e && (o.set(a, e), e.root = s);
+		}
+		return {
+			astNodes: a,
+			cstNodes: o
+		};
+	}
+	hydrateAstNode(a, o) {
+		let c = o.astNodes.get(a);
+		c.$type = a.$type, c.$containerIndex = a.$containerIndex, c.$containerProperty = a.$containerProperty, a.$cstNode && (c.$cstNode = o.cstNodes.get(a.$cstNode));
+		for (let [l, u] of Object.entries(a)) if (!l.startsWith("$")) if (Array.isArray(u)) {
+			let a = [];
+			c[l] = a;
+			for (let d of u) isAstNode(d) ? a.push(this.setParent(this.hydrateAstNode(d, o), c)) : isReference(d) ? a.push(this.hydrateReference(d, c, l, o)) : a.push(d);
+		} else isAstNode(u) ? c[l] = this.setParent(this.hydrateAstNode(u, o), c) : isReference(u) ? c[l] = this.hydrateReference(u, c, l, o) : u !== void 0 && (c[l] = u);
+		return c;
+	}
+	setParent(e, a) {
+		return e.$container = a, e;
+	}
+	hydrateReference(e, a, o, s) {
+		return this.linker.buildReference(a, o, s.cstNodes.get(e.$refNode), e.$refText);
+	}
+	hydrateCstNode(e, o, s = 0) {
+		let c = o.cstNodes.get(e);
+		if (typeof e.grammarSource == "number" && (c.grammarSource = this.getGrammarElement(e.grammarSource)), c.astNode = o.astNodes.get(e.astNode), isCompositeCstNode(c)) for (let a of e.content) {
+			let e = this.hydrateCstNode(a, o, s++);
+			c.content.push(e);
+		}
+		return c;
+	}
+	hydrateCstLeafNode(e) {
+		let a = this.getTokenType(e.tokenType), o = e.offset, s = e.length, c = e.startLine, l = e.startColumn, u = e.endLine, d = e.endColumn, f = e.hidden;
+		return new LeafCstNodeImpl(o, s, {
+			start: {
+				line: c,
+				character: l
+			},
+			end: {
+				line: u,
+				character: d
+			}
+		}, a, f);
+	}
+	getTokenType(e) {
+		return this.lexer.definition[e];
+	}
+	getGrammarElementId(e) {
+		if (e) return this.grammarElementIdMap.size === 0 && this.createGrammarElementIdMap(), this.grammarElementIdMap.get(e);
+	}
+	getGrammarElement(e) {
+		return this.grammarElementIdMap.size === 0 && this.createGrammarElementIdMap(), this.grammarElementIdMap.getKey(e);
+	}
+	createGrammarElementIdMap() {
+		let e = 0;
+		for (let a of streamAst(this.grammar)) isAbstractElement(a) && this.grammarElementIdMap.set(a, e++);
+	}
+};
+export { DefaultHydrator };

package/dist/node_modules/langium/lib/serializer/json-serializer.js

@@ -0,0 +1,145 @@
+import { isAstNode, isMultiReference, isReference } from "../syntax-tree.js";
+import { getDocument } from "../utils/ast-utils.js";
+import { findNodesForProperty } from "../utils/grammar-utils.js";
+import { URI } from "../../../vscode-uri/lib/esm/index.js";
+function isAstNodeWithComment(e) {
+	return typeof e.$comment == "string";
+}
+function isIntermediateReference(e) {
+	return typeof e == "object" && !!e && ("$ref" in e || "$error" in e);
+}
+var DefaultJsonSerializer = class {
+	constructor(e) {
+		this.ignoreProperties = new Set([
+			"$container",
+			"$containerProperty",
+			"$containerIndex",
+			"$document",
+			"$cstNode"
+		]), this.langiumDocuments = e.shared.workspace.LangiumDocuments, this.astNodeLocator = e.workspace.AstNodeLocator, this.nameProvider = e.references.NameProvider, this.commentProvider = e.documentation.CommentProvider;
+	}
+	serialize(e, t) {
+		let n = t ?? {}, i = t?.replacer, a = (e, t) => this.replacer(e, t, n), o = i ? (e, t) => i(e, t, a) : a;
+		try {
+			return this.currentDocument = getDocument(e), JSON.stringify(e, o, t?.space);
+		} finally {
+			this.currentDocument = void 0;
+		}
+	}
+	deserialize(e, t) {
+		let n = t ?? {}, r = JSON.parse(e);
+		return this.linkNode(r, r, n), r;
+	}
+	replacer(i, a, { refText: o, sourceText: s, textRegions: c, comments: l, uriConverter: u }) {
+		if (!this.ignoreProperties.has(i)) if (isReference(a)) {
+			let e = a.ref, t = o ? a.$refText : void 0;
+			if (e) {
+				let n = getDocument(e), i = "";
+				this.currentDocument && this.currentDocument !== n && (i = u ? u(n.uri, e) : n.uri.toString());
+				let a = this.astNodeLocator.getAstNodePath(e);
+				return {
+					$ref: `${i}#${a}`,
+					$refText: t
+				};
+			} else return {
+				$error: a.error?.message ?? "Could not resolve reference",
+				$refText: t
+			};
+		} else if (isMultiReference(a)) {
+			let e = o ? a.$refText : void 0, t = [];
+			for (let e of a.items) {
+				let n = e.ref, i = getDocument(e.ref), a = "";
+				this.currentDocument && this.currentDocument !== i && (a = u ? u(i.uri, n) : i.uri.toString());
+				let o = this.astNodeLocator.getAstNodePath(n);
+				t.push(`${a}#${o}`);
+			}
+			return {
+				$refs: t,
+				$refText: e
+			};
+		} else if (isAstNode(a)) {
+			let e;
+			if (c && (e = this.addAstNodeRegionWithAssignmentsTo({ ...a }), (!i || a.$document) && e?.$textRegion && (e.$textRegion.documentURI = this.currentDocument?.uri.toString())), s && !i && (e ??= { ...a }, e.$sourceText = a.$cstNode?.text), l) {
+				e ??= { ...a };
+				let t = this.commentProvider.getComment(a);
+				t && (e.$comment = t.replace(/\r/g, ""));
+			}
+			return e ?? a;
+		} else return a;
+	}
+	addAstNodeRegionWithAssignmentsTo(e) {
+		let t = (e) => ({
+			offset: e.offset,
+			end: e.end,
+			length: e.length,
+			range: e.range
+		});
+		if (e.$cstNode) {
+			let n = e.$textRegion = t(e.$cstNode), r = n.assignments = {};
+			return Object.keys(e).filter((e) => !e.startsWith("$")).forEach((n) => {
+				let a = findNodesForProperty(e.$cstNode, n).map(t);
+				a.length !== 0 && (r[n] = a);
+			}), e;
+		}
+	}
+	linkNode(t, n, r, i, a, o) {
+		for (let [i, a] of Object.entries(t)) if (Array.isArray(a)) for (let o = 0; o < a.length; o++) {
+			let c = a[o];
+			isIntermediateReference(c) ? a[o] = this.reviveReference(t, i, n, c, r) : isAstNode(c) && this.linkNode(c, n, r, t, i, o);
+		}
+		else isIntermediateReference(a) ? t[i] = this.reviveReference(t, i, n, a, r) : isAstNode(a) && this.linkNode(a, n, r, t, i);
+		let c = t;
+		c.$container = i, c.$containerProperty = a, c.$containerIndex = o;
+	}
+	reviveReference(t, n, r, i, a) {
+		let o = i.$refText, s = i.$error, c;
+		if (i.$ref) {
+			let t = this.getRefNode(r, i.$ref, a.uriConverter);
+			if (isAstNode(t)) return o ||= this.nameProvider.getName(t), {
+				$refText: o ?? "",
+				ref: t
+			};
+			s = t;
+		} else if (i.$refs) {
+			let t = [];
+			for (let n of i.$refs) {
+				let i = this.getRefNode(r, n, a.uriConverter);
+				isAstNode(i) && t.push({ ref: i });
+			}
+			if (t.length === 0) c = {
+				$refText: o ?? "",
+				items: t
+			}, s ??= "Could not resolve multi-reference";
+			else return {
+				$refText: o ?? "",
+				items: t
+			};
+		}
+		if (s) return c ??= {
+			$refText: o ?? "",
+			ref: void 0
+		}, c.error = {
+			info: {
+				container: t,
+				property: n,
+				reference: c
+			},
+			message: s
+		}, c;
+	}
+	getRefNode(e, t, n) {
+		try {
+			let r = t.indexOf("#");
+			if (r === 0) return this.astNodeLocator.getAstNode(e, t.substring(1)) || "Could not resolve path: " + t;
+			if (r < 0) {
+				let e = n ? n(t) : URI.parse(t), r = this.langiumDocuments.getDocument(e);
+				return r ? r.parseResult.value : "Could not find document for URI: " + t;
+			}
+			let i = n ? n(t.substring(0, r)) : URI.parse(t.substring(0, r)), o = this.langiumDocuments.getDocument(i);
+			return o ? r === t.length - 1 ? o.parseResult.value : this.astNodeLocator.getAstNode(o.parseResult.value, t.substring(r + 1)) || "Could not resolve URI: " + t : "Could not find document for URI: " + t;
+		} catch (e) {
+			return String(e);
+		}
+	}
+};
+export { DefaultJsonSerializer, isAstNodeWithComment };

package/dist/node_modules/langium/lib/service-registry.js

@@ -0,0 +1,37 @@
+import { UriUtils } from "./utils/uri-utils.js";
+var DefaultServiceRegistry = class {
+	get map() {
+		return this.fileExtensionMap;
+	}
+	constructor(e) {
+		this.languageIdMap = /* @__PURE__ */ new Map(), this.fileExtensionMap = /* @__PURE__ */ new Map(), this.fileNameMap = /* @__PURE__ */ new Map(), this.textDocuments = e?.workspace.TextDocuments;
+	}
+	register(e) {
+		let t = e.LanguageMetaData;
+		for (let n of t.fileExtensions) this.fileExtensionMap.has(n) && console.warn(`The file extension ${n} is used by multiple languages. It is now assigned to '${t.languageId}'.`), this.fileExtensionMap.set(n, e);
+		if (t.fileNames) for (let n of t.fileNames) this.fileNameMap.has(n) && console.warn(`The file name ${n} is used by multiple languages. It is now assigned to '${t.languageId}'.`), this.fileNameMap.set(n, e);
+		this.languageIdMap.set(t.languageId, e);
+	}
+	getServices(t) {
+		if (this.languageIdMap.size === 0) throw Error("The service registry is empty. Use `register` to register the services of a language.");
+		let n = this.textDocuments?.get(t)?.languageId;
+		if (n !== void 0) {
+			let e = this.languageIdMap.get(n);
+			if (e) return e;
+		}
+		let r = UriUtils.extname(t), i = UriUtils.basename(t), a = this.fileNameMap.get(i) ?? this.fileExtensionMap.get(r);
+		if (!a) throw n ? Error(`The service registry contains no services for the extension '${r}' for language '${n}'.`) : Error(`The service registry contains no services for the extension '${r}'.`);
+		return a;
+	}
+	hasServices(e) {
+		try {
+			return this.getServices(e), !0;
+		} catch {
+			return !1;
+		}
+	}
+	get all() {
+		return Array.from(this.languageIdMap.values());
+	}
+};
+export { DefaultServiceRegistry };

package/dist/node_modules/langium/lib/syntax-tree.js

@@ -0,0 +1,70 @@
+function isAstNode(e) {
+	return typeof e == "object" && !!e && typeof e.$type == "string";
+}
+function isReference(e) {
+	return typeof e == "object" && !!e && typeof e.$refText == "string" && "ref" in e;
+}
+function isMultiReference(e) {
+	return typeof e == "object" && !!e && typeof e.$refText == "string" && "items" in e;
+}
+function isAstNodeDescription(e) {
+	return typeof e == "object" && !!e && typeof e.name == "string" && typeof e.type == "string" && typeof e.path == "string";
+}
+function isLinkingError(e) {
+	return typeof e == "object" && !!e && typeof e.info == "object" && typeof e.message == "string";
+}
+var AbstractAstReflection = class {
+	constructor() {
+		this.subtypes = {}, this.allSubtypes = {};
+	}
+	getAllTypes() {
+		return Object.keys(this.types);
+	}
+	getReferenceType(e) {
+		let a = this.types[e.container.$type];
+		if (!a) throw Error(`Type ${e.container.$type || "undefined"} not found.`);
+		let o = a.properties[e.property]?.referenceType;
+		if (!o) throw Error(`Property ${e.property || "undefined"} of type ${e.container.$type} is not a reference.`);
+		return o;
+	}
+	getTypeMetaData(e) {
+		return this.types[e] || {
+			name: e,
+			properties: {},
+			superTypes: []
+		};
+	}
+	isInstance(a, o) {
+		return isAstNode(a) && this.isSubtype(a.$type, o);
+	}
+	isSubtype(e, a) {
+		if (e === a) return !0;
+		let o = this.subtypes[e];
+		o ||= this.subtypes[e] = {};
+		let s = o[a];
+		if (s !== void 0) return s;
+		{
+			let s = this.types[e], c = s ? s.superTypes.some((e) => this.isSubtype(e, a)) : !1;
+			return o[a] = c, c;
+		}
+	}
+	getAllSubTypes(e) {
+		let a = this.allSubtypes[e];
+		if (a) return a;
+		{
+			let a = this.getAllTypes(), o = [];
+			for (let s of a) this.isSubtype(s, e) && o.push(s);
+			return this.allSubtypes[e] = o, o;
+		}
+	}
+};
+function isCompositeCstNode(e) {
+	return typeof e == "object" && !!e && Array.isArray(e.content);
+}
+function isLeafCstNode(e) {
+	return typeof e == "object" && !!e && typeof e.tokenType == "object";
+}
+function isRootCstNode(e) {
+	return isCompositeCstNode(e) && typeof e.fullText == "string";
+}
+export { AbstractAstReflection, isAstNode, isAstNodeDescription, isCompositeCstNode, isLeafCstNode, isLinkingError, isMultiReference, isReference, isRootCstNode };

package/dist/node_modules/langium/lib/utils/ast-utils.js

@@ -0,0 +1,157 @@
+import { __export } from "../../../../_virtual/rolldown_runtime.js";
+import { isAstNode, isMultiReference, isReference } from "../syntax-tree.js";
+import { DONE_RESULT, StreamImpl, TreeStreamImpl } from "./stream.js";
+import { inRange } from "./cst-utils.js";
+var ast_utils_exports = /* @__PURE__ */ __export({
+	assignMandatoryProperties: () => assignMandatoryProperties,
+	copyAstNode: () => copyAstNode,
+	findRootNode: () => findRootNode,
+	getContainerOfType: () => getContainerOfType,
+	getDocument: () => getDocument,
+	getReferenceNodes: () => getReferenceNodes,
+	hasContainerOfType: () => hasContainerOfType,
+	linkContentToContainer: () => linkContentToContainer,
+	streamAllContents: () => streamAllContents,
+	streamAst: () => streamAst,
+	streamContents: () => streamContents,
+	streamReferences: () => streamReferences
+}, 1);
+function linkContentToContainer(e, g = {}) {
+	for (let [_, v] of Object.entries(e)) _.startsWith("$") || (Array.isArray(v) ? v.forEach((v, y) => {
+		isAstNode(v) && (v.$container = e, v.$containerProperty = _, v.$containerIndex = y, g.deep && linkContentToContainer(v, g));
+	}) : isAstNode(v) && (v.$container = e, v.$containerProperty = _, g.deep && linkContentToContainer(v, g)));
+}
+function getContainerOfType(e, h) {
+	let g = e;
+	for (; g;) {
+		if (h(g)) return g;
+		g = g.$container;
+	}
+}
+function hasContainerOfType(e, h) {
+	let g = e;
+	for (; g;) {
+		if (h(g)) return !0;
+		g = g.$container;
+	}
+	return !1;
+}
+function getDocument(e) {
+	let h = findRootNode(e).$document;
+	if (!h) throw Error("AST node has no document.");
+	return h;
+}
+function findRootNode(e) {
+	for (; e.$container;) e = e.$container;
+	return e;
+}
+function getReferenceNodes(e) {
+	return isReference(e) ? e.ref ? [e.ref] : [] : isMultiReference(e) ? e.items.map((e) => e.ref) : [];
+}
+function streamContents(e, g) {
+	if (!e) throw Error("Node must be an AstNode.");
+	let _ = g?.range;
+	return new StreamImpl(() => ({
+		keys: Object.keys(e),
+		keyIndex: 0,
+		arrayIndex: 0
+	}), (g) => {
+		for (; g.keyIndex < g.keys.length;) {
+			let v = g.keys[g.keyIndex];
+			if (!v.startsWith("$")) {
+				let y = e[v];
+				if (isAstNode(y)) {
+					if (g.keyIndex++, isAstNodeInRange(y, _)) return {
+						done: !1,
+						value: y
+					};
+				} else if (Array.isArray(y)) {
+					for (; g.arrayIndex < y.length;) {
+						let e = y[g.arrayIndex++];
+						if (isAstNode(e) && isAstNodeInRange(e, _)) return {
+							done: !1,
+							value: e
+						};
+					}
+					g.arrayIndex = 0;
+				}
+			}
+			g.keyIndex++;
+		}
+		return DONE_RESULT;
+	});
+}
+function streamAllContents(e, h) {
+	if (!e) throw Error("Root node must be an AstNode.");
+	return new TreeStreamImpl(e, (e) => streamContents(e, h));
+}
+function streamAst(e, h) {
+	if (e) {
+		if (h?.range && !isAstNodeInRange(e, h.range)) return new TreeStreamImpl(e, () => []);
+	} else throw Error("Root node must be an AstNode.");
+	return new TreeStreamImpl(e, (e) => streamContents(e, h), { includeRoot: !0 });
+}
+function isAstNodeInRange(e, h) {
+	if (!h) return !0;
+	let g = e.$cstNode?.range;
+	return g ? inRange(g, h) : !1;
+}
+function streamReferences(e) {
+	return new StreamImpl(() => ({
+		keys: Object.keys(e),
+		keyIndex: 0,
+		arrayIndex: 0
+	}), (h) => {
+		for (; h.keyIndex < h.keys.length;) {
+			let v = h.keys[h.keyIndex];
+			if (!v.startsWith("$")) {
+				let y = e[v];
+				if (isReference(y) || isMultiReference(y)) return h.keyIndex++, {
+					done: !1,
+					value: {
+						reference: y,
+						container: e,
+						property: v
+					}
+				};
+				if (Array.isArray(y)) {
+					for (; h.arrayIndex < y.length;) {
+						let b = h.arrayIndex++, x = y[b];
+						if (isReference(x) || isMultiReference(y)) return {
+							done: !1,
+							value: {
+								reference: x,
+								container: e,
+								property: v,
+								index: b
+							}
+						};
+					}
+					h.arrayIndex = 0;
+				}
+			}
+			h.keyIndex++;
+		}
+		return DONE_RESULT;
+	});
+}
+function assignMandatoryProperties(e, h) {
+	let g = e.getTypeMetaData(h.$type), _ = h;
+	for (let e of Object.values(g.properties)) e.defaultValue !== void 0 && _[e.name] === void 0 && (_[e.name] = copyDefaultValue(e.defaultValue));
+}
+function copyDefaultValue(e) {
+	return Array.isArray(e) ? [...e.map(copyDefaultValue)] : e;
+}
+function copyAstNode(e, g, v) {
+	let y = { $type: e.$type };
+	v && (v.set(e, y), v.set(y, e));
+	for (let [b, x] of Object.entries(e)) if (!b.startsWith("$")) if (isAstNode(x)) y[b] = copyAstNode(x, g, v);
+	else if (isReference(x)) y[b] = g(y, b, x.$refNode, x.$refText, x);
+	else if (Array.isArray(x)) {
+		let e = [];
+		for (let S of x) isAstNode(S) ? e.push(copyAstNode(S, g, v)) : isReference(S) ? e.push(g(y, b, S.$refNode, S.$refText, S)) : e.push(S);
+		y[b] = e;
+	} else y[b] = x;
+	return linkContentToContainer(y, { deep: !0 }), y;
+}
+export { assignMandatoryProperties, ast_utils_exports, findRootNode, getContainerOfType, getDocument, getReferenceNodes, linkContentToContainer, streamAllContents, streamAst, streamContents, streamReferences };