@bfra.me/doc-sync 0.1.0

package/lib/chunk-ROLA7SBB.js

@@ -0,0 +1,12 @@
+// src/types.ts
+var SENTINEL_MARKERS = {
+  AUTO_START: "{/* AUTO-GENERATED-START */}",
+  AUTO_END: "{/* AUTO-GENERATED-END */}",
+  MANUAL_START: "{/* MANUAL-CONTENT-START */}",
+  MANUAL_END: "{/* MANUAL-CONTENT-END */}"
+};
+
+export {
+  SENTINEL_MARKERS
+};
+//# sourceMappingURL=chunk-ROLA7SBB.js.map

package/lib/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/lib/cli/index.js

@@ -0,0 +1,397 @@
+#!/usr/bin/env node
+import {
+  createPackageScanner,
+  createSyncOrchestrator,
+  createValidationPipeline
+} from "../chunk-DR6UG237.js";
+import {
+  generateMDXDocument,
+  mergeContent
+} from "../chunk-G5KKGJYO.js";
+import "../chunk-ROLA7SBB.js";
+import {
+  getUnscopedName
+} from "../chunk-6NKAJT2M.js";
+
+// src/cli/index.ts
+import process4 from "process";
+import { cac } from "cac";
+
+// src/cli/commands/sync.ts
+import path from "path";
+import process from "process";
+
+// src/cli/ui.ts
+import * as p from "@clack/prompts";
+import { consola } from "consola";
+function createLogger(options) {
+  const { verbose = false, quiet = false } = options;
+  return {
+    info(message) {
+      if (!quiet) {
+        p.log.info(message);
+      }
+    },
+    success(message) {
+      if (!quiet) {
+        p.log.success(message);
+      }
+    },
+    warn(message) {
+      p.log.warn(message);
+    },
+    error(message) {
+      p.log.error(message);
+    },
+    debug(message) {
+      if (verbose) {
+        consola.debug(message);
+      }
+    }
+  };
+}
+function showIntro(title) {
+  p.intro(title);
+}
+function showOutro(message) {
+  p.outro(message);
+}
+function createSpinner() {
+  return p.spinner();
+}
+async function selectPackages(availablePackages) {
+  if (availablePackages.length === 0) {
+    return [];
+  }
+  const options = availablePackages.map((pkg) => ({
+    value: pkg.value,
+    label: pkg.label,
+    hint: pkg.hint
+  }));
+  const selected = await p.multiselect({
+    message: "Select packages to sync",
+    options,
+    required: false
+  });
+  return selected;
+}
+function handleCancel(value) {
+  return p.isCancel(value);
+}
+function showCancel(message = "Operation cancelled.") {
+  p.cancel(message);
+}
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.round(ms % 6e4 / 1e3);
+  return `${minutes}m ${seconds}s`;
+}
+function formatPackageList(packages) {
+  if (packages.length === 0) {
+    return "no packages";
+  }
+  if (packages.length === 1) {
+    return packages[0] ?? "unknown";
+  }
+  if (packages.length <= 3) {
+    return packages.join(", ");
+  }
+  return `${packages.slice(0, 3).join(", ")} and ${packages.length - 3} more`;
+}
+function createProgressCallback(options) {
+  const logger = createLogger(options);
+  return (message) => {
+    logger.debug(message);
+  };
+}
+
+// src/cli/commands/sync.ts
+async function runSync(packages, options) {
+  const logger = createLogger(options);
+  const rootDir = path.resolve(options.root);
+  const outputDir = path.join(rootDir, "docs", "src", "content", "docs", "packages");
+  if (options.quiet !== true) {
+    showIntro("\u{1F4DA} doc-sync");
+  }
+  let selectedPackages = packages;
+  if (options.interactive === true && packages.length === 0) {
+    const scanner = createPackageScanner({
+      rootDir,
+      parseSourceFiles: false,
+      parseReadme: false
+    });
+    const scanResult = await scanner.scan();
+    const availablePackages = scanResult.packages.map((pkg) => ({
+      value: pkg.info.name,
+      label: pkg.info.name,
+      hint: pkg.needsDocumentation ? "needs docs" : "up to date"
+    }));
+    const selection = await selectPackages(availablePackages);
+    if (handleCancel(selection)) {
+      showCancel();
+      process.exit(0);
+    }
+    selectedPackages = selection;
+  }
+  const spinner2 = options.quiet === true ? void 0 : createSpinner();
+  const errors = [];
+  const orchestrator = createSyncOrchestrator({
+    config: {
+      rootDir,
+      outputDir,
+      includePatterns: ["packages/*"],
+      excludePatterns: []
+    },
+    dryRun: options.dryRun ?? false,
+    verbose: options.verbose ?? false,
+    onProgress: createProgressCallback(options),
+    onError(error) {
+      errors.push(error);
+      logger.error(`Error syncing ${error.packageName ?? "unknown"}: ${error.message}`);
+    }
+  });
+  const actionPrefix = options.dryRun === true ? "[DRY RUN] " : "";
+  if (selectedPackages.length > 0) {
+    spinner2?.start(`${actionPrefix}Syncing ${formatPackageList(selectedPackages)}...`);
+    const result = await orchestrator.syncPackages(selectedPackages);
+    spinner2?.stop(`${actionPrefix}Sync complete`);
+    reportSyncResult(result, logger, options);
+  } else {
+    spinner2?.start(`${actionPrefix}Syncing all packages...`);
+    const result = await orchestrator.syncAll();
+    spinner2?.stop(`${actionPrefix}Sync complete`);
+    reportSyncResult(result, logger, options);
+  }
+  if (errors.length > 0) {
+    if (options.quiet !== true) {
+      showOutro(`\u26A0\uFE0F  Completed with ${errors.length} error${errors.length === 1 ? "" : "s"}`);
+    }
+    process.exit(1);
+  }
+  if (options.quiet !== true) {
+    showOutro("\u2728 Documentation sync complete!");
+  }
+}
+function reportSyncResult(result, logger, options) {
+  const { successCount, failureCount, unchangedCount, durationMs, details } = result;
+  if (options.verbose === true) {
+    for (const detail of details) {
+      switch (detail.action) {
+        case "created":
+          logger.success(`Created: ${detail.packageName}`);
+          break;
+        case "updated":
+          logger.info(`Updated: ${detail.packageName}`);
+          break;
+        case "unchanged":
+          logger.debug(`Unchanged: ${detail.packageName}`);
+          break;
+      }
+    }
+  }
+  const summary = [
+    successCount > 0 ? `${successCount} synced` : null,
+    unchangedCount > 0 ? `${unchangedCount} unchanged` : null,
+    failureCount > 0 ? `${failureCount} failed` : null
+  ].filter(Boolean).join(", ");
+  logger.info(`${summary} in ${formatDuration(durationMs)}`);
+}
+
+// src/cli/commands/validate.ts
+import fs from "fs/promises";
+import path2 from "path";
+import process2 from "process";
+async function runValidate(packages, options) {
+  const logger = createLogger(options);
+  const rootDir = path2.resolve(options.root);
+  const outputDir = path2.join(rootDir, "docs", "src", "content", "docs", "packages");
+  if (options.quiet !== true) {
+    showIntro("\u{1F50D} doc-sync validate");
+  }
+  const startTime = Date.now();
+  const spinner2 = options.quiet === true ? void 0 : createSpinner();
+  const validationResults = [];
+  spinner2?.start("Scanning packages...");
+  const scanner = createPackageScanner({
+    rootDir,
+    parseSourceFiles: true,
+    parseReadme: true
+  });
+  const validationPipeline = createValidationPipeline();
+  const scanResult = await scanner.scan();
+  spinner2?.stop(`Found ${scanResult.packages.length} packages`);
+  const packagesToValidate = packages.length > 0 ? scanResult.packages.filter((pkg) => packages.includes(pkg.info.name)) : scanResult.packages;
+  spinner2?.start(`Validating ${packagesToValidate.length} packages...`);
+  for (const pkg of packagesToValidate) {
+    const issues = [];
+    let isValid = true;
+    const docPath = buildDocPath(pkg.info.name, outputDir);
+    try {
+      await fs.access(docPath);
+      const existingContent = await fs.readFile(docPath, "utf-8");
+      const contentValidation = validationPipeline.validateContent(existingContent);
+      if (!contentValidation.valid) {
+        isValid = false;
+        for (const error of contentValidation.errors) {
+          issues.push(`MDX error: ${error.message}`);
+        }
+      }
+      const docResult = generateMDXDocument(pkg.info, pkg.readme, pkg.api);
+      if (docResult.success) {
+        const generatedContent = docResult.data.rendered;
+        const mergedResult = mergeContent(existingContent, generatedContent);
+        if (mergedResult.success) {
+          if (normalizeContent(existingContent) !== normalizeContent(mergedResult.data.content)) {
+            isValid = false;
+            issues.push("Documentation is out of date with source");
+          }
+        } else if (normalizeContent(existingContent) !== normalizeContent(generatedContent)) {
+          isValid = false;
+          issues.push("Documentation is out of date with source");
+        }
+      } else {
+        issues.push(`Generation failed: ${docResult.error.message}`);
+      }
+    } catch {
+      isValid = false;
+      issues.push("Documentation file does not exist");
+    }
+    validationResults.push({
+      packageName: pkg.info.name,
+      isValid,
+      issues
+    });
+    if (options.verbose === true) {
+      if (isValid) {
+        logger.success(`\u2713 ${pkg.info.name}`);
+      } else {
+        logger.warn(`\u2717 ${pkg.info.name}: ${issues.join(", ")}`);
+      }
+    }
+  }
+  spinner2?.stop("Validation complete");
+  const validCount = validationResults.filter((r) => r.isValid).length;
+  const invalidCount = validationResults.filter((r) => !r.isValid).length;
+  const durationMs = Date.now() - startTime;
+  if (invalidCount > 0) {
+    logger.warn(`Found ${invalidCount} package${invalidCount === 1 ? "" : "s"} with issues:`);
+    for (const result of validationResults) {
+      if (!result.isValid) {
+        logger.error(`  ${result.packageName}:`);
+        for (const issue of result.issues) {
+          logger.error(`    - ${issue}`);
+        }
+      }
+    }
+  }
+  logger.info(`${validCount} valid, ${invalidCount} invalid in ${formatDuration(durationMs)}`);
+  if (options.quiet !== true) {
+    if (invalidCount > 0) {
+      showOutro(
+        `\u26A0\uFE0F  ${invalidCount} package${invalidCount === 1 ? "" : "s"} need${invalidCount === 1 ? "s" : ""} attention`
+      );
+    } else {
+      showOutro("\u2728 All documentation is up to date!");
+    }
+  }
+  if (invalidCount > 0) {
+    process2.exit(1);
+  }
+}
+function buildDocPath(packageName, outputDir) {
+  const slug = getUnscopedName(packageName).toLowerCase().replaceAll(/[^a-z0-9-]/g, "-");
+  return path2.join(outputDir, `${slug}.mdx`);
+}
+function normalizeContent(content) {
+  return content.replaceAll("\r\n", "\n").replaceAll(/\s+$/gm, "").trim();
+}
+
+// src/cli/commands/watch.ts
+import path3 from "path";
+import process3 from "process";
+async function runWatch(packages, options) {
+  const logger = createLogger(options);
+  const rootDir = path3.resolve(options.root);
+  const outputDir = path3.join(rootDir, "docs", "src", "content", "docs", "packages");
+  if (options.quiet !== true) {
+    showIntro("\u{1F441}\uFE0F  doc-sync watch");
+  }
+  const spinner2 = options.quiet === true ? void 0 : createSpinner();
+  const orchestrator = createSyncOrchestrator({
+    config: {
+      rootDir,
+      outputDir,
+      includePatterns: ["packages/*"],
+      excludePatterns: [],
+      watch: true,
+      debounceMs: 300
+    },
+    dryRun: options.dryRun ?? false,
+    verbose: options.verbose ?? false,
+    onProgress: createProgressCallback(options),
+    onError(error) {
+      logger.error(`Error: ${error.message}`);
+    }
+  });
+  if (packages.length > 0) {
+    logger.info(`Watching packages: ${packages.join(", ")}`);
+    spinner2?.start("Performing initial sync...");
+    await orchestrator.syncPackages(packages);
+    spinner2?.stop("Initial sync complete");
+  } else {
+    spinner2?.start("Performing initial sync of all packages...");
+    await orchestrator.syncAll();
+    spinner2?.stop("Initial sync complete");
+  }
+  logger.info("Starting watch mode...");
+  spinner2?.start("Watching for changes... (Ctrl+C to stop)");
+  await orchestrator.startWatching();
+  const shutdown = async () => {
+    spinner2?.stop("Stopping watch mode...");
+    await orchestrator.stopWatching();
+    if (options.quiet !== true) {
+      showOutro("\u{1F44B} Watch mode stopped");
+    }
+    process3.exit(0);
+  };
+  process3.on("SIGINT", () => {
+    shutdown().catch(() => process3.exit(1));
+  });
+  process3.on("SIGTERM", () => {
+    shutdown().catch(() => process3.exit(1));
+  });
+  setInterval(() => {
+  }, 1 << 30);
+}
+
+// src/cli/index.ts
+var cli = cac("doc-sync");
+cli.command(
+  "sync [...packages]",
+  "Sync documentation for specified packages (or all if none specified)"
+).option("-r, --root <dir>", "Root directory of the monorepo", { default: process4.cwd() }).option("-d, --dry-run", "Preview changes without writing files").option("-v, --verbose", "Enable verbose output").option("-q, --quiet", "Suppress non-error output").option("-i, --interactive", "Use interactive package selection").action(async (packages, options) => {
+  await runSync(packages, options);
+});
+cli.command("watch [...packages]", "Watch for changes and sync automatically").option("-r, --root <dir>", "Root directory of the monorepo", { default: process4.cwd() }).option("-d, --dry-run", "Preview changes without writing files").option("-v, --verbose", "Enable verbose output").option("-q, --quiet", "Suppress non-error output").action(async (packages, options) => {
+  await runWatch(packages, options);
+});
+cli.command("validate [...packages]", "Check documentation freshness and validate MDX syntax").option("-r, --root <dir>", "Root directory of the monorepo", { default: process4.cwd() }).option("-v, --verbose", "Enable verbose output").option("-q, --quiet", "Suppress non-error output").action(async (packages, options) => {
+  await runValidate(packages, options);
+});
+cli.command("[...packages]", "Sync documentation (default command)").option("-r, --root <dir>", "Root directory of the monorepo", { default: process4.cwd() }).option("-w, --watch", "Watch for changes and sync automatically").option("-d, --dry-run", "Preview changes without writing files").option("-v, --verbose", "Enable verbose output").option("-q, --quiet", "Suppress non-error output").option("-i, --interactive", "Use interactive package selection").action(async (packages, options) => {
+  if (options.watch === true) {
+    await runWatch(packages, options);
+  } else {
+    await runSync(packages, options);
+  }
+});
+cli.help();
+cli.version("0.0.1");
+cli.parse();
+//# sourceMappingURL=index.js.map

package/lib/generators/index.d.ts

@@ -0,0 +1,170 @@
+import { PackageAPI, ExportedFunction, ExportedType, ReadmeContent, PackageInfo, ReadmeSection, SyncError, MDXFrontmatter, MDXDocument } from '../types.js';
+import { Result } from '@bfra.me/es/result';
+import 'zod';
+
+/**
+ * @bfra.me/doc-sync/generators/api-reference-generator - API documentation table generation
+ */
+
+declare function generateAPIReference(api: PackageAPI): string;
+declare function generateAPICompact(api: PackageAPI): string;
+declare function generateCategoryReference(functions: readonly ExportedFunction[], types: readonly ExportedType[], categoryName: string): string;
+
+/**
+ * @bfra.me/doc-sync/generators/code-example-formatter - Syntax-highlighted code blocks from JSDoc examples
+ */
+
+/**
+ * Options for code example formatting
+ */
+interface CodeExampleOptions {
+    /** Default language for code blocks */
+    readonly defaultLanguage?: string;
+    /** Whether to add function name as title */
+    readonly includeTitle?: boolean;
+    /** Maximum number of examples per function */
+    readonly maxExamplesPerFunction?: number;
+    /** Whether to wrap examples in collapsible sections */
+    readonly collapsible?: boolean;
+}
+declare function formatCodeExamples(api: PackageAPI, options?: CodeExampleOptions): string;
+declare function formatFunctionExamples(fn: ExportedFunction, options?: CodeExampleOptions): string;
+declare function formatTypeExamples(type: ExportedType, options?: CodeExampleOptions): string;
+declare function formatCodeBlock(code: string, language?: string): string;
+declare function cleanCodeExample(code: string): string;
+declare function detectLanguage(code: string): string | undefined;
+declare function formatUsageExample(fn: ExportedFunction): string;
+declare function groupExamplesByCategory(api: PackageAPI): Map<string, {
+    functions: ExportedFunction[];
+    types: ExportedType[];
+}>;
+declare function formatGroupedExamples(api: PackageAPI, options?: CodeExampleOptions): string;
+
+/**
+ * @bfra.me/doc-sync/generators/component-mapper - Map content sections to Starlight components
+ */
+
+/**
+ * Configuration for Starlight component mapping
+ */
+interface ComponentMapperConfig {
+    /** Section titles that should use CardGrid for features */
+    readonly featureSections?: readonly string[];
+    /** Section titles that should use Tabs for installation */
+    readonly tabSections?: readonly string[];
+    /** Section titles to exclude from output */
+    readonly excludeSections?: readonly string[];
+    /** Custom component mappings by section title */
+    readonly customMappings?: Record<string, SectionMapper>;
+}
+/**
+ * A function that maps section content to MDX output
+ */
+type SectionMapper = (section: ReadmeSection, info: PackageInfo) => string;
+declare function mapToStarlightComponents(readme: ReadmeContent, packageInfo: PackageInfo, config?: ComponentMapperConfig): string;
+declare function generateInstallTabs(packageName: string): string;
+declare function createBadge(text: string, variant?: 'note' | 'tip' | 'caution' | 'danger' | 'success' | 'default'): string;
+declare function createCard(title: string, content: string, icon?: string): string;
+declare function createCardGrid(cards: {
+    title: string;
+    content: string;
+    icon?: string;
+}[]): string;
+declare function createTabs(items: {
+    label: string;
+    content: string;
+}[]): string;
+
+/**
+ * @bfra.me/doc-sync/generators/content-merger - Preserve manual sections using sentinel markers
+ */
+
+/**
+ * A section of content extracted from MDX
+ */
+interface ContentSection {
+    /** Section type */
+    readonly type: 'auto' | 'manual' | 'unchanged';
+    /** Section content */
+    readonly content: string;
+    /** Start position in source */
+    readonly startIndex: number;
+    /** End position in source */
+    readonly endIndex: number;
+}
+/**
+ * Merge options
+ */
+interface MergeOptions {
+    /** Strategy for handling conflicts */
+    readonly conflictStrategy?: 'keep-manual' | 'keep-auto' | 'merge';
+    /** Preserve empty manual sections */
+    readonly preserveEmptyManual?: boolean;
+}
+/**
+ * Result of a merge operation
+ */
+interface MergeResult {
+    /** Merged content */
+    readonly content: string;
+    /** Number of manual sections preserved */
+    readonly preservedCount: number;
+    /** Number of auto-generated sections updated */
+    readonly updatedCount: number;
+    /** Whether content changed */
+    readonly hasChanges: boolean;
+}
+declare function mergeContent(existingContent: string, newContent: string, options?: MergeOptions): Result<MergeResult, SyncError>;
+declare function extractManualSections(content: string): ContentSection[];
+declare function extractAutoSections(content: string): ContentSection[];
+declare function hasManualContent(content: string): boolean;
+declare function hasAutoContent(content: string): boolean;
+declare function wrapManualSection(content: string): string;
+declare function wrapAutoSection(content: string): string;
+declare function stripSentinelMarkers(content: string): string;
+declare function validateMarkerPairing(content: string): Result<true, SyncError>;
+declare function createDiffSummary(oldContent: string, newContent: string): string;
+
+/**
+ * @bfra.me/doc-sync/generators/frontmatter-generator - Starlight-compatible frontmatter generation
+ */
+
+declare function generateFrontmatter(packageInfo: PackageInfo, readme: ReadmeContent | undefined, overrides?: Partial<MDXFrontmatter>): MDXFrontmatter;
+declare function stringifyFrontmatter(frontmatter: MDXFrontmatter): string;
+declare function parseFrontmatter(yaml: string): Partial<MDXFrontmatter>;
+
+/**
+ * @bfra.me/doc-sync/generators/mdx-generator - MDX document structure generation for Starlight
+ */
+
+/**
+ * Options for MDX generation
+ */
+interface MDXGeneratorOptions {
+    /** Include API reference section */
+    readonly includeAPI?: boolean;
+    /** Include examples from JSDoc */
+    readonly includeExamples?: boolean;
+    /** Custom frontmatter overrides */
+    readonly frontmatterOverrides?: Partial<MDXFrontmatter>;
+    /** Preserve manual content sections */
+    readonly preserveManualContent?: boolean;
+    /** Existing MDX content for merging */
+    readonly existingContent?: string;
+}
+declare function generateMDXDocument(packageInfo: PackageInfo, readme: ReadmeContent | undefined, api: PackageAPI | undefined, options?: MDXGeneratorOptions): Result<MDXDocument, SyncError>;
+/**
+ * Sanitizes content for safe MDX rendering
+ * Prevents XSS by escaping potentially dangerous content
+ */
+declare function sanitizeContent(content: string): string;
+/**
+ * Sanitizes content within MDX while preserving JSX components
+ * Only escapes content that appears to be user-provided text
+ * Now includes sanitization of JSX component attributes to prevent XSS
+ * Uses safe, non-backtracking parsing to prevent ReDoS
+ */
+declare function sanitizeTextContent(content: string): string;
+declare function validateMDXSyntax(mdx: string): Result<true, SyncError>;
+
+export { type CodeExampleOptions, type ComponentMapperConfig, type ContentSection, type MDXGeneratorOptions, type MergeOptions, type MergeResult, type SectionMapper, cleanCodeExample, createBadge, createCard, createCardGrid, createDiffSummary, createTabs, detectLanguage, extractAutoSections, extractManualSections, formatCodeBlock, formatCodeExamples, formatFunctionExamples, formatGroupedExamples, formatTypeExamples, formatUsageExample, generateAPICompact, generateAPIReference, generateCategoryReference, generateFrontmatter, generateInstallTabs, generateMDXDocument, groupExamplesByCategory, hasAutoContent, hasManualContent, mapToStarlightComponents, mergeContent, parseFrontmatter, sanitizeContent, sanitizeTextContent, stringifyFrontmatter, stripSentinelMarkers, validateMDXSyntax, validateMarkerPairing, wrapAutoSection, wrapManualSection };

package/lib/generators/index.js

@@ -0,0 +1,76 @@
+import {
+  cleanCodeExample,
+  createBadge,
+  createCard,
+  createCardGrid,
+  createDiffSummary,
+  createTabs,
+  detectLanguage,
+  extractAutoSections,
+  extractManualSections,
+  formatCodeBlock,
+  formatCodeExamples,
+  formatFunctionExamples,
+  formatGroupedExamples,
+  formatTypeExamples,
+  formatUsageExample,
+  generateAPICompact,
+  generateAPIReference,
+  generateCategoryReference,
+  generateFrontmatter,
+  generateInstallTabs,
+  generateMDXDocument,
+  groupExamplesByCategory,
+  hasAutoContent,
+  hasManualContent,
+  mapToStarlightComponents,
+  mergeContent,
+  parseFrontmatter,
+  sanitizeContent,
+  sanitizeTextContent,
+  stringifyFrontmatter,
+  stripSentinelMarkers,
+  validateMDXSyntax,
+  validateMarkerPairing,
+  wrapAutoSection,
+  wrapManualSection
+} from "../chunk-G5KKGJYO.js";
+import "../chunk-ROLA7SBB.js";
+export {
+  cleanCodeExample,
+  createBadge,
+  createCard,
+  createCardGrid,
+  createDiffSummary,
+  createTabs,
+  detectLanguage,
+  extractAutoSections,
+  extractManualSections,
+  formatCodeBlock,
+  formatCodeExamples,
+  formatFunctionExamples,
+  formatGroupedExamples,
+  formatTypeExamples,
+  formatUsageExample,
+  generateAPICompact,
+  generateAPIReference,
+  generateCategoryReference,
+  generateFrontmatter,
+  generateInstallTabs,
+  generateMDXDocument,
+  groupExamplesByCategory,
+  hasAutoContent,
+  hasManualContent,
+  mapToStarlightComponents,
+  mergeContent,
+  parseFrontmatter,
+  sanitizeContent,
+  sanitizeTextContent,
+  stringifyFrontmatter,
+  stripSentinelMarkers,
+  validateMDXSyntax,
+  validateMarkerPairing,
+  wrapAutoSection,
+  wrapManualSection
+};
+//# sourceMappingURL=index.js.map