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

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

@@ -0,0 +1,87 @@
+import { stream } from "../utils/stream.js";
+import { assertUnreachable } from "../utils/errors.js";
+import { isOperationCancelled } from "../utils/promise-utils.js";
+import { MultiMap } from "../utils/collections.js";
+import "../index.js";
+function diagnosticData(e) {
+	return { code: e };
+}
+var ValidationCategory;
+(function(e) {
+	e.defaults = [
+		"fast",
+		"slow",
+		"built-in"
+	], e.all = e.defaults;
+})(ValidationCategory ||= {});
+var ValidationRegistry = class {
+	constructor(e) {
+		this.entries = new MultiMap(), this.knownCategories = new Set(ValidationCategory.defaults), this.entriesBefore = [], this.entriesAfter = [], this.reflection = e.shared.AstReflection;
+	}
+	register(e, n = this, r = "fast") {
+		if (r === "built-in") throw Error("The 'built-in' category is reserved for lexer, parser, and linker errors.");
+		this.knownCategories.add(r);
+		for (let [i, a] of Object.entries(e)) {
+			let e = a;
+			if (Array.isArray(e)) for (let t of e) {
+				let e = {
+					check: this.wrapValidationException(t, n),
+					category: r
+				};
+				this.addEntry(i, e);
+			}
+			else if (typeof e == "function") {
+				let t = {
+					check: this.wrapValidationException(e, n),
+					category: r
+				};
+				this.addEntry(i, t);
+			} else assertUnreachable(e);
+		}
+	}
+	wrapValidationException(e, t) {
+		return async (n, r, i) => {
+			await this.handleException(() => e.call(t, n, r, i), "An error occurred during validation", r, n);
+		};
+	}
+	async handleException(e, t, r, i) {
+		try {
+			await e();
+		} catch (e) {
+			if (isOperationCancelled(e)) throw e;
+			console.error(`${t}:`, e), e instanceof Error && e.stack && console.error(e.stack), r("error", `${t}: ${e instanceof Error ? e.message : String(e)}`, { node: i });
+		}
+	}
+	addEntry(e, t) {
+		if (e === "AstNode") {
+			this.entries.add("AstNode", t);
+			return;
+		}
+		for (let n of this.reflection.getAllSubTypes(e)) this.entries.add(n, t);
+	}
+	getChecks(t, n) {
+		let r = stream(this.entries.get(t)).concat(this.entries.get("AstNode"));
+		return n && (r = r.filter((e) => n.includes(e.category))), r.map((e) => e.check);
+	}
+	registerBeforeDocument(e, t = this) {
+		this.entriesBefore.push(this.wrapPreparationException(e, "An error occurred during set-up of the validation", t));
+	}
+	registerAfterDocument(e, t = this) {
+		this.entriesAfter.push(this.wrapPreparationException(e, "An error occurred during tear-down of the validation", t));
+	}
+	wrapPreparationException(e, t, n) {
+		return async (r, i, a, o) => {
+			await this.handleException(() => e.call(n, r, i, a, o), t, i, r);
+		};
+	}
+	get checksBefore() {
+		return this.entriesBefore;
+	}
+	get checksAfter() {
+		return this.entriesAfter;
+	}
+	getAllValidationCategories(e) {
+		return this.knownCategories;
+	}
+};
+export { ValidationCategory, ValidationRegistry, diagnosticData };

package/dist/node_modules/langium/lib/workspace/ast-descriptions.js

@@ -0,0 +1,57 @@
+import { isMultiReference, isReference } from "../syntax-tree.js";
+import { getDocument, streamAst, streamReferences } from "../utils/ast-utils.js";
+import { toDocumentSegment } from "../utils/cst-utils.js";
+import { cancellation_exports } from "../utils/cancellation.js";
+import { interruptAndCheck } from "../utils/promise-utils.js";
+import { UriUtils } from "../utils/uri-utils.js";
+var DefaultAstNodeDescriptionProvider = class {
+	constructor(e) {
+		this.astNodeLocator = e.workspace.AstNodeLocator, this.nameProvider = e.references.NameProvider;
+	}
+	createDescription(e, t, r) {
+		let i = r ?? getDocument(e);
+		t ??= this.nameProvider.getName(e);
+		let o = this.astNodeLocator.getAstNodePath(e);
+		if (!t) throw Error(`Node at path ${o} has no name.`);
+		let s, c = () => s ??= toDocumentSegment(this.nameProvider.getNameNode(e) ?? e.$cstNode);
+		return {
+			node: e,
+			name: t,
+			get nameSegment() {
+				return c();
+			},
+			selectionSegment: toDocumentSegment(e.$cstNode),
+			type: e.$type,
+			documentUri: i.uri,
+			path: o
+		};
+	}
+}, DefaultReferenceDescriptionProvider = class {
+	constructor(e) {
+		this.nodeLocator = e.workspace.AstNodeLocator;
+	}
+	async createDescriptions(e, t = cancellation_exports.CancellationToken.None) {
+		let n = [], a = e.parseResult.value;
+		for (let e of streamAst(a)) await interruptAndCheck(t), streamReferences(e).forEach((e) => {
+			e.reference.error || n.push(...this.createInfoDescriptions(e));
+		});
+		return n;
+	}
+	createInfoDescriptions(r) {
+		let i = r.reference;
+		if (i.error || !i.$refNode) return [];
+		let o = [];
+		isReference(i) && i.$nodeDescription ? o = [i.$nodeDescription] : isMultiReference(i) && (o = i.items.map((e) => e.$nodeDescription).filter((e) => e !== void 0));
+		let s = getDocument(r.container).uri, l = this.nodeLocator.getAstNodePath(r.container), u = [], d = toDocumentSegment(i.$refNode);
+		for (let e of o) u.push({
+			sourceUri: s,
+			sourcePath: l,
+			targetUri: e.documentUri,
+			targetPath: e.path,
+			segment: d,
+			local: UriUtils.equals(e.documentUri, s)
+		});
+		return u;
+	}
+};
+export { DefaultAstNodeDescriptionProvider, DefaultReferenceDescriptionProvider };

package/dist/node_modules/langium/lib/workspace/ast-node-locator.js

@@ -0,0 +1,28 @@
+var DefaultAstNodeLocator = class {
+	constructor() {
+		this.segmentSeparator = "/", this.indexSeparator = "@";
+	}
+	getAstNodePath(e) {
+		if (e.$container) {
+			let t = this.getAstNodePath(e.$container), n = this.getPathSegment(e);
+			return t + this.segmentSeparator + n;
+		}
+		return "";
+	}
+	getPathSegment({ $containerProperty: e, $containerIndex: t }) {
+		if (!e) throw Error("Missing '$containerProperty' in AST node.");
+		return t === void 0 ? e : e + this.indexSeparator + t;
+	}
+	getAstNode(e, t) {
+		return t.split(this.segmentSeparator).reduce((e, t) => {
+			if (!e || t.length === 0) return e;
+			let n = t.indexOf(this.indexSeparator);
+			if (n > 0) {
+				let r = t.substring(0, n), i = parseInt(t.substring(n + 1));
+				return e[r]?.[i];
+			}
+			return e[t];
+		}, e);
+	}
+};
+export { DefaultAstNodeLocator };

package/dist/node_modules/langium/lib/workspace/configuration.js

@@ -0,0 +1,51 @@
+import { Deferred } from "../utils/promise-utils.js";
+import { event_exports } from "../utils/event.js";
+var DefaultConfigurationProvider = class {
+	constructor(n) {
+		this._ready = new Deferred(), this.onConfigurationSectionUpdateEmitter = new event_exports.Emitter(), this.settings = {}, this.workspaceConfig = !1, this.serviceRegistry = n.ServiceRegistry;
+	}
+	get ready() {
+		return this._ready.promise;
+	}
+	initialize(e) {
+		this.workspaceConfig = e.capabilities.workspace?.configuration ?? !1;
+	}
+	async initialized(e) {
+		if (this.workspaceConfig) {
+			if (e.register) {
+				let t = this.serviceRegistry.all;
+				e.register({ section: t.map((e) => this.toSectionName(e.LanguageMetaData.languageId)) });
+			}
+			if (e.fetchConfiguration) {
+				let t = this.serviceRegistry.all.map((e) => ({ section: this.toSectionName(e.LanguageMetaData.languageId) })), n = await e.fetchConfiguration(t);
+				t.forEach((e, t) => {
+					this.updateSectionConfiguration(e.section, n[t]);
+				});
+			}
+		}
+		this._ready.resolve();
+	}
+	updateConfiguration(e) {
+		typeof e.settings != "object" || e.settings === null || Object.entries(e.settings).forEach(([e, t]) => {
+			this.updateSectionConfiguration(e, t), this.onConfigurationSectionUpdateEmitter.fire({
+				section: e,
+				configuration: t
+			});
+		});
+	}
+	updateSectionConfiguration(e, t) {
+		this.settings[e] = t;
+	}
+	async getConfiguration(e, t) {
+		await this.ready;
+		let n = this.toSectionName(e);
+		if (this.settings[n]) return this.settings[n][t];
+	}
+	toSectionName(e) {
+		return `${e}`;
+	}
+	get onConfigurationSectionUpdate() {
+		return this.onConfigurationSectionUpdateEmitter.event;
+	}
+};
+export { DefaultConfigurationProvider };

package/dist/node_modules/langium/lib/workspace/document-builder.js

@@ -0,0 +1,201 @@
+import { stream } from "../utils/stream.js";
+import { cancellation_exports } from "../utils/cancellation.js";
+import { OperationCancelled, interruptAndCheck, isOperationCancelled } from "../utils/promise-utils.js";
+import { UriUtils } from "../utils/uri-utils.js";
+import { DocumentState } from "./documents.js";
+import { MultiMap } from "../utils/collections.js";
+import { require_main } from "../../../vscode-languageserver-protocol/lib/browser/main.js";
+import { Disposable } from "../utils/disposable.js";
+var import_main = require_main(), DefaultDocumentBuilder = class {
+	constructor(e) {
+		this.updateBuildOptions = { validation: { categories: ["built-in", "fast"] } }, this.updateListeners = [], this.buildPhaseListeners = new MultiMap(), this.documentPhaseListeners = new MultiMap(), this.buildState = /* @__PURE__ */ new Map(), this.documentBuildWaiters = /* @__PURE__ */ new Map(), this.currentState = DocumentState.Changed, this.langiumDocuments = e.workspace.LangiumDocuments, this.langiumDocumentFactory = e.workspace.LangiumDocumentFactory, this.textDocuments = e.workspace.TextDocuments, this.indexManager = e.workspace.IndexManager, this.fileSystemProvider = e.workspace.FileSystemProvider, this.workspaceManager = () => e.workspace.WorkspaceManager, this.serviceRegistry = e.ServiceRegistry;
+	}
+	async build(e, r = {}, i = cancellation_exports.CancellationToken.None) {
+		for (let n of e) {
+			let e = n.uri.toString();
+			if (n.state === DocumentState.Validated) {
+				if (typeof r.validation == "boolean" && r.validation) this.resetToState(n, DocumentState.IndexedReferences);
+				else if (typeof r.validation == "object") {
+					let i = this.findMissingValidationCategories(n, r);
+					i.length > 0 && (this.buildState.set(e, {
+						completed: !1,
+						options: { validation: { categories: i } },
+						result: this.buildState.get(e)?.result
+					}), n.state = DocumentState.IndexedReferences);
+				}
+			} else this.buildState.delete(e);
+		}
+		this.currentState = DocumentState.Changed, await this.emitUpdate(e.map((e) => e.uri), []), await this.buildDocuments(e, r, i);
+	}
+	async update(r, a, o = cancellation_exports.CancellationToken.None) {
+		this.currentState = DocumentState.Changed;
+		let c = [];
+		for (let e of a) {
+			let n = this.langiumDocuments.deleteDocuments(e);
+			for (let e of n) c.push(e.uri), this.cleanUpDeleted(e);
+		}
+		let l = (await Promise.all(r.map((e) => this.findChangedUris(e)))).flat();
+		for (let e of l) {
+			let n = this.langiumDocuments.getDocument(e);
+			n === void 0 && (n = this.langiumDocumentFactory.fromModel({ $type: "INVALID" }, e), n.state = DocumentState.Changed, this.langiumDocuments.addDocument(n)), this.resetToState(n, DocumentState.Changed);
+		}
+		let u = stream(l).concat(c).map((e) => e.toString()).toSet();
+		this.langiumDocuments.all.filter((e) => !u.has(e.uri.toString()) && this.shouldRelink(e, u)).forEach((e) => this.resetToState(e, DocumentState.ComputedScopes)), await this.emitUpdate(l, c), await interruptAndCheck(o);
+		let d = this.sortDocuments(this.langiumDocuments.all.filter((e) => e.state < DocumentState.Validated || !this.buildState.get(e.uri.toString())?.completed || this.resultsAreIncomplete(e, this.updateBuildOptions)).toArray());
+		await this.buildDocuments(d, this.updateBuildOptions, o);
+	}
+	resultsAreIncomplete(e, n) {
+		return this.findMissingValidationCategories(e, n).length >= 1;
+	}
+	findMissingValidationCategories(n, r) {
+		let i = this.buildState.get(n.uri.toString()), a = this.serviceRegistry.getServices(n.uri).validation.ValidationRegistry.getAllValidationCategories(n), o = i?.result?.validationChecks ? new Set(i?.result?.validationChecks) : i?.completed ? a : /* @__PURE__ */ new Set();
+		return stream(r === void 0 || r.validation === !0 ? a : typeof r.validation == "object" ? r.validation.categories ?? a : []).filter((e) => !o.has(e)).toArray();
+	}
+	async findChangedUris(e) {
+		if (this.langiumDocuments.getDocument(e) ?? this.textDocuments?.get(e)) return [e];
+		try {
+			let n = await this.fileSystemProvider.stat(e);
+			if (n.isDirectory) return await this.workspaceManager().searchFolder(e);
+			if (this.workspaceManager().shouldIncludeEntry(n)) return [e];
+		} catch {}
+		return [];
+	}
+	async emitUpdate(e, n) {
+		await Promise.all(this.updateListeners.map((r) => r(e, n)));
+	}
+	sortDocuments(e) {
+		let n = 0, r = e.length - 1;
+		for (; n < r;) {
+			for (; n < e.length && this.hasTextDocument(e[n]);) n++;
+			for (; r >= 0 && !this.hasTextDocument(e[r]);) r--;
+			n < r && ([e[n], e[r]] = [e[r], e[n]]);
+		}
+		return e;
+	}
+	hasTextDocument(e) {
+		return !!this.textDocuments?.get(e.uri);
+	}
+	shouldRelink(e, n) {
+		return e.references.some((e) => e.error !== void 0) ? !0 : this.indexManager.isAffected(e, n);
+	}
+	onUpdate(e) {
+		return this.updateListeners.push(e), Disposable.create(() => {
+			let n = this.updateListeners.indexOf(e);
+			n >= 0 && this.updateListeners.splice(n, 1);
+		});
+	}
+	resetToState(e, n) {
+		switch (n) {
+			case DocumentState.Changed:
+			case DocumentState.Parsed: this.indexManager.removeContent(e.uri);
+			case DocumentState.IndexedContent: e.localSymbols = void 0;
+			case DocumentState.ComputedScopes: this.serviceRegistry.getServices(e.uri).references.Linker.unlink(e);
+			case DocumentState.Linked: this.indexManager.removeReferences(e.uri);
+			case DocumentState.IndexedReferences: e.diagnostics = void 0, this.buildState.delete(e.uri.toString());
+			case DocumentState.Validated:
+		}
+		e.state > n && (e.state = n);
+	}
+	cleanUpDeleted(e) {
+		this.buildState.delete(e.uri.toString()), this.indexManager.remove(e.uri), e.state = DocumentState.Changed;
+	}
+	async buildDocuments(e, n, r) {
+		this.prepareBuild(e, n), await this.runCancelable(e, DocumentState.Parsed, r, (e) => this.langiumDocumentFactory.update(e, r)), await this.runCancelable(e, DocumentState.IndexedContent, r, (e) => this.indexManager.updateContent(e, r)), await this.runCancelable(e, DocumentState.ComputedScopes, r, async (e) => {
+			e.localSymbols = await this.serviceRegistry.getServices(e.uri).references.ScopeComputation.collectLocalSymbols(e, r);
+		});
+		let i = e.filter((e) => this.shouldLink(e));
+		await this.runCancelable(i, DocumentState.Linked, r, (e) => this.serviceRegistry.getServices(e.uri).references.Linker.link(e, r)), await this.runCancelable(i, DocumentState.IndexedReferences, r, (e) => this.indexManager.updateReferences(e, r));
+		let a = e.filter((e) => this.shouldValidate(e) ? !0 : (this.markAsCompleted(e), !1));
+		await this.runCancelable(a, DocumentState.Validated, r, async (e) => {
+			await this.validate(e, r), this.markAsCompleted(e);
+		});
+	}
+	markAsCompleted(e) {
+		let n = this.buildState.get(e.uri.toString());
+		n && (n.completed = !0);
+	}
+	prepareBuild(e, n) {
+		for (let r of e) {
+			let e = r.uri.toString(), i = this.buildState.get(e);
+			(!i || i.completed) && this.buildState.set(e, {
+				completed: !1,
+				options: n,
+				result: i?.result
+			});
+		}
+	}
+	async runCancelable(e, n, r, a) {
+		for (let o of e) o.state < n && (await interruptAndCheck(r), await a(o), o.state = n, await this.notifyDocumentPhase(o, n, r));
+		let o = e.filter((e) => e.state === n);
+		await this.notifyBuildPhase(o, n, r), this.currentState = n;
+	}
+	onBuildPhase(e, n) {
+		return this.buildPhaseListeners.add(e, n), Disposable.create(() => {
+			this.buildPhaseListeners.delete(e, n);
+		});
+	}
+	onDocumentPhase(e, n) {
+		return this.documentPhaseListeners.add(e, n), Disposable.create(() => {
+			this.documentPhaseListeners.delete(e, n);
+		});
+	}
+	waitUntil(e, r, i) {
+		let a;
+		return r && "path" in r ? a = r : i = r, i ??= cancellation_exports.CancellationToken.None, a ? this.awaitDocumentState(e, a, i) : this.awaitBuilderState(e, i);
+	}
+	awaitDocumentState(e, n, i) {
+		let a = this.langiumDocuments.getDocument(n);
+		if (a) {
+			if (a.state >= e) return Promise.resolve(n);
+			if (i.isCancellationRequested) return Promise.reject(OperationCancelled);
+			if (this.currentState >= e && e > a.state) return Promise.reject(new import_main.ResponseError(import_main.LSPErrorCodes.RequestFailed, `Document state of ${n.toString()} is ${DocumentState[a.state]}, requiring ${DocumentState[e]}, but workspace state is already ${DocumentState[this.currentState]}. Returning undefined.`));
+		} else return Promise.reject(new import_main.ResponseError(import_main.LSPErrorCodes.ServerCancelled, `No document found for URI: ${n.toString()}`));
+		return new Promise((a, s) => {
+			let c = this.onDocumentPhase(e, (e) => {
+				UriUtils.equals(e.uri, n) && (c.dispose(), l.dispose(), a(e.uri));
+			}), l = i.onCancellationRequested(() => {
+				c.dispose(), l.dispose(), s(OperationCancelled);
+			});
+		});
+	}
+	awaitBuilderState(e, n) {
+		return this.currentState >= e ? Promise.resolve() : n.isCancellationRequested ? Promise.reject(OperationCancelled) : new Promise((i, a) => {
+			let o = this.onBuildPhase(e, () => {
+				o.dispose(), s.dispose(), i();
+			}), s = n.onCancellationRequested(() => {
+				o.dispose(), s.dispose(), a(OperationCancelled);
+			});
+		});
+	}
+	async notifyDocumentPhase(e, n, r) {
+		let o = this.documentPhaseListeners.get(n).slice();
+		for (let n of o) try {
+			await interruptAndCheck(r), await n(e, r);
+		} catch (e) {
+			if (!isOperationCancelled(e)) throw e;
+		}
+	}
+	async notifyBuildPhase(e, n, r) {
+		if (e.length === 0) return;
+		let a = this.buildPhaseListeners.get(n).slice();
+		for (let n of a) await interruptAndCheck(r), await n(e, r);
+	}
+	shouldLink(e) {
+		return this.getBuildOptions(e).eagerLinking ?? !0;
+	}
+	shouldValidate(e) {
+		return !!this.getBuildOptions(e).validation;
+	}
+	async validate(n, r) {
+		let i = this.serviceRegistry.getServices(n.uri).validation.DocumentValidator, a = this.getBuildOptions(n), o = typeof a.validation == "object" ? { ...a.validation } : {};
+		o.categories = this.findMissingValidationCategories(n, a);
+		let s = await i.validateDocument(n, o, r);
+		n.diagnostics ? n.diagnostics.push(...s) : n.diagnostics = s;
+		let c = this.buildState.get(n.uri.toString());
+		c && (c.result ??= {}, c.result.validationChecks ? c.result.validationChecks = stream(c.result.validationChecks).concat(o.categories).distinct().toArray() : c.result.validationChecks = [...o.categories]);
+	}
+	getBuildOptions(e) {
+		return this.buildState.get(e.uri.toString())?.options ?? {};
+	}
+};
+export { DefaultDocumentBuilder };

package/dist/node_modules/langium/lib/workspace/documents.js

@@ -0,0 +1,142 @@
+import { stream } from "../utils/stream.js";
+import { cancellation_exports } from "../utils/cancellation.js";
+import { TextDocument } from "../../../vscode-languageserver-textdocument/lib/esm/main.js";
+import { URI } from "../../../vscode-uri/lib/esm/index.js";
+import { UriTrie } from "../utils/uri-utils.js";
+var DocumentState;
+(function(e) {
+	e[e.Changed = 0] = "Changed", e[e.Parsed = 1] = "Parsed", e[e.IndexedContent = 2] = "IndexedContent", e[e.ComputedScopes = 3] = "ComputedScopes", e[e.Linked = 4] = "Linked", e[e.IndexedReferences = 5] = "IndexedReferences", e[e.Validated = 6] = "Validated";
+})(DocumentState ||= {});
+var DefaultLangiumDocumentFactory = class {
+	constructor(e) {
+		this.serviceRegistry = e.ServiceRegistry, this.textDocuments = e.workspace.TextDocuments, this.fileSystemProvider = e.workspace.FileSystemProvider;
+	}
+	async fromUri(e, a = cancellation_exports.CancellationToken.None) {
+		let o = await this.fileSystemProvider.readFile(e);
+		return this.createAsync(e, o, a);
+	}
+	fromTextDocument(e, a, s) {
+		return a ??= URI.parse(e.uri), cancellation_exports.CancellationToken.is(s) ? this.createAsync(a, e, s) : this.create(a, e, s);
+	}
+	fromString(e, a, o) {
+		return cancellation_exports.CancellationToken.is(o) ? this.createAsync(a, e, o) : this.create(a, e, o);
+	}
+	fromModel(e, i) {
+		return this.create(i, { $model: e });
+	}
+	create(e, i, a) {
+		if (typeof i == "string") {
+			let o = this.parse(e, i, a);
+			return this.createLangiumDocument(o, e, void 0, i);
+		} else if ("$model" in i) {
+			let a = {
+				value: i.$model,
+				parserErrors: [],
+				lexerErrors: []
+			};
+			return this.createLangiumDocument(a, e);
+		} else {
+			let o = this.parse(e, i.getText(), a);
+			return this.createLangiumDocument(o, e, i);
+		}
+	}
+	async createAsync(e, i, a) {
+		if (typeof i == "string") {
+			let o = await this.parseAsync(e, i, a);
+			return this.createLangiumDocument(o, e, void 0, i);
+		} else {
+			let o = await this.parseAsync(e, i.getText(), a);
+			return this.createLangiumDocument(o, e, i);
+		}
+	}
+	createLangiumDocument(e, i, a, o) {
+		let s;
+		if (a) s = {
+			parseResult: e,
+			uri: i,
+			state: DocumentState.Parsed,
+			references: [],
+			textDocument: a
+		};
+		else {
+			let a = this.createTextDocumentGetter(i, o);
+			s = {
+				parseResult: e,
+				uri: i,
+				state: DocumentState.Parsed,
+				references: [],
+				get textDocument() {
+					return a();
+				}
+			};
+		}
+		return e.value.$document = s, s;
+	}
+	async update(e, i) {
+		let a = e.parseResult.value.$cstNode?.root.fullText, o = this.textDocuments?.get(e.uri.toString()), s = o ? o.getText() : await this.fileSystemProvider.readFile(e.uri);
+		if (o) Object.defineProperty(e, "textDocument", { value: o });
+		else {
+			let i = this.createTextDocumentGetter(e.uri, s);
+			Object.defineProperty(e, "textDocument", { get: i });
+		}
+		return a !== s && (e.parseResult = await this.parseAsync(e.uri, s, i), e.parseResult.value.$document = e), e.state = DocumentState.Parsed, e;
+	}
+	parse(e, i, a) {
+		return this.serviceRegistry.getServices(e).parser.LangiumParser.parse(i, a);
+	}
+	parseAsync(e, i, a) {
+		return this.serviceRegistry.getServices(e).parser.AsyncParser.parse(i, a);
+	}
+	createTextDocumentGetter(e, i) {
+		let o = this.serviceRegistry, s;
+		return () => s ??= TextDocument.create(e.toString(), o.getServices(e).LanguageMetaData.languageId, 0, i ?? "");
+	}
+}, DefaultLangiumDocuments = class {
+	constructor(e) {
+		this.documentTrie = new UriTrie(), this.services = e, this.langiumDocumentFactory = e.workspace.LangiumDocumentFactory, this.documentBuilder = () => e.workspace.DocumentBuilder;
+	}
+	get all() {
+		return stream(this.documentTrie.all());
+	}
+	addDocument(e) {
+		let i = e.uri.toString();
+		if (this.documentTrie.has(i)) throw Error(`A document with the URI '${i}' is already present.`);
+		this.documentTrie.insert(i, e);
+	}
+	getDocument(e) {
+		let i = e.toString();
+		return this.documentTrie.find(i);
+	}
+	getDocuments(e) {
+		let i = e.toString();
+		return this.documentTrie.findAll(i);
+	}
+	async getOrCreateDocument(e, i) {
+		let a = this.getDocument(e);
+		return a || (a = await this.langiumDocumentFactory.fromUri(e, i), this.addDocument(a), a);
+	}
+	createDocument(e, i, a) {
+		if (a) return this.langiumDocumentFactory.fromString(i, e, a).then((e) => (this.addDocument(e), e));
+		{
+			let a = this.langiumDocumentFactory.fromString(i, e);
+			return this.addDocument(a), a;
+		}
+	}
+	hasDocument(e) {
+		return this.documentTrie.has(e.toString());
+	}
+	invalidateDocument(e) {
+		let i = e.toString(), a = this.documentTrie.find(i);
+		return a && this.documentBuilder().resetToState(a, DocumentState.Changed), a;
+	}
+	deleteDocument(e) {
+		let i = e.toString(), a = this.documentTrie.find(i);
+		return a && (a.state = DocumentState.Changed, this.documentTrie.delete(i)), a;
+	}
+	deleteDocuments(e) {
+		let i = e.toString(), a = this.documentTrie.findAll(i);
+		for (let e of a) e.state = DocumentState.Changed;
+		return this.documentTrie.delete(i), a;
+	}
+};
+export { DefaultLangiumDocumentFactory, DefaultLangiumDocuments, DocumentState };

package/dist/node_modules/langium/lib/workspace/file-system-provider.js

@@ -0,0 +1,34 @@
+var EmptyFileSystemProvider = class {
+	stat(e) {
+		throw Error("No file system is available.");
+	}
+	statSync(e) {
+		throw Error("No file system is available.");
+	}
+	async exists() {
+		return !1;
+	}
+	existsSync() {
+		return !1;
+	}
+	readBinary() {
+		throw Error("No file system is available.");
+	}
+	readBinarySync() {
+		throw Error("No file system is available.");
+	}
+	readFile() {
+		throw Error("No file system is available.");
+	}
+	readFileSync() {
+		throw Error("No file system is available.");
+	}
+	async readDirectory() {
+		return [];
+	}
+	readDirectorySync() {
+		return [];
+	}
+};
+const EmptyFileSystem = { fileSystemProvider: () => new EmptyFileSystemProvider() };
+export { EmptyFileSystem, EmptyFileSystemProvider };

package/dist/node_modules/langium/lib/workspace/index-manager.js

@@ -0,0 +1,49 @@
+import { stream } from "../utils/stream.js";
+import { getDocument } from "../utils/ast-utils.js";
+import { cancellation_exports } from "../utils/cancellation.js";
+import { UriUtils } from "../utils/uri-utils.js";
+import { ContextCache } from "../utils/caching.js";
+var DefaultIndexManager = class {
+	constructor(e) {
+		this.symbolIndex = /* @__PURE__ */ new Map(), this.symbolByTypeIndex = new ContextCache(), this.referenceIndex = /* @__PURE__ */ new Map(), this.documents = e.workspace.LangiumDocuments, this.serviceRegistry = e.ServiceRegistry, this.astReflection = e.AstReflection;
+	}
+	findAllReferences(n, i) {
+		let a = getDocument(n).uri, o = [];
+		return this.referenceIndex.forEach((e) => {
+			e.forEach((e) => {
+				UriUtils.equals(e.targetUri, a) && e.targetPath === i && o.push(e);
+			});
+		}), stream(o);
+	}
+	allElements(t, n) {
+		let r = stream(this.symbolIndex.keys());
+		return n && (r = r.filter((e) => !n || n.has(e))), r.map((e) => this.getFileDescriptions(e, t)).flat();
+	}
+	getFileDescriptions(e, t) {
+		return t ? this.symbolByTypeIndex.get(e, t, () => (this.symbolIndex.get(e) ?? []).filter((e) => this.astReflection.isSubtype(e.type, t))) : this.symbolIndex.get(e) ?? [];
+	}
+	remove(e) {
+		this.removeContent(e), this.removeReferences(e);
+	}
+	removeContent(e) {
+		let t = e.toString();
+		this.symbolIndex.delete(t), this.symbolByTypeIndex.clear(t);
+	}
+	removeReferences(e) {
+		let t = e.toString();
+		this.referenceIndex.delete(t);
+	}
+	async updateContent(e, t = cancellation_exports.CancellationToken.None) {
+		let r = await this.serviceRegistry.getServices(e.uri).references.ScopeComputation.collectExportedSymbols(e, t), i = e.uri.toString();
+		this.symbolIndex.set(i, r), this.symbolByTypeIndex.clear(i);
+	}
+	async updateReferences(e, t = cancellation_exports.CancellationToken.None) {
+		let r = await this.serviceRegistry.getServices(e.uri).workspace.ReferenceDescriptionProvider.createDescriptions(e, t);
+		this.referenceIndex.set(e.uri.toString(), r);
+	}
+	isAffected(e, t) {
+		let n = this.referenceIndex.get(e.uri.toString());
+		return n ? n.some((e) => !e.local && t.has(e.targetUri.toString())) : !1;
+	}
+};
+export { DefaultIndexManager };