@thallylabs/migrate 0.2.27 → 0.2.29

package/dist/url-migration.js

@@ -0,0 +1,3872 @@
+// src/url-run.ts
+import { createHash } from "crypto";
+import { load as load2 } from "cheerio";
+import remarkParse3 from "remark-parse";
+import remarkMdx3 from "remark-mdx";
+import { unified as unified3 } from "unified";
+
+// src/navigation.ts
+import { existsSync, lstatSync, readFileSync, realpathSync as realpathSync2 } from "fs";
+import { dirname, extname as extname2, relative as relative2 } from "path";
+
+// src/mintlify-extras.ts
+import { extname } from "path";
+
+// src/path.ts
+import { realpathSync } from "fs";
+import { isAbsolute, relative, resolve, sep } from "path";
+var SAFE_SEGMENT = /[^a-z0-9._-]+/gi;
+function slugifySegment(value, preserveCase = false) {
+  let decoded = value;
+  try {
+    decoded = decodeURIComponent(value);
+  } catch {
+  }
+  const normalized = preserveCase ? decoded : decoded.toLowerCase();
+  const slug = normalized.replace(/\.(?:html?|mdx?)$/i, "").replace(SAFE_SEGMENT, "-").replace(/(^-|-$)/g, "");
+  return slug === "." || slug === ".." ? "" : slug;
+}
+function pageIdFromReference(value, preserveCase = false) {
+  const withoutQuery = value.split(/[?#]/, 1)[0].replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!withoutQuery || withoutQuery.includes("\0")) return null;
+  const rawSegments = withoutQuery.split("/").filter(Boolean);
+  if (rawSegments.some((segment) => segment === ".." || segment === ".")) return null;
+  const last = rawSegments.at(-1)?.replace(/\.(?:mdx?|rst|txt)$/i, "") ?? "";
+  const isRootLevelReadme = rawSegments.length === 1 && /^readme$/i.test(last);
+  const collapsesToParent = /^index$/i.test(last) || isRootLevelReadme;
+  const baseSegments = collapsesToParent ? rawSegments.slice(0, -1) : rawSegments;
+  if (!collapsesToParent) {
+    baseSegments[baseSegments.length - 1] = last;
+  }
+  const segments = baseSegments.map((segment) => slugifySegment(segment, preserveCase)).filter(Boolean);
+  return segments.join("/") || "introduction";
+}
+
+// src/mintlify-extras.ts
+var OPEN_NAVIGATION_ACCESS = Object.freeze({ hasPublicFalse: false, hasPublicTrue: false });
+function playgroundDisplay(value, where, warn) {
+  const mode = typeof value === "string" ? value.trim().toLowerCase() : "";
+  if (mode === "interactive" || mode === "simple" || mode === "none") return mode;
+  if (mode === "auth") {
+    warn?.(`${where} "auth" requires reader sign-in, which Thally does not support. Migrated as "simple" (no Try it). Set it to "interactive" to allow everyone.`);
+    return "simple";
+  }
+  warn?.(`${where} is not one of interactive, simple, none, auth and was dropped.`);
+  return void 0;
+}
+
+// src/navigation.ts
+function titleCase(value) {
+  return value.split(/[-_]/).map((word) => ["api", "cli", "sdk", "ui"].includes(word.toLowerCase()) ? word.toUpperCase() : word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+var TOP_LEVEL_LABELS = {
+  "api-reference": "API Reference",
+  cli: "CLI",
+  faqs: "FAQs",
+  introduction: "Overview",
+  "mcp-server": "MCP Server",
+  sdk: "SDK"
+};
+function topLevelLabel(segment) {
+  return TOP_LEVEL_LABELS[segment] ?? titleCase(segment);
+}
+function groupsWithinSection(section, pageIds, sectionLabel = topLevelLabel(section)) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const id of pageIds) {
+    const relative4 = id === "introduction" ? "" : id.startsWith(`${section}/`) ? id.slice(section.length + 1) : id;
+    const nestedSegment = relative4.includes("/") ? relative4.split("/", 1)[0] : "overview";
+    const group = groups.get(nestedSegment) ?? [];
+    group.push(id);
+    groups.set(nestedSegment, group);
+  }
+  return [...groups].map(([segment, pages]) => ({
+    group: segment === "overview" ? sectionLabel : titleCase(segment),
+    pages
+  }));
+}
+function preferredLandingPage(section, pageIds) {
+  const candidates = [
+    section === "introduction" ? "introduction" : void 0,
+    `${section}/overview`,
+    `${section}/introduction`,
+    section
+  ];
+  return candidates.find((candidate) => Boolean(candidate && pageIds.includes(candidate)));
+}
+function buildNavigationFromPages(pages, options = {}) {
+  const ids = pages.filter((page) => !page.locale || page.locale === "en").map((page) => page.navigationId);
+  const ordered = [...new Set(ids)];
+  if (options.topLevelTabs) {
+    const sourceNavigation2 = (options.topLevelNavigation ?? []).flatMap((entry) => {
+      const sectionPages = ordered.filter((id) => id === entry.section || id.startsWith(`${entry.section}/`));
+      const pageId = ordered.includes(entry.pageId) ? entry.pageId : preferredLandingPage(entry.section, sectionPages) ?? sectionPages[0];
+      return pageId ? [{ ...entry, pageId }] : [];
+    });
+    if (sourceNavigation2.length > 1) {
+      const claimedIds = /* @__PURE__ */ new Set();
+      const tabs = sourceNavigation2.map((entry) => {
+        const pageIds = ordered.filter((id) => {
+          const matches = id === entry.pageId || id === entry.section || id.startsWith(`${entry.section}/`);
+          if (matches) claimedIds.add(id);
+          return matches;
+        });
+        return { entry, pageIds };
+      });
+      tabs[0].pageIds.push(...ordered.filter((id) => !claimedIds.has(id)));
+      return {
+        tabs: tabs.map(({ entry, pageIds }) => ({
+          tab: entry.label,
+          href: entry.pageId === "introduction" ? "/" : `/${entry.pageId}`,
+          groups: groupsWithinSection(entry.section, [...new Set(pageIds)], entry.label)
+        }))
+      };
+    }
+    const sectionNames = [...new Set(ordered.filter((id) => id.includes("/")).map((id) => id.split("/", 1)[0]))];
+    if (sectionNames.length > 1) {
+      const defaultSection = sectionNames.includes("introduction") ? "introduction" : sectionNames[0];
+      const sections = /* @__PURE__ */ new Map();
+      for (const id of ordered) {
+        const section = id.includes("/") ? id.split("/", 1)[0] : defaultSection;
+        const bucket = sections.get(section) ?? [];
+        bucket.push(id);
+        sections.set(section, bucket);
+      }
+      return {
+        tabs: [...sections].map(([section, pageIds]) => {
+          const label = topLevelLabel(section);
+          const landingPage = preferredLandingPage(section, pageIds);
+          return {
+            tab: label,
+            ...landingPage ? { href: landingPage === "introduction" ? "/" : `/${landingPage}` } : {},
+            groups: groupsWithinSection(section, pageIds)
+          };
+        })
+      };
+    }
+  }
+  const buckets = /* @__PURE__ */ new Map();
+  for (const id of ordered) {
+    const segment = id.includes("/") ? id.split("/", 1)[0] : "overview";
+    const bucket = buckets.get(segment) ?? [];
+    bucket.push(id);
+    buckets.set(segment, bucket);
+  }
+  const groups = [...buckets].map(([segment, pageIds]) => ({
+    group: segment === "overview" ? "Overview" : titleCase(segment),
+    pages: pageIds
+  }));
+  return { tabs: [{ tab: "Documentation", groups }] };
+}
+
+// src/svg-policy.ts
+import { Parser } from "htmlparser2";
+var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+var XLINK_NAMESPACE = "http://www.w3.org/1999/xlink";
+var ALLOWED_ELEMENTS = /* @__PURE__ */ new Set([
+  "svg",
+  "g",
+  "defs",
+  "symbol",
+  "use",
+  "title",
+  "desc",
+  "path",
+  "rect",
+  "circle",
+  "ellipse",
+  "line",
+  "polyline",
+  "polygon",
+  "text",
+  "tspan",
+  "textpath",
+  "lineargradient",
+  "radialgradient",
+  "stop",
+  "clippath",
+  "mask",
+  "pattern",
+  "marker",
+  "filter",
+  "feblend",
+  "fecolormatrix",
+  "fecomponenttransfer",
+  "fecomposite",
+  "feconvolvematrix",
+  "fediffuselighting",
+  "fedisplacementmap",
+  "fedistantlight",
+  "fedropshadow",
+  "feflood",
+  "fefunca",
+  "fefuncb",
+  "fefuncg",
+  "fefuncr",
+  "fegaussianblur",
+  "femerge",
+  "femergenode",
+  "femorphology",
+  "feoffset",
+  "fepointlight",
+  "fespecularlighting",
+  "fespotlight",
+  "fetile",
+  "feturbulence"
+]);
+var ALLOWED_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "xmlns",
+  "xmlns:xlink",
+  "xml:space",
+  "version",
+  "baseprofile",
+  "id",
+  "class",
+  "viewbox",
+  "preserveaspectratio",
+  "width",
+  "height",
+  "x",
+  "y",
+  "x1",
+  "y1",
+  "x2",
+  "y2",
+  "cx",
+  "cy",
+  "r",
+  "rx",
+  "ry",
+  "d",
+  "points",
+  "pathlength",
+  "transform",
+  "transform-origin",
+  "fill",
+  "fill-opacity",
+  "fill-rule",
+  "stroke",
+  "stroke-width",
+  "stroke-opacity",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-miterlimit",
+  "stroke-dasharray",
+  "stroke-dashoffset",
+  "opacity",
+  "color",
+  "display",
+  "visibility",
+  "overflow",
+  "clip-path",
+  "clip-rule",
+  "clippathunits",
+  "mask",
+  "maskunits",
+  "maskcontentunits",
+  "filter",
+  "filterunits",
+  "primitiveunits",
+  "marker-start",
+  "marker-mid",
+  "marker-end",
+  "markerwidth",
+  "markerheight",
+  "markerunits",
+  "refx",
+  "refy",
+  "orient",
+  "patternunits",
+  "patterncontentunits",
+  "patterntransform",
+  "gradientunits",
+  "gradienttransform",
+  "spreadmethod",
+  "fx",
+  "fy",
+  "fr",
+  "offset",
+  "stop-color",
+  "stop-opacity",
+  "font-family",
+  "font-size",
+  "font-weight",
+  "font-style",
+  "font-variant",
+  "letter-spacing",
+  "word-spacing",
+  "text-anchor",
+  "dominant-baseline",
+  "alignment-baseline",
+  "baseline-shift",
+  "text-decoration",
+  "dx",
+  "dy",
+  "rotate",
+  "textlength",
+  "lengthadjust",
+  "startoffset",
+  "writing-mode",
+  "direction",
+  "unicode-bidi",
+  "shape-rendering",
+  "text-rendering",
+  "image-rendering",
+  "color-interpolation",
+  "color-interpolation-filters",
+  "vector-effect",
+  "paint-order",
+  "mix-blend-mode",
+  "isolation",
+  "in",
+  "in2",
+  "result",
+  "stddeviation",
+  "mode",
+  "type",
+  "values",
+  "tablevalues",
+  "slope",
+  "intercept",
+  "amplitude",
+  "exponent",
+  "operator",
+  "k1",
+  "k2",
+  "k3",
+  "k4",
+  "radius",
+  "scale",
+  "xchannelselector",
+  "ychannelselector",
+  "basefrequency",
+  "numoctaves",
+  "seed",
+  "stitchtiles",
+  "flood-color",
+  "flood-opacity",
+  "lighting-color",
+  "surfacescale",
+  "diffuseconstant",
+  "specularconstant",
+  "specularexponent",
+  "kernelmatrix",
+  "kernelunitlength",
+  "order",
+  "divisor",
+  "bias",
+  "targetx",
+  "targety",
+  "edgemode",
+  "preservealpha",
+  "azimuth",
+  "elevation",
+  "z",
+  "pointsatx",
+  "pointsaty",
+  "pointsatz",
+  "limitingconeangle",
+  "aria-hidden",
+  "aria-label",
+  "role",
+  "focusable",
+  // Validated below: only in-document fragment references.
+  "href",
+  "xlink:href"
+]);
+function hasExternalReference(value) {
+  if (value.includes("\\")) return true;
+  const compact = value.replace(/[\u0000- ]/gu, "").toLowerCase();
+  if (/(?:java|vb)script:|data:|expression\(|@import|<|>/u.test(compact)) {
+    return true;
+  }
+  for (const match of compact.matchAll(/url\(([^)]*)\)/gu)) {
+    if (!/^["']?#[a-z0-9_.:-]+["']?$/u.test(match[1])) return true;
+  }
+  return compact.replace(/url\(([^)]*)\)/gu, "").includes("url(");
+}
+function utf8SvgText(content) {
+  const hasUtf8Bom = content[0] === 239 && content[1] === 187 && content[2] === 191;
+  const body = hasUtf8Bom ? content.subarray(3) : content;
+  if (body[0] === 254 && body[1] === 255 || body[0] === 255 && body[1] === 254 || body[0] === 0 && body[1] === 0 || body.includes(0)) {
+    return null;
+  }
+  const text = body.toString("utf8");
+  if (text.includes("\uFFFD")) return null;
+  const declaration = /^<\?xml\b[^>]*\?>/iu.exec(text);
+  if (declaration) {
+    const encoding = /\bencoding\s*=\s*["']([^"']*)["']/iu.exec(declaration[0]);
+    if (encoding && !/^utf-?8$/iu.test(encoding[1].trim())) return null;
+  } else if (/<\?xml\b/iu.test(text)) {
+    return null;
+  }
+  return text;
+}
+function isPassiveSvg(content) {
+  const text = utf8SvgText(Buffer.from(content.buffer, content.byteOffset, content.byteLength));
+  if (text === null) return false;
+  let isPassive = true;
+  let depth = 0;
+  let sawRoot = false;
+  const openStarts = [];
+  const fail = () => {
+    isPassive = false;
+  };
+  const parser3 = new Parser(
+    {
+      onopentag(name, attributes) {
+        const element = name.toLowerCase();
+        if (depth === 0) {
+          if (sawRoot || element !== "svg") fail();
+          sawRoot = true;
+        }
+        depth += 1;
+        openStarts.push(parser3.startIndex);
+        if (element.includes(":") || !ALLOWED_ELEMENTS.has(element)) fail();
+        for (const [rawName, value] of Object.entries(attributes)) {
+          const attribute = rawName.toLowerCase();
+          if (!ALLOWED_ATTRIBUTES.has(attribute)) {
+            fail();
+            continue;
+          }
+          if (attribute === "xmlns" && value !== SVG_NAMESPACE) fail();
+          if (attribute === "xmlns:xlink" && value !== XLINK_NAMESPACE) fail();
+          if ((attribute === "href" || attribute === "xlink:href") && !/^#[A-Za-z0-9_.:-]+$/u.test(value.trim())) {
+            fail();
+          }
+          if (hasExternalReference(value)) fail();
+        }
+      },
+      onclosetag(_name, isImplied) {
+        depth -= 1;
+        const start = openStarts.pop();
+        if (isImplied && start !== parser3.startIndex) fail();
+      },
+      // DOCTYPE (and with it custom entities) or any other declaration other
+      // than the XML prolog.
+      onprocessinginstruction(name) {
+        if (name.toLowerCase() !== "?xml") fail();
+      },
+      oncdatastart: fail,
+      ontext(value) {
+        if (depth === 0 && value.trim()) fail();
+      },
+      onerror: fail
+    },
+    { xmlMode: true, decodeEntities: true, recognizeSelfClosing: true }
+  );
+  try {
+    parser3.write(text);
+    parser3.end();
+  } catch {
+    return false;
+  }
+  return isPassive && sawRoot && depth === 0;
+}
+
+// src/url-asset-cache.ts
+function createMigrationAssetCache() {
+  const settled = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const remember = (url, asset) => {
+    settled.delete(url);
+    settled.set(url, asset);
+    if (settled.size > 480) settled.delete(settled.keys().next().value);
+    return asset;
+  };
+  const get = (url) => {
+    const asset = settled.get(url);
+    if (asset) return Promise.resolve(remember(url, asset));
+    return pending.get(url);
+  };
+  return {
+    remember,
+    get,
+    has(url) {
+      return settled.has(url) || pending.has(url);
+    },
+    get size() {
+      return settled.size + pending.size;
+    },
+    load(url, acquire) {
+      const existing = get(url);
+      if (existing) return existing;
+      const request = Promise.resolve().then(acquire).then((asset) => {
+        pending.delete(url);
+        return remember(url, asset);
+      }, (error) => {
+        pending.delete(url);
+        throw error;
+      });
+      pending.set(url, request);
+      return request;
+    },
+    delete(url) {
+      settled.delete(url);
+    }
+  };
+}
+
+// src/url-journal-clone.ts
+function cloneUrlMigrationCheckpoint(checkpoint) {
+  const ancestors = /* @__PURE__ */ new Set();
+  const clone = (value) => {
+    if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+    if (typeof value === "number") return Number.isFinite(value) ? value === 0 ? 0 : value : null;
+    if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol") return void 0;
+    if (typeof value !== "object") throw new TypeError("Checkpoint must contain JSON-safe values.");
+    if (ancestors.has(value)) throw new TypeError("Checkpoint must not contain circular references.");
+    if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new TypeError("Checkpoint must contain plain JSON containers.");
+    ancestors.add(value);
+    try {
+      if (Array.isArray(value)) return Array.from(value, (entry) => clone(entry) ?? null);
+      return Object.fromEntries(Object.entries(value).flatMap(([key, entry]) => {
+        const copied = clone(entry);
+        return copied === void 0 ? [] : [[key, copied]];
+      }));
+    } finally {
+      ancestors.delete(value);
+    }
+  };
+  return clone(checkpoint);
+}
+
+// src/url-images.ts
+function migrationImageUrl(value, base) {
+  const url = new URL(value, base);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new Error("Responsive image URL is not a credential-free HTTP(S) URL.");
+  return url.toString();
+}
+function migrationImageCandidates(value, base, resolve3 = true) {
+  if (value.length > 64e3) throw new Error("Responsive image candidate list exceeds its safety bound.");
+  const result = [];
+  let index = 0;
+  while (index < value.length) {
+    while (index < value.length && /[\t\n\f\r ,]/.test(value[index])) index++;
+    if (index === value.length) break;
+    const start = index;
+    while (index < value.length && !/[\t\n\f\r ]/.test(value[index])) index++;
+    let url = value.slice(start, index);
+    const hasTerminatingComma = url.endsWith(",");
+    if (hasTerminatingComma) url = url.replace(/,+$/, "");
+    const descriptorStart = index;
+    if (!hasTerminatingComma) while (index < value.length && value[index] !== ",") index++;
+    const descriptor = hasTerminatingComma ? "" : value.slice(descriptorStart, index).trim();
+    if (descriptor && !/^(?:[1-9]\d*w|(?:\d+(?:\.\d+)?|\.\d+)x)$/.test(descriptor)) throw new Error("Responsive image has an unsupported descriptor.");
+    if (descriptor.endsWith("x") && Number(descriptor.slice(0, -1)) <= 0) throw new Error("Responsive image density must be positive.");
+    const resolved = migrationImageUrl(url, base);
+    result.push({ url: resolve3 ? resolved : url, descriptor });
+    if (result.length > 128) throw new Error("Responsive image has too many candidates.");
+    if (value[index] === ",") index++;
+  }
+  if (!result.length) throw new Error("Responsive image has no candidates.");
+  return result;
+}
+function renderMigrationSrcset(candidates) {
+  return candidates.map((candidate) => `${candidate.url}${candidate.descriptor ? ` ${candidate.descriptor}` : ""}`).join(", ");
+}
+function migrationImageAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\{/g, "&#123;").replace(/\}/g, "&#125;").replace(/\r/g, "&#13;").replace(/\n/g, "&#10;");
+}
+
+// src/url.ts
+import { load } from "cheerio";
+import remarkMdx2 from "remark-mdx";
+import remarkParse2 from "remark-parse";
+import TurndownService from "turndown";
+import { unified as unified2 } from "unified";
+import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+
+// src/analytics.ts
+var HOSTNAME_LABEL = "[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?";
+var HOSTNAME = new RegExp(`^${HOSTNAME_LABEL}(?:\\.${HOSTNAME_LABEL})*$`);
+
+// src/mdx.ts
+import { posix } from "path";
+import { compileSync } from "@mdx-js/mdx";
+import { nameToEmoji } from "gemoji";
+import remarkGfm from "remark-gfm";
+import remarkMdx from "remark-mdx";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+
+// src/builtin-components.ts
+var THALLY_BUILTIN_COMPONENTS = /* @__PURE__ */ new Set([
+  "CodeGroup",
+  "Info",
+  "Warning",
+  "Check",
+  "Danger",
+  "Error",
+  "Note",
+  "Tip",
+  "Callout",
+  "AccordionGroup",
+  "Latex",
+  "Hero",
+  "Card",
+  "CardGroup",
+  "Columns",
+  "Frame",
+  "Accordion",
+  "Tooltip",
+  "Icon",
+  "Steps",
+  "Step",
+  "Tabs",
+  "Tab",
+  "Badge",
+  "Update",
+  "RequestExample",
+  "ResponseExample",
+  "Panel",
+  "ContentPanel",
+  "InlinePanel",
+  "InlineRequestExample",
+  "InlineResponseExample",
+  "Tile",
+  "TileGroup",
+  "Prompt",
+  "PromptUser",
+  "PromptAssistant",
+  "Terminal",
+  "TerminalInput",
+  "TerminalOutput",
+  "AgentPrompt",
+  "Color",
+  "Tree",
+  "Folder",
+  "File",
+  "ResponseField",
+  "ParamField",
+  "Expandable",
+  "Mermaid",
+  "View",
+  "Embed",
+  "LegacyView",
+  "GitHub",
+  "Github",
+  "Visibility",
+  "Human",
+  "Agent",
+  "BannerPreview",
+  "Banner",
+  "CodeBlock",
+  "Column",
+  "FileTree",
+  "LiteYouTubeEmbed",
+  "MDX",
+  "Video",
+  "YouTube"
+]);
+function isThallyBuiltinComponent(name) {
+  return THALLY_BUILTIN_COMPONENTS.has(name) || THALLY_BUILTIN_COMPONENTS.has(name.split(".")[0]);
+}
+
+// src/inline-extraction.ts
+import ts from "typescript";
+var SERVER_ONLY_IDENTIFIERS = /* @__PURE__ */ new Set(["process", "require", "module", "exports", "__dirname", "__filename", "Buffer"]);
+var BROWSER_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "window",
+  "document",
+  "localStorage",
+  "sessionStorage",
+  "navigator",
+  "location",
+  "history",
+  "IntersectionObserver",
+  "ResizeObserver",
+  "MutationObserver",
+  "matchMedia",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "alert",
+  "confirm",
+  "prompt",
+  "HTMLElement",
+  "Element",
+  "Node",
+  "Event",
+  "KeyboardEvent",
+  "MouseEvent",
+  "CustomEvent",
+  "FormData",
+  "File",
+  "FileReader",
+  "Image",
+  "Audio",
+  "XMLHttpRequest",
+  "WebSocket",
+  "getComputedStyle",
+  "innerWidth",
+  "innerHeight",
+  "scrollTo"
+]);
+var JS_GLOBALS = /* @__PURE__ */ new Set([
+  "undefined",
+  "NaN",
+  "Infinity",
+  "globalThis",
+  "arguments",
+  "Object",
+  "Function",
+  "Array",
+  "Number",
+  "Boolean",
+  "String",
+  "Symbol",
+  "BigInt",
+  "Date",
+  "RegExp",
+  "Error",
+  "AggregateError",
+  "EvalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError",
+  "JSON",
+  "Math",
+  "Intl",
+  "Reflect",
+  "Proxy",
+  "Promise",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "WeakRef",
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "DataView",
+  "Atomics",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURI",
+  "encodeURIComponent",
+  "decodeURI",
+  "decodeURIComponent",
+  "console",
+  "fetch",
+  "URL",
+  "URLSearchParams",
+  "Headers",
+  "Request",
+  "Response",
+  "AbortController",
+  "AbortSignal",
+  "TextEncoder",
+  "TextDecoder",
+  "atob",
+  "btoa",
+  "structuredClone",
+  "queueMicrotask",
+  "performance",
+  "setTimeout",
+  "clearTimeout",
+  "setInterval",
+  "clearInterval",
+  "crypto",
+  "Blob",
+  "EventTarget",
+  "escape",
+  "unescape",
+  "eval",
+  "WebAssembly",
+  "Iterator",
+  "self",
+  "screen",
+  "FinalizationRegistry",
+  "DOMException",
+  "ReadableStream",
+  "WritableStream",
+  "TransformStream",
+  "MessageChannel",
+  "BroadcastChannel"
+]);
+function parse(source) {
+  return ts.createSourceFile("inline.tsx", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+}
+function bindingNames(name, into) {
+  if (ts.isIdentifier(name)) into.add(name.text);
+  else for (const element of name.elements) if (ts.isBindingElement(element)) bindingNames(element.name, into);
+}
+function isFunctionLike(node) {
+  return ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node);
+}
+function functionScope(fn) {
+  const scope = /* @__PURE__ */ new Set();
+  if ((ts.isFunctionExpression(fn) || ts.isFunctionDeclaration(fn)) && fn.name) scope.add(fn.name.text);
+  for (const parameter of fn.parameters) bindingNames(parameter.name, scope);
+  function collect(node) {
+    if (ts.isVariableDeclaration(node)) bindingNames(node.name, scope);
+    if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) && node.name) scope.add(node.name.text);
+    if (isFunctionLike(node)) return;
+    ts.forEachChild(node, collect);
+  }
+  if (fn.body) ts.forEachChild(fn.body, collect);
+  if (fn.body && !ts.isBlock(fn.body)) collect(fn.body);
+  return scope;
+}
+function collectRefs(root) {
+  const refs = [];
+  const assigned = [];
+  let awaitOutsideAsync = false;
+  let dynamicImport = false;
+  function bound(name, scopes) {
+    return scopes.some((scope) => scope.has(name));
+  }
+  function push(name, kind, scopes) {
+    if (!bound(name, scopes)) refs.push({ name, kind });
+  }
+  function walkNode(node, scopes, inAsync) {
+    if (ts.isTypeNode(node)) return;
+    if (isFunctionLike(node)) {
+      const nextScopes = [...scopes, functionScope(node)];
+      const async = !!node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword);
+      for (const parameter of node.parameters) {
+        if (!ts.isIdentifier(parameter.name)) walkNode(parameter.name, nextScopes, async);
+        if (parameter.initializer) walkNode(parameter.initializer, nextScopes, async);
+      }
+      if (node.body) walkNode(node.body, nextScopes, async);
+      return;
+    }
+    if (ts.isAwaitExpression(node) && !inAsync) awaitOutsideAsync = true;
+    const target = ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment ? node.left : (ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) && (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) ? node.operand : void 0;
+    if (target) {
+      let base = target;
+      while (ts.isPropertyAccessExpression(base) || ts.isElementAccessExpression(base)) base = base.expression;
+      if (ts.isIdentifier(base) && !bound(base.text, scopes)) assigned.push(base.text);
+    }
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) dynamicImport = true;
+    if (ts.isIdentifier(node)) {
+      const parent = node.parent;
+      let operandOf = parent;
+      while (ts.isParenthesizedExpression(operandOf)) operandOf = operandOf.parent;
+      const kind = ts.isTypeOfExpression(operandOf) ? "typeof" : ts.isJsxExpression(parent) && parent.parent && ts.isJsxAttribute(parent.parent) ? "prop" : "other";
+      push(node.text, kind, scopes);
+      return;
+    }
+    if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+      let tag = node.tagName;
+      while (ts.isPropertyAccessExpression(tag)) tag = tag.expression;
+      if (ts.isIdentifier(tag)) {
+        if (node.tagName !== tag || /^[A-Z]/.test(tag.text)) push(tag.text, node.tagName === tag ? "tag" : "member", scopes);
+      }
+      walkNode(node.attributes, scopes, inAsync);
+      return;
+    }
+    if (ts.isJsxClosingElement(node)) return;
+    if (ts.isJsxAttribute(node)) {
+      if (node.initializer) walkNode(node.initializer, scopes, inAsync);
+      return;
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+      walkNode(node.expression, scopes, inAsync);
+      return;
+    }
+    if (ts.isQualifiedName(node)) return;
+    if (ts.isPropertyAssignment(node)) {
+      if (ts.isComputedPropertyName(node.name)) walkNode(node.name.expression, scopes, inAsync);
+      walkNode(node.initializer, scopes, inAsync);
+      return;
+    }
+    if (ts.isShorthandPropertyAssignment(node)) {
+      push(node.name.text, "other", scopes);
+      if (node.objectAssignmentInitializer) walkNode(node.objectAssignmentInitializer, scopes, inAsync);
+      return;
+    }
+    if (ts.isBindingElement(node)) {
+      if (node.propertyName && ts.isComputedPropertyName(node.propertyName)) walkNode(node.propertyName.expression, scopes, inAsync);
+      if (node.initializer) walkNode(node.initializer, scopes, inAsync);
+      if (!ts.isIdentifier(node.name)) walkNode(node.name, scopes, inAsync);
+      return;
+    }
+    if (ts.isVariableDeclaration(node)) {
+      if (!ts.isIdentifier(node.name)) walkNode(node.name, scopes, inAsync);
+      if (node.initializer) walkNode(node.initializer, scopes, inAsync);
+      return;
+    }
+    if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
+      const inner = ts.isClassExpression(node) && node.name ? [...scopes, /* @__PURE__ */ new Set([node.name.text])] : scopes;
+      node.members.forEach((member) => walkNode(member, inner, inAsync));
+      for (const clause of node.heritageClauses ?? []) for (const type of clause.types) walkNode(type.expression, scopes, inAsync);
+      return;
+    }
+    if (ts.isMetaProperty(node)) return;
+    if (ts.isPropertyDeclaration(node)) {
+      if (node.initializer) walkNode(node.initializer, scopes, inAsync);
+      return;
+    }
+    if (ts.isLabeledStatement(node)) {
+      walkNode(node.statement, scopes, inAsync);
+      return;
+    }
+    if (ts.isBreakOrContinueStatement(node)) return;
+    ts.forEachChild(node, (child) => walkNode(child, scopes, inAsync));
+  }
+  walkNode(root, [], false);
+  return { refs, assigned, awaitOutsideAsync, dynamicImport };
+}
+function declaredNames(statement) {
+  const isDefault = !!(ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : void 0)?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword) || ts.isExportAssignment(statement);
+  const names = /* @__PURE__ */ new Set();
+  let componentLike = false;
+  if (ts.isVariableStatement(statement)) {
+    for (const declaration of statement.declarationList.declarations) {
+      bindingNames(declaration.name, names);
+      const initializer = declaration.initializer && unwrap(declaration.initializer);
+      if (ts.isIdentifier(declaration.name) && /^[A-Z]/.test(declaration.name.text) && initializer && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer) || ts.isClassExpression(initializer))) {
+        componentLike = true;
+      }
+    }
+  } else if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name) {
+    names.add(statement.name.text);
+    componentLike = /^[A-Z]/.test(statement.name.text);
+  }
+  return { names: [...names], componentLike, defaultExport: isDefault };
+}
+function unwrap(expression) {
+  let current = expression;
+  while (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isSatisfiesExpression(current)) current = current.expression;
+  return current;
+}
+function importLocals(statementText) {
+  const sf = parse(statementText);
+  const locals = [];
+  for (const statement of sf.statements) {
+    if (!ts.isImportDeclaration(statement) || !statement.importClause) continue;
+    const clause = statement.importClause;
+    if (clause.name) locals.push(clause.name.text);
+    const named = clause.namedBindings;
+    if (named && ts.isNamespaceImport(named)) locals.push(named.name.text);
+    if (named && ts.isNamedImports(named)) for (const element of named.elements) locals.push(element.name.text);
+  }
+  return locals;
+}
+function expressionRefs(expression) {
+  const sf = parse(`const __expression = (${expression})`);
+  const statement = sf.statements[0];
+  return statement ? collectRefs(statement).refs : [];
+}
+function pageScopeNames(esmSources) {
+  const names = /* @__PURE__ */ new Set();
+  for (const source of esmSources) {
+    for (const statement of parse(source).statements) {
+      for (const local of importLocals(statement.getText())) names.add(local);
+      if (ts.isImportDeclaration(statement)) continue;
+      const target = ts.isExportDeclaration(statement) || ts.isExportAssignment(statement) ? void 0 : statement;
+      if (target) for (const name of declaredNames(target).names) names.add(name);
+    }
+  }
+  return names;
+}
+function unresolvedExpressionNames(expression, pageNames) {
+  const names = /* @__PURE__ */ new Set();
+  for (const { name, kind } of expressionRefs(expression)) {
+    if (kind === "typeof") continue;
+    if (!name || pageNames.has(name) || JS_GLOBALS.has(name) || BROWSER_IDENTIFIERS.has(name) || SERVER_ONLY_IDENTIFIERS.has(name) || name === "props" || name === "React") continue;
+    if ((kind === "tag" || kind === "member") && isThallyBuiltinComponent(name)) continue;
+    names.add(name);
+  }
+  return [...names];
+}
+
+// src/frontmatter.ts
+import { parse as parseYaml } from "yaml";
+function salvageFrontmatterLines(matter) {
+  const data = {};
+  for (const line of matter.split(/\r?\n/)) {
+    if (!/^[A-Za-z_][\w-]*:\s?/.test(line)) continue;
+    try {
+      const parsedLine = parseYaml(line);
+      if (parsedLine && typeof parsedLine === "object" && !Array.isArray(parsedLine)) {
+        Object.assign(data, parsedLine);
+      }
+    } catch {
+    }
+  }
+  return data;
+}
+function parseFrontmatter(raw) {
+  const source = raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+  const opening = /^---([^\r\n]*)\r?\n/.exec(source);
+  if (!opening || opening[1].startsWith("-")) return { content: source, data: {} };
+  const language = opening[1].trim().toLowerCase();
+  const remainder = source.slice(opening[0].length);
+  const closing = /^---[ \t]*\r?$/m.exec(remainder);
+  const matter = closing ? remainder.slice(0, closing.index) : remainder;
+  let content = closing ? remainder.slice(closing.index + closing[0].length) : "";
+  if (content.startsWith("\r\n")) content = content.slice(2);
+  else if (content.startsWith("\n")) content = content.slice(1);
+  if (matter.trim() === "" || !["", "yaml", "yml"].includes(language)) {
+    return { content, data: {} };
+  }
+  try {
+    const parsed = parseYaml(matter);
+    return {
+      content,
+      data: parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {}
+    };
+  } catch (err) {
+    return {
+      content,
+      data: salvageFrontmatterLines(matter),
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/mdx.ts
+function titleFromId(id) {
+  const value = id.split("/").at(-1) ?? id;
+  if (value === "introduction") return "Introduction";
+  return value.split(/[-_]/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+var descriptionParser = unified().use(remarkParse).use(remarkGfm).use(remarkMdx);
+function plainText(node) {
+  if (node.type === "text" || node.type === "inlineCode") return node.value ?? "";
+  if (node.type === "image") return node.alt ?? "";
+  if (node.type === "break") return " ";
+  return (node.children ?? []).map(plainText).join("");
+}
+function firstParagraph(content) {
+  function findParagraph(node) {
+    if (node.type === "paragraph") {
+      const value = plainText(node).replace(/\s+/g, " ").trim();
+      if (value) return value.slice(0, 240);
+    }
+    for (const child of node.children ?? []) {
+      const value = findParagraph(child);
+      if (value) return value;
+    }
+    return "";
+  }
+  try {
+    return findParagraph(descriptionParser.parse(content));
+  } catch {
+    return "";
+  }
+}
+function docusaurusAdmonitionTag(kind) {
+  if (kind === "danger") return "Error";
+  if (kind === "info") return "Info";
+  if (kind === "caution" || kind === "warning") return "Warning";
+  return "Note";
+}
+function scanJsxOpeningTag(source, start, name) {
+  const opener = `<${name}`;
+  let quote = null;
+  let depth = 0;
+  let braceQuote = null;
+  let lineComment = false;
+  let blockComment = false;
+  const attributesStart = start + opener.length;
+  for (let index = attributesStart; index < source.length; index++) {
+    const char = source[index];
+    if (char === "<" && !quote && !braceQuote && depth === 0 && !lineComment && !blockComment && source.startsWith(opener, index) && !/[\w$.-]/.test(source[index + opener.length] ?? "")) {
+      return { attributes: source.slice(attributesStart, index), end: null, next: index };
+    }
+    if (lineComment) {
+      if (char === "\n" || char === "\r") lineComment = false;
+    } else if (blockComment) {
+      if (char === "*" && source[index + 1] === "/") {
+        blockComment = false;
+        index++;
+      }
+    } else if (braceQuote) {
+      if (char === "\\") index++;
+      else if (char === braceQuote) braceQuote = null;
+    } else if (depth > 0) {
+      if (char === "/" && source[index + 1] === "/") {
+        lineComment = true;
+        index++;
+      } else if (char === "/" && source[index + 1] === "*") {
+        blockComment = true;
+        index++;
+      } else if (char === '"' || char === "'" || char === "`") braceQuote = char;
+      else if (char === "{") depth++;
+      else if (char === "}") depth--;
+    } else if (quote) {
+      if (char === quote) quote = null;
+    } else if (char === '"' || char === "'") quote = char;
+    else if (char === "{") depth++;
+    else if (char === ">") return { attributes: source.slice(attributesStart, index), end: index, next: index + 1 };
+  }
+  return { attributes: source.slice(attributesStart), end: null, next: source.length };
+}
+function normalizeDocusaurusAdmonitionTags(segment) {
+  const open = [];
+  const marker = /<\/Admonition>|<Admonition(?![\w$.-])/g;
+  let output = "";
+  let cursor = 0;
+  for (let match = marker.exec(segment); match; match = marker.exec(segment)) {
+    if (match[0] === "</Admonition>") {
+      output += `${segment.slice(cursor, match.index)}
+</${open.pop() ?? "Note"}>`;
+      cursor = marker.lastIndex;
+      continue;
+    }
+    const tag = scanJsxOpeningTag(segment, match.index, "Admonition");
+    marker.lastIndex = tag.next;
+    if (tag.end === null) continue;
+    const type = tag.attributes.match(/\btype=(?:"([^"]*)"|'([^']*)')/)?.slice(1).find(Boolean)?.toLowerCase() ?? "note";
+    const title = tag.attributes.match(/\btitle=(?:"([^"]*)"|'([^']*)')/)?.slice(1).find(Boolean)?.trim();
+    const callout = docusaurusAdmonitionTag(type);
+    open.push(callout);
+    output += `${segment.slice(cursor, match.index)}${title ? `<${callout}>
+**${title}**
+` : `<${callout}>
+`}`;
+    cursor = tag.end + 1;
+    marker.lastIndex = cursor;
+  }
+  return output + segment.slice(cursor);
+}
+function normalizeDocusaurusLinkTags(segment) {
+  const marker = /<Link(?![\w$.-])/g;
+  let output = "";
+  let cursor = 0;
+  for (let match = marker.exec(segment); match; match = marker.exec(segment)) {
+    const tag = scanJsxOpeningTag(segment, match.index, "Link");
+    marker.lastIndex = tag.next;
+    if (tag.end === null) continue;
+    output += `${segment.slice(cursor, match.index)}<a${tag.attributes.replace(/(^|\s)to=/, "$1href=")}>`;
+    cursor = tag.end + 1;
+    marker.lastIndex = cursor;
+  }
+  return (output + segment.slice(cursor)).replace(/<\/Link>/g, "</a>");
+}
+function normalizeDocusaurusThemedImages(segment) {
+  return segment.replace(/<ThemedImage\b([^<]*?)\/>/g, (original, attributes) => {
+    const light = attributes.match(/\blight\s*:\s*(?:useBaseUrl\(\s*)?(?:"([^"]+)"|'([^']+)')/)?.slice(1).find(Boolean);
+    if (!light) return original;
+    const alt = attributes.match(/\balt=(?:"([^"]*)"|'([^']*)')/)?.slice(1).find((value) => value !== void 0);
+    return `<img src="${light.replace(/"/g, "&quot;")}"${alt === void 0 ? "" : ` alt="${alt.replace(/"/g, "&quot;")}"`} />`;
+  });
+}
+function normalizeDocusaurusAdmonitions(body) {
+  const lines = body.split("\n");
+  const openAdmonitions = [];
+  const headingLines = [];
+  let codeFence = null;
+  const output = lines.map((line, index) => {
+    const codeMatch = line.match(/^\s{0,3}(`{3,}|~{3,})/);
+    if (codeMatch) {
+      if (!codeFence) codeFence = codeMatch[1];
+      else if (codeMatch[1][0] === codeFence[0] && codeMatch[1].length >= codeFence.length && /^\s*$/.test(line.slice(codeMatch[0].length))) codeFence = null;
+      return line;
+    }
+    if (codeFence) return line;
+    if (/^#{1,6}\s/.test(line)) headingLines.push(index);
+    const opening = line.match(/^\s*(:{3,})(note|tip|info|warning|caution|danger)(?:\[([^\]]+)\]|\s+(.+))?\s*$/i);
+    if (opening) {
+      const tag = docusaurusAdmonitionTag(opening[2].toLowerCase());
+      openAdmonitions.push({ delimiter: opening[1], tag, openedAt: index });
+      const title = (opening[3] ?? opening[4])?.trim();
+      return title ? `<${tag}>
+**${title}**` : `<${tag}>`;
+    }
+    const closing = line.match(/^\s*(:{3,})\s*$/);
+    const current = openAdmonitions.at(-1);
+    if (closing && current?.delimiter === closing[1]) {
+      openAdmonitions.pop();
+      return `</${current.tag}>`;
+    }
+    return line;
+  });
+  const closingByLine = /* @__PURE__ */ new Map();
+  for (const open of openAdmonitions.reverse()) {
+    const at = headingLines.find((line) => line > open.openedAt) ?? output.length;
+    closingByLine.set(at, [...closingByLine.get(at) ?? [], `</${open.tag}>`]);
+  }
+  for (const [at, closing] of [...closingByLine].sort(([left], [right]) => right - left)) output.splice(at, 0, ...closing);
+  return output.join("\n");
+}
+function unwrapDocusaurusMdxCodeBlocks(body) {
+  const output = [];
+  let fence;
+  let isMdxCodeBlock = false;
+  for (const line of body.split("\n")) {
+    const opening = !fence && line.match(/^ {0,3}(`{3,}|~{3,})mdx-code-block\s*$/);
+    if (opening) {
+      fence = opening[1];
+      isMdxCodeBlock = true;
+      continue;
+    }
+    if (fence) {
+      const closing = line.match(/^ {0,3}(`{3,}|~{3,})\s*$/);
+      if (closing && closing[1][0] === fence[0] && closing[1].length >= fence.length) {
+        if (!isMdxCodeBlock) output.push(line);
+        fence = void 0;
+        isMdxCodeBlock = false;
+        continue;
+      }
+      if (isMdxCodeBlock && /^\s*(?:import|export)\b/.test(line)) return body;
+      output.push(line);
+      continue;
+    }
+    const ordinaryFence = line.match(/^ {0,3}(`{3,}|~{3,})/);
+    if (ordinaryFence) {
+      fence = ordinaryFence[1];
+      isMdxCodeBlock = false;
+    }
+    output.push(line);
+  }
+  return isMdxCodeBlock ? body : output.join("\n");
+}
+var HTML_ID = /^[^\s"'<>`{}&]+$/u;
+function normalizeExplicitHeadingIds(raw, warn, options = {}) {
+  const { front, body } = splitFrontmatterBlock(raw);
+  return front + replaceOutsideCode(body, (segment) => segment.split("\n").map((line) => {
+    if (!/^[ \t]{0,3}#{1,6}[ \t]+/.test(line)) return line;
+    const trimmed = line.trimEnd();
+    if (trimmed.endsWith("}")) {
+      const marker = trimmed.lastIndexOf(" {#");
+      if (marker >= 0) {
+        const id = trimmed.slice(marker + 3, -1);
+        const heading = trimmed.slice(0, marker).trimEnd();
+        if (/[{}]/.test(id)) return line;
+        const usable = options.headingMarkers ? id && !/\s/.test(id) && !id.includes("*/") : HTML_ID.test(id);
+        if (usable && options.headingMarkers) return `${heading} ${headingIdMarker(id)}`;
+        if (usable) return `<a id="${id}"></a>
+${heading}`;
+        warn?.(`Heading anchor {#${id}} ${options.headingMarkers ? 'contains whitespace or "*/"' : "is not a valid HTML id"} and was removed from "${heading.replace(/^\s*#+\s*/, "")}".`);
+        return heading;
+      }
+    }
+    if (!options.headingMarkers && !options.keepIdComments && trimmed.endsWith("*/}")) {
+      const marker = trimmed.lastIndexOf(" {/*");
+      if (marker >= 0) {
+        const comment = trimmed.slice(marker + 4, -3).trim();
+        const id = comment.startsWith("#") ? comment.slice(1) : "";
+        if (HTML_ID.test(id)) {
+          return `<a id="${id}"></a>
+${trimmed.slice(0, marker).trimEnd()}`;
+        }
+      }
+    }
+    return line;
+  }).join("\n"));
+}
+function headingIdMarker(id) {
+  return `{/* #${id} */}`;
+}
+function mintlifyHeadingSlug(text) {
+  return text.replace(/\u200b/g, "").normalize("NFC").trim().toLowerCase().replace(/[.\s]+/g, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "").replace(/[^\p{L}\p{M}\p{N}_\-+&/\u2019\u201c\u201d\u2014\u2013\u2192]/gu, "");
+}
+function thallyHeadingSlug(text) {
+  return text.normalize("NFC").toLowerCase().replace(/[^\p{L}\p{M}\p{N}]+/gu, "-").replace(/(^-|-$)/g, "");
+}
+function typesetQuotes(text) {
+  return text.split(/(`[^`]*`|<[^>]*>|\]\([^)]*\))/).map((part, index) => {
+    if (index % 2) return part;
+    return part.replace(/(^|[\s([{\u2014\u2013])"/g, "$1\u201C").replace(/"/g, "\u201D").replace(/(^|[\s([{\u2014\u2013\u201c])'(?=\S)/g, "$1\u2018").replace(/'/g, "\u2019");
+  }).join("");
+}
+function plainHeadingText(source) {
+  return source.replace(/\{\/\*[\s\S]*?\*\/\}/g, " ").replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/<\/?[A-Za-z][^>]*>/g, "").replace(/`([^`]*)`/g, "$1").replace(/(\*\*|__|~~|\*)/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/\\([\\`*_{}[\]()#+.!&<>|~-])/g, "$1");
+}
+function markMintlifyHeadings(body) {
+  let fence;
+  return body.split("\n").map((line) => {
+    const marker = line.match(/^ {0,3}(`{3,}|~{3,})/);
+    if (marker) {
+      if (!fence) fence = marker[1];
+      else if (marker[1][0] === fence[0] && marker[1].length >= fence.length && /^\s*$/.test(line.slice(marker[0].length))) fence = void 0;
+      return line;
+    }
+    if (fence) return line;
+    const heading = line.match(/^( {0,3}#{2,6}[ \t]+)(.+?)(?:[ \t]+#+)?[ \t]*$/);
+    if (!heading) return line;
+    const explicit = heading[2].match(/^(.*?)([ \t]*\{\/\*[ \t]*#\S+[ \t]*\*\/\})$/);
+    const source = typesetQuotes(explicit ? explicit[1] : heading[2]);
+    if (explicit) return `${heading[1]}${source}${explicit[2]}`;
+    const text = plainHeadingText(source);
+    const id = mintlifyHeadingSlug(text);
+    return `${heading[1]}${source}${id && id !== thallyHeadingSlug(text) ? ` ${headingIdMarker(id)}` : ""}`;
+  }).join("\n");
+}
+var GLOBAL_DOCUSARUS_COMPONENTS = /* @__PURE__ */ new Set([
+  "Tabs",
+  "TabItem",
+  "Link",
+  "DocCardList",
+  "TOCInline"
+]);
+function removeGlobalDocusaurusImports(body) {
+  return replaceOutsideCode(body, (segment) => segment.replace(
+    /\bimport\s+([A-Za-z_$][\w$]*)\s+from\s+(['"])(@(?:theme|docusaurus)\/[^'"]+)\2\s*;?/g,
+    (statement, component) => GLOBAL_DOCUSARUS_COMPONENTS.has(component) ? "" : statement
+  ));
+}
+function leadingPageHeading(body) {
+  if (!/^ {0,3}(?:#(?:[ \t]|$)|=+[ \t\r]*$)/m.test(body)) return void 0;
+  try {
+    const root = descriptionParser.parse(body);
+    const first = root.children?.find((node) => node.type !== "mdxjsEsm" && node.type !== "html" && !(node.type === "mdxFlowExpression" && node.data?.estree?.body.length === 0));
+    if (first?.type !== "heading" || first.depth !== 1) return void 0;
+    const text = (node) => node.type === "mdxTextExpression" || node.type === "mdxFlowExpression" ? "" : node.value ?? (node.children ?? []).map(text).join("");
+    const title = text(first).replace(/\s+/g, " ").trim();
+    const start = first.position?.start.offset;
+    const end = first.position?.end.offset;
+    return title && start !== void 0 && end !== void 0 ? { title, start, end } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolvePageDisplayHeading(page, platform) {
+  const heading = leadingPageHeading(page.body);
+  if (!heading || heading.title !== page.title && platform !== "docusaurus") return;
+  if (heading.title !== page.title) page.headingTitle = heading.title;
+  page.body = `${page.body.slice(0, heading.start)}${page.body.slice(heading.end)}`.trim();
+}
+function splitFrontmatterBlock(raw) {
+  const hasBom = raw.charCodeAt(0) === 65279;
+  const bom = hasBom ? raw[0] : "";
+  const source = hasBom ? raw.slice(1) : raw;
+  const opening = /^---([^\r\n]*)\r?\n/.exec(source);
+  if (!opening || opening[1].startsWith("-")) return { front: bom, body: source };
+  const remainder = source.slice(opening[0].length);
+  const closing = /^---[ \t]*\r?$/m.exec(remainder);
+  if (!closing) return { front: bom, body: source };
+  const end = opening[0].length + closing.index + closing[0].length;
+  return { front: bom + source.slice(0, end), body: source.slice(end) };
+}
+function maskCode(body) {
+  const source = body.replace(/\u0000/g, "");
+  const blocks = [];
+  const stash = (text) => {
+    blocks.push(text);
+    return `\0${blocks.length - 1}\0`;
+  };
+  const lines = [];
+  let codeFence = null;
+  let fenceBuffer = [];
+  for (const line of source.split("\n")) {
+    const fenceMatch = line.match(/^\s{0,3}(`{3,}|~{3,})/);
+    if (codeFence) {
+      fenceBuffer.push(line);
+      if (fenceMatch && fenceMatch[1][0] === codeFence[0] && fenceMatch[1].length >= codeFence.length && /^\s*$/.test(line.slice(fenceMatch[0].length))) {
+        lines.push(stash(fenceBuffer.join("\n")));
+        codeFence = null;
+        fenceBuffer = [];
+      }
+      continue;
+    }
+    if (fenceMatch) {
+      codeFence = fenceMatch[1];
+      fenceBuffer = [line];
+      continue;
+    }
+    lines.push(line.split(/(`[^`]*`)/).map((segment, index) => index % 2 === 1 ? stash(segment) : segment).join(""));
+  }
+  if (fenceBuffer.length) lines.push(stash(fenceBuffer.join("\n")));
+  return {
+    masked: lines.join("\n"),
+    unmask: (text) => text.replace(/\u0000(\d+)\u0000/g, (_match, index) => blocks[Number(index)]),
+    openFence: codeFence
+  };
+}
+function replaceOutsideCode(body, transform) {
+  const { masked, unmask } = maskCode(body);
+  return unmask(transform(masked));
+}
+function mdxComment(text) {
+  return `{/*${text.replace(/\*\//g, "* /")}*/}`;
+}
+function normalizeFernFileTrees(body) {
+  return replaceOutsideCode(body, (whole) => whole.replace(
+    /<FileTree\s*>\s*\n([\s\S]*?)\n\s*<\/FileTree>/g,
+    (original, contents) => {
+      const lines = contents.split(/\r?\n/).filter((line) => line.trim());
+      if (!lines.length) return original;
+      const nodes = [];
+      for (const line of lines) {
+        const match = /^( *)(?:-|\*|\+)\s+(.+?)\s*$/.exec(line);
+        if (!match || match[1].length % 2 !== 0 || match[2].includes("\0")) return original;
+        nodes.push({ indent: match[1].length / 2, name: match[2], isFolder: match[2].endsWith("/") });
+      }
+      const output = ["<Tree>"];
+      const folders = [];
+      for (const node of nodes) {
+        while (folders.length > node.indent) {
+          output.push("</Folder>");
+          folders.pop();
+        }
+        if (node.indent > folders.length || node.indent > 0 && folders.length === 0) return original;
+        const name = `{${JSON.stringify(node.name)}}`;
+        if (node.isFolder) {
+          output.push(`<Folder name=${name} defaultOpen>`);
+          folders.push(node.indent);
+        } else {
+          output.push(`<File name=${name} />`);
+        }
+      }
+      while (folders.length) {
+        output.push("</Folder>");
+        folders.pop();
+      }
+      output.push("</Tree>");
+      return output.join("\n");
+    }
+  ));
+}
+function normalizeFernCallouts(body) {
+  return replaceOutsideCode(body, (whole) => {
+    const openTags = [];
+    const output = [];
+    let cursor = 0;
+    while (cursor < whole.length) {
+      const opening = whole.indexOf("<Callout", cursor);
+      const closing = whole.indexOf("</Callout>", cursor);
+      const next = opening < 0 ? closing : closing < 0 ? opening : Math.min(opening, closing);
+      if (next < 0) break;
+      output.push(whole.slice(cursor, next));
+      if (next === closing) {
+        const tag = openTags.pop();
+        output.push(tag ? `</${tag}>` : "</Callout>");
+        cursor = next + "</Callout>".length;
+        continue;
+      }
+      const attributeStart = next + "<Callout".length;
+      if (!/[\s/>]/.test(whole[attributeStart] ?? "")) {
+        output.push("<Callout");
+        cursor = attributeStart;
+        continue;
+      }
+      let end = attributeStart;
+      let quote = null;
+      let expressionDepth = 0;
+      for (; end < whole.length; end++) {
+        const character = whole[end];
+        if (quote) {
+          if (character === quote && whole[end - 1] !== "\\") quote = null;
+        } else if (character === '"' || character === "'") {
+          quote = character;
+        } else if (character === "{") {
+          expressionDepth++;
+        } else if (character === "}" && expressionDepth > 0) {
+          expressionDepth--;
+        } else if (character === ">" && expressionDepth === 0) {
+          break;
+        }
+      }
+      if (end === whole.length) {
+        output.push(whole.slice(next));
+        cursor = whole.length;
+        break;
+      }
+      const attributes = whole.slice(attributeStart, end);
+      const intent = findStaticCalloutIntent(attributes);
+      const isSelfClosing = attributes.trimEnd().endsWith("/");
+      if (!intent) {
+        output.push(whole.slice(next, end + 1));
+        if (!isSelfClosing) openTags.push(null);
+      } else {
+        const value = intent.value.toLowerCase();
+        const tag = value === "warning" ? "Warning" : value === "success" || value === "tip" ? "Tip" : value === "error" || value === "danger" ? "Error" : "Note";
+        output.push(`<${tag}${attributes.slice(0, intent.start)}${attributes.slice(intent.end)}>`);
+        if (!isSelfClosing) openTags.push(tag);
+      }
+      cursor = end + 1;
+    }
+    output.push(whole.slice(cursor));
+    return output.join("");
+  });
+}
+function findStaticCalloutIntent(attributes) {
+  let cursor = 0;
+  while (cursor < attributes.length) {
+    const start = cursor;
+    while (/\s/.test(attributes[cursor] ?? "")) cursor++;
+    if (cursor === start) {
+      cursor++;
+      continue;
+    }
+    const nameStart = cursor;
+    while (/[A-Za-z0-9_-]/.test(attributes[cursor] ?? "")) cursor++;
+    const name = attributes.slice(nameStart, cursor);
+    while (/\s/.test(attributes[cursor] ?? "")) cursor++;
+    if (attributes[cursor] !== "=") continue;
+    cursor++;
+    while (/\s/.test(attributes[cursor] ?? "")) cursor++;
+    const quote = attributes[cursor];
+    if (quote !== '"' && quote !== "'") {
+      if (quote === "{") {
+        let depth = 0;
+        do {
+          if (attributes[cursor] === "{") depth++;
+          if (attributes[cursor] === "}") depth--;
+          cursor++;
+        } while (cursor < attributes.length && depth > 0);
+      } else {
+        while (cursor < attributes.length && !/\s/.test(attributes[cursor])) cursor++;
+      }
+      continue;
+    }
+    const valueStart = ++cursor;
+    while (cursor < attributes.length && attributes[cursor] !== quote) cursor++;
+    const value = attributes.slice(valueStart, cursor);
+    if (cursor < attributes.length) cursor++;
+    if (name === "intent") return { start, end: cursor, value };
+  }
+  return null;
+}
+function unwrapFernCodeBlockTabs(body) {
+  return replaceOutsideCode(body, (whole) => {
+    let groupDepth = 0;
+    return whole.replace(/<CodeGroup\b[^>]*>|<\/CodeGroup>|<CodeBlock\b[^>]*>|<\/CodeBlock>/g, (match) => {
+      if (match.startsWith("<CodeGroup")) {
+        groupDepth++;
+        return match;
+      }
+      if (match === "</CodeGroup>") {
+        groupDepth = Math.max(0, groupDepth - 1);
+        return match;
+      }
+      return groupDepth > 0 ? "" : match;
+    });
+  });
+}
+var STANDALONE_CODE_BLOCK_SHIM = [
+  "export const CodeBlock = ({ children, filename, ...rest }) => (",
+  "  <pre {...rest}>",
+  "    {filename ? <div>{filename}</div> : null}",
+  "    <code>{children}</code>",
+  "  </pre>",
+  ");"
+].join("\n");
+function exportDeclarationBodies(body) {
+  const bodies = [];
+  const opener = /export const \w+ = [^\n]*=> ([({])/g;
+  for (const match of body.matchAll(opener)) {
+    const open = match[1];
+    const close = open === "(" ? ")" : "}";
+    let depth = 1;
+    let i = (match.index ?? 0) + match[0].length;
+    while (i < body.length && depth > 0) {
+      if (body[i] === open) depth++;
+      else if (body[i] === close) depth--;
+      i++;
+    }
+    bodies.push(body.slice((match.index ?? 0) + match[0].length, i));
+  }
+  return bodies;
+}
+function provideScopedGlobalReferences(body) {
+  const alreadyBound = (name) => new RegExp(`\\b${name}\\s*[=:]|\\bimport\\s+.*\\b${name}\\b`).test(body);
+  const referencedIn = exportDeclarationBodies(body).join("\n");
+  let result = body;
+  if (/<Icon\b/.test(referencedIn) && !alreadyBound("Icon")) {
+    result = `import { Icon } from '@/components/mdx/content-icon';
+
+${result}`;
+  }
+  if (/<CodeBlock\b/.test(referencedIn) && !alreadyBound("CodeBlock")) {
+    result = `${STANDALONE_CODE_BLOCK_SHIM}
+
+${result}`;
+  }
+  return result;
+}
+function normalizeDocusaurusTabs(body) {
+  let result = body;
+  for (let depth = 0; depth < 20; depth += 1) {
+    const updated = result.replace(/<Tabs\b([^>]*)>((?:(?!<Tabs\b)[\s\S])*?)<\/Tabs>/g, (_match, attributes, inner) => {
+      const labelByValue = /* @__PURE__ */ new Map();
+      const valuesSource = attributes.match(/\bvalues=\{(\[[\s\S]*?\])\s*\}/)?.[1];
+      if (valuesSource) {
+        for (const entry of valuesSource.matchAll(/\{([^{}]*)\}/g)) {
+          const label = entry[1].match(/\blabel:\s*(?:"([^"]*)"|'([^']*)')/)?.slice(1).find(Boolean);
+          const value = entry[1].match(/\bvalue:\s*(?:"([^"]*)"|'([^']*)')/)?.slice(1).find(Boolean);
+          if (value) labelByValue.set(value, label ?? value);
+        }
+      }
+      const cleanedAttributes = attributes.replace(/\s*defaultValue=(?:\{[^}]*\}|"[^"]*"|'[^']*')/g, "").replace(/\s*values=\{[\s\S]*?\]\s*\}/g, "").replace(/\s*values=\{[^{}]*\}/g, "").replace(/\s*groupId=(?:"[^"]*"|'[^']*')/g, "").replace(/\s*queryString(?:=(?:\{[^}]*\}|"[^"]*"|'[^']*'))?/g, "");
+      const rewrittenInner = inner.replace(/<TabItem\b([^>]*)>/g, (_itemMatch, itemAttributes) => {
+        const label = itemAttributes.match(/\blabel=(?:"([^"]*)"|'([^']*)')/)?.slice(1).find(Boolean);
+        const value = itemAttributes.match(/\bvalue=(?:"([^"]*)"|'([^']*)')/)?.slice(1).find(Boolean);
+        const title = label ?? (value && labelByValue.get(value)) ?? value ?? "Tab";
+        return `<Tab title="${title.replace(/"/g, "&quot;")}">`;
+      }).replace(/<\/TabItem>/g, "</Tab>");
+      return `<ThallyTabs${cleanedAttributes}>${rewrittenInner}</ThallyTabs>`;
+    });
+    if (updated === result) break;
+    result = updated;
+  }
+  return result.replace(/<ThallyTabs\b/g, "<Tabs").replace(/<\/ThallyTabs>/g, "</Tabs>");
+}
+var TAB_FENCE_OPEN = /^(`{3,}|~{3,})(\S*)\s+tab\b(.*)$/;
+function normalizeDocusaurusTabBlocks(body) {
+  const lines = body.split("\n");
+  const output = [];
+  let index = 0;
+  while (index < lines.length) {
+    const open = lines[index].match(TAB_FENCE_OPEN);
+    if (!open) {
+      output.push(lines[index]);
+      index++;
+      continue;
+    }
+    const blocks = [];
+    while (index < lines.length) {
+      const start = lines[index].match(TAB_FENCE_OPEN);
+      if (!start) break;
+      const marker = start[1];
+      const block = [`${start[1]}${start[2]}${start[3]}`];
+      index++;
+      while (index < lines.length && lines[index].trim() !== marker) {
+        block.push(lines[index]);
+        index++;
+      }
+      block.push(lines[index] ?? marker);
+      index++;
+      blocks.push(block);
+      let lookahead = index;
+      while (lookahead < lines.length && lines[lookahead].trim() === "") lookahead++;
+      if (!lines[lookahead] || !TAB_FENCE_OPEN.test(lines[lookahead])) break;
+      index = lookahead;
+    }
+    if (blocks.length > 1) {
+      output.push("<CodeGroup>", "");
+      for (const block of blocks) output.push(...block, "");
+      output.pop();
+      output.push("</CodeGroup>");
+    } else {
+      output.push(...blocks[0]);
+    }
+  }
+  return output.join("\n");
+}
+function splitCssDeclarations(value) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const char of value) {
+    if (char === "(") depth++;
+    else if (char === ")") depth = Math.max(0, depth - 1);
+    if (char === ";" && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) parts.push(current);
+  return parts;
+}
+function cssPropertyToJsKey(property) {
+  if (property.startsWith("--")) return JSON.stringify(property);
+  const camel = property.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
+  return camel.startsWith("Ms") ? camel.slice(0, 1).toLowerCase() + camel.slice(1) : camel;
+}
+function cssTextToStyleObjectLiteral(cssText) {
+  const entries = splitCssDeclarations(cssText).flatMap((declaration) => {
+    const colon = declaration.indexOf(":");
+    if (colon === -1) return [];
+    const property = declaration.slice(0, colon).trim();
+    const value = declaration.slice(colon + 1).replace(/\s*!\s*important\s*$/i, "").trim();
+    if (!property || !value || !/^-{0,2}[a-zA-Z][a-zA-Z0-9-]*$/.test(property)) return [];
+    return [`${cssPropertyToJsKey(property)}: ${JSON.stringify(value)}`];
+  });
+  return `{${entries.join(", ")}}`;
+}
+function convertHtmlStyleAttributes(body) {
+  return body.replace(
+    // The separator before `style=` must be `\s+`, not a single `\s`: a
+    // multi-line tag indents its attributes, so more than one whitespace
+    // character (a newline plus spaces) commonly precedes it.
+    /<([a-z][a-zA-Z0-9]*)((?:\s+[^\s"'=<>/]+(?:=(?:"[^"]*"|'[^']*'))?)*)\s+style=(["'])([\s\S]*?)\3((?:\s+[^\s"'=<>/]+(?:=(?:"[^"]*"|'[^']*'))?)*)\s*(\/?)>/g,
+    (_match, tag, before, _quote, styleText, after, selfClose) => `<${tag}${before} style={${cssTextToStyleObjectLiteral(styleText)}}${after}${selfClose ? " /" : ""}>`
+  );
+}
+function normalizeMintlifyUpdateLabels(body) {
+  return body.replace(/(<Update\b[^>]*\blabel=)\{(<\>[\s\S]*?<\/\>)\}/g, (match, prefix, fragment) => {
+    let root;
+    try {
+      root = descriptionParser.parse(fragment);
+    } catch {
+      return match;
+    }
+    const plainText2 = (node) => {
+      if (node.type === "text" || node.type === "inlineCode") return node.value ?? "";
+      if (node.type === "mdxTextExpression" || node.type === "mdxFlowExpression" || node.type === "mdxjsEsm") return null;
+      const parts = (node.children ?? []).map(plainText2);
+      return parts.some((part) => part === null) ? null : parts.join("");
+    };
+    const label = plainText2(root)?.replace(/\s+/g, " ").trim();
+    return label && !/[{}]/.test(label) ? `${prefix}{${JSON.stringify(label)}}` : match;
+  });
+}
+function normalizeMintlifyParameterAnchors(body) {
+  const seen = /* @__PURE__ */ new Set();
+  const anchorFor = (name) => {
+    const id = `param-${name.toLowerCase().replace(/[._]/g, "-")}`;
+    if (seen.has(id)) return "";
+    seen.add(id);
+    return `<a id="${id}"></a>
+`;
+  };
+  let fence;
+  const withHeadings = body.split("\n").map((line) => {
+    const marker = line.match(/^ {0,3}(`{3,}|~{3,})/);
+    if (marker) {
+      if (!fence) fence = marker[1];
+      else if (marker[1][0] === fence[0] && marker[1].length >= fence.length && /^\s*$/.test(line.slice(marker[0].length))) fence = void 0;
+      return line;
+    }
+    if (fence) return line;
+    const heading = line.match(/^ {0,3}#{1,6}\s+`([A-Za-z][A-Za-z0-9._-]*)`(?:\s|$)/);
+    return heading ? `${anchorFor(heading[1])}${line}` : line;
+  }).join("\n");
+  return replaceOutsideCode(withHeadings, (segment) => segment.replace(
+    /<(ResponseField|ParamField)\b([^>]*?)\bname=(?:"([A-Za-z][A-Za-z0-9._-]*)"|'([A-Za-z][A-Za-z0-9._-]*)')([^>]*)>/g,
+    (match, _tag, _before, doubleQuoted, singleQuoted) => `${anchorFor(doubleQuoted ?? singleQuoted)}${match}`
+  ));
+}
+function matchFenceLine(line) {
+  const match = line.match(/^(\s*)(`{3,}|~{3,})(.*)$/);
+  if (!match) return null;
+  return { index: -1, indent: match[1], char: match[2][0], length: match[2].length, info: match[3].trim(), rest: match[3] };
+}
+function normalizeNestedCodeFences(body) {
+  const lines = body.split("\n");
+  const fences = lines.map((line, index) => {
+    const fence = matchFenceLine(line);
+    return fence ? { ...fence, index } : null;
+  }).filter((fence) => fence !== null);
+  if (fences.length === 0) return body;
+  const stack = [];
+  const roots = [];
+  for (const fence of fences) {
+    const top = stack.at(-1);
+    if (top && fence.info === "" && fence.char === top.open.char && fence.length >= top.open.length) {
+      stack.pop();
+      const block = { open: top.open, close: fence, children: top.children };
+      const parent = stack.at(-1);
+      if (parent) parent.children.push(block);
+      else roots.push(block);
+    } else {
+      stack.push({ open: fence, children: [] });
+    }
+  }
+  if (stack.length > 0) return body;
+  const widenedLengths = /* @__PURE__ */ new Map();
+  function requiredLength(block) {
+    const deepestChild = Math.max(0, ...block.children.map(requiredLength));
+    const length = Math.max(block.open.length, deepestChild > 0 ? deepestChild + 1 : 0);
+    widenedLengths.set(block.open.index, length);
+    widenedLengths.set(block.close.index, length);
+    return length;
+  }
+  roots.forEach(requiredLength);
+  return lines.map((line, index) => {
+    const targetLength = widenedLengths.get(index);
+    const fence = targetLength ? matchFenceLine(line) : null;
+    if (!targetLength || !fence || targetLength <= fence.length) return line;
+    return `${fence.indent}${fence.char.repeat(targetLength)}${fence.rest}`;
+  }).join("\n");
+}
+function maskCodeRegions(body) {
+  let inFence = false;
+  return body.split("\n").map((line) => {
+    if (/^\s*(`{3,}|~{3,})/.test(line)) {
+      inFence = !inFence;
+      return " ".repeat(line.length);
+    }
+    if (inFence) return " ".repeat(line.length);
+    return line.replace(/`[^`]*`/g, (span) => " ".repeat(span.length));
+  }).join("\n");
+}
+var UNTERMINATED = "unterminated";
+function readTagEnd(text, from) {
+  if (from < text.length && !/[\s/>]/.test(text[from])) return null;
+  let depth = 0;
+  let quote = "";
+  for (let i = from; i < text.length; i++) {
+    const char = text[i];
+    if (quote) {
+      if (char === "\\" && depth > 0) i++;
+      else if (char === quote) quote = "";
+    } else if (char === '"' || char === "'" || char === "`" && depth > 0) {
+      quote = char;
+    } else if (char === "{") {
+      depth++;
+    } else if (char === "}") {
+      depth = Math.max(0, depth - 1);
+    } else if (depth === 0) {
+      if (char === "<") return null;
+      if (char === ">") {
+        const selfClosing = text[i - 1] === "/" && i > from;
+        return { end: i + 1, selfClosing, attributes: text.slice(from, selfClosing ? i - 1 : i) };
+      }
+    }
+  }
+  return quote || depth > 0 ? UNTERMINATED : null;
+}
+function pinStepsTitleSize(body) {
+  let result = "";
+  let cursor = 0;
+  for (const match of body.matchAll(/<Steps(?=[\s/>])/g)) {
+    if (match.index < cursor) continue;
+    const tag = readTagEnd(body, match.index + match[0].length);
+    if (tag === UNTERMINATED) break;
+    if (!tag) continue;
+    const attributesEnd = tag.end - (tag.selfClosing ? 2 : 1);
+    if (/\btitleSize\s*=/.test(tag.attributes)) continue;
+    result += `${body.slice(cursor, attributesEnd).trimEnd()} titleSize="p"${tag.selfClosing ? " /" : ""}>`;
+    cursor = tag.end;
+  }
+  return result + body.slice(cursor);
+}
+function isKnownComponentName(name, body) {
+  if (isThallyBuiltinComponent(name)) return true;
+  if (new RegExp(`^\\s*export\\s+(?:const|function|default\\s+function)\\s+${name}\\b`, "m").test(body)) return true;
+  if (new RegExp(`^\\s*import\\s+(?:\\{[^}]*\\b${name}\\b[^}]*\\}|${name})\\s+from\\s+['"][^'"]+['"]`, "m").test(body)) return true;
+  return false;
+}
+function escapeOrphanCapitalizedTags(body) {
+  const masked = maskCodeRegions(body);
+  const tagPattern = /<(\/?)([A-Z][A-Za-z0-9]*)(?:\s+[^<>]*?)?(\/?)>/g;
+  const opens = /* @__PURE__ */ new Map();
+  const closedOrSelfClosed = /* @__PURE__ */ new Set();
+  for (const match of masked.matchAll(tagPattern)) {
+    const [full, closing, name, selfClosing] = match;
+    if (closing || selfClosing) {
+      closedOrSelfClosed.add(name);
+      continue;
+    }
+    const start = match.index;
+    const list = opens.get(name) ?? [];
+    list.push({ start, end: start + full.length });
+    opens.set(name, list);
+  }
+  const edits = [];
+  for (const [name, ranges] of opens) {
+    if (closedOrSelfClosed.has(name) || isKnownComponentName(name, body)) continue;
+    edits.push(...ranges);
+  }
+  if (edits.length === 0) return body;
+  try {
+    compileSync(body, { outputFormat: "program" });
+    return body;
+  } catch {
+  }
+  edits.sort((a, b) => a.start - b.start);
+  let result = "";
+  let cursor = 0;
+  for (const edit of edits) {
+    result += body.slice(cursor, edit.start);
+    result += body.slice(edit.start, edit.end).replace(/^</, "&lt;").replace(/>$/, "&gt;");
+    cursor = edit.end;
+  }
+  return result + body.slice(cursor);
+}
+var REACT_HOOK_NAMES = ["useState", "useEffect", "useRef", "useCallback", "useMemo", "useContext", "useReducer"];
+function injectReactHookImports(body) {
+  const masked = maskCodeRegions(body);
+  const used = REACT_HOOK_NAMES.filter((hook) => new RegExp(`\\b${hook}\\s*\\(`).test(masked) && !new RegExp(`import\\s*\\{[^}]*\\b${hook}\\b[^}]*\\}\\s*from\\s*['"]react['"]`).test(body));
+  return used.length > 0 ? `import { ${used.join(", ")} } from 'react'
+
+${body}` : body;
+}
+function removeUndefinedExpressions(body, warn) {
+  if (!body.includes("{")) return body;
+  let tree;
+  try {
+    tree = descriptionParser.parse(body);
+  } catch {
+    return body;
+  }
+  const esm = [];
+  const collect = (node) => {
+    if (node.type === "mdxjsEsm" && node.value) esm.push(node.value);
+    for (const child of node.children ?? []) collect(child);
+  };
+  collect(tree);
+  const scope = pageScopeNames(esm);
+  const edits = [];
+  const removed = /* @__PURE__ */ new Set();
+  const check = (expression, position) => {
+    const names = unresolvedExpressionNames(expression, scope);
+    const start = position?.start.offset;
+    const end = position?.end.offset;
+    if (names.length === 0 || start === void 0 || end === void 0) return;
+    names.forEach((name) => removed.add(name));
+    edits.push({ start, end });
+  };
+  const visit = (node) => {
+    if ((node.type === "mdxFlowExpression" || node.type === "mdxTextExpression") && node.value !== void 0) {
+      check(node.value, node.position);
+    }
+    for (const attribute of node.attributes ?? []) {
+      const value = attribute.value;
+      if (attribute.type === "mdxJsxExpressionAttribute" && typeof value === "string") check(`{${value}}`, attribute.position);
+      else if (value && typeof value === "object" && typeof value.value === "string") {
+        check(value.value, attribute.position);
+      }
+    }
+    for (const child of node.children ?? []) visit(child);
+  };
+  visit(tree);
+  if (edits.length === 0) return body;
+  warn?.(`Expressions that use ${[...removed].map((name) => `"${name}"`).join(", ")} were removed so the page builds: ${removed.size === 1 ? "the name is" : "the names are"} not defined on this page. Define ${removed.size === 1 ? "the name" : "the names"} or escape the braces as \\{ \\} to show the text.`);
+  return edits.sort((a, b) => b.start - a.start).reduce((text, edit) => text.slice(0, edit.start) + text.slice(edit.end), body);
+}
+function normalizeFlowParagraphContainers(body) {
+  if (!body.includes("<p")) return body;
+  let tree;
+  try {
+    tree = descriptionParser.parse(body);
+  } catch {
+    return body;
+  }
+  const edits = [];
+  function visit(node) {
+    if (node.type === "mdxJsxFlowElement" && node.name === "p" && node.children?.some((child) => child.type === "paragraph" || child.type === "list" || child.type === "mdxJsxFlowElement")) {
+      const start = node.position?.start.offset;
+      const end = node.position?.end.offset;
+      if (start !== void 0 && end !== void 0 && body.slice(start, start + 2) === "<p") {
+        const closing = body.slice(start, end).match(/<\/p\s*>\s*$/i);
+        if (closing?.index !== void 0) {
+          edits.push({ offset: start + 1, value: "div" });
+          edits.push({ offset: start + closing.index + 2, value: "div" });
+        }
+      }
+    }
+    for (const child of node.children ?? []) visit(child);
+  }
+  visit(tree);
+  return edits.sort((a, b) => b.offset - a.offset).reduce((text, edit) => text.slice(0, edit.offset) + edit.value + text.slice(edit.offset + 1), body);
+}
+function normalizeMdx(body, platform, unwrapMdxCodeBlocks = true) {
+  const runFern = platform === "fern";
+  const runMintlify = platform === "mintlify";
+  const runDocusaurus = platform === "docusaurus";
+  const sourceBody = runDocusaurus && unwrapMdxCodeBlocks ? unwrapDocusaurusMdxCodeBlocks(body) : body;
+  let rewritten = normalizeExplicitHeadingIds(
+    runFern ? normalizeFernFileTrees(normalizeFernCallouts(normalizeNestedCodeFences(sourceBody))) : normalizeNestedCodeFences(sourceBody),
+    void 0,
+    { headingMarkers: runMintlify }
+  );
+  if (runDocusaurus) rewritten = normalizeDocusaurusAdmonitions(rewritten);
+  if (runMintlify) rewritten = markMintlifyHeadings(rewritten);
+  if (runDocusaurus) {
+    rewritten = replaceOutsideCode(rewritten, (segment) => segment.replace(
+      /:([+\w-]+):/g,
+      (shortcode, name) => nameToEmoji[name] ?? shortcode
+    ));
+    rewritten = replaceOutsideCode(rewritten, (segment) => segment.replace(
+      /\b(href|src)=\{\s*require\(\s*(['"])@docusaurus\/useBaseUrl\2\s*\)\.default\(\s*(['"])([^'"]+)\3\s*\)\s*\}/g,
+      (original, attribute, _moduleQuote, _pathQuote, path) => {
+        if (!/^[\w./~%-]+$/.test(path) || path.split("/").includes("..")) return original;
+        return `${attribute}="/${path.replace(/^\.\//, "").replace(/^\/+/, "")}"`;
+      }
+    ));
+    rewritten = replaceOutsideCode(rewritten, (segment) => normalizeDocusaurusThemedImages(normalizeDocusaurusAdmonitionTags(segment)));
+    rewritten = normalizeDocusaurusTabBlocks(normalizeDocusaurusTabs(removeGlobalDocusaurusImports(rewritten)));
+    rewritten = replaceOutsideCode(rewritten, (segment) => segment.replace(
+      /\bimport\s+([A-Za-z_$][\w$]*)\s+from\s+(['"])(@site\/[^'"]+)\2\s*;?/g,
+      (statement, binding, _quote, _source, offset) => {
+        const withoutStatement = segment.slice(0, offset) + segment.slice(offset + statement.length);
+        return new RegExp(`\\b${binding}\\s*(?:\\.|\\[|\\})`).test(withoutStatement) ? statement : "";
+      }
+    ));
+    rewritten = rewritten.replace(/^\n{2,}/, "\n");
+  }
+  if (runMintlify) rewritten = normalizeMintlifyParameterAnchors(rewritten);
+  rewritten = replaceOutsideCode(rewritten, (segment) => {
+    let result = convertHtmlStyleAttributes(segment).replace(/<!--([\s\S]*?)-->/g, (_match, content) => mdxComment(content)).replace(/<Danger(\s[^>]*)?>/g, "<Error$1>").replace(/<\/Danger>/g, "</Error>").replace(/<Warn(\s[^>]*)?>/g, "<Warning$1>").replace(/<\/Warn>/g, "</Warning>").replace(/<Check(\s[^>]*)?>/g, "<Note$1>").replace(/<\/Check>/g, "</Note>").replace(/<Tree\.Folder/g, "<Folder").replace(/<\/Tree\.Folder>/g, "</Folder>").replace(/<Tree\.File/g, "<File").replace(/<\/Tree\.File>/g, "</File>");
+    if (runDocusaurus) {
+      result = result.replace(/<TabItem\b([^<>]*)>/g, (_match, attributes) => {
+        const title = attributes.match(/\blabel=(?:"([^"]*)"|'([^']*)')/)?.slice(1).find(Boolean) ?? attributes.match(/\bvalue=(?:"([^"]*)"|'([^']*)')/)?.slice(1).find(Boolean) ?? "Tab";
+        return `<Tab title="${title.replace(/"/g, "&quot;")}">`;
+      }).replace(/<\/TabItem>/g, "</Tab>");
+      result = normalizeDocusaurusLinkTags(result).replace(/<(?:DocCardList|TOCInline)\b[^<>]*\/>/g, "");
+    }
+    if (runMintlify) {
+      result = normalizeMintlifyUpdateLabels(result).replace(/<FileTree(\s[^>]*)?>/g, "<Tree$1>").replace(/<\/FileTree>/g, "</Tree>").replace(/<GitHub\.Repo/g, "<GitHub").replace(/<\/GitHub\.Repo>/g, "</GitHub>").replace(/<Column(\s[^>]*)?>/g, "<div$1>").replace(/<\/Column>/g, "</div>");
+      result = pinStepsTitleSize(result);
+    }
+    if (runFern) {
+      result = result.replace(/<CodeBlocks(\s[^>]*)?>/g, "<CodeGroup$1>").replace(/<\/CodeBlocks>/g, "</CodeGroup>").replace(/<ParameterField\b/g, "<ParamField").replace(/<\/ParameterField>/g, "</ParamField>").replace(/<Cards(\s[^>]*)?>/g, "<CardGroup$1>").replace(/<\/Cards>/g, "</CardGroup>").replace(/<Success(\s[^>]*)?>/g, "<Tip$1>").replace(/<\/Success>/g, "</Tip>").replace(/<Launch(\s[^>]*)?>/g, "<Note$1>").replace(/<\/Launch>/g, "</Note>").replace(/<Files(\s[^>]*)?>\n?/g, "").replace(/<\/Files>/g, "");
+    }
+    return result;
+  });
+  if (runFern) rewritten = unwrapFernCodeBlockTabs(rewritten);
+  const normalized = escapeOrphanCapitalizedTags(provideScopedGlobalReferences(rewritten));
+  if (runDocusaurus && sourceBody !== body) {
+    try {
+      compileSync(normalized, { outputFormat: "program" });
+    } catch {
+      return normalizeMdx(body, platform, false);
+    }
+  }
+  return normalizeFlowParagraphContainers(normalized);
+}
+function parseMarkdownPage(input) {
+  const parsed = parseFrontmatter(input.raw);
+  const fallbackIdentity = {
+    id: input.id,
+    navigationId: input.navigationId ?? input.id,
+    ...input.locale ? { locale: input.locale } : {}
+  };
+  const identity = input.resolveIdentity?.(parsed.data, fallbackIdentity) ?? fallbackIdentity;
+  const body = removeUndefinedExpressions(injectReactHookImports(normalizeMdx(parsed.content, input.platform)), input.warn).trim();
+  const keywords = Array.isArray(parsed.data.keywords) ? parsed.data.keywords.filter((value) => typeof value === "string") : [];
+  const heading = leadingPageHeading(body);
+  const title = typeof parsed.data.title === "string" && parsed.data.title.trim() ? parsed.data.title.trim() : heading?.title ?? titleFromId(identity.navigationId);
+  const sidebarTitle = input.platform === "docusaurus" ? parsed.data.sidebar_label : parsed.data.sidebarTitle;
+  const navTitle = typeof sidebarTitle === "string" && sidebarTitle.trim() ? sidebarTitle.trim() : typeof parsed.data.navTitle === "string" && parsed.data.navTitle.trim() ? parsed.data.navTitle.trim() : void 0;
+  const icon = typeof parsed.data.icon === "string" && parsed.data.icon.trim() ? parsed.data.icon.trim() : void 0;
+  const iconType = icon && typeof parsed.data.iconType === "string" && ["regular", "solid", "outline", "brands"].includes(parsed.data.iconType) ? parsed.data.iconType : void 0;
+  const meta = {};
+  for (const [source, field] of PAGE_META_FIELDS) {
+    const value = parsed.data[source];
+    if (typeof value === "string" && value.trim()) meta[field] = value.trim();
+  }
+  const badge = typeof parsed.data.tag === "string" && parsed.data.tag.trim() ? parsed.data.tag.trim() : typeof parsed.data.badge === "string" && parsed.data.badge.trim() ? parsed.data.badge.trim() : void 0;
+  const sourceMode = typeof parsed.data.mode === "string" ? parsed.data.mode : void 0;
+  const mode = sourceMode === "frame" ? "wide" : ["default", "wide", "custom", "center", "home"].includes(sourceMode ?? "") ? sourceMode : void 0;
+  const description = typeof parsed.data.description === "string" && parsed.data.description.trim() ? parsed.data.description.trim() : typeof parsed.data.openapi === "string" && parsed.data.openapi.trim() ? "" : firstParagraph(body);
+  const page = {
+    id: identity.id,
+    navigationId: identity.navigationId,
+    locale: identity.locale,
+    title,
+    navTitle,
+    icon,
+    iconType,
+    description,
+    ...input.platform === "docusaurus" || input.platform === "fern" ? { descriptionPlacement: "body" } : {},
+    badge,
+    keywords,
+    mode,
+    hidden: parsed.data.hidden === true ? true : void 0,
+    noindex: parsed.data.noindex === true || parsed.data.noindex === "true" ? true : void 0,
+    ...Object.keys(meta).length > 0 ? { meta } : {},
+    openapi: typeof parsed.data.openapi === "string" ? parsed.data.openapi.trim() : void 0,
+    ...apiFrontmatter(parsed.data, input.warn),
+    body,
+    source: input.source,
+    ...parsed.error ? { frontmatterError: parsed.error } : {}
+  };
+  resolvePageDisplayHeading(page, input.platform);
+  return page;
+}
+var PAGE_META_FIELDS = [
+  ["og:title", "ogTitle"],
+  ["og:description", "ogDescription"],
+  ["og:image", "ogImage"],
+  ["twitter:title", "twitterTitle"],
+  ["twitter:description", "twitterDescription"],
+  ["twitter:image", "twitterImage"]
+];
+var AUTH_METHODS = /* @__PURE__ */ new Set(["bearer", "basic", "key", "none"]);
+function apiFrontmatter(data, warn) {
+  const result = {};
+  if (data.playground !== void 0 && data.playground !== null) {
+    const display = playgroundDisplay(data.playground, `The page's "playground" frontmatter`, warn);
+    if (display) result.playground = display;
+  }
+  if (data.api !== void 0 && data.api !== null) {
+    if (typeof data.api === "string" && data.api.trim()) result.api = data.api.trim();
+    else warn?.(`The page's "api" frontmatter is not a "METHOD url-or-path" string and was dropped.`);
+  }
+  if (data.authMethod !== void 0 && data.authMethod !== null) {
+    const method = typeof data.authMethod === "string" ? data.authMethod.trim().toLowerCase() : "";
+    if (AUTH_METHODS.has(method)) result.authMethod = method;
+    else warn?.(`The page's "authMethod" frontmatter is not one of bearer, basic, key, none and was dropped.`);
+  }
+  return result;
+}
+
+// src/url.ts
+var MAX_LOCAL_RESPONSE_BYTES = 2e6;
+var PORTABLE_MDX_COMPONENTS = /* @__PURE__ */ new Set([
+  "Accordion",
+  "AccordionGroup",
+  "Badge",
+  "Callout",
+  "Card",
+  "CardGroup",
+  "Check",
+  "CodeBlock",
+  "CodeGroup",
+  "Color",
+  "Column",
+  "Columns",
+  "ContentPanel",
+  "Danger",
+  "Error",
+  "Expandable",
+  "Agent",
+  "AgentPrompt",
+  "Banner",
+  "BannerPreview",
+  "Embed",
+  "File",
+  "Folder",
+  "Frame",
+  "GitHub",
+  "Github",
+  "Hero",
+  "Human",
+  "Icon",
+  "Info",
+  "InlinePanel",
+  "InlineRequestExample",
+  "InlineResponseExample",
+  "Latex",
+  "LegacyView",
+  "LiteYouTubeEmbed",
+  "MDX",
+  "Mermaid",
+  "Note",
+  "Panel",
+  "ParamField",
+  "Prompt",
+  "PromptAssistant",
+  "PromptUser",
+  "RequestExample",
+  "ResponseExample",
+  "ResponseField",
+  "Step",
+  "Steps",
+  "Tab",
+  "Tabs",
+  "Terminal",
+  "TerminalInput",
+  "TerminalOutput",
+  "Tile",
+  "TileGroup",
+  "Tip",
+  "Tooltip",
+  "Tree",
+  "Update",
+  "Video",
+  "View",
+  "Visibility",
+  "Warning",
+  "YouTube",
+  "picture",
+  "source"
+]);
+var PORTABLE_URL_PROPS = "href|src|img|primaryHref|secondaryHref";
+var PORTABLE_URL_PROP_NAMES = new Set(PORTABLE_URL_PROPS.split("|"));
+var remoteMarkdownParser = unified2().use(remarkParse2).use(remarkMdx2);
+function validateMigrationUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("Enter a complete documentation URL, including https://.");
+  }
+  if (!["http:", "https:"].includes(url.protocol)) {
+    throw new Error("Documentation imports support only HTTP and HTTPS URLs.");
+  }
+  if (url.username || url.password) throw new Error("Documentation URLs cannot contain credentials.");
+  url.hash = "";
+  return url;
+}
+async function readResponseBody(response) {
+  const contentLength = Number(response.headers.get("content-length") ?? 0);
+  if (contentLength > MAX_LOCAL_RESPONSE_BYTES) throw new Error("A documentation response exceeded the 2 MB import limit.");
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > MAX_LOCAL_RESPONSE_BYTES) {
+      await reader.cancel();
+      throw new Error("A documentation response exceeded the 2 MB import limit.");
+    }
+    chunks.push(value);
+  }
+  const body = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(body);
+}
+var defaultMigrationFetcher = async (url, request) => {
+  const response = await fetch(url, {
+    headers: {
+      Accept: request.accept,
+      "User-Agent": "Thally-Migrate/1.0 (+https://thally.io)"
+    },
+    redirect: "follow",
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!response.ok) throw new Error(`Documentation server returned ${response.status}.`);
+  return {
+    finalUrl: new URL(response.url),
+    body: await readResponseBody(response),
+    contentType: response.headers.get("content-type") ?? "",
+    headers: Object.fromEntries(response.headers.entries())
+  };
+};
+function plainDescription(value) {
+  return value.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/[`*_>#-]/g, "").replace(/\s+/g, " ").trim().slice(0, 240);
+}
+function withoutFencedCode(body) {
+  let fenceCharacter = "";
+  let fenceLength = 0;
+  return body.split("\n").map((line) => {
+    const match = line.match(/^\s{0,3}(`{3,}|~{3,})(.*)$/);
+    if (match && !fenceCharacter) {
+      fenceCharacter = match[1][0];
+      fenceLength = match[1].length;
+      return "";
+    }
+    if (match && match[1][0] === fenceCharacter && match[1].length >= fenceLength && match[2].trim() === "") {
+      fenceCharacter = "";
+      fenceLength = 0;
+      return "";
+    }
+    return fenceCharacter ? "" : line;
+  }).join("\n");
+}
+function eventHandlerPropEnd(value, start) {
+  const opening = value[start];
+  if (opening === '"' || opening === "'") {
+    for (let index = start + 1; index < value.length; index += 1) {
+      if (value[index] === opening && value[index - 1] !== "\\") return index + 1;
+    }
+    return null;
+  }
+  if (opening !== "{") {
+    const match = value.slice(start).match(/^[^\s>]+/);
+    return match ? start + match[0].length : null;
+  }
+  let depth = 0;
+  let quote = "";
+  for (let index = start; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote) {
+      if (character === quote && value[index - 1] !== "\\") quote = "";
+      continue;
+    }
+    if (character === '"' || character === "'" || character === "`") {
+      quote = character;
+      continue;
+    }
+    if (character === "{") depth += 1;
+    if (character === "}") {
+      depth -= 1;
+      if (depth === 0) return index + 1;
+    }
+  }
+  return null;
+}
+function stripEventHandlerProps(line) {
+  const matcher = /\s+on[A-Z][A-Za-z0-9]*\s*=\s*/g;
+  let cursor = 0;
+  let result = "";
+  for (const match of line.matchAll(matcher)) {
+    const start = match.index;
+    const valueStart = start + match[0].length;
+    const end = eventHandlerPropEnd(line, valueStart);
+    if (end === null) continue;
+    result += line.slice(cursor, start);
+    cursor = end;
+  }
+  return cursor === 0 ? line : `${result}${line.slice(cursor)}`;
+}
+function isSafePortableUrl(value) {
+  try {
+    const parsed = new URL(value, "https://relative.thally.invalid");
+    return ["http:", "https:", "mailto:", "tel:"].includes(parsed.protocol);
+  } catch {
+    return false;
+  }
+}
+function decodeHtmlAttribute(value) {
+  const document = load(`<i data-thally-value="${value.replace(/"/g, "&quot;")}"></i>`);
+  return document("i").attr("data-thally-value") ?? "";
+}
+function escapeMarkdownText(value, escapeTableSeparator = false) {
+  let escaped = "";
+  for (const character of value) {
+    if (character === "\\") escaped += "\\\\";
+    else if (character === "[" || character === "]") escaped += `\\${character}`;
+    else if (character === "<") escaped += "&lt;";
+    else if (character === ">") escaped += "&gt;";
+    else if (character === "{") escaped += "&#123;";
+    else if (character === "}") escaped += "&#125;";
+    else if (character === "|" && escapeTableSeparator) escaped += "\\|";
+    else escaped += character;
+  }
+  return escaped;
+}
+function markdownLinkDestination(value) {
+  try {
+    return encodeURI(value).replace(/\(/g, "%28").replace(/\)/g, "%29").replace(/&/g, "&amp;");
+  } catch {
+    return null;
+  }
+}
+function htmlOpeningTagEnd(value, start) {
+  let quote = "";
+  for (let index = start; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote) {
+      if (character === quote) quote = "";
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === ">") return index + 1;
+  }
+  return null;
+}
+function replacePortableHtmlImages(value) {
+  const matcher = /<img\b/gi;
+  let cursor = 0;
+  let output = "";
+  for (const match of value.matchAll(matcher)) {
+    const start = match.index;
+    if (start < cursor) continue;
+    const end = htmlOpeningTagEnd(value, start + match[0].length);
+    if (end === null) continue;
+    const fragment = load(value.slice(start, end));
+    const image = fragment("img").first();
+    const source = image.attr("src");
+    const destination = source && isSafePortableUrl(source) ? markdownLinkDestination(source) : null;
+    const alternative = escapeMarkdownText(image.attr("alt") ?? "");
+    output += value.slice(cursor, start);
+    output += destination ? `![${alternative}](${destination})` : alternative;
+    cursor = end;
+  }
+  return cursor === 0 ? value : `${output}${value.slice(cursor)}`;
+}
+function replacePortableHtmlAnchors(value) {
+  const matcher = /<a\b/gi;
+  let cursor = 0;
+  let output = "";
+  for (const match of value.matchAll(matcher)) {
+    const start = match.index;
+    if (start < cursor) continue;
+    const openingEnd = htmlOpeningTagEnd(value, start + match[0].length);
+    if (openingEnd === null) continue;
+    const closingMatch = /<\/a\s*>/gi;
+    closingMatch.lastIndex = openingEnd;
+    const closing = closingMatch.exec(value);
+    if (!closing) continue;
+    const end = closing.index + closing[0].length;
+    const fragment = load(value.slice(start, end));
+    const anchor = fragment("a").first();
+    const href = anchor.attr("href");
+    const label = escapeMarkdownText(anchor.text().replace(/\s+/g, " ").trim());
+    const destination = href && isSafePortableUrl(href) ? markdownLinkDestination(href) : null;
+    output += value.slice(cursor, start);
+    output += destination ? `[${label}](${destination})` : label;
+    cursor = end;
+  }
+  return cursor === 0 ? value : `${output}${value.slice(cursor)}`;
+}
+function markdownNodeText(node) {
+  if (node.type === "text" || node.type === "inlineCode") return node.value ?? "";
+  if (node.type === "image" || node.type === "imageReference") return node.alt ?? "";
+  return (node.children ?? []).map(markdownNodeText).join("");
+}
+function sanitizeMarkdownUrls(value) {
+  let root;
+  try {
+    root = remoteMarkdownParser.parse(value);
+  } catch {
+    return null;
+  }
+  let hasUnsafeMdxSyntax = false;
+  const validateMdxSyntax = (node) => {
+    if (node.type === "mdxTextExpression" || node.type === "mdxFlowExpression" || node.type === "mdxjsEsm") {
+      hasUnsafeMdxSyntax = true;
+      return;
+    }
+    if (node.type === "mdxJsxTextElement" || node.type === "mdxJsxFlowElement") {
+      for (const attribute of node.attributes ?? []) {
+        if (attribute.type !== "mdxJsxAttribute" || !attribute.name || /^on[A-Z]/.test(attribute.name)) {
+          hasUnsafeMdxSyntax = true;
+          return;
+        }
+        let staticValue = attribute.value;
+        if (attribute.value && typeof attribute.value === "object") {
+          if (attribute.value.type !== "mdxJsxAttributeValueExpression") {
+            hasUnsafeMdxSyntax = true;
+            return;
+          }
+          try {
+            staticValue = JSON.parse(attribute.value.value);
+          } catch {
+            hasUnsafeMdxSyntax = true;
+            return;
+          }
+        }
+        if (PORTABLE_URL_PROP_NAMES.has(attribute.name) && (typeof staticValue !== "string" || !isSafePortableUrl(decodeHtmlAttribute(staticValue)))) {
+          hasUnsafeMdxSyntax = true;
+          return;
+        }
+        if (node.name === "source" || node.name === "picture") {
+          const allowed = node.name === "picture" ? [] : ["src", "srcSet", "srcset", "sizes", "media", "type", "width", "height", "id"];
+          if (!allowed.includes(attribute.name) || typeof attribute.value !== "string") {
+            hasUnsafeMdxSyntax = true;
+            return;
+          }
+          try {
+            if (/^srcset$/i.test(attribute.name)) migrationImageCandidates(decodeHtmlAttribute(attribute.value), new URL("https://migration.invalid"));
+            if (attribute.name === "src") migrationImageUrl(decodeHtmlAttribute(attribute.value), new URL("https://migration.invalid"));
+          } catch {
+            hasUnsafeMdxSyntax = true;
+            return;
+          }
+        }
+      }
+    }
+    for (const child of node.children ?? []) validateMdxSyntax(child);
+  };
+  validateMdxSyntax(root);
+  if (hasUnsafeMdxSyntax) return null;
+  const unsafeDefinitions = /* @__PURE__ */ new Set();
+  const visitDefinitions = (node) => {
+    if (node.type === "definition" && node.identifier && node.url && !isSafePortableUrl(node.url)) unsafeDefinitions.add(node.identifier.toLowerCase());
+    for (const child of node.children ?? []) visitDefinitions(child);
+  };
+  visitDefinitions(root);
+  const replacements = [];
+  const replaceNode = (node, replacement) => {
+    const start = node.position?.start.offset;
+    const end = node.position?.end.offset;
+    if (start === void 0 || end === void 0) return false;
+    replacements.push({ start, end, value: replacement });
+    return true;
+  };
+  const visitUrls = (node) => {
+    const hasUnsafeDirectUrl = (node.type === "link" || node.type === "image") && typeof node.url === "string" && !isSafePortableUrl(node.url);
+    const hasUnsafeReference = (node.type === "linkReference" || node.type === "imageReference") && typeof node.identifier === "string" && unsafeDefinitions.has(node.identifier.toLowerCase());
+    if (hasUnsafeDirectUrl || hasUnsafeReference) {
+      if (replaceNode(node, escapeMarkdownText(markdownNodeText(node)))) return;
+    }
+    if (node.type === "definition" && node.identifier && unsafeDefinitions.has(node.identifier.toLowerCase())) {
+      if (replaceNode(node, "")) return;
+    }
+    for (const child of node.children ?? []) visitUrls(child);
+  };
+  visitUrls(root);
+  return replacements.sort((left, right) => right.start - left.start).reduce((result, replacement) => `${result.slice(0, replacement.start)}${replacement.value}${result.slice(replacement.end)}`, value);
+}
+function hasUnsafePortableUrlProp(value) {
+  const quotedProps = new RegExp(`\\b(?:${PORTABLE_URL_PROPS})\\s*=\\s*(['"])([^'"\\r\\n]*)\\1`, "gi");
+  for (const match of value.matchAll(quotedProps)) {
+    if (!isSafePortableUrl(decodeHtmlAttribute(match[2]))) return true;
+  }
+  const expressionProps = new RegExp(`\\b(?:${PORTABLE_URL_PROPS})\\s*=\\s*\\{\\s*("(?:\\\\.|[^"\\\\])*")\\s*\\}`, "gi");
+  for (const match of value.matchAll(expressionProps)) {
+    try {
+      if (!isSafePortableUrl(decodeHtmlAttribute(JSON.parse(match[1])))) return true;
+    } catch {
+      return true;
+    }
+  }
+  return false;
+}
+function portableHtmlToMarkdown(value) {
+  return replacePortableHtmlAnchors(replacePortableHtmlImages(value)).replace(/<span\b[^>]*>|<\/span>/gi, "").replace(/<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi, (_original, level, content) => {
+    return `
+${"#".repeat(Number(level))} ${content.trim()}
+`;
+  }).replace(/<p\b[^>]*>([\s\S]*?)<\/p>/gi, (_original, content) => `
+${content.trim()}
+`).replace(/<br\s*\/?\s*>/gi, "\n").replace(/<\/?(?:article|div|main|section)\b[^>]*>/gi, "");
+}
+function transformMarkdownProse(body, transform) {
+  const output = [];
+  let prose = [];
+  let fenceCharacter = "";
+  let fenceLength = 0;
+  const flushProse = () => {
+    if (prose.length === 0) return;
+    output.push(transform(prose.join("\n")));
+    prose = [];
+  };
+  for (const line of body.split("\n")) {
+    const fence = line.match(/^\s{0,3}(`{3,}|~{3,})(.*)$/);
+    if (fence && !fenceCharacter) {
+      flushProse();
+      fenceCharacter = fence[1][0];
+      fenceLength = fence[1].length;
+      output.push(line);
+      continue;
+    }
+    if (fenceCharacter) {
+      output.push(line);
+      if (fence && fence[1][0] === fenceCharacter && fence[1].length >= fenceLength && fence[2].trim() === "") {
+        fenceCharacter = "";
+        fenceLength = 0;
+      }
+      continue;
+    }
+    prose.push(line);
+  }
+  flushProse();
+  return output.join("\n");
+}
+function sanitizeRemoteMarkdown(body) {
+  let fenceCharacter = "";
+  let fenceLength = 0;
+  const portableBody = transformMarkdownProse(body, portableHtmlToMarkdown);
+  const sanitized = portableBody.split("\n").map((line) => {
+    const fence = line.match(/^\s{0,3}(`{3,}|~{3,})(.*)$/);
+    if (fence && !fenceCharacter) {
+      fenceCharacter = fence[1][0];
+      fenceLength = fence[1].length;
+      return line;
+    }
+    if (fence && fence[1][0] === fenceCharacter && fence[1].length >= fenceLength && fence[2].trim() === "") {
+      fenceCharacter = "";
+      fenceLength = 0;
+      return line;
+    }
+    if (fenceCharacter) return line;
+    return portableHtmlToMarkdown(stripEventHandlerProps(line.replace(/!\[([^\]]*)\]\(\s*([^)]+)\)/g, (original, alternative, destination) => isSafePortableUrl(decodeHtmlAttribute(destination.replace(/^<|>$/g, ""))) ? original : escapeMarkdownText(alternative))));
+  }).join("\n");
+  const urlSafeMarkdown = sanitizeMarkdownUrls(sanitized);
+  if (urlSafeMarkdown === null) return null;
+  const executable = withoutFencedCode(urlSafeMarkdown).replace(/\{\/\*[\s\S]*?\*\/\}/g, "").replace(/<(?:https?:\/\/|mailto:)[^>]+>/gi, "").replace(/(`+)[\s\S]*?\1/g, "");
+  if (/^\s*(?:import|export)\s/m.test(executable)) return null;
+  let hasUnsafeExpression = false;
+  const withoutStaticProps = executable.replace(/=\{([^{}\n]*)\}/g, (original, value) => {
+    try {
+      JSON.parse(value);
+      return '=""';
+    } catch {
+      hasUnsafeExpression = true;
+      return original;
+    }
+  }).replace(/\\[{}]/g, "");
+  if (hasUnsafeExpression || /[{}]/.test(withoutStaticProps) || /\bon[A-Z][A-Za-z]*\s*=/g.test(withoutStaticProps) || hasUnsafePortableUrlProp(executable)) return null;
+  for (const match of withoutStaticProps.matchAll(/<\/?([A-Za-z][A-Za-z0-9.]*)(?:\s|>|\/)/g)) {
+    const component = match[1].split(".", 1)[0];
+    if (!PORTABLE_MDX_COMPONENTS.has(component)) return null;
+  }
+  return urlSafeMarkdown;
+}
+function remoteMarkdownMetadata(body) {
+  if (!/^---\r?\n/.test(body)) return { content: body };
+  const end = body.slice(4, 65540).search(/\r?\n---(?:\r?\n|$)/);
+  if (end < 0) return { content: body };
+  const frontmatter = body.slice(4, end + 4);
+  const contentStart = end + 4 + body.slice(end + 4).match(/^\r?\n---(?:\r?\n|$)/)[0].length;
+  function scalar(key) {
+    const value = frontmatter.match(new RegExp(`^${key}:\\s*(.+)$`, "m"))?.[1].trim();
+    if (!value) return void 0;
+    if (/^['"].*['"]$/.test(value)) {
+      try {
+        const parsed = JSON.parse(value.replace(/^'/, '"').replace(/'$/, '"'));
+        return typeof parsed === "string" ? parsed : void 0;
+      } catch {
+        return value.slice(1, -1);
+      }
+    }
+    return value.slice(0, 500);
+  }
+  return {
+    content: body.slice(contentStart),
+    title: scalar("title"),
+    description: scalar("description"),
+    sidebarTitle: scalar("sidebarTitle"),
+    tag: scalar("tag"),
+    mode: scalar("mode"),
+    hidden: scalar("hidden") === "true" ? true : void 0,
+    noindex: scalar("noindex") === "true" ? true : void 0
+  };
+}
+function stripMintlifyDocumentationIndex(body) {
+  const lines = body.split(/\r?\n/);
+  if (!/^>\s*##\s+Documentation Index\s*$/i.test(lines[0] ?? "") || !/^>.*\/llms(?:-full)?\.txt/i.test(lines[1] ?? "") || !/^>.*discover all available pages/i.test(lines[2] ?? "")) return body;
+  let index = 3;
+  while (index < lines.length && /^>/.test(lines[index])) index += 1;
+  while (index < lines.length && lines[index].trim() === "") index += 1;
+  return lines.slice(index).join("\n");
+}
+function extractEmbeddedOpenApi(content) {
+  const fencePattern = /^\s{0,3}(`{3,}|~{3,})(?:yaml|yml|json)\s+(\S+\.(?:yaml|yml|json))\s+(delete|get|head|options|patch|post|put|trace)\s+(\/\S+)\s*\r?\n([\s\S]*?)^\s{0,3}\1\s*$/im;
+  const match = fencePattern.exec(content);
+  if (!match) return { content };
+  try {
+    const parsed = parseYaml2(match[5], { maxAliasCount: 50 });
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { content };
+    const document = parsed;
+    if (typeof document.openapi !== "string" && typeof document.swagger !== "string") return { content };
+    const method = match[3].toUpperCase();
+    const path = match[4];
+    const paths = document.paths;
+    if (!paths || typeof paths !== "object" || Array.isArray(paths)) return { content };
+    const pathItem = paths[path];
+    if (!pathItem || typeof pathItem !== "object" || Array.isArray(pathItem) || !(match[3].toLowerCase() in pathItem)) return { content };
+    const before = content.slice(0, match.index).replace(/(?:^|\n)##\s+OpenAPI\s*\n\s*$/i, "\n");
+    const after = content.slice(match.index + match[0].length);
+    return {
+      content: `${before}${after}`.trim(),
+      openapi: `${method} ${path}`,
+      fragment: {
+        method,
+        path,
+        document
+      }
+    };
+  } catch {
+    return { content };
+  }
+}
+function markdownPage(document, id, platform, warn) {
+  const parsed = remoteMarkdownMetadata(document.body);
+  let content = stripMintlifyDocumentationIndex(parsed.content).trimStart();
+  const titleMatch = content.match(/^#\s+(.+)\r?\n/);
+  const title = parsed.title ?? titleMatch?.[1] ?? id.split("/").at(-1) ?? "Introduction";
+  if (titleMatch) content = content.slice(titleMatch[0].length).trimStart();
+  let description = parsed.description;
+  if (!description) {
+    const quoteMatch = content.match(/^(>[^\r\n]*(?:\r?\n>[^\r\n]*)*)\r?\n/);
+    if (quoteMatch) {
+      description = plainDescription(quoteMatch[1].replace(/^>\s?/gm, ""));
+      content = content.slice(quoteMatch[0].length).trimStart();
+    }
+  }
+  const embeddedOpenApi = extractEmbeddedOpenApi(content);
+  const raw = [
+    "---",
+    `title: ${JSON.stringify(title)}`,
+    ...description ? [`description: ${JSON.stringify(description)}`] : [],
+    ...parsed.sidebarTitle ? [`sidebarTitle: ${JSON.stringify(parsed.sidebarTitle)}`] : [],
+    ...parsed.tag ? [`tag: ${JSON.stringify(parsed.tag)}`] : [],
+    ...parsed.mode ? [`mode: ${JSON.stringify(parsed.mode)}`] : [],
+    ...parsed.hidden ? ["hidden: true"] : [],
+    ...parsed.noindex ? ["noindex: true"] : [],
+    ...embeddedOpenApi.openapi ? [`openapi: ${JSON.stringify(embeddedOpenApi.openapi)}`] : [],
+    "---",
+    "",
+    embeddedOpenApi.content
+  ].join("\n");
+  return {
+    // The crawler knows the source platform (detected or caller-provided)
+    // before it ever parses a page; an omitted platform would otherwise
+    // apply every platform's textual renames to content of unknown origin.
+    page: parseMarkdownPage({ id, raw, source: document.finalUrl.toString(), platform, ...warn ? { warn } : {} }),
+    openApiFragment: embeddedOpenApi.fragment
+  };
+}
+function htmlPage(document, id, options = {}) {
+  const $ = load(document.body);
+  const links = $('nav a[href], main a[href], article a[href], [role="main"] a[href]').map((_index, element) => $(element).attr("href") ?? "").get().filter(Boolean);
+  const scopedTitle = options.omitDocumentHeading ? $('main article, article, main, [role="main"]').first().find("h1").first().text().trim() : "";
+  const title = scopedTitle || $("main h1, article h1, h1").first().text().trim() || $('meta[property="og:title"]').attr("content")?.trim() || $("title").text().split("|")[0].trim();
+  const description = $('meta[name="description"]').attr("content")?.trim() || $('meta[property="og:description"]').attr("content")?.trim();
+  const content = $('main article, article, main, [role="main"]').first();
+  const root = content.length ? content : $("body");
+  let documentHeadingAnchor = "";
+  const excludedElements = options.omitDocumentHeading ? "script,style,noscript,nav,footer,aside,form,button,svg,iframe,object,embed,link,meta" : "script,style,noscript,nav,header,footer,aside,form,button,svg,iframe,object,embed,link,meta";
+  root.find(excludedElements).remove();
+  root.find(".theme-doc-version-badge,.theme-doc-breadcrumbs,.theme-doc-toc-mobile,.table-of-contents,.hash-link").remove();
+  if (options.omitDocumentHeading) {
+    const heading = root.find("h1").first();
+    if (heading.length && heading.text().trim() === title) {
+      const anchorId = heading.attr("id");
+      if (anchorId) documentHeadingAnchor = `<a id="${migrationImageAttribute(anchorId)}" />
+
+`;
+      heading.remove();
+    }
+  }
+  root.find("a[href]").each((_index, element) => {
+    const href = $(element).attr("href");
+    if (!href) return;
+    try {
+      const resolved = new URL(href, document.finalUrl);
+      if (["http:", "https:", "mailto:", "tel:"].includes(resolved.protocol)) {
+        $(element).attr("href", resolved.toString());
+      } else {
+        $(element).removeAttr("href");
+      }
+    } catch {
+      $(element).removeAttr("href");
+    }
+  });
+  root.find("img[src]").each((_index, element) => {
+    const src = $(element).attr("src");
+    if (!src) return;
+    try {
+      const resolved = new URL(src, document.finalUrl);
+      if (["http:", "https:"].includes(resolved.protocol)) {
+        $(element).attr("src", resolved.toString());
+      } else {
+        $(element).removeAttr("src");
+      }
+    } catch {
+      $(element).removeAttr("src");
+    }
+  });
+  const turndown = new TurndownService({ codeBlockStyle: "fenced", emDelimiter: "_", headingStyle: "atx" });
+  turndown.remove(["script", "style", "noscript"]);
+  const anchor = (element) => {
+    const value = element.getAttribute("id");
+    return options.preserveAnchors && value ? `<a id="${value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/\{/g, "&#123;")}" />
+
+` : "";
+  };
+  if (options.preserveAnchors) turndown.addRule("migration-source-anchor", {
+    filter: (node) => node.hasAttribute("id") && node.nodeName !== "PRE",
+    replacement: (content2, node) => {
+      const element = node;
+      const heading = element.nodeName.match(/^H([1-6])$/);
+      return `
+
+${anchor(element)}${heading ? `${"#".repeat(Number(heading[1]))} ` : ""}${content2}
+
+`;
+    }
+  });
+  if (options.preserveResponsiveImages) {
+    const image = (element) => {
+      const tag = element.nodeName.toLowerCase();
+      const attributes = [];
+      for (const name of ["src", "srcset", "sizes", "alt", "title", "media", "type", "width", "height", "id"]) {
+        let value = element.getAttribute(name);
+        if (value === null) continue;
+        if (name === "src") value = migrationImageUrl(value, document.finalUrl);
+        if (name === "srcset") value = renderMigrationSrcset(migrationImageCandidates(value, document.finalUrl));
+        const prop = name === "srcset" ? "srcSet" : name;
+        attributes.push(`${prop}="${migrationImageAttribute(value)}"`);
+      }
+      return `<${tag}${attributes.length ? ` ${attributes.join(" ")}` : ""} />`;
+    };
+    turndown.addRule("migration-responsive-image", {
+      filter: (node) => ["IMG", "SOURCE"].includes(node.nodeName),
+      replacement: (_content, node) => image(node)
+    });
+    turndown.addRule("migration-responsive-picture", {
+      filter: "picture",
+      replacement: (content2) => `
+
+<picture>
+${content2.trim()}
+</picture>
+
+`
+    });
+  }
+  turndown.addRule("docusaurus-admonition", {
+    filter: (node) => node.nodeName === "DIV" && node.classList.contains("theme-admonition"),
+    replacement: (_content, node) => {
+      const element = node;
+      const className = element.className;
+      const tag = /admonition-(?:danger)/.test(className) ? "Error" : /admonition-(?:caution|warning)/.test(className) ? "Warning" : /admonition-info/.test(className) ? "Info" : "Note";
+      const fragment = load(element.outerHTML);
+      const clone = fragment(".theme-admonition").first();
+      const title2 = clone.find('[class*="admonitionHeading"],.admonition-heading').first();
+      const titleText = title2.text().trim();
+      title2.remove();
+      const markdown = turndown.turndown(clone.html() ?? "").trim();
+      return `
+
+${anchor(element)}<${tag}>
+${titleText ? `**${escapeMarkdownText(titleText)}**
+
+` : ""}${markdown}
+</${tag}>
+
+`;
+    }
+  });
+  turndown.addRule("docusaurus-tabs", {
+    filter: (node) => node.nodeName === "DIV" && node.classList.contains("tabs-container"),
+    replacement: (_content, node) => {
+      const element = node;
+      const fragment = load(element.outerHTML);
+      const container = fragment(".tabs-container").first();
+      const labels = container.children("ul.tabs").children("li").toArray().map((item) => fragment(item).text().trim() || "Tab");
+      const panels = container.find('[role="tabpanel"]').toArray().filter((panel) => fragment(panel).closest(".tabs-container")[0] === container[0]);
+      if (panels.length === 0) return _content;
+      const tabs = panels.map((panel, index) => {
+        const panelId = fragment(panel).attr("id");
+        const tab = panelId ? container.find('[role="tab"]').toArray().find((item) => fragment(item).attr("aria-controls") === panelId) : void 0;
+        const title2 = migrationImageAttribute((tab ? fragment(tab).text().trim() : labels[index]) || `Tab ${index + 1}`);
+        const panelAnchor = options.preserveAnchors && panelId ? `<a id="${migrationImageAttribute(panelId)}" />
+
+` : "";
+        return `<Tab title="${title2}">
+${panelAnchor}${turndown.turndown(fragment(panel).html() ?? "").trim()}
+</Tab>`;
+      });
+      return `
+
+${anchor(element)}<Tabs>
+${tabs.join("\n\n")}
+</Tabs>
+
+`;
+    }
+  });
+  turndown.addRule("gfm-table", {
+    filter: "table",
+    replacement: (_content, node) => {
+      const fragment = load(node.outerHTML);
+      const rows = fragment("tr").toArray().map((row) => fragment(row).children("th,td").toArray().map((cell) => escapeMarkdownText(
+        fragment(cell).text().replace(/\s+/g, " ").trim(),
+        true
+      ))).filter((row) => row.length > 0);
+      if (rows.length === 0) return "";
+      const width = Math.max(...rows.map((row) => row.length));
+      const normalized = rows.map((row) => [...row, ...Array(width - row.length).fill("")]);
+      return `
+
+| ${normalized[0].join(" | ")} |
+| ${Array(width).fill("---").join(" | ")} |
+${normalized.slice(1).map((row) => `| ${row.join(" | ")} |`).join("\n")}
+
+`;
+    }
+  });
+  turndown.addRule("migration-safe-fenced-code", {
+    filter: (node) => node.nodeName === "PRE",
+    replacement: (_content, node) => {
+      const element = node;
+      const fragment = load(element.outerHTML);
+      const tokenLines = fragment(".token-line").toArray();
+      const code = (tokenLines.length > 0 ? tokenLines.map((line) => fragment(line).text()).join("\n") : fragment("pre").text()).replace(/\n$/, "");
+      const language = fragment("code").attr("class")?.match(/(?:language-|lang-)([A-Za-z0-9_+-]+)/)?.[1] ?? "";
+      const longestFence = Math.max(0, ...[...code.matchAll(/`+/g)].map((match) => match[0].length));
+      const fence = "`".repeat(Math.max(3, longestFence + 1));
+      return `
+
+${anchor(element)}${fence}${language}
+${code}
+${fence}
+
+`;
+    }
+  });
+  const escape = turndown.escape.bind(turndown);
+  turndown.escape = (text) => escape(text).replace(/[<{}]/g, (match) => `\\${match}`);
+  const body = `${documentHeadingAnchor}${turndown.turndown(root.html() ?? "").trim()}`;
+  if (!title || body.length < 40 && $("article").length === 0) return { page: null, links };
+  return {
+    page: {
+      id,
+      navigationId: id,
+      title,
+      description: description || plainDescription(body) || `Documentation imported from ${document.finalUrl.hostname}.`,
+      keywords: [],
+      body,
+      source: document.finalUrl.toString()
+    },
+    links
+  };
+}
+
+// src/url-run.ts
+var CONVERTER_VERSION = "url-evidence-v2";
+var parser = unified3().use(remarkParse3).use(remarkMdx3);
+var ACCEPT = "text/markdown,text/html,application/xhtml+xml;q=0.9";
+var MAX_RESPONSE_BYTES = 8e6;
+var MAX_ASSET_BYTES = 1e7;
+var MAX_RECORDS = 1e5;
+var LOCALES = /* @__PURE__ */ new Set(["ar", "cs", "da", "de", "el", "en", "es", "fi", "fr", "he", "hi", "hu", "id", "it", "ja", "ko", "ms", "nl", "no", "pl", "pt", "pt-br", "ro", "ru", "sk", "sv", "th", "tr", "uk", "vi", "zh", "zh-cn", "zh-hans", "zh-hant"]);
+function hash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function pageHash(page) {
+  const canonical2 = (value) => Array.isArray(value) ? value.map(canonical2) : value !== null && typeof value === "object" ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, field]) => [key, canonical2(field)])) : value;
+  return hash(JSON.stringify(canonical2(page)));
+}
+function inScope(url, source, scope) {
+  return url.origin === source.origin && !url.username && !url.password && (scope === "/" || url.pathname === scope || url.pathname.startsWith(`${scope}/`));
+}
+function isDiscoveryIndex(url, source) {
+  return url.origin === source.origin && /\/(?:llms(?:-full)?|robots)\.txt$|\/sitemap[^/]*\.xml$/i.test(url.pathname);
+}
+function canonical(value, base) {
+  try {
+    const url = validateMigrationUrl(new URL(value, base).toString());
+    url.pathname = url.pathname.replace(/\/+$/, "") || "/";
+    return url.toString();
+  } catch {
+    return null;
+  }
+}
+function classifyMigrationResponse(document) {
+  if (document.status && document.status >= 400) return "unsupported";
+  if (/\/(?:llms(?:-full)?|robots)\.txt$|\/sitemap[^/]*\.xml$|\/search(?:\.html)?$/i.test(document.finalUrl.pathname) || /(?:xml|json)/i.test(document.contentType)) return "index";
+  if (/^(?:image|audio|video)\//i.test(document.contentType) || /\.(?:pdf|zip|png|jpe?g|webp|gif|svg|ico|mp4|webm)$/i.test(document.finalUrl.pathname)) return "asset";
+  return /(?:html|markdown|text\/plain)/i.test(document.contentType) || /\.mdx?$/i.test(document.finalUrl.pathname) ? "page" : "unsupported";
+}
+function markdownNodes(body) {
+  const nodes = [];
+  const visit = (node) => {
+    nodes.push(node);
+    for (const child of node.children ?? []) visit(child);
+  };
+  visit(parser.parse(body));
+  return nodes;
+}
+function markdownCode(body) {
+  return markdownNodes(body).filter((node) => node.type === "code").map((node) => node.value ?? "");
+}
+function alternativeBlocks(body, baseline) {
+  const blocks = (value) => (parser.parse(value).children ?? []).map((node) => value.slice(node.position.start.offset, node.position.end.offset));
+  const originals = new Set(blocks(baseline));
+  return blocks(body).filter((block) => !originals.has(block)).join("\n\n");
+}
+function linksOf(document) {
+  if (/html/i.test(document.contentType)) {
+    const $ = load2(document.body);
+    const root = $('main article,article,main,[role="main"]').first();
+    root.find("nav,footer,aside").remove();
+    return [...root.find("a[href]").toArray(), ...$('link[rel="sitemap"][href],link[rel="alternate"][href]').toArray()].map((node) => $(node).attr("href")).filter(Boolean);
+  }
+  if (/xml/i.test(document.contentType) || /<urlset|<sitemapindex/i.test(document.body)) {
+    const $ = load2(document.body, { xmlMode: true });
+    return $("loc").toArray().map((node) => $(node).text().trim());
+  }
+  return [
+    ...markdownNodes(document.body).flatMap((node) => node.url ? [node.url] : []),
+    ...[...document.body.matchAll(/^Sitemap:\s*(\S+)/gmi)].map((match) => match[1])
+  ];
+}
+function htmlEvidence(document) {
+  const $ = load2(document.body);
+  const root = $('main article,article,main,[role="main"]').first();
+  const article = root.length ? root : $("body");
+  article.find("nav,footer,aside,form,script,style").remove();
+  return {
+    anchors: article.find("[id]").toArray().map((node) => $(node).attr("id")).filter(Boolean),
+    code: article.find("pre").toArray().map((node) => {
+      const lines = $(node).find(".token-line");
+      return lines.length ? lines.toArray().map((line) => $(line).text()).join("\n") : $(node).text();
+    })
+  };
+}
+function evidenceOf(capture) {
+  const technical = /html/i.test(capture.contentType) ? htmlEvidence(capture) : { code: markdownCode(capture.body), anchors: markdownHeadingAnchors(capture.body) };
+  return {
+    sha256: hash(capture.body),
+    byteLength: Buffer.byteLength(capture.body),
+    finalUrl: capture.finalUrl.toString(),
+    contentType: capture.contentType,
+    ...capture.artifactRef ? { artifactRef: capture.artifactRef } : {},
+    states: (capture.states ?? []).map((state) => ({ id: state.id, label: state.label, sha256: hash(state.response.body) })),
+    ...technical,
+    links: linksOf(capture)
+  };
+}
+function markdownHeadingAnchors(body) {
+  const seen = /* @__PURE__ */ new Map();
+  return markdownNodes(body).filter((node) => node.type === "heading").map((node) => {
+    const text = (value) => value.value ?? (value.children ?? []).map(text).join("");
+    const base = text(node).toLowerCase().replace(/[^\p{L}\p{N}\s_-]/gu, "").replace(/\s/g, "-");
+    const occurrence = seen.get(base) ?? 0;
+    seen.set(base, occurrence + 1);
+    return occurrence ? `${base}-${occurrence}` : base;
+  });
+}
+function sourceNavigation(capture) {
+  if (capture.navigation) {
+    const resolve3 = (nodes, depth = 0) => {
+      if (depth > 32 || nodes.length > 1e4) throw new Error("Source navigation exceeds its depth or width safety bound.");
+      return nodes.map((node) => ({ label: node.label, ...node.url ? { url: new URL(node.url, capture.finalUrl).toString() } : {}, ...node.children ? { children: resolve3(node.children, depth + 1) } : {} }));
+    };
+    return resolve3(capture.navigation);
+  }
+  if (!/html/i.test(capture.contentType)) return [];
+  const $ = load2(capture.body);
+  const candidates = ['.theme-doc-sidebar-menu,[aria-label*="sidebar" i]', "aside", '[role="navigation"],nav'];
+  const root = candidates.map((selector) => $(selector).filter((_index, node) => $(node).find("a[href]").length > 0 && $(node).closest("header").length === 0).first()).find((candidate) => candidate.length) ?? $("aside").first();
+  if (!root.length) return [];
+  const walk = (element, excluded) => {
+    const result = [];
+    $(element).children().each((_index, node) => {
+      if (node === excluded) return;
+      const item = $(node);
+      if (item.is("a[href]")) {
+        result.push({ label: item.text().replace(/\s+/g, " ").trim(), url: new URL(item.attr("href"), capture.finalUrl).toString() });
+      } else if (item.is("li,details") || item.attr("data-migration-group") !== void 0 || item.children("h2,h3,h4,h5,h6").length > 0) {
+        const directLink = item.children("a[href]").first();
+        const direct = directLink.length ? directLink : item.children("div").children("a[href]").first();
+        const label = direct.text().trim() || item.children("summary,button,span,h2,h3,h4,h5,h6").first().text().trim();
+        const children = walk(node, direct[0]);
+        if (label) result.push({ label, ...direct.length ? { url: new URL(direct.attr("href"), capture.finalUrl).toString() } : {}, ...children.length ? { children } : {} });
+        else result.push(...children);
+      } else result.push(...walk(node, excluded));
+    });
+    return result;
+  };
+  try {
+    return walk(root);
+  } catch {
+    return [];
+  }
+}
+function idForUrl(url, scope) {
+  const relative4 = scope === "/" ? url.pathname.slice(1) : url.pathname.slice(scope.length).replace(/^\//, "");
+  const id = pageIdFromReference(relative4 || "introduction", true);
+  return id && `${id}${url.search ? `--${hash(url.search).slice(0, 12)}` : ""}`;
+}
+function convert(document, id) {
+  if (/html/i.test(document.contentType)) {
+    const technical = htmlEvidence(document);
+    const page = htmlPage(document, id, { preserveAnchors: true, preserveResponsiveImages: true, omitDocumentHeading: true }).page;
+    if (!page) return null;
+    page.descriptionPlacement = "body";
+    const nodes = markdownNodes(page.body).filter((node) => node.type === "code");
+    if (nodes.length === technical.code.length) {
+      for (let index = nodes.length - 1; index >= 0; index--) {
+        const node = nodes[index];
+        const start = node.position?.start.offset;
+        const end = node.position?.end.offset;
+        if (start === void 0 || end === void 0) continue;
+        const original = page.body.slice(start, end);
+        const info = original.split("\n", 1)[0].replace(/^`+|^~+/, "");
+        const code = technical.code[index];
+        const fence = "`".repeat(Math.max(3, ...[...code.matchAll(/`+/g)].map((match) => match[0].length + 1)));
+        page.body = `${page.body.slice(0, start)}${fence}${info}
+${code}
+${fence}${page.body.slice(end)}`;
+      }
+    }
+    return page;
+  }
+  const safe = sanitizeRemoteMarkdown(document.body);
+  return safe === null ? null : markdownPage({ ...document, body: safe }, id, "generic").page;
+}
+function assetReferences(capture) {
+  if (!/html/i.test(capture.contentType)) {
+    return markdownNodes(capture.body).filter((node) => node.type === "image").flatMap((node) => node.url ? [node.url] : []);
+  }
+  const $ = load2(capture.body);
+  const root = $('main article,article,main,[role="main"]').first();
+  return [
+    ...root.find("img[src],video[poster],a[download][href]").toArray().map((node) => $(node).attr("src") ?? $(node).attr("poster") ?? $(node).attr("href")),
+    ...root.find("[srcset]").toArray().flatMap((node) => migrationImageCandidates($(node).attr("srcset") ?? "", capture.finalUrl).map((candidate) => candidate.url))
+  ].filter(Boolean);
+}
+function unresolvedStaticControls(body) {
+  const $ = load2(body);
+  const root = $('main article,article,main,[role="main"]').first();
+  const tabs = root.find('[role="tab"]').toArray();
+  for (const tab of tabs) {
+    const controls = $(tab).attr("aria-controls");
+    const panels = controls ? root.find("[id]").filter((_index, node) => $(node).attr("id") === controls) : root.find('[role="tabpanel"]').eq(tabs.indexOf(tab));
+    if (panels.length !== 1 || !panels.text().trim() && !panels.find("pre,img,table,svg").length || panels.find('[aria-busy="true"],[role="progressbar"]').length) return true;
+  }
+  return root.find("details:not([open])").toArray().some((node) => {
+    const clone = $(node).clone();
+    clone.children("summary").remove();
+    return !clone.text().trim() && !clone.find("pre,img,table,svg").length;
+  });
+}
+async function defaultAssetFetcher(url, signal) {
+  const response = await fetch(url, { signal: signal ?? AbortSignal.timeout(15e3) });
+  if (!response.ok) throw new Error(`Asset returned ${response.status}.`);
+  if (Number(response.headers.get("content-length")) > MAX_ASSET_BYTES) throw new Error("Asset exceeds size limit.");
+  const reader = response.body?.getReader();
+  const chunks = [];
+  let size = 0;
+  if (reader) while (true) {
+    const next = await reader.read();
+    if (next.done) break;
+    size += next.value.length;
+    if (size > MAX_ASSET_BYTES) {
+      await reader.cancel();
+      throw new Error("Asset exceeds size limit.");
+    }
+    chunks.push(next.value);
+  }
+  return { url: response.url || url.toString(), contentType: response.headers.get("content-type") ?? "", content: Buffer.concat(chunks) };
+}
+function acceptedAsset(asset) {
+  if (asset.content.byteLength > MAX_ASSET_BYTES) return null;
+  const mime = asset.contentType.split(";", 1)[0].toLowerCase().trim();
+  if (mime === "image/svg+xml") return isPassiveSvg(asset.content) ? "svg" : null;
+  const signature = Buffer.from(asset.content.slice(0, 16));
+  const extensions = { "image/png": "png", "image/jpeg": "jpg", "image/gif": "gif", "image/webp": "webp", "application/pdf": "pdf", "image/avif": "avif" };
+  const extension = extensions[mime];
+  if (!extension) return null;
+  const isSignatureValid = extension === "png" ? signature.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])) : extension === "jpg" ? signature[0] === 255 && signature[1] === 216 : extension === "gif" ? /^GIF8[79]a/.test(signature.toString()) : extension === "webp" ? signature.toString("ascii", 0, 4) === "RIFF" && signature.toString("ascii", 8, 12) === "WEBP" : extension === "pdf" ? signature.toString("ascii", 0, 5) === "%PDF-" : signature.toString("ascii", 4, 8) === "ftyp" && /avif|avis/.test(signature.toString("ascii", 8));
+  return isSignatureValid ? extension : null;
+}
+function validRecord(record) {
+  if (record.outcome !== "imported") return true;
+  return Boolean(record.page && record.pageSha256 === pageHash(record.page) && record.evidence && pageIdFromReference(record.page.id, true) === record.page.id && pageIdFromReference(record.page.navigationId, true) === record.page.navigationId && sanitizeRemoteMarkdown(record.page.body.replace(/^<a id="[^"<]*" \/>$/gm, "")) !== null && /^[a-f0-9]{64}$/.test(record.evidence.sha256) && record.assets?.every((asset) => /^migration-assets\/[a-f0-9]{64}\.[a-z0-9]+$/.test(asset.path) && hash(Buffer.from(asset.base64, "base64")) === asset.sha256));
+}
+function navigationConfig(navigation, records) {
+  const project = (nodes) => nodes.flatMap((node) => {
+    const record = node.url ? records.get(canonical(node.url, node.url) ?? "") : void 0;
+    const target = record?.outcome === "alias" ? records.get(record.aliasOf ?? "") : record;
+    const page = target?.page;
+    const children = project(node.children ?? []);
+    if (children.length) {
+      const contains = (entries) => entries.some((entry) => typeof entry === "string" ? entry === page?.navigationId : contains(entry.pages));
+      return [{ group: node.label || "Documentation", pages: [...page && !contains(children) ? [page.navigationId] : [], ...children] }];
+    }
+    return page ? [page.navigationId] : [];
+  });
+  const pages = project(navigation);
+  return pages.length ? { tabs: [{ tab: "Documentation", pages }] } : null;
+}
+function observedLocale(document, id, scopePath) {
+  const issues = [];
+  const canonicalLanguage = (value) => {
+    if (!/^[a-z]{2,3}(?:-[a-z0-9]{2,8}){0,4}$/i.test(value)) return void 0;
+    try {
+      return Intl.getCanonicalLocales(value)[0];
+    } catch {
+      return void 0;
+    }
+  };
+  const candidates = [];
+  if (document.locale) {
+    const locale = canonicalLanguage(document.locale);
+    if (!locale) throw new Error("Capture locale is not a portable language code.");
+    candidates.push({ source: "capture", value: locale });
+  }
+  const urlLocale = [id.split("/", 1)[0], ...scopePath.split("/"), document.finalUrl.pathname.split("/").filter(Boolean)[0]].find((segment) => segment && LOCALES.has(segment.toLowerCase()));
+  if (urlLocale) candidates.push({ source: "URL", value: canonicalLanguage(urlLocale) });
+  const declared = /html/i.test(document.contentType) ? load2(document.body)("html").attr("lang")?.trim() : void 0;
+  if (declared) {
+    const locale = canonicalLanguage(declared);
+    if (locale) candidates.push({ source: "html lang", value: locale });
+    else issues.push({ code: "unsupported-component", source: document.finalUrl.href, message: "The source declares an unsupported HTML language; review its locale configuration." });
+  }
+  if (new Set(candidates.map((candidate) => candidate.value)).size > 1) {
+    issues.push({ code: "unsupported-component", source: document.finalUrl.href, message: `Observed locale metadata disagrees (${candidates.map((candidate) => `${candidate.source}: ${candidate.value}`).join(", ")}); review the source language.` });
+  }
+  return { locale: candidates[0]?.value, issues };
+}
+function localeProjection(checkpoint) {
+  const pages = checkpoint.records.flatMap((record) => record.page ? [record.page] : []);
+  const canonicalLocale = (page) => {
+    try {
+      return page.locale ? Intl.getCanonicalLocales(page.locale)[0] : void 0;
+    } catch {
+      return void 0;
+    }
+  };
+  const locales = [...new Set(pages.map(canonicalLocale).filter((locale) => Boolean(locale)))];
+  const defaultLocale = pages.some((page) => !page.locale) || locales.includes("en") ? "en" : locales[0] ?? "en";
+  const pageId = (page) => {
+    const locale = canonicalLocale(page);
+    return locale ? `${locale === defaultLocale ? "" : `${locale}/`}${page.navigationId}` : page.id;
+  };
+  const route = (page) => {
+    const locale = canonicalLocale(page);
+    const prefix = locale && locale !== defaultLocale ? `/${locale}` : "";
+    return `${prefix}${page.navigationId === "introduction" ? "/" : `/${page.navigationId}`}`;
+  };
+  return { canonicalLocale, locales, defaultLocale, pageId, route };
+}
+function validateUrlMigration(checkpoint, cancelled = false) {
+  const issues = [];
+  const counts = { pending: 0, imported: 0, excluded: 0, failed: 0, alias: 0 };
+  const records = new Map(checkpoint.records.map((record) => [record.url, record]));
+  const source = new URL(checkpoint.sourceUrl);
+  const projection = localeProjection(checkpoint);
+  const primaryIds = new Set(checkpoint.records.flatMap((record) => record.page && (!record.page.locale || projection.canonicalLocale(record.page) === projection.defaultLocale) ? [record.page.navigationId] : []));
+  const outputIds = /* @__PURE__ */ new Set();
+  const resolve3 = (url) => {
+    const record = records.get(canonical(url, checkpoint.sourceUrl) ?? "");
+    return record?.outcome === "alias" ? records.get(record.aliasOf ?? "") : record;
+  };
+  for (const record of checkpoint.records) {
+    counts[record.outcome]++;
+    issues.push(...record.issues ?? []);
+    if (record.outcome === "pending" || record.outcome === "failed") issues.push({ code: "missing-page", source: record.url, message: record.reason ?? `Inventory entry is ${record.outcome}.` });
+    if (!record.page || !record.evidence) continue;
+    const outputId = projection.pageId(record.page);
+    if (outputIds.has(outputId)) issues.push({ code: "collision", source: record.url, message: `Multiple source pages map to runtime path ${outputId}.` });
+    outputIds.add(outputId);
+    if (record.page.locale && projection.canonicalLocale(record.page) !== projection.defaultLocale && !primaryIds.has(record.page.navigationId)) {
+      issues.push({ code: "missing-page", source: record.url, message: `Secondary locale ${record.page.locale} requires a primary ${projection.defaultLocale} page at ${record.page.navigationId}; the runtime cannot serve an orphan translation.` });
+    }
+    const actual = markdownCode(record.page.body);
+    if (JSON.stringify(actual) !== JSON.stringify(record.evidence.code)) issues.push({ code: "code-mismatch", source: record.url, message: "Source code payloads differ from converted code payloads." });
+    for (const value of record.evidence.links) {
+      let link;
+      try {
+        link = new URL(value, record.evidence.finalUrl);
+      } catch {
+        continue;
+      }
+      if (!inScope(link, source, checkpoint.scopePath)) continue;
+      if (/\.(?:png|jpe?g|gif|svg|webp|avif|pdf|zip|mp4|webm|css|js|json|ya?ml)$/i.test(link.pathname)) continue;
+      const destination = resolve3(link.toString());
+      if (!destination || !["imported", "excluded"].includes(destination.outcome)) {
+        issues.push({ code: "missing-page", source: record.url, message: `Unresolved internal destination: ${link}` });
+      } else if (link.hash && destination.outcome === "imported") {
+        let anchor = link.hash.slice(1);
+        try {
+          anchor = decodeURIComponent(anchor);
+        } catch {
+        }
+        if (!destination.evidence?.anchors.includes(anchor)) issues.push({ code: "missing-anchor", source: record.url, message: `Missing source anchor: ${link}` });
+      }
+    }
+  }
+  const visit = (nodes) => {
+    for (const node of nodes) {
+      if (node.url) {
+        const url = new URL(node.url, source);
+        if (inScope(url, source, checkpoint.scopePath) && !resolve3(url.toString())?.page) issues.push({ code: "navigation-missing", source: node.url, message: `Source navigation target ${node.label} was not imported.` });
+      }
+      visit(node.children ?? []);
+    }
+  };
+  visit(checkpoint.navigation);
+  if (!counts.imported) issues.push({ code: "missing-page", source: checkpoint.sourceUrl, message: "No readable article pages were imported." });
+  return { status: cancelled ? "cancelled" : issues.length ? "partial" : "passed", issues, counts };
+}
+async function runUrlMigration(options) {
+  const source = validateMigrationUrl(options.sourceUrl);
+  const sourceUrl = canonical(source.toString(), source.toString());
+  const requestedScope = options.scopePath ?? (source.pathname.endsWith("/") ? source.pathname : source.pathname.slice(0, source.pathname.lastIndexOf("/")) || "/");
+  let scopeEnd = requestedScope.length;
+  while (scopeEnd > 0 && requestedScope.charCodeAt(scopeEnd - 1) === 47) scopeEnd--;
+  const scopePath = requestedScope.slice(0, scopeEnd) || "/";
+  if (!scopePath.startsWith("/") || scopePath.includes("?") || scopePath.includes("#") || !inScope(source, source, scopePath)) throw new Error("The selected documentation scope must contain the source URL.");
+  const maxPages = options.maxPages ?? 1e3;
+  if (!Number.isInteger(maxPages) || maxPages < 1 || maxPages > 1e4) throw new Error("maxPages must be between 1 and 10000.");
+  const concurrency = Math.max(1, Math.min(32, Math.floor(options.concurrency ?? 5)));
+  const batchSize = Math.max(1, Math.min(500, Math.floor(options.batchSize ?? 50)));
+  if (!Number.isFinite(concurrency) || !Number.isFinite(batchSize) || options.maxCaptures !== void 0 && (!Number.isInteger(options.maxCaptures) || options.maxCaptures < 1) || options.maxTotalBytes !== void 0 && (!Number.isFinite(options.maxTotalBytes) || options.maxTotalBytes < 1)) throw new Error("Migration batch, concurrency and byte limits must be positive finite numbers.");
+  const captureVersion = options.captureVersion ?? "fetch-v1";
+  if (options.checkpoint && options.checkpoint.records.length > MAX_RECORDS) throw new Error("Checkpoint inventory exceeds its bound.");
+  const checkpoint = options.checkpoint ? cloneUrlMigrationCheckpoint(options.checkpoint) : { schemaVersion: 1, converterVersion: CONVERTER_VERSION, sourceUrl, scopePath, captureVersion, records: [], navigation: [] };
+  if (checkpoint.schemaVersion !== 1 || checkpoint.converterVersion !== CONVERTER_VERSION || checkpoint.sourceUrl !== sourceUrl || checkpoint.scopePath !== scopePath || checkpoint.captureVersion !== captureVersion) throw new Error("Checkpoint does not match this source, scope or capture/converter version.");
+  if (checkpoint.records.length > MAX_RECORDS) throw new Error("Checkpoint inventory exceeds its bound.");
+  const records = /* @__PURE__ */ new Map();
+  for (const record of checkpoint.records) {
+    if (canonical(record.url, sourceUrl) !== record.url || !inScope(new URL(record.url), source, scopePath) && !isDiscoveryIndex(new URL(record.url), source)) throw new Error("Checkpoint contains an unsafe inventory URL.");
+    if (records.has(record.url)) throw new Error("Checkpoint contains a duplicate inventory URL.");
+    if (!validRecord(record) || record.outcome === "failed" && options.retryFailed !== false || record.outcome !== "pending" && options.reconcile && !await options.reconcile(record)) {
+      record.outcome = "pending";
+      delete record.page;
+      delete record.pageSha256;
+      delete record.evidence;
+      delete record.assets;
+    }
+    if (record.page && pageIdFromReference(record.page.id, true) !== record.page.id) throw new Error("Checkpoint contains an unsafe page path.");
+    records.set(record.url, record);
+  }
+  const pending = [...records.values()].filter((record) => record.outcome === "pending");
+  let changed = [];
+  let navigationChanged = false;
+  const enqueue = (value, base, discoveredBy) => {
+    const url = canonical(value, base);
+    if (!url || !inScope(new URL(url), source, scopePath) && !isDiscoveryIndex(new URL(url), source)) return;
+    const existing = records.get(url);
+    if (existing) {
+      if (!existing.discoveredBy.includes(discoveredBy)) {
+        existing.discoveredBy.push(discoveredBy);
+        changed.push(existing);
+      }
+      return;
+    }
+    if (records.size >= MAX_RECORDS) throw new Error("Discovered URL inventory exceeded the 100000 URL safety bound.");
+    const record = { url, discoveredBy: [discoveredBy], outcome: "pending" };
+    records.set(url, record);
+    checkpoint.records.push(record);
+    pending.push(record);
+    changed.push(record);
+  };
+  enqueue(sourceUrl, sourceUrl, "submitted");
+  for (const path of ["llms.txt", "sitemap.xml", "robots.txt"]) enqueue(`${scopePath === "/" ? "" : scopePath}/${path}`, sourceUrl, "discovery-index");
+  if (scopePath !== "/") for (const path of ["llms.txt", "sitemap.xml", "robots.txt"]) enqueue(`/${path}`, sourceUrl, "discovery-index");
+  const fetcher = options.fetcher ?? defaultMigrationFetcher;
+  const capture = options.captureProvider?.capture.bind(options.captureProvider) ?? (async ({ url }) => fetcher(url, { accept: ACCEPT }));
+  const assetFetcher = options.assetFetcher ?? (!options.fetcher && !options.captureProvider ? defaultAssetFetcher : void 0);
+  const usedIds = new Map([...records.values()].filter((record) => record.page).map((record) => [record.page.id, record.url]));
+  const finalUrls = new Map([...records.values()].filter((record) => record.evidence && record.page).map((record) => [canonical(record.evidence.finalUrl, sourceUrl), record.url]));
+  let imported = usedIds.size;
+  const assetPayloads = new Map(checkpoint.records.flatMap((record) => (record.assets ?? []).map((asset) => [asset.sha256, asset])));
+  const assetBytes = /* @__PURE__ */ new Map();
+  const retainAsset = (asset) => {
+    if (!acceptedAsset(asset)) throw new Error("Asset MIME/signature is unsupported or unsafe to serve.");
+    const sha256 = hash(asset.content);
+    const content = assetBytes.get(sha256) ?? Buffer.from(asset.content);
+    assetBytes.set(sha256, content);
+    return { ...asset, content };
+  };
+  const assetRequests = createMigrationAssetCache();
+  for (const record of checkpoint.records) for (const asset of record.assets ?? []) {
+    if (!assetRequests.has(asset.url)) {
+      const content = assetBytes.get(asset.sha256) ?? Buffer.from(asset.base64, "base64");
+      assetBytes.set(asset.sha256, content);
+      assetRequests.remember(asset.url, { url: asset.url, contentType: asset.contentType, content });
+    }
+  }
+  let totalBytes = checkpoint.records.reduce((sum, record) => sum + (record.evidence?.byteLength ?? 0), 0) + [...assetPayloads.values()].reduce((sum, asset) => sum + Buffer.byteLength(asset.base64, "base64"), 0);
+  let budgetExhausted = false;
+  let cursor = 0;
+  const flush = async () => {
+    const distinct = [...new Map(changed.map((record) => [record.url, record])).values()];
+    if (options.onCheckpoint) for (let index = 0; index < distinct.length || index === 0 && navigationChanged; index += batchSize) {
+      await options.onCheckpoint({ schemaVersion: 1, converterVersion: CONVERTER_VERSION, scopePath, captureVersion, sourceUrl, records: distinct.slice(index, index + batchSize), ...navigationChanged && index === 0 ? { navigation: checkpoint.navigation } : {} });
+    }
+    changed = [];
+    navigationChanged = false;
+  };
+  const process = async (record) => {
+    if (options.signal?.aborted) return;
+    try {
+      delete record.reason;
+      const document = await capture({ url: new URL(record.url), signal: options.signal });
+      if (options.signal?.aborted) return;
+      if (Buffer.byteLength(document.body) > MAX_RESPONSE_BYTES) throw new Error("Captured response exceeds the 8 MB safety bound.");
+      const final = canonical(document.finalUrl.toString(), sourceUrl);
+      const role = classifyMigrationResponse(document);
+      if (!inScope(document.finalUrl, source, scopePath) && !(role === "index" && isDiscoveryIndex(document.finalUrl, source))) {
+        record.outcome = "excluded";
+        record.reason = "Redirected outside the selected origin/path.";
+        return;
+      }
+      if (document.status && document.status >= 400) throw new Error(`Source page returned HTTP ${document.status}.`);
+      if (role !== "page") {
+        totalBytes += Buffer.byteLength(document.body);
+        if (totalBytes > (options.maxTotalBytes ?? 5e8)) {
+          budgetExhausted = true;
+          throw new Error("Migration exceeded its content byte budget.");
+        }
+        record.outcome = "excluded";
+        record.reason = `Final response role: ${role}.`;
+        const links = role === "index" ? linksOf(document) : [];
+        record.evidence = { sha256: hash(document.body), byteLength: Buffer.byteLength(document.body), finalUrl: final, contentType: document.contentType, ...document.artifactRef ? { artifactRef: document.artifactRef } : {}, states: [], code: [], anchors: [], links };
+        for (const link of links) enqueue(link, final, record.url);
+        return;
+      }
+      if (imported >= maxPages) {
+        record.outcome = "excluded";
+        record.reason = "A discovery endpoint resolved to an article after the selected page limit.";
+        return;
+      }
+      const already = finalUrls.get(final);
+      if (already && already !== record.url) {
+        record.outcome = "alias";
+        record.aliasOf = already;
+        return;
+      }
+      finalUrls.set(final, record.url);
+      const id = idForUrl(document.finalUrl, scopePath);
+      if (!id) throw new Error("Source URL has no safe destination path.");
+      if (usedIds.has(id) && usedIds.get(id) !== record.url) {
+        record.outcome = "failed";
+        record.reason = `Destination collision for ${id}.`;
+        return;
+      }
+      usedIds.set(id, record.url);
+      const evidence = evidenceOf(document);
+      const page = convert(document, id);
+      if (!page) {
+        record.outcome = "failed";
+        record.reason = "Content could not be represented as safe inert MDX.";
+        return;
+      }
+      const states = document.states ?? [];
+      if (states.length > 64) throw new Error("Capture contains too many alternative states.");
+      for (const state of states) {
+        if (Buffer.byteLength(state.response.body) > MAX_RESPONSE_BYTES) throw new Error("Alternative state exceeds the 8 MB safety bound.");
+        if (!inScope(state.response.finalUrl, source, scopePath) || classifyMigrationResponse(state.response) !== "page") throw new Error("Capture state escaped its selected scope or article role.");
+        const alternative = convert(state.response, id);
+        if (!alternative) throw new Error(`Alternative state ${state.id} is not inert content.`);
+        const stateCode = /html/i.test(state.response.contentType) ? htmlEvidence(state.response).code : markdownCode(state.response.body);
+        evidence.states.find((entry) => entry.id === state.id).code = stateCode;
+        const difference = alternativeBlocks(alternative.body, page.body);
+        evidence.code.push(...markdownCode(difference));
+        evidence.links.push(...linksOf(state.response));
+        evidence.anchors.push(.../html/i.test(state.response.contentType) ? htmlEvidence(state.response).anchors : markdownHeadingAnchors(state.response.body));
+        if (difference) page.body += `
+
+### ${state.label.replace(/[<>{}#\n\r]/g, "")}
+
+${difference}`;
+      }
+      totalBytes += Buffer.byteLength(document.body) + states.reduce((sum, state) => sum + Buffer.byteLength(state.response.body), 0);
+      evidence.byteLength = Buffer.byteLength(document.body) + states.reduce((sum, state) => sum + Buffer.byteLength(state.response.body), 0);
+      if (totalBytes > (options.maxTotalBytes ?? 5e8)) {
+        budgetExhausted = true;
+        throw new Error("Migration exceeded its content byte budget.");
+      }
+      record.assets = [];
+      record.issues = [];
+      if (/html/i.test(document.contentType)) {
+        const $ = load2(document.body);
+        const root = $('main article,article,main,[role="main"]').first();
+        root.find("nav,footer,aside,.theme-doc-breadcrumbs,.theme-doc-toc-mobile,.table-of-contents,.hash-link").remove();
+        root.find('button svg,a.hash-link svg,[aria-hidden="true"] svg,svg[aria-hidden="true"],svg[data-lucide],svg[data-icon]').remove();
+        if (root.find("h1").length > 1) record.issues.push({ code: "unsupported-component", source: record.url, message: "The article contains multiple level-one headings; review their hierarchy." });
+        const unsupported = [...new Set(root.find("iframe,object,embed,canvas,svg,form,input,textarea,select,math,video,audio").toArray().map((node) => node.tagName))];
+        if (unsupported.length) record.issues.push({ code: "unsupported-component", source: record.url, message: `Rendered content requires explicit review for: ${unsupported.join(", ")}.` });
+        if (!states.length && unresolvedStaticControls(document.body)) record.issues.push({ code: "unsupported-component", source: record.url, message: "An interactive alternative has no complete captured panel or disclosure content." });
+      }
+      const suppliedAssets = new Map((document.assets ?? []).map((asset) => [canonical(asset.url, final), asset]));
+      const assetUrls = [...new Set([...assetReferences(document), ...states.flatMap((state) => assetReferences(state.response))].map((url) => canonical(url, final)).filter((url) => Boolean(url)))];
+      if (assetUrls.length > 256 || (document.assets?.length ?? 0) > 256) throw new Error("Capture exceeds the 256 assets per page safety bound.");
+      for (const url of assetUrls) {
+        try {
+          let assetRequest = assetRequests.get(url);
+          if (!suppliedAssets.has(url) && !assetRequest && assetFetcher) {
+            assetRequest = assetRequests.load(url, () => assetFetcher(new URL(url), options.signal).then(retainAsset));
+          }
+          const supplied = suppliedAssets.get(url);
+          const asset = supplied ? retainAsset(supplied) : assetRequest ? await assetRequest : null;
+          if (!asset) throw new Error("Capture host did not supply asset bytes or a binary fetch boundary.");
+          const extension = acceptedAsset(asset);
+          if (!extension) throw new Error("Asset MIME/signature is unsupported or unsafe to serve.");
+          const sha256 = hash(asset.content);
+          const existing = assetPayloads.get(sha256);
+          if (!existing) {
+            totalBytes += asset.content.byteLength;
+            if (totalBytes > (options.maxTotalBytes ?? 5e8)) {
+              budgetExhausted = true;
+              throw new Error("Migration exceeded its content and asset byte budget.");
+            }
+          }
+          const path = `migration-assets/${sha256}.${extension}`;
+          const receipt = { url, path, sha256, contentType: asset.contentType, base64: existing?.base64 ?? Buffer.from(asset.content).toString("base64") };
+          record.assets.push(receipt);
+          if (!existing) assetPayloads.set(sha256, receipt);
+          if (!assetRequests.has(url)) assetRequests.remember(url, asset);
+          page.body = rewriteMarkdownDestinations(page.body, (destination) => canonical(destination, final) === url ? `/${path}${new URL(destination, final).hash}` : destination);
+        } catch (error) {
+          assetRequests.delete(url);
+          record.issues.push({ code: "asset-failed", source: record.url, message: `${url}: ${error instanceof Error ? error.message : String(error)}` });
+        }
+      }
+      if (options.signal?.aborted) return;
+      if (sanitizeRemoteMarkdown(page.body.replace(/^<a id="[^"<]*" \/>$/gm, "")) === null) throw new Error("Converted content did not pass inert MDX validation.");
+      record.evidence = evidence;
+      record.page = page;
+      const language = observedLocale(document, page.id, scopePath);
+      record.issues.push(...language.issues);
+      const canonicalLocale = language.locale;
+      if (canonicalLocale) {
+        page.locale = canonicalLocale;
+        const segments = page.id.split("/");
+        const localeIndex = segments.findIndex((segment) => segment.toLowerCase() === canonicalLocale.toLowerCase());
+        page.navigationId = segments.filter((_segment, index) => index !== localeIndex).join("/") || "introduction";
+        page.id = `${canonicalLocale}/${page.navigationId}`;
+        if (usedIds.has(page.id) && usedIds.get(page.id) !== record.url) throw new Error(`Destination collision for locale page ${page.id}.`);
+        usedIds.delete(id);
+        usedIds.set(page.id, record.url);
+      }
+      record.version = document.version ?? [...page.id.split("/"), ...document.finalUrl.pathname.split("/")].find((segment) => /^v\d+(?:\.\d+)*$/i.test(segment));
+      record.pageSha256 = pageHash(page);
+      record.outcome = "imported";
+      imported++;
+      const navigation = checkpoint.navigation.length ? [] : sourceNavigation(document);
+      if (!checkpoint.navigation.length && navigation.length) {
+        checkpoint.navigation = navigation;
+        navigationChanged = true;
+      }
+      for (const link of evidence.links) {
+        try {
+          const url = new URL(link, final);
+          if (!/\.(?:png|jpe?g|gif|svg|webp|avif|pdf|zip|mp4|webm|css|js)$/i.test(url.pathname)) enqueue(link, final, record.url);
+        } catch {
+        }
+      }
+      const visit = (nodes) => {
+        for (const node of nodes) {
+          if (node.url) enqueue(node.url, final, "source-navigation");
+          visit(node.children ?? []);
+        }
+      };
+      visit(navigation);
+    } catch (error) {
+      if (options.signal?.aborted) return;
+      const wasImported = record.outcome === "imported";
+      record.outcome = record.discoveredBy.every((origin) => origin === "discovery-index") ? "excluded" : "failed";
+      record.reason = error instanceof Error ? error.message : String(error);
+      if (record.page) {
+        if (wasImported) imported--;
+        usedIds.delete(record.page.id);
+      }
+      delete record.page;
+      delete record.pageSha256;
+      delete record.assets;
+    } finally {
+      if (record.outcome !== "pending") {
+        if (options.onRecord) await options.onRecord(record);
+        changed.push(record);
+      }
+    }
+  };
+  while (cursor < pending.length && !options.signal?.aborted && !budgetExhausted && cursor < (options.maxCaptures ?? Infinity)) {
+    if (imported >= maxPages) {
+      const index = pending.findIndex((record, position) => position >= cursor && isDiscoveryIndex(new URL(record.url), source));
+      if (index < 0) break;
+      pending.splice(cursor, 0, pending.splice(index, 1)[0]);
+    }
+    const batch = pending.slice(cursor, cursor + Math.min(concurrency, imported >= maxPages ? 1 : maxPages - imported, (options.maxCaptures ?? Infinity) - cursor));
+    cursor += batch.length;
+    await Promise.all(batch.map(process));
+    if (changed.length >= batchSize) await flush();
+  }
+  await flush();
+  const projection = localeProjection(checkpoint);
+  const routeMap = /* @__PURE__ */ new Map();
+  for (const record of checkpoint.records) {
+    const target = record.outcome === "alias" ? records.get(record.aliasOf ?? "") : record;
+    if (target?.page) {
+      const route = projection.route(target.page);
+      routeMap.set(record.url, route);
+      if (target.evidence) routeMap.set(canonical(target.evidence.finalUrl, sourceUrl), route);
+    }
+  }
+  const navigationLabels = /* @__PURE__ */ new Map();
+  const navigationIssues = [];
+  const labelPages = (nodes) => {
+    for (const node of nodes) {
+      const entry = node.url ? records.get(canonical(node.url, sourceUrl) ?? "") : void 0;
+      const target = entry?.outcome === "alias" ? records.get(entry.aliasOf ?? "") : entry;
+      if (target?.page && node.label && !node.children?.length) {
+        const previous = navigationLabels.get(target.url);
+        if (previous && previous !== node.label) navigationIssues.push({ code: "unsupported-component", source: target.url, message: `This page has multiple source navigation labels (${previous}, ${node.label}); review the shared sidebar title.` });
+        else navigationLabels.set(target.url, node.label);
+      }
+      labelPages(node.children ?? []);
+    }
+  };
+  labelPages(checkpoint.navigation);
+  const pages = checkpoint.records.flatMap((record) => record.page ? [{ ...record.page, id: projection.pageId(record.page), ...record.page.locale ? { locale: projection.canonicalLocale(record.page) } : {}, ...navigationLabels.has(record.url) ? { navTitle: navigationLabels.get(record.url) } : {}, body: rewriteMarkdownDestinations(record.page.body, (value) => {
+    let url;
+    try {
+      url = new URL(value, record.evidence.finalUrl);
+    } catch {
+      return value;
+    }
+    const route = routeMap.get(canonical(url.toString(), sourceUrl));
+    return route ? `${route}${url.hash}` : value;
+  }) }] : []);
+  const validation = validateUrlMigration(checkpoint, Boolean(options.signal?.aborted));
+  validation.issues.push(...navigationIssues);
+  if (navigationIssues.length && validation.status === "passed") validation.status = "partial";
+  const assets = /* @__PURE__ */ new Map();
+  for (const record of checkpoint.records) for (const asset of record.assets ?? []) {
+    if (!assets.has(asset.path)) {
+      const content = assetBytes.get(asset.sha256) ?? Buffer.from(asset.base64, "base64");
+      assets.set(asset.path, { path: asset.path, content: Buffer.from(content.buffer, content.byteOffset, content.byteLength) });
+    }
+  }
+  const bundle = {
+    sourceUrl,
+    sourceKind: "url",
+    platform: options.platform ?? "generic",
+    pages,
+    assets: [...assets.values()],
+    docsConfig: navigationConfig(checkpoint.navigation, records) ?? buildNavigationFromPages(pages),
+    warnings: validation.issues.map((issue) => ({ code: issue.code === "missing-page" ? "missing-page" : "unsupported-config", message: issue.message, source: issue.source })),
+    urlMigrationValidation: validation,
+    stats: { discovered: records.size, imported: pages.length, skipped: records.size - pages.length }
+  };
+  if (projection.locales.length) {
+    const locales = [.../* @__PURE__ */ new Set([projection.defaultLocale, ...projection.locales])];
+    bundle.docsConfig.i18n = { defaultLocale: projection.defaultLocale, locales: locales.map((code) => ({ code, label: code === "en" ? "English" : code })) };
+  }
+  const stopReason = options.signal?.aborted ? "cancelled" : budgetExhausted ? "byte-limit" : cursor < pending.length && cursor >= (options.maxCaptures ?? Infinity) ? "capture-limit" : imported >= maxPages && cursor < pending.length ? "page-limit" : cursor < pending.length ? "capture-limit" : "complete";
+  return { bundle, checkpoint, validation, stopReason };
+}
+function rewriteMarkdownDestinations(body, rewrite) {
+  const edits = markdownNodes(body).filter((node) => node.url && node.position).map((node) => {
+    const start = node.position.start.offset;
+    const end = node.position.end.offset;
+    const original = body.slice(start, end);
+    const replacement = rewrite(node.url);
+    if (replacement === node.url) return null;
+    const index = original.lastIndexOf(node.url);
+    if (index < 0) return null;
+    return { start: start + index, end: start + index + node.url.length, replacement };
+  }).filter((edit) => edit !== null).sort((a, b) => b.start - a.start);
+  for (const node of markdownNodes(body)) for (const attribute of node.attributes ?? []) {
+    if (!attribute.name || !["src", "href", "srcSet", "srcset", "img", "primaryHref", "secondaryHref"].includes(attribute.name) || !attribute.position) continue;
+    let value = attribute.value;
+    if (typeof value !== "string") {
+      try {
+        value = JSON.parse(value?.value ?? "");
+      } catch {
+        continue;
+      }
+    }
+    if (typeof value !== "string") continue;
+    let replacement;
+    if (/^srcset$/i.test(attribute.name)) {
+      const candidates = migrationImageCandidates(value, new URL("https://migration.invalid"), false);
+      replacement = renderMigrationSrcset(candidates.map((candidate) => ({ ...candidate, url: rewrite(candidate.url) })));
+      if (replacement === renderMigrationSrcset(candidates)) continue;
+    } else {
+      replacement = rewrite(value);
+      if (replacement === value) continue;
+    }
+    const start = attribute.position.start.offset, end = attribute.position.end.offset;
+    if (start === void 0 || end === void 0) continue;
+    edits.push({ start, end, replacement: `${attribute.name}="${migrationImageAttribute(replacement)}"` });
+  }
+  edits.sort((a, b) => b.start - a.start);
+  for (const edit of edits) body = body.slice(0, edit.start) + edit.replacement + body.slice(edit.end);
+  return body;
+}
+
+// src/components.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync2, lstatSync as lstatSync2, readFileSync as readFileSync2 } from "fs";
+import { basename, dirname as dirname2, extname as extname3, posix as posix2, relative as relative3, resolve as resolve2 } from "path";
+import postcss from "postcss";
+import selectorParser from "postcss-selector-parser";
+import remarkMdx4 from "remark-mdx";
+import remarkParse4 from "remark-parse";
+import ts2 from "typescript";
+import { unified as unified4 } from "unified";
+var parser2 = unified4().use(remarkParse4).use(remarkMdx4);
+var DOCUSAURUS_THEME_SHIMS = {
+  "@theme/CodeBlock": {
+    filename: "docusaurus-code-block.tsx",
+    content: [
+      "import type { ReactNode } from 'react'",
+      "",
+      "export default function CodeBlock({ children, className }: { children?: ReactNode; className?: string }) {",
+      "  return (",
+      "    <pre className={className}>",
+      "      <code>{children}</code>",
+      "    </pre>",
+      "  )",
+      "}",
+      ""
+    ].join("\n")
+  },
+  "@docusaurus/BrowserOnly": {
+    filename: "docusaurus-browser-only.tsx",
+    content: [
+      "'use client'",
+      "",
+      "import { useEffect, useState, type ReactNode } from 'react'",
+      "",
+      "export default function BrowserOnly({ children, fallback = null }: { children: () => ReactNode; fallback?: ReactNode }) {",
+      "  const [mounted, setMounted] = useState(false)",
+      "  useEffect(() => { setMounted(true) }, [])",
+      "  return mounted ? <>{children()}</> : <>{fallback}</>",
+      "}",
+      ""
+    ].join("\n")
+  }
+};
+function applyReplacements(source, replacements) {
+  return replacements.sort((a, b) => b.start - a.start).reduce(
+    (text, edit) => text.slice(0, edit.start) + edit.value + text.slice(edit.end),
+    source
+  );
+}
+function hash2(value) {
+  return createHash2("sha256").update(value).digest("hex").slice(0, 12);
+}
+function sourceFile(source, filename) {
+  return ts2.createSourceFile(
+    filename,
+    source,
+    ts2.ScriptTarget.Latest,
+    true,
+    /\.[cm]?ts$/.test(filename) ? ts2.ScriptKind.TS : ts2.ScriptKind.TSX
+  );
+}
+function mergeComponentRegistry(existing, incoming) {
+  const fingerprint = hash2(incoming);
+  const name = `MigratedRegistry${fingerprint}`;
+  const registryPath = `./migrated-components-${fingerprint}`;
+  const source = sourceFile(existing, "custom-components.tsx");
+  const alreadyImported = source.statements.some((statement) => ts2.isImportDeclaration(statement) && ts2.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === registryPath);
+  let initializer;
+  for (const statement of source.statements) {
+    if (!ts2.isVariableStatement(statement) || !statement.modifiers?.some((modifier) => modifier.kind === ts2.SyntaxKind.ExportKeyword)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts2.isIdentifier(declaration.name) && declaration.name.text === "customComponents") initializer = declaration.initializer;
+    }
+  }
+  while (initializer && (ts2.isAsExpression(initializer) || ts2.isSatisfiesExpression(initializer) || ts2.isParenthesizedExpression(initializer))) initializer = initializer.expression;
+  if (!initializer || !ts2.isObjectLiteralExpression(initializer)) {
+    throw new Error("Cannot safely merge src/mdx/custom-components.tsx: export customComponents as an object literal before importing components. The existing registry was preserved.");
+  }
+  const content = alreadyImported ? existing : applyReplacements(existing, [
+    {
+      start: source.statements.filter((statement) => ts2.isExpressionStatement(statement) && ts2.isStringLiteral(statement.expression)).at(-1)?.end ?? 0,
+      end: source.statements.filter((statement) => ts2.isExpressionStatement(statement) && ts2.isStringLiteral(statement.expression)).at(-1)?.end ?? 0,
+      value: `
+import { customComponents as ${name} } from ${JSON.stringify(registryPath)}
+`
+    },
+    { start: initializer.getStart(source) + 1, end: initializer.getStart(source) + 1, value: `
+  ...${name},` }
+  ]);
+  return [
+    { path: `src/mdx/migrated-components-${fingerprint}.tsx`, content: incoming },
+    { path: "src/mdx/custom-components.tsx", content }
+  ];
+}
+
+// src/render.ts
+function yamlString(value) {
+  return JSON.stringify(value.replace(/\s+/g, " ").trim());
+}
+function renderPage(bundle, page) {
+  return [
+    "---",
+    `title: ${yamlString(page.title)}`,
+    page.headingTitle ? `headingTitle: ${yamlString(page.headingTitle)}` : null,
+    page.navTitle ? `navTitle: ${yamlString(page.navTitle)}` : null,
+    page.icon ? `icon: ${yamlString(page.icon)}` : null,
+    page.iconType ? `iconType: ${yamlString(page.iconType)}` : null,
+    `description: ${yamlString(page.description)}`,
+    page.descriptionPlacement === "body" ? "descriptionPlacement: body" : null,
+    page.badge ? `badge: ${yamlString(page.badge)}` : null,
+    page.keywords.length > 0 ? `keywords: [${page.keywords.map(yamlString).join(", ")}]` : null,
+    page.mode ? `mode: ${yamlString(page.mode)}` : null,
+    page.hidden ? "hidden: true" : null,
+    page.noindex ? "noindex: true" : null,
+    // Group names must match identity-provider claims exactly, so they are
+    // quoted as-is rather than whitespace-collapsed like display strings.
+    page.groups?.length ? `groups: [${page.groups.map((group) => JSON.stringify(group)).join(", ")}]` : null,
+    page.public !== void 0 ? `public: ${page.public ? "true" : "false"}` : null,
+    ...Object.entries(page.meta ?? {}).map(([field, value]) => `${field}: ${yamlString(value)}`),
+    page.openapi ? `openapi: ${yamlString(page.openapi)}` : null,
+    page.api ? `api: ${yamlString(page.api)}` : null,
+    page.authMethod ? `authMethod: ${yamlString(page.authMethod)}` : null,
+    page.playground ? `playground: ${yamlString(page.playground)}` : null,
+    bundle.sourceKind === "url" ? `source: ${yamlString(page.source)}` : null,
+    "---",
+    "",
+    page.body,
+    ""
+  ].filter((line) => line !== null).join("\n");
+}
+function isIntegrationsObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mergeMigrationConfig(existing, incoming) {
+  const tabs = existing.tabs.filter((tab) => tab.tab.toLowerCase() !== "changelog");
+  const names = new Set(tabs.map((tab) => tab.tab.toLowerCase()));
+  const seenPages = /* @__PURE__ */ new Set();
+  function recordPages(pages = []) {
+    for (const page of pages) {
+      if (typeof page === "string") seenPages.add(page);
+      else recordPages(page.pages);
+    }
+  }
+  for (const tab of tabs) {
+    recordPages(tab.pages);
+    recordPages(tab.groups);
+  }
+  function uniquePages(pages = []) {
+    return pages.flatMap((page) => {
+      if (typeof page === "string") {
+        if (seenPages.has(page)) return [];
+        seenPages.add(page);
+        return [page];
+      }
+      const children = uniquePages(page.pages);
+      return children.length > 0 ? [{ ...page, pages: children }] : [];
+    });
+  }
+  function uniqueGroups(groups) {
+    return uniquePages(groups ?? []);
+  }
+  for (const tab of incoming.tabs) {
+    if (tab.tab.toLowerCase() === "changelog") continue;
+    const uniqueTab = {
+      ...tab,
+      ...tab.pages ? { pages: uniquePages(tab.pages) } : {},
+      ...tab.groups ? { groups: uniqueGroups(tab.groups) } : {}
+    };
+    if ((tab.pages || tab.groups) && !uniqueTab.pages?.length && !uniqueTab.groups?.length && !tab.href && !tab.api) continue;
+    if (!names.has(tab.tab.toLowerCase())) {
+      tabs.push(uniqueTab);
+      names.add(tab.tab.toLowerCase());
+      continue;
+    }
+    const target = tabs.find((item) => item.tab.toLowerCase() === tab.tab.toLowerCase());
+    if (!target) continue;
+    const incomingRootNodes = [
+      ...uniqueTab.pages ?? [],
+      ...uniqueTab.groups ?? []
+    ];
+    if (uniqueTab.pages?.length) {
+      target.pages = [...target.pages ?? target.groups ?? [], ...incomingRootNodes];
+      delete target.groups;
+    } else if (uniqueTab.groups?.length) {
+      if (target.pages) target.pages = [...target.pages, ...uniqueTab.groups];
+      else target.groups = [...target.groups ?? [], ...uniqueTab.groups];
+    }
+  }
+  const changelog = existing.tabs.find((tab) => tab.tab.toLowerCase() === "changelog") ?? incoming.tabs.find((tab) => tab.tab.toLowerCase() === "changelog");
+  if (changelog) tabs.push(changelog);
+  const i18n = existing.i18n || incoming.i18n ? {
+    defaultLocale: existing.i18n?.defaultLocale ?? incoming.i18n?.defaultLocale ?? "en",
+    locales: [...new Map(
+      [...existing.i18n?.locales ?? [], ...incoming.i18n?.locales ?? []].map((locale) => [locale.code, locale])
+    ).values()]
+  } : void 0;
+  return {
+    ...incoming,
+    ...existing,
+    tabs,
+    // Collection presentation belongs to the imported information
+    // architecture; starter defaults must not coerce source dropdowns to tabs.
+    navigation: incoming.navigation ?? existing.navigation,
+    ...existing.stylesheets?.length || incoming.stylesheets?.length ? { stylesheets: [.../* @__PURE__ */ new Set([...existing.stylesheets ?? [], ...incoming.stylesheets ?? []])] } : {},
+    ...i18n ? { i18n } : {},
+    // Existing providers win per provider; imported ones fill the gaps.
+    // A malformed (string/array) existing value must not spread into index keys.
+    ...isIntegrationsObject(existing.integrations) || isIntegrationsObject(incoming.integrations) ? {
+      integrations: {
+        ...isIntegrationsObject(incoming.integrations) ? incoming.integrations : {},
+        ...isIntegrationsObject(existing.integrations) ? existing.integrations : {}
+      }
+    } : {}
+  };
+}
+function renderMigrationFiles(bundle, options = {}) {
+  const config = options.existingConfig ? mergeMigrationConfig(options.existingConfig, bundle.docsConfig) : bundle.docsConfig;
+  return [
+    ...bundle.pages.map((page) => ({
+      path: `src/content/${page.id}.mdx`,
+      content: renderPage(bundle, page)
+    })),
+    ...bundle.assets.map((asset) => ({ path: asset.projectRelative ? asset.path : `public/${asset.path}`, content: asset.content })),
+    ...(bundle.componentFiles ?? []).flatMap((file) => file.path === "src/mdx/custom-components.tsx" && options.existingComponentRegistry !== void 0 && typeof file.content === "string" ? mergeComponentRegistry(options.existingComponentRegistry, file.content) : [file]),
+    ...bundle.quarantinedFiles ?? [],
+    { path: "docs.json", content: `${JSON.stringify(config, null, 2)}
+` }
+  ];
+}
+export {
+  classifyMigrationResponse,
+  renderMigrationFiles,
+  runUrlMigration,
+  validateUrlMigration
+};
+//# sourceMappingURL=url-migration.js.map