@solutiondesk/help 0.0.0 → 1.0.0-69d9f69

package/dist/fumadocs.js

@@ -0,0 +1,664 @@
+import { Callout } from 'fumadocs-ui/components/callout';
+import { Card, Cards } from 'fumadocs-ui/components/card';
+import { CodeBlock, Pre } from 'fumadocs-ui/components/codeblock';
+import { Heading } from 'fumadocs-ui/components/heading';
+import { Step, Steps } from 'fumadocs-ui/components/steps';
+import { Tab, Tabs } from 'fumadocs-ui/components/tabs';
+import { Fragment as Fragment$1 } from 'react';
+import { directiveFromMarkdown } from 'mdast-util-directive';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { gfmFromMarkdown } from 'mdast-util-gfm';
+import { directive } from 'micromark-extension-directive';
+import { gfm } from 'micromark-extension-gfm';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+// src/fumadocs/body.tsx
+var HELP_BLOCKS = ["callout", "steps", "step", "tabs", "tab", "cards", "card"];
+var HELP_CALLOUT_TYPES = ["info", "warn", "error", "success", "idea"];
+var isHelpBlock = (name) => HELP_BLOCKS.includes(name);
+function parseHelpMarkdown(markdown) {
+  return fromMarkdown(markdown ?? "", {
+    extensions: [gfm(), directive()],
+    mdastExtensions: [gfmFromMarkdown(), directiveFromMarkdown()]
+  });
+}
+var CONTROL = /[\u0000-\u001f\u007f]/;
+var PROTOCOL_RELATIVE = /^[\\/]{2}/;
+function safeHelpHref(raw) {
+  const href = (raw ?? "").trim();
+  if (CONTROL.test(href) || PROTOCOL_RELATIVE.test(href)) return null;
+  if (/^https?:\/\/[^\s]+$/i.test(href)) return href;
+  if (/^mailto:[^\s]+$/i.test(href)) return href;
+  if (/^\/[^\s]*$/.test(href)) return href;
+  if (/^#[^\s]*$/.test(href)) return href;
+  return null;
+}
+function safeHelpImageSrc(raw) {
+  const src = (raw ?? "").trim();
+  if (CONTROL.test(src) || PROTOCOL_RELATIVE.test(src)) return null;
+  if (/^https?:\/\/[^\s]+$/i.test(src)) return src;
+  if (/^\/[^\s]*$/.test(src)) return src;
+  return null;
+}
+function plainText(node) {
+  if ("value" in node && typeof node.value === "string") return node.value;
+  if (node.type === "image") return node.alt ?? "";
+  if ("children" in node) return node.children.map(plainText).join("");
+  return "";
+}
+function sourceOf(node, markdown) {
+  const start = node.position?.start.offset;
+  const end = node.position?.end.offset;
+  return start === void 0 || end === void 0 ? plainText(node) : markdown.slice(start, end);
+}
+function labelOf(node) {
+  const first = node.children[0];
+  return first?.type === "paragraph" && first.data?.directiveLabel ? first : void 0;
+}
+function contentOf(node) {
+  return labelOf(node) ? node.children.slice(1) : node.children;
+}
+function directiveTitle(node) {
+  const attribute = node.attributes?.title?.trim();
+  if (attribute) return attribute;
+  const label = labelOf(node);
+  const text = label ? plainText(label).trim() : "";
+  return text || void 0;
+}
+function calloutType(node) {
+  const raw = node.attributes?.type?.trim().toLowerCase() ?? "";
+  return HELP_CALLOUT_TYPES.includes(raw) ? raw : "info";
+}
+function codeInfo(lang, meta) {
+  const info = [lang ?? "", meta ?? ""].join(" ").trim();
+  const first = info.match(/^\S*/)?.[0] ?? "";
+  const language = first.includes("=") ? void 0 : first || void 0;
+  const match = /(?:^|\s)title=(?:"([^"]*)"|'([^']*)'|(\S+))/.exec(info);
+  const title = (match ? match[1] ?? match[2] ?? match[3] : void 0)?.trim() || void 0;
+  return { language, title };
+}
+var TRANSLITERATIONS = {
+  \u00E4: "ae",
+  \u00F6: "oe",
+  \u00FC: "ue",
+  \u00DF: "ss",
+  \u00E6: "ae",
+  \u0153: "oe",
+  \u00F8: "o",
+  \u00E5: "a",
+  \u0111: "d",
+  \u00F0: "d",
+  \u00FE: "th",
+  \u0142: "l",
+  \u0131: "i"
+};
+function headingSlug(text) {
+  return text.normalize("NFC").toLowerCase().replace(/[äöüßæœøåđðþłı]/g, (ch) => TRANSLITERATIONS[ch] ?? ch).normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 96).replace(/-+$/, "");
+}
+function collectHeadings(root) {
+  const out = [];
+  const walk = (node) => {
+    if (node.type === "heading") out.push(node);
+    if ("children" in node) for (const child of node.children) walk(child);
+  };
+  walk(root);
+  return out;
+}
+function headingIds(root, known) {
+  const headings = collectHeadings(root);
+  const ids = /* @__PURE__ */ new Map();
+  if (known && known.length === headings.length) {
+    headings.forEach((heading, index) => {
+      ids.set(heading, known[index]?.id ?? "");
+    });
+    return ids;
+  }
+  const used = /* @__PURE__ */ new Map();
+  for (const heading of headings) {
+    const text = plainText(heading).replace(/\s+/g, " ").trim();
+    const base = headingSlug(text) || "section";
+    const seen = used.get(base) ?? 0;
+    used.set(base, seen + 1);
+    ids.set(heading, seen === 0 ? base : `${base}-${seen + 1}`);
+  }
+  return ids;
+}
+var PLAIN_CODE_COLORS = {
+  "--shiki-light": "var(--color-fd-foreground)",
+  "--shiki-dark": "var(--color-fd-foreground)"
+};
+var helpBodyComponents = {
+  Callout: ({ type, title, children }) => /* @__PURE__ */ jsx(Callout, { type, title, children }),
+  Steps: ({ children }) => /* @__PURE__ */ jsx(Steps, { children }),
+  Step: ({ title, children }) => /* @__PURE__ */ jsxs(Step, { children: [
+    title ? /* @__PURE__ */ jsx("h3", { children: title }) : null,
+    children
+  ] }),
+  Tabs: ({ items, children }) => /* @__PURE__ */ jsx(Tabs, { items, children }),
+  Tab: ({ value, children }) => /* @__PURE__ */ jsx(Tab, { value, children }),
+  Cards: ({ children }) => /* @__PURE__ */ jsx(Cards, { children }),
+  Card: ({ title, href, icon, children }) => /* @__PURE__ */ jsx(Card, { title, href, icon, children }),
+  Code: ({ code, lang, title }) => /* @__PURE__ */ jsx(CodeBlock, { title, children: /* @__PURE__ */ jsx(Pre, { children: /* @__PURE__ */ jsx("code", { className: lang ? `language-${lang}` : void 0, style: PLAIN_CODE_COLORS, children: code.split("\n").map((line, index) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+    /* @__PURE__ */ jsxs("span", { className: "line", children: [
+      line,
+      "\n"
+    ] }, index)
+  )) }) }) }),
+  Heading: ({ level, id, children }) => {
+    const as = `h${level}`;
+    return /* @__PURE__ */ jsx(Heading, { as, id, children });
+  },
+  Link: ({ href, title, children }) => /* @__PURE__ */ jsx("a", { href, title, children }),
+  Image: ({ src, alt, title }) => /* @__PURE__ */ jsx("img", { src, alt, title, loading: "lazy" })
+};
+var normalizeId = (id) => id.trim().replace(/\s+/g, " ").toLowerCase();
+function collectDefinitions(root) {
+  const out = /* @__PURE__ */ new Map();
+  const walk = (node) => {
+    if (node.type === "definition") {
+      const key = normalizeId(node.identifier);
+      if (!out.has(key)) out.set(key, node);
+    }
+    if ("children" in node) for (const child of node.children) walk(child);
+  };
+  walk(root);
+  return out;
+}
+function renderAll(nodes, ctx) {
+  return nodes.map((node, index) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+    /* @__PURE__ */ jsx(Fragment$1, { children: renderNode(node, ctx) }, index)
+  ));
+}
+var literalBlock = (text) => /* @__PURE__ */ jsx("p", { children: text });
+function renderImage(node, ctx) {
+  const src = safeHelpImageSrc(node.url);
+  if (!src) return node.alt ?? "";
+  return /* @__PURE__ */ jsx(ctx.c.Image, { src, alt: node.alt ?? "", title: node.title ?? void 0 });
+}
+function renderLink(href, title, children, ctx) {
+  const safe = safeHelpHref(href);
+  if (ctx.linkless || !safe) return children;
+  return /* @__PURE__ */ jsx(ctx.c.Link, { href: safe, title: title ?? void 0, children });
+}
+function renderParagraph(node, ctx) {
+  const parts = node.children.filter((child) => !(child.type === "text" && !child.value.trim()));
+  const only = parts.length === 1 ? parts[0] : void 0;
+  if (only?.type === "image" && only.title && safeHelpImageSrc(only.url)) {
+    return /* @__PURE__ */ jsxs("figure", { children: [
+      renderImage(only, ctx),
+      /* @__PURE__ */ jsx("figcaption", { children: only.title })
+    ] });
+  }
+  const inner = renderAll(node.children, { ...ctx, inline: true });
+  return ctx.tight ? inner : /* @__PURE__ */ jsx("p", { children: inner });
+}
+function renderList(node, ctx) {
+  const tight = !node.spread && node.children.every((item) => !item.spread);
+  const items = node.children.map((item, index) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+    /* @__PURE__ */ jsxs("li", { children: [
+      typeof item.checked === "boolean" ? /* @__PURE__ */ jsx("input", { type: "checkbox", checked: item.checked, disabled: true, readOnly: true }) : null,
+      renderAll(item.children, { ...ctx, tight })
+    ] }, index)
+  ));
+  if (node.ordered) {
+    return /* @__PURE__ */ jsx("ol", { start: node.start != null && node.start !== 1 ? node.start : void 0, children: items });
+  }
+  return /* @__PURE__ */ jsx("ul", { children: items });
+}
+function renderTable(node, ctx) {
+  const [head, ...body] = node.children;
+  const align = (index) => node.align?.[index] ?? void 0;
+  const cells = (row, Tag) => row.children.map((cell, index) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+    /* @__PURE__ */ jsx(Tag, { style: align(index) ? { textAlign: align(index) ?? void 0 } : void 0, children: renderAll(cell.children, { ...ctx, inline: true }) }, index)
+  ));
+  return /* @__PURE__ */ jsxs("table", { children: [
+    head ? /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsx("tr", { children: cells(head, "th") }) }) : null,
+    body.length ? /* @__PURE__ */ jsx("tbody", { children: body.map((row, index) => (
+      // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+      /* @__PURE__ */ jsx("tr", { children: cells(row, "td") }, index)
+    )) }) : null
+  ] });
+}
+function tabItems(titles) {
+  const seen = /* @__PURE__ */ new Map();
+  return titles.map((title, index) => {
+    const base = title || String(index + 1);
+    const count = (seen.get(base) ?? 0) + 1;
+    seen.set(base, count);
+    return count === 1 ? base : `${base} (${count})`;
+  });
+}
+var isDirective = (node, name) => node.type === "containerDirective" && node.name === name;
+function renderCard(node, ctx) {
+  const href = node.attributes?.href ? safeHelpHref(node.attributes.href) : null;
+  const iconName = node.attributes?.icon?.trim();
+  const icon = iconName && /^[A-Za-z][A-Za-z0-9]{0,47}$/.test(iconName) && ctx.icon ? ctx.icon(iconName) : void 0;
+  return /* @__PURE__ */ jsx(ctx.c.Card, { title: directiveTitle(node) ?? "", href: href ?? void 0, icon, children: renderAll(contentOf(node), { ...ctx, linkless: ctx.linkless || !!href }) });
+}
+function renderTabs(children, ctx) {
+  const tabs = children.filter((child) => isDirective(child, "tab"));
+  const items = tabItems(tabs.map(directiveTitle));
+  let index = 0;
+  return /* @__PURE__ */ jsx(ctx.c.Tabs, { items, children: children.map((child, i) => {
+    if (!isDirective(child, "tab")) {
+      return /* @__PURE__ */ jsx(Fragment$1, { children: renderNode(child, ctx) }, i);
+    }
+    const value = items[index++] ?? "";
+    return (
+      // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+      /* @__PURE__ */ jsx(ctx.c.Tab, { value, children: renderAll(contentOf(child), ctx) }, i)
+    );
+  }) });
+}
+function renderDirective(node, ctx) {
+  const { c } = ctx;
+  if (!isHelpBlock(node.name)) {
+    const source = sourceOf(node, ctx.markdown);
+    const lines = source.split("\n");
+    const closing = lines.length > 1 && /^\s*:{3,}\s*$/.test(lines.at(-1) ?? "");
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      literalBlock(lines[0] ?? ""),
+      renderAll(contentOf(node), ctx),
+      closing ? literalBlock(lines.at(-1)?.trim() ?? "") : null
+    ] });
+  }
+  const content = contentOf(node);
+  const title = directiveTitle(node);
+  switch (node.name) {
+    case "callout":
+      return /* @__PURE__ */ jsx(c.Callout, { type: calloutType(node), title, children: renderAll(content, ctx) });
+    case "steps":
+      return /* @__PURE__ */ jsx(c.Steps, { children: content.map(
+        (child, i) => isDirective(child, "step") ? (
+          // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+          /* @__PURE__ */ jsx(c.Step, { title: directiveTitle(child), children: renderAll(contentOf(child), ctx) }, i)
+        ) : (
+          // A loose block between steps becomes a step of its own.
+          // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+          /* @__PURE__ */ jsx(c.Step, { children: renderNode(child, ctx) }, i)
+        )
+      ) });
+    case "step":
+      return /* @__PURE__ */ jsx(c.Steps, { children: /* @__PURE__ */ jsx(c.Step, { title, children: renderAll(content, ctx) }) });
+    case "tabs":
+      return renderTabs(content, ctx);
+    case "tab":
+      return renderTabs([node], ctx);
+    case "cards":
+      return /* @__PURE__ */ jsx(c.Cards, { children: content.map(
+        (child, i) => isDirective(child, "card") ? (
+          // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+          /* @__PURE__ */ jsx(Fragment$1, { children: renderCard(child, ctx) }, i)
+        ) : (
+          // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+          /* @__PURE__ */ jsx(Fragment$1, { children: renderNode(child, ctx) }, i)
+        )
+      ) });
+    case "card":
+      return /* @__PURE__ */ jsx(c.Cards, { children: renderCard(node, ctx) });
+  }
+}
+function renderNode(node, ctx) {
+  const { c } = ctx;
+  switch (node.type) {
+    case "root":
+      return renderAll(node.children, ctx);
+    case "paragraph":
+      return renderParagraph(node, ctx);
+    case "heading":
+      return /* @__PURE__ */ jsx(c.Heading, { level: node.depth, id: ctx.ids.get(node) ?? "", children: renderAll(node.children, { ...ctx, inline: true }) });
+    case "text":
+      return node.value;
+    case "emphasis":
+      return /* @__PURE__ */ jsx("em", { children: renderAll(node.children, ctx) });
+    case "strong":
+      return /* @__PURE__ */ jsx("strong", { children: renderAll(node.children, ctx) });
+    case "delete":
+      return /* @__PURE__ */ jsx("del", { children: renderAll(node.children, ctx) });
+    case "inlineCode":
+      return /* @__PURE__ */ jsx("code", { children: node.value });
+    case "break":
+      return /* @__PURE__ */ jsx("br", {});
+    case "thematicBreak":
+      return /* @__PURE__ */ jsx("hr", {});
+    case "blockquote":
+      return /* @__PURE__ */ jsx("blockquote", { children: renderAll(node.children, { ...ctx, tight: false }) });
+    case "list":
+      return renderList(node, ctx);
+    case "listItem":
+      return /* @__PURE__ */ jsx("li", { children: renderAll(node.children, ctx) });
+    case "table":
+      return renderTable(node, ctx);
+    case "code": {
+      const { language, title } = codeInfo(node.lang, node.meta);
+      return /* @__PURE__ */ jsx(c.Code, { code: node.value, lang: language, title });
+    }
+    // Raw HTML is shown as text, never as markup.
+    case "html":
+      return ctx.inline ? node.value : literalBlock(node.value.trim());
+    case "link":
+      return renderLink(node.url, node.title, renderAll(node.children, ctx), ctx);
+    case "image":
+      return renderImage(node, ctx);
+    case "linkReference": {
+      const definition = ctx.definitions.get(normalizeId(node.identifier));
+      if (!definition) return sourceOf(node, ctx.markdown);
+      return renderLink(definition.url, definition.title, renderAll(node.children, ctx), ctx);
+    }
+    case "imageReference": {
+      const definition = ctx.definitions.get(normalizeId(node.identifier));
+      if (!definition) return sourceOf(node, ctx.markdown);
+      return renderImage({ url: definition.url, alt: node.alt, title: definition.title }, ctx);
+    }
+    case "definition":
+      return null;
+    case "containerDirective":
+      return renderDirective(node, { ...ctx, tight: false });
+    // Not ours: printed back as written.
+    case "leafDirective":
+    case "footnoteDefinition":
+      return literalBlock(sourceOf(node, ctx.markdown));
+    case "textDirective":
+    case "footnoteReference":
+      return sourceOf(node, ctx.markdown);
+    default:
+      return "children" in node ? renderAll(node.children, ctx) : "value" in node ? String(node.value) : plainText(node);
+  }
+}
+function HelpBody({ markdown, headings, components, icon }) {
+  const source = markdown ?? "";
+  const root = parseHelpMarkdown(source);
+  const ctx = {
+    markdown: source,
+    ids: headingIds(root, headings),
+    c: { ...helpBodyComponents, ...components },
+    icon,
+    definitions: collectDefinitions(root),
+    linkless: false,
+    tight: false,
+    inline: false
+  };
+  return /* @__PURE__ */ jsx(Fragment, { children: renderNode(root, ctx) });
+}
+
+// ../sdk-core/src/webhook.ts
+function encoder() {
+  const Encoder = globalThis.TextEncoder;
+  if (!Encoder) throw new Error("TextEncoder is not available in this runtime.");
+  return new Encoder();
+}
+function bytesOf(body) {
+  if (typeof body === "string") return encoder().encode(body);
+  return body instanceof Uint8Array ? body : new Uint8Array(body);
+}
+function hex(buffer) {
+  let out = "";
+  for (const byte of new Uint8Array(buffer)) out += byte.toString(16).padStart(2, "0");
+  return out;
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+function parseHeader(header) {
+  let t = Number.NaN;
+  const signatures = [];
+  for (const part of header.split(",")) {
+    const index = part.indexOf("=");
+    if (index < 0) continue;
+    const key = part.slice(0, index).trim();
+    const value = part.slice(index + 1).trim();
+    if (key === "t" && /^\d{1,12}$/.test(value)) t = Number(value);
+    else if (key === "v1" && /^[0-9a-f]{64}$/i.test(value)) signatures.push(value.toLowerCase());
+  }
+  return Number.isFinite(t) && signatures.length > 0 ? { t, signatures } : null;
+}
+async function verifyWebhookSignature(secret, rawBody, header, options = {}) {
+  if (!secret || !header || header.length > 1e3) return false;
+  const parsed = parseHeader(header);
+  if (!parsed) return false;
+  const now = options.now instanceof Date ? options.now.getTime() : options.now ?? Date.now();
+  const tolerance = options.toleranceSeconds ?? 300;
+  if (Math.abs(now / 1e3 - parsed.t) > tolerance) return false;
+  const subtle = options.crypto?.subtle ?? globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new Error(
+      "Web Crypto is not available: pass `crypto` (on Node 18: require('node:crypto').webcrypto)."
+    );
+  }
+  const text = encoder();
+  const key = await subtle.importKey(
+    "raw",
+    text.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const prefix = text.encode(`${parsed.t}.`);
+  const body = bytesOf(rawBody);
+  const signed = new Uint8Array(prefix.length + body.length);
+  signed.set(prefix, 0);
+  signed.set(body, prefix.length);
+  const expected = hex(await subtle.sign("HMAC", key, signed));
+  let ok = false;
+  for (const signature of parsed.signatures) ok = constantTimeEqual(expected, signature) || ok;
+  return ok;
+}
+
+// src/fumadocs/revalidate.ts
+function createHelpRevalidateHandler(options) {
+  return async (request) => {
+    if (!options.secret) {
+      return new Response("Webhook secret is not configured", { status: 500 });
+    }
+    const raw = await request.text();
+    const signature = request.headers.get("x-solutiondesk-signature");
+    if (!await verifyWebhookSignature(options.secret, raw, signature, options.verifyOptions)) {
+      return new Response("Invalid signature", { status: 401 });
+    }
+    const body = parseBody(raw);
+    if (!body) return new Response("Malformed body", { status: 400 });
+    if (body.event !== "ping" || options.includePing) await options.revalidate(body);
+    return new Response(null, { status: 204 });
+  };
+}
+function parseBody(raw) {
+  let body;
+  try {
+    body = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof body !== "object" || body === null) return null;
+  const { event, path, previousPaths } = body;
+  if (typeof event !== "string") return null;
+  if (path !== null && path !== void 0 && typeof path !== "string") return null;
+  if (previousPaths !== void 0 && !Array.isArray(previousPaths)) return null;
+  return body;
+}
+
+// src/fumadocs/structured.ts
+function helpStructuredData(markdown, headings) {
+  const root = parseHelpMarkdown(markdown);
+  const ids = headingIds(root, headings);
+  const out = { headings: [], contents: [] };
+  let current;
+  const text = (node) => plainText(node).replace(/\s+/g, " ").trim();
+  const walk = (node) => {
+    if (node.type === "heading") {
+      current = ids.get(node);
+      const content = text(node);
+      if (current && content) out.headings.push({ id: current, content });
+      return;
+    }
+    if (node.type === "paragraph" || node.type === "tableCell") {
+      const content = text(node);
+      if (content) out.contents.push({ heading: current, content });
+      return;
+    }
+    if (node.type === "code" || node.type === "html" || node.type === "definition") return;
+    if ("children" in node) for (const child of node.children) walk(child);
+  };
+  walk(root);
+  return out;
+}
+
+// src/fumadocs/source.ts
+var linkTitle = (title) => title.replace(/[[\]]/g, "").trim() || "Link";
+var linkUrl = (url) => url.replace(/\)/g, "%29").replace(/\s/g, "%20");
+var lastSegment = (path) => path.split("/").at(-1) ?? path;
+var slugsOf = (path) => path ? path.split("/") : [];
+var pageFileName = (page) => {
+  if (!page.path) return "index";
+  const name = lastSegment(page.path);
+  return name === "index" ? "index_" : name;
+};
+function helpMetaEntry(node) {
+  switch (node.type) {
+    case "page":
+      return pageFileName(node);
+    case "folder":
+      return node.slug;
+    case "separator": {
+      const title = node.title?.replace(/---/g, "\u2013").trim();
+      if (!title) return "---";
+      return `---${node.icon ? `[${node.icon}]` : ""}${title}---`;
+    }
+    case "link":
+      return `${node.external ? "external:" : ""}${node.icon ? `[${node.icon}]` : ""}[${linkTitle(node.title)}](${linkUrl(node.url)})`;
+  }
+}
+function helpTreeToFiles(payload, options) {
+  const files = [];
+  const ext = (name, extension) => `${name}${options.suffix ? `.${options.suffix}` : ""}.${extension}`;
+  const join = (dir, name) => dir ? `${dir}/${name}` : name;
+  const seen = /* @__PURE__ */ new Set();
+  const addPage = (page, file) => {
+    if (seen.has(file)) return;
+    seen.add(file);
+    const isPrefetched = options.prefetched?.has(page.path) ?? false;
+    const prefetched = options.prefetched?.get(page.path) ?? null;
+    const load = isPrefetched ? async () => prefetched : () => options.load(page.path);
+    const data = {
+      title: page.title,
+      ...page.description ? { description: page.description } : {},
+      ...page.icon ? { icon: page.icon } : {},
+      path: page.path,
+      lang: options.lang,
+      load,
+      structuredData: async () => {
+        const full = await load();
+        return full ? helpStructuredData(full.markdown, full.headings) : { headings: [], contents: [] };
+      },
+      ...prefetched ? { page: prefetched } : {}
+    };
+    files.push({ type: "page", path: file, slugs: slugsOf(page.path), data });
+  };
+  const addFolder = (folder, dir) => {
+    if (folder.index) addPage(folder.index, join(dir, ext("index", "mdx")));
+    const data = {
+      title: folder.title,
+      ...folder.icon ? { icon: folder.icon } : {},
+      ...folder.root ? { root: true } : {},
+      defaultOpen: folder.defaultOpen,
+      collapsible: folder.collapsible,
+      ...folder.index ? { pagesIndex: "index" } : {},
+      pages: folder.children.map(helpMetaEntry)
+    };
+    files.push({ type: "meta", path: join(dir, ext("meta", "json")), data });
+    addChildren(folder.children, dir);
+  };
+  const addChildren = (nodes, dir) => {
+    for (const node of nodes) {
+      if (node.type === "page") {
+        addPage(node, node.path ? join(dir, ext(pageFileName(node), "mdx")) : ext("index", "mdx"));
+      } else if (node.type === "folder") {
+        addFolder(node, join(dir, node.slug));
+      }
+    }
+  };
+  files.push({
+    type: "meta",
+    path: ext("meta", "json"),
+    data: { title: payload.site.name, pages: payload.tree.map(helpMetaEntry) }
+  });
+  addChildren(payload.tree, "");
+  return files;
+}
+function helpTreePaths(tree) {
+  const out = [];
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (node.type === "page") out.push(node.path);
+      else if (node.type === "folder") {
+        if (node.index) out.push(node.index.path);
+        walk(node.children);
+      }
+    }
+  };
+  walk(tree);
+  return out;
+}
+var isNotFoundError = (error) => error instanceof Error && error.name === "SolutionDeskError" && error.status === 404;
+async function mapLimit(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const index = next++;
+      out[index] = await fn(items[index]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, worker));
+  return out;
+}
+async function createHelpSource(client, options = {}) {
+  const { requestOptions } = options;
+  const languages = options.languages?.length ? [...options.languages] : [void 0];
+  const files = await Promise.all(
+    languages.map(async (lang) => {
+      const payload = await client.site(lang ? { lang } : {}, requestOptions);
+      const forLang = lang ?? payload.locale;
+      const load = async (path) => {
+        try {
+          return (await client.page(path, { lang: forLang }, requestOptions)).page;
+        } catch (error) {
+          if (isNotFoundError(error)) return null;
+          throw error;
+        }
+      };
+      let prefetched;
+      if (options.pages === "eager") {
+        const paths = helpTreePaths(payload.tree);
+        const pages = await mapLimit(paths, options.concurrency ?? 6, load);
+        prefetched = new Map(paths.map((path, index) => [path, pages[index] ?? null]));
+      }
+      return helpTreeToFiles(payload, {
+        lang: forLang,
+        load,
+        ...lang ? { suffix: lang } : {},
+        ...prefetched ? { prefetched } : {}
+      });
+    })
+  );
+  return { files: files.flat() };
+}
+function helpDynamicSource(client, options = {}) {
+  return { files: async () => (await createHelpSource(client, options)).files };
+}
+
+// src/fumadocs/toc.ts
+function getHelpToc(headings, options = {}) {
+  const list = "headings" in headings ? headings.headings : headings;
+  const min = options.minLevel ?? 1;
+  const max = options.maxLevel ?? 6;
+  return list.filter((heading) => heading.level >= min && heading.level <= max && heading.id).map((heading) => ({ title: heading.text, url: `#${heading.id}`, depth: heading.level }));
+}
+
+export { HELP_BLOCKS, HELP_CALLOUT_TYPES, HelpBody, createHelpRevalidateHandler, createHelpSource, getHelpToc, helpBodyComponents, helpDynamicSource, helpMetaEntry, helpStructuredData, helpTreePaths, helpTreeToFiles, safeHelpHref };