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

package/dist/node_modules/langium/lib/dependency-injection.js

@@ -0,0 +1,62 @@
+var Module;
+(function(e) {
+	e.merge = (e, n) => _merge(_merge({}, e), n);
+})(Module ||= {});
+function inject(e, n, r, i, o, s, c, l, u) {
+	return _inject([
+		e,
+		n,
+		r,
+		i,
+		o,
+		s,
+		c,
+		l,
+		u
+	].reduce(_merge, {}));
+}
+var isProxy = Symbol("isProxy");
+function eagerLoad(e) {
+	if (e && e[isProxy]) for (let n of Object.values(e)) eagerLoad(n);
+	return e;
+}
+function _inject(e, n) {
+	let i = new Proxy({}, {
+		deleteProperty: () => !1,
+		set: () => {
+			throw Error("Cannot set property on injected service container");
+		},
+		get: (a, o) => o === isProxy ? !0 : _resolve(a, o, e, n || i),
+		getOwnPropertyDescriptor: (r, a) => (_resolve(r, a, e, n || i), Object.getOwnPropertyDescriptor(r, a)),
+		has: (n, r) => r in e,
+		ownKeys: () => [...Object.getOwnPropertyNames(e)]
+	});
+	return i;
+}
+var __requested__ = Symbol();
+function _resolve(e, n, r, i) {
+	if (n in e) {
+		if (e[n] instanceof Error) throw Error("Construction failure. Please make sure that your dependencies are constructable. Cause: " + e[n]);
+		if (e[n] === __requested__) throw Error("Cycle detected. Please make \"" + String(n) + "\" lazy. Visit https://langium.org/docs/reference/configuration-services/#resolving-cyclic-dependencies");
+		return e[n];
+	} else if (n in r) {
+		let s = r[n];
+		e[n] = __requested__;
+		try {
+			e[n] = typeof s == "function" ? s(i) : _inject(s, i);
+		} catch (r) {
+			throw e[n] = r instanceof Error ? r : void 0, r;
+		}
+		return e[n];
+	} else return;
+}
+function _merge(e, n) {
+	if (n) {
+		for (let [r, i] of Object.entries(n)) if (i != null) if (typeof i == "object") {
+			let n = e[r];
+			typeof n == "object" && n ? e[r] = _merge(n, i) : e[r] = _merge({}, i);
+		} else e[r] = i;
+	}
+	return e;
+}
+export { Module, eagerLoad, inject };

package/dist/node_modules/langium/lib/documentation/comment-provider.js

@@ -0,0 +1,11 @@
+import { findCommentNode } from "../utils/cst-utils.js";
+import { isAstNodeWithComment } from "../serializer/json-serializer.js";
+var DefaultCommentProvider = class {
+	constructor(e) {
+		this.grammarConfig = () => e.parser.GrammarConfig;
+	}
+	getComment(n) {
+		return isAstNodeWithComment(n) ? n.$comment : findCommentNode(n.$cstNode, this.grammarConfig().multilineCommentRules)?.text;
+	}
+};
+export { DefaultCommentProvider };

package/dist/node_modules/langium/lib/documentation/documentation-provider.js

@@ -0,0 +1,36 @@
+import { getDocument } from "../utils/ast-utils.js";
+import { isJSDoc, parseJSDoc } from "./jsdoc.js";
+var JSDocDocumentationProvider = class {
+	constructor(e) {
+		this.indexManager = e.shared.workspace.IndexManager, this.commentProvider = e.documentation.CommentProvider;
+	}
+	getDocumentation(e) {
+		let r = this.commentProvider.getComment(e);
+		if (r && isJSDoc(r)) return parseJSDoc(r).toMarkdown({
+			renderLink: (t, n) => this.documentationLinkRenderer(e, t, n),
+			renderTag: (t) => this.documentationTagRenderer(e, t)
+		});
+	}
+	documentationLinkRenderer(e, t, n) {
+		let r = this.findNameInLocalSymbols(e, t) ?? this.findNameInGlobalScope(e, t);
+		if (r && r.nameSegment) {
+			let e = r.nameSegment.range.start.line + 1, t = r.nameSegment.range.start.character + 1;
+			return `[${n}](${r.documentUri.with({ fragment: `L${e},${t}` }).toString()})`;
+		} else return;
+	}
+	documentationTagRenderer(e, t) {}
+	findNameInLocalSymbols(t, n) {
+		let r = getDocument(t).localSymbols;
+		if (!r) return;
+		let i = t;
+		do {
+			let e = r.getStream(i).find((e) => e.name === n);
+			if (e) return e;
+			i = i.$container;
+		} while (i);
+	}
+	findNameInGlobalScope(e, t) {
+		return this.indexManager.allElements().find((e) => e.name === t);
+	}
+};
+export { JSDocDocumentationProvider };

package/dist/node_modules/langium/lib/documentation/jsdoc.js

@@ -0,0 +1,303 @@
+import { NEWLINE_REGEXP, escapeRegExp } from "../utils/regexp-utils.js";
+import { Position, Range, init_main } from "../../../vscode-languageserver-types/lib/esm/main.js";
+import { URI } from "../../../vscode-uri/lib/esm/index.js";
+init_main();
+function parseJSDoc(i, x, C) {
+	let w, T;
+	typeof i == "string" ? (T = x, w = C) : (T = i.range.start, w = x), T ||= Position.create(0, 0);
+	let E = getLines(i), D = normalizeOptions(w);
+	return parseJSDocComment({
+		index: 0,
+		tokens: tokenize({
+			lines: E,
+			position: T,
+			options: D
+		}),
+		position: T
+	});
+}
+function isJSDoc(i, x) {
+	let S = normalizeOptions(x), C = getLines(i);
+	if (C.length === 0) return !1;
+	let w = C[0], T = C[C.length - 1], E = S.start, D = S.end;
+	return !!E?.exec(w) && !!D?.exec(T);
+}
+function getLines(x) {
+	let S = "";
+	return S = typeof x == "string" ? x : x.text, S.split(NEWLINE_REGEXP);
+}
+var tagRegex = /\s*(@([\p{L}][\p{L}\p{N}]*)?)/uy, inlineTagRegex = /\{(@[\p{L}][\p{L}\p{N}]*)(\s*)([^\r\n}]+)?\}/gu;
+function tokenize(i) {
+	let x = [], w = i.position.line, T = i.position.character;
+	for (let E = 0; E < i.lines.length; E++) {
+		let D = E === 0, O = E === i.lines.length - 1, j = i.lines[E], M = 0;
+		if (D && i.options.start) {
+			let x = i.options.start?.exec(j);
+			x && (M = x.index + x[0].length);
+		} else {
+			let x = i.options.line?.exec(j);
+			x && (M = x.index + x[0].length);
+		}
+		if (O) {
+			let x = i.options.end?.exec(j);
+			x && (j = j.substring(0, x.index));
+		}
+		if (j = j.substring(0, lastCharacter(j)), skipWhitespace(j, M) >= j.length) {
+			if (x.length > 0) {
+				let i = Position.create(w, T);
+				x.push({
+					type: "break",
+					content: "",
+					range: Range.create(i, i)
+				});
+			}
+		} else {
+			tagRegex.lastIndex = M;
+			let i = tagRegex.exec(j);
+			if (i) {
+				let E = i[0], D = i[1], O = Position.create(w, T + M), k = Position.create(w, T + M + E.length);
+				x.push({
+					type: "tag",
+					content: D,
+					range: Range.create(O, k)
+				}), M += E.length, M = skipWhitespace(j, M);
+			}
+			if (M < j.length) {
+				let i = j.substring(M), S = Array.from(i.matchAll(inlineTagRegex));
+				x.push(...buildInlineTokens(S, i, w, T + M));
+			}
+		}
+		w++, T = 0;
+	}
+	return x.length > 0 && x[x.length - 1].type === "break" ? x.slice(0, -1) : x;
+}
+function buildInlineTokens(i, x, w, T) {
+	let E = [];
+	if (i.length === 0) {
+		let i = Position.create(w, T), D = Position.create(w, T + x.length);
+		E.push({
+			type: "text",
+			content: x,
+			range: Range.create(i, D)
+		});
+	} else {
+		let D = 0;
+		for (let O of i) {
+			let i = O.index, k = x.substring(D, i);
+			k.length > 0 && E.push({
+				type: "text",
+				content: x.substring(D, i),
+				range: Range.create(Position.create(w, D + T), Position.create(w, i + T))
+			});
+			let A = k.length + 1, j = O[1];
+			if (E.push({
+				type: "inline-tag",
+				content: j,
+				range: Range.create(Position.create(w, D + A + T), Position.create(w, D + A + j.length + T))
+			}), A += j.length, O.length === 4) {
+				A += O[2].length;
+				let i = O[3];
+				E.push({
+					type: "text",
+					content: i,
+					range: Range.create(Position.create(w, D + A + T), Position.create(w, D + A + i.length + T))
+				});
+			} else E.push({
+				type: "text",
+				content: "",
+				range: Range.create(Position.create(w, D + A + T), Position.create(w, D + A + T))
+			});
+			D = i + O[0].length;
+		}
+		let O = x.substring(D);
+		O.length > 0 && E.push({
+			type: "text",
+			content: O,
+			range: Range.create(Position.create(w, D + T), Position.create(w, D + T + O.length))
+		});
+	}
+	return E;
+}
+var nonWhitespaceRegex = /\S/, whitespaceEndRegex = /\s*$/;
+function skipWhitespace(i, x) {
+	let S = i.substring(x).match(nonWhitespaceRegex);
+	return S ? x + S.index : i.length;
+}
+function lastCharacter(i) {
+	let x = i.match(whitespaceEndRegex);
+	if (x && typeof x.index == "number") return x.index;
+}
+function parseJSDocComment(i) {
+	let x = Position.create(i.position.line, i.position.character);
+	if (i.tokens.length === 0) return new JSDocCommentImpl([], Range.create(x, x));
+	let w = [];
+	for (; i.index < i.tokens.length;) {
+		let x = parseJSDocElement(i, w[w.length - 1]);
+		x && w.push(x);
+	}
+	let T = w[0]?.range.start ?? x, E = w[w.length - 1]?.range.end ?? x;
+	return new JSDocCommentImpl(w, Range.create(T, E));
+}
+function parseJSDocElement(i, x) {
+	let S = i.tokens[i.index];
+	if (S.type === "tag") return parseJSDocTag(i, !1);
+	if (S.type === "text" || S.type === "inline-tag") return parseJSDocText(i);
+	appendEmptyLine(S, x), i.index++;
+}
+function appendEmptyLine(i, x) {
+	if (x) {
+		let S = new JSDocLineImpl("", i.range);
+		"inlines" in x ? x.inlines.push(S) : x.content.inlines.push(S);
+	}
+}
+function parseJSDocText(i) {
+	let x = i.tokens[i.index], S = x, w = x, T = [];
+	for (; x && x.type !== "break" && x.type !== "tag";) T.push(parseJSDocInline(i)), w = x, x = i.tokens[i.index];
+	return new JSDocTextImpl(T, Range.create(S.range.start, w.range.end));
+}
+function parseJSDocInline(i) {
+	return i.tokens[i.index].type === "inline-tag" ? parseJSDocTag(i, !0) : parseJSDocLine(i);
+}
+function parseJSDocTag(i, x) {
+	let S = i.tokens[i.index++], w = S.content.substring(1);
+	if (i.tokens[i.index]?.type === "text") if (x) {
+		let T = parseJSDocLine(i);
+		return new JSDocTagImpl(w, new JSDocTextImpl([T], T.range), x, Range.create(S.range.start, T.range.end));
+	} else {
+		let T = parseJSDocText(i);
+		return new JSDocTagImpl(w, T, x, Range.create(S.range.start, T.range.end));
+	}
+	else {
+		let i = S.range;
+		return new JSDocTagImpl(w, new JSDocTextImpl([], i), x, i);
+	}
+}
+function parseJSDocLine(i) {
+	let x = i.tokens[i.index++];
+	return new JSDocLineImpl(x.content, x.range);
+}
+function normalizeOptions(i) {
+	if (!i) return normalizeOptions({
+		start: "/**",
+		end: "*/",
+		line: "*"
+	});
+	let { start: x, end: S, line: C } = i;
+	return {
+		start: normalizeOption(x, !0),
+		end: normalizeOption(S, !1),
+		line: normalizeOption(C, !0)
+	};
+}
+function normalizeOption(i, S) {
+	if (typeof i == "string" || typeof i == "object") {
+		let C = typeof i == "string" ? escapeRegExp(i) : i.source;
+		return S ? /* @__PURE__ */ RegExp(`^\\s*${C}`) : /* @__PURE__ */ RegExp(`\\s*${C}\\s*$`);
+	} else return i;
+}
+var JSDocCommentImpl = class {
+	constructor(i, x) {
+		this.elements = i, this.range = x;
+	}
+	getTag(i) {
+		return this.getAllTags().find((x) => x.name === i);
+	}
+	getTags(i) {
+		return this.getAllTags().filter((x) => x.name === i);
+	}
+	getAllTags() {
+		return this.elements.filter((i) => "name" in i);
+	}
+	toString() {
+		let i = "";
+		for (let x of this.elements) if (i.length === 0) i = x.toString();
+		else {
+			let S = x.toString();
+			i += fillNewlines(i) + S;
+		}
+		return i.trim();
+	}
+	toMarkdown(i) {
+		let x = "";
+		for (let S of this.elements) if (x.length === 0) x = S.toMarkdown(i);
+		else {
+			let C = S.toMarkdown(i);
+			x += fillNewlines(x) + C;
+		}
+		return x.trim();
+	}
+}, JSDocTagImpl = class {
+	constructor(i, x, S, C) {
+		this.name = i, this.content = x, this.inline = S, this.range = C;
+	}
+	toString() {
+		let i = `@${this.name}`, x = this.content.toString();
+		return this.content.inlines.length === 1 ? i = `${i} ${x}` : this.content.inlines.length > 1 && (i = `${i}\n${x}`), this.inline ? `{${i}}` : i;
+	}
+	toMarkdown(i) {
+		return i?.renderTag?.(this) ?? this.toMarkdownDefault(i);
+	}
+	toMarkdownDefault(i) {
+		let x = this.content.toMarkdown(i);
+		if (this.inline) {
+			let S = renderInlineTag(this.name, x, i ?? {});
+			if (typeof S == "string") return S;
+		}
+		let S = "";
+		i?.tag === "italic" || i?.tag === void 0 ? S = "*" : i?.tag === "bold" ? S = "**" : i?.tag === "bold-italic" && (S = "***");
+		let C = `${S}@${this.name}${S}`;
+		return this.content.inlines.length === 1 ? C = `${C} — ${x}` : this.content.inlines.length > 1 && (C = `${C}\n${x}`), this.inline ? `{${C}}` : C;
+	}
+};
+function renderInlineTag(i, x, S) {
+	if (i === "linkplain" || i === "linkcode" || i === "link") {
+		let C = x.indexOf(" "), w = x;
+		if (C > 0) {
+			let i = skipWhitespace(x, C);
+			w = x.substring(i), x = x.substring(0, C);
+		}
+		return (i === "linkcode" || i === "link" && S.link === "code") && (w = `\`${w}\``), S.renderLink?.(x, w) ?? renderLinkDefault(x, w);
+	}
+}
+function renderLinkDefault(i, x) {
+	try {
+		return URI.parse(i, !0), `[${x}](${i})`;
+	} catch {
+		return i;
+	}
+}
+var JSDocTextImpl = class {
+	constructor(i, x) {
+		this.inlines = i, this.range = x;
+	}
+	toString() {
+		let i = "";
+		for (let x = 0; x < this.inlines.length; x++) {
+			let S = this.inlines[x], C = this.inlines[x + 1];
+			i += S.toString(), C && C.range.start.line > S.range.start.line && (i += "\n");
+		}
+		return i;
+	}
+	toMarkdown(i) {
+		let x = "";
+		for (let S = 0; S < this.inlines.length; S++) {
+			let C = this.inlines[S], w = this.inlines[S + 1];
+			x += C.toMarkdown(i), w && w.range.start.line > C.range.start.line && (x += "\n");
+		}
+		return x;
+	}
+}, JSDocLineImpl = class {
+	constructor(i, x) {
+		this.text = i, this.range = x;
+	}
+	toString() {
+		return this.text;
+	}
+	toMarkdown() {
+		return this.text;
+	}
+};
+function fillNewlines(i) {
+	return i.endsWith("\n") ? "\n" : "\n\n";
+}
+export { isJSDoc, parseJSDoc };

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

@@ -0,0 +1,182 @@
+import { __export, __reExport } from "../../../_virtual/rolldown_runtime.js";
+import { AbstractAstReflection, isAstNode, isAstNodeDescription, isCompositeCstNode, isLeafCstNode, isLinkingError, isMultiReference, isReference, isRootCstNode } from "./syntax-tree.js";
+import { DONE_RESULT, EMPTY_STREAM, Reduction, StreamImpl, TreeStreamImpl, stream } from "./utils/stream.js";
+import { ast_utils_exports } from "./utils/ast-utils.js";
+import { ast_exports } from "./languages/generated/ast.js";
+import { cst_utils_exports } from "./utils/cst-utils.js";
+import { ErrorWithLocation, assertCondition, assertUnreachable } from "./utils/errors.js";
+import { regexp_utils_exports } from "./utils/regexp-utils.js";
+import { grammar_utils_exports } from "./utils/grammar-utils.js";
+import { createGrammarConfig } from "./languages/grammar-config.js";
+import { AbstractCstNode, CompositeCstNodeImpl, CstNodeBuilder, LeafCstNodeImpl, RootCstNodeImpl } from "./parser/cst-node-builder.js";
+import { AbstractLangiumParser, AbstractParserErrorMessageProvider, DatatypeSymbol, LangiumCompletionParser, LangiumParser, LangiumParserErrorMessageProvider } from "./parser/langium-parser.js";
+import { createParser } from "./parser/parser-builder-base.js";
+import { createCompletionParser } from "./parser/completion-parser-builder.js";
+import { createLangiumParser, prepareLangiumParser } from "./parser/langium-parser-builder.js";
+import { DefaultTokenBuilder } from "./parser/token-builder.js";
+import { DefaultValueConverter, ValueConverter } from "./parser/value-converter.js";
+import { cancellation_exports } from "./utils/cancellation.js";
+import { Deferred, OperationCancelled, delayNextTick, interruptAndCheck, isOperationCancelled, setInterruptionPeriod, startCancelableOperation } from "./utils/promise-utils.js";
+import { TextDocument } from "../../vscode-languageserver-textdocument/lib/esm/main.js";
+import { URI } from "../../vscode-uri/lib/esm/index.js";
+import { UriTrie, UriUtils } from "./utils/uri-utils.js";
+import { DefaultLangiumDocumentFactory, DefaultLangiumDocuments, DocumentState } from "./workspace/documents.js";
+import { DefaultLinker, RefResolving } from "./references/linker.js";
+import { DefaultNameProvider, isNamed } from "./references/name-provider.js";
+import { DefaultReferences } from "./references/references.js";
+import { BiMap, MultiMap } from "./utils/collections.js";
+import { DefaultScopeComputation } from "./references/scope-computation.js";
+import { EMPTY_SCOPE, MapScope, MultiMapScope, StreamScope } from "./references/scope.js";
+import { ContextCache, DisposableCache, DocumentCache, SimpleCache, WorkspaceCache } from "./utils/caching.js";
+import { DefaultScopeProvider } from "./references/scope-provider.js";
+import { DefaultJsonSerializer, isAstNodeWithComment } from "./serializer/json-serializer.js";
+import { DefaultServiceRegistry } from "./service-registry.js";
+import { ValidationCategory, ValidationRegistry, diagnosticData } from "./validation/validation-registry.js";
+import { DefaultDocumentValidator, DocumentValidator, VALIDATE_EACH_NODE, getDiagnosticRange, toDiagnosticData, toDiagnosticSeverity } from "./validation/document-validator.js";
+import { DefaultAstNodeDescriptionProvider, DefaultReferenceDescriptionProvider } from "./workspace/ast-descriptions.js";
+import { DefaultAstNodeLocator } from "./workspace/ast-node-locator.js";
+import { DefaultConfigurationProvider } from "./workspace/configuration.js";
+import { Disposable } from "./utils/disposable.js";
+import { DefaultDocumentBuilder } from "./workspace/document-builder.js";
+import { DefaultIndexManager } from "./workspace/index-manager.js";
+import { DefaultWorkspaceManager } from "./workspace/workspace-manager.js";
+import { DEFAULT_TOKENIZE_OPTIONS, DefaultLexer, DefaultLexerErrorMessageProvider, isIMultiModeLexerDefinition, isTokenTypeArray, isTokenTypeDictionary } from "./parser/lexer.js";
+import { isJSDoc, parseJSDoc } from "./documentation/jsdoc.js";
+import { JSDocDocumentationProvider } from "./documentation/documentation-provider.js";
+import { DefaultCommentProvider } from "./documentation/comment-provider.js";
+import { AbstractThreadedAsyncParser, DefaultAsyncParser, ParserWorker } from "./parser/async-parser.js";
+import { DefaultWorkspaceLock } from "./workspace/workspace-lock.js";
+import { DefaultHydrator } from "./serializer/hydrator.js";
+import { createDefaultCoreModule, createDefaultSharedCoreModule } from "./default-module.js";
+import { Module, eagerLoad, inject } from "./dependency-injection.js";
+import { IndentationAwareLexer, IndentationAwareTokenBuilder, LexingMode, indentationBuilderDefaultOptions } from "./parser/indentation-aware.js";
+import { EmptyFileSystem, EmptyFileSystemProvider } from "./workspace/file-system-provider.js";
+import { loadGrammarFromJson } from "./utils/grammar-loader.js";
+import { utils_exports } from "./utils/index.js";
+import { DefaultLangiumProfiler, ProfilingTask } from "./workspace/profiler.js";
+__reExport(/* @__PURE__ */ __export({
+	AbstractAstReflection: () => AbstractAstReflection,
+	AbstractCstNode: () => AbstractCstNode,
+	AbstractLangiumParser: () => AbstractLangiumParser,
+	AbstractParserErrorMessageProvider: () => AbstractParserErrorMessageProvider,
+	AbstractThreadedAsyncParser: () => AbstractThreadedAsyncParser,
+	AstUtils: () => ast_utils_exports,
+	BiMap: () => BiMap,
+	Cancellation: () => cancellation_exports,
+	CompositeCstNodeImpl: () => CompositeCstNodeImpl,
+	ContextCache: () => ContextCache,
+	CstNodeBuilder: () => CstNodeBuilder,
+	CstUtils: () => cst_utils_exports,
+	DEFAULT_TOKENIZE_OPTIONS: () => DEFAULT_TOKENIZE_OPTIONS,
+	DONE_RESULT: () => DONE_RESULT,
+	DatatypeSymbol: () => DatatypeSymbol,
+	DefaultAstNodeDescriptionProvider: () => DefaultAstNodeDescriptionProvider,
+	DefaultAstNodeLocator: () => DefaultAstNodeLocator,
+	DefaultAsyncParser: () => DefaultAsyncParser,
+	DefaultCommentProvider: () => DefaultCommentProvider,
+	DefaultConfigurationProvider: () => DefaultConfigurationProvider,
+	DefaultDocumentBuilder: () => DefaultDocumentBuilder,
+	DefaultDocumentValidator: () => DefaultDocumentValidator,
+	DefaultHydrator: () => DefaultHydrator,
+	DefaultIndexManager: () => DefaultIndexManager,
+	DefaultJsonSerializer: () => DefaultJsonSerializer,
+	DefaultLangiumDocumentFactory: () => DefaultLangiumDocumentFactory,
+	DefaultLangiumDocuments: () => DefaultLangiumDocuments,
+	DefaultLangiumProfiler: () => DefaultLangiumProfiler,
+	DefaultLexer: () => DefaultLexer,
+	DefaultLexerErrorMessageProvider: () => DefaultLexerErrorMessageProvider,
+	DefaultLinker: () => DefaultLinker,
+	DefaultNameProvider: () => DefaultNameProvider,
+	DefaultReferenceDescriptionProvider: () => DefaultReferenceDescriptionProvider,
+	DefaultReferences: () => DefaultReferences,
+	DefaultScopeComputation: () => DefaultScopeComputation,
+	DefaultScopeProvider: () => DefaultScopeProvider,
+	DefaultServiceRegistry: () => DefaultServiceRegistry,
+	DefaultTokenBuilder: () => DefaultTokenBuilder,
+	DefaultValueConverter: () => DefaultValueConverter,
+	DefaultWorkspaceLock: () => DefaultWorkspaceLock,
+	DefaultWorkspaceManager: () => DefaultWorkspaceManager,
+	Deferred: () => Deferred,
+	Disposable: () => Disposable,
+	DisposableCache: () => DisposableCache,
+	DocumentCache: () => DocumentCache,
+	DocumentState: () => DocumentState,
+	DocumentValidator: () => DocumentValidator,
+	EMPTY_SCOPE: () => EMPTY_SCOPE,
+	EMPTY_STREAM: () => EMPTY_STREAM,
+	EmptyFileSystem: () => EmptyFileSystem,
+	EmptyFileSystemProvider: () => EmptyFileSystemProvider,
+	ErrorWithLocation: () => ErrorWithLocation,
+	GrammarAST: () => ast_exports,
+	GrammarUtils: () => grammar_utils_exports,
+	IndentationAwareLexer: () => IndentationAwareLexer,
+	IndentationAwareTokenBuilder: () => IndentationAwareTokenBuilder,
+	JSDocDocumentationProvider: () => JSDocDocumentationProvider,
+	LangiumCompletionParser: () => LangiumCompletionParser,
+	LangiumParser: () => LangiumParser,
+	LangiumParserErrorMessageProvider: () => LangiumParserErrorMessageProvider,
+	LeafCstNodeImpl: () => LeafCstNodeImpl,
+	LexingMode: () => LexingMode,
+	MapScope: () => MapScope,
+	Module: () => Module,
+	MultiMap: () => MultiMap,
+	MultiMapScope: () => MultiMapScope,
+	OperationCancelled: () => OperationCancelled,
+	ParserWorker: () => ParserWorker,
+	ProfilingTask: () => ProfilingTask,
+	Reduction: () => Reduction,
+	RefResolving: () => RefResolving,
+	RegExpUtils: () => regexp_utils_exports,
+	RootCstNodeImpl: () => RootCstNodeImpl,
+	SimpleCache: () => SimpleCache,
+	StreamImpl: () => StreamImpl,
+	StreamScope: () => StreamScope,
+	TextDocument: () => TextDocument,
+	TreeStreamImpl: () => TreeStreamImpl,
+	URI: () => URI,
+	UriTrie: () => UriTrie,
+	UriUtils: () => UriUtils,
+	VALIDATE_EACH_NODE: () => VALIDATE_EACH_NODE,
+	ValidationCategory: () => ValidationCategory,
+	ValidationRegistry: () => ValidationRegistry,
+	ValueConverter: () => ValueConverter,
+	WorkspaceCache: () => WorkspaceCache,
+	assertCondition: () => assertCondition,
+	assertUnreachable: () => assertUnreachable,
+	createCompletionParser: () => createCompletionParser,
+	createDefaultCoreModule: () => createDefaultCoreModule,
+	createDefaultSharedCoreModule: () => createDefaultSharedCoreModule,
+	createGrammarConfig: () => createGrammarConfig,
+	createLangiumParser: () => createLangiumParser,
+	createParser: () => createParser,
+	delayNextTick: () => delayNextTick,
+	diagnosticData: () => diagnosticData,
+	eagerLoad: () => eagerLoad,
+	getDiagnosticRange: () => getDiagnosticRange,
+	indentationBuilderDefaultOptions: () => indentationBuilderDefaultOptions,
+	inject: () => inject,
+	interruptAndCheck: () => interruptAndCheck,
+	isAstNode: () => isAstNode,
+	isAstNodeDescription: () => isAstNodeDescription,
+	isAstNodeWithComment: () => isAstNodeWithComment,
+	isCompositeCstNode: () => isCompositeCstNode,
+	isIMultiModeLexerDefinition: () => isIMultiModeLexerDefinition,
+	isJSDoc: () => isJSDoc,
+	isLeafCstNode: () => isLeafCstNode,
+	isLinkingError: () => isLinkingError,
+	isMultiReference: () => isMultiReference,
+	isNamed: () => isNamed,
+	isOperationCancelled: () => isOperationCancelled,
+	isReference: () => isReference,
+	isRootCstNode: () => isRootCstNode,
+	isTokenTypeArray: () => isTokenTypeArray,
+	isTokenTypeDictionary: () => isTokenTypeDictionary,
+	loadGrammarFromJson: () => loadGrammarFromJson,
+	parseJSDoc: () => parseJSDoc,
+	prepareLangiumParser: () => prepareLangiumParser,
+	setInterruptionPeriod: () => setInterruptionPeriod,
+	startCancelableOperation: () => startCancelableOperation,
+	stream: () => stream,
+	toDiagnosticData: () => toDiagnosticData,
+	toDiagnosticSeverity: () => toDiagnosticSeverity
+}, 1), utils_exports, void 0, 1);