specra 0.1.13 → 0.2.0

package/dist/lib/index.js

@@ -1,1595 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/lib/index.ts
-var lib_exports = {};
-__export(lib_exports, {
-  CSP_DIRECTIVES: () => CSP_DIRECTIVES,
-  OpenApiParser: () => OpenApiParser,
-  PerfTimer: () => PerfTimer,
-  PostmanParser: () => PostmanParser,
-  SAFE_MDX_COMPONENTS: () => SAFE_MDX_COMPONENTS,
-  SpecraParser: () => SpecraParser,
-  buildRedirectMappings: () => buildRedirectMappings,
-  buildSidebarStructure: () => buildSidebarStructure,
-  clearAllCaches: () => clearAllCaches,
-  cn: () => cn,
-  debugLog: () => debugLog,
-  defaultConfig: () => defaultConfig,
-  detectParserType: () => detectParserType,
-  extractHeadings: () => extractHeadings,
-  extractTableOfContents: () => extractTableOfContents,
-  findRedirect: () => findRedirect,
-  generateCSPHeader: () => generateCSPHeader,
-  getAdjacentDocs: () => getAdjacentDocs,
-  getAllCategoryConfigs: () => getAllCategoryConfigs,
-  getAllDocs: () => getAllDocs,
-  getAssetPath: () => getAssetPath,
-  getCacheStats: () => getCacheStats,
-  getCachedAllDocs: () => getCachedAllDocs,
-  getCachedDocBySlug: () => getCachedDocBySlug,
-  getCachedVersions: () => getCachedVersions,
-  getCategoryConfig: () => getCategoryConfig,
-  getConfig: () => getConfig,
-  getConfigValue: () => getConfigValue,
-  getDocBySlug: () => getDocBySlug,
-  getI18nConfig: () => getI18nConfig,
-  getVersions: () => getVersions,
-  initConfig: () => initConfig,
-  isCategoryPage: () => isCategoryPage,
-  loadConfig: () => loadConfig,
-  logCacheOperation: () => logCacheOperation,
-  logFsOperation: () => logFsOperation,
-  logMemoryUsage: () => logMemoryUsage,
-  parseApiSpec: () => parseApiSpec,
-  processContentWithEnv: () => processContentWithEnv,
-  reloadConfig: () => reloadConfig,
-  replaceEnvVariables: () => replaceEnvVariables,
-  sanitizeMDXContent: () => sanitizeMDXContent,
-  sanitizePath: () => sanitizePath,
-  scanMDXForDangerousPatterns: () => scanMDXForDangerousPatterns,
-  sortSidebarGroups: () => sortSidebarGroups,
-  sortSidebarItems: () => sortSidebarItems,
-  validateConfig: () => validateConfig,
-  validateMDXComponents: () => validateMDXComponents,
-  validateMDXSecurity: () => validateMDXSecurity,
-  validatePathWithinDirectory: () => validatePathWithinDirectory
-});
-module.exports = __toCommonJS(lib_exports);
-
-// src/lib/mdx.ts
-var import_fs2 = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
-var import_gray_matter = __toESM(require("gray-matter"));
-
-// src/lib/category.ts
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var DOCS_DIR = import_path.default.join(process.cwd(), "docs");
-function getCategoryConfig(folderPath) {
-  try {
-    const categoryPath = import_path.default.join(folderPath, "_category_.json");
-    if (!import_fs.default.existsSync(categoryPath)) {
-      return null;
-    }
-    const content = import_fs.default.readFileSync(categoryPath, "utf8");
-    return JSON.parse(content);
-  } catch (error) {
-    console.error(`Error reading category config from ${folderPath}:`, error);
-    return null;
-  }
-}
-function getAllCategoryConfigs(version) {
-  const configs = /* @__PURE__ */ new Map();
-  const versionDir = import_path.default.join(DOCS_DIR, version);
-  if (!import_fs.default.existsSync(versionDir)) {
-    return configs;
-  }
-  function scanDirectory(dir, relativePath = "") {
-    const entries = import_fs.default.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const fullPath = import_path.default.join(dir, entry.name);
-        const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-        const config = getCategoryConfig(fullPath);
-        if (config) {
-          configs.set(relPath, config);
-        }
-        scanDirectory(fullPath, relPath);
-      }
-    }
-  }
-  scanDirectory(versionDir);
-  return configs;
-}
-
-// src/lib/sidebar-utils.ts
-function sortSidebarItems(items) {
-  return [...items].sort((a, b) => {
-    const posA = a.sidebar_position ?? a.meta?.sidebar_position ?? a.meta?.order ?? 999;
-    const posB = b.sidebar_position ?? b.meta?.sidebar_position ?? b.meta?.order ?? 999;
-    return posA - posB;
-  });
-}
-function sortSidebarGroups(groups) {
-  return Object.entries(groups).sort(([, a], [, b]) => {
-    const posA = a.position ?? 999;
-    const posB = b.position ?? 999;
-    return posA - posB;
-  });
-}
-function buildSidebarStructure(docs) {
-  const rootGroups = {};
-  const standalone = [];
-  const categoryMetadata = /* @__PURE__ */ new Map();
-  docs.forEach((doc) => {
-    const pathParts = doc.filePath.split("/");
-    const folderPath = pathParts.length > 1 ? pathParts.slice(0, -1).join("/") : "";
-    if (folderPath && doc.categoryLabel) {
-      categoryMetadata.set(folderPath, {
-        label: doc.categoryLabel,
-        position: doc.categoryPosition,
-        icon: doc.categoryIcon,
-        collapsible: doc.categoryCollapsible,
-        collapsed: doc.categoryCollapsed
-      });
-    }
-  });
-  docs.forEach((doc) => {
-    const pathParts = doc.filePath.split("/");
-    const isIndexFile = doc.filePath.endsWith("/index") || doc.filePath === "index" || pathParts.length > 1 && doc.slug === pathParts.slice(0, -1).join("/");
-    const customGroup = doc.meta.sidebar || doc.meta.group;
-    if (customGroup) {
-      const groupName = customGroup.charAt(0).toUpperCase() + customGroup.slice(1);
-      if (!rootGroups[groupName]) {
-        rootGroups[groupName] = {
-          label: groupName,
-          path: customGroup,
-          items: [],
-          position: 999,
-          collapsible: doc.categoryCollapsible ?? true,
-          defaultCollapsed: doc.categoryCollapsed ?? false,
-          children: {}
-        };
-      }
-      if (isIndexFile) {
-        rootGroups[groupName].position = doc.categoryPosition ?? doc.meta.sidebar_position ?? 999;
-        rootGroups[groupName].icon = doc.categoryIcon;
-      } else {
-        rootGroups[groupName].items.push(doc);
-      }
-      return;
-    }
-    if (pathParts.length > 1) {
-      const folderParts = pathParts.slice(0, -1);
-      let currentLevel = rootGroups;
-      let currentPath = "";
-      for (let i = 0; i < folderParts.length; i++) {
-        const folder = folderParts[i];
-        currentPath = currentPath ? `${currentPath}/${folder}` : folder;
-        const folderLabel = folder.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-        const metadata = categoryMetadata.get(currentPath);
-        if (!currentLevel[folder]) {
-          currentLevel[folder] = {
-            label: metadata?.label ?? folderLabel,
-            path: currentPath,
-            icon: metadata?.icon,
-            items: [],
-            position: metadata?.position ?? 999,
-            collapsible: metadata?.collapsible ?? true,
-            defaultCollapsed: metadata?.collapsed ?? false,
-            children: {}
-          };
-        }
-        if (i === folderParts.length - 1) {
-          if (isIndexFile) {
-            currentLevel[folder].position = doc.categoryPosition ?? doc.meta.sidebar_position ?? currentLevel[folder].position;
-            if (doc.categoryLabel) {
-              currentLevel[folder].label = doc.categoryLabel;
-            }
-            if (doc.categoryIcon) {
-              currentLevel[folder].icon = doc.categoryIcon;
-            }
-            if (doc.categoryCollapsible !== void 0) {
-              currentLevel[folder].collapsible = doc.categoryCollapsible;
-            }
-            if (doc.categoryCollapsed !== void 0) {
-              currentLevel[folder].defaultCollapsed = doc.categoryCollapsed;
-            }
-          } else {
-            currentLevel[folder].items.push(doc);
-          }
-        }
-        currentLevel = currentLevel[folder].children;
-      }
-    } else {
-      if (!isIndexFile) {
-        standalone.push(doc);
-      }
-    }
-  });
-  return { rootGroups, standalone };
-}
-
-// src/lib/mdx-security.ts
-var import_path2 = __toESM(require("path"));
-function sanitizePath(userPath) {
-  const decoded = decodeURIComponent(userPath);
-  if (decoded.includes("../") || decoded.includes("..\\") || decoded.includes("%2e%2e") || decoded.includes("%252e%252e") || import_path2.default.isAbsolute(decoded)) {
-    throw new Error("Path traversal detected");
-  }
-  const normalized = import_path2.default.normalize(decoded).replace(/\\/g, "/");
-  if (normalized.startsWith("..") || normalized.includes("/../")) {
-    throw new Error("Invalid path detected");
-  }
-  return normalized;
-}
-function validatePathWithinDirectory(filePath, allowedDir) {
-  const resolvedPath = import_path2.default.resolve(allowedDir, filePath);
-  const resolvedDir = import_path2.default.resolve(allowedDir);
-  return resolvedPath.startsWith(resolvedDir + import_path2.default.sep) || resolvedPath === resolvedDir;
-}
-var DANGEROUS_PATTERNS = [
-  // JavaScript execution
-  /eval\s*\(/gi,
-  /Function\s*\(/gi,
-  /import\s*\(/gi,
-  /require\s*\(/gi,
-  // File system access
-  /fs\.[a-z]+/gi,
-  /readFile/gi,
-  /writeFile/gi,
-  /process\.env/gi,
-  // Network requests during SSR (legitimate client-side usage should use components)
-  /fetch\s*\(/gi,
-  // Dangerous Node.js modules
-  /child_process/gi,
-  /exec\s*\(/gi,
-  /spawn\s*\(/gi,
-  // Script tag injection
-  /<script[>\s]/gi,
-  /javascript:/gi,
-  /\bon(abort|blur|cancel|canplay|canplaythrough|change|click|close|contextmenu|cuechange|dblclick|drag|dragend|dragenter|dragleave|dragover|dragstart|drop|durationchange|emptied|ended|error|focus|input|invalid|keydown|keypress|keyup|load|loadeddata|loadedmetadata|loadstart|mousedown|mouseenter|mouseleave|mousemove|mouseout|mouseover|mouseup|mousewheel|pause|play|playing|progress|ratechange|reset|resize|scroll|seeked|seeking|select|show|stalled|submit|suspend|timeupdate|toggle|volumechange|waiting|wheel)\s*=/gi
-  // onclick, onerror, onload, etc.
-];
-function removeCodeBlocks(content) {
-  let withoutCodeBlocks = content.replace(/```[\s\S]*?```/g, "");
-  withoutCodeBlocks = withoutCodeBlocks.replace(/`[^`]*`/g, "");
-  return withoutCodeBlocks;
-}
-function scanMDXForDangerousPatterns(content) {
-  const issues = [];
-  const contentWithoutCode = removeCodeBlocks(content);
-  for (const pattern of DANGEROUS_PATTERNS) {
-    const matches = contentWithoutCode.match(pattern);
-    if (matches) {
-      issues.push(`Dangerous pattern detected: ${pattern.source}`);
-    }
-  }
-  return issues;
-}
-function sanitizeMDXContent(content, strict = false) {
-  if (strict) {
-    const issues = scanMDXForDangerousPatterns(content);
-    if (issues.length > 0) {
-      throw new Error(`MDX content contains dangerous patterns: ${issues.join(", ")}`);
-    }
-  }
-  let sanitized = content.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
-  sanitized = sanitized.replace(/\s+on\w+\s*=\s*["'][^"']*["']/gi, "");
-  sanitized = sanitized.replace(/javascript:/gi, "");
-  return sanitized;
-}
-var CSP_DIRECTIVES = {
-  "default-src": ["'self'"],
-  "script-src": [
-    "'self'",
-    "'unsafe-inline'",
-    // Required for Next.js
-    "'unsafe-eval'"
-    // Required for dev mode - remove in production
-  ],
-  "style-src": ["'self'", "'unsafe-inline'"],
-  // Required for styled-components/emotion
-  "img-src": ["'self'", "data:", "https:"],
-  "font-src": ["'self'", "data:"],
-  "connect-src": ["'self'"],
-  "frame-src": ["'self'"],
-  "object-src": ["'none'"],
-  "base-uri": ["'self'"],
-  "form-action": ["'self'"],
-  "frame-ancestors": ["'self'"],
-  "upgrade-insecure-requests": []
-};
-function generateCSPHeader(customDirectives, production = true) {
-  const directives = { ...CSP_DIRECTIVES, ...customDirectives };
-  if (production && directives["script-src"]) {
-    directives["script-src"] = directives["script-src"].filter(
-      (src) => src !== "'unsafe-eval'"
-    );
-  }
-  return Object.entries(directives).map(([key, values]) => `${key} ${values.join(" ")}`).join("; ");
-}
-var SAFE_MDX_COMPONENTS = /* @__PURE__ */ new Set([
-  // Standard HTML elements (automatically allowed by MDX)
-  "h1",
-  "h2",
-  "h3",
-  "h4",
-  "h5",
-  "h6",
-  "p",
-  "a",
-  "ul",
-  "ol",
-  "li",
-  "code",
-  "pre",
-  "blockquote",
-  "table",
-  "thead",
-  "tbody",
-  "tr",
-  "th",
-  "td",
-  "img",
-  "video",
-  "audio",
-  "br",
-  "hr",
-  "strong",
-  "em",
-  // Custom safe components
-  "Callout",
-  "CodeBlock",
-  "Accordion",
-  "AccordionItem",
-  "Tabs",
-  "Tab",
-  "Image",
-  "Video",
-  "Card",
-  "CardGrid",
-  "ImageCard",
-  "ImageCardGrid",
-  "Steps",
-  "Step",
-  "Icon",
-  "Mermaid",
-  "Math",
-  "Columns",
-  "Column",
-  "Badge",
-  "Tooltip",
-  "Frame",
-  "ApiEndpoint",
-  "ApiParams",
-  "ApiResponse",
-  "ApiPlayground",
-  "ApiReference"
-]);
-function validateMDXComponents(content) {
-  const issues = [];
-  const componentRegex = /<([A-Z][a-zA-Z0-9]*)/g;
-  let match;
-  while ((match = componentRegex.exec(content)) !== null) {
-    const componentName = match[1];
-    if (!SAFE_MDX_COMPONENTS.has(componentName)) {
-      issues.push(`Unsafe component detected: ${componentName}`);
-    }
-  }
-  return {
-    valid: issues.length === 0,
-    issues
-  };
-}
-function validateMDXSecurity(content, options = {}) {
-  const {
-    strictMode = false,
-    allowCustomComponents = true,
-    blockDangerousPatterns = true
-  } = options;
-  const issues = [];
-  if (blockDangerousPatterns) {
-    const patternIssues = scanMDXForDangerousPatterns(content);
-    issues.push(...patternIssues);
-  }
-  if (!allowCustomComponents) {
-    const componentValidation = validateMDXComponents(content);
-    if (!componentValidation.valid) {
-      issues.push(...componentValidation.issues);
-    }
-  }
-  if (strictMode && issues.length > 0) {
-    return { valid: false, issues };
-  }
-  const sanitized = sanitizeMDXContent(content, false);
-  return {
-    valid: true,
-    issues,
-    sanitized
-  };
-}
-
-// src/lib/config.types.ts
-var defaultConfig = {
-  site: {
-    title: "Documentation",
-    description: "Project documentation",
-    baseUrl: "/",
-    language: "en"
-  },
-  theme: {
-    defaultMode: "system",
-    respectPrefersColorScheme: true
-  },
-  navigation: {
-    showSidebar: true,
-    collapsibleSidebar: true,
-    showBreadcrumbs: true,
-    showTableOfContents: true,
-    tocPosition: "right",
-    tocMaxDepth: 3
-  },
-  search: {
-    enabled: true,
-    provider: "local",
-    placeholder: "Search documentation..."
-  },
-  features: {
-    showLastUpdated: true,
-    showReadingTime: true,
-    showAuthors: false,
-    showTags: true,
-    versioning: true,
-    i18n: false
-  }
-};
-
-// src/lib/config.server.ts
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key in source) {
-    const sourceValue = source[key];
-    const targetValue = result[key];
-    if (sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue)) {
-      result[key] = deepMerge(
-        targetValue && typeof targetValue === "object" ? targetValue : {},
-        sourceValue
-      );
-    } else if (sourceValue !== void 0) {
-      result[key] = sourceValue;
-    }
-  }
-  return result;
-}
-function loadConfig(userConfig) {
-  try {
-    const config = deepMerge(defaultConfig, userConfig);
-    return config;
-  } catch (error) {
-    console.error(`\u274C Error loading configuration:`, error);
-    console.warn("Using default configuration.");
-    return defaultConfig;
-  }
-}
-function getConfigValue(path4, config) {
-  const cfg = config || loadConfig({});
-  const keys = path4.split(".");
-  let value = cfg;
-  for (const key of keys) {
-    if (value && typeof value === "object" && key in value) {
-      value = value[key];
-    } else {
-      return void 0;
-    }
-  }
-  return value;
-}
-function replaceEnvVariables(text, config) {
-  const cfg = config || loadConfig({});
-  const envVars = cfg.env || {};
-  let result = text;
-  result = result.replace(/\$\{([^}]+)\}/g, (match, varName) => {
-    return envVars[varName] || match;
-  });
-  result = result.replace(/\{\{([^}]+)\}\}/g, (match, varName) => {
-    return envVars[varName] || match;
-  });
-  return result;
-}
-function processContentWithEnv(content, config) {
-  return replaceEnvVariables(content, config);
-}
-function validateConfig(config) {
-  const errors = [];
-  if (!config.site?.title) {
-    errors.push("site.title is required");
-  }
-  if (config.site?.url) {
-    try {
-      new URL(config.site.url);
-    } catch {
-      errors.push("site.url must be a valid URL");
-    }
-  }
-  if (config.social) {
-    const socialKeys = ["github", "twitter", "discord", "linkedin", "youtube"];
-    for (const key of socialKeys) {
-      const url = config.social[key];
-      if (url) {
-        try {
-          new URL(url);
-        } catch {
-          errors.push(`social.${key} must be a valid URL`);
-        }
-      }
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-}
-var configInstance = null;
-function initConfig(userConfig) {
-  configInstance = loadConfig(userConfig);
-  return configInstance;
-}
-function getConfig() {
-  if (!configInstance) {
-    configInstance = loadConfig({});
-  }
-  return configInstance;
-}
-function reloadConfig(userConfig) {
-  configInstance = loadConfig(userConfig);
-  return configInstance;
-}
-
-// src/lib/mdx.ts
-var DOCS_DIR2 = import_path3.default.join(process.cwd(), "docs");
-function calculateReadingTime(content) {
-  const words = content.trim().split(/\s+/).length;
-  const minutes = Math.ceil(words / 200);
-  return { minutes, words };
-}
-function getVersions() {
-  try {
-    const versions = import_fs2.default.readdirSync(DOCS_DIR2);
-    return versions.filter((v) => import_fs2.default.statSync(import_path3.default.join(DOCS_DIR2, v)).isDirectory());
-  } catch (error) {
-    return ["v1.0.0"];
-  }
-}
-function findMdxFiles(dir, baseDir = dir) {
-  const files = [];
-  try {
-    const entries = import_fs2.default.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = import_path3.default.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        files.push(...findMdxFiles(fullPath, baseDir));
-      } else if (entry.isFile() && entry.name.endsWith(".mdx")) {
-        const relativePath = import_path3.default.relative(baseDir, fullPath).replace(/\\/g, "/");
-        files.push(relativePath);
-      }
-    }
-  } catch (error) {
-    console.error(`Error reading directory ${dir}:`, error);
-  }
-  return files;
-}
-function readDocFromFile(filePath, originalSlug) {
-  try {
-    if (!import_fs2.default.existsSync(filePath)) {
-      return null;
-    }
-    if (!validatePathWithinDirectory(filePath, DOCS_DIR2)) {
-      console.error(`[Security] Path traversal attempt blocked: ${filePath}`);
-      return null;
-    }
-    const fileContents = import_fs2.default.readFileSync(filePath, "utf8");
-    const { data, content } = (0, import_gray_matter.default)(fileContents);
-    const securityCheck = validateMDXSecurity(content, {
-      strictMode: process.env.NODE_ENV === "production",
-      blockDangerousPatterns: true
-    });
-    if (!securityCheck.valid) {
-      console.error(`[Security] MDX validation failed for ${filePath}:`, securityCheck.issues);
-      if (process.env.NODE_ENV === "production") {
-        return null;
-      }
-      console.warn("[Security] Continuing in development mode with sanitized content");
-    }
-    const safeContent = securityCheck.sanitized || content;
-    const { minutes, words } = calculateReadingTime(safeContent);
-    let finalSlug = originalSlug;
-    if (data.slug) {
-      const customSlug = data.slug.replace(/^\//, "");
-      const parts = originalSlug.split("/");
-      if (parts.length > 1) {
-        parts[parts.length - 1] = customSlug;
-        finalSlug = parts.join("/");
-      } else {
-        finalSlug = customSlug;
-      }
-    }
-    return {
-      slug: finalSlug,
-      filePath: originalSlug,
-      // Keep original file path for sidebar
-      title: data.title || originalSlug,
-      meta: {
-        ...data,
-        content: safeContent,
-        reading_time: minutes,
-        word_count: words
-      },
-      content: safeContent
-    };
-  } catch (error) {
-    console.error(`Error reading file ${filePath}:`, error);
-    return null;
-  }
-}
-function getI18nConfig() {
-  const config = getConfig();
-  const i18n = config.features?.i18n;
-  if (!i18n) return null;
-  if (typeof i18n === "boolean") {
-    return i18n ? {
-      defaultLocale: "en",
-      locales: ["en"],
-      localeNames: { en: "English" }
-    } : null;
-  }
-  return i18n;
-}
-async function getDocBySlug(slug, version = "v1.0.0", locale) {
-  try {
-    const sanitizedVersion = sanitizePath(version);
-    let sanitizedSlug = sanitizePath(slug);
-    const i18nConfig = getI18nConfig();
-    let detectedLocale = locale || i18nConfig?.defaultLocale;
-    if (i18nConfig) {
-      const parts = sanitizedSlug.split("/");
-      if (parts.length > 0 && i18nConfig.locales.includes(parts[0])) {
-        detectedLocale = parts[0];
-        sanitizedSlug = parts.slice(1).join("/");
-        if (sanitizedSlug === "") sanitizedSlug = "index";
-      }
-    }
-    const targetLocale = detectedLocale;
-    const isDefaultLocale = targetLocale === i18nConfig?.defaultLocale;
-    const basePath = import_path3.default.join(DOCS_DIR2, sanitizedVersion);
-    if (targetLocale) {
-      const localizedPath = import_path3.default.join(basePath, `${sanitizedSlug}.${targetLocale}.mdx`);
-      const doc2 = readDocFromFile(localizedPath, sanitizedSlug);
-      if (doc2) {
-        doc2.slug = i18nConfig ? `${targetLocale}/${sanitizedSlug}` : sanitizedSlug;
-        doc2.meta.locale = targetLocale;
-        return doc2;
-      }
-    }
-    const defaultPath = import_path3.default.join(basePath, `${sanitizedSlug}.mdx`);
-    const doc = readDocFromFile(defaultPath, sanitizedSlug);
-    if (doc) {
-      if (isDefaultLocale || !i18nConfig) {
-        const usePrefix = i18nConfig && (i18nConfig.prefixDefault || targetLocale !== i18nConfig.defaultLocale);
-        if (usePrefix && targetLocale) {
-          doc.slug = `${targetLocale}/${doc.slug}`;
-        }
-        doc.meta.locale = targetLocale || "en";
-        return doc;
-      }
-    }
-    return null;
-  } catch (error) {
-    console.error(`Error reading doc ${slug}:`, error);
-    return null;
-  }
-}
-async function getAllDocs(version = "v1.0.0", locale) {
-  try {
-    const versionDir = import_path3.default.join(DOCS_DIR2, version);
-    if (!import_fs2.default.existsSync(versionDir)) {
-      return [];
-    }
-    const i18nConfig = getI18nConfig();
-    const targetLocale = locale || i18nConfig?.defaultLocale || "en";
-    const mdxFiles = findMdxFiles(versionDir);
-    const categoryConfigs = getAllCategoryConfigs(version);
-    const docs = await Promise.all(
-      mdxFiles.map(async (file) => {
-        let originalFilePath = file.replace(/\.mdx$/, "");
-        let isLocalized = false;
-        let fileLocale = i18nConfig?.defaultLocale || "en";
-        if (i18nConfig) {
-          const parts = originalFilePath.split(".");
-          const lastPart = parts[parts.length - 1];
-          if (i18nConfig.locales.includes(lastPart)) {
-            fileLocale = lastPart;
-            isLocalized = true;
-            originalFilePath = parts.slice(0, -1).join(".");
-          }
-        }
-        const doc = await getDocBySlug(originalFilePath, version, isLocalized ? fileLocale : void 0);
-        if (!doc) return null;
-        doc.filePath = originalFilePath;
-        const folderPath = import_path3.default.dirname(originalFilePath).replace(/\\/g, "/");
-        if (folderPath !== ".") {
-          const categoryConfig = categoryConfigs.get(folderPath);
-          if (categoryConfig) {
-            doc.categoryLabel = categoryConfig.label;
-            doc.categoryPosition = categoryConfig.position ?? categoryConfig.sidebar_position;
-            doc.categoryCollapsible = categoryConfig.collapsible;
-            doc.categoryCollapsed = categoryConfig.collapsed;
-            doc.categoryIcon = categoryConfig.icon;
-            doc.categoryTabGroup = categoryConfig.tab_group;
-          }
-        }
-        return doc;
-      })
-    );
-    const isDevelopment3 = process.env.NODE_ENV === "development";
-    const uniqueDocs = /* @__PURE__ */ new Map();
-    const validDocs = docs.filter((doc) => doc !== null && (isDevelopment3 || !doc.meta.draft));
-    validDocs.forEach((doc) => {
-      if (locale === "all") {
-        uniqueDocs.set(doc.slug, doc);
-        return;
-      }
-      let logicalSlug = doc.slug;
-      if (i18nConfig) {
-        const parts = logicalSlug.split("/");
-        if (i18nConfig.locales.includes(parts[0])) {
-          logicalSlug = parts.slice(1).join("/");
-        }
-      }
-      const existing = uniqueDocs.get(logicalSlug);
-      if (!existing) {
-        if (doc.meta.locale === targetLocale) {
-          uniqueDocs.set(logicalSlug, doc);
-        } else if (doc.meta.locale === i18nConfig?.defaultLocale) {
-          uniqueDocs.set(logicalSlug, doc);
-        }
-      } else {
-        if (doc.meta.locale === targetLocale && existing.meta.locale !== targetLocale) {
-          uniqueDocs.set(logicalSlug, doc);
-        }
-      }
-    });
-    return Array.from(uniqueDocs.values()).sort((a, b) => {
-      const orderA = a.meta.sidebar_position ?? a.meta.order ?? 999;
-      const orderB = b.meta.sidebar_position ?? b.meta.order ?? 999;
-      return orderA - orderB;
-    });
-  } catch (error) {
-    console.error(`Error getting all docs for version ${version}:`, error);
-    return [];
-  }
-}
-function flattenSidebarOrder(rootGroups, standalone) {
-  const flatDocs = [];
-  const flattenGroup = (group) => {
-    const sortedChildren = sortSidebarGroups(group.children);
-    const sortedItems = sortSidebarItems(group.items);
-    const merged = [
-      ...sortedChildren.map(([, childGroup]) => ({
-        type: "group",
-        group: childGroup,
-        position: childGroup.position
-      })),
-      ...sortedItems.map((doc) => ({
-        type: "item",
-        doc,
-        position: doc.meta.sidebar_position ?? doc.meta.order ?? 999
-      }))
-    ];
-    merged.sort((a, b) => a.position - b.position);
-    merged.forEach((item) => {
-      if (item.type === "group") {
-        flattenGroup(item.group);
-      } else {
-        flatDocs.push(item.doc);
-      }
-    });
-  };
-  sortSidebarItems(standalone).forEach((doc) => {
-    flatDocs.push(doc);
-  });
-  const sortedRootGroups = sortSidebarGroups(rootGroups);
-  sortedRootGroups.forEach(([, group]) => {
-    flattenGroup(group);
-  });
-  return flatDocs;
-}
-function getAdjacentDocs(currentSlug, allDocs) {
-  const { rootGroups, standalone } = buildSidebarStructure(allDocs);
-  const orderedDocs = flattenSidebarOrder(rootGroups, standalone);
-  const currentIndex = orderedDocs.findIndex((doc) => doc.slug === currentSlug);
-  if (currentIndex === -1) {
-    return {};
-  }
-  const currentDoc = orderedDocs[currentIndex];
-  const currentTabGroup = currentDoc.meta?.tab_group || currentDoc.categoryTabGroup;
-  const filteredDocs = orderedDocs.filter((doc) => {
-    const docTabGroup = doc.meta?.tab_group || doc.categoryTabGroup;
-    if (currentTabGroup) {
-      return docTabGroup === currentTabGroup;
-    }
-    return !docTabGroup;
-  });
-  const filteredIndex = filteredDocs.findIndex((doc) => doc.slug === currentSlug);
-  if (filteredIndex === -1) {
-    return {};
-  }
-  return {
-    previous: filteredIndex > 0 ? filteredDocs[filteredIndex - 1] : void 0,
-    next: filteredIndex < filteredDocs.length - 1 ? filteredDocs[filteredIndex + 1] : void 0
-  };
-}
-function extractTableOfContents(content) {
-  const headingRegex = /^(#{2,3})\s+(.+)$/gm;
-  const toc = [];
-  let match;
-  while ((match = headingRegex.exec(content)) !== null) {
-    const level = match[1].length;
-    const text = match[2];
-    const id = text.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/^-|-$/g, "");
-    toc.push({ id, title: text, level });
-  }
-  return toc;
-}
-function isCategoryPage(slug, allDocs) {
-  return allDocs.some((doc) => {
-    const parts = doc.slug.split("/");
-    const docParent = parts.slice(0, -1).join("/");
-    return docParent === slug && doc.slug !== slug;
-  });
-}
-
-// src/lib/mdx-cache.ts
-var import_fs3 = require("fs");
-var import_path4 = require("path");
-
-// src/lib/dev-utils.ts
-var isDevelopment = process.env.NODE_ENV === "development";
-var PerfTimer = class {
-  constructor(label) {
-    this.label = label;
-    this.startTime = isDevelopment ? performance.now() : 0;
-  }
-  end() {
-    if (!isDevelopment) return;
-    const duration = performance.now() - this.startTime;
-    const color = duration > 1e3 ? "\x1B[31m" : duration > 500 ? "\x1B[33m" : "\x1B[32m";
-    const reset = "\x1B[0m";
-    console.log(`${color}\u23F1\uFE0F  ${this.label}: ${duration.toFixed(2)}ms${reset}`);
-  }
-};
-function logFsOperation(operation, path4, details) {
-  if (!isDevelopment) return;
-  console.log(`\u{1F4C1} [FS] ${operation}: ${path4}`, details || "");
-}
-function logCacheOperation(operation, key) {
-  if (!isDevelopment) return;
-  const emoji = operation === "hit" ? "\u2705" : operation === "miss" ? "\u274C" : "\u{1F504}";
-  console.log(`${emoji} [Cache] ${operation}: ${key}`);
-}
-function logMemoryUsage(label) {
-  if (!isDevelopment) return;
-  const used = process.memoryUsage();
-  const prefix = label ? `[${label}] ` : "";
-  console.log(`\u{1F4BE} ${prefix}Memory Usage:`, {
-    rss: `${Math.round(used.rss / 1024 / 1024)}MB`,
-    heapTotal: `${Math.round(used.heapTotal / 1024 / 1024)}MB`,
-    heapUsed: `${Math.round(used.heapUsed / 1024 / 1024)}MB`
-  });
-}
-function debugLog(label, data) {
-  if (!isDevelopment) return;
-  console.log(`
-\u{1F50D} ${label}:`);
-  console.dir(data, { depth: null, colors: true });
-  console.log("");
-}
-
-// src/lib/mdx-cache.ts
-var isDevelopment2 = process.env.NODE_ENV === "development";
-var versionsCache = {
-  data: null,
-  timestamp: 0
-};
-var allDocsCache = /* @__PURE__ */ new Map();
-var docBySlugCache = /* @__PURE__ */ new Map();
-var CACHE_TTL = isDevelopment2 ? 5e3 : 6e4;
-var watchersInitialized = false;
-function initializeWatchers() {
-  if (!isDevelopment2 || watchersInitialized) return;
-  watchersInitialized = true;
-  const docsPath = (0, import_path4.join)(process.cwd(), "docs");
-  try {
-    (0, import_fs3.watch)(docsPath, { recursive: true }, (eventType, filename) => {
-      if (!filename) return;
-      if (filename.endsWith(".mdx") || filename.endsWith(".json")) {
-        const parts = filename.split(/[/\\]/);
-        const version = parts[0];
-        allDocsCache.delete(version);
-        const cacheKeysToDelete = [];
-        docBySlugCache.forEach((_, key) => {
-          if (key.startsWith(`${version}:`)) {
-            cacheKeysToDelete.push(key);
-          }
-        });
-        cacheKeysToDelete.forEach((key) => docBySlugCache.delete(key));
-        if (eventType === "rename") {
-          versionsCache.data = null;
-        }
-        console.log(`[MDX Cache] Invalidated cache for: ${filename}`);
-      }
-    });
-    console.log("[MDX Cache] File watchers initialized");
-  } catch (error) {
-    console.error("[MDX Cache] Failed to initialize watchers:", error);
-  }
-}
-function isCacheValid(timestamp) {
-  return Date.now() - timestamp < CACHE_TTL;
-}
-function getCachedVersions() {
-  initializeWatchers();
-  if (versionsCache.data && isCacheValid(versionsCache.timestamp)) {
-    logCacheOperation("hit", "versions");
-    return versionsCache.data;
-  }
-  logCacheOperation("miss", "versions");
-  const timer = new PerfTimer("getVersions");
-  const versions = getVersions();
-  timer.end();
-  versionsCache.data = versions;
-  versionsCache.timestamp = Date.now();
-  return versions;
-}
-async function getCachedAllDocs(version = "v1.0.0", locale) {
-  initializeWatchers();
-  const cacheKey = locale ? `${version}:${locale}` : version;
-  const cached = allDocsCache.get(cacheKey);
-  if (cached && isCacheValid(cached.timestamp)) {
-    logCacheOperation("hit", `getAllDocs:${cacheKey}`);
-    return cached.data;
-  }
-  logCacheOperation("miss", `getAllDocs:${cacheKey}`);
-  const timer = new PerfTimer(`getAllDocs(${cacheKey})`);
-  const docs = await getAllDocs(version, locale);
-  timer.end();
-  allDocsCache.set(cacheKey, {
-    data: docs,
-    timestamp: Date.now()
-  });
-  return docs;
-}
-async function getCachedDocBySlug(slug, version = "v1.0.0") {
-  initializeWatchers();
-  const cacheKey = `${version}:${slug}`;
-  const cached = docBySlugCache.get(cacheKey);
-  if (cached && isCacheValid(cached.timestamp)) {
-    logCacheOperation("hit", `getDocBySlug:${cacheKey}`);
-    return cached.data;
-  }
-  logCacheOperation("miss", `getDocBySlug:${cacheKey}`);
-  const timer = new PerfTimer(`getDocBySlug(${slug})`);
-  const doc = await getDocBySlug(slug, version);
-  timer.end();
-  docBySlugCache.set(cacheKey, {
-    data: doc,
-    timestamp: Date.now()
-  });
-  return doc;
-}
-function clearAllCaches() {
-  versionsCache.data = null;
-  allDocsCache.clear();
-  docBySlugCache.clear();
-  console.log("[MDX Cache] All caches cleared");
-}
-function getCacheStats() {
-  return {
-    versions: {
-      cached: versionsCache.data !== null,
-      age: versionsCache.timestamp ? Date.now() - versionsCache.timestamp : 0
-    },
-    allDocs: {
-      entries: allDocsCache.size,
-      versions: Array.from(allDocsCache.keys())
-    },
-    docBySlug: {
-      entries: docBySlugCache.size
-    }
-  };
-}
-
-// src/lib/toc.ts
-function extractHeadings(html) {
-  const headingRegex = /<h([2-3])[^>]*id="([^"]*)"[^>]*>(.*?)<\/h\1>/g;
-  const toc = [];
-  let match;
-  while ((match = headingRegex.exec(html)) !== null) {
-    const level = Number.parseInt(match[1]);
-    const id = match[2];
-    const title = match[3].replace(/<[^>]*>/g, "");
-    toc.push({ id, title, level });
-  }
-  return toc;
-}
-
-// src/lib/parsers/specra-parser.ts
-var SpecraParser = class {
-  validate(input) {
-    return typeof input === "object" && input !== null && "endpoints" in input && Array.isArray(input.endpoints);
-  }
-  parse(input) {
-    if (!this.validate(input)) {
-      throw new Error("Invalid Specra API spec format");
-    }
-    return input;
-  }
-};
-
-// src/lib/parsers/openapi-parser.ts
-var OpenApiParser = class {
-  validate(input) {
-    return typeof input === "object" && input !== null && ("openapi" in input || "swagger" in input) && "paths" in input;
-  }
-  parse(input) {
-    if (!this.validate(input)) {
-      throw new Error("Invalid OpenAPI spec format");
-    }
-    const baseUrl = this.extractBaseUrl(input);
-    const endpoints = [];
-    for (const [path4, pathItem] of Object.entries(input.paths || {})) {
-      const methods = ["get", "post", "put", "patch", "delete"];
-      for (const method of methods) {
-        const operation = pathItem[method];
-        if (!operation) continue;
-        const endpoint = this.parseOperation(path4, method.toUpperCase(), operation, input);
-        endpoints.push(endpoint);
-      }
-    }
-    return {
-      version: input.info?.version,
-      title: input.info?.title,
-      description: input.info?.description,
-      baseUrl,
-      auth: this.extractAuth(input),
-      endpoints
-    };
-  }
-  extractBaseUrl(spec) {
-    if (spec.servers && spec.servers.length > 0) {
-      return spec.servers[0].url;
-    }
-    if (spec.host) {
-      const scheme = spec.schemes?.[0] || "https";
-      const basePath = spec.basePath || "";
-      return `${scheme}://${spec.host}${basePath}`;
-    }
-    return "";
-  }
-  extractAuth(spec) {
-    const securitySchemes = spec.components?.securitySchemes || spec.securityDefinitions;
-    if (!securitySchemes) return void 0;
-    const firstScheme = Object.values(securitySchemes)[0];
-    if (!firstScheme) return void 0;
-    if (firstScheme.type === "http" && firstScheme.scheme === "bearer") {
-      return {
-        type: "bearer",
-        description: firstScheme.description,
-        tokenPrefix: "Bearer"
-      };
-    }
-    if (firstScheme.type === "apiKey") {
-      return {
-        type: "apiKey",
-        description: firstScheme.description,
-        headerName: firstScheme.name || "X-API-Key"
-      };
-    }
-    if (firstScheme.type === "http" && firstScheme.scheme === "basic") {
-      return {
-        type: "basic",
-        description: firstScheme.description
-      };
-    }
-    return void 0;
-  }
-  parseOperation(path4, method, operation, spec) {
-    const endpoint = {
-      title: operation.summary || operation.operationId || `${method} ${path4}`,
-      method,
-      path: this.convertPathParams(path4),
-      description: operation.description
-    };
-    const params = this.parseParameters(operation.parameters || [], spec);
-    if (params.path.length > 0) endpoint.pathParams = params.path;
-    if (params.query.length > 0) endpoint.queryParams = params.query;
-    if (params.header.length > 0) {
-      endpoint.headers = params.header.map((p) => ({
-        name: p.name,
-        value: p.example || "",
-        description: p.description
-      }));
-    }
-    if (operation.requestBody) {
-      endpoint.body = this.parseRequestBody(operation.requestBody, spec);
-    }
-    const responses = this.parseResponses(operation.responses || {}, spec);
-    if (responses.success) endpoint.successResponse = responses.success;
-    if (responses.errors.length > 0) endpoint.errorResponses = responses.errors;
-    return endpoint;
-  }
-  convertPathParams(path4) {
-    return path4.replace(/\{([^}]+)\}/g, ":$1");
-  }
-  parseParameters(parameters, spec) {
-    const result = { path: [], query: [], header: [] };
-    for (const param of parameters) {
-      const resolved = param.$ref ? this.resolveRef(param.$ref, spec) : param;
-      const apiParam = {
-        name: resolved.name,
-        type: resolved.schema?.type || resolved.type || "string",
-        required: resolved.required,
-        description: resolved.description,
-        example: resolved.example || resolved.schema?.example
-      };
-      if (resolved.in === "path") result.path.push(apiParam);
-      else if (resolved.in === "query") result.query.push(apiParam);
-      else if (resolved.in === "header") result.header.push(apiParam);
-    }
-    return result;
-  }
-  parseRequestBody(requestBody, spec) {
-    const content = requestBody.content?.["application/json"];
-    if (!content) return void 0;
-    return {
-      description: requestBody.description,
-      example: content.example || this.generateExample(content.schema, spec),
-      schema: content.schema
-    };
-  }
-  parseResponses(responses, spec) {
-    const result = { errors: [] };
-    for (const [statusCode, response] of Object.entries(responses)) {
-      const status = parseInt(statusCode);
-      if (isNaN(status)) continue;
-      const resolved = response.$ref ? this.resolveRef(response.$ref, spec) : response;
-      const content = resolved.content?.["application/json"];
-      const apiResponse = {
-        status,
-        description: resolved.description,
-        example: content?.example || this.generateExample(content?.schema, spec),
-        schema: content?.schema
-      };
-      if (status >= 200 && status < 300) {
-        result.success = apiResponse;
-      } else {
-        result.errors.push(apiResponse);
-      }
-    }
-    return result;
-  }
-  generateExample(schema, spec) {
-    if (!schema) return void 0;
-    if (schema.$ref) schema = this.resolveRef(schema.$ref, spec);
-    if (schema.example) return schema.example;
-    if (schema.type === "object" && schema.properties) {
-      const example = {};
-      for (const [key, prop] of Object.entries(schema.properties)) {
-        example[key] = this.generateExample(prop, spec);
-      }
-      return example;
-    }
-    if (schema.type === "array" && schema.items) {
-      return [this.generateExample(schema.items, spec)];
-    }
-    const defaults = {
-      string: "string",
-      number: 0,
-      integer: 0,
-      boolean: false,
-      object: {},
-      array: []
-    };
-    return defaults[schema.type] || null;
-  }
-  resolveRef(ref, spec) {
-    const path4 = ref.replace(/^#\//, "").split("/");
-    let current = spec;
-    for (const segment of path4) {
-      current = current[segment];
-      if (!current) return {};
-    }
-    return current;
-  }
-};
-
-// src/lib/parsers/postman-parser.ts
-var PostmanParser = class {
-  validate(input) {
-    return typeof input === "object" && input !== null && "info" in input && input.info?.schema?.includes("v2");
-  }
-  parse(input) {
-    if (!this.validate(input)) {
-      throw new Error("Invalid Postman Collection format (requires v2.0 or v2.1)");
-    }
-    const baseUrl = this.extractBaseUrl(input);
-    const endpoints = [];
-    this.parseItems(input.item || [], endpoints, baseUrl, input);
-    return {
-      version: input.info?.version,
-      title: input.info?.name,
-      description: input.info?.description,
-      baseUrl,
-      auth: this.extractAuth(input.auth),
-      globalHeaders: this.extractGlobalHeaders(input),
-      endpoints
-    };
-  }
-  extractBaseUrl(collection) {
-    const baseUrlVar = collection.variable?.find(
-      (v) => v.key === "baseUrl" || v.key === "base_url" || v.key === "url"
-    );
-    if (baseUrlVar) return baseUrlVar.value;
-    if (collection.item && collection.item.length > 0) {
-      const firstRequest = this.findFirstRequest(collection.item);
-      if (firstRequest?.request?.url) {
-        const url = this.parseUrl(firstRequest.request.url);
-        if (url.host) {
-          return `${url.protocol}://${url.host.join(".")}`;
-        }
-      }
-    }
-    return "";
-  }
-  findFirstRequest(items) {
-    for (const item of items) {
-      if (item.request) return item;
-      if (item.item) {
-        const found = this.findFirstRequest(item.item);
-        if (found) return found;
-      }
-    }
-    return null;
-  }
-  extractAuth(auth) {
-    if (!auth) return void 0;
-    if (auth.type === "bearer") {
-      return {
-        type: "bearer",
-        tokenPrefix: "Bearer"
-      };
-    }
-    if (auth.type === "apikey") {
-      const keyData = auth.apikey?.find((a) => a.key === "key");
-      const keyName = keyData?.value || "X-API-Key";
-      return {
-        type: "apiKey",
-        headerName: keyName
-      };
-    }
-    if (auth.type === "basic") {
-      return {
-        type: "basic"
-      };
-    }
-    return void 0;
-  }
-  extractGlobalHeaders(collection) {
-    return [];
-  }
-  parseItems(items, endpoints, baseUrl, collection) {
-    for (const item of items) {
-      if (item.item && Array.isArray(item.item)) {
-        this.parseItems(item.item, endpoints, baseUrl, collection);
-      } else if (item.request) {
-        const endpoint = this.parseRequest(item, baseUrl, collection);
-        endpoints.push(endpoint);
-      }
-    }
-  }
-  parseRequest(item, baseUrl, collection) {
-    const request = item.request;
-    const url = this.parseUrl(request.url);
-    const endpoint = {
-      title: item.name,
-      method: request.method.toUpperCase(),
-      path: this.buildPath(url, baseUrl),
-      description: item.request.description || item.description
-    };
-    const params = this.parseUrlParams(url);
-    if (params.path.length > 0) endpoint.pathParams = params.path;
-    if (params.query.length > 0) endpoint.queryParams = params.query;
-    if (request.header && request.header.length > 0) {
-      endpoint.headers = request.header.filter((h) => !h.disabled).map((h) => ({
-        name: h.key,
-        value: h.value || "",
-        description: h.description
-      }));
-    }
-    if (request.body) {
-      endpoint.body = this.parseBody(request.body);
-    }
-    const responses = this.parseResponses(item.response || []);
-    if (responses.success) endpoint.successResponse = responses.success;
-    if (responses.errors.length > 0) endpoint.errorResponses = responses.errors;
-    return endpoint;
-  }
-  parseUrl(url) {
-    if (typeof url === "string") {
-      const urlObj = new URL(url);
-      return {
-        protocol: urlObj.protocol.replace(":", ""),
-        host: urlObj.hostname.split("."),
-        path: urlObj.pathname.split("/").filter(Boolean),
-        query: [],
-        variable: []
-      };
-    }
-    return {
-      protocol: url.protocol || "https",
-      host: url.host || [],
-      path: url.path || [],
-      query: url.query || [],
-      variable: url.variable || []
-    };
-  }
-  buildPath(url, baseUrl) {
-    let path4 = "/";
-    if (url.path && url.path.length > 0) {
-      path4 += url.path.join("/");
-    }
-    path4 = path4.replace(/\{\{([^}]+)\}\}/g, ":$1");
-    return path4;
-  }
-  parseUrlParams(url) {
-    const result = { path: [], query: [] };
-    if (url.variable && url.variable.length > 0) {
-      for (const v of url.variable) {
-        result.path.push({
-          name: v.key,
-          type: v.type || "string",
-          description: v.description,
-          example: v.value
-        });
-      }
-    }
-    if (url.path && url.path.length > 0) {
-      for (const segment of url.path) {
-        if (segment.startsWith(":")) {
-          const paramName = segment.slice(1);
-          if (!result.path.find((p) => p.name === paramName)) {
-            result.path.push({
-              name: paramName,
-              type: "string"
-            });
-          }
-        }
-      }
-    }
-    if (url.query && url.query.length > 0) {
-      for (const q of url.query) {
-        if (q.disabled) continue;
-        result.query.push({
-          name: q.key,
-          type: "string",
-          description: q.description,
-          example: q.value
-        });
-      }
-    }
-    return result;
-  }
-  parseBody(body) {
-    if (!body) return void 0;
-    let example;
-    let description = body.description;
-    if (body.mode === "raw") {
-      try {
-        example = JSON.parse(body.raw);
-      } catch {
-        example = body.raw;
-      }
-    } else if (body.mode === "formdata" || body.mode === "urlencoded") {
-      example = {};
-      for (const item of body[body.mode] || []) {
-        if (!item.disabled) {
-          example[item.key] = item.value;
-        }
-      }
-    }
-    return {
-      description,
-      example
-    };
-  }
-  parseResponses(responses) {
-    const result = { errors: [] };
-    for (const response of responses) {
-      let example;
-      try {
-        example = JSON.parse(response.body);
-      } catch {
-        example = response.body;
-      }
-      const apiResponse = {
-        status: response.code || 200,
-        description: response.name,
-        example
-      };
-      if (apiResponse.status >= 200 && apiResponse.status < 300) {
-        if (!result.success) result.success = apiResponse;
-      } else {
-        result.errors.push(apiResponse);
-      }
-    }
-    return result;
-  }
-};
-
-// src/lib/parsers/index.ts
-var parsers = /* @__PURE__ */ new Map([
-  ["specra", new SpecraParser()],
-  ["openapi", new OpenApiParser()],
-  ["postman", new PostmanParser()]
-]);
-function detectParserType(input) {
-  if (!input || typeof input !== "object") {
-    throw new Error("Invalid API spec: input must be an object");
-  }
-  if (input.info?.schema?.includes("v2")) {
-    return "postman";
-  }
-  if (input.openapi || input.swagger) {
-    return "openapi";
-  }
-  if (input.endpoints && Array.isArray(input.endpoints)) {
-    return "specra";
-  }
-  throw new Error(
-    "Unable to auto-detect API spec format. Supported formats: Specra, OpenAPI 3.x, Postman Collection v2.x"
-  );
-}
-function parseApiSpec(input, parserType = "auto") {
-  const actualType = parserType === "auto" ? detectParserType(input) : parserType;
-  const parser = parsers.get(actualType);
-  if (!parser) {
-    throw new Error(`Unknown parser type: ${actualType}`);
-  }
-  if (!parser.validate(input)) {
-    throw new Error(`Input does not match ${actualType} format`);
-  }
-  return parser.parse(input);
-}
-
-// src/lib/utils.ts
-var import_clsx = require("clsx");
-var import_tailwind_merge = require("tailwind-merge");
-function cn(...inputs) {
-  return (0, import_tailwind_merge.twMerge)((0, import_clsx.clsx)(inputs));
-}
-function getAssetPath(path4) {
-  const basePath = process.env.NEXT_PUBLIC_BASE_PATH || process.env.__NEXT_ROUTER_BASEPATH || "";
-  const normalizedPath = path4.startsWith("/") ? path4 : `/${path4}`;
-  if (basePath) {
-    const normalizedBase = basePath.startsWith("/") ? basePath : `/${basePath}`;
-    const cleanBase = normalizedBase.replace(/\/$/, "");
-    return `${cleanBase}${normalizedPath}`;
-  }
-  return normalizedPath;
-}
-
-// src/lib/redirects.ts
-async function buildRedirectMappings() {
-  const versions = getVersions();
-  const redirects = [];
-  for (const version of versions) {
-    const docs = await getAllDocs(version);
-    for (const doc of docs) {
-      if (doc.meta.redirect_from && Array.isArray(doc.meta.redirect_from)) {
-        for (const oldPath of doc.meta.redirect_from) {
-          redirects.push({
-            from: oldPath,
-            to: `/docs/${version}/${doc.slug}`
-          });
-        }
-      }
-    }
-  }
-  return redirects;
-}
-async function findRedirect(path4) {
-  const redirects = await buildRedirectMappings();
-  const redirect = redirects.find((r) => r.from === path4);
-  return redirect ? redirect.to : null;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CSP_DIRECTIVES,
-  OpenApiParser,
-  PerfTimer,
-  PostmanParser,
-  SAFE_MDX_COMPONENTS,
-  SpecraParser,
-  buildRedirectMappings,
-  buildSidebarStructure,
-  clearAllCaches,
-  cn,
-  debugLog,
-  defaultConfig,
-  detectParserType,
-  extractHeadings,
-  extractTableOfContents,
-  findRedirect,
-  generateCSPHeader,
-  getAdjacentDocs,
-  getAllCategoryConfigs,
-  getAllDocs,
-  getAssetPath,
-  getCacheStats,
-  getCachedAllDocs,
-  getCachedDocBySlug,
-  getCachedVersions,
-  getCategoryConfig,
-  getConfig,
-  getConfigValue,
-  getDocBySlug,
-  getI18nConfig,
-  getVersions,
-  initConfig,
-  isCategoryPage,
-  loadConfig,
-  logCacheOperation,
-  logFsOperation,
-  logMemoryUsage,
-  parseApiSpec,
-  processContentWithEnv,
-  reloadConfig,
-  replaceEnvVariables,
-  sanitizeMDXContent,
-  sanitizePath,
-  scanMDXForDangerousPatterns,
-  sortSidebarGroups,
-  sortSidebarItems,
-  validateConfig,
-  validateMDXComponents,
-  validateMDXSecurity,
-  validatePathWithinDirectory
-});
-//# sourceMappingURL=index.js.map