@elmethis/core 1.0.0-alpha.149 → 1.0.0-alpha.150

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/document-builder.mjs

@@ -1,328 +0,0 @@
-import { Disposable } from "../utils/disposable.mjs";
-import { MultiMap } from "../utils/collections.mjs";
-import { interruptAndCheck, OperationCancelled, isOperationCancelled } from "../utils/promise-utils.mjs";
-import { stream } from "../utils/stream.mjs";
-import { ValidationCategory } from "../validation/validation-registry.mjs";
-import { DocumentState } from "./documents.mjs";
-import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
-class DefaultDocumentBuilder {
-  constructor(services) {
-    this.updateBuildOptions = {
-      // Default: run only the built-in validation checks and those in the _fast_ category (includes those without category)
-      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 = services.workspace.LangiumDocuments;
-    this.langiumDocumentFactory = services.workspace.LangiumDocumentFactory;
-    this.textDocuments = services.workspace.TextDocuments;
-    this.indexManager = services.workspace.IndexManager;
-    this.serviceRegistry = services.ServiceRegistry;
-  }
-  async build(documents, options = {}, cancelToken = cancellationExports.CancellationToken.None) {
-    var _a, _b;
-    for (const document of documents) {
-      const key = document.uri.toString();
-      if (document.state === DocumentState.Validated) {
-        if (typeof options.validation === "boolean" && options.validation) {
-          document.state = DocumentState.IndexedReferences;
-          document.diagnostics = void 0;
-          this.buildState.delete(key);
-        } else if (typeof options.validation === "object") {
-          const buildState = this.buildState.get(key);
-          const previousCategories = (_a = buildState === null || buildState === void 0 ? void 0 : buildState.result) === null || _a === void 0 ? void 0 : _a.validationChecks;
-          if (previousCategories) {
-            const newCategories = (_b = options.validation.categories) !== null && _b !== void 0 ? _b : ValidationCategory.all;
-            const categories = newCategories.filter((c) => !previousCategories.includes(c));
-            if (categories.length > 0) {
-              this.buildState.set(key, {
-                completed: false,
-                options: {
-                  validation: Object.assign(Object.assign({}, options.validation), { categories })
-                },
-                result: buildState.result
-              });
-              document.state = DocumentState.IndexedReferences;
-            }
-          }
-        }
-      } else {
-        this.buildState.delete(key);
-      }
-    }
-    this.currentState = DocumentState.Changed;
-    await this.emitUpdate(documents.map((e) => e.uri), []);
-    await this.buildDocuments(documents, options, cancelToken);
-  }
-  async update(changed, deleted, cancelToken = cancellationExports.CancellationToken.None) {
-    this.currentState = DocumentState.Changed;
-    for (const deletedUri of deleted) {
-      this.langiumDocuments.deleteDocument(deletedUri);
-      this.buildState.delete(deletedUri.toString());
-      this.indexManager.remove(deletedUri);
-    }
-    for (const changedUri of changed) {
-      const invalidated = this.langiumDocuments.invalidateDocument(changedUri);
-      if (!invalidated) {
-        const newDocument = this.langiumDocumentFactory.fromModel({ $type: "INVALID" }, changedUri);
-        newDocument.state = DocumentState.Changed;
-        this.langiumDocuments.addDocument(newDocument);
-      }
-      this.buildState.delete(changedUri.toString());
-    }
-    const allChangedUris = stream(changed).concat(deleted).map((uri) => uri.toString()).toSet();
-    this.langiumDocuments.all.filter((doc) => !allChangedUris.has(doc.uri.toString()) && this.shouldRelink(doc, allChangedUris)).forEach((doc) => {
-      const linker = this.serviceRegistry.getServices(doc.uri).references.Linker;
-      linker.unlink(doc);
-      doc.state = Math.min(doc.state, DocumentState.ComputedScopes);
-      doc.diagnostics = void 0;
-    });
-    await this.emitUpdate(changed, deleted);
-    await interruptAndCheck(cancelToken);
-    const rebuildDocuments = this.sortDocuments(this.langiumDocuments.all.filter((doc) => {
-      var _a;
-      return doc.state < DocumentState.Linked || !((_a = this.buildState.get(doc.uri.toString())) === null || _a === void 0 ? void 0 : _a.completed);
-    }).toArray());
-    await this.buildDocuments(rebuildDocuments, this.updateBuildOptions, cancelToken);
-  }
-  async emitUpdate(changed, deleted) {
-    await Promise.all(this.updateListeners.map((listener) => listener(changed, deleted)));
-  }
-  /**
-   * Sort the given documents by priority. By default, documents with an open text document are prioritized.
-   * This is useful to ensure that visible documents show their diagnostics before all other documents.
-   *
-   * This improves the responsiveness in large workspaces as users usually don't care about diagnostics
-   * in files that are currently not opened in the editor.
-   */
-  sortDocuments(documents) {
-    let left = 0;
-    let right = documents.length - 1;
-    while (left < right) {
-      while (left < documents.length && this.hasTextDocument(documents[left])) {
-        left++;
-      }
-      while (right >= 0 && !this.hasTextDocument(documents[right])) {
-        right--;
-      }
-      if (left < right) {
-        [documents[left], documents[right]] = [documents[right], documents[left]];
-      }
-    }
-    return documents;
-  }
-  hasTextDocument(doc) {
-    var _a;
-    return Boolean((_a = this.textDocuments) === null || _a === void 0 ? void 0 : _a.get(doc.uri));
-  }
-  /**
-   * Check whether the given document should be relinked after changes were found in the given URIs.
-   */
-  shouldRelink(document, changedUris) {
-    if (document.references.some((ref) => ref.error !== void 0)) {
-      return true;
-    }
-    return this.indexManager.isAffected(document, changedUris);
-  }
-  onUpdate(callback) {
-    this.updateListeners.push(callback);
-    return Disposable.create(() => {
-      const index = this.updateListeners.indexOf(callback);
-      if (index >= 0) {
-        this.updateListeners.splice(index, 1);
-      }
-    });
-  }
-  /**
-   * Build the given documents by stepping through all build phases. If a document's state indicates
-   * that a certain build phase is already done, the phase is skipped for that document.
-   *
-   * @param documents The documents to build.
-   * @param options the {@link BuildOptions} to use.
-   * @param cancelToken A cancellation token that can be used to cancel the build.
-   * @returns A promise that resolves when the build is done.
-   */
-  async buildDocuments(documents, options, cancelToken) {
-    this.prepareBuild(documents, options);
-    await this.runCancelable(documents, DocumentState.Parsed, cancelToken, (doc) => this.langiumDocumentFactory.update(doc, cancelToken));
-    await this.runCancelable(documents, DocumentState.IndexedContent, cancelToken, (doc) => this.indexManager.updateContent(doc, cancelToken));
-    await this.runCancelable(documents, DocumentState.ComputedScopes, cancelToken, async (doc) => {
-      const scopeComputation = this.serviceRegistry.getServices(doc.uri).references.ScopeComputation;
-      doc.precomputedScopes = await scopeComputation.computeLocalScopes(doc, cancelToken);
-    });
-    await this.runCancelable(documents, DocumentState.Linked, cancelToken, (doc) => {
-      const linker = this.serviceRegistry.getServices(doc.uri).references.Linker;
-      return linker.link(doc, cancelToken);
-    });
-    await this.runCancelable(documents, DocumentState.IndexedReferences, cancelToken, (doc) => this.indexManager.updateReferences(doc, cancelToken));
-    const toBeValidated = documents.filter((doc) => this.shouldValidate(doc));
-    await this.runCancelable(toBeValidated, DocumentState.Validated, cancelToken, (doc) => this.validate(doc, cancelToken));
-    for (const doc of documents) {
-      const state = this.buildState.get(doc.uri.toString());
-      if (state) {
-        state.completed = true;
-      }
-    }
-  }
-  /**
-   * Runs prior to beginning the build process to update the {@link DocumentBuildState} for each document
-   *
-   * @param documents collection of documents to be built
-   * @param options the {@link BuildOptions} to use
-   */
-  prepareBuild(documents, options) {
-    for (const doc of documents) {
-      const key = doc.uri.toString();
-      const state = this.buildState.get(key);
-      if (!state || state.completed) {
-        this.buildState.set(key, {
-          completed: false,
-          options,
-          result: state === null || state === void 0 ? void 0 : state.result
-        });
-      }
-    }
-  }
-  /**
-   * Runs a cancelable operation on a set of documents to bring them to a specified {@link DocumentState}.
-   *
-   * @param documents The array of documents to process.
-   * @param targetState The target {@link DocumentState} to bring the documents to.
-   * @param cancelToken A token that can be used to cancel the operation.
-   * @param callback A function to be called for each document.
-   * @returns A promise that resolves when all documents have been processed or the operation is canceled.
-   * @throws Will throw `OperationCancelled` if the operation is canceled via a `CancellationToken`.
-   */
-  async runCancelable(documents, targetState, cancelToken, callback) {
-    const filtered = documents.filter((doc) => doc.state < targetState);
-    for (const document of filtered) {
-      await interruptAndCheck(cancelToken);
-      await callback(document);
-      document.state = targetState;
-      await this.notifyDocumentPhase(document, targetState, cancelToken);
-    }
-    const targetStateDocs = documents.filter((doc) => doc.state === targetState);
-    await this.notifyBuildPhase(targetStateDocs, targetState, cancelToken);
-    this.currentState = targetState;
-  }
-  onBuildPhase(targetState, callback) {
-    this.buildPhaseListeners.add(targetState, callback);
-    return Disposable.create(() => {
-      this.buildPhaseListeners.delete(targetState, callback);
-    });
-  }
-  onDocumentPhase(targetState, callback) {
-    this.documentPhaseListeners.add(targetState, callback);
-    return Disposable.create(() => {
-      this.documentPhaseListeners.delete(targetState, callback);
-    });
-  }
-  waitUntil(state, uriOrToken, cancelToken) {
-    let uri = void 0;
-    if (uriOrToken && "path" in uriOrToken) {
-      uri = uriOrToken;
-    } else {
-      cancelToken = uriOrToken;
-    }
-    cancelToken !== null && cancelToken !== void 0 ? cancelToken : cancelToken = cancellationExports.CancellationToken.None;
-    if (uri) {
-      const document = this.langiumDocuments.getDocument(uri);
-      if (document && document.state > state) {
-        return Promise.resolve(uri);
-      }
-    }
-    if (this.currentState >= state) {
-      return Promise.resolve(void 0);
-    } else if (cancelToken.isCancellationRequested) {
-      return Promise.reject(OperationCancelled);
-    }
-    return new Promise((resolve, reject) => {
-      const buildDisposable = this.onBuildPhase(state, () => {
-        buildDisposable.dispose();
-        cancelDisposable.dispose();
-        if (uri) {
-          const document = this.langiumDocuments.getDocument(uri);
-          resolve(document === null || document === void 0 ? void 0 : document.uri);
-        } else {
-          resolve(void 0);
-        }
-      });
-      const cancelDisposable = cancelToken.onCancellationRequested(() => {
-        buildDisposable.dispose();
-        cancelDisposable.dispose();
-        reject(OperationCancelled);
-      });
-    });
-  }
-  async notifyDocumentPhase(document, state, cancelToken) {
-    const listeners = this.documentPhaseListeners.get(state);
-    const listenersCopy = listeners.slice();
-    for (const listener of listenersCopy) {
-      try {
-        await listener(document, cancelToken);
-      } catch (err) {
-        if (!isOperationCancelled(err)) {
-          throw err;
-        }
-      }
-    }
-  }
-  async notifyBuildPhase(documents, state, cancelToken) {
-    if (documents.length === 0) {
-      return;
-    }
-    const listeners = this.buildPhaseListeners.get(state);
-    const listenersCopy = listeners.slice();
-    for (const listener of listenersCopy) {
-      await interruptAndCheck(cancelToken);
-      await listener(documents, cancelToken);
-    }
-  }
-  /**
-   * Determine whether the given document should be validated during a build. The default
-   * implementation checks the `validation` property of the build options. If it's set to `true`
-   * or a `ValidationOptions` object, the document is included in the validation phase.
-   */
-  shouldValidate(document) {
-    return Boolean(this.getBuildOptions(document).validation);
-  }
-  /**
-   * Run validation checks on the given document and store the resulting diagnostics in the document.
-   * If the document already contains diagnostics, the new ones are added to the list.
-   */
-  async validate(document, cancelToken) {
-    var _a, _b;
-    const validator = this.serviceRegistry.getServices(document.uri).validation.DocumentValidator;
-    const validationSetting = this.getBuildOptions(document).validation;
-    const options = typeof validationSetting === "object" ? validationSetting : void 0;
-    const diagnostics = await validator.validateDocument(document, options, cancelToken);
-    if (document.diagnostics) {
-      document.diagnostics.push(...diagnostics);
-    } else {
-      document.diagnostics = diagnostics;
-    }
-    const state = this.buildState.get(document.uri.toString());
-    if (state) {
-      (_a = state.result) !== null && _a !== void 0 ? _a : state.result = {};
-      const newCategories = (_b = options === null || options === void 0 ? void 0 : options.categories) !== null && _b !== void 0 ? _b : ValidationCategory.all;
-      if (state.result.validationChecks) {
-        state.result.validationChecks.push(...newCategories);
-      } else {
-        state.result.validationChecks = [...newCategories];
-      }
-    }
-  }
-  getBuildOptions(document) {
-    var _a, _b;
-    return (_b = (_a = this.buildState.get(document.uri.toString())) === null || _a === void 0 ? void 0 : _a.options) !== null && _b !== void 0 ? _b : {};
-  }
-}
-export {
-  DefaultDocumentBuilder
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/documents.mjs

@@ -1,210 +0,0 @@
-import { TextDocument } from "../../../../../vscode-languageserver-textdocument@1.0.12/node_modules/vscode-languageserver-textdocument/lib/esm/main.mjs";
-import { stream } from "../utils/stream.mjs";
-import "../utils/uri-utils.mjs";
-import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
-import { URI } from "../../../../../vscode-uri@3.0.8/node_modules/vscode-uri/lib/esm/index.mjs";
-var DocumentState;
-(function(DocumentState2) {
-  DocumentState2[DocumentState2["Changed"] = 0] = "Changed";
-  DocumentState2[DocumentState2["Parsed"] = 1] = "Parsed";
-  DocumentState2[DocumentState2["IndexedContent"] = 2] = "IndexedContent";
-  DocumentState2[DocumentState2["ComputedScopes"] = 3] = "ComputedScopes";
-  DocumentState2[DocumentState2["Linked"] = 4] = "Linked";
-  DocumentState2[DocumentState2["IndexedReferences"] = 5] = "IndexedReferences";
-  DocumentState2[DocumentState2["Validated"] = 6] = "Validated";
-})(DocumentState || (DocumentState = {}));
-class DefaultLangiumDocumentFactory {
-  constructor(services) {
-    this.serviceRegistry = services.ServiceRegistry;
-    this.textDocuments = services.workspace.TextDocuments;
-    this.fileSystemProvider = services.workspace.FileSystemProvider;
-  }
-  async fromUri(uri, cancellationToken = cancellationExports.CancellationToken.None) {
-    const content = await this.fileSystemProvider.readFile(uri);
-    return this.createAsync(uri, content, cancellationToken);
-  }
-  fromTextDocument(textDocument, uri, token) {
-    uri = uri !== null && uri !== void 0 ? uri : URI.parse(textDocument.uri);
-    if (cancellationExports.CancellationToken.is(token)) {
-      return this.createAsync(uri, textDocument, token);
-    } else {
-      return this.create(uri, textDocument, token);
-    }
-  }
-  fromString(text, uri, token) {
-    if (cancellationExports.CancellationToken.is(token)) {
-      return this.createAsync(uri, text, token);
-    } else {
-      return this.create(uri, text, token);
-    }
-  }
-  fromModel(model, uri) {
-    return this.create(uri, { $model: model });
-  }
-  create(uri, content, options) {
-    if (typeof content === "string") {
-      const parseResult = this.parse(uri, content, options);
-      return this.createLangiumDocument(parseResult, uri, void 0, content);
-    } else if ("$model" in content) {
-      const parseResult = { value: content.$model, parserErrors: [], lexerErrors: [] };
-      return this.createLangiumDocument(parseResult, uri);
-    } else {
-      const parseResult = this.parse(uri, content.getText(), options);
-      return this.createLangiumDocument(parseResult, uri, content);
-    }
-  }
-  async createAsync(uri, content, cancelToken) {
-    if (typeof content === "string") {
-      const parseResult = await this.parseAsync(uri, content, cancelToken);
-      return this.createLangiumDocument(parseResult, uri, void 0, content);
-    } else {
-      const parseResult = await this.parseAsync(uri, content.getText(), cancelToken);
-      return this.createLangiumDocument(parseResult, uri, content);
-    }
-  }
-  /**
-   * Create a LangiumDocument from a given parse result.
-   *
-   * A TextDocument is created on demand if it is not provided as argument here. Usually this
-   * should not be necessary because the main purpose of the TextDocument is to convert between
-   * text ranges and offsets, which is done solely in LSP request handling.
-   *
-   * With the introduction of {@link update} below this method is supposed to be mainly called
-   * during workspace initialization and on addition/recognition of new files, while changes in
-   * existing documents are processed via {@link update}.
-   */
-  createLangiumDocument(parseResult, uri, textDocument, text) {
-    let document;
-    if (textDocument) {
-      document = {
-        parseResult,
-        uri,
-        state: DocumentState.Parsed,
-        references: [],
-        textDocument
-      };
-    } else {
-      const textDocumentGetter = this.createTextDocumentGetter(uri, text);
-      document = {
-        parseResult,
-        uri,
-        state: DocumentState.Parsed,
-        references: [],
-        get textDocument() {
-          return textDocumentGetter();
-        }
-      };
-    }
-    parseResult.value.$document = document;
-    return document;
-  }
-  async update(document, cancellationToken) {
-    var _a, _b;
-    const oldText = (_a = document.parseResult.value.$cstNode) === null || _a === void 0 ? void 0 : _a.root.fullText;
-    const textDocument = (_b = this.textDocuments) === null || _b === void 0 ? void 0 : _b.get(document.uri.toString());
-    const text = textDocument ? textDocument.getText() : await this.fileSystemProvider.readFile(document.uri);
-    if (textDocument) {
-      Object.defineProperty(document, "textDocument", {
-        value: textDocument
-      });
-    } else {
-      const textDocumentGetter = this.createTextDocumentGetter(document.uri, text);
-      Object.defineProperty(document, "textDocument", {
-        get: textDocumentGetter
-      });
-    }
-    if (oldText !== text) {
-      document.parseResult = await this.parseAsync(document.uri, text, cancellationToken);
-      document.parseResult.value.$document = document;
-    }
-    document.state = DocumentState.Parsed;
-    return document;
-  }
-  parse(uri, text, options) {
-    const services = this.serviceRegistry.getServices(uri);
-    return services.parser.LangiumParser.parse(text, options);
-  }
-  parseAsync(uri, text, cancellationToken) {
-    const services = this.serviceRegistry.getServices(uri);
-    return services.parser.AsyncParser.parse(text, cancellationToken);
-  }
-  createTextDocumentGetter(uri, text) {
-    const serviceRegistry = this.serviceRegistry;
-    let textDoc = void 0;
-    return () => {
-      return textDoc !== null && textDoc !== void 0 ? textDoc : textDoc = TextDocument.create(uri.toString(), serviceRegistry.getServices(uri).LanguageMetaData.languageId, 0, text !== null && text !== void 0 ? text : "");
-    };
-  }
-}
-class DefaultLangiumDocuments {
-  constructor(services) {
-    this.documentMap = /* @__PURE__ */ new Map();
-    this.langiumDocumentFactory = services.workspace.LangiumDocumentFactory;
-    this.serviceRegistry = services.ServiceRegistry;
-  }
-  get all() {
-    return stream(this.documentMap.values());
-  }
-  addDocument(document) {
-    const uriString = document.uri.toString();
-    if (this.documentMap.has(uriString)) {
-      throw new Error(`A document with the URI '${uriString}' is already present.`);
-    }
-    this.documentMap.set(uriString, document);
-  }
-  getDocument(uri) {
-    const uriString = uri.toString();
-    return this.documentMap.get(uriString);
-  }
-  async getOrCreateDocument(uri, cancellationToken) {
-    let document = this.getDocument(uri);
-    if (document) {
-      return document;
-    }
-    document = await this.langiumDocumentFactory.fromUri(uri, cancellationToken);
-    this.addDocument(document);
-    return document;
-  }
-  createDocument(uri, text, cancellationToken) {
-    if (cancellationToken) {
-      return this.langiumDocumentFactory.fromString(text, uri, cancellationToken).then((document) => {
-        this.addDocument(document);
-        return document;
-      });
-    } else {
-      const document = this.langiumDocumentFactory.fromString(text, uri);
-      this.addDocument(document);
-      return document;
-    }
-  }
-  hasDocument(uri) {
-    return this.documentMap.has(uri.toString());
-  }
-  invalidateDocument(uri) {
-    const uriString = uri.toString();
-    const langiumDoc = this.documentMap.get(uriString);
-    if (langiumDoc) {
-      const linker = this.serviceRegistry.getServices(uri).references.Linker;
-      linker.unlink(langiumDoc);
-      langiumDoc.state = DocumentState.Changed;
-      langiumDoc.precomputedScopes = void 0;
-      langiumDoc.diagnostics = void 0;
-    }
-    return langiumDoc;
-  }
-  deleteDocument(uri) {
-    const uriString = uri.toString();
-    const langiumDoc = this.documentMap.get(uriString);
-    if (langiumDoc) {
-      langiumDoc.state = DocumentState.Changed;
-      this.documentMap.delete(uriString);
-    }
-    return langiumDoc;
-  }
-}
-export {
-  DefaultLangiumDocumentFactory,
-  DefaultLangiumDocuments,
-  DocumentState,
-  TextDocument
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/file-system-provider.mjs

@@ -1,15 +0,0 @@
-class EmptyFileSystemProvider {
-  readFile() {
-    throw new Error("No file system is available.");
-  }
-  async readDirectory() {
-    return [];
-  }
-}
-const EmptyFileSystem = {
-  fileSystemProvider: () => new EmptyFileSystemProvider()
-};
-export {
-  EmptyFileSystem,
-  EmptyFileSystemProvider
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/index-manager.mjs

@@ -1,74 +0,0 @@
-import { getDocument } from "../utils/ast-utils.mjs";
-import { ContextCache } from "../utils/caching.mjs";
-import { stream } from "../utils/stream.mjs";
-import { UriUtils } from "../utils/uri-utils.mjs";
-import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
-class DefaultIndexManager {
-  constructor(services) {
-    this.symbolIndex = /* @__PURE__ */ new Map();
-    this.symbolByTypeIndex = new ContextCache();
-    this.referenceIndex = /* @__PURE__ */ new Map();
-    this.documents = services.workspace.LangiumDocuments;
-    this.serviceRegistry = services.ServiceRegistry;
-    this.astReflection = services.AstReflection;
-  }
-  findAllReferences(targetNode, astNodePath) {
-    const targetDocUri = getDocument(targetNode).uri;
-    const result = [];
-    this.referenceIndex.forEach((docRefs) => {
-      docRefs.forEach((refDescr) => {
-        if (UriUtils.equals(refDescr.targetUri, targetDocUri) && refDescr.targetPath === astNodePath) {
-          result.push(refDescr);
-        }
-      });
-    });
-    return stream(result);
-  }
-  allElements(nodeType, uris) {
-    let documentUris = stream(this.symbolIndex.keys());
-    if (uris) {
-      documentUris = documentUris.filter((uri) => !uris || uris.has(uri));
-    }
-    return documentUris.map((uri) => this.getFileDescriptions(uri, nodeType)).flat();
-  }
-  getFileDescriptions(uri, nodeType) {
-    var _a;
-    if (!nodeType) {
-      return (_a = this.symbolIndex.get(uri)) !== null && _a !== void 0 ? _a : [];
-    }
-    const descriptions = this.symbolByTypeIndex.get(uri, nodeType, () => {
-      var _a2;
-      const allFileDescriptions = (_a2 = this.symbolIndex.get(uri)) !== null && _a2 !== void 0 ? _a2 : [];
-      return allFileDescriptions.filter((e) => this.astReflection.isSubtype(e.type, nodeType));
-    });
-    return descriptions;
-  }
-  remove(uri) {
-    const uriString = uri.toString();
-    this.symbolIndex.delete(uriString);
-    this.symbolByTypeIndex.clear(uriString);
-    this.referenceIndex.delete(uriString);
-  }
-  async updateContent(document, cancelToken = cancellationExports.CancellationToken.None) {
-    const services = this.serviceRegistry.getServices(document.uri);
-    const exports = await services.references.ScopeComputation.computeExports(document, cancelToken);
-    const uri = document.uri.toString();
-    this.symbolIndex.set(uri, exports);
-    this.symbolByTypeIndex.clear(uri);
-  }
-  async updateReferences(document, cancelToken = cancellationExports.CancellationToken.None) {
-    const services = this.serviceRegistry.getServices(document.uri);
-    const indexData = await services.workspace.ReferenceDescriptionProvider.createDescriptions(document, cancelToken);
-    this.referenceIndex.set(document.uri.toString(), indexData);
-  }
-  isAffected(document, changedUris) {
-    const references = this.referenceIndex.get(document.uri.toString());
-    if (!references) {
-      return false;
-    }
-    return references.some((ref) => !ref.local && changedUris.has(ref.targetUri.toString()));
-  }
-}
-export {
-  DefaultIndexManager
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/workspace-lock.mjs

@@ -1,64 +0,0 @@
-import { startCancelableOperation, Deferred, isOperationCancelled } from "../utils/promise-utils.mjs";
-import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
-class DefaultWorkspaceLock {
-  constructor() {
-    this.previousTokenSource = new cancellationExports.CancellationTokenSource();
-    this.writeQueue = [];
-    this.readQueue = [];
-    this.done = true;
-  }
-  write(action) {
-    this.cancelWrite();
-    const tokenSource = startCancelableOperation();
-    this.previousTokenSource = tokenSource;
-    return this.enqueue(this.writeQueue, action, tokenSource.token);
-  }
-  read(action) {
-    return this.enqueue(this.readQueue, action);
-  }
-  enqueue(queue, action, cancellationToken = cancellationExports.CancellationToken.None) {
-    const deferred = new Deferred();
-    const entry = {
-      action,
-      deferred,
-      cancellationToken
-    };
-    queue.push(entry);
-    this.performNextOperation();
-    return deferred.promise;
-  }
-  async performNextOperation() {
-    if (!this.done) {
-      return;
-    }
-    const entries = [];
-    if (this.writeQueue.length > 0) {
-      entries.push(this.writeQueue.shift());
-    } else if (this.readQueue.length > 0) {
-      entries.push(...this.readQueue.splice(0, this.readQueue.length));
-    } else {
-      return;
-    }
-    this.done = false;
-    await Promise.all(entries.map(async ({ action, deferred, cancellationToken }) => {
-      try {
-        const result = await Promise.resolve().then(() => action(cancellationToken));
-        deferred.resolve(result);
-      } catch (err) {
-        if (isOperationCancelled(err)) {
-          deferred.resolve(void 0);
-        } else {
-          deferred.reject(err);
-        }
-      }
-    }));
-    this.done = true;
-    this.performNextOperation();
-  }
-  cancelWrite() {
-    this.previousTokenSource.cancel();
-  }
-}
-export {
-  DefaultWorkspaceLock
-};