@plumile/ui 0.1.113 → 0.1.114

package/lib/esm/node_modules/langium/lib/utils/caching.js

@@ -1,84 +0,0 @@
-//#region ../../node_modules/langium/lib/utils/caching.js
-var e = class {
-	constructor() {
-		this.toDispose = [], this.isDisposed = !1;
-	}
-	onDispose(e) {
-		this.toDispose.push(e);
-	}
-	dispose() {
-		this.throwIfDisposed(), this.clear(), this.isDisposed = !0, this.toDispose.forEach((e) => e.dispose());
-	}
-	throwIfDisposed() {
-		if (this.isDisposed) throw Error("This cache has already been disposed");
-	}
-}, t = class extends e {
-	constructor() {
-		super(...arguments), this.cache = /* @__PURE__ */ new Map();
-	}
-	has(e) {
-		return this.throwIfDisposed(), this.cache.has(e);
-	}
-	set(e, t) {
-		this.throwIfDisposed(), this.cache.set(e, t);
-	}
-	get(e, t) {
-		if (this.throwIfDisposed(), this.cache.has(e)) return this.cache.get(e);
-		if (t) {
-			let n = t();
-			return this.cache.set(e, n), n;
-		} else return;
-	}
-	delete(e) {
-		return this.throwIfDisposed(), this.cache.delete(e);
-	}
-	clear() {
-		this.throwIfDisposed(), this.cache.clear();
-	}
-}, n = class extends e {
-	constructor(e) {
-		super(), this.cache = /* @__PURE__ */ new Map(), this.converter = e ?? ((e) => e);
-	}
-	has(e, t) {
-		return this.throwIfDisposed(), this.cacheForContext(e).has(t);
-	}
-	set(e, t, n) {
-		this.throwIfDisposed(), this.cacheForContext(e).set(t, n);
-	}
-	get(e, t, n) {
-		this.throwIfDisposed();
-		let r = this.cacheForContext(e);
-		if (r.has(t)) return r.get(t);
-		if (n) {
-			let e = n();
-			return r.set(t, e), e;
-		} else return;
-	}
-	delete(e, t) {
-		return this.throwIfDisposed(), this.cacheForContext(e).delete(t);
-	}
-	clear(e) {
-		if (this.throwIfDisposed(), e) {
-			let t = this.converter(e);
-			this.cache.delete(t);
-		} else this.cache.clear();
-	}
-	cacheForContext(e) {
-		let t = this.converter(e), n = this.cache.get(t);
-		return n || (n = /* @__PURE__ */ new Map(), this.cache.set(t, n)), n;
-	}
-}, r = class extends t {
-	constructor(e, t) {
-		super(), t ? (this.toDispose.push(e.workspace.DocumentBuilder.onBuildPhase(t, () => {
-			this.clear();
-		})), this.toDispose.push(e.workspace.DocumentBuilder.onUpdate((e, t) => {
-			t.length > 0 && this.clear();
-		}))) : this.toDispose.push(e.workspace.DocumentBuilder.onUpdate(() => {
-			this.clear();
-		}));
-	}
-};
-//#endregion
-export { n as ContextCache, r as WorkspaceCache };
-
-//# sourceMappingURL=caching.js.map

package/lib/esm/node_modules/langium/lib/utils/caching.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"caching.js","names":[],"sources":["../../../../../../../../node_modules/langium/lib/utils/caching.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport class DisposableCache {\n    constructor() {\n        this.toDispose = [];\n        this.isDisposed = false;\n    }\n    onDispose(disposable) {\n        this.toDispose.push(disposable);\n    }\n    dispose() {\n        this.throwIfDisposed();\n        this.clear();\n        this.isDisposed = true;\n        this.toDispose.forEach(disposable => disposable.dispose());\n    }\n    throwIfDisposed() {\n        if (this.isDisposed) {\n            throw new Error('This cache has already been disposed');\n        }\n    }\n}\nexport class SimpleCache extends DisposableCache {\n    constructor() {\n        super(...arguments);\n        this.cache = new Map();\n    }\n    has(key) {\n        this.throwIfDisposed();\n        return this.cache.has(key);\n    }\n    set(key, value) {\n        this.throwIfDisposed();\n        this.cache.set(key, value);\n    }\n    get(key, provider) {\n        this.throwIfDisposed();\n        if (this.cache.has(key)) {\n            return this.cache.get(key);\n        }\n        else if (provider) {\n            const value = provider();\n            this.cache.set(key, value);\n            return value;\n        }\n        else {\n            return undefined;\n        }\n    }\n    delete(key) {\n        this.throwIfDisposed();\n        return this.cache.delete(key);\n    }\n    clear() {\n        this.throwIfDisposed();\n        this.cache.clear();\n    }\n}\nexport class ContextCache extends DisposableCache {\n    constructor(converter) {\n        super();\n        this.cache = new Map();\n        this.converter = converter ?? (value => value);\n    }\n    has(contextKey, key) {\n        this.throwIfDisposed();\n        return this.cacheForContext(contextKey).has(key);\n    }\n    set(contextKey, key, value) {\n        this.throwIfDisposed();\n        this.cacheForContext(contextKey).set(key, value);\n    }\n    get(contextKey, key, provider) {\n        this.throwIfDisposed();\n        const contextCache = this.cacheForContext(contextKey);\n        if (contextCache.has(key)) {\n            return contextCache.get(key);\n        }\n        else if (provider) {\n            const value = provider();\n            contextCache.set(key, value);\n            return value;\n        }\n        else {\n            return undefined;\n        }\n    }\n    delete(contextKey, key) {\n        this.throwIfDisposed();\n        return this.cacheForContext(contextKey).delete(key);\n    }\n    clear(contextKey) {\n        this.throwIfDisposed();\n        if (contextKey) {\n            const mapKey = this.converter(contextKey);\n            this.cache.delete(mapKey);\n        }\n        else {\n            this.cache.clear();\n        }\n    }\n    cacheForContext(contextKey) {\n        const mapKey = this.converter(contextKey);\n        let documentCache = this.cache.get(mapKey);\n        if (!documentCache) {\n            documentCache = new Map();\n            this.cache.set(mapKey, documentCache);\n        }\n        return documentCache;\n    }\n}\n/**\n * Every key/value pair in this cache is scoped to a document.\n * If this document is changed or deleted, all associated key/value pairs are deleted.\n */\nexport class DocumentCache extends ContextCache {\n    /**\n     * Creates a new document cache.\n     *\n     * @param sharedServices Service container instance to hook into document lifecycle events.\n     * @param state Optional document state on which the cache should evict.\n     * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.\n     * *Deleted* documents are considered in both cases.\n     *\n     * Providing a state here will use `DocumentBuilder#onDocumentPhase` instead,\n     * which triggers on all documents that have been affected by this change, assuming that the\n     * state is `DocumentState.Linked` or a later state.\n     */\n    constructor(sharedServices, state) {\n        super(uri => uri.toString());\n        if (state) {\n            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onDocumentPhase(state, document => {\n                this.clear(document.uri.toString());\n            }));\n            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {\n                for (const uri of deleted) { // react only on deleted documents\n                    this.clear(uri);\n                }\n            }));\n        }\n        else {\n            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((changed, deleted) => {\n                const allUris = changed.concat(deleted); // react on both changed and deleted documents\n                for (const uri of allUris) {\n                    this.clear(uri);\n                }\n            }));\n        }\n    }\n}\n/**\n * Every key/value pair in this cache is scoped to the whole workspace.\n * If any document in the workspace is added, changed or deleted, the whole cache is evicted.\n */\nexport class WorkspaceCache extends SimpleCache {\n    /**\n     * Creates a new workspace cache.\n     *\n     * @param sharedServices Service container instance to hook into document lifecycle events.\n     * @param state Optional document state on which the cache should evict.\n     * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.\n     * *Deleted* documents are considered in both cases.\n     */\n    constructor(sharedServices, state) {\n        super();\n        if (state) {\n            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onBuildPhase(state, () => {\n                this.clear();\n            }));\n            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {\n                if (deleted.length > 0) { // react only on deleted documents\n                    this.clear();\n                }\n            }));\n        }\n        else {\n            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate(() => {\n                this.clear();\n            }));\n        }\n    }\n}\n//# sourceMappingURL=caching.js.map"],"x_google_ignoreList":[0],"mappings":";AAKA,IAAa,IAAb,MAA6B;CACzB,cAAc;EAEV,AADA,KAAK,YAAY,EAAE,EACnB,KAAK,aAAa;;CAEtB,UAAU,GAAY;EAClB,KAAK,UAAU,KAAK,EAAW;;CAEnC,UAAU;EAIN,AAHA,KAAK,iBAAiB,EACtB,KAAK,OAAO,EACZ,KAAK,aAAa,IAClB,KAAK,UAAU,SAAQ,MAAc,EAAW,SAAS,CAAC;;CAE9D,kBAAkB;EACd,IAAI,KAAK,YACL,MAAU,MAAM,uCAAuC;;GAItD,IAAb,cAAiC,EAAgB;CAC7C,cAAc;EAEV,AADA,MAAM,GAAG,UAAU,EACnB,KAAK,wBAAQ,IAAI,KAAK;;CAE1B,IAAI,GAAK;EAEL,OADA,KAAK,iBAAiB,EACf,KAAK,MAAM,IAAI,EAAI;;CAE9B,IAAI,GAAK,GAAO;EAEZ,AADA,KAAK,iBAAiB,EACtB,KAAK,MAAM,IAAI,GAAK,EAAM;;CAE9B,IAAI,GAAK,GAAU;EAEf,IADA,KAAK,iBAAiB,EAClB,KAAK,MAAM,IAAI,EAAI,EACnB,OAAO,KAAK,MAAM,IAAI,EAAI;EAEzB,IAAI,GAAU;GACf,IAAM,IAAQ,GAAU;GAExB,OADA,KAAK,MAAM,IAAI,GAAK,EAAM,EACnB;SAGP;;CAGR,OAAO,GAAK;EAER,OADA,KAAK,iBAAiB,EACf,KAAK,MAAM,OAAO,EAAI;;CAEjC,QAAQ;EAEJ,AADA,KAAK,iBAAiB,EACtB,KAAK,MAAM,OAAO;;GAGb,IAAb,cAAkC,EAAgB;CAC9C,YAAY,GAAW;EAGnB,AAFA,OAAO,EACP,KAAK,wBAAQ,IAAI,KAAK,EACtB,KAAK,YAAY,OAAc,MAAS;;CAE5C,IAAI,GAAY,GAAK;EAEjB,OADA,KAAK,iBAAiB,EACf,KAAK,gBAAgB,EAAW,CAAC,IAAI,EAAI;;CAEpD,IAAI,GAAY,GAAK,GAAO;EAExB,AADA,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EAAW,CAAC,IAAI,GAAK,EAAM;;CAEpD,IAAI,GAAY,GAAK,GAAU;EAC3B,KAAK,iBAAiB;EACtB,IAAM,IAAe,KAAK,gBAAgB,EAAW;EACrD,IAAI,EAAa,IAAI,EAAI,EACrB,OAAO,EAAa,IAAI,EAAI;EAE3B,IAAI,GAAU;GACf,IAAM,IAAQ,GAAU;GAExB,OADA,EAAa,IAAI,GAAK,EAAM,EACrB;SAGP;;CAGR,OAAO,GAAY,GAAK;EAEpB,OADA,KAAK,iBAAiB,EACf,KAAK,gBAAgB,EAAW,CAAC,OAAO,EAAI;;CAEvD,MAAM,GAAY;EAEd,IADA,KAAK,iBAAiB,EAClB,GAAY;GACZ,IAAM,IAAS,KAAK,UAAU,EAAW;GACzC,KAAK,MAAM,OAAO,EAAO;SAGzB,KAAK,MAAM,OAAO;;CAG1B,gBAAgB,GAAY;EACxB,IAAM,IAAS,KAAK,UAAU,EAAW,EACrC,IAAgB,KAAK,MAAM,IAAI,EAAO;EAK1C,OAJK,MACD,oBAAgB,IAAI,KAAK,EACzB,KAAK,MAAM,IAAI,GAAQ,EAAc,GAElC;;GA8CF,IAAb,cAAoC,EAAY;CAS5C,YAAY,GAAgB,GAAO;EAE/B,AADA,OAAO,EACH,KACA,KAAK,UAAU,KAAK,EAAe,UAAU,gBAAgB,aAAa,SAAa;GACnF,KAAK,OAAO;IACd,CAAC,EACH,KAAK,UAAU,KAAK,EAAe,UAAU,gBAAgB,UAAU,GAAU,MAAY;GACzF,AAAI,EAAQ,SAAS,KACjB,KAAK,OAAO;IAElB,CAAC,IAGH,KAAK,UAAU,KAAK,EAAe,UAAU,gBAAgB,eAAe;GACxE,KAAK,OAAO;IACd,CAAC"}

package/lib/esm/node_modules/langium/lib/utils/cancellation.js

@@ -1,9 +0,0 @@
-import { __exportAll as e, __reExport as t, __toESM as n } from "../../../../_virtual/_rolldown/runtime.js";
-import { require_cancellation as r } from "../../../vscode-jsonrpc/lib/common/cancellation.js";
-//#region ../../node_modules/langium/lib/utils/cancellation.js
-var i = /* @__PURE__ */ e({});
-t(i, /* @__PURE__ */ n(r(), 1));
-//#endregion
-export { i as cancellation_exports };
-
-//# sourceMappingURL=cancellation.js.map

package/lib/esm/node_modules/langium/lib/utils/cancellation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cancellation.js","names":[],"sources":["../../../../../../../../node_modules/langium/lib/utils/cancellation.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2024 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\n// eslint-disable-next-line no-restricted-imports\nexport * from 'vscode-jsonrpc/lib/common/cancellation.js';\n//# sourceMappingURL=cancellation.js.map"],"x_google_ignoreList":[0],"mappings":""}

package/lib/esm/node_modules/langium/lib/utils/collections.js

@@ -1,89 +0,0 @@
-import { EMPTY_STREAM as e, Reduction as t, stream as n } from "./stream.js";
-//#region ../../node_modules/langium/lib/utils/collections.js
-var r = class {
-	constructor(e) {
-		if (this.map = /* @__PURE__ */ new Map(), e) for (let [t, n] of e) this.add(t, n);
-	}
-	get size() {
-		return t.sum(n(this.map.values()).map((e) => e.length));
-	}
-	clear() {
-		this.map.clear();
-	}
-	delete(e, t) {
-		if (t === void 0) return this.map.delete(e);
-		{
-			let n = this.map.get(e);
-			if (n) {
-				let r = n.indexOf(t);
-				if (r >= 0) return n.length === 1 ? this.map.delete(e) : n.splice(r, 1), !0;
-			}
-			return !1;
-		}
-	}
-	get(e) {
-		return this.map.get(e) ?? [];
-	}
-	getStream(t) {
-		let r = this.map.get(t);
-		return r ? n(r) : e;
-	}
-	has(e, t) {
-		if (t === void 0) return this.map.has(e);
-		{
-			let n = this.map.get(e);
-			return n ? n.indexOf(t) >= 0 : !1;
-		}
-	}
-	add(e, t) {
-		return this.map.has(e) ? this.map.get(e).push(t) : this.map.set(e, [t]), this;
-	}
-	addAll(e, t) {
-		return this.map.has(e) ? this.map.get(e).push(...t) : this.map.set(e, Array.from(t)), this;
-	}
-	forEach(e) {
-		this.map.forEach((t, n) => t.forEach((t) => e(t, n, this)));
-	}
-	[Symbol.iterator]() {
-		return this.entries().iterator();
-	}
-	entries() {
-		return n(this.map.entries()).flatMap(([e, t]) => t.map((t) => [e, t]));
-	}
-	keys() {
-		return n(this.map.keys());
-	}
-	values() {
-		return n(this.map.values()).flat();
-	}
-	entriesGroupedByKey() {
-		return n(this.map.entries());
-	}
-}, i = class {
-	get size() {
-		return this.map.size;
-	}
-	constructor(e) {
-		if (this.map = /* @__PURE__ */ new Map(), this.inverse = /* @__PURE__ */ new Map(), e) for (let [t, n] of e) this.set(t, n);
-	}
-	clear() {
-		this.map.clear(), this.inverse.clear();
-	}
-	set(e, t) {
-		return this.map.set(e, t), this.inverse.set(t, e), this;
-	}
-	get(e) {
-		return this.map.get(e);
-	}
-	getKey(e) {
-		return this.inverse.get(e);
-	}
-	delete(e) {
-		let t = this.map.get(e);
-		return t === void 0 ? !1 : (this.map.delete(e), this.inverse.delete(t), !0);
-	}
-};
-//#endregion
-export { i as BiMap, r as MultiMap };
-
-//# sourceMappingURL=collections.js.map

package/lib/esm/node_modules/langium/lib/utils/collections.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"collections.js","names":[],"sources":["../../../../../../../../node_modules/langium/lib/utils/collections.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { EMPTY_STREAM, Reduction, stream } from './stream.js';\n/**\n * A multimap is a variation of a Map that has potentially multiple values for every key.\n */\nexport class MultiMap {\n    constructor(elements) {\n        this.map = new Map();\n        if (elements) {\n            for (const [key, value] of elements) {\n                this.add(key, value);\n            }\n        }\n    }\n    /**\n     * The total number of values in the multimap.\n     */\n    get size() {\n        return Reduction.sum(stream(this.map.values()).map(a => a.length));\n    }\n    /**\n     * Clear all entries in the multimap.\n     */\n    clear() {\n        this.map.clear();\n    }\n    /**\n     * Operates differently depending on whether a `value` is given:\n     *  * With a value, this method deletes the specific key / value pair from the multimap.\n     *  * Without a value, all values associated with the given key are deleted.\n     *\n     * @returns `true` if a value existed and has been removed, or `false` if the specified\n     *     key / value does not exist.\n     */\n    delete(key, value) {\n        if (value === undefined) {\n            return this.map.delete(key);\n        }\n        else {\n            const values = this.map.get(key);\n            if (values) {\n                const index = values.indexOf(value);\n                if (index >= 0) {\n                    if (values.length === 1) {\n                        this.map.delete(key);\n                    }\n                    else {\n                        values.splice(index, 1);\n                    }\n                    return true;\n                }\n            }\n            return false;\n        }\n    }\n    /**\n     * Returns an array of all values associated with the given key. If no value exists,\n     * an empty array is returned.\n     *\n     * _Note:_ The returned array is assumed not to be modified. Use the `set` method to add a\n     * value and `delete` to remove a value from the multimap.\n     */\n    get(key) {\n        return this.map.get(key) ?? [];\n    }\n    /**\n     * Returns a stream of all values associated with the given key. If no value exists,\n     * {@link EMPTY_STREAM} is returned.\n     */\n    getStream(key) {\n        const values = this.map.get(key);\n        return values ? stream(values) : EMPTY_STREAM;\n    }\n    /**\n     * Operates differently depending on whether a `value` is given:\n     *  * With a value, this method returns `true` if the specific key / value pair is present in the multimap.\n     *  * Without a value, this method returns `true` if the given key is present in the multimap.\n     */\n    has(key, value) {\n        if (value === undefined) {\n            return this.map.has(key);\n        }\n        else {\n            const values = this.map.get(key);\n            if (values) {\n                return values.indexOf(value) >= 0;\n            }\n            return false;\n        }\n    }\n    /**\n     * Add the given key / value pair to the multimap.\n     */\n    add(key, value) {\n        if (this.map.has(key)) {\n            this.map.get(key).push(value);\n        }\n        else {\n            this.map.set(key, [value]);\n        }\n        return this;\n    }\n    /**\n     * Add the given set of key / value pairs to the multimap.\n     */\n    addAll(key, values) {\n        if (this.map.has(key)) {\n            this.map.get(key).push(...values);\n        }\n        else {\n            this.map.set(key, Array.from(values));\n        }\n        return this;\n    }\n    /**\n     * Invokes the given callback function for every key / value pair in the multimap.\n     */\n    forEach(callbackfn) {\n        this.map.forEach((array, key) => array.forEach(value => callbackfn(value, key, this)));\n    }\n    /**\n     * Returns an iterator of key, value pairs for every entry in the map.\n     */\n    [Symbol.iterator]() {\n        return this.entries().iterator();\n    }\n    /**\n     * Returns a stream of key, value pairs for every entry in the map.\n     */\n    entries() {\n        return stream(this.map.entries())\n            .flatMap(([key, array]) => array.map(value => [key, value]));\n    }\n    /**\n     * Returns a stream of keys in the map.\n     */\n    keys() {\n        return stream(this.map.keys());\n    }\n    /**\n     * Returns a stream of values in the map.\n     */\n    values() {\n        return stream(this.map.values()).flat();\n    }\n    /**\n     * Returns a stream of key, value set pairs for every key in the map.\n     */\n    entriesGroupedByKey() {\n        return stream(this.map.entries());\n    }\n}\nexport class BiMap {\n    get size() {\n        return this.map.size;\n    }\n    constructor(elements) {\n        this.map = new Map();\n        this.inverse = new Map();\n        if (elements) {\n            for (const [key, value] of elements) {\n                this.set(key, value);\n            }\n        }\n    }\n    clear() {\n        this.map.clear();\n        this.inverse.clear();\n    }\n    set(key, value) {\n        this.map.set(key, value);\n        this.inverse.set(value, key);\n        return this;\n    }\n    get(key) {\n        return this.map.get(key);\n    }\n    getKey(value) {\n        return this.inverse.get(value);\n    }\n    delete(key) {\n        const value = this.map.get(key);\n        if (value !== undefined) {\n            this.map.delete(key);\n            this.inverse.delete(value);\n            return true;\n        }\n        return false;\n    }\n}\n//# sourceMappingURL=collections.js.map"],"x_google_ignoreList":[0],"mappings":";;AASA,IAAa,IAAb,MAAsB;CAClB,YAAY,GAAU;EAElB,IADA,KAAK,sBAAM,IAAI,KAAK,EAChB,GACA,KAAK,IAAM,CAAC,GAAK,MAAU,GACvB,KAAK,IAAI,GAAK,EAAM;;CAOhC,IAAI,OAAO;EACP,OAAO,EAAU,IAAI,EAAO,KAAK,IAAI,QAAQ,CAAC,CAAC,KAAI,MAAK,EAAE,OAAO,CAAC;;CAKtE,QAAQ;EACJ,KAAK,IAAI,OAAO;;CAUpB,OAAO,GAAK,GAAO;EACf,IAAI,MAAU,KAAA,GACV,OAAO,KAAK,IAAI,OAAO,EAAI;EAE1B;GACD,IAAM,IAAS,KAAK,IAAI,IAAI,EAAI;GAChC,IAAI,GAAQ;IACR,IAAM,IAAQ,EAAO,QAAQ,EAAM;IACnC,IAAI,KAAS,GAOT,OANI,EAAO,WAAW,IAClB,KAAK,IAAI,OAAO,EAAI,GAGpB,EAAO,OAAO,GAAO,EAAE,EAEpB;;GAGf,OAAO;;;CAUf,IAAI,GAAK;EACL,OAAO,KAAK,IAAI,IAAI,EAAI,IAAI,EAAE;;CAMlC,UAAU,GAAK;EACX,IAAM,IAAS,KAAK,IAAI,IAAI,EAAI;EAChC,OAAO,IAAS,EAAO,EAAO,GAAG;;CAOrC,IAAI,GAAK,GAAO;EACZ,IAAI,MAAU,KAAA,GACV,OAAO,KAAK,IAAI,IAAI,EAAI;EAEvB;GACD,IAAM,IAAS,KAAK,IAAI,IAAI,EAAI;GAIhC,OAHI,IACO,EAAO,QAAQ,EAAM,IAAI,IAE7B;;;CAMf,IAAI,GAAK,GAAO;EAOZ,OANI,KAAK,IAAI,IAAI,EAAI,GACjB,KAAK,IAAI,IAAI,EAAI,CAAC,KAAK,EAAM,GAG7B,KAAK,IAAI,IAAI,GAAK,CAAC,EAAM,CAAC,EAEvB;;CAKX,OAAO,GAAK,GAAQ;EAOhB,OANI,KAAK,IAAI,IAAI,EAAI,GACjB,KAAK,IAAI,IAAI,EAAI,CAAC,KAAK,GAAG,EAAO,GAGjC,KAAK,IAAI,IAAI,GAAK,MAAM,KAAK,EAAO,CAAC,EAElC;;CAKX,QAAQ,GAAY;EAChB,KAAK,IAAI,SAAS,GAAO,MAAQ,EAAM,SAAQ,MAAS,EAAW,GAAO,GAAK,KAAK,CAAC,CAAC;;CAK1F,CAAC,OAAO,YAAY;EAChB,OAAO,KAAK,SAAS,CAAC,UAAU;;CAKpC,UAAU;EACN,OAAO,EAAO,KAAK,IAAI,SAAS,CAAC,CAC5B,SAAS,CAAC,GAAK,OAAW,EAAM,KAAI,MAAS,CAAC,GAAK,EAAM,CAAC,CAAC;;CAKpE,OAAO;EACH,OAAO,EAAO,KAAK,IAAI,MAAM,CAAC;;CAKlC,SAAS;EACL,OAAO,EAAO,KAAK,IAAI,QAAQ,CAAC,CAAC,MAAM;;CAK3C,sBAAsB;EAClB,OAAO,EAAO,KAAK,IAAI,SAAS,CAAC;;GAG5B,IAAb,MAAmB;CACf,IAAI,OAAO;EACP,OAAO,KAAK,IAAI;;CAEpB,YAAY,GAAU;EAGlB,IAFA,KAAK,sBAAM,IAAI,KAAK,EACpB,KAAK,0BAAU,IAAI,KAAK,EACpB,GACA,KAAK,IAAM,CAAC,GAAK,MAAU,GACvB,KAAK,IAAI,GAAK,EAAM;;CAIhC,QAAQ;EAEJ,AADA,KAAK,IAAI,OAAO,EAChB,KAAK,QAAQ,OAAO;;CAExB,IAAI,GAAK,GAAO;EAGZ,OAFA,KAAK,IAAI,IAAI,GAAK,EAAM,EACxB,KAAK,QAAQ,IAAI,GAAO,EAAI,EACrB;;CAEX,IAAI,GAAK;EACL,OAAO,KAAK,IAAI,IAAI,EAAI;;CAE5B,OAAO,GAAO;EACV,OAAO,KAAK,QAAQ,IAAI,EAAM;;CAElC,OAAO,GAAK;EACR,IAAM,IAAQ,KAAK,IAAI,IAAI,EAAI;EAM/B,OALI,MAAU,KAAA,IAKP,MAJH,KAAK,IAAI,OAAO,EAAI,EACpB,KAAK,QAAQ,OAAO,EAAM,EACnB"}

package/lib/esm/node_modules/langium/lib/utils/cst-utils.js

@@ -1,77 +0,0 @@
-import { isCompositeCstNode as e, isLeafCstNode as t, isRootCstNode as n } from "../syntax-tree.js";
-import { TreeStreamImpl as r } from "./stream.js";
-//#region ../../node_modules/langium/lib/utils/cst-utils.js
-function i(t) {
-	return new r(t, (t) => e(t) ? t.content : [], { includeRoot: !0 });
-}
-function a(e, t) {
-	for (; e.container;) if (e = e.container, e === t) return !0;
-	return !1;
-}
-function o(e) {
-	return {
-		start: {
-			character: e.startColumn - 1,
-			line: e.startLine - 1
-		},
-		end: {
-			character: e.endColumn,
-			line: e.endLine - 1
-		}
-	};
-}
-function s(e) {
-	if (!e) return;
-	let { offset: t, end: n, range: r } = e;
-	return {
-		range: r,
-		offset: t,
-		end: n,
-		length: n - t
-	};
-}
-var c;
-(function(e) {
-	e[e.Before = 0] = "Before", e[e.After = 1] = "After", e[e.OverlapFront = 2] = "OverlapFront", e[e.OverlapBack = 3] = "OverlapBack", e[e.Inside = 4] = "Inside", e[e.Outside = 5] = "Outside";
-})(c ||= {});
-function l(e, t) {
-	if (e.end.line < t.start.line || e.end.line === t.start.line && e.end.character <= t.start.character) return c.Before;
-	if (e.start.line > t.end.line || e.start.line === t.end.line && e.start.character >= t.end.character) return c.After;
-	let n = e.start.line > t.start.line || e.start.line === t.start.line && e.start.character >= t.start.character, r = e.end.line < t.end.line || e.end.line === t.end.line && e.end.character <= t.end.character;
-	return n && r ? c.Inside : n ? c.OverlapBack : r ? c.OverlapFront : c.Outside;
-}
-function u(e, t) {
-	return l(e, t) > c.After;
-}
-var d = /^[\w\p{L}]$/u;
-function f(e, t) {
-	if (e) {
-		let r = m(e, !0);
-		if (r && p(r, t)) return r;
-		if (n(e)) {
-			let n = e.content.findIndex((e) => !e.hidden);
-			for (let r = n - 1; r >= 0; r--) {
-				let n = e.content[r];
-				if (p(n, t)) return n;
-			}
-		}
-	}
-}
-function p(e, n) {
-	return t(e) && n.includes(e.tokenType.name);
-}
-function m(e, t = !0) {
-	for (; e.container;) {
-		let n = e.container, r = n.content.indexOf(e);
-		for (; r > 0;) {
-			r--;
-			let e = n.content[r];
-			if (t || !e.hidden) return e;
-		}
-		e = n;
-	}
-}
-//#endregion
-export { d as DefaultNameRegexp, f as findCommentNode, u as inRange, a as isChildNode, i as streamCst, s as toDocumentSegment, o as tokenToRange };
-
-//# sourceMappingURL=cst-utils.js.map

package/lib/esm/node_modules/langium/lib/utils/cst-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cst-utils.js","names":[],"sources":["../../../../../../../../node_modules/langium/lib/utils/cst-utils.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { isCompositeCstNode, isLeafCstNode, isRootCstNode } from '../syntax-tree.js';\nimport { TreeStreamImpl } from './stream.js';\nimport { getContainerOfType } from './ast-utils.js';\nimport { isParserRule } from '../languages/generated/ast.js';\n/**\n * Attempts to find the CST node that belongs to the datatype element that contains the given CST node.\n *\n * @param cstNode The CST node for which to find the datatype node.\n * @returns The CST node corresponding to the datatype element, or the undefined if no such element exists.\n */\nexport function getDatatypeNode(cstNode) {\n    let current = cstNode;\n    let found = false;\n    while (current) {\n        const definingRule = getContainerOfType(current.grammarSource, isParserRule);\n        if (definingRule && definingRule.dataType) {\n            // Go up the chain. This element might be part of a larger datatype rule\n            current = current.container;\n            found = true;\n        }\n        else if (found) {\n            // The last datatype node is the one we are looking for\n            return current;\n        }\n        else {\n            // We haven't found any datatype node yet and we've reached a non-datatype rule\n            return undefined;\n        }\n    }\n    return undefined;\n}\n/**\n * Create a stream of all CST nodes that are directly and indirectly contained in the given root node,\n * including the root node itself.\n */\nexport function streamCst(node) {\n    return new TreeStreamImpl(node, element => {\n        if (isCompositeCstNode(element)) {\n            return element.content;\n        }\n        else {\n            return [];\n        }\n    }, { includeRoot: true });\n}\n/**\n * Create a stream of all leaf nodes that are directly and indirectly contained in the given root node.\n */\nexport function flattenCst(node) {\n    return streamCst(node).filter(isLeafCstNode);\n}\n/**\n * Determines whether the specified cst node is a child of the specified parent node.\n */\nexport function isChildNode(child, parent) {\n    while (child.container) {\n        child = child.container;\n        if (child === parent) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function tokenToRange(token) {\n    // Chevrotain uses 1-based indices everywhere\n    // So we subtract 1 from every value to align with the LSP\n    return {\n        start: {\n            character: token.startColumn - 1,\n            line: token.startLine - 1\n        },\n        end: {\n            character: token.endColumn, // endColumn uses the correct index\n            line: token.endLine - 1\n        }\n    };\n}\nexport function toDocumentSegment(node) {\n    if (!node) {\n        return undefined;\n    }\n    const { offset, end, range } = node;\n    return {\n        range,\n        offset,\n        end,\n        length: end - offset\n    };\n}\nexport var RangeComparison;\n(function (RangeComparison) {\n    RangeComparison[RangeComparison[\"Before\"] = 0] = \"Before\";\n    RangeComparison[RangeComparison[\"After\"] = 1] = \"After\";\n    RangeComparison[RangeComparison[\"OverlapFront\"] = 2] = \"OverlapFront\";\n    RangeComparison[RangeComparison[\"OverlapBack\"] = 3] = \"OverlapBack\";\n    RangeComparison[RangeComparison[\"Inside\"] = 4] = \"Inside\";\n    RangeComparison[RangeComparison[\"Outside\"] = 5] = \"Outside\";\n})(RangeComparison || (RangeComparison = {}));\nexport function compareRange(range, to) {\n    if (range.end.line < to.start.line || (range.end.line === to.start.line && range.end.character <= to.start.character)) {\n        return RangeComparison.Before;\n    }\n    else if (range.start.line > to.end.line || (range.start.line === to.end.line && range.start.character >= to.end.character)) {\n        return RangeComparison.After;\n    }\n    const startInside = range.start.line > to.start.line || (range.start.line === to.start.line && range.start.character >= to.start.character);\n    const endInside = range.end.line < to.end.line || (range.end.line === to.end.line && range.end.character <= to.end.character);\n    if (startInside && endInside) {\n        return RangeComparison.Inside;\n    }\n    else if (startInside) {\n        return RangeComparison.OverlapBack;\n    }\n    else if (endInside) {\n        return RangeComparison.OverlapFront;\n    }\n    else {\n        return RangeComparison.Outside;\n    }\n}\nexport function inRange(range, to) {\n    const comparison = compareRange(range, to);\n    return comparison > RangeComparison.After;\n}\n// The \\p{L} regex matches any unicode letter character, i.e. characters from non-english alphabets\n// Together with \\w it matches any kind of character which can commonly appear in IDs\nexport const DefaultNameRegexp = /^[\\w\\p{L}]$/u;\n/**\n * Performs `findLeafNodeAtOffset` with a minor difference: When encountering a character that matches the `nameRegexp` argument,\n * it will instead return the leaf node at the `offset - 1` position.\n *\n * For LSP services, users expect that the declaration of an element is available if the cursor is directly after the element.\n */\nexport function findDeclarationNodeAtOffset(cstNode, offset, nameRegexp = DefaultNameRegexp) {\n    if (cstNode) {\n        if (offset > 0) {\n            const localOffset = offset - cstNode.offset;\n            const textAtOffset = cstNode.text.charAt(localOffset);\n            if (!nameRegexp.test(textAtOffset)) {\n                offset--;\n            }\n        }\n        return findLeafNodeAtOffset(cstNode, offset);\n    }\n    return undefined;\n}\nexport function findCommentNode(cstNode, commentNames) {\n    if (cstNode) {\n        const previous = getPreviousNode(cstNode, true);\n        if (previous && isCommentNode(previous, commentNames)) {\n            return previous;\n        }\n        if (isRootCstNode(cstNode)) {\n            // Go from the first non-hidden node through all nodes in reverse order\n            // We do this to find the comment node which directly precedes the root node\n            const endIndex = cstNode.content.findIndex(e => !e.hidden);\n            for (let i = endIndex - 1; i >= 0; i--) {\n                const child = cstNode.content[i];\n                if (isCommentNode(child, commentNames)) {\n                    return child;\n                }\n            }\n        }\n    }\n    return undefined;\n}\nexport function isCommentNode(cstNode, commentNames) {\n    return isLeafCstNode(cstNode) && commentNames.includes(cstNode.tokenType.name);\n}\n/**\n * Finds the leaf CST node at the specified 0-based string offset.\n * Note that the given offset will be within the range of the returned leaf node.\n *\n * If the offset does not point to a CST node (but just white space), this method will return `undefined`.\n *\n * @param node The CST node to search through.\n * @param offset The specified offset.\n * @returns The CST node at the specified offset.\n */\nexport function findLeafNodeAtOffset(node, offset) {\n    if (isLeafCstNode(node)) {\n        return node;\n    }\n    else if (isCompositeCstNode(node)) {\n        const searchResult = binarySearch(node, offset, false);\n        if (searchResult) {\n            return findLeafNodeAtOffset(searchResult, offset);\n        }\n    }\n    return undefined;\n}\n/**\n * Finds the leaf CST node at the specified 0-based string offset.\n * If no CST node exists at the specified position, it will return the leaf node before it.\n *\n * If there is no leaf node before the specified offset, this method will return `undefined`.\n *\n * @param node The CST node to search through.\n * @param offset The specified offset.\n * @returns The CST node closest to the specified offset.\n */\nexport function findLeafNodeBeforeOffset(node, offset) {\n    if (isLeafCstNode(node)) {\n        return node;\n    }\n    else if (isCompositeCstNode(node)) {\n        const searchResult = binarySearch(node, offset, true);\n        if (searchResult) {\n            return findLeafNodeBeforeOffset(searchResult, offset);\n        }\n    }\n    return undefined;\n}\nfunction binarySearch(node, offset, closest) {\n    let left = 0;\n    let right = node.content.length - 1;\n    let closestNode = undefined;\n    while (left <= right) {\n        const middle = Math.floor((left + right) / 2);\n        const middleNode = node.content[middle];\n        if (middleNode.offset <= offset && middleNode.end > offset) {\n            // Found an exact match\n            return middleNode;\n        }\n        if (middleNode.end <= offset) {\n            // Update the closest node (less than offset) and move to the right half\n            closestNode = closest ? middleNode : undefined;\n            left = middle + 1;\n        }\n        else {\n            // Move to the left half\n            right = middle - 1;\n        }\n    }\n    return closestNode;\n}\nexport function getPreviousNode(node, hidden = true) {\n    while (node.container) {\n        const parent = node.container;\n        let index = parent.content.indexOf(node);\n        while (index > 0) {\n            index--;\n            const previous = parent.content[index];\n            if (hidden || !previous.hidden) {\n                return previous;\n            }\n        }\n        node = parent;\n    }\n    return undefined;\n}\nexport function getNextNode(node, hidden = true) {\n    while (node.container) {\n        const parent = node.container;\n        let index = parent.content.indexOf(node);\n        const last = parent.content.length - 1;\n        while (index < last) {\n            index++;\n            const next = parent.content[index];\n            if (hidden || !next.hidden) {\n                return next;\n            }\n        }\n        node = parent;\n    }\n    return undefined;\n}\nexport function getStartlineNode(node) {\n    if (node.range.start.character === 0) {\n        return node;\n    }\n    const line = node.range.start.line;\n    let last = node;\n    let index;\n    while (node.container) {\n        const parent = node.container;\n        const selfIndex = index ?? parent.content.indexOf(node);\n        if (selfIndex === 0) {\n            node = parent;\n            index = undefined;\n        }\n        else {\n            index = selfIndex - 1;\n            node = parent.content[index];\n        }\n        if (node.range.start.line !== line) {\n            break;\n        }\n        last = node;\n    }\n    return last;\n}\nexport function getInteriorNodes(start, end) {\n    const commonParent = getCommonParent(start, end);\n    if (!commonParent) {\n        return [];\n    }\n    return commonParent.parent.content.slice(commonParent.a + 1, commonParent.b);\n}\nfunction getCommonParent(a, b) {\n    const aParents = getParentChain(a);\n    const bParents = getParentChain(b);\n    let current;\n    for (let i = 0; i < aParents.length && i < bParents.length; i++) {\n        const aParent = aParents[i];\n        const bParent = bParents[i];\n        if (aParent.parent === bParent.parent) {\n            current = {\n                parent: aParent.parent,\n                a: aParent.index,\n                b: bParent.index\n            };\n        }\n        else {\n            break;\n        }\n    }\n    return current;\n}\nfunction getParentChain(node) {\n    const chain = [];\n    while (node.container) {\n        const parent = node.container;\n        const index = parent.content.indexOf(node);\n        chain.push({\n            parent,\n            index\n        });\n        node = parent;\n    }\n    return chain.reverse();\n}\n//# sourceMappingURL=cst-utils.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAwCA,SAAgB,EAAU,GAAM;CAC5B,OAAO,IAAI,EAAe,IAAM,MACxB,EAAmB,EAAQ,GACpB,EAAQ,UAGR,EAAE,EAEd,EAAE,aAAa,IAAM,CAAC;;AAW7B,SAAgB,EAAY,GAAO,GAAQ;CACvC,OAAO,EAAM,YAET,IADA,IAAQ,EAAM,WACV,MAAU,GACV,OAAO;CAGf,OAAO;;AAEX,SAAgB,EAAa,GAAO;CAGhC,OAAO;EACH,OAAO;GACH,WAAW,EAAM,cAAc;GAC/B,MAAM,EAAM,YAAY;GAC3B;EACD,KAAK;GACD,WAAW,EAAM;GACjB,MAAM,EAAM,UAAU;GACzB;EACJ;;AAEL,SAAgB,EAAkB,GAAM;CACpC,IAAI,CAAC,GACD;CAEJ,IAAM,EAAE,WAAQ,QAAK,aAAU;CAC/B,OAAO;EACH;EACA;EACA;EACA,QAAQ,IAAM;EACjB;;AAEL,IAAW;CACV,SAAU,GAAiB;CAMxB,AALA,EAAgB,EAAgB,SAAY,KAAK,UACjD,EAAgB,EAAgB,QAAW,KAAK,SAChD,EAAgB,EAAgB,eAAkB,KAAK,gBACvD,EAAgB,EAAgB,cAAiB,KAAK,eACtD,EAAgB,EAAgB,SAAY,KAAK,UACjD,EAAgB,EAAgB,UAAa,KAAK;GACnD,AAAoB,MAAkB,EAAE,CAAE;AAC7C,SAAgB,EAAa,GAAO,GAAI;CACpC,IAAI,EAAM,IAAI,OAAO,EAAG,MAAM,QAAS,EAAM,IAAI,SAAS,EAAG,MAAM,QAAQ,EAAM,IAAI,aAAa,EAAG,MAAM,WACvG,OAAO,EAAgB;CAEtB,IAAI,EAAM,MAAM,OAAO,EAAG,IAAI,QAAS,EAAM,MAAM,SAAS,EAAG,IAAI,QAAQ,EAAM,MAAM,aAAa,EAAG,IAAI,WAC5G,OAAO,EAAgB;CAE3B,IAAM,IAAc,EAAM,MAAM,OAAO,EAAG,MAAM,QAAS,EAAM,MAAM,SAAS,EAAG,MAAM,QAAQ,EAAM,MAAM,aAAa,EAAG,MAAM,WAC3H,IAAY,EAAM,IAAI,OAAO,EAAG,IAAI,QAAS,EAAM,IAAI,SAAS,EAAG,IAAI,QAAQ,EAAM,IAAI,aAAa,EAAG,IAAI;CAW/G,OAVA,KAAe,IACR,EAAgB,SAElB,IACE,EAAgB,cAElB,IACE,EAAgB,eAGhB,EAAgB;;AAG/B,SAAgB,EAAQ,GAAO,GAAI;CAE/B,OADmB,EAAa,GAAO,EACtB,GAAG,EAAgB;;AAIxC,IAAa,IAAoB;AAoBjC,SAAgB,EAAgB,GAAS,GAAc;CACnD,IAAI,GAAS;EACT,IAAM,IAAW,EAAgB,GAAS,GAAK;EAC/C,IAAI,KAAY,EAAc,GAAU,EAAa,EACjD,OAAO;EAEX,IAAI,EAAc,EAAQ,EAAE;GAGxB,IAAM,IAAW,EAAQ,QAAQ,WAAU,MAAK,CAAC,EAAE,OAAO;GAC1D,KAAK,IAAI,IAAI,IAAW,GAAG,KAAK,GAAG,KAAK;IACpC,IAAM,IAAQ,EAAQ,QAAQ;IAC9B,IAAI,EAAc,GAAO,EAAa,EAClC,OAAO;;;;;AAO3B,SAAgB,EAAc,GAAS,GAAc;CACjD,OAAO,EAAc,EAAQ,IAAI,EAAa,SAAS,EAAQ,UAAU,KAAK;;AAqElF,SAAgB,EAAgB,GAAM,IAAS,IAAM;CACjD,OAAO,EAAK,YAAW;EACnB,IAAM,IAAS,EAAK,WAChB,IAAQ,EAAO,QAAQ,QAAQ,EAAK;EACxC,OAAO,IAAQ,IAAG;GACd;GACA,IAAM,IAAW,EAAO,QAAQ;GAChC,IAAI,KAAU,CAAC,EAAS,QACpB,OAAO;;EAGf,IAAO"}

package/lib/esm/node_modules/langium/lib/utils/disposable.js

@@ -1,12 +0,0 @@
-//#region ../../node_modules/langium/lib/utils/disposable.js
-var e;
-(function(e) {
-	function t(e) {
-		return { dispose: async () => await e() };
-	}
-	e.create = t;
-})(e ||= {});
-//#endregion
-export { e as Disposable };
-
-//# sourceMappingURL=disposable.js.map

package/lib/esm/node_modules/langium/lib/utils/disposable.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"disposable.js","names":[],"sources":["../../../../../../../../node_modules/langium/lib/utils/disposable.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport var Disposable;\n(function (Disposable) {\n    function create(callback) {\n        return {\n            dispose: async () => await callback()\n        };\n    }\n    Disposable.create = create;\n})(Disposable || (Disposable = {}));\n//# sourceMappingURL=disposable.js.map"],"x_google_ignoreList":[0],"mappings":";AAKA,IAAW;CACV,SAAU,GAAY;CACnB,SAAS,EAAO,GAAU;EACtB,OAAO,EACH,SAAS,YAAY,MAAM,GAAU,EACxC;;CAEL,EAAW,SAAS;GACrB,AAAe,MAAa,EAAE,CAAE"}

package/lib/esm/node_modules/langium/lib/utils/errors.js

@@ -1,13 +0,0 @@
-//#region ../../node_modules/langium/lib/utils/errors.js
-var e = class extends Error {
-	constructor(e, t) {
-		super(e ? `${t} at ${e.range.start.line}:${e.range.start.character}` : t);
-	}
-};
-function t(e, t = "Error: Got unexpected value.") {
-	throw Error(t);
-}
-//#endregion
-export { e as ErrorWithLocation, t as assertUnreachable };
-
-//# sourceMappingURL=errors.js.map

package/lib/esm/node_modules/langium/lib/utils/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.js","names":[],"sources":["../../../../../../../../node_modules/langium/lib/utils/errors.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport class ErrorWithLocation extends Error {\n    constructor(node, message) {\n        super(node ? `${message} at ${node.range.start.line}:${node.range.start.character}` : message);\n    }\n}\nexport function assertUnreachable(_, message = 'Error: Got unexpected value.') {\n    throw new Error(message);\n}\nexport function assertCondition(condition, message = 'Error: Condition is violated.') {\n    if (!condition) {\n        throw new Error(message);\n    }\n}\n//# sourceMappingURL=errors.js.map"],"x_google_ignoreList":[0],"mappings":";AAKA,IAAa,IAAb,cAAuC,MAAM;CACzC,YAAY,GAAM,GAAS;EACvB,MAAM,IAAO,GAAG,EAAQ,MAAM,EAAK,MAAM,MAAM,KAAK,GAAG,EAAK,MAAM,MAAM,cAAc,EAAQ;;;AAGtG,SAAgB,EAAkB,GAAG,IAAU,gCAAgC;CAC3E,MAAU,MAAM,EAAQ"}

package/lib/esm/node_modules/langium/lib/utils/event.js

@@ -1,9 +0,0 @@
-import { __exportAll as e, __reExport as t, __toESM as n } from "../../../../_virtual/_rolldown/runtime.js";
-import { require_events as r } from "../../../vscode-jsonrpc/lib/common/events.js";
-//#region ../../node_modules/langium/lib/utils/event.js
-var i = /* @__PURE__ */ e({});
-t(i, /* @__PURE__ */ n(r(), 1));
-//#endregion
-export { i as event_exports };
-
-//# sourceMappingURL=event.js.map

package/lib/esm/node_modules/langium/lib/utils/event.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"event.js","names":[],"sources":["../../../../../../../../node_modules/langium/lib/utils/event.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2024 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\n// eslint-disable-next-line no-restricted-imports\nexport * from 'vscode-jsonrpc/lib/common/events.js';\n//# sourceMappingURL=event.js.map"],"x_google_ignoreList":[0],"mappings":""}

package/lib/esm/node_modules/langium/lib/utils/grammar-loader.js

@@ -1,26 +0,0 @@
-import { LangiumGrammarAstReflection as e } from "../languages/generated/ast.js";
-import { URI as t } from "../../../vscode-uri/lib/esm/index.js";
-import { createDefaultCoreModule as n, createDefaultSharedCoreModule as r } from "../default-module.js";
-import { inject as i } from "../dependency-injection.js";
-import { EmptyFileSystem as a } from "../workspace/file-system-provider.js";
-//#region ../../node_modules/langium/lib/utils/grammar-loader.js
-var o = {
-	Grammar: () => void 0,
-	LanguageMetaData: () => ({
-		caseInsensitive: !1,
-		fileExtensions: [".langium"],
-		languageId: "langium"
-	})
-}, s = { AstReflection: () => new e() };
-function c() {
-	let e = i(r(a), s), t = i(n({ shared: e }), o);
-	return e.ServiceRegistry.register(t), t;
-}
-function l(e) {
-	let n = c(), r = n.serializer.JsonSerializer.deserialize(e);
-	return n.shared.workspace.LangiumDocumentFactory.fromModel(r, t.parse(`memory:/${r.name ?? "grammar"}.langium`)), r;
-}
-//#endregion
-export { l as loadGrammarFromJson };
-
-//# sourceMappingURL=grammar-loader.js.map

package/lib/esm/node_modules/langium/lib/utils/grammar-loader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"grammar-loader.js","names":["ast.LangiumGrammarAstReflection"],"sources":["../../../../../../../../node_modules/langium/lib/utils/grammar-loader.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { createDefaultCoreModule, createDefaultSharedCoreModule } from '../default-module.js';\nimport { inject } from '../dependency-injection.js';\nimport * as ast from '../languages/generated/ast.js';\nimport { EmptyFileSystem } from '../workspace/file-system-provider.js';\nimport { URI } from './uri-utils.js';\nconst minimalGrammarModule = {\n    Grammar: () => undefined,\n    LanguageMetaData: () => ({\n        caseInsensitive: false,\n        fileExtensions: ['.langium'],\n        languageId: 'langium'\n    })\n};\nconst minimalSharedGrammarModule = {\n    AstReflection: () => new ast.LangiumGrammarAstReflection()\n};\nfunction createMinimalGrammarServices() {\n    const shared = inject(createDefaultSharedCoreModule(EmptyFileSystem), minimalSharedGrammarModule);\n    const grammar = inject(createDefaultCoreModule({ shared }), minimalGrammarModule);\n    shared.ServiceRegistry.register(grammar);\n    return grammar;\n}\n/**\n * Load a Langium grammar for your language from a JSON string. This is used by several services,\n * most notably the parser builder which interprets the grammar to create a parser.\n */\nexport function loadGrammarFromJson(json) {\n    const services = createMinimalGrammarServices();\n    const astNode = services.serializer.JsonSerializer.deserialize(json);\n    services.shared.workspace.LangiumDocumentFactory.fromModel(astNode, URI.parse(`memory:/${astNode.name ?? 'grammar'}.langium`));\n    return astNode;\n}\n//# sourceMappingURL=grammar-loader.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;AAUA,IAAM,IAAuB;CACzB,eAAe,KAAA;CACf,yBAAyB;EACrB,iBAAiB;EACjB,gBAAgB,CAAC,WAAW;EAC5B,YAAY;EACf;CACJ,EACK,IAA6B,EAC/B,qBAAqB,IAAIA,GAAiC,EAC7D;AACD,SAAS,IAA+B;CACpC,IAAM,IAAS,EAAO,EAA8B,EAAgB,EAAE,EAA2B,EAC3F,IAAU,EAAO,EAAwB,EAAE,WAAQ,CAAC,EAAE,EAAqB;CAEjF,OADA,EAAO,gBAAgB,SAAS,EAAQ,EACjC;;AAMX,SAAgB,EAAoB,GAAM;CACtC,IAAM,IAAW,GAA8B,EACzC,IAAU,EAAS,WAAW,eAAe,YAAY,EAAK;CAEpE,OADA,EAAS,OAAO,UAAU,uBAAuB,UAAU,GAAS,EAAI,MAAM,WAAW,EAAQ,QAAQ,UAAU,UAAU,CAAC,EACvH"}

package/lib/esm/node_modules/langium/lib/utils/grammar-utils.js

@@ -1,221 +0,0 @@
-import { isCompositeCstNode as e } from "../syntax-tree.js";
-import { getContainerOfType as t, streamAllContents as n } from "./ast-utils.js";
-import { isAbstractParserRule as r, isAction as i, isAssignment as a, isCharacterRange as o, isInferredType as s, isInfixRule as c, isInterface as l, isKeyword as u, isNegatedToken as ee, isParserRule as d, isRegexToken as f, isReturnType as p, isRuleCall as m, isSimpleType as h, isTerminalAlternatives as g, isTerminalGroup as _, isTerminalRule as v, isTerminalRuleCall as y, isType as b, isUntilToken as x, isWildcard as S } from "../languages/generated/ast.js";
-import { streamCst as C } from "./cst-utils.js";
-import { assertUnreachable as w } from "./errors.js";
-import { escapeRegExp as T, isWhitespace as te } from "./regexp-utils.js";
-//#region ../../node_modules/langium/lib/utils/grammar-utils.js
-function E(e) {
-	return e.rules.find((e) => d(e) && e.entry);
-}
-function D(e) {
-	return e.rules.filter((e) => v(e) && e.hidden);
-}
-function O(e, t) {
-	let n = /* @__PURE__ */ new Set(), r = E(e);
-	if (!r) return new Set(e.rules);
-	let i = [r].concat(D(e));
-	for (let e of i) k(e, n, t);
-	let a = /* @__PURE__ */ new Set();
-	for (let t of e.rules) (n.has(t.name) || v(t) && t.hidden) && a.add(t);
-	return a;
-}
-function k(e, t, r) {
-	t.add(e.name), n(e).forEach((e) => {
-		if (m(e) || r && y(e)) {
-			let n = e.rule.ref;
-			n && !t.has(n.name) && k(n, t, r);
-		}
-	});
-}
-function A(e) {
-	if (e.terminal) return e.terminal;
-	if (e.type.ref) return R(e.type.ref)?.terminal;
-}
-function j(e) {
-	return e.hidden && !te(K(e));
-}
-function M(e, t) {
-	return !e || !t ? [] : P(e, t, e.astNode, !0);
-}
-function N(e, t, n) {
-	if (!e || !t) return;
-	let r = P(e, t, e.astNode, !0);
-	if (r.length !== 0) return n = n === void 0 ? 0 : Math.max(0, Math.min(n, r.length - 1)), r[n];
-}
-function P(n, r, i, o) {
-	if (!o) {
-		let e = t(n.grammarSource, a);
-		if (e && e.feature === r) return [n];
-	}
-	return e(n) && n.astNode === i ? n.content.flatMap((e) => P(e, r, i, !1)) : [];
-}
-function F(e, t, n) {
-	if (!e) return;
-	let r = I(e, t, e?.astNode);
-	if (r.length !== 0) return n = n === void 0 ? 0 : Math.max(0, Math.min(n, r.length - 1)), r[n];
-}
-function I(e, t, n) {
-	if (e.astNode !== n) return [];
-	if (u(e.grammarSource) && e.grammarSource.value === t) return [e];
-	let r = C(e).iterator(), i, a = [];
-	do
-		if (i = r.next(), !i.done) {
-			let e = i.value;
-			e.astNode === n ? u(e.grammarSource) && e.grammarSource.value === t && a.push(e) : r.prune();
-		}
-	while (!i.done);
-	return a;
-}
-function L(e) {
-	let n = e.astNode;
-	for (; n === e.container?.astNode;) {
-		let n = t(e.grammarSource, a);
-		if (n) return n;
-		e = e.container;
-	}
-}
-function R(e) {
-	let t = e;
-	return s(t) && (i(t.$container) ? t = t.$container.$container : r(t.$container) ? t = t.$container : w(t.$container)), z(e, t, /* @__PURE__ */ new Map());
-}
-function z(e, r, i) {
-	function o(n, r) {
-		let o;
-		return t(n, a) || (o = z(r, r, i)), i.set(e, o), o;
-	}
-	if (i.has(e)) return i.get(e);
-	i.set(e, void 0);
-	for (let t of n(r)) if (a(t) && t.feature.toLowerCase() === "name") return i.set(e, t), t;
-	else if (m(t) && d(t.rule.ref)) return o(t, t.rule.ref);
-	else if (h(t) && t.typeRef?.ref) return o(t, t.typeRef.ref);
-}
-function B(e) {
-	return V(e, /* @__PURE__ */ new Set());
-}
-function V(e, t) {
-	if (t.has(e)) return !0;
-	t.add(e);
-	for (let r of n(e)) if (m(r)) {
-		if (!r.rule.ref || d(r.rule.ref) && !V(r.rule.ref, t) || c(r.rule.ref)) return !1;
-	} else if (a(r)) return !1;
-	else if (i(r)) return !1;
-	return !!e.definition;
-}
-function H(e) {
-	if (!v(e)) {
-		if (e.inferredType) return e.inferredType.name;
-		if (e.dataType) return e.dataType;
-		if (e.returnType) {
-			let t = e.returnType.ref;
-			if (t) return t.name;
-		}
-	}
-}
-function U(e) {
-	if (r(e)) return d(e) && B(e) ? e.name : H(e) ?? e.name;
-	if (l(e) || b(e) || p(e)) return e.name;
-	if (i(e)) {
-		let t = W(e);
-		if (t) return t;
-	} else if (s(e)) return e.name;
-	throw Error("Cannot get name of Unknown Type");
-}
-function W(e) {
-	if (e.inferredType) return e.inferredType.name;
-	if (e.type?.ref) return U(e.type.ref);
-}
-function G(e) {
-	return v(e) ? e.type?.name ?? "string" : H(e) ?? e.name;
-}
-function K(e) {
-	let t = {
-		s: !1,
-		i: !1,
-		u: !1
-	}, n = J(e.definition, t), r = Object.entries(t).filter(([, e]) => e).map(([e]) => e).join("");
-	return new RegExp(n, r);
-}
-var q = "[\\s\\S]";
-function J(e, t) {
-	if (g(e)) return Y(e);
-	if (_(e)) return X(e);
-	if (o(e)) return re(e);
-	if (y(e)) {
-		let t = e.rule.ref;
-		if (!t) throw Error("Missing rule reference.");
-		return $(J(t.definition), {
-			cardinality: e.cardinality,
-			lookahead: e.lookahead,
-			parenthesized: e.parenthesized
-		});
-	} else if (ee(e)) return ne(e);
-	else if (x(e)) return Z(e);
-	else if (f(e)) {
-		let n = e.regex.lastIndexOf("/"), r = e.regex.substring(1, n), i = e.regex.substring(n + 1);
-		return t && (t.i = i.includes("i"), t.s = i.includes("s"), t.u = i.includes("u")), $(r, {
-			cardinality: e.cardinality,
-			lookahead: e.lookahead,
-			parenthesized: e.parenthesized,
-			wrap: !1
-		});
-	} else if (S(e)) return $(q, {
-		cardinality: e.cardinality,
-		lookahead: e.lookahead,
-		parenthesized: e.parenthesized
-	});
-	else throw Error(`Invalid terminal element: ${e?.$type}, ${e?.$cstNode?.text}`);
-}
-function Y(e) {
-	return $(e.elements.map((e) => J(e)).join("|"), {
-		cardinality: e.cardinality,
-		lookahead: e.lookahead,
-		parenthesized: e.parenthesized,
-		wrap: !1
-	});
-}
-function X(e) {
-	return $(e.elements.map((e) => J(e)).join(""), {
-		cardinality: e.cardinality,
-		lookahead: e.lookahead,
-		parenthesized: e.parenthesized,
-		wrap: !1
-	});
-}
-function Z(e) {
-	return $(`${q}*?${J(e.terminal)}`, {
-		cardinality: e.cardinality,
-		lookahead: e.lookahead,
-		parenthesized: e.parenthesized
-	});
-}
-function ne(e) {
-	return $(`(?!${J(e.terminal)})${q}*?`, {
-		cardinality: e.cardinality,
-		lookahead: e.lookahead,
-		parenthesized: e.parenthesized
-	});
-}
-function re(e) {
-	return e.right ? $(`[${Q(e.left)}-${Q(e.right)}]`, {
-		cardinality: e.cardinality,
-		lookahead: e.lookahead,
-		parenthesized: e.parenthesized,
-		wrap: !1
-	}) : $(Q(e.left), {
-		cardinality: e.cardinality,
-		lookahead: e.lookahead,
-		parenthesized: e.parenthesized,
-		wrap: !1
-	});
-}
-function Q(e) {
-	return T(e.value);
-}
-function $(e, t) {
-	return (t.parenthesized || t.lookahead || t.wrap !== !1) && (e = `(${t.lookahead ?? (t.parenthesized ? "" : "?:")}${e})`), t.cardinality ? `${e}${t.cardinality}` : e;
-}
-//#endregion
-export { L as findAssignment, R as findNameAssignment, F as findNodeForKeyword, N as findNodeForProperty, M as findNodesForProperty, O as getAllReachableRules, A as getCrossReferenceTerminal, G as getRuleType, U as getTypeName, j as isCommentTerminal, B as isDataTypeRule, K as terminalRegex };
-
-//# sourceMappingURL=grammar-utils.js.map