@mintlify/components 0.4.17 → 1.0.0

package/dist/node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/xlink.js

@@ -0,0 +1,19 @@
+import { create as n } from "./util/create.js";
+const r = n({
+  properties: {
+    xLinkActuate: null,
+    xLinkArcRole: null,
+    xLinkHref: null,
+    xLinkRole: null,
+    xLinkShow: null,
+    xLinkTitle: null,
+    xLinkType: null
+  },
+  space: "xlink",
+  transform(e, l) {
+    return "xlink:" + l.slice(5).toLowerCase();
+  }
+});
+export {
+  r as xlink
+};

package/dist/node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/xml.js

@@ -0,0 +1,11 @@
+import { create as e } from "./util/create.js";
+const o = e({
+  properties: { xmlBase: null, xmlLang: null, xmlSpace: null },
+  space: "xml",
+  transform(r, l) {
+    return "xml:" + l.slice(3).toLowerCase();
+  }
+});
+export {
+  o as xml
+};

package/dist/node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/xmlns.js

@@ -0,0 +1,11 @@
+import { create as n } from "./util/create.js";
+import { caseInsensitiveTransform as s } from "./util/case-insensitive-transform.js";
+const m = n({
+  attributes: { xmlnsxlink: "xmlns:xlink" },
+  properties: { xmlnsXLink: null, xmlns: null },
+  space: "xmlns",
+  transform: s
+});
+export {
+  m as xmlns
+};

package/dist/node_modules/.pnpm/react-use-rect@2.0.6_react@18.3.1/node_modules/react-use-rect/dist/index.esm.js

@@ -0,0 +1,54 @@
+import { useRef as s, useEffect as i, useCallback as l } from "react";
+function y(e, { resize: t = !1 } = {}) {
+  const n = s(e);
+  i(() => {
+    n.current = e;
+  }, [e]);
+  const R = s(t);
+  i(() => {
+    R.current = t, a();
+  }, [t]);
+  const r = s(null), b = l((o) => {
+    o !== r.current && (r.current = o, c(), a());
+  }, []), h = s(null), c = l(
+    ({ force: o = !1 } = {}) => {
+      if (!r.current)
+        return;
+      const f = r.current.getBoundingClientRect();
+      if (o || O(h.current, f)) {
+        h.current = f;
+        const { bottom: g, height: m, left: v, right: d, top: p, width: E, x: w, y: x } = f;
+        n.current({
+          bottom: g,
+          height: m,
+          left: v,
+          right: d,
+          top: p,
+          width: E,
+          x: w,
+          y: x
+        });
+      }
+    },
+    []
+  ), u = s(null), a = l(() => {
+    u.current && (u.current.disconnect(), u.current = null), r.current && R.current && (u.current = new ResizeObserver(() => c()), u.current.observe(r.current));
+  }, [c]);
+  return i(c), [b, c];
+}
+var C = [
+  "bottom",
+  "height",
+  "left",
+  "right",
+  "top",
+  "width",
+  "x",
+  "y"
+];
+function O(e, t) {
+  return !e || e !== t && C.some((n) => e[n] !== t[n]);
+}
+export {
+  y as useRect
+};

package/dist/node_modules/.pnpm/regex-recursion@6.0.2/node_modules/regex-recursion/src/index.js

@@ -0,0 +1,182 @@
+import { hasUnescaped as x, Context as R, getGroupContents as H, forEachUnescaped as W, replaceUnescaped as _ } from "../../../../regex-utilities@2.3.0/node_modules/regex-utilities/src/index.js";
+const d = String.raw, j = d`\\g<(?<gRNameOrNum>[^>&]+)&R=(?<gRDepth>[^>]+)>`, U = d`\(\?R=(?<rDepth>[^\)]+)\)|${j}`, T = d`\(\?<(?![=!])(?<captureName>[^>]+)>`, G = d`${T}|(?<unnamed>\()(?!\?)`, C = new RegExp(d`${T}|${U}|\(\?|\\?.`, "gsu"), L = "Cannot use multiple overlapping recursions";
+function J(e, t) {
+  const { hiddenCaptures: n, mode: r } = {
+    hiddenCaptures: [],
+    mode: "plugin",
+    ...t
+  };
+  let a = (t == null ? void 0 : t.captureTransfers) ?? /* @__PURE__ */ new Map();
+  if (!new RegExp(U, "su").test(e))
+    return {
+      pattern: e,
+      captureTransfers: a,
+      hiddenCaptures: n
+    };
+  if (r === "plugin" && x(e, d`\(\?\(DEFINE\)`, R.DEFAULT))
+    throw new Error("DEFINE groups cannot be used with recursion");
+  const f = [], o = x(e, d`\\[1-9]`, R.DEFAULT), l = /* @__PURE__ */ new Map(), h = [];
+  let w = !1, i = 0, u = 0, m;
+  for (C.lastIndex = 0; m = C.exec(e); ) {
+    const { 0: g, groups: { captureName: p, rDepth: c, gRNameOrNum: s, gRDepth: D } } = m;
+    if (g === "[")
+      i++;
+    else if (i)
+      g === "]" && i--;
+    else if (c) {
+      if (v(c), w)
+        throw new Error(L);
+      if (o)
+        throw new Error(
+          // When used in `external` mode by transpilers other than Regex+, backrefs might have
+          // gone through conversion from named to numbered, so avoid a misleading error
+          `${r === "external" ? "Backrefs" : "Numbered backrefs"} cannot be used with global recursion`
+        );
+      const $ = e.slice(0, m.index), E = e.slice(C.lastIndex);
+      if (x(E, U, R.DEFAULT))
+        throw new Error(L);
+      const N = +c - 1;
+      e = B(
+        $,
+        E,
+        N,
+        !1,
+        n,
+        f,
+        u
+      ), a = S(
+        a,
+        $,
+        N,
+        f.length,
+        0,
+        u
+      );
+      break;
+    } else if (s) {
+      v(D);
+      let $ = !1;
+      for (const b of h)
+        if (b.name === s || b.num === +s) {
+          if ($ = !0, b.hasRecursedWithin)
+            throw new Error(L);
+          break;
+        }
+      if (!$)
+        throw new Error(d`Recursive \g cannot be used outside the referenced group "${r === "external" ? s : d`\g<${s}&R=${D}>`}"`);
+      const E = l.get(s), N = H(e, E);
+      if (o && x(N, d`${T}|\((?!\?)`, R.DEFAULT))
+        throw new Error(
+          // When used in `external` mode by transpilers other than Regex+, backrefs might have
+          // gone through conversion from named to numbered, so avoid a misleading error
+          `${r === "external" ? "Backrefs" : "Numbered backrefs"} cannot be used with recursion of capturing groups`
+        );
+      const k = e.slice(E, m.index), F = N.slice(k.length + g.length), I = f.length, A = +D - 1, M = B(
+        k,
+        F,
+        A,
+        !0,
+        n,
+        f,
+        u
+      );
+      a = S(
+        a,
+        k,
+        A,
+        f.length - I,
+        I,
+        u
+      );
+      const O = e.slice(0, E), z = e.slice(E + N.length);
+      e = `${O}${M}${z}`, C.lastIndex += M.length - g.length - k.length - F.length, h.forEach((b) => b.hasRecursedWithin = !0), w = !0;
+    } else if (p)
+      u++, l.set(String(u), C.lastIndex), l.set(p, C.lastIndex), h.push({
+        num: u,
+        name: p
+      });
+    else if (g[0] === "(") {
+      const $ = g === "(";
+      $ && (u++, l.set(String(u), C.lastIndex)), h.push($ ? { num: u } : {});
+    } else g === ")" && h.pop();
+  }
+  return n.push(...f), {
+    pattern: e,
+    captureTransfers: a,
+    hiddenCaptures: n
+  };
+}
+function v(e) {
+  const t = `Max depth must be integer between 2 and 100; used ${e}`;
+  if (!/^[1-9]\d*$/.test(e))
+    throw new Error(t);
+  if (e = +e, e < 2 || e > 100)
+    throw new Error(t);
+}
+function B(e, t, n, r, a, f, o) {
+  const l = /* @__PURE__ */ new Set();
+  r && W(e + t, T, ({ groups: { captureName: w } }) => {
+    l.add(w);
+  }, R.DEFAULT);
+  const h = [
+    n,
+    r ? l : null,
+    a,
+    f,
+    o
+  ];
+  return `${e}${P(`(?:${e}`, "forward", ...h)}(?:)${P(`${t})`, "backward", ...h)}${t}`;
+}
+function P(e, t, n, r, a, f, o) {
+  const h = (i) => t === "forward" ? i + 2 : n - i + 2 - 1;
+  let w = "";
+  for (let i = 0; i < n; i++) {
+    const u = h(i);
+    w += _(
+      e,
+      d`${G}|\\k<(?<backref>[^>]+)>`,
+      ({ 0: m, groups: { captureName: g, unnamed: p, backref: c } }) => {
+        if (c && r && !r.has(c))
+          return m;
+        const s = `_$${u}`;
+        if (p || g) {
+          const D = o + f.length + 1;
+          return f.push(D), q(a, D), p ? m : `(?<${g}${s}>`;
+        }
+        return d`\k<${c}${s}>`;
+      },
+      R.DEFAULT
+    );
+  }
+  return w;
+}
+function q(e, t) {
+  for (let n = 0; n < e.length; n++)
+    e[n] >= t && e[n]++;
+}
+function S(e, t, n, r, a, f) {
+  if (e.size && r) {
+    let o = 0;
+    W(t, G, () => o++, R.DEFAULT);
+    const l = f - o + a, h = /* @__PURE__ */ new Map();
+    return e.forEach((w, i) => {
+      const u = (r - o * n) / n, m = o * n, g = i > l + o ? i + r : i, p = [];
+      for (const c of w)
+        if (c <= l)
+          p.push(c);
+        else if (c > l + o + u)
+          p.push(c + r);
+        else if (c <= l + o)
+          for (let s = 0; s <= n; s++)
+            p.push(c + o * s);
+        else
+          for (let s = 0; s <= n; s++)
+            p.push(c + m + u * s);
+      h.set(g, p);
+    }), h;
+  }
+  return e;
+}
+export {
+  J as recursion
+};

package/dist/node_modules/.pnpm/regex-utilities@2.3.0/node_modules/regex-utilities/src/index.js

@@ -0,0 +1,67 @@
+const a = Object.freeze({
+  DEFAULT: "DEFAULT",
+  CHAR_CLASS: "CHAR_CLASS"
+});
+function p(t, i, s, c) {
+  const u = new RegExp(String.raw`${i}|(?<$skip>\[\^?|\\?.)`, "gsu"), n = [!1];
+  let e = 0, l = "";
+  for (const f of t.matchAll(u)) {
+    const { 0: o, groups: { $skip: r } } = f;
+    if (!r && (!c || c === a.DEFAULT == !e)) {
+      s instanceof Function ? l += s(f, {
+        context: e ? a.CHAR_CLASS : a.DEFAULT,
+        negated: n[n.length - 1]
+      }) : l += s;
+      continue;
+    }
+    o[0] === "[" ? (e++, n.push(o[1] === "^")) : o === "]" && e && (e--, n.pop()), l += o;
+  }
+  return l;
+}
+function h(t, i, s, c) {
+  p(t, i, s, c);
+}
+function g(t, i, s = 0, c) {
+  if (!new RegExp(i, "su").test(t))
+    return null;
+  const u = new RegExp(`${i}|(?<$skip>\\\\?.)`, "gsu");
+  u.lastIndex = s;
+  let n = 0, e;
+  for (; e = u.exec(t); ) {
+    const { 0: l, groups: { $skip: f } } = e;
+    if (!f && (!c || c === a.DEFAULT == !n))
+      return e;
+    l === "[" ? n++ : l === "]" && n && n--, u.lastIndex == e.index && u.lastIndex++;
+  }
+  return null;
+}
+function C(t, i, s) {
+  return !!g(t, i, 0, s);
+}
+function d(t, i) {
+  const s = /\\?./gsu;
+  s.lastIndex = i;
+  let c = t.length, u = 0, n = 1, e;
+  for (; e = s.exec(t); ) {
+    const [l] = e;
+    if (l === "[")
+      u++;
+    else if (u)
+      l === "]" && u--;
+    else if (l === "(")
+      n++;
+    else if (l === ")" && (n--, !n)) {
+      c = e.index;
+      break;
+    }
+  }
+  return t.slice(i, c);
+}
+export {
+  a as Context,
+  g as execUnescaped,
+  h as forEachUnescaped,
+  d as getGroupContents,
+  C as hasUnescaped,
+  p as replaceUnescaped
+};

package/dist/node_modules/.pnpm/regex@6.1.0/node_modules/regex/src/atomic.js

@@ -0,0 +1,125 @@
+import { incrementIfAtLeast as v, noncapturingDelim as b, spliceStr as q } from "./utils-internals.js";
+import { replaceUnescaped as B, Context as D } from "../../../../regex-utilities@2.3.0/node_modules/regex-utilities/src/index.js";
+const E = new RegExp(String.raw`(?<noncapturingStart>${b})|(?<capturingStart>\((?:\?<[^>]+>)?)|\\?.`, "gsu");
+function F(e, a) {
+  const d = (a == null ? void 0 : a.hiddenCaptures) ?? [];
+  let s = (a == null ? void 0 : a.captureTransfers) ?? /* @__PURE__ */ new Map();
+  if (!/\(\?>/.test(e))
+    return {
+      pattern: e,
+      captureTransfers: s,
+      hiddenCaptures: d
+    };
+  const t = "(?>", u = "(?:(?=(", p = [0], n = [];
+  let l = 0, i = 0, c = NaN, h;
+  do {
+    h = !1;
+    let f = 0, r = 0, o = !1, g;
+    for (E.lastIndex = Number.isNaN(c) ? 0 : c + u.length; g = E.exec(e); ) {
+      const { 0: $, index: w, groups: { capturingStart: S, noncapturingStart: k } } = g;
+      if ($ === "[")
+        f++;
+      else if (f)
+        $ === "]" && f--;
+      else if ($ === t && !o)
+        c = w, o = !0;
+      else if (o && k)
+        r++;
+      else if (S)
+        o ? r++ : (l++, p.push(l + i));
+      else if ($ === ")" && o) {
+        if (!r) {
+          i++;
+          const m = l + i;
+          if (e = `${e.slice(0, c)}${u}${e.slice(c + t.length, w)}))<$$${m}>)${e.slice(w + 1)}`, h = !0, n.push(m), v(d, m), s.size) {
+            const G = /* @__PURE__ */ new Map();
+            s.forEach((T, A) => {
+              G.set(
+                A >= m ? A + 1 : A,
+                T.map((C) => C >= m ? C + 1 : C)
+              );
+            }), s = G;
+          }
+          break;
+        }
+        r--;
+      }
+    }
+  } while (h);
+  return d.push(...n), e = B(
+    e,
+    String.raw`\\(?<backrefNum>[1-9]\d*)|<\$\$(?<wrappedBackrefNum>\d+)>`,
+    ({ 0: f, groups: { backrefNum: r, wrappedBackrefNum: o } }) => {
+      if (r) {
+        const g = +r;
+        if (g > p.length - 1)
+          throw new Error(`Backref "${f}" greater than number of captures`);
+        return `\\${p[g]}`;
+      }
+      return `\\${o}`;
+    },
+    D.DEFAULT
+  ), {
+    pattern: e,
+    captureTransfers: s,
+    hiddenCaptures: d
+  };
+}
+const N = String.raw`(?:[?*+]|\{\d+(?:,\d*)?\})`, I = new RegExp(String.raw`
+\\(?: \d+
+  | c[A-Za-z]
+  | [gk]<[^>]+>
+  | [pPu]\{[^\}]+\}
+  | u[A-Fa-f\d]{4}
+  | x[A-Fa-f\d]{2}
+  )
+| \((?: \? (?: [:=!>]
+  | <(?:[=!]|[^>]+>)
+  | [A-Za-z\-]+:
+  | \(DEFINE\)
+  ))?
+| (?<qBase>${N})(?<qMod>[?+]?)(?<invalidQ>[?*+\{]?)
+| \\?.
+`.replace(/\s+/g, ""), "gsu");
+function z(e) {
+  if (!new RegExp(`${N}\\+`).test(e))
+    return {
+      pattern: e
+    };
+  const a = [];
+  let d = null, s = null, t = "", u = 0, p;
+  for (I.lastIndex = 0; p = I.exec(e); ) {
+    const { 0: n, index: l, groups: { qBase: i, qMod: c, invalidQ: h } } = p;
+    if (n === "[")
+      u || (s = l), u++;
+    else if (n === "]")
+      u ? u-- : s = null;
+    else if (!u)
+      if (c === "+" && t && !t.startsWith("(")) {
+        if (h)
+          throw new Error(`Invalid quantifier "${n}"`);
+        let f = -1;
+        if (/^\{\d+\}$/.test(i))
+          e = q(e, l + i.length, c, "");
+        else {
+          if (t === ")" || t === "]") {
+            const r = t === ")" ? d : s;
+            if (r === null)
+              throw new Error(`Invalid unmatched "${t}"`);
+            e = `${e.slice(0, r)}(?>${e.slice(r, l)}${i})${e.slice(l + n.length)}`;
+          } else
+            e = `${e.slice(0, l - t.length)}(?>${t}${i})${e.slice(l + n.length)}`;
+          f += 4;
+        }
+        I.lastIndex += f;
+      } else n[0] === "(" ? a.push(l) : n === ")" && (d = a.length ? a.pop() : null);
+    t = n;
+  }
+  return {
+    pattern: e
+  };
+}
+export {
+  F as atomic,
+  z as possessive
+};

package/dist/node_modules/.pnpm/regex@6.1.0/node_modules/regex/src/utils-internals.js

@@ -0,0 +1,13 @@
+const c = String.raw`\(\?(?:[:=!>A-Za-z\-]|<[=!]|\(DEFINE\))`;
+function l(n, e) {
+  for (let t = 0; t < n.length; t++)
+    n[t] >= e && n[t]++;
+}
+function f(n, e, t, i) {
+  return n.slice(0, e) + i + n.slice(e + t.length);
+}
+export {
+  l as incrementIfAtLeast,
+  c as noncapturingDelim,
+  f as spliceStr
+};