@mintlify/components 0.4.17 → 1.0.0

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

@@ -0,0 +1,230 @@
+import { Disposable as h } from "../utils/disposable.js";
+import { MultiMap as m } from "../utils/collections.js";
+import { interruptAndCheck as c, OperationCancelled as g, isOperationCancelled as b } from "../utils/promise-utils.js";
+import { stream as w } from "../utils/stream.js";
+import { ValidationCategory as v } from "../validation/validation-registry.js";
+import { DocumentState as o } from "./documents.js";
+import { c as f } from "../../../../../../../_virtual/cancellation.js";
+class M {
+  constructor(t) {
+    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 m(), this.documentPhaseListeners = new m(), this.buildState = /* @__PURE__ */ new Map(), this.documentBuildWaiters = /* @__PURE__ */ new Map(), this.currentState = o.Changed, this.langiumDocuments = t.workspace.LangiumDocuments, this.langiumDocumentFactory = t.workspace.LangiumDocumentFactory, this.textDocuments = t.workspace.TextDocuments, this.indexManager = t.workspace.IndexManager, this.serviceRegistry = t.ServiceRegistry;
+  }
+  async build(t, e = {}, i = f.CancellationToken.None) {
+    var r, a;
+    for (const s of t) {
+      const n = s.uri.toString();
+      if (s.state === o.Validated) {
+        if (typeof e.validation == "boolean" && e.validation)
+          s.state = o.IndexedReferences, s.diagnostics = void 0, this.buildState.delete(n);
+        else if (typeof e.validation == "object") {
+          const l = this.buildState.get(n), u = (r = l == null ? void 0 : l.result) === null || r === void 0 ? void 0 : r.validationChecks;
+          if (u) {
+            const p = ((a = e.validation.categories) !== null && a !== void 0 ? a : v.all).filter((D) => !u.includes(D));
+            p.length > 0 && (this.buildState.set(n, {
+              completed: !1,
+              options: {
+                validation: Object.assign(Object.assign({}, e.validation), { categories: p })
+              },
+              result: l.result
+            }), s.state = o.IndexedReferences);
+          }
+        }
+      } else
+        this.buildState.delete(n);
+    }
+    this.currentState = o.Changed, await this.emitUpdate(t.map((s) => s.uri), []), await this.buildDocuments(t, e, i);
+  }
+  async update(t, e, i = f.CancellationToken.None) {
+    this.currentState = o.Changed;
+    for (const s of e)
+      this.langiumDocuments.deleteDocument(s), this.buildState.delete(s.toString()), this.indexManager.remove(s);
+    for (const s of t) {
+      if (!this.langiumDocuments.invalidateDocument(s)) {
+        const l = this.langiumDocumentFactory.fromModel({ $type: "INVALID" }, s);
+        l.state = o.Changed, this.langiumDocuments.addDocument(l);
+      }
+      this.buildState.delete(s.toString());
+    }
+    const r = w(t).concat(e).map((s) => s.toString()).toSet();
+    this.langiumDocuments.all.filter((s) => !r.has(s.uri.toString()) && this.shouldRelink(s, r)).forEach((s) => {
+      this.serviceRegistry.getServices(s.uri).references.Linker.unlink(s), s.state = Math.min(s.state, o.ComputedScopes), s.diagnostics = void 0;
+    }), await this.emitUpdate(t, e), await c(i);
+    const a = this.sortDocuments(this.langiumDocuments.all.filter((s) => {
+      var n;
+      return s.state < o.Linked || !(!((n = this.buildState.get(s.uri.toString())) === null || n === void 0) && n.completed);
+    }).toArray());
+    await this.buildDocuments(a, this.updateBuildOptions, i);
+  }
+  async emitUpdate(t, e) {
+    await Promise.all(this.updateListeners.map((i) => i(t, e)));
+  }
+  /**
+   * 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(t) {
+    let e = 0, i = t.length - 1;
+    for (; e < i; ) {
+      for (; e < t.length && this.hasTextDocument(t[e]); )
+        e++;
+      for (; i >= 0 && !this.hasTextDocument(t[i]); )
+        i--;
+      e < i && ([t[e], t[i]] = [t[i], t[e]]);
+    }
+    return t;
+  }
+  hasTextDocument(t) {
+    var e;
+    return !!(!((e = this.textDocuments) === null || e === void 0) && e.get(t.uri));
+  }
+  /**
+   * Check whether the given document should be relinked after changes were found in the given URIs.
+   */
+  shouldRelink(t, e) {
+    return t.references.some((i) => i.error !== void 0) ? !0 : this.indexManager.isAffected(t, e);
+  }
+  onUpdate(t) {
+    return this.updateListeners.push(t), h.create(() => {
+      const e = this.updateListeners.indexOf(t);
+      e >= 0 && this.updateListeners.splice(e, 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(t, e, i) {
+    this.prepareBuild(t, e), await this.runCancelable(t, o.Parsed, i, (a) => this.langiumDocumentFactory.update(a, i)), await this.runCancelable(t, o.IndexedContent, i, (a) => this.indexManager.updateContent(a, i)), await this.runCancelable(t, o.ComputedScopes, i, async (a) => {
+      const s = this.serviceRegistry.getServices(a.uri).references.ScopeComputation;
+      a.precomputedScopes = await s.computeLocalScopes(a, i);
+    }), await this.runCancelable(t, o.Linked, i, (a) => this.serviceRegistry.getServices(a.uri).references.Linker.link(a, i)), await this.runCancelable(t, o.IndexedReferences, i, (a) => this.indexManager.updateReferences(a, i));
+    const r = t.filter((a) => this.shouldValidate(a));
+    await this.runCancelable(r, o.Validated, i, (a) => this.validate(a, i));
+    for (const a of t) {
+      const s = this.buildState.get(a.uri.toString());
+      s && (s.completed = !0);
+    }
+  }
+  /**
+   * 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(t, e) {
+    for (const i of t) {
+      const r = i.uri.toString(), a = this.buildState.get(r);
+      (!a || a.completed) && this.buildState.set(r, {
+        completed: !1,
+        options: e,
+        result: a == null ? void 0 : a.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(t, e, i, r) {
+    const a = t.filter((n) => n.state < e);
+    for (const n of a)
+      await c(i), await r(n), n.state = e, await this.notifyDocumentPhase(n, e, i);
+    const s = t.filter((n) => n.state === e);
+    await this.notifyBuildPhase(s, e, i), this.currentState = e;
+  }
+  onBuildPhase(t, e) {
+    return this.buildPhaseListeners.add(t, e), h.create(() => {
+      this.buildPhaseListeners.delete(t, e);
+    });
+  }
+  onDocumentPhase(t, e) {
+    return this.documentPhaseListeners.add(t, e), h.create(() => {
+      this.documentPhaseListeners.delete(t, e);
+    });
+  }
+  waitUntil(t, e, i) {
+    let r;
+    if (e && "path" in e ? r = e : i = e, i ?? (i = f.CancellationToken.None), r) {
+      const a = this.langiumDocuments.getDocument(r);
+      if (a && a.state > t)
+        return Promise.resolve(r);
+    }
+    return this.currentState >= t ? Promise.resolve(void 0) : i.isCancellationRequested ? Promise.reject(g) : new Promise((a, s) => {
+      const n = this.onBuildPhase(t, () => {
+        if (n.dispose(), l.dispose(), r) {
+          const u = this.langiumDocuments.getDocument(r);
+          a(u == null ? void 0 : u.uri);
+        } else
+          a(void 0);
+      }), l = i.onCancellationRequested(() => {
+        n.dispose(), l.dispose(), s(g);
+      });
+    });
+  }
+  async notifyDocumentPhase(t, e, i) {
+    const a = this.documentPhaseListeners.get(e).slice();
+    for (const s of a)
+      try {
+        await s(t, i);
+      } catch (n) {
+        if (!b(n))
+          throw n;
+      }
+  }
+  async notifyBuildPhase(t, e, i) {
+    if (t.length === 0)
+      return;
+    const a = this.buildPhaseListeners.get(e).slice();
+    for (const s of a)
+      await c(i), await s(t, i);
+  }
+  /**
+   * 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(t) {
+    return !!this.getBuildOptions(t).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(t, e) {
+    var i, r;
+    const a = this.serviceRegistry.getServices(t.uri).validation.DocumentValidator, s = this.getBuildOptions(t).validation, n = typeof s == "object" ? s : void 0, l = await a.validateDocument(t, n, e);
+    t.diagnostics ? t.diagnostics.push(...l) : t.diagnostics = l;
+    const u = this.buildState.get(t.uri.toString());
+    if (u) {
+      (i = u.result) !== null && i !== void 0 || (u.result = {});
+      const d = (r = n == null ? void 0 : n.categories) !== null && r !== void 0 ? r : v.all;
+      u.result.validationChecks ? u.result.validationChecks.push(...d) : u.result.validationChecks = [...d];
+    }
+  }
+  getBuildOptions(t) {
+    var e, i;
+    return (i = (e = this.buildState.get(t.uri.toString())) === null || e === void 0 ? void 0 : e.options) !== null && i !== void 0 ? i : {};
+  }
+}
+export {
+  M as DefaultDocumentBuilder
+};

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

@@ -0,0 +1,156 @@
+import { TextDocument as l } from "../../../../../vscode-languageserver-textdocument@1.0.12/node_modules/vscode-languageserver-textdocument/lib/esm/main.js";
+import { stream as m } from "../utils/stream.js";
+import "../utils/uri-utils.js";
+import { c as u } from "../../../../../../../_virtual/cancellation.js";
+import { URI as g } from "../../../../../vscode-uri@3.0.8/node_modules/vscode-uri/lib/esm/index.js";
+var n;
+(function(i) {
+  i[i.Changed = 0] = "Changed", i[i.Parsed = 1] = "Parsed", i[i.IndexedContent = 2] = "IndexedContent", i[i.ComputedScopes = 3] = "ComputedScopes", i[i.Linked = 4] = "Linked", i[i.IndexedReferences = 5] = "IndexedReferences", i[i.Validated = 6] = "Validated";
+})(n || (n = {}));
+class D {
+  constructor(e) {
+    this.serviceRegistry = e.ServiceRegistry, this.textDocuments = e.workspace.TextDocuments, this.fileSystemProvider = e.workspace.FileSystemProvider;
+  }
+  async fromUri(e, t = u.CancellationToken.None) {
+    const r = await this.fileSystemProvider.readFile(e);
+    return this.createAsync(e, r, t);
+  }
+  fromTextDocument(e, t, r) {
+    return t = t ?? g.parse(e.uri), u.CancellationToken.is(r) ? this.createAsync(t, e, r) : this.create(t, e, r);
+  }
+  fromString(e, t, r) {
+    return u.CancellationToken.is(r) ? this.createAsync(t, e, r) : this.create(t, e, r);
+  }
+  fromModel(e, t) {
+    return this.create(t, { $model: e });
+  }
+  create(e, t, r) {
+    if (typeof t == "string") {
+      const s = this.parse(e, t, r);
+      return this.createLangiumDocument(s, e, void 0, t);
+    } else if ("$model" in t) {
+      const s = { value: t.$model, parserErrors: [], lexerErrors: [] };
+      return this.createLangiumDocument(s, e);
+    } else {
+      const s = this.parse(e, t.getText(), r);
+      return this.createLangiumDocument(s, e, t);
+    }
+  }
+  async createAsync(e, t, r) {
+    if (typeof t == "string") {
+      const s = await this.parseAsync(e, t, r);
+      return this.createLangiumDocument(s, e, void 0, t);
+    } else {
+      const s = await this.parseAsync(e, t.getText(), r);
+      return this.createLangiumDocument(s, e, t);
+    }
+  }
+  /**
+   * 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(e, t, r, s) {
+    let a;
+    if (r)
+      a = {
+        parseResult: e,
+        uri: t,
+        state: n.Parsed,
+        references: [],
+        textDocument: r
+      };
+    else {
+      const c = this.createTextDocumentGetter(t, s);
+      a = {
+        parseResult: e,
+        uri: t,
+        state: n.Parsed,
+        references: [],
+        get textDocument() {
+          return c();
+        }
+      };
+    }
+    return e.value.$document = a, a;
+  }
+  async update(e, t) {
+    var r, s;
+    const a = (r = e.parseResult.value.$cstNode) === null || r === void 0 ? void 0 : r.root.fullText, c = (s = this.textDocuments) === null || s === void 0 ? void 0 : s.get(e.uri.toString()), o = c ? c.getText() : await this.fileSystemProvider.readFile(e.uri);
+    if (c)
+      Object.defineProperty(e, "textDocument", {
+        value: c
+      });
+    else {
+      const d = this.createTextDocumentGetter(e.uri, o);
+      Object.defineProperty(e, "textDocument", {
+        get: d
+      });
+    }
+    return a !== o && (e.parseResult = await this.parseAsync(e.uri, o, t), e.parseResult.value.$document = e), e.state = n.Parsed, e;
+  }
+  parse(e, t, r) {
+    return this.serviceRegistry.getServices(e).parser.LangiumParser.parse(t, r);
+  }
+  parseAsync(e, t, r) {
+    return this.serviceRegistry.getServices(e).parser.AsyncParser.parse(t, r);
+  }
+  createTextDocumentGetter(e, t) {
+    const r = this.serviceRegistry;
+    let s;
+    return () => s ?? (s = l.create(e.toString(), r.getServices(e).LanguageMetaData.languageId, 0, t ?? ""));
+  }
+}
+class x {
+  constructor(e) {
+    this.documentMap = /* @__PURE__ */ new Map(), this.langiumDocumentFactory = e.workspace.LangiumDocumentFactory, this.serviceRegistry = e.ServiceRegistry;
+  }
+  get all() {
+    return m(this.documentMap.values());
+  }
+  addDocument(e) {
+    const t = e.uri.toString();
+    if (this.documentMap.has(t))
+      throw new Error(`A document with the URI '${t}' is already present.`);
+    this.documentMap.set(t, e);
+  }
+  getDocument(e) {
+    const t = e.toString();
+    return this.documentMap.get(t);
+  }
+  async getOrCreateDocument(e, t) {
+    let r = this.getDocument(e);
+    return r || (r = await this.langiumDocumentFactory.fromUri(e, t), this.addDocument(r), r);
+  }
+  createDocument(e, t, r) {
+    if (r)
+      return this.langiumDocumentFactory.fromString(t, e, r).then((s) => (this.addDocument(s), s));
+    {
+      const s = this.langiumDocumentFactory.fromString(t, e);
+      return this.addDocument(s), s;
+    }
+  }
+  hasDocument(e) {
+    return this.documentMap.has(e.toString());
+  }
+  invalidateDocument(e) {
+    const t = e.toString(), r = this.documentMap.get(t);
+    return r && (this.serviceRegistry.getServices(e).references.Linker.unlink(r), r.state = n.Changed, r.precomputedScopes = void 0, r.diagnostics = void 0), r;
+  }
+  deleteDocument(e) {
+    const t = e.toString(), r = this.documentMap.get(t);
+    return r && (r.state = n.Changed, this.documentMap.delete(t)), r;
+  }
+}
+export {
+  D as DefaultLangiumDocumentFactory,
+  x as DefaultLangiumDocuments,
+  n as DocumentState,
+  l as TextDocument
+};

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

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

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

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

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

@@ -0,0 +1,48 @@
+import { startCancelableOperation as o, Deferred as u, isOperationCancelled as a } from "../utils/promise-utils.js";
+import { c as n } from "../../../../../../../_virtual/cancellation.js";
+class p {
+  constructor() {
+    this.previousTokenSource = new n.CancellationTokenSource(), this.writeQueue = [], this.readQueue = [], this.done = !0;
+  }
+  write(e) {
+    this.cancelWrite();
+    const t = o();
+    return this.previousTokenSource = t, this.enqueue(this.writeQueue, e, t.token);
+  }
+  read(e) {
+    return this.enqueue(this.readQueue, e);
+  }
+  enqueue(e, t, s = n.CancellationToken.None) {
+    const i = new u(), r = {
+      action: t,
+      deferred: i,
+      cancellationToken: s
+    };
+    return e.push(r), this.performNextOperation(), i.promise;
+  }
+  async performNextOperation() {
+    if (!this.done)
+      return;
+    const e = [];
+    if (this.writeQueue.length > 0)
+      e.push(this.writeQueue.shift());
+    else if (this.readQueue.length > 0)
+      e.push(...this.readQueue.splice(0, this.readQueue.length));
+    else
+      return;
+    this.done = !1, await Promise.all(e.map(async ({ action: t, deferred: s, cancellationToken: i }) => {
+      try {
+        const r = await Promise.resolve().then(() => t(i));
+        s.resolve(r);
+      } catch (r) {
+        a(r) ? s.resolve(void 0) : s.reject(r);
+      }
+    })), this.done = !0, this.performNextOperation();
+  }
+  cancelWrite() {
+    this.previousTokenSource.cancel();
+  }
+}
+export {
+  p as DefaultWorkspaceLock
+};

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

@@ -0,0 +1,90 @@
+import { Deferred as l, interruptAndCheck as u } from "../utils/promise-utils.js";
+import { UriUtils as o } from "../utils/uri-utils.js";
+import { c } from "../../../../../../../_virtual/cancellation.js";
+import { URI as d } from "../../../../../vscode-uri@3.0.8/node_modules/vscode-uri/lib/esm/index.js";
+class g {
+  constructor(e) {
+    this.initialBuildOptions = {}, this._ready = new l(), this.serviceRegistry = e.ServiceRegistry, this.langiumDocuments = e.workspace.LangiumDocuments, this.documentBuilder = e.workspace.DocumentBuilder, this.fileSystemProvider = e.workspace.FileSystemProvider, this.mutex = e.workspace.WorkspaceLock;
+  }
+  get ready() {
+    return this._ready.promise;
+  }
+  get workspaceFolders() {
+    return this.folders;
+  }
+  initialize(e) {
+    var i;
+    this.folders = (i = e.workspaceFolders) !== null && i !== void 0 ? i : void 0;
+  }
+  initialized(e) {
+    return this.mutex.write((i) => {
+      var r;
+      return this.initializeWorkspace((r = this.folders) !== null && r !== void 0 ? r : [], i);
+    });
+  }
+  async initializeWorkspace(e, i = c.CancellationToken.None) {
+    const r = await this.performStartup(e);
+    await u(i), await this.documentBuilder.build(r, this.initialBuildOptions, i);
+  }
+  /**
+   * Performs the uninterruptable startup sequence of the workspace manager.
+   * This methods loads all documents in the workspace and other documents and returns them.
+   */
+  async performStartup(e) {
+    const i = this.serviceRegistry.all.flatMap((t) => t.LanguageMetaData.fileExtensions), r = [], s = (t) => {
+      r.push(t), this.langiumDocuments.hasDocument(t.uri) || this.langiumDocuments.addDocument(t);
+    };
+    return await this.loadAdditionalDocuments(e, s), await Promise.all(e.map((t) => [t, this.getRootFolder(t)]).map(async (t) => this.traverseFolder(...t, i, s))), this._ready.resolve(), r;
+  }
+  /**
+   * Load all additional documents that shall be visible in the context of the given workspace
+   * folders and add them to the collector. This can be used to include built-in libraries of
+   * your language, which can be either loaded from provided files or constructed in memory.
+   */
+  loadAdditionalDocuments(e, i) {
+    return Promise.resolve();
+  }
+  /**
+   * Determine the root folder of the source documents in the given workspace folder.
+   * The default implementation returns the URI of the workspace folder, but you can override
+   * this to return a subfolder like `src` instead.
+   */
+  getRootFolder(e) {
+    return d.parse(e.uri);
+  }
+  /**
+   * Traverse the file system folder identified by the given URI and its subfolders. All
+   * contained files that match the file extensions are added to the collector.
+   */
+  async traverseFolder(e, i, r, s) {
+    const t = await this.fileSystemProvider.readDirectory(i);
+    await Promise.all(t.map(async (a) => {
+      if (this.includeEntry(e, a, r)) {
+        if (a.isDirectory)
+          await this.traverseFolder(e, a.uri, r, s);
+        else if (a.isFile) {
+          const n = await this.langiumDocuments.getOrCreateDocument(a.uri);
+          s(n);
+        }
+      }
+    }));
+  }
+  /**
+   * Determine whether the given folder entry shall be included while indexing the workspace.
+   */
+  includeEntry(e, i, r) {
+    const s = o.basename(i.uri);
+    if (s.startsWith("."))
+      return !1;
+    if (i.isDirectory)
+      return s !== "node_modules" && s !== "out";
+    if (i.isFile) {
+      const t = o.extname(i.uri);
+      return r.includes(t);
+    }
+    return !1;
+  }
+}
+export {
+  g as DefaultWorkspaceManager
+};