@bfra.me/doc-sync 0.1.0

package/lib/index.d.ts

@@ -0,0 +1,141 @@
+export { CodeExampleOptions, ComponentMapperConfig, ContentSection, MDXGeneratorOptions, MergeOptions, MergeResult, 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 } from './generators/index.js';
+import { Result } from '@bfra.me/es/result';
+import { PackageInfo, ReadmeContent, PackageAPI, SyncError, FileChangeEvent, DocConfig, SyncSummary, MDXDocument } from './types.js';
+export { CLIOptions, DocConfigSource, ExportedFunction, ExportedType, FunctionParameter, InferSchema, JSDocInfo, JSDocParam, JSDocTag, MDXFrontmatter, ParseError, ParseErrorCode, ParseResult, ReExport, ReadmeSection, SENTINEL_MARKERS, SyncErrorCode, SyncInfo, SyncResult } from './types.js';
+import 'zod';
+
+interface PackageScannerOptions {
+    readonly rootDir: string;
+    readonly includePatterns?: readonly string[];
+    readonly excludePackages?: readonly string[];
+    readonly parseSourceFiles?: boolean;
+    readonly parseReadme?: boolean;
+}
+interface ScannedPackage {
+    readonly info: PackageInfo;
+    readonly readme?: ReadmeContent;
+    readonly api?: PackageAPI;
+    readonly sourceFiles: readonly string[];
+    readonly needsDocumentation: boolean;
+    readonly existingDocPath?: string;
+}
+interface ScanResult {
+    readonly packages: readonly ScannedPackage[];
+    readonly packagesNeedingDocs: readonly ScannedPackage[];
+    readonly errors: readonly SyncError[];
+    readonly durationMs: number;
+}
+declare function createPackageScanner(options: PackageScannerOptions): {
+    readonly scan: () => Promise<ScanResult>;
+    readonly scanPackage: (packagePath: string) => Promise<Result<ScannedPackage, SyncError>>;
+};
+declare function filterPackagesByPattern(packages: readonly ScannedPackage[], pattern: string): ScannedPackage[];
+declare function groupPackagesByScope(packages: readonly ScannedPackage[]): Map<string, ScannedPackage[]>;
+
+interface DocWatcherOptions {
+    readonly rootDir?: string;
+    readonly debounceMs?: number;
+    readonly additionalIgnore?: readonly string[];
+    readonly usePolling?: boolean;
+}
+type DocChangeHandler = (events: readonly FileChangeEvent[]) => void | Promise<void>;
+interface DocFileWatcher {
+    readonly start: () => Promise<void>;
+    readonly close: () => Promise<void>;
+    readonly onChanges: (handler: DocChangeHandler) => () => void;
+    readonly getWatchedPaths: () => readonly string[];
+}
+declare function createDocWatcher(options?: DocWatcherOptions): DocFileWatcher;
+type FileCategory = 'readme' | 'source' | 'package-json' | 'unknown';
+declare function categorizeFile(filePath: string): FileCategory;
+declare function groupChangesByPackage(events: readonly FileChangeEvent[]): Map<string, FileChangeEvent[]>;
+declare function filterDocumentationChanges(events: readonly FileChangeEvent[]): FileChangeEvent[];
+
+interface DocChangeDetectorOptions {
+    readonly algorithm?: 'sha256' | 'md5';
+}
+interface PackageChangeAnalysis {
+    readonly packageName: string;
+    readonly needsRegeneration: boolean;
+    readonly changedCategories: readonly FileCategory[];
+    readonly changedFiles: readonly string[];
+}
+interface DocChangeDetector {
+    readonly hasChanged: (filePath: string) => Promise<boolean>;
+    readonly record: (filePath: string) => Promise<void>;
+    readonly recordPackage: (pkg: PackageInfo, files: readonly string[]) => Promise<void>;
+    readonly clear: (filePath: string) => void;
+    readonly clearAll: () => void;
+    readonly analyzeChanges: (events: readonly FileChangeEvent[]) => Promise<PackageChangeAnalysis[]>;
+}
+declare function createDocChangeDetector(options?: DocChangeDetectorOptions): DocChangeDetector;
+type RegenerationScope = 'full' | 'api-only' | 'readme-only' | 'metadata-only' | 'none';
+declare function determineRegenerationScope(changedCategories: readonly FileCategory[]): RegenerationScope;
+declare function hasAnyFileChanged(detector: DocChangeDetector, files: readonly string[]): Promise<boolean>;
+
+interface DocDebouncerOptions {
+    readonly debounceMs?: number;
+    readonly maxWaitMs?: number;
+}
+type BatchChangeHandler = (events: readonly FileChangeEvent[]) => void | Promise<void>;
+interface DocDebouncer {
+    readonly add: (event: FileChangeEvent) => void;
+    readonly addAll: (events: readonly FileChangeEvent[]) => void;
+    readonly flush: () => void;
+    readonly cancel: () => void;
+    readonly getPendingCount: () => number;
+}
+declare function createDocDebouncer(handler: BatchChangeHandler, options?: DocDebouncerOptions): DocDebouncer;
+declare function deduplicateEvents(events: readonly FileChangeEvent[]): FileChangeEvent[];
+declare function consolidateEvents(events: readonly FileChangeEvent[]): FileChangeEvent[];
+
+interface SyncOrchestratorOptions {
+    readonly config: DocConfig;
+    readonly dryRun?: boolean;
+    readonly verbose?: boolean;
+    readonly onProgress?: (message: string) => void;
+    readonly onError?: (error: SyncError) => void;
+}
+interface SyncOrchestrator {
+    readonly syncAll: () => Promise<SyncSummary>;
+    readonly syncPackages: (packageNames: readonly string[]) => Promise<SyncSummary>;
+    readonly handleChanges: (events: readonly FileChangeEvent[]) => Promise<SyncSummary>;
+    readonly startWatching: () => Promise<void>;
+    readonly stopWatching: () => Promise<void>;
+    readonly isWatching: () => boolean;
+}
+declare function createSyncOrchestrator(options: SyncOrchestratorOptions): SyncOrchestrator;
+/** Prevents directory traversal attacks (SEC-002) */
+declare function isValidFilePath(filePath: string, rootDir: string): boolean;
+
+interface ValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly ValidationError[];
+    readonly warnings: readonly ValidationWarning[];
+}
+interface ValidationError {
+    readonly type: 'syntax' | 'frontmatter' | 'component' | 'content';
+    readonly message: string;
+    readonly line?: number;
+    readonly column?: number;
+}
+interface ValidationWarning {
+    readonly type: 'deprecation' | 'recommendation' | 'compatibility';
+    readonly message: string;
+    readonly line?: number;
+}
+interface ValidationPipelineOptions {
+    readonly validateFrontmatter?: boolean;
+    readonly validateComponents?: boolean;
+    readonly validateContent?: boolean;
+    readonly strict?: boolean;
+}
+declare function createValidationPipeline(options?: ValidationPipelineOptions): {
+    readonly validate: (doc: MDXDocument) => ValidationResult;
+    readonly validateContent: (content: string) => ValidationResult;
+    readonly validateMultiple: (docs: readonly MDXDocument[]) => Result<Map<string, ValidationResult>, SyncError>;
+};
+declare function validateDocument(doc: MDXDocument, options?: ValidationPipelineOptions): Result<MDXDocument, SyncError>;
+declare function validateContentString(content: string, options?: ValidationPipelineOptions): Result<string, SyncError>;
+
+export { type BatchChangeHandler, type DocChangeDetector, type DocChangeDetectorOptions, type DocChangeHandler, DocConfig, type DocDebouncer, type DocDebouncerOptions, type DocFileWatcher, type DocWatcherOptions, type FileCategory, FileChangeEvent, MDXDocument, PackageAPI, type PackageChangeAnalysis, PackageInfo, type PackageScannerOptions, ReadmeContent, type RegenerationScope, type ScanResult, type ScannedPackage, SyncError, type SyncOrchestrator, type SyncOrchestratorOptions, SyncSummary, type ValidationError, type ValidationPipelineOptions, type ValidationResult, type ValidationWarning, categorizeFile, consolidateEvents, createDocChangeDetector, createDocDebouncer, createDocWatcher, createPackageScanner, createSyncOrchestrator, createValidationPipeline, deduplicateEvents, determineRegenerationScope, filterDocumentationChanges, filterPackagesByPattern, groupChangesByPackage, groupPackagesByScope, hasAnyFileChanged, isValidFilePath, validateContentString, validateDocument };

package/lib/index.js

@@ -0,0 +1,118 @@
+import {
+  categorizeFile,
+  consolidateEvents,
+  createDocChangeDetector,
+  createDocDebouncer,
+  createDocWatcher,
+  createPackageScanner,
+  createSyncOrchestrator,
+  createValidationPipeline,
+  deduplicateEvents,
+  determineRegenerationScope,
+  filterDocumentationChanges,
+  filterPackagesByPattern,
+  groupChangesByPackage,
+  groupPackagesByScope,
+  hasAnyFileChanged,
+  isValidFilePath,
+  validateContentString,
+  validateDocument
+} from "./chunk-DR6UG237.js";
+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 {
+  SENTINEL_MARKERS
+} from "./chunk-ROLA7SBB.js";
+import "./chunk-6NKAJT2M.js";
+export {
+  SENTINEL_MARKERS,
+  categorizeFile,
+  cleanCodeExample,
+  consolidateEvents,
+  createBadge,
+  createCard,
+  createCardGrid,
+  createDiffSummary,
+  createDocChangeDetector,
+  createDocDebouncer,
+  createDocWatcher,
+  createPackageScanner,
+  createSyncOrchestrator,
+  createTabs,
+  createValidationPipeline,
+  deduplicateEvents,
+  detectLanguage,
+  determineRegenerationScope,
+  extractAutoSections,
+  extractManualSections,
+  filterDocumentationChanges,
+  filterPackagesByPattern,
+  formatCodeBlock,
+  formatCodeExamples,
+  formatFunctionExamples,
+  formatGroupedExamples,
+  formatTypeExamples,
+  formatUsageExample,
+  generateAPICompact,
+  generateAPIReference,
+  generateCategoryReference,
+  generateFrontmatter,
+  generateInstallTabs,
+  generateMDXDocument,
+  groupChangesByPackage,
+  groupExamplesByCategory,
+  groupPackagesByScope,
+  hasAnyFileChanged,
+  hasAutoContent,
+  hasManualContent,
+  isValidFilePath,
+  mapToStarlightComponents,
+  mergeContent,
+  parseFrontmatter,
+  sanitizeContent,
+  sanitizeTextContent,
+  stringifyFrontmatter,
+  stripSentinelMarkers,
+  validateContentString,
+  validateDocument,
+  validateMDXSyntax,
+  validateMarkerPairing,
+  wrapAutoSection,
+  wrapManualSection
+};
+//# sourceMappingURL=index.js.map

package/lib/parsers/index.d.ts

@@ -0,0 +1,264 @@
+import { ParseResult, PackageAPI, PackageInfo, ParseError, DocConfigSource, ExportedFunction, ExportedType, JSDocInfo, JSDocParam, JSDocTag, MDXFrontmatter, ReadmeContent, ReadmeSection, ReExport, SyncError } from '../types.js';
+import { ClassDeclaration, EnumDeclaration, FunctionDeclaration, InterfaceDeclaration, TypeAliasDeclaration, Node, JSDocableNode, JSDoc, Project, SourceFile } from 'ts-morph';
+import '@bfra.me/es/result';
+import 'zod';
+
+/**
+ * @bfra.me/doc-sync/parsers/export-analyzer - Public API surface analyzer for package exports
+ */
+
+/**
+ * Options for analyzing package exports
+ */
+interface ExportAnalyzerOptions {
+    readonly tsConfigPath?: string;
+    readonly followReExports?: boolean;
+    readonly maxDepth?: number;
+}
+/**
+ * Resolved export information including the original source
+ */
+interface ResolvedExport {
+    readonly name: string;
+    readonly kind: 'function' | 'type' | 'interface' | 'enum' | 'class' | 're-export';
+    readonly source: string;
+    readonly isDefault: boolean;
+}
+/**
+ * Complete analysis of a package's public API
+ */
+interface PublicAPIAnalysis {
+    readonly packagePath: string;
+    readonly entryPoint: string;
+    readonly api: PackageAPI;
+    readonly resolvedExports: readonly ResolvedExport[];
+}
+/**
+ * Analyzes the public API surface of a package from its entry point
+ */
+declare function analyzePublicAPI(entryPointPath: string, options?: ExportAnalyzerOptions): ParseResult<PublicAPIAnalysis>;
+/**
+ * Finds all exported symbols from a package entry point
+ */
+declare function findExportedSymbols(entryPointPath: string, options?: ExportAnalyzerOptions): ParseResult<readonly string[]>;
+/**
+ * Checks if a symbol is exported from a package
+ */
+declare function isSymbolExported(entryPointPath: string, symbolName: string, options?: ExportAnalyzerOptions): ParseResult<boolean>;
+/**
+ * Gets detailed information about a specific exported symbol
+ */
+declare function getExportedSymbolInfo(entryPointPath: string, symbolName: string, options?: ExportAnalyzerOptions): ParseResult<ResolvedExport | undefined>;
+/**
+ * Filters exports by kind
+ */
+declare function getExportsByKind(entryPointPath: string, kind: ResolvedExport['kind'], options?: ExportAnalyzerOptions): ParseResult<readonly ResolvedExport[]>;
+
+/**
+ * @bfra.me/doc-sync/parsers/guards - Type guards and validation for parser types
+ */
+
+declare function isParseError(value: unknown): value is ParseError;
+/**
+ * Type guard for SyncError
+ */
+declare function isSyncError(value: unknown): value is SyncError;
+declare function isJSDocParam(value: unknown): value is JSDocParam;
+declare function isJSDocTag(value: unknown): value is JSDocTag;
+declare function isJSDocInfo(value: unknown): value is JSDocInfo;
+declare function isExportedFunction(value: unknown): value is ExportedFunction;
+declare function isExportedType(value: unknown): value is ExportedType;
+declare function isReExport(value: unknown): value is ReExport;
+declare function isPackageAPI(value: unknown): value is PackageAPI;
+declare function isDocConfigSource(value: unknown): value is DocConfigSource;
+declare function isPackageInfo(value: unknown): value is PackageInfo;
+declare function isReadmeSection(value: unknown): value is ReadmeSection;
+declare function isReadmeContent(value: unknown): value is ReadmeContent;
+declare function isMDXFrontmatter(value: unknown): value is MDXFrontmatter;
+declare function isValidPackageName(name: string): boolean;
+declare function isValidSemver(version: string): boolean;
+declare function isValidHeadingLevel(level: number): level is 1 | 2 | 3 | 4 | 5 | 6;
+/** Checks for potential XSS patterns to prevent injection attacks */
+declare function isSafeContent(content: string): boolean;
+/** Prevents directory traversal attacks in file paths */
+declare function isSafeFilePath(filePath: string): boolean;
+declare function assertParseError(value: unknown): asserts value is ParseError;
+declare function assertPackageInfo(value: unknown): asserts value is PackageInfo;
+declare function assertPackageAPI(value: unknown): asserts value is PackageAPI;
+
+/**
+ * @bfra.me/doc-sync/parsers/jsdoc-extractor - JSDoc annotation extraction from TypeScript AST nodes
+ */
+
+/**
+ * Supported node types for JSDoc extraction
+ */
+type JSDocableDeclaration = ClassDeclaration | EnumDeclaration | FunctionDeclaration | InterfaceDeclaration | TypeAliasDeclaration;
+/**
+ * Type guard to check if a node has JSDoc
+ */
+declare function hasJSDoc(node: Node): node is Node & JSDocableNode;
+/**
+ * Extracts JSDoc information from an AST node
+ */
+declare function extractJSDocInfo(node: JSDocableDeclaration): JSDocInfo | undefined;
+/**
+ * Parses a JSDoc node into structured information
+ */
+declare function parseJSDoc(jsDoc: JSDoc): JSDocInfo;
+
+/**
+ * @bfra.me/doc-sync/parsers/package-info - Package.json metadata extraction
+ */
+
+/**
+ * Schema for validating package.json structure (runtime validation)
+ */
+interface PackageJsonSchema {
+    readonly name: string;
+    readonly version: string;
+    readonly description?: string;
+    readonly keywords?: readonly string[];
+    readonly main?: string;
+    readonly module?: string;
+    readonly types?: string;
+    readonly exports?: Record<string, unknown>;
+    readonly repository?: string | {
+        readonly type?: string;
+        readonly url?: string;
+        readonly directory?: string;
+    };
+    readonly docs?: DocConfigSource;
+}
+/**
+ * Options for parsing package.json files
+ */
+interface PackageInfoOptions {
+    readonly validateSchema?: boolean;
+    readonly extractDocsConfig?: boolean;
+}
+/**
+ * Parses a package.json file and extracts relevant metadata
+ */
+declare function parsePackageJson(packagePath: string, options?: PackageInfoOptions): Promise<ParseResult<PackageInfo>>;
+/**
+ * Parses package.json content from a string
+ */
+declare function parsePackageJsonContent(content: string, filePath: string, options?: PackageInfoOptions): ParseResult<PackageInfo>;
+/**
+ * Extracts documentation configuration from package.json
+ */
+declare function extractDocsConfig(pkg: PackageInfo): DocConfigSource | undefined;
+/**
+ * Checks if a README file exists for a package
+ */
+declare function findReadmePath(packagePath: string): Promise<string | undefined>;
+/**
+ * Extracts the source entry point from package.json
+ */
+declare function findEntryPoint(pkg: PackageInfo, content: string): string;
+/**
+ * Parses a complete package including README detection
+ */
+declare function parsePackageComplete(packagePath: string, options?: PackageInfoOptions): Promise<ParseResult<PackageInfo>>;
+/**
+ * Gets the package scope from a scoped package name
+ */
+declare function getPackageScope(packageName: string): string | undefined;
+/**
+ * Gets the unscoped package name
+ */
+declare function getUnscopedName(packageName: string): string;
+/**
+ * Builds a documentation slug from a package name
+ */
+declare function buildDocSlug(packageName: string): string;
+
+/**
+ * @bfra.me/doc-sync/parsers/readme-parser - README Markdown parser with section extraction
+ */
+
+/**
+ * Options for parsing README files
+ */
+interface ReadmeParserOptions {
+    readonly extractSections?: boolean;
+    readonly preserveRaw?: boolean;
+}
+/**
+ * Parses a README markdown string into structured content
+ */
+declare function parseReadme(content: string, options?: ReadmeParserOptions): ParseResult<ReadmeContent>;
+/**
+ * Parses a README file from the file system
+ */
+declare function parseReadmeFile(filePath: string, options?: ReadmeParserOptions): Promise<ParseResult<ReadmeContent>>;
+/**
+ * Finds a section by heading text (case-insensitive)
+ */
+declare function findSection(content: ReadmeContent, headingText: string): ReadmeSection | undefined;
+/**
+ * Gets all sections at a specific heading level
+ */
+declare function getSectionsByLevel(content: ReadmeContent, level: number): readonly ReadmeSection[];
+/**
+ * Flattens all sections into a single array
+ */
+declare function flattenSections(content: ReadmeContent): readonly ReadmeSection[];
+/**
+ * Gets the table of contents as a flat list
+ */
+declare function getTableOfContents(content: ReadmeContent): readonly {
+    readonly heading: string;
+    readonly level: number;
+}[];
+
+/**
+ * @bfra.me/doc-sync/parsers/typescript-parser - TypeScript source file parser using ts-morph
+ */
+
+/**
+ * Options for parsing TypeScript source files
+ */
+interface TypeScriptParserOptions {
+    readonly tsConfigPath?: string;
+    readonly compilerOptions?: Record<string, unknown>;
+}
+/**
+ * Creates a ts-morph project instance for analyzing source files
+ */
+declare function createProject(options?: TypeScriptParserOptions): Project;
+/**
+ * Parses a TypeScript source file and extracts its structure
+ */
+declare function parseSourceFile(project: Project, filePath: string): ParseResult<SourceFile>;
+/**
+ * Parses TypeScript source content from a string
+ */
+declare function parseSourceContent(project: Project, content: string, virtualPath?: string): ParseResult<SourceFile>;
+/**
+ * Extracts exported functions from a source file
+ */
+declare function extractExportedFunctions(sourceFile: SourceFile): readonly ExportedFunction[];
+/**
+ * Extracts exported types and interfaces from a source file
+ */
+declare function extractExportedTypes(sourceFile: SourceFile): readonly ExportedType[];
+/**
+ * Extracts re-export statements from a source file
+ */
+declare function extractReExports(sourceFile: SourceFile): readonly ReExport[];
+/**
+ * Extracts the complete API surface from a source file
+ */
+declare function extractPackageAPI(sourceFile: SourceFile): PackageAPI;
+/**
+ * Parses and analyzes a TypeScript file, returning the complete API
+ */
+declare function analyzeTypeScriptFile(filePath: string, options?: TypeScriptParserOptions): ParseResult<PackageAPI>;
+/**
+ * Analyzes TypeScript content from a string
+ */
+declare function analyzeTypeScriptContent(content: string, options?: TypeScriptParserOptions): ParseResult<PackageAPI>;
+
+export { type ExportAnalyzerOptions, type JSDocableDeclaration, type PackageInfoOptions, type PackageJsonSchema, type PublicAPIAnalysis, type ReadmeParserOptions, type ResolvedExport, type TypeScriptParserOptions, analyzePublicAPI, analyzeTypeScriptContent, analyzeTypeScriptFile, assertPackageAPI, assertPackageInfo, assertParseError, buildDocSlug, createProject, extractDocsConfig, extractExportedFunctions, extractExportedTypes, extractJSDocInfo, extractPackageAPI, extractReExports, findEntryPoint, findExportedSymbols, findReadmePath, findSection, flattenSections, getExportedSymbolInfo, getExportsByKind, getPackageScope, getSectionsByLevel, getTableOfContents, getUnscopedName, hasJSDoc, isDocConfigSource, isExportedFunction, isExportedType, isJSDocInfo, isJSDocParam, isJSDocTag, isMDXFrontmatter, isPackageAPI, isPackageInfo, isParseError, isReExport, isReadmeContent, isReadmeSection, isSafeContent, isSafeFilePath, isSymbolExported, isSyncError, isValidHeadingLevel, isValidPackageName, isValidSemver, parseJSDoc, parsePackageComplete, parsePackageJson, parsePackageJsonContent, parseReadme, parseReadmeFile, parseSourceContent, parseSourceFile };

package/lib/parsers/index.js

@@ -0,0 +1,113 @@
+import {
+  analyzePublicAPI,
+  analyzeTypeScriptContent,
+  analyzeTypeScriptFile,
+  assertPackageAPI,
+  assertPackageInfo,
+  assertParseError,
+  buildDocSlug,
+  createProject,
+  extractDocsConfig,
+  extractExportedFunctions,
+  extractExportedTypes,
+  extractJSDocInfo,
+  extractPackageAPI,
+  extractReExports,
+  findEntryPoint,
+  findExportedSymbols,
+  findReadmePath,
+  findSection,
+  flattenSections,
+  getExportedSymbolInfo,
+  getExportsByKind,
+  getPackageScope,
+  getSectionsByLevel,
+  getTableOfContents,
+  getUnscopedName,
+  hasJSDoc,
+  isDocConfigSource,
+  isExportedFunction,
+  isExportedType,
+  isJSDocInfo,
+  isJSDocParam,
+  isJSDocTag,
+  isMDXFrontmatter,
+  isPackageAPI,
+  isPackageInfo,
+  isParseError,
+  isReExport,
+  isReadmeContent,
+  isReadmeSection,
+  isSafeContent,
+  isSafeFilePath,
+  isSymbolExported,
+  isSyncError,
+  isValidHeadingLevel,
+  isValidPackageName,
+  isValidSemver,
+  parseJSDoc,
+  parsePackageComplete,
+  parsePackageJson,
+  parsePackageJsonContent,
+  parseReadme,
+  parseReadmeFile,
+  parseSourceContent,
+  parseSourceFile
+} from "../chunk-6NKAJT2M.js";
+export {
+  analyzePublicAPI,
+  analyzeTypeScriptContent,
+  analyzeTypeScriptFile,
+  assertPackageAPI,
+  assertPackageInfo,
+  assertParseError,
+  buildDocSlug,
+  createProject,
+  extractDocsConfig,
+  extractExportedFunctions,
+  extractExportedTypes,
+  extractJSDocInfo,
+  extractPackageAPI,
+  extractReExports,
+  findEntryPoint,
+  findExportedSymbols,
+  findReadmePath,
+  findSection,
+  flattenSections,
+  getExportedSymbolInfo,
+  getExportsByKind,
+  getPackageScope,
+  getSectionsByLevel,
+  getTableOfContents,
+  getUnscopedName,
+  hasJSDoc,
+  isDocConfigSource,
+  isExportedFunction,
+  isExportedType,
+  isJSDocInfo,
+  isJSDocParam,
+  isJSDocTag,
+  isMDXFrontmatter,
+  isPackageAPI,
+  isPackageInfo,
+  isParseError,
+  isReExport,
+  isReadmeContent,
+  isReadmeSection,
+  isSafeContent,
+  isSafeFilePath,
+  isSymbolExported,
+  isSyncError,
+  isValidHeadingLevel,
+  isValidPackageName,
+  isValidSemver,
+  parseJSDoc,
+  parsePackageComplete,
+  parsePackageJson,
+  parsePackageJsonContent,
+  parseReadme,
+  parseReadmeFile,
+  parseSourceContent,
+  parseSourceFile
+};
+//# sourceMappingURL=index.js.map