@mintlify/components 0.4.16 → 1.0.0

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/caching.js

@@ -0,0 +1,103 @@
+class c {
+  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 new Error("This cache has already been disposed");
+  }
+}
+class r extends c {
+  constructor() {
+    super(...arguments), this.cache = /* @__PURE__ */ new Map();
+  }
+  has(e) {
+    return this.throwIfDisposed(), this.cache.has(e);
+  }
+  set(e, s) {
+    this.throwIfDisposed(), this.cache.set(e, s);
+  }
+  get(e, s) {
+    if (this.throwIfDisposed(), this.cache.has(e))
+      return this.cache.get(e);
+    if (s) {
+      const t = s();
+      return this.cache.set(e, t), t;
+    } else
+      return;
+  }
+  delete(e) {
+    return this.throwIfDisposed(), this.cache.delete(e);
+  }
+  clear() {
+    this.throwIfDisposed(), this.cache.clear();
+  }
+}
+class a extends c {
+  constructor(e) {
+    super(), this.cache = /* @__PURE__ */ new Map(), this.converter = e ?? ((s) => s);
+  }
+  has(e, s) {
+    return this.throwIfDisposed(), this.cacheForContext(e).has(s);
+  }
+  set(e, s, t) {
+    this.throwIfDisposed(), this.cacheForContext(e).set(s, t);
+  }
+  get(e, s, t) {
+    this.throwIfDisposed();
+    const h = this.cacheForContext(e);
+    if (h.has(s))
+      return h.get(s);
+    if (t) {
+      const o = t();
+      return h.set(s, o), o;
+    } else
+      return;
+  }
+  delete(e, s) {
+    return this.throwIfDisposed(), this.cacheForContext(e).delete(s);
+  }
+  clear(e) {
+    if (this.throwIfDisposed(), e) {
+      const s = this.converter(e);
+      this.cache.delete(s);
+    } else
+      this.cache.clear();
+  }
+  cacheForContext(e) {
+    const s = this.converter(e);
+    let t = this.cache.get(s);
+    return t || (t = /* @__PURE__ */ new Map(), this.cache.set(s, t)), t;
+  }
+}
+class n extends r {
+  /**
+   * Creates a new workspace cache.
+   *
+   * @param sharedServices Service container instance to hook into document lifecycle events.
+   * @param state Optional document state on which the cache should evict.
+   * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.
+   * *Deleted* documents are considered in both cases.
+   */
+  constructor(e, s) {
+    super(), s ? (this.toDispose.push(e.workspace.DocumentBuilder.onBuildPhase(s, () => {
+      this.clear();
+    })), this.toDispose.push(e.workspace.DocumentBuilder.onUpdate((t, h) => {
+      h.length > 0 && this.clear();
+    }))) : this.toDispose.push(e.workspace.DocumentBuilder.onUpdate(() => {
+      this.clear();
+    }));
+  }
+}
+export {
+  a as ContextCache,
+  c as DisposableCache,
+  r as SimpleCache,
+  n as WorkspaceCache
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/collections.js

@@ -0,0 +1,143 @@
+import { Reduction as n, stream as r } from "./stream.js";
+class p {
+  constructor(e) {
+    if (this.map = /* @__PURE__ */ new Map(), e)
+      for (const [t, s] of e)
+        this.add(t, s);
+  }
+  /**
+   * The total number of values in the multimap.
+   */
+  get size() {
+    return n.sum(r(this.map.values()).map((e) => e.length));
+  }
+  /**
+   * Clear all entries in the multimap.
+   */
+  clear() {
+    this.map.clear();
+  }
+  /**
+   * Operates differently depending on whether a `value` is given:
+   *  * With a value, this method deletes the specific key / value pair from the multimap.
+   *  * Without a value, all values associated with the given key are deleted.
+   *
+   * @returns `true` if a value existed and has been removed, or `false` if the specified
+   *     key / value does not exist.
+   */
+  delete(e, t) {
+    if (t === void 0)
+      return this.map.delete(e);
+    {
+      const s = this.map.get(e);
+      if (s) {
+        const i = s.indexOf(t);
+        if (i >= 0)
+          return s.length === 1 ? this.map.delete(e) : s.splice(i, 1), !0;
+      }
+      return !1;
+    }
+  }
+  /**
+   * Returns an array of all values associated with the given key. If no value exists,
+   * an empty array is returned.
+   *
+   * _Note:_ The returned array is assumed not to be modified. Use the `set` method to add a
+   * value and `delete` to remove a value from the multimap.
+   */
+  get(e) {
+    var t;
+    return (t = this.map.get(e)) !== null && t !== void 0 ? t : [];
+  }
+  /**
+   * Operates differently depending on whether a `value` is given:
+   *  * With a value, this method returns `true` if the specific key / value pair is present in the multimap.
+   *  * Without a value, this method returns `true` if the given key is present in the multimap.
+   */
+  has(e, t) {
+    if (t === void 0)
+      return this.map.has(e);
+    {
+      const s = this.map.get(e);
+      return s ? s.indexOf(t) >= 0 : !1;
+    }
+  }
+  /**
+   * Add the given key / value pair to the multimap.
+   */
+  add(e, t) {
+    return this.map.has(e) ? this.map.get(e).push(t) : this.map.set(e, [t]), this;
+  }
+  /**
+   * Add the given set of key / value pairs to the multimap.
+   */
+  addAll(e, t) {
+    return this.map.has(e) ? this.map.get(e).push(...t) : this.map.set(e, Array.from(t)), this;
+  }
+  /**
+   * Invokes the given callback function for every key / value pair in the multimap.
+   */
+  forEach(e) {
+    this.map.forEach((t, s) => t.forEach((i) => e(i, s, this)));
+  }
+  /**
+   * Returns an iterator of key, value pairs for every entry in the map.
+   */
+  [Symbol.iterator]() {
+    return this.entries().iterator();
+  }
+  /**
+   * Returns a stream of key, value pairs for every entry in the map.
+   */
+  entries() {
+    return r(this.map.entries()).flatMap(([e, t]) => t.map((s) => [e, s]));
+  }
+  /**
+   * Returns a stream of keys in the map.
+   */
+  keys() {
+    return r(this.map.keys());
+  }
+  /**
+   * Returns a stream of values in the map.
+   */
+  values() {
+    return r(this.map.values()).flat();
+  }
+  /**
+   * Returns a stream of key, value set pairs for every key in the map.
+   */
+  entriesGroupedByKey() {
+    return r(this.map.entries());
+  }
+}
+class u {
+  get size() {
+    return this.map.size;
+  }
+  constructor(e) {
+    if (this.map = /* @__PURE__ */ new Map(), this.inverse = /* @__PURE__ */ new Map(), e)
+      for (const [t, s] of e)
+        this.set(t, s);
+  }
+  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) {
+    const t = this.map.get(e);
+    return t !== void 0 ? (this.map.delete(e), this.inverse.delete(t), !0) : !1;
+  }
+}
+export {
+  u as BiMap,
+  p as MultiMap
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/cst-utils.js

@@ -0,0 +1,95 @@
+import { isCompositeCstNode as s, isRootCstNode as d, isLeafCstNode as l } from "../syntax-tree.js";
+import { TreeStreamImpl as a } from "./stream.js";
+function O(e) {
+  return new a(e, (t) => s(t) ? t.content : [], { includeRoot: !0 });
+}
+function I(e, t) {
+  for (; e.container; )
+    if (e = e.container, e === t)
+      return !0;
+  return !1;
+}
+function m(e) {
+  return {
+    start: {
+      character: e.startColumn - 1,
+      line: e.startLine - 1
+    },
+    end: {
+      character: e.endColumn,
+      // endColumn uses the correct index
+      line: e.endLine - 1
+    }
+  };
+}
+function x(e) {
+  if (!e)
+    return;
+  const { offset: t, end: n, range: r } = e;
+  return {
+    range: r,
+    offset: t,
+    end: n,
+    length: n - t
+  };
+}
+var i;
+(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";
+})(i || (i = {}));
+function o(e, t) {
+  if (e.end.line < t.start.line || e.end.line === t.start.line && e.end.character <= t.start.character)
+    return i.Before;
+  if (e.start.line > t.end.line || e.start.line === t.end.line && e.start.character >= t.end.character)
+    return i.After;
+  const 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 ? i.Inside : n ? i.OverlapBack : r ? i.OverlapFront : i.Outside;
+}
+function B(e, t) {
+  return o(e, t) > i.After;
+}
+const w = /^[\w\p{L}]$/u;
+function A(e, t) {
+  if (e) {
+    const n = h(e, !0);
+    if (n && f(n, t))
+      return n;
+    if (d(e)) {
+      const r = e.content.findIndex((u) => !u.hidden);
+      for (let u = r - 1; u >= 0; u--) {
+        const c = e.content[u];
+        if (f(c, t))
+          return c;
+      }
+    }
+  }
+}
+function f(e, t) {
+  return l(e) && t.includes(e.tokenType.name);
+}
+function h(e, t = !0) {
+  for (; e.container; ) {
+    const n = e.container;
+    let r = n.content.indexOf(e);
+    for (; r > 0; ) {
+      r--;
+      const u = n.content[r];
+      if (t || !u.hidden)
+        return u;
+    }
+    e = n;
+  }
+}
+export {
+  w as DefaultNameRegexp,
+  i as RangeComparison,
+  o as compareRange,
+  A as findCommentNode,
+  h as getPreviousNode,
+  B as inRange,
+  I as isChildNode,
+  f as isCommentNode,
+  O as streamCst,
+  x as toDocumentSegment,
+  m as tokenToRange
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/disposable.js

@@ -0,0 +1,12 @@
+var e;
+(function(a) {
+  function t(n) {
+    return {
+      dispose: async () => await n()
+    };
+  }
+  a.create = t;
+})(e || (e = {}));
+export {
+  e as Disposable
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/errors.js

@@ -0,0 +1,12 @@
+class e extends Error {
+  constructor(r, t) {
+    super(r ? `${t} at ${r.range.start.line}:${r.range.start.character}` : t);
+  }
+}
+function n(a) {
+  throw new Error("Error! The input value was not handled.");
+}
+export {
+  e as ErrorWithLocation,
+  n as assertUnreachable
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/grammar-loader.js

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

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/grammar-utils.js

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

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/promise-utils.js

@@ -0,0 +1,36 @@
+import { c as o } from "../../../../../../../_virtual/cancellation.js";
+function c() {
+  return new Promise((e) => {
+    typeof setImmediate > "u" ? setTimeout(e, 0) : setImmediate(e);
+  });
+}
+let t = 0, l = 10;
+function u() {
+  return t = performance.now(), new o.CancellationTokenSource();
+}
+const i = Symbol("OperationCancelled");
+function f(e) {
+  return e === i;
+}
+async function m(e) {
+  if (e === o.CancellationToken.None)
+    return;
+  const n = performance.now();
+  if (n - t >= l && (t = n, await c(), t = performance.now()), e.isCancellationRequested)
+    throw i;
+}
+class p {
+  constructor() {
+    this.promise = new Promise((n, a) => {
+      this.resolve = (r) => (n(r), this), this.reject = (r) => (a(r), this);
+    });
+  }
+}
+export {
+  p as Deferred,
+  i as OperationCancelled,
+  c as delayNextTick,
+  m as interruptAndCheck,
+  f as isOperationCancelled,
+  u as startCancelableOperation
+};