@thallylabs/migrate 0.1.0

package/dist/index.js

@@ -0,0 +1,1421 @@
+// src/repository.ts
+import { spawn } from "child_process";
+import {
+  existsSync as existsSync2,
+  lstatSync,
+  readFileSync as readFileSync2,
+  readdirSync
+} from "fs";
+import { basename, dirname as dirname2, extname as extname2, relative as relative3 } from "path";
+
+// src/mdx.ts
+import matter from "gray-matter";
+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(" ");
+}
+function firstParagraph(content) {
+  for (const block of content.split(/\n\s*\n/)) {
+    const value = block.replace(/\s+/g, " ").trim();
+    if (!value || /^(?:#|```|:::|<|import\s|export\s)/.test(value)) continue;
+    return value.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").slice(0, 240);
+  }
+  return "";
+}
+function normalizeMdx(body) {
+  return body.replace(/<!--([\s\S]*?)-->/g, (_match, content) => `{/*${content}*/}`).replace(/<Danger(\s[^>]*)?>/g, "<Error$1>").replace(/<\/Danger>/g, "</Error>").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>");
+}
+function parseMarkdownPage(input) {
+  const parsed = matter(input.raw);
+  const body = normalizeMdx(parsed.content).trim();
+  if (parsed.data.openapi && !body) return null;
+  const keywords = Array.isArray(parsed.data.keywords) ? parsed.data.keywords.filter((value) => typeof value === "string") : [];
+  const title = typeof parsed.data.title === "string" && parsed.data.title.trim() ? parsed.data.title.trim() : titleFromId(input.navigationId ?? input.id);
+  const description = typeof parsed.data.description === "string" && parsed.data.description.trim() ? parsed.data.description.trim() : firstParagraph(body);
+  return {
+    id: input.id,
+    navigationId: input.navigationId ?? input.id,
+    locale: input.locale,
+    title,
+    description,
+    keywords,
+    body,
+    source: input.source
+  };
+}
+
+// src/navigation.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, extname, relative as relative2 } from "path";
+
+// src/path.ts
+import { isAbsolute, relative, resolve, sep } from "path";
+var SAFE_SEGMENT = /[^a-z0-9._-]+/g;
+function slugifySegment(value) {
+  let decoded = value;
+  try {
+    decoded = decodeURIComponent(value);
+  } catch {
+  }
+  return decoded.toLowerCase().replace(/\.(?:html?|mdx?)$/i, "").replace(SAFE_SEGMENT, "-").replace(/(^-|-$)/g, "");
+}
+function pageIdFromReference(value) {
+  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 baseSegments = /^(?:index|readme)$/i.test(last) ? rawSegments.slice(0, -1) : rawSegments;
+  if (!/^(?:index|readme)$/i.test(last)) {
+    baseSegments[baseSegments.length - 1] = last;
+  }
+  const segments = baseSegments.map(slugifySegment).filter(Boolean);
+  return segments.join("/") || "introduction";
+}
+function resolveWithin(root, candidate) {
+  if (isAbsolute(candidate) || candidate.includes("\0")) {
+    throw new Error(`Unsafe migration path: ${candidate}`);
+  }
+  const target = resolve(root, candidate);
+  const fromRoot = relative(resolve(root), target);
+  if (fromRoot === ".." || fromRoot.startsWith(`..${sep}`) || isAbsolute(fromRoot)) {
+    throw new Error(`Migration path escapes its root: ${candidate}`);
+  }
+  return target;
+}
+function normalizeAssetPath(value) {
+  const normalized = value.replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!normalized || normalized.includes("\0")) return null;
+  const segments = normalized.split("/").filter(Boolean);
+  if (segments.some((segment) => segment === "." || segment === "..")) return null;
+  return segments.join("/");
+}
+
+// src/navigation.ts
+var LANGUAGE_LABELS = {
+  ar: "Arabic",
+  de: "German",
+  en: "English",
+  es: "Spanish",
+  fr: "French",
+  hi: "Hindi",
+  it: "Italian",
+  ja: "Japanese",
+  ko: "Korean",
+  nl: "Dutch",
+  pl: "Polish",
+  pt: "Portuguese",
+  ru: "Russian",
+  tr: "Turkish",
+  uk: "Ukrainian",
+  zh: "Chinese"
+};
+function objectValue(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function labelFor(value, fallback) {
+  for (const key of ["tab", "group", "anchor", "product", "dropdown", "version", "menu", "label", "name", "title"]) {
+    if (typeof value[key] === "string" && value[key]) return String(value[key]);
+  }
+  return fallback;
+}
+function localReference(value) {
+  return value.split("#", 1)[0];
+}
+function jsonPointer(root, pointer) {
+  if (!pointer || pointer === "#") return root;
+  const tokens = pointer.replace(/^#\/?/, "").split("/").filter(Boolean);
+  return tokens.reduce((current, token) => {
+    const object = objectValue(current);
+    if (!object) return void 0;
+    return object[token.replace(/~1/g, "/").replace(/~0/g, "~")];
+  }, root);
+}
+function resolveJsonReferences(value, currentFile, repositoryRoot, stack) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => resolveJsonReferences(entry, currentFile, repositoryRoot, stack));
+  }
+  const object = objectValue(value);
+  if (!object) return value;
+  if (typeof object.$ref === "string") {
+    const [filePart, pointer = ""] = object.$ref.split("#", 2);
+    const referencedFile = filePart ? resolveWithin(dirname(currentFile), filePart) : currentFile;
+    const relativePath = relative2(repositoryRoot, referencedFile);
+    resolveWithin(repositoryRoot, relativePath);
+    const stackKey = `${referencedFile}#${pointer}`;
+    if (stack.has(stackKey)) throw new Error(`Circular Mintlify $ref: ${object.$ref}`);
+    stack.add(stackKey);
+    const referencedRoot = JSON.parse(readFileSync(referencedFile, "utf8"));
+    const referenced = jsonPointer(referencedRoot, pointer ? `#${pointer}` : "");
+    const resolved = resolveJsonReferences(referenced, referencedFile, repositoryRoot, stack);
+    stack.delete(stackKey);
+    return resolved;
+  }
+  return Object.fromEntries(
+    Object.entries(object).map(([key, entry]) => [
+      key,
+      resolveJsonReferences(entry, currentFile, repositoryRoot, stack)
+    ])
+  );
+}
+function readMintlifyConfig(repositoryRoot) {
+  const configPath = ["docs.json", "mint.json"].map((filename) => resolveWithin(repositoryRoot, filename)).find(existsSync);
+  if (!configPath) return null;
+  const raw = JSON.parse(readFileSync(configPath, "utf8"));
+  return resolveJsonReferences(raw, configPath, repositoryRoot, /* @__PURE__ */ new Set());
+}
+function normalizePageRef(value) {
+  if (/^(?:https?:)?\/\//i.test(value) || value.startsWith("#")) return null;
+  const ref = localReference(value).replace(/^\/+/, "").replace(/\.(?:mdx?|rst|txt)$/i, "");
+  return pageIdFromReference(ref);
+}
+function registerReference(value, context) {
+  const localePrefix = context.locale ? `${context.locale}/` : "";
+  const localizedValue = localePrefix && value.replace(/^\/+/, "").startsWith(localePrefix) ? value.replace(/^\/+/, "").slice(localePrefix.length) : value;
+  const navigationId = normalizePageRef(localizedValue);
+  if (!navigationId) return null;
+  const key = `${context.locale ?? ""}:${value}`;
+  if (!context.seenReferences.has(key)) {
+    context.seenReferences.add(key);
+    context.references.push({ ref: value, navigationId, locale: context.locale });
+  }
+  return navigationId;
+}
+function convertPage(value, context) {
+  if (typeof value === "string") return registerReference(value, context);
+  const object = objectValue(value);
+  if (!object) return null;
+  if (typeof object.page === "string") return registerReference(object.page, context);
+  const pages = Array.isArray(object.pages) ? object.pages : [];
+  if ("group" in object || pages.length > 0) {
+    const children = [];
+    if (typeof object.root === "string") {
+      const root = registerReference(object.root, context);
+      if (root) children.push(root);
+    }
+    for (const page of pages) {
+      const converted = convertPage(page, context);
+      if (converted) children.push(converted);
+    }
+    if (children.length === 0) return null;
+    return {
+      group: labelFor(object, "Documentation"),
+      ...typeof object.icon === "string" ? { icon: object.icon } : {},
+      pages: children
+    };
+  }
+  return null;
+}
+function convertGroups(values, context, fallbackGroup) {
+  const groups = [];
+  const loosePages = [];
+  for (const value of values) {
+    const converted = convertPage(value, context);
+    if (!converted) continue;
+    if (typeof converted === "string") loosePages.push(converted);
+    else groups.push(converted);
+  }
+  if (loosePages.length > 0) groups.unshift({ group: fallbackGroup, pages: loosePages });
+  return groups;
+}
+function convertContainerToTabs(containerValue, context, fallbackTab) {
+  const container = objectValue(containerValue);
+  if (!container) return [];
+  for (const key of ["tabs", "anchors", "products", "dropdowns", "versions", "menus"]) {
+    if (!Array.isArray(container[key])) continue;
+    const tabs = container[key].flatMap((value, index) => {
+      const object = objectValue(value);
+      if (!object) return [];
+      const tab = labelFor(object, `${fallbackTab} ${index + 1}`);
+      if (typeof object.href === "string" && !object.pages && !object.groups) {
+        return [{ tab, href: object.href }];
+      }
+      const nested = convertContainerToTabs(object, context, tab);
+      if (nested.length > 0) {
+        if (nested.length === 1) return [{ ...nested[0], tab }];
+        return nested.map((item) => ({ ...item, tab: `${tab}: ${item.tab}` }));
+      }
+      return [];
+    });
+    if (tabs.length > 0) return tabs;
+  }
+  const rawPages = [
+    ...Array.isArray(container.groups) ? container.groups : [],
+    ...Array.isArray(container.pages) ? container.pages : []
+  ];
+  if (typeof container.root === "string") rawPages.unshift(container.root);
+  const groups = convertGroups(rawPages, context, "Overview");
+  return groups.length > 0 ? [{ tab: fallbackTab, groups }] : [];
+}
+function projectMintlifyNavigation(config) {
+  const warnings = [];
+  const references = [];
+  const seenReferences = /* @__PURE__ */ new Set();
+  const navigation = objectValue(config.navigation) ?? config;
+  const languages = Array.isArray(navigation.languages) ? navigation.languages.map(objectValue).filter((value) => Boolean(value)) : [];
+  let tabs = [];
+  let i18n;
+  if (languages.length > 0) {
+    const defaultLanguage = languages.find((entry) => entry.language === "en") ?? languages[0];
+    const defaultLocale = String(defaultLanguage.language ?? "en");
+    const locales = languages.map((entry) => {
+      const code = String(entry.language ?? entry.locale ?? "en");
+      return { code, label: LANGUAGE_LABELS[code] ?? code.toUpperCase() };
+    });
+    i18n = { defaultLocale, locales };
+    for (const language of languages) {
+      const locale = String(language.language ?? language.locale ?? defaultLocale);
+      const context = {
+        locale,
+        references,
+        seenReferences
+      };
+      const languageTabs = convertContainerToTabs(language, context, "Documentation");
+      if (language === defaultLanguage) tabs = languageTabs;
+    }
+  } else {
+    tabs = convertContainerToTabs(navigation, { references, seenReferences }, "Documentation");
+    if (tabs.length === 0 && Array.isArray(config.navigation)) {
+      const groups = convertGroups(config.navigation, { references, seenReferences }, "Overview");
+      if (groups.length > 0) tabs = [{ tab: "Documentation", groups }];
+    }
+  }
+  if (tabs.length === 0) {
+    warnings.push({
+      code: "unsupported-config",
+      message: "Mintlify navigation could not be projected; generated navigation will be used."
+    });
+  }
+  if (!tabs.some((tab) => tab.tab.toLowerCase() === "changelog")) {
+    tabs.push({ tab: "Changelog", href: "/changelog" });
+  }
+  const redirects = Array.isArray(config.redirects) ? config.redirects.flatMap((value) => {
+    const redirect = objectValue(value);
+    if (!redirect || typeof redirect.source !== "string" || typeof redirect.destination !== "string") return [];
+    return [{
+      source: redirect.source,
+      destination: redirect.destination,
+      ...typeof redirect.permanent === "boolean" ? { permanent: redirect.permanent } : {}
+    }];
+  }) : [];
+  return {
+    docsConfig: { tabs, ...i18n ? { i18n } : {}, ...redirects.length > 0 ? { redirects } : {} },
+    pageReferences: references,
+    warnings
+  };
+}
+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(" ");
+}
+function buildNavigationFromPages(pages) {
+  const ids = pages.filter((page) => !page.locale || page.locale === "en").map((page) => page.navigationId);
+  const ordered = [...new Set(ids)];
+  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 }] };
+}
+function isDocumentationExtension(filename) {
+  return [".md", ".mdx", ".rst", ".txt"].includes(extname(filename).toLowerCase());
+}
+
+// src/repository.ts
+var MAX_SOURCE_FILES = 5e3;
+var MAX_PAGE_BYTES = 2e6;
+var MAX_ASSET_BYTES = 25e6;
+var MAX_TOTAL_ASSET_BYTES = 1e8;
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".github",
+  ".next",
+  ".turbo",
+  ".vercel",
+  ".vscode",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage"
+]);
+var ASSET_DIRECTORIES = /* @__PURE__ */ new Set(["assets", "images", "img", "media", "public", "static"]);
+var ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".avif",
+  ".bmp",
+  ".gif",
+  ".ico",
+  ".jpeg",
+  ".jpg",
+  ".mp3",
+  ".mp4",
+  ".pdf",
+  ".png",
+  ".svg",
+  ".webm",
+  ".webp"
+]);
+var REPOSITORY_ONLY_DOCUMENTS = /* @__PURE__ */ new Set([
+  "agents.md",
+  "claude.md",
+  "code_of_conduct.md",
+  "contributing.md",
+  "license.md",
+  "readme.md",
+  "security.md"
+]);
+var SNIPPET_DIRECTORIES = /* @__PURE__ */ new Set(["snippets", "_snippets", "partials", "_partials"]);
+var OPENAPI_FILENAMES = /* @__PURE__ */ new Set([
+  "openapi.json",
+  "openapi.yaml",
+  "openapi.yml",
+  "swagger.json",
+  "swagger.yaml",
+  "swagger.yml"
+]);
+function parseGitHubRepositoryUrl(rawUrl) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    throw new Error(`Invalid GitHub URL: ${rawUrl}`);
+  }
+  if (url.protocol !== "https:" || url.hostname.toLowerCase() !== "github.com") {
+    throw new Error("Repository migrations require an https://github.com URL.");
+  }
+  if (url.username || url.password || url.port) {
+    throw new Error("GitHub repository URLs cannot include credentials or custom ports.");
+  }
+  const segments = url.pathname.split("/").filter(Boolean).map(decodeURIComponent);
+  const [owner, rawRepo] = segments;
+  const repo = rawRepo?.replace(/\.git$/i, "");
+  const safeName = /^[A-Za-z0-9_.-]+$/;
+  if (!owner || !repo || !safeName.test(owner) || !safeName.test(repo)) {
+    throw new Error("GitHub URL must include a valid owner and repository name.");
+  }
+  let branch = "HEAD";
+  let docsDir = "";
+  if (segments[2] === "tree" && segments[3]) {
+    branch = segments[3];
+    docsDir = segments.slice(4).join("/");
+  }
+  return {
+    owner,
+    repo,
+    branch,
+    docsDir,
+    cloneUrl: `https://github.com/${owner}/${repo}.git`
+  };
+}
+async function cloneGitHubRepository(source, targetDir) {
+  const args = ["clone", "--depth", "1", "--single-branch"];
+  if (source.branch !== "HEAD") args.push("--branch", source.branch);
+  args.push("--", source.cloneUrl, targetDir);
+  await new Promise((resolve2, reject) => {
+    const child = spawn("git", args, { stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      if (stderr.length < 16e3) stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve2();
+      else reject(new Error(`Failed to clone ${source.owner}/${source.repo}: ${stderr.trim() || `git exited ${code}`}`));
+    });
+  });
+}
+function detectRepositoryPlatform(repositoryDir) {
+  if (existsSync2(resolveWithin(repositoryDir, "mint.json"))) return "mintlify";
+  const docsJson = resolveWithin(repositoryDir, "docs.json");
+  if (existsSync2(docsJson)) {
+    try {
+      const config = JSON.parse(readFileSync2(docsJson, "utf8"));
+      if (String(config.$schema ?? "").includes("mintlify") || "navigation" in config) return "mintlify";
+      if (Array.isArray(config.tabs)) return "thally";
+    } catch {
+    }
+  }
+  if (["docusaurus.config.js", "docusaurus.config.ts", "docusaurus.config.mjs"].some((name) => existsSync2(resolveWithin(repositoryDir, name)))) return "docusaurus";
+  if (existsSync2(resolveWithin(repositoryDir, "SUMMARY.md"))) return "gitbook";
+  if (existsSync2(resolveWithin(repositoryDir, ".vitepress"))) return "vitepress";
+  if (["astro.config.mjs", "astro.config.ts"].some((name) => existsSync2(resolveWithin(repositoryDir, name)))) return "starlight";
+  if (["pages/_meta.json", "_meta.json"].some((name) => existsSync2(resolveWithin(repositoryDir, name)))) return "nextra";
+  return "unknown";
+}
+function containsMarkdown(directory, depth = 0) {
+  if (depth > 4) return false;
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    if (IGNORED_DIRECTORIES.has(entry.name) || entry.isSymbolicLink()) continue;
+    const path = resolveWithin(directory, entry.name);
+    if (entry.isFile() && [".md", ".mdx"].includes(extname2(entry.name).toLowerCase())) return true;
+    if (entry.isDirectory() && containsMarkdown(path, depth + 1)) return true;
+  }
+  return false;
+}
+function detectRepositoryDocsDir(repositoryDir) {
+  for (const candidate of ["docs", "documentation", "content", "pages", "src/content", "src/pages", "guide", "guides", ""]) {
+    const path = resolveWithin(repositoryDir, candidate);
+    if (existsSync2(path) && lstatSync(path).isDirectory() && containsMarkdown(path)) return candidate;
+  }
+  return "";
+}
+function scanFiles(root) {
+  const files = [];
+  function visit(directory) {
+    if (files.length >= MAX_SOURCE_FILES) return;
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      if (files.length >= MAX_SOURCE_FILES) return;
+      if (IGNORED_DIRECTORIES.has(entry.name) || entry.isSymbolicLink()) continue;
+      const path = resolveWithin(directory, entry.name);
+      if (entry.isDirectory()) visit(path);
+      else if (entry.isFile()) files.push({ absolutePath: path, relativePath: relative3(root, path).replace(/\\/g, "/") });
+    }
+  }
+  visit(root);
+  return files;
+}
+function normalizedReferenceKey(value) {
+  return value.split(/[?#]/, 1)[0].replace(/^\/+/, "").replace(/\\/g, "/").replace(/\.(?:mdx?|rst|txt)$/i, "").replace(/\/(?:index|readme)$/i, "").replace(/^(?:index|readme)$/i, "") || "introduction";
+}
+function findOpenApi(files) {
+  return files.find((file) => OPENAPI_FILENAMES.has(basename(file.relativePath).toLowerCase())) ?? null;
+}
+function withoutFrontmatter(value) {
+  return value.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "").trim();
+}
+function inlineMdxSnippets(raw, currentFile, repositoryRoot, warnings, depth = 0) {
+  if (depth >= 8) return raw;
+  const snippets = /* @__PURE__ */ new Map();
+  const withoutImports = raw.replace(
+    /^import\s+([A-Z][A-Za-z0-9_]*)\s+from\s+['"]([^'"]+\.mdx?)['"]\s*;?\s*$/gm,
+    (_statement, componentName, sourcePath) => {
+      try {
+        const candidate = sourcePath.startsWith("/") ? resolveWithin(repositoryRoot, sourcePath.replace(/^\/+/, "")) : resolveWithin(dirname2(currentFile), sourcePath);
+        resolveWithin(repositoryRoot, relative3(repositoryRoot, candidate));
+        if (!existsSync2(candidate) || !lstatSync(candidate).isFile()) throw new Error("file not found");
+        const nested = inlineMdxSnippets(
+          withoutFrontmatter(readFileSync2(candidate, "utf8")),
+          candidate,
+          repositoryRoot,
+          warnings,
+          depth + 1
+        );
+        snippets.set(componentName, nested);
+        return "";
+      } catch {
+        warnings.push({
+          code: "missing-page",
+          message: `Imported snippet ${sourcePath} could not be resolved and was left as a comment.`,
+          source: relative3(repositoryRoot, currentFile).replace(/\\/g, "/")
+        });
+        snippets.set(componentName, `{/* Missing imported snippet: ${sourcePath} */}`);
+        return "";
+      }
+    }
+  );
+  let result = withoutImports;
+  for (const [componentName, snippet] of snippets) {
+    result = result.replace(new RegExp(`<${componentName}(?:\\s[^>]*)?\\s*/>`, "g"), snippet).replace(new RegExp(`<${componentName}(?:\\s[^>]*)?>(?:[\\s\\S]*?)<\\/${componentName}>`, "g"), snippet);
+  }
+  return result;
+}
+function injectOpenApi(config, filename) {
+  const tabs = config.tabs.filter((tab) => !tab.tab.toLowerCase().includes("api"));
+  const apiTab = {
+    tab: "API Reference",
+    api: { source: `/${filename}` }
+  };
+  const changelog = tabs.findIndex((tab) => tab.tab.toLowerCase() === "changelog");
+  if (changelog >= 0) tabs.splice(changelog, 0, apiTab);
+  else tabs.push(apiTab);
+  return { ...config, tabs };
+}
+function migrateRepository(options) {
+  const repositoryDir = options.repositoryDir;
+  const platform = options.platform ?? detectRepositoryPlatform(repositoryDir);
+  const warnings = [];
+  let docsConfig = { tabs: [] };
+  const referenceMap = /* @__PURE__ */ new Map();
+  const referenceOrder = /* @__PURE__ */ new Map();
+  if (platform === "mintlify") {
+    try {
+      const config = readMintlifyConfig(repositoryDir);
+      if (config) {
+        const projected = projectMintlifyNavigation(config);
+        docsConfig = projected.docsConfig;
+        warnings.push(...projected.warnings);
+        for (const [index, reference] of projected.pageReferences.entries()) {
+          const key = normalizedReferenceKey(reference.ref);
+          referenceMap.set(key, reference);
+          referenceOrder.set(key, index);
+        }
+      }
+    } catch (error) {
+      warnings.push({
+        code: "unsupported-config",
+        message: `Mintlify config could not be read: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  const configuredDocsDir = options.docsDir ?? (platform === "mintlify" ? "" : detectRepositoryDocsDir(repositoryDir));
+  const contentRoot = resolveWithin(repositoryDir, configuredDocsDir);
+  if (!existsSync2(contentRoot) || !lstatSync(contentRoot).isDirectory()) {
+    throw new Error(`Documentation directory does not exist: ${configuredDocsDir || "."}`);
+  }
+  const files = scanFiles(contentRoot);
+  const pages = [];
+  const assets = [];
+  const seenPageIds = /* @__PURE__ */ new Set();
+  let skipped = 0;
+  const localeConfig = docsConfig.i18n;
+  const pageFiles = [...files].sort((left, right) => {
+    const leftOrder = referenceOrder.get(normalizedReferenceKey(left.relativePath)) ?? Number.MAX_SAFE_INTEGER;
+    const rightOrder = referenceOrder.get(normalizedReferenceKey(right.relativePath)) ?? Number.MAX_SAFE_INTEGER;
+    return leftOrder - rightOrder || left.relativePath.localeCompare(right.relativePath);
+  });
+  for (const file of pageFiles) {
+    if (!isDocumentationExtension(file.relativePath)) continue;
+    if (file.relativePath.split("/").some((segment) => SNIPPET_DIRECTORIES.has(segment.toLowerCase()))) {
+      skipped++;
+      continue;
+    }
+    const rootFilename = !file.relativePath.includes("/") ? basename(file.relativePath).toLowerCase() : "";
+    if (REPOSITORY_ONLY_DOCUMENTS.has(rootFilename)) {
+      skipped++;
+      continue;
+    }
+    if (![".md", ".mdx"].includes(extname2(file.relativePath).toLowerCase())) {
+      skipped++;
+      warnings.push({ code: "skipped-file", message: "Only Markdown and MDX are imported without an explicit converter.", source: file.relativePath });
+      continue;
+    }
+    const size = lstatSync(file.absolutePath).size;
+    if (size > MAX_PAGE_BYTES) {
+      skipped++;
+      warnings.push({ code: "skipped-file", message: "Page exceeded the 2 MB repository import limit.", source: file.relativePath });
+      continue;
+    }
+    const key = normalizedReferenceKey(file.relativePath);
+    const referenced = referenceMap.get(key);
+    let locale = referenced?.locale;
+    let navigationId = referenced?.navigationId ?? pageIdFromReference(file.relativePath);
+    if (!referenced && localeConfig) {
+      const prefix = file.relativePath.split("/", 1)[0];
+      if (localeConfig.locales.some((entry) => entry.code === prefix)) {
+        locale = prefix;
+        navigationId = pageIdFromReference(file.relativePath.slice(prefix.length + 1));
+      }
+    }
+    if (!navigationId) {
+      skipped++;
+      warnings.push({ code: "invalid-page", message: "Page path could not be normalized safely.", source: file.relativePath });
+      continue;
+    }
+    const isDefaultLocale = !locale || locale === localeConfig?.defaultLocale;
+    const id = isDefaultLocale ? navigationId : `${locale}/${navigationId}`;
+    if (seenPageIds.has(id)) {
+      skipped++;
+      warnings.push({ code: "collision", message: `Multiple source files map to ${id}; the first file was kept.`, source: file.relativePath });
+      continue;
+    }
+    const raw = inlineMdxSnippets(
+      readFileSync2(file.absolutePath, "utf8"),
+      file.absolutePath,
+      repositoryDir,
+      warnings
+    );
+    const page = parseMarkdownPage({
+      id,
+      navigationId,
+      ...locale ? { locale } : {},
+      raw,
+      source: `${options.sourceUrl}#${file.relativePath}`
+    });
+    if (!page) {
+      skipped++;
+      continue;
+    }
+    seenPageIds.add(id);
+    pages.push(page);
+  }
+  const discoveredReferenceKeys = new Set(files.map((file) => normalizedReferenceKey(file.relativePath)));
+  for (const [key] of referenceMap) {
+    if (!discoveredReferenceKeys.has(key)) {
+      warnings.push({ code: "missing-page", message: "A navigation entry did not resolve to a source page.", source: key });
+    }
+  }
+  let totalAssetBytes = 0;
+  for (const file of files) {
+    const firstSegment = file.relativePath.split("/", 1)[0].toLowerCase();
+    if (!ASSET_DIRECTORIES.has(firstSegment) || !ASSET_EXTENSIONS.has(extname2(file.relativePath).toLowerCase())) continue;
+    const size = lstatSync(file.absolutePath).size;
+    if (size > MAX_ASSET_BYTES || totalAssetBytes + size > MAX_TOTAL_ASSET_BYTES) {
+      warnings.push({ code: "limit-reached", message: "An asset was skipped because the migration asset budget was exhausted.", source: file.relativePath });
+      continue;
+    }
+    const assetPath = normalizeAssetPath(firstSegment === "public" ? file.relativePath.slice("public/".length) : file.relativePath);
+    if (!assetPath) continue;
+    assets.push({ path: assetPath, content: readFileSync2(file.absolutePath) });
+    totalAssetBytes += size;
+  }
+  if (files.length >= MAX_SOURCE_FILES) {
+    warnings.push({ code: "limit-reached", message: `Repository discovery stopped at ${MAX_SOURCE_FILES} files.` });
+  }
+  if (docsConfig.tabs.length === 0) docsConfig = buildNavigationFromPages(pages);
+  const openApi = findOpenApi(files);
+  if (openApi) {
+    const filename = basename(openApi.relativePath);
+    if (!assets.some((asset) => asset.path === filename)) {
+      assets.push({ path: filename, content: readFileSync2(openApi.absolutePath) });
+    }
+    docsConfig = injectOpenApi(docsConfig, filename);
+  }
+  if (pages.length === 0) throw new Error("No importable Markdown or MDX pages were found in the repository.");
+  return {
+    sourceUrl: options.sourceUrl,
+    sourceKind: "repository",
+    platform,
+    pages,
+    assets,
+    docsConfig,
+    warnings,
+    stats: { discovered: files.length, imported: pages.length, skipped }
+  };
+}
+
+// src/render.ts
+function yamlString(value) {
+  return JSON.stringify(value.replace(/\s+/g, " ").trim());
+}
+function renderPage(bundle, page) {
+  return [
+    "---",
+    `title: ${yamlString(page.title)}`,
+    `description: ${yamlString(page.description)}`,
+    page.keywords.length > 0 ? `keywords: [${page.keywords.map(yamlString).join(", ")}]` : null,
+    bundle.sourceKind === "url" ? `source: ${yamlString(page.source)}` : null,
+    "---",
+    "",
+    page.body,
+    ""
+  ].filter((line) => line !== null).join("\n");
+}
+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(groups) {
+    for (const group of groups ?? []) {
+      for (const page of group.pages) {
+        if (typeof page === "string") seenPages.add(page);
+        else recordPages([page]);
+      }
+    }
+  }
+  for (const tab of tabs) recordPages(tab.groups);
+  function uniqueGroups(groups) {
+    return (groups ?? []).flatMap((group) => {
+      const pages = group.pages.flatMap((page) => {
+        if (typeof page === "string") {
+          if (seenPages.has(page)) return [];
+          seenPages.add(page);
+          return [page];
+        }
+        const [nested] = uniqueGroups([page]);
+        return nested ? [nested] : [];
+      });
+      return pages.length > 0 ? [{ ...group, pages }] : [];
+    });
+  }
+  for (const tab of incoming.tabs) {
+    if (tab.tab.toLowerCase() === "changelog") continue;
+    const uniqueTab = { ...tab, ...tab.groups ? { groups: uniqueGroups(tab.groups) } : {} };
+    if (tab.groups && uniqueTab.groups?.length === 0 && !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 || !uniqueTab.groups) continue;
+    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,
+    ...i18n ? { i18n } : {}
+  };
+}
+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: `public/${asset.path}`, content: asset.content })),
+    { path: "docs.json", content: `${JSON.stringify(config, null, 2)}
+` }
+  ];
+}
+
+// src/url.ts
+import { load } from "cheerio";
+import TurndownService from "turndown";
+var DEFAULT_MAX_PAGES = 1e3;
+var DEFAULT_MAX_TOTAL_BYTES = 1e8;
+var MAX_DISCOVERED_URLS = 5e3;
+var MAX_LOCAL_RESPONSE_BYTES = 2e6;
+var MAX_SITEMAP_DOCUMENTS = 25;
+var PORTABLE_MDX_COMPONENTS = /* @__PURE__ */ new Set([
+  "Accordion",
+  "AccordionGroup",
+  "Badge",
+  "Callout",
+  "Card",
+  "CardGroup",
+  "Check",
+  "CodeGroup",
+  "Color",
+  "Column",
+  "Columns",
+  "Danger",
+  "Error",
+  "Expandable",
+  "File",
+  "Folder",
+  "Frame",
+  "Hero",
+  "Icon",
+  "Info",
+  "Latex",
+  "Mermaid",
+  "Note",
+  "Panel",
+  "ParamField",
+  "Prompt",
+  "PromptAssistant",
+  "PromptUser",
+  "RequestExample",
+  "ResponseExample",
+  "ResponseField",
+  "Step",
+  "Steps",
+  "Tab",
+  "Tabs",
+  "Tile",
+  "TileGroup",
+  "Tip",
+  "Tooltip",
+  "Tree",
+  "Update",
+  "View",
+  "Warning"
+]);
+var LOCALE_CODES = /* @__PURE__ */ new Set([
+  "ar",
+  "cs",
+  "da",
+  "de",
+  "el",
+  "es",
+  "fi",
+  "fr",
+  "he",
+  "hi",
+  "hu",
+  "id",
+  "it",
+  "ja",
+  "ko",
+  "ms",
+  "nl",
+  "no",
+  "pl",
+  "pt",
+  "ro",
+  "ru",
+  "sk",
+  "sv",
+  "th",
+  "tr",
+  "uk",
+  "vi",
+  "zh"
+]);
+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 docsScopePath(source) {
+  const path = source.pathname.replace(/\/+$/, "") || "/";
+  if (path === "/") return "/";
+  const segments = path.split("/").filter(Boolean);
+  return `/${segments.length > 1 ? segments[0] : segments.join("/")}`;
+}
+function isInScope(url, source, scopePath) {
+  if (url.origin !== source.origin || !["http:", "https:"].includes(url.protocol)) return false;
+  const path = url.pathname.replace(/\/+$/, "") || "/";
+  if (scopePath === "/") return true;
+  return path === scopePath || path === `${scopePath}.md` || path.startsWith(`${scopePath}/`);
+}
+function normalizeCandidate(value, base, source, scopePath) {
+  try {
+    const url = new URL(value, base);
+    url.hash = "";
+    if (!isInScope(url, source, scopePath)) return null;
+    if (/\.(?:avif|bmp|gif|ico|jpe?g|mp[34]|pdf|png|svg|webm|webp|zip)$/i.test(url.pathname)) return null;
+    return url;
+  } catch {
+    return null;
+  }
+}
+function candidateIdentity(url) {
+  const pathname = url.pathname.replace(/\.mdx?$/i, "").replace(/\/+$/, "") || "/";
+  return `${url.origin}${pathname}${url.search}`;
+}
+function pageIdForUrl(url, scopePath) {
+  let path = url.pathname.replace(/\/+$/, "");
+  if (scopePath !== "/") {
+    if (path === `${scopePath}.md`) path = "";
+    else if (path === scopePath) path = "";
+    else if (path.startsWith(`${scopePath}/`)) path = path.slice(scopePath.length + 1);
+  }
+  return pageIdFromReference(path.replace(/^\/+/, "") || "introduction");
+}
+function detectUrlPlatform(document) {
+  const value = `${document.body.slice(0, 2e5)} ${document.headers?.["x-powered-by"] ?? ""}`.toLowerCase();
+  if (value.includes("mintlify") || value.includes("__mintlify")) return "mintlify";
+  if (value.includes("docusaurus") || value.includes("__docusaurus")) return "docusaurus";
+  if (value.includes("gitbook") || value.includes("gitbook.io")) return "gitbook";
+  if (value.includes("nextra")) return "nextra";
+  if (value.includes("vitepress")) return "vitepress";
+  if (value.includes("starlight")) return "starlight";
+  return "generic";
+}
+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 sanitizeRemoteMarkdown(body) {
+  let fenceCharacter = "";
+  let fenceLength = 0;
+  const sanitized = body.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 line.replace(/<\/?div\b[^>]*>/gi, "").replace(/<img\s+([^>]*?)\/?\s*>/gi, (original, attributes) => {
+      const source = attributes.match(/\bsrc\s*=\s*(['"])(.*?)\1/i)?.[2];
+      const alternative = attributes.match(/\balt\s*=\s*(['"])(.*?)\1/i)?.[2] ?? "";
+      if (!source || /^(?:javascript|data):/i.test(source)) return "";
+      return `![${alternative.replace(/]/g, "\\]")}](${source})`;
+    });
+  }).join("\n");
+  const executable = withoutFencedCode(sanitized).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) || /\b(?:href|src)\s*=\s*(['"])\s*(?:javascript|data):/gi.test(withoutStaticProps)) 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 sanitized;
+}
+function migratedHref(href, currentUrl, source, scopePath, importedIds) {
+  if (/^(?:javascript|data|vbscript):/i.test(href)) return "#";
+  if (href.startsWith("#") || /^(?:mailto|tel):/i.test(href)) return href;
+  try {
+    const target = new URL(href, currentUrl);
+    if (target.origin !== source.origin) return href;
+    let path = target.pathname;
+    if (scopePath !== "/" && (path === scopePath || path.startsWith(`${scopePath}/`))) {
+      path = path.slice(scopePath.length);
+    }
+    const id = pageIdFromReference(path.replace(/^\/+/, "") || "introduction");
+    const localizedId = id && LOCALE_CODES.has(id) ? `${id}/introduction` : id;
+    if (localizedId && importedIds.has(localizedId)) {
+      const destination = localizedId === "introduction" ? "/" : `/${localizedId.replace(/\/introduction$/, "")}`;
+      return `${destination}${target.search}${target.hash}`;
+    }
+    return target.toString();
+  } catch {
+    return href;
+  }
+}
+function rewriteInternalLinks(body, currentUrl, source, scopePath, importedIds) {
+  const markdown = body.replace(/(?<!!)\[([^\]]+)\]\(([^)\s]+)(\s+['"][^'"]*['"])?\)/g, (original, label, href, title = "") => {
+    const destination = migratedHref(href, currentUrl, source, scopePath, importedIds);
+    return destination === href ? original : `[${label}](${destination}${title})`;
+  });
+  return markdown.replace(/\bhref=(['"])([^'"]+)\1/g, (_original, quote, href) => {
+    const destination = migratedHref(href, currentUrl, source, scopePath, importedIds);
+    return `href=${quote}${destination}${quote}`;
+  });
+}
+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")
+  };
+}
+function markdownPage(document, id) {
+  const parsed = remoteMarkdownMetadata(document.body);
+  const titleMatch = parsed.content.match(/^#\s+(.+)$/m);
+  const title = parsed.title ?? titleMatch?.[1] ?? id.split("/").at(-1) ?? "Introduction";
+  const raw = [
+    "---",
+    `title: ${JSON.stringify(title)}`,
+    ...parsed.description ? [`description: ${JSON.stringify(parsed.description)}`] : [],
+    "---",
+    "",
+    parsed.content
+  ].join("\n");
+  return parseMarkdownPage({ id, raw, source: document.finalUrl.toString() });
+}
+function htmlPage(document, id) {
+  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 title = $("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");
+  root.find("script,style,noscript,nav,header,footer,aside,form,button,svg,iframe,object,embed,link,meta").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"]);
+  turndown.addRule("migration-safe-fenced-code", {
+    filter: (node) => node.nodeName === "PRE",
+    replacement: (_content, node) => {
+      const element = node;
+      const code = element.textContent?.replace(/\n$/, "") ?? "";
+      const language = element.querySelector("code")?.className.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 `
+
+${fence}${language}
+${code}
+${fence}
+
+`;
+    }
+  });
+  const escape = turndown.escape.bind(turndown);
+  turndown.escape = (text) => escape(text).replace(/[<{]/g, (match) => `\\${match}`);
+  const body = turndown.turndown(root.html() ?? "").trim();
+  if (!title || body.length < 40) 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
+  };
+}
+function markdownLinks(body) {
+  return [...body.matchAll(/\[[^\]]+\]\(([^)\s]+)(?:\s+['"][^'"]*['"])?\)/g)].map((match) => match[1]);
+}
+function sitemapLinks(body) {
+  const $ = load(body, { xmlMode: true });
+  return $("url > loc, sitemap > loc").map((_index, element) => $(element).text().trim()).get().filter(Boolean);
+}
+function robotsSitemaps(body) {
+  return body.split("\n").map((line) => line.match(/^\s*Sitemap:\s*(\S+)/i)?.[1]).filter((value) => Boolean(value));
+}
+function headerLinks(document) {
+  const links = [];
+  const llms = document.headers?.["x-llms-txt"];
+  if (llms) links.push(llms);
+  const linkHeader = document.headers?.link ?? "";
+  for (const match of linkHeader.matchAll(/<([^>]+)>\s*;[^,]*(?:rel=["']?(?:alternate|llms-txt)["']?|type=["']text\/(?:markdown|plain)["'])/gi)) {
+    links.push(match[1]);
+  }
+  return links;
+}
+async function safeFetch(fetcher, url, accept) {
+  try {
+    return await fetcher(url, { accept });
+  } catch {
+    return null;
+  }
+}
+async function migrateUrl(options) {
+  const source = validateMigrationUrl(options.sourceUrl);
+  const fetcher = options.fetcher ?? defaultMigrationFetcher;
+  const maxPages = Math.max(1, Math.min(options.maxPages ?? DEFAULT_MAX_PAGES, 1e3));
+  const concurrency = Math.max(1, Math.min(options.concurrency ?? 5, 10));
+  const maxTotalBytes = Math.max(1e6, Math.min(options.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES, 5e8));
+  const scopePath = docsScopePath(source);
+  const initial = await fetcher(source, { accept: "text/markdown,text/html,application/xhtml+xml;q=0.9" });
+  if (!isInScope(initial.finalUrl, source, scopePath)) {
+    throw new Error("The documentation URL redirected outside the submitted docs origin or path.");
+  }
+  const platform = detectUrlPlatform(initial);
+  const cache = /* @__PURE__ */ new Map([[source.toString(), initial]]);
+  const queue = [source];
+  const queued = /* @__PURE__ */ new Set([candidateIdentity(source)]);
+  const warnings = [];
+  const fetchedSitemaps = /* @__PURE__ */ new Set();
+  function enqueue(value, base) {
+    if (queued.size >= MAX_DISCOVERED_URLS) return;
+    const url = normalizeCandidate(value, base, source, scopePath);
+    if (!url || queued.has(candidateIdentity(url))) return;
+    queued.add(candidateIdentity(url));
+    queue.push(url);
+  }
+  async function discoverDocumentLinks(document, depth = 0) {
+    const links = sitemapLinks(document.body);
+    for (const link of links) {
+      let url;
+      try {
+        url = new URL(link, document.finalUrl);
+      } catch {
+        continue;
+      }
+      if (depth < 2 && /\.xml(?:$|\?)/i.test(url.pathname)) {
+        if (url.origin !== source.origin || fetchedSitemaps.size >= MAX_SITEMAP_DOCUMENTS || fetchedSitemaps.has(url.toString())) continue;
+        fetchedSitemaps.add(url.toString());
+        const nested = await safeFetch(fetcher, url, "application/xml,text/xml");
+        if (nested && nested.finalUrl.origin === source.origin) await discoverDocumentLinks(nested, depth + 1);
+      } else {
+        enqueue(link, document.finalUrl);
+      }
+    }
+  }
+  for (const link of headerLinks(initial)) {
+    let url;
+    try {
+      url = new URL(link, initial.finalUrl);
+    } catch {
+      continue;
+    }
+    if (url.origin !== source.origin) continue;
+    const document = await safeFetch(fetcher, url, "text/plain,text/markdown");
+    if (!document || document.finalUrl.origin !== source.origin) continue;
+    for (const candidate of markdownLinks(document.body)) enqueue(candidate, document.finalUrl);
+  }
+  const pathRoot = scopePath === "/" ? source.origin : `${source.origin}${scopePath}`;
+  const discoveryUrls = [
+    new URL("/llms.txt", source.origin),
+    new URL(`${pathRoot.replace(source.origin, "")}/llms.txt`, source.origin),
+    new URL("/robots.txt", source.origin),
+    new URL("/sitemap.xml", source.origin),
+    new URL(`${pathRoot.replace(source.origin, "")}/sitemap.xml`, source.origin)
+  ];
+  const uniqueDiscovery = [...new Map(discoveryUrls.map((url) => [url.toString(), url])).values()];
+  for (const url of uniqueDiscovery) {
+    const document = await safeFetch(fetcher, url, "text/plain,application/xml,text/xml;q=0.9");
+    if (!document || document.finalUrl.origin !== source.origin) continue;
+    const isRobots = url.pathname.endsWith("robots.txt");
+    const isSitemap = url.pathname.endsWith("sitemap.xml") || document.contentType.includes("xml");
+    if (isRobots) {
+      for (const link of robotsSitemaps(document.body)) {
+        let sitemapUrl;
+        try {
+          sitemapUrl = new URL(link, document.finalUrl);
+        } catch {
+          continue;
+        }
+        if (sitemapUrl.origin !== source.origin || fetchedSitemaps.size >= MAX_SITEMAP_DOCUMENTS || fetchedSitemaps.has(sitemapUrl.toString())) continue;
+        fetchedSitemaps.add(sitemapUrl.toString());
+        const sitemap = await safeFetch(fetcher, sitemapUrl, "application/xml,text/xml");
+        if (sitemap && sitemap.finalUrl.origin === source.origin) await discoverDocumentLinks(sitemap);
+      }
+    } else if (isSitemap) {
+      await discoverDocumentLinks(document);
+    } else {
+      for (const link of markdownLinks(document.body)) enqueue(link, document.finalUrl);
+    }
+  }
+  const pages = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  let importedBytes = 0;
+  let isByteBudgetExhausted = false;
+  while (queue.length > 0 && pages.length < maxPages && !isByteBudgetExhausted) {
+    const batch = [];
+    while (queue.length > 0 && batch.length < Math.min(concurrency, maxPages - pages.length)) {
+      const candidate = queue.shift();
+      if (!candidate || visited.has(candidate.toString())) continue;
+      visited.add(candidate.toString());
+      batch.push(candidate);
+    }
+    if (batch.length === 0) continue;
+    const results = await Promise.all(batch.map(async (candidate) => {
+      let document = cache.get(candidate.toString()) ?? await safeFetch(fetcher, candidate, "text/markdown,text/html,application/xhtml+xml;q=0.9");
+      if (!document) {
+        return { candidate, page: null, links: [], failure: true };
+      }
+      if (!isInScope(document.finalUrl, source, scopePath)) {
+        return { candidate, page: null, links: [], failure: false };
+      }
+      const isMarkdown = /(?:markdown|text\/plain)/i.test(document.contentType) || /\.mdx?$/i.test(document.finalUrl.pathname);
+      if (!isMarkdown && !/\.mdx?$/i.test(candidate.pathname)) {
+        const markdownUrl = new URL(candidate);
+        markdownUrl.pathname = `${markdownUrl.pathname.replace(/\/$/, "")}.md`;
+        const markdownDocument = await safeFetch(fetcher, markdownUrl, "text/markdown,text/plain");
+        if (markdownDocument && isInScope(markdownDocument.finalUrl, source, scopePath) && /(?:markdown|text\/plain)/i.test(markdownDocument.contentType)) {
+          document = markdownDocument;
+        }
+      }
+      const isResolvedMarkdown = /(?:markdown|text\/plain)/i.test(document.contentType) || /\.mdx?$/i.test(document.finalUrl.pathname);
+      const sanitizedMarkdown = isResolvedMarkdown ? sanitizeRemoteMarkdown(document.body) : null;
+      if (isResolvedMarkdown && sanitizedMarkdown === null) {
+        const htmlUrl = new URL(candidate);
+        htmlUrl.pathname = htmlUrl.pathname.replace(/\.mdx?$/i, "") || "/";
+        const htmlDocument = await safeFetch(fetcher, htmlUrl, "text/html,application/xhtml+xml");
+        if (htmlDocument && isInScope(htmlDocument.finalUrl, source, scopePath) && /html/i.test(htmlDocument.contentType)) {
+          document = htmlDocument;
+        }
+      } else if (sanitizedMarkdown !== null) {
+        document = { ...document, body: sanitizedMarkdown };
+      }
+      const responseBytes = Buffer.byteLength(document.body, "utf8");
+      if (importedBytes + responseBytes > maxTotalBytes) {
+        isByteBudgetExhausted = true;
+        return { candidate, page: null, links: [], failure: false, budgetExceeded: true };
+      }
+      importedBytes += responseBytes;
+      const id = pageIdForUrl(document.finalUrl, scopePath) ?? pageIdForUrl(candidate, scopePath);
+      if (!id) return { candidate, page: null, links: [], failure: false };
+      if (/(?:markdown|text\/plain)/i.test(document.contentType) || /\.mdx?$/i.test(document.finalUrl.pathname)) {
+        return {
+          candidate,
+          page: markdownPage(document, id),
+          links: markdownLinks(document.body),
+          base: document.finalUrl,
+          failure: false
+        };
+      }
+      const extracted = htmlPage(document, id);
+      return { candidate, page: extracted.page, links: extracted.links, base: document.finalUrl, failure: false };
+    }));
+    for (const result of results) {
+      if (result.failure) {
+        warnings.push({ code: "fetch-failed", message: "A discovered documentation page could not be fetched.", source: result.candidate.toString() });
+        continue;
+      }
+      if (result.budgetExceeded) continue;
+      if (result.page && !seenIds.has(result.page.id) && pages.length < maxPages) {
+        pages.push(result.page);
+        seenIds.add(result.page.id);
+      }
+      for (const link of result.links) enqueue(link, result.base ?? result.candidate);
+    }
+  }
+  if (pages.length === 0) throw new Error("No readable documentation pages were found at that URL.");
+  for (const page of pages) {
+    const [locale, ...navigationSegments] = page.id.split("/");
+    if (LOCALE_CODES.has(locale)) {
+      if (navigationSegments.length === 0) page.id = `${locale}/introduction`;
+      page.locale = locale;
+      page.navigationId = navigationSegments.join("/") || "introduction";
+    }
+  }
+  const importedIds = new Set(pages.map((page) => page.id));
+  for (const page of pages) {
+    page.body = rewriteInternalLinks(page.body, new URL(page.source), source, scopePath, importedIds);
+  }
+  if (isByteBudgetExhausted) {
+    warnings.push({ code: "limit-reached", message: `Import stopped after reaching the ${Math.round(maxTotalBytes / 1e6)} MB content budget.` });
+  } else if (queue.length > 0 || queued.size >= MAX_DISCOVERED_URLS) {
+    warnings.push({ code: "limit-reached", message: `Import stopped after ${pages.length} pages; narrow the URL or raise the caller limit to import more.` });
+  }
+  const docsConfig = buildNavigationFromPages(pages);
+  const locales = [...new Set(pages.map((page) => page.locale).filter((value) => Boolean(value)))];
+  if (locales.length > 0) {
+    docsConfig.i18n = {
+      defaultLocale: "en",
+      locales: [
+        { code: "en", label: "English" },
+        ...locales.filter((locale) => locale !== "en").map((locale) => ({ code: locale, label: locale.toUpperCase() }))
+      ]
+    };
+  }
+  return {
+    sourceUrl: source.toString(),
+    sourceKind: "url",
+    platform,
+    pages,
+    assets: [],
+    docsConfig,
+    warnings,
+    stats: {
+      discovered: visited.size,
+      imported: pages.length,
+      skipped: Math.max(0, visited.size - pages.length)
+    }
+  };
+}
+export {
+  buildNavigationFromPages,
+  cloneGitHubRepository,
+  defaultMigrationFetcher,
+  detectRepositoryDocsDir,
+  detectRepositoryPlatform,
+  mergeMigrationConfig,
+  migrateRepository,
+  migrateUrl,
+  normalizeMdx,
+  parseGitHubRepositoryUrl,
+  parseMarkdownPage,
+  projectMintlifyNavigation,
+  readMintlifyConfig,
+  renderMigrationFiles,
+  validateMigrationUrl
+};
+//# sourceMappingURL=index.js.map