@mintlify/components 0.4.17 → 1.0.0

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/parser-builder-base.js

@@ -0,0 +1,268 @@
+import { EMPTY_ALT as v } from "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/parser.js";
+import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/lexer_public.js";
+import { EOF as P } from "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens_public.js";
+import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/lookahead.js";
+import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/errors_public.js";
+import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/exceptions_public.js";
+import { isParserRule as T, isKeyword as y, isAction as j, isAssignment as D, isCrossReference as U, isRuleCall as g, isAlternatives as L, isUnorderedGroup as $, isGroup as w, isEndOfFile as M, isTerminalRule as R, isDisjunction as I, isConjunction as S, isNegation as _, isParameterReference as B, isBooleanLiteral as K } from "../languages/generated/ast.js";
+import { ErrorWithLocation as k, assertUnreachable as G } from "../utils/errors.js";
+import { stream as W } from "../utils/stream.js";
+import { getAllReachableRules as Y, getTypeName as N, findNameAssignment as q } from "../utils/grammar-utils.js";
+function de(e, r, s) {
+  return z({
+    parser: r,
+    tokens: s,
+    ruleNames: /* @__PURE__ */ new Map()
+  }, e), r;
+}
+function z(e, r) {
+  const s = Y(r, !1), n = W(r.rules).filter(T).filter((t) => s.has(t));
+  for (const t of n) {
+    const o = Object.assign(Object.assign({}, e), { consume: 1, optional: 1, subrule: 1, many: 1, or: 1 });
+    e.parser.rule(t, c(o, t.definition));
+  }
+}
+function c(e, r, s = !1) {
+  let n;
+  if (y(r))
+    n = x(e, r);
+  else if (j(r))
+    n = H(e, r);
+  else if (D(r))
+    n = c(e, r.terminal);
+  else if (U(r))
+    n = C(e, r);
+  else if (g(r))
+    n = J(e, r);
+  else if (L(r))
+    n = V(e, r);
+  else if ($(r))
+    n = X(e, r);
+  else if (w(r))
+    n = Z(e, r);
+  else if (M(r)) {
+    const t = e.consume++;
+    n = () => e.parser.consume(t, P, r);
+  } else
+    throw new k(r.$cstNode, `Unexpected element type: ${r.$type}`);
+  return F(e, s ? void 0 : E(r), n, r.cardinality);
+}
+function H(e, r) {
+  const s = N(r);
+  return () => e.parser.action(s, r);
+}
+function J(e, r) {
+  const s = r.rule.ref;
+  if (T(s)) {
+    const n = e.subrule++, t = s.fragment, o = r.arguments.length > 0 ? Q(s, r.arguments) : () => ({});
+    return (u) => e.parser.subrule(n, O(e, s), t, r, o(u));
+  } else if (R(s)) {
+    const n = e.consume++, t = h(e, s.name);
+    return () => e.parser.consume(n, t, r);
+  } else if (s)
+    G();
+  else
+    throw new k(r.$cstNode, `Undefined rule: ${r.rule.$refText}`);
+}
+function Q(e, r) {
+  const s = r.map((n) => a(n.value));
+  return (n) => {
+    const t = {};
+    for (let o = 0; o < s.length; o++) {
+      const u = e.parameters[o], i = s[o];
+      t[u.name] = i(n);
+    }
+    return t;
+  };
+}
+function a(e) {
+  if (I(e)) {
+    const r = a(e.left), s = a(e.right);
+    return (n) => r(n) || s(n);
+  } else if (S(e)) {
+    const r = a(e.left), s = a(e.right);
+    return (n) => r(n) && s(n);
+  } else if (_(e)) {
+    const r = a(e.value);
+    return (s) => !r(s);
+  } else if (B(e)) {
+    const r = e.parameter.ref.name;
+    return (s) => s !== void 0 && s[r] === !0;
+  } else if (K(e)) {
+    const r = !!e.true;
+    return () => r;
+  }
+  G();
+}
+function V(e, r) {
+  if (r.elements.length === 1)
+    return c(e, r.elements[0]);
+  {
+    const s = [];
+    for (const t of r.elements) {
+      const o = {
+        // Since we handle the guard condition in the alternative already
+        // We can ignore the group guard condition inside
+        ALT: c(e, t, !0)
+      }, u = E(t);
+      u && (o.GATE = a(u)), s.push(o);
+    }
+    const n = e.or++;
+    return (t) => e.parser.alternatives(n, s.map((o) => {
+      const u = {
+        ALT: () => o.ALT(t)
+      }, i = o.GATE;
+      return i && (u.GATE = () => i(t)), u;
+    }));
+  }
+}
+function X(e, r) {
+  if (r.elements.length === 1)
+    return c(e, r.elements[0]);
+  const s = [];
+  for (const i of r.elements) {
+    const l = {
+      // Since we handle the guard condition in the alternative already
+      // We can ignore the group guard condition inside
+      ALT: c(e, i, !0)
+    }, f = E(i);
+    f && (l.GATE = a(f)), s.push(l);
+  }
+  const n = e.or++, t = (i, l) => {
+    const f = l.getRuleStack().join("-");
+    return `uGroup_${i}_${f}`;
+  }, o = (i) => e.parser.alternatives(n, s.map((l, f) => {
+    const A = { ALT: () => !0 }, d = e.parser;
+    A.ALT = () => {
+      if (l.ALT(i), !d.isRecording()) {
+        const p = t(n, d);
+        d.unorderedGroups.get(p) || d.unorderedGroups.set(p, []);
+        const m = d.unorderedGroups.get(p);
+        typeof (m == null ? void 0 : m[f]) > "u" && (m[f] = !0);
+      }
+    };
+    const b = l.GATE;
+    return b ? A.GATE = () => b(i) : A.GATE = () => {
+      const p = d.unorderedGroups.get(t(n, d));
+      return !(p != null && p[f]);
+    }, A;
+  })), u = F(e, E(r), o, "*");
+  return (i) => {
+    u(i), e.parser.isRecording() || e.parser.unorderedGroups.delete(t(n, e.parser));
+  };
+}
+function Z(e, r) {
+  const s = r.elements.map((n) => c(e, n));
+  return (n) => s.forEach((t) => t(n));
+}
+function E(e) {
+  if (w(e))
+    return e.guardCondition;
+}
+function C(e, r, s = r.terminal) {
+  if (s)
+    if (g(s) && T(s.rule.ref)) {
+      const n = s.rule.ref, t = e.subrule++;
+      return (o) => e.parser.subrule(t, O(e, n), !1, r, o);
+    } else if (g(s) && R(s.rule.ref)) {
+      const n = e.consume++, t = h(e, s.rule.ref.name);
+      return () => e.parser.consume(n, t, r);
+    } else if (y(s)) {
+      const n = e.consume++, t = h(e, s.value);
+      return () => e.parser.consume(n, t, r);
+    } else
+      throw new Error("Could not build cross reference parser");
+  else {
+    if (!r.type.ref)
+      throw new Error("Could not resolve reference to type: " + r.type.$refText);
+    const n = q(r.type.ref), t = n == null ? void 0 : n.terminal;
+    if (!t)
+      throw new Error("Could not find name assignment for type: " + N(r.type.ref));
+    return C(e, r, t);
+  }
+}
+function x(e, r) {
+  const s = e.consume++, n = e.tokens[r.value];
+  if (!n)
+    throw new Error("Could not find token for keyword: " + r.value);
+  return () => e.parser.consume(s, n, r);
+}
+function F(e, r, s, n) {
+  const t = r && a(r);
+  if (!n)
+    if (t) {
+      const o = e.or++;
+      return (u) => e.parser.alternatives(o, [
+        {
+          ALT: () => s(u),
+          GATE: () => t(u)
+        },
+        {
+          ALT: v(),
+          GATE: () => !t(u)
+        }
+      ]);
+    } else
+      return s;
+  if (n === "*") {
+    const o = e.many++;
+    return (u) => e.parser.many(o, {
+      DEF: () => s(u),
+      GATE: t ? () => t(u) : void 0
+    });
+  } else if (n === "+") {
+    const o = e.many++;
+    if (t) {
+      const u = e.or++;
+      return (i) => e.parser.alternatives(u, [
+        {
+          ALT: () => e.parser.atLeastOne(o, {
+            DEF: () => s(i)
+          }),
+          GATE: () => t(i)
+        },
+        {
+          ALT: v(),
+          GATE: () => !t(i)
+        }
+      ]);
+    } else
+      return (u) => e.parser.atLeastOne(o, {
+        DEF: () => s(u)
+      });
+  } else if (n === "?") {
+    const o = e.optional++;
+    return (u) => e.parser.optional(o, {
+      DEF: () => s(u),
+      GATE: t ? () => t(u) : void 0
+    });
+  } else
+    G();
+}
+function O(e, r) {
+  const s = ee(e, r), n = e.parser.getRule(s);
+  if (!n)
+    throw new Error(`Rule "${s}" not found."`);
+  return n;
+}
+function ee(e, r) {
+  if (T(r))
+    return r.name;
+  if (e.ruleNames.has(r))
+    return e.ruleNames.get(r);
+  {
+    let s = r, n = s.$container, t = r.$type;
+    for (; !T(n); )
+      (w(n) || L(n) || $(n)) && (t = n.elements.indexOf(s).toString() + ":" + t), s = n, n = n.$container;
+    return t = n.name + ":" + t, e.ruleNames.set(r, t), t;
+  }
+}
+function h(e, r) {
+  const s = e.tokens[r];
+  if (!s)
+    throw new Error(`Token "${r}" not found."`);
+  return s;
+}
+export {
+  de as createParser
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/token-builder.js

@@ -0,0 +1,71 @@
+import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/parser.js";
+import { Lexer as l } from "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/lexer_public.js";
+import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens_public.js";
+import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/lookahead.js";
+import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/errors_public.js";
+import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/exceptions_public.js";
+import { isTerminalRule as a, isParserRule as c, isKeyword as d } from "../languages/generated/ast.js";
+import { streamAllContents as f } from "../utils/ast-utils.js";
+import { getAllReachableRules as p, terminalRegex as m } from "../utils/grammar-utils.js";
+import { isWhitespace as u, getCaseInsensitivePattern as h, partialMatches as T } from "../utils/regexp-utils.js";
+import { stream as g } from "../utils/stream.js";
+class N {
+  constructor() {
+    this.diagnostics = [];
+  }
+  buildTokens(e, r) {
+    const i = g(p(e, !1)), t = this.buildTerminalTokens(i), n = this.buildKeywordTokens(i, t, r);
+    return t.forEach((o) => {
+      const s = o.PATTERN;
+      typeof s == "object" && s && "test" in s && u(s) ? n.unshift(o) : n.push(o);
+    }), n;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  flushLexingReport(e) {
+    return { diagnostics: this.popDiagnostics() };
+  }
+  popDiagnostics() {
+    const e = [...this.diagnostics];
+    return this.diagnostics = [], e;
+  }
+  buildTerminalTokens(e) {
+    return e.filter(a).filter((r) => !r.fragment).map((r) => this.buildTerminalToken(r)).toArray();
+  }
+  buildTerminalToken(e) {
+    const r = m(e), i = this.requiresCustomPattern(r) ? this.regexPatternFunction(r) : r, t = {
+      name: e.name,
+      PATTERN: i
+    };
+    return typeof i == "function" && (t.LINE_BREAKS = !0), e.hidden && (t.GROUP = u(r) ? l.SKIPPED : "hidden"), t;
+  }
+  requiresCustomPattern(e) {
+    return e.flags.includes("u") || e.flags.includes("s") ? !0 : !!(e.source.includes("?<=") || e.source.includes("?<!"));
+  }
+  regexPatternFunction(e) {
+    const r = new RegExp(e, e.flags + "y");
+    return (i, t) => (r.lastIndex = t, r.exec(i));
+  }
+  buildKeywordTokens(e, r, i) {
+    return e.filter(c).flatMap((t) => f(t).filter(d)).distinct((t) => t.value).toArray().sort((t, n) => n.value.length - t.value.length).map((t) => this.buildKeywordToken(t, r, !!(i != null && i.caseInsensitive)));
+  }
+  buildKeywordToken(e, r, i) {
+    const t = this.buildKeywordPattern(e, i), n = {
+      name: e.value,
+      PATTERN: t,
+      LONGER_ALT: this.findLongerAlt(e, r)
+    };
+    return typeof t == "function" && (n.LINE_BREAKS = !0), n;
+  }
+  buildKeywordPattern(e, r) {
+    return r ? new RegExp(h(e.value)) : e.value;
+  }
+  findLongerAlt(e, r) {
+    return r.reduce((i, t) => {
+      const n = t == null ? void 0 : t.PATTERN;
+      return n != null && n.source && T("^" + n.source + "$", e.value) && i.push(t), i;
+    }, []);
+  }
+}
+export {
+  N as DefaultTokenBuilder
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/value-converter.js

@@ -0,0 +1,103 @@
+import { isCrossReference as b, isRuleCall as I } from "../languages/generated/ast.js";
+import { getCrossReferenceTerminal as h, getRuleType as w } from "../utils/grammar-utils.js";
+class B {
+  convert(a, e) {
+    let c = e.grammarSource;
+    if (b(c) && (c = h(c)), I(c)) {
+      const o = c.rule.ref;
+      if (!o)
+        throw new Error("This cst node was not parsed by a rule.");
+      return this.runConverter(o, a, e);
+    }
+    return a;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  runConverter(a, e, c) {
+    var o;
+    switch (a.name.toUpperCase()) {
+      case "INT":
+        return t.convertInt(e);
+      case "STRING":
+        return t.convertString(e);
+      case "ID":
+        return t.convertID(e);
+    }
+    switch ((o = w(a)) === null || o === void 0 ? void 0 : o.toLowerCase()) {
+      case "number":
+        return t.convertNumber(e);
+      case "boolean":
+        return t.convertBoolean(e);
+      case "bigint":
+        return t.convertBigint(e);
+      case "date":
+        return t.convertDate(e);
+      default:
+        return e;
+    }
+  }
+}
+var t;
+(function(n) {
+  function a(r) {
+    let u = "";
+    for (let s = 1; s < r.length - 1; s++) {
+      const i = r.charAt(s);
+      if (i === "\\") {
+        const m = r.charAt(++s);
+        u += e(m);
+      } else
+        u += i;
+    }
+    return u;
+  }
+  n.convertString = a;
+  function e(r) {
+    switch (r) {
+      case "b":
+        return "\b";
+      case "f":
+        return "\f";
+      case "n":
+        return `
+`;
+      case "r":
+        return "\r";
+      case "t":
+        return "	";
+      case "v":
+        return "\v";
+      case "0":
+        return "\0";
+      default:
+        return r;
+    }
+  }
+  function c(r) {
+    return r.charAt(0) === "^" ? r.substring(1) : r;
+  }
+  n.convertID = c;
+  function o(r) {
+    return parseInt(r);
+  }
+  n.convertInt = o;
+  function v(r) {
+    return BigInt(r);
+  }
+  n.convertBigint = v;
+  function f(r) {
+    return new Date(r);
+  }
+  n.convertDate = f;
+  function l(r) {
+    return Number(r);
+  }
+  n.convertNumber = l;
+  function g(r) {
+    return r.toLowerCase() === "true";
+  }
+  n.convertBoolean = g;
+})(t || (t = {}));
+export {
+  B as DefaultValueConverter,
+  t as ValueConverter
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/linker.js

@@ -0,0 +1,111 @@
+import { isLinkingError as a, isAstNode as u, isAstNodeDescription as g } from "../syntax-tree.js";
+import { streamAst as m, streamReferences as p, findRootNode as f } from "../utils/ast-utils.js";
+import { interruptAndCheck as _ } from "../utils/promise-utils.js";
+import { DocumentState as h } from "../workspace/documents.js";
+import { c as $ } from "../../../../../../../_virtual/cancellation.js";
+const l = Symbol("ref_resolving");
+class b {
+  constructor(e) {
+    this.reflection = e.shared.AstReflection, this.langiumDocuments = () => e.shared.workspace.LangiumDocuments, this.scopeProvider = e.references.ScopeProvider, this.astNodeLocator = e.workspace.AstNodeLocator;
+  }
+  async link(e, o = $.CancellationToken.None) {
+    for (const r of m(e.parseResult.value))
+      await _(o), p(r).forEach((t) => this.doLink(t, e));
+  }
+  doLink(e, o) {
+    var r;
+    const t = e.reference;
+    if (t._ref === void 0) {
+      t._ref = l;
+      try {
+        const n = this.getCandidate(e);
+        if (a(n))
+          t._ref = n;
+        else if (t._nodeDescription = n, this.langiumDocuments().hasDocument(n.documentUri)) {
+          const s = this.loadAstNode(n);
+          t._ref = s ?? this.createLinkingError(e, n);
+        } else
+          t._ref = void 0;
+      } catch (n) {
+        console.error(`An error occurred while resolving reference to '${t.$refText}':`, n);
+        const s = (r = n.message) !== null && r !== void 0 ? r : String(n);
+        t._ref = Object.assign(Object.assign({}, e), { message: `An error occurred while resolving reference to '${t.$refText}': ${s}` });
+      }
+      o.references.push(t);
+    }
+  }
+  unlink(e) {
+    for (const o of e.references)
+      delete o._ref, delete o._nodeDescription;
+    e.references = [];
+  }
+  getCandidate(e) {
+    const r = this.scopeProvider.getScope(e).getElement(e.reference.$refText);
+    return r ?? this.createLinkingError(e);
+  }
+  buildReference(e, o, r, t) {
+    const n = this, s = {
+      $refNode: r,
+      $refText: t,
+      get ref() {
+        var d;
+        if (u(this._ref))
+          return this._ref;
+        if (g(this._nodeDescription)) {
+          const i = n.loadAstNode(this._nodeDescription);
+          this._ref = i ?? n.createLinkingError({ reference: s, container: e, property: o }, this._nodeDescription);
+        } else if (this._ref === void 0) {
+          this._ref = l;
+          const i = f(e).$document, c = n.getLinkedNode({ reference: s, container: e, property: o });
+          if (c.error && i && i.state < h.ComputedScopes)
+            return this._ref = void 0;
+          this._ref = (d = c.node) !== null && d !== void 0 ? d : c.error, this._nodeDescription = c.descr, i == null || i.references.push(this);
+        } else if (this._ref === l)
+          throw new Error(`Cyclic reference resolution detected: ${n.astNodeLocator.getAstNodePath(e)}/${o} (symbol '${t}')`);
+        return u(this._ref) ? this._ref : void 0;
+      },
+      get $nodeDescription() {
+        return this._nodeDescription;
+      },
+      get error() {
+        return a(this._ref) ? this._ref : void 0;
+      }
+    };
+    return s;
+  }
+  getLinkedNode(e) {
+    var o;
+    try {
+      const r = this.getCandidate(e);
+      if (a(r))
+        return { error: r };
+      const t = this.loadAstNode(r);
+      return t ? { node: t, descr: r } : {
+        descr: r,
+        error: this.createLinkingError(e, r)
+      };
+    } catch (r) {
+      console.error(`An error occurred while resolving reference to '${e.reference.$refText}':`, r);
+      const t = (o = r.message) !== null && o !== void 0 ? o : String(r);
+      return {
+        error: Object.assign(Object.assign({}, e), { message: `An error occurred while resolving reference to '${e.reference.$refText}': ${t}` })
+      };
+    }
+  }
+  loadAstNode(e) {
+    if (e.node)
+      return e.node;
+    const o = this.langiumDocuments().getDocument(e.documentUri);
+    if (o)
+      return this.astNodeLocator.getAstNode(o.parseResult.value, e.path);
+  }
+  createLinkingError(e, o) {
+    const r = f(e.container).$document;
+    r && r.state < h.ComputedScopes && console.warn(`Attempted reference resolution before document reached ComputedScopes state (${r.uri}).`);
+    const t = this.reflection.getReferenceType(e);
+    return Object.assign(Object.assign({}, e), { message: `Could not resolve reference to ${t} named '${e.reference.$refText}'.`, targetDescription: o });
+  }
+}
+export {
+  b as DefaultLinker
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/name-provider.js

@@ -0,0 +1,17 @@
+import { findNodeForProperty as t } from "../utils/grammar-utils.js";
+function n(r) {
+  return typeof r.name == "string";
+}
+class a {
+  getName(e) {
+    if (n(e))
+      return e.name;
+  }
+  getNameNode(e) {
+    return t(e.$cstNode, "name");
+  }
+}
+export {
+  a as DefaultNameProvider,
+  n as isNamed
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/references.js

@@ -0,0 +1,64 @@
+import { findAssignment as f } from "../utils/grammar-utils.js";
+import { isReference as i } from "../syntax-tree.js";
+import { getDocument as d } from "../utils/ast-utils.js";
+import { isChildNode as s, toDocumentSegment as a } from "../utils/cst-utils.js";
+import { stream as c } from "../utils/stream.js";
+import { UriUtils as m } from "../utils/uri-utils.js";
+class A {
+  constructor(e) {
+    this.nameProvider = e.references.NameProvider, this.index = e.shared.workspace.IndexManager, this.nodeLocator = e.workspace.AstNodeLocator;
+  }
+  findDeclaration(e) {
+    if (e) {
+      const t = f(e), r = e.astNode;
+      if (t && r) {
+        const n = r[t.feature];
+        if (i(n))
+          return n.ref;
+        if (Array.isArray(n)) {
+          for (const o of n)
+            if (i(o) && o.$refNode && o.$refNode.offset <= e.offset && o.$refNode.end >= e.end)
+              return o.ref;
+        }
+      }
+      if (r) {
+        const n = this.nameProvider.getNameNode(r);
+        if (n && (n === e || s(e, n)))
+          return r;
+      }
+    }
+  }
+  findDeclarationNode(e) {
+    const t = this.findDeclaration(e);
+    if (t != null && t.$cstNode) {
+      const r = this.nameProvider.getNameNode(t);
+      return r ?? t.$cstNode;
+    }
+  }
+  findReferences(e, t) {
+    const r = [];
+    if (t.includeDeclaration) {
+      const o = this.getReferenceToSelf(e);
+      o && r.push(o);
+    }
+    let n = this.index.findAllReferences(e, this.nodeLocator.getAstNodePath(e));
+    return t.documentUri && (n = n.filter((o) => m.equals(o.sourceUri, t.documentUri))), r.push(...n), c(r);
+  }
+  getReferenceToSelf(e) {
+    const t = this.nameProvider.getNameNode(e);
+    if (t) {
+      const r = d(e), n = this.nodeLocator.getAstNodePath(e);
+      return {
+        sourceUri: r.uri,
+        sourcePath: n,
+        targetUri: r.uri,
+        targetPath: n,
+        segment: a(t),
+        local: !0
+      };
+    }
+  }
+}
+export {
+  A as DefaultReferences
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/scope-computation.js

@@ -0,0 +1,60 @@
+import { streamContents as c, streamAllContents as p } from "../utils/ast-utils.js";
+import { MultiMap as m } from "../utils/collections.js";
+import { interruptAndCheck as i } from "../utils/promise-utils.js";
+import { c as n } from "../../../../../../../_virtual/cancellation.js";
+class h {
+  constructor(o) {
+    this.nameProvider = o.references.NameProvider, this.descriptions = o.workspace.AstNodeDescriptionProvider;
+  }
+  async computeExports(o, e = n.CancellationToken.None) {
+    return this.computeExportsForNode(o.parseResult.value, o, void 0, e);
+  }
+  /**
+   * Creates {@link AstNodeDescription AstNodeDescriptions} for the given {@link AstNode parentNode} and its children.
+   * The list of children to be considered is determined by the function parameter {@link children}.
+   * By default only the direct children of {@link parentNode} are visited, nested nodes are not exported.
+   *
+   * @param parentNode AST node to be exported, i.e., of which an {@link AstNodeDescription} shall be added to the returned list.
+   * @param document The document containing the AST node to be exported.
+   * @param children A function called with {@link parentNode} as single argument and returning an {@link Iterable} supplying the children to be visited, which must be directly or transitively contained in {@link parentNode}.
+   * @param cancelToken Indicates when to cancel the current operation.
+   * @throws `OperationCancelled` if a user action occurs during execution.
+   * @returns A list of {@link AstNodeDescription AstNodeDescriptions} to be published to index.
+   */
+  async computeExportsForNode(o, e, s = c, t = n.CancellationToken.None) {
+    const r = [];
+    this.exportNode(o, r, e);
+    for (const a of s(o))
+      await i(t), this.exportNode(a, r, e);
+    return r;
+  }
+  /**
+   * Add a single node to the list of exports if it has a name. Override this method to change how
+   * symbols are exported, e.g. by modifying their exported name.
+   */
+  exportNode(o, e, s) {
+    const t = this.nameProvider.getName(o);
+    t && e.push(this.descriptions.createDescription(o, t, s));
+  }
+  async computeLocalScopes(o, e = n.CancellationToken.None) {
+    const s = o.parseResult.value, t = new m();
+    for (const r of p(s))
+      await i(e), this.processNode(r, o, t);
+    return t;
+  }
+  /**
+   * Process a single node during scopes computation. The default implementation makes the node visible
+   * in the subtree of its container (if the node has a name). Override this method to change this,
+   * e.g. by increasing the visibility to a higher level in the AST.
+   */
+  processNode(o, e, s) {
+    const t = o.$container;
+    if (t) {
+      const r = this.nameProvider.getName(o);
+      r && s.add(t, this.descriptions.createDescription(o, r, e));
+    }
+  }
+}
+export {
+  h as DefaultScopeComputation
+};