@bfra.me/doc-sync 0.1.0

package/lib/chunk-6NKAJT2M.js

@@ -0,0 +1,1233 @@
+// src/parsers/export-analyzer.ts
+import { ok as ok2 } from "@bfra.me/es/result";
+
+// src/parsers/typescript-parser.ts
+import { err, ok } from "@bfra.me/es/result";
+import { Project } from "ts-morph";
+
+// src/parsers/jsdoc-extractor.ts
+function hasJSDoc(node) {
+  return "getJsDocs" in node && typeof node.getJsDocs === "function";
+}
+function extractJSDocInfo(node) {
+  if (!hasJSDoc(node)) {
+    return void 0;
+  }
+  const jsDocs = node.getJsDocs();
+  if (jsDocs.length === 0) {
+    return void 0;
+  }
+  const jsDoc = jsDocs[0];
+  if (jsDoc === void 0) {
+    return void 0;
+  }
+  return parseJSDoc(jsDoc);
+}
+function parseJSDoc(jsDoc) {
+  const description = jsDoc.getDescription().trim() || void 0;
+  const tags = jsDoc.getTags();
+  const params = extractParams(tags);
+  const returns = extractReturns(tags);
+  const examples = extractExamples(tags);
+  const deprecated = extractDeprecated(tags);
+  const since = extractSince(tags);
+  const see = extractSee(tags);
+  const customTags = extractCustomTags(tags);
+  return {
+    ...description !== void 0 && { description },
+    ...params.length > 0 && { params },
+    ...returns !== void 0 && { returns },
+    ...examples.length > 0 && { examples },
+    ...deprecated !== void 0 && { deprecated },
+    ...since !== void 0 && { since },
+    ...see.length > 0 && { see },
+    ...customTags.length > 0 && { customTags }
+  };
+}
+function extractParams(tags) {
+  const params = [];
+  for (const tag of tags) {
+    const tagName = tag.getTagName();
+    if (tagName !== "param") continue;
+    const text = getTagText(tag);
+    if (text === void 0) continue;
+    const parsed = parseParamText(text);
+    if (parsed !== void 0) {
+      params.push(parsed);
+    }
+  }
+  return params;
+}
+function parseParamText(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  let type;
+  let remaining = trimmed;
+  if (remaining.startsWith("{")) {
+    const typeEnd = remaining.indexOf("}");
+    if (typeEnd > 0) {
+      type = remaining.slice(1, typeEnd);
+      remaining = remaining.slice(typeEnd + 1).trim();
+    }
+  }
+  const dashIndex = remaining.indexOf(" - ");
+  const spaceIndex = remaining.indexOf(" ");
+  let name;
+  let description;
+  if (dashIndex > 0) {
+    name = remaining.slice(0, dashIndex).trim();
+    description = remaining.slice(dashIndex + 3).trim() || void 0;
+  } else if (spaceIndex > 0) {
+    name = remaining.slice(0, spaceIndex).trim();
+    description = remaining.slice(spaceIndex + 1).trim() || void 0;
+  } else {
+    name = remaining;
+  }
+  let optional = false;
+  if (name.startsWith("[") && name.endsWith("]")) {
+    optional = true;
+    name = name.slice(1, -1);
+  }
+  let defaultValue;
+  const defaultIndex = name.indexOf("=");
+  if (defaultIndex > 0) {
+    defaultValue = name.slice(defaultIndex + 1);
+    name = name.slice(0, defaultIndex);
+    optional = true;
+  }
+  return {
+    name,
+    ...type !== void 0 && { type },
+    ...description !== void 0 && { description },
+    ...optional && { optional },
+    ...defaultValue !== void 0 && { defaultValue }
+  };
+}
+function extractReturns(tags) {
+  for (const tag of tags) {
+    const tagName = tag.getTagName();
+    if (tagName !== "returns" && tagName !== "return") continue;
+    const text = getTagText(tag);
+    if (text !== void 0 && text.trim().length > 0) {
+      let result = text.trim();
+      if (result.startsWith("{")) {
+        const typeEnd = result.indexOf("}");
+        if (typeEnd > 0) {
+          result = result.slice(typeEnd + 1).trim();
+        }
+      }
+      return result.length > 0 ? result : void 0;
+    }
+  }
+  return void 0;
+}
+function extractExamples(tags) {
+  const examples = [];
+  for (const tag of tags) {
+    const tagName = tag.getTagName();
+    if (tagName !== "example") continue;
+    const text = getTagText(tag);
+    if (text !== void 0 && text.trim().length > 0) {
+      examples.push(text.trim());
+    }
+  }
+  return examples;
+}
+function extractDeprecated(tags) {
+  for (const tag of tags) {
+    const tagName = tag.getTagName();
+    if (tagName !== "deprecated") continue;
+    const text = getTagText(tag);
+    return text?.trim() ?? "";
+  }
+  return void 0;
+}
+function extractSince(tags) {
+  for (const tag of tags) {
+    const tagName = tag.getTagName();
+    if (tagName !== "since") continue;
+    const text = getTagText(tag);
+    if (text !== void 0 && text.trim().length > 0) {
+      return text.trim();
+    }
+  }
+  return void 0;
+}
+function extractSee(tags) {
+  const see = [];
+  for (const tag of tags) {
+    const tagName = tag.getTagName();
+    if (tagName !== "see") continue;
+    const text = getTagText(tag);
+    if (text !== void 0 && text.trim().length > 0) {
+      see.push(text.trim());
+    }
+  }
+  return see;
+}
+var STANDARD_TAGS = /* @__PURE__ */ new Set([
+  "param",
+  "returns",
+  "return",
+  "example",
+  "deprecated",
+  "since",
+  "see",
+  "type",
+  "typedef",
+  "callback",
+  "template",
+  "throws",
+  "async",
+  "generator",
+  "override",
+  "readonly",
+  "private",
+  "protected",
+  "public",
+  "module",
+  "exports",
+  "interface",
+  "enum",
+  "class",
+  "constructor",
+  "function",
+  "method",
+  "property",
+  "member",
+  "implements",
+  "extends",
+  "augments"
+]);
+function extractCustomTags(tags) {
+  const customTags = [];
+  for (const tag of tags) {
+    const tagName = tag.getTagName();
+    if (STANDARD_TAGS.has(tagName)) continue;
+    const text = getTagText(tag);
+    const value = text !== void 0 && text.trim().length > 0 ? text.trim() : void 0;
+    customTags.push({
+      name: tagName,
+      ...value !== void 0 && { value }
+    });
+  }
+  return customTags;
+}
+function getTagText(tag) {
+  const fullText = tag.getText();
+  const tagName = tag.getTagName();
+  const prefix = `@${tagName}`;
+  if (fullText.startsWith(prefix)) {
+    const text = fullText.slice(prefix.length).trim();
+    return text.length > 0 ? text : void 0;
+  }
+  return void 0;
+}
+
+// src/parsers/typescript-parser.ts
+function createProject(options) {
+  return new Project({
+    tsConfigFilePath: options?.tsConfigPath,
+    compilerOptions: {
+      declaration: true,
+      ...options?.compilerOptions
+    },
+    skipAddingFilesFromTsConfig: true
+  });
+}
+function parseSourceFile(project, filePath) {
+  try {
+    const sourceFile = project.addSourceFileAtPath(filePath);
+    return ok(sourceFile);
+  } catch (error) {
+    return err({
+      code: "FILE_NOT_FOUND",
+      message: `Failed to parse source file: ${filePath}`,
+      filePath,
+      cause: error
+    });
+  }
+}
+function parseSourceContent(project, content, virtualPath = "virtual.ts") {
+  try {
+    const sourceFile = project.createSourceFile(virtualPath, content, {
+      overwrite: true
+    });
+    return ok(sourceFile);
+  } catch (error) {
+    return err({
+      code: "INVALID_SYNTAX",
+      message: "Failed to parse TypeScript content",
+      filePath: virtualPath,
+      cause: error
+    });
+  }
+}
+function extractExportedFunctions(sourceFile) {
+  const functions = [];
+  for (const func of sourceFile.getFunctions()) {
+    if (!func.isExported()) continue;
+    const name = func.getName() ?? "default";
+    const parameters = extractFunctionParameters(func);
+    const returnType = func.getReturnType().getText();
+    const jsdoc = extractJSDocInfo(func);
+    functions.push({
+      name,
+      jsdoc,
+      signature: func.getSignature()?.getDeclaration().getText() ?? func.getText(),
+      isAsync: func.isAsync(),
+      isGenerator: func.isGenerator(),
+      parameters,
+      returnType,
+      isDefault: func.isDefaultExport()
+    });
+  }
+  return functions;
+}
+function extractFunctionParameters(func) {
+  return func.getParameters().map((param) => ({
+    name: param.getName(),
+    type: param.getType().getText(),
+    optional: param.isOptional(),
+    defaultValue: param.getInitializer()?.getText()
+  }));
+}
+function extractExportedTypes(sourceFile) {
+  const types = [];
+  for (const iface of sourceFile.getInterfaces()) {
+    if (!iface.isExported()) continue;
+    const jsdoc = extractJSDocInfo(iface);
+    const typeParams = iface.getTypeParameters().map((tp) => tp.getText());
+    types.push({
+      name: iface.getName(),
+      jsdoc,
+      definition: iface.getText(),
+      kind: "interface",
+      isDefault: iface.isDefaultExport(),
+      typeParameters: typeParams.length > 0 ? typeParams : void 0
+    });
+  }
+  for (const typeAlias of sourceFile.getTypeAliases()) {
+    if (!typeAlias.isExported()) continue;
+    const jsdoc = extractJSDocInfo(typeAlias);
+    const typeParams = typeAlias.getTypeParameters().map((tp) => tp.getText());
+    types.push({
+      name: typeAlias.getName(),
+      jsdoc,
+      definition: typeAlias.getText(),
+      kind: "type",
+      isDefault: typeAlias.isDefaultExport(),
+      typeParameters: typeParams.length > 0 ? typeParams : void 0
+    });
+  }
+  for (const enumDecl of sourceFile.getEnums()) {
+    if (!enumDecl.isExported()) continue;
+    const jsdoc = extractJSDocInfo(enumDecl);
+    types.push({
+      name: enumDecl.getName(),
+      jsdoc,
+      definition: enumDecl.getText(),
+      kind: "enum",
+      isDefault: enumDecl.isDefaultExport()
+    });
+  }
+  for (const classDecl of sourceFile.getClasses()) {
+    if (!classDecl.isExported()) continue;
+    const name = classDecl.getName();
+    if (name === void 0) continue;
+    const jsdoc = extractJSDocInfo(classDecl);
+    const typeParams = classDecl.getTypeParameters().map((tp) => tp.getText());
+    types.push({
+      name,
+      jsdoc,
+      definition: classDecl.getText(),
+      kind: "class",
+      isDefault: classDecl.isDefaultExport(),
+      typeParameters: typeParams.length > 0 ? typeParams : void 0
+    });
+  }
+  return types;
+}
+function extractReExports(sourceFile) {
+  const reExports = [];
+  for (const exportDecl of sourceFile.getExportDeclarations()) {
+    const moduleSpecifier = exportDecl.getModuleSpecifierValue();
+    if (moduleSpecifier === void 0 || moduleSpecifier.length === 0) continue;
+    if (exportDecl.isNamespaceExport()) {
+      const namespaceExport = exportDecl.getNamespaceExport();
+      reExports.push({
+        from: moduleSpecifier,
+        exports: "*",
+        alias: namespaceExport?.getName()
+      });
+    } else {
+      const namedExports = exportDecl.getNamedExports().map((ne) => {
+        const aliasNode = ne.getAliasNode();
+        const alias = aliasNode === void 0 ? void 0 : aliasNode.getText();
+        const name = ne.getName();
+        return alias === void 0 ? name : `${name} as ${alias}`;
+      });
+      if (namedExports.length > 0) {
+        reExports.push({
+          from: moduleSpecifier,
+          exports: namedExports
+        });
+      }
+    }
+  }
+  return reExports;
+}
+function extractPackageAPI(sourceFile) {
+  return {
+    functions: extractExportedFunctions(sourceFile),
+    types: extractExportedTypes(sourceFile),
+    reExports: extractReExports(sourceFile)
+  };
+}
+function analyzeTypeScriptFile(filePath, options) {
+  const project = createProject(options);
+  const sourceFileResult = parseSourceFile(project, filePath);
+  if (!sourceFileResult.success) {
+    return sourceFileResult;
+  }
+  try {
+    const api = extractPackageAPI(sourceFileResult.data);
+    return ok(api);
+  } catch (error) {
+    return err({
+      code: "INVALID_SYNTAX",
+      message: `Failed to analyze TypeScript file: ${filePath}`,
+      filePath,
+      cause: error
+    });
+  }
+}
+function analyzeTypeScriptContent(content, options) {
+  const project = createProject(options);
+  const sourceFileResult = parseSourceContent(project, content);
+  if (!sourceFileResult.success) {
+    return sourceFileResult;
+  }
+  try {
+    const api = extractPackageAPI(sourceFileResult.data);
+    return ok(api);
+  } catch (error) {
+    return err({
+      code: "INVALID_SYNTAX",
+      message: "Failed to analyze TypeScript content",
+      cause: error
+    });
+  }
+}
+
+// src/parsers/export-analyzer.ts
+function analyzePublicAPI(entryPointPath, options) {
+  const project = createProject({ tsConfigPath: options?.tsConfigPath });
+  const sourceFileResult = parseSourceFile(project, entryPointPath);
+  if (!sourceFileResult.success) {
+    return sourceFileResult;
+  }
+  const sourceFile = sourceFileResult.data;
+  const api = extractPackageAPI(sourceFile);
+  const resolvedExports = resolveAllExports(sourceFile, api, project, options);
+  return ok2({
+    packagePath: sourceFile.getDirectoryPath(),
+    entryPoint: entryPointPath,
+    api,
+    resolvedExports
+  });
+}
+function resolveAllExports(sourceFile, api, project, options) {
+  const exports = [];
+  const filePath = sourceFile.getFilePath();
+  for (const func of api.functions) {
+    exports.push({
+      name: func.name,
+      kind: "function",
+      source: filePath,
+      isDefault: func.isDefault
+    });
+  }
+  for (const type of api.types) {
+    exports.push({
+      name: type.name,
+      kind: type.kind,
+      source: filePath,
+      isDefault: type.isDefault
+    });
+  }
+  if (options?.followReExports !== false) {
+    const maxDepth = options?.maxDepth ?? 5;
+    const reExportedItems = resolveReExports(
+      sourceFile,
+      api.reExports,
+      project,
+      maxDepth,
+      /* @__PURE__ */ new Set()
+    );
+    exports.push(...reExportedItems);
+  }
+  return exports;
+}
+function resolveReExports(sourceFile, reExports, project, remainingDepth, visited) {
+  if (remainingDepth <= 0 || reExports.length === 0) {
+    return [];
+  }
+  const exports = [];
+  for (const reExport of reExports) {
+    const resolvedPath = resolveModulePath(sourceFile, reExport.from);
+    if (resolvedPath === void 0 || visited.has(resolvedPath)) {
+      if (reExport.exports === "*") {
+        exports.push({
+          name: reExport.alias ?? "*",
+          kind: "re-export",
+          source: reExport.from,
+          isDefault: false
+        });
+      } else {
+        for (const name of reExport.exports) {
+          exports.push({
+            name,
+            kind: "re-export",
+            source: reExport.from,
+            isDefault: false
+          });
+        }
+      }
+      continue;
+    }
+    visited.add(resolvedPath);
+    try {
+      const reExportedFile = getOrAddSourceFile(project, resolvedPath);
+      if (reExportedFile === void 0) continue;
+      const reExportedAPI = extractPackageAPI(reExportedFile);
+      if (reExport.exports === "*") {
+        for (const func of reExportedAPI.functions) {
+          exports.push({
+            name: func.name,
+            kind: "function",
+            source: resolvedPath,
+            isDefault: func.isDefault
+          });
+        }
+        for (const type of reExportedAPI.types) {
+          exports.push({
+            name: type.name,
+            kind: type.kind,
+            source: resolvedPath,
+            isDefault: type.isDefault
+          });
+        }
+        const nestedExports = resolveReExports(
+          reExportedFile,
+          reExportedAPI.reExports,
+          project,
+          remainingDepth - 1,
+          visited
+        );
+        exports.push(...nestedExports);
+      } else {
+        for (const exportName of reExport.exports) {
+          const [originalName, alias] = parseExportName(exportName);
+          const func = reExportedAPI.functions.find((f) => f.name === originalName);
+          if (func !== void 0) {
+            exports.push({
+              name: alias ?? originalName,
+              kind: "function",
+              source: resolvedPath,
+              isDefault: func.isDefault
+            });
+            continue;
+          }
+          const type = reExportedAPI.types.find((t) => t.name === originalName);
+          if (type !== void 0) {
+            exports.push({
+              name: alias ?? originalName,
+              kind: type.kind,
+              source: resolvedPath,
+              isDefault: type.isDefault
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return exports;
+}
+function parseExportName(exportName) {
+  const asIndex = exportName.indexOf(" as ");
+  if (asIndex > 0) {
+    return [exportName.slice(0, asIndex), exportName.slice(asIndex + 4)];
+  }
+  return [exportName, void 0];
+}
+function resolveModulePath(sourceFile, modulePath) {
+  if (!modulePath.startsWith(".")) {
+    return void 0;
+  }
+  try {
+    const directory = sourceFile.getDirectory();
+    const extensions = [".ts", ".tsx", "/index.ts", "/index.tsx", ".js", ".jsx"];
+    for (const ext of extensions) {
+      const candidate = directory.getSourceFile(modulePath + ext);
+      if (candidate !== void 0) {
+        return candidate.getFilePath();
+      }
+    }
+    const direct = directory.getSourceFile(modulePath);
+    return direct?.getFilePath();
+  } catch {
+    return void 0;
+  }
+}
+function getOrAddSourceFile(project, filePath) {
+  try {
+    return project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
+  } catch {
+    return void 0;
+  }
+}
+function findExportedSymbols(entryPointPath, options) {
+  const analysisResult = analyzePublicAPI(entryPointPath, options);
+  if (!analysisResult.success) {
+    return analysisResult;
+  }
+  const symbols = analysisResult.data.resolvedExports.map((exp) => exp.name);
+  return ok2([...new Set(symbols)]);
+}
+function isSymbolExported(entryPointPath, symbolName, options) {
+  const analysisResult = analyzePublicAPI(entryPointPath, options);
+  if (!analysisResult.success) {
+    return analysisResult;
+  }
+  const isExported = analysisResult.data.resolvedExports.some((exp) => exp.name === symbolName);
+  return ok2(isExported);
+}
+function getExportedSymbolInfo(entryPointPath, symbolName, options) {
+  const analysisResult = analyzePublicAPI(entryPointPath, options);
+  if (!analysisResult.success) {
+    return analysisResult;
+  }
+  const exported = analysisResult.data.resolvedExports.find((exp) => exp.name === symbolName);
+  return ok2(exported);
+}
+function getExportsByKind(entryPointPath, kind, options) {
+  const analysisResult = analyzePublicAPI(entryPointPath, options);
+  if (!analysisResult.success) {
+    return analysisResult;
+  }
+  const filtered = analysisResult.data.resolvedExports.filter((exp) => exp.kind === kind);
+  return ok2(filtered);
+}
+
+// src/parsers/guards.ts
+function isParseError(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return typeof obj.code === "string" && typeof obj.message === "string" && [
+    "INVALID_SYNTAX",
+    "FILE_NOT_FOUND",
+    "READ_ERROR",
+    "MALFORMED_JSON",
+    "UNSUPPORTED_FORMAT"
+  ].includes(obj.code);
+}
+function isSyncError(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return typeof obj.code === "string" && typeof obj.message === "string" && [
+    "WRITE_ERROR",
+    "VALIDATION_ERROR",
+    "GENERATION_ERROR",
+    "PACKAGE_NOT_FOUND",
+    "CONFIG_ERROR"
+  ].includes(obj.code);
+}
+function isJSDocParam(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return typeof obj.name === "string" && (obj.type === void 0 || typeof obj.type === "string") && (obj.description === void 0 || typeof obj.description === "string") && (obj.optional === void 0 || typeof obj.optional === "boolean") && (obj.defaultValue === void 0 || typeof obj.defaultValue === "string");
+}
+function isJSDocTag(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return typeof obj.name === "string" && (obj.value === void 0 || typeof obj.value === "string");
+}
+function isJSDocInfo(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return (obj.description === void 0 || typeof obj.description === "string") && (obj.params === void 0 || Array.isArray(obj.params) && obj.params.every(isJSDocParam)) && (obj.returns === void 0 || typeof obj.returns === "string") && (obj.examples === void 0 || Array.isArray(obj.examples) && obj.examples.every((e) => typeof e === "string")) && (obj.deprecated === void 0 || typeof obj.deprecated === "string") && (obj.since === void 0 || typeof obj.since === "string") && (obj.see === void 0 || Array.isArray(obj.see) && obj.see.every((s) => typeof s === "string")) && (obj.customTags === void 0 || Array.isArray(obj.customTags) && obj.customTags.every(isJSDocTag));
+}
+function isExportedFunction(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return typeof obj.name === "string" && typeof obj.signature === "string" && typeof obj.isAsync === "boolean" && typeof obj.isGenerator === "boolean" && Array.isArray(obj.parameters) && typeof obj.returnType === "string" && typeof obj.isDefault === "boolean";
+}
+function isExportedType(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return typeof obj.name === "string" && typeof obj.definition === "string" && typeof obj.kind === "string" && ["interface", "type", "enum", "class"].includes(obj.kind) && typeof obj.isDefault === "boolean";
+}
+function isReExport(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return typeof obj.from === "string" && (obj.exports === "*" || Array.isArray(obj.exports) && obj.exports.every((e) => typeof e === "string"));
+}
+function isPackageAPI(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return Array.isArray(obj.functions) && obj.functions.every(isExportedFunction) && Array.isArray(obj.types) && obj.types.every(isExportedType) && Array.isArray(obj.reExports) && obj.reExports.every(isReExport);
+}
+function isDocConfigSource(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return (obj.title === void 0 || typeof obj.title === "string") && (obj.description === void 0 || typeof obj.description === "string") && (obj.sidebar === void 0 || typeof obj.sidebar === "object") && (obj.excludeSections === void 0 || Array.isArray(obj.excludeSections) && obj.excludeSections.every((s) => typeof s === "string")) && (obj.frontmatter === void 0 || typeof obj.frontmatter === "object");
+}
+function isPackageInfo(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return typeof obj.name === "string" && typeof obj.version === "string" && typeof obj.packagePath === "string" && typeof obj.srcPath === "string" && (obj.description === void 0 || typeof obj.description === "string") && (obj.keywords === void 0 || Array.isArray(obj.keywords) && obj.keywords.every((k) => typeof k === "string")) && (obj.readmePath === void 0 || typeof obj.readmePath === "string") && (obj.docsConfig === void 0 || isDocConfigSource(obj.docsConfig));
+}
+function isReadmeSection(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return typeof obj.heading === "string" && typeof obj.level === "number" && obj.level >= 1 && obj.level <= 6 && typeof obj.content === "string" && Array.isArray(obj.children) && obj.children.every(isReadmeSection);
+}
+function isReadmeContent(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return (obj.title === void 0 || typeof obj.title === "string") && (obj.preamble === void 0 || typeof obj.preamble === "string") && Array.isArray(obj.sections) && obj.sections.every(isReadmeSection) && typeof obj.raw === "string";
+}
+function isMDXFrontmatter(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return typeof obj.title === "string" && (obj.description === void 0 || typeof obj.description === "string") && (obj.sidebar === void 0 || typeof obj.sidebar === "object") && (obj.tableOfContents === void 0 || typeof obj.tableOfContents === "boolean" || typeof obj.tableOfContents === "object") && (obj.template === void 0 || obj.template === "doc" || obj.template === "splash");
+}
+function isValidPackageName(name) {
+  if (name.length === 0) {
+    return false;
+  }
+  if (name.startsWith(".") || name.startsWith("_")) {
+    return false;
+  }
+  if (name.startsWith("@")) {
+    const slashIndex = name.indexOf("/");
+    if (slashIndex <= 1 || slashIndex === name.length - 1) {
+      return false;
+    }
+    const scope = name.slice(1, slashIndex);
+    const pkg = name.slice(slashIndex + 1);
+    return isValidUnscopedPackageName(scope) && isValidUnscopedPackageName(pkg);
+  }
+  return isValidUnscopedPackageName(name);
+}
+function isValidUnscopedPackageName(name) {
+  return /^\w[\w.-]*$/.test(name);
+}
+function isValidSemver(version) {
+  return /^\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.test(version);
+}
+function isValidHeadingLevel(level) {
+  return Number.isInteger(level) && level >= 1 && level <= 6;
+}
+function isSafeContent(content) {
+  const dangerousPatterns = [/<script\b/i, /javascript:/i, /on\w+\s*=/i, /data:/i, /vbscript:/i];
+  return !dangerousPatterns.some((pattern) => pattern.test(content));
+}
+function isSafeFilePath(filePath) {
+  const normalizedPath = filePath.replaceAll("\\", "/").replaceAll(/\/+/g, "/").replaceAll("/./", "/");
+  if (normalizedPath.includes("../") || normalizedPath.includes("..\\")) {
+    return false;
+  }
+  if (normalizedPath.startsWith("/") && !filePath.startsWith("/")) {
+    return false;
+  }
+  return true;
+}
+function assertParseError(value) {
+  if (!isParseError(value)) {
+    throw new TypeError("Expected ParseError");
+  }
+}
+function assertPackageInfo(value) {
+  if (!isPackageInfo(value)) {
+    throw new TypeError("Expected PackageInfo");
+  }
+}
+function assertPackageAPI(value) {
+  if (!isPackageAPI(value)) {
+    throw new TypeError("Expected PackageAPI");
+  }
+}
+
+// src/parsers/package-info.ts
+import path from "path";
+import { err as err2, ok as ok3 } from "@bfra.me/es/result";
+async function parsePackageJson(packagePath, options) {
+  const packageJsonPath = packagePath.endsWith("package.json") ? packagePath : path.join(packagePath, "package.json");
+  try {
+    const fs = await import("fs/promises");
+    const content = await fs.readFile(packageJsonPath, "utf-8");
+    return parsePackageJsonContent(content, packageJsonPath, options);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return err2({
+        code: "FILE_NOT_FOUND",
+        message: `package.json not found: ${packageJsonPath}`,
+        filePath: packageJsonPath,
+        cause: error
+      });
+    }
+    return err2({
+      code: "READ_ERROR",
+      message: `Failed to read package.json: ${packageJsonPath}`,
+      filePath: packageJsonPath,
+      cause: error
+    });
+  }
+}
+function parsePackageJsonContent(content, filePath, options) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (error) {
+    return err2({
+      code: "MALFORMED_JSON",
+      message: `Invalid JSON in package.json: ${filePath}`,
+      filePath,
+      cause: error
+    });
+  }
+  if (!isPackageJson(parsed)) {
+    return err2({
+      code: "INVALID_SYNTAX",
+      message: "package.json is missing required fields (name, version)",
+      filePath
+    });
+  }
+  const packageDir = path.dirname(filePath);
+  return ok3({
+    name: parsed.name,
+    version: parsed.version,
+    ...parsed.description !== void 0 && { description: parsed.description },
+    ...parsed.keywords !== void 0 && { keywords: parsed.keywords },
+    packagePath: packageDir,
+    srcPath: path.join(packageDir, "src"),
+    ...options?.extractDocsConfig !== false && parsed.docs !== void 0 && { docsConfig: parsed.docs }
+  });
+}
+function isPackageJson(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  if (typeof obj.name !== "string" || obj.name.length === 0) {
+    return false;
+  }
+  if (typeof obj.version !== "string" || obj.version.length === 0) {
+    return false;
+  }
+  return true;
+}
+function extractDocsConfig(pkg) {
+  return pkg.docsConfig;
+}
+async function findReadmePath(packagePath) {
+  const fs = await import("fs/promises");
+  const candidates = ["README.md", "readme.md", "Readme.md", "README.MD", "README"];
+  for (const candidate of candidates) {
+    const readmePath = path.join(packagePath, candidate);
+    try {
+      await fs.access(readmePath);
+      return readmePath;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function findEntryPoint(pkg, content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed.exports !== void 0) {
+      const mainExport = parsed.exports["."];
+      if (mainExport !== void 0 && typeof mainExport === "object") {
+        const exportObj = mainExport;
+        if (typeof exportObj.source === "string") {
+          return path.join(pkg.packagePath, exportObj.source);
+        }
+        if (typeof exportObj.import === "string") {
+          const importPath = exportObj.import;
+          if (importPath.includes("/lib/")) {
+            return path.join(
+              pkg.packagePath,
+              importPath.replace("/lib/", "/src/").replace(".js", ".ts")
+            );
+          }
+          return path.join(pkg.packagePath, importPath);
+        }
+      }
+      if (typeof mainExport === "string") {
+        return path.join(pkg.packagePath, mainExport);
+      }
+    }
+    if (typeof parsed.types === "string") {
+      const typesPath = parsed.types.replace("/lib/", "/src/").replace(".d.ts", ".ts");
+      return path.join(pkg.packagePath, typesPath);
+    }
+    if (typeof parsed.main === "string") {
+      const mainPath = parsed.main.replace("/lib/", "/src/").replace(".js", ".ts");
+      return path.join(pkg.packagePath, mainPath);
+    }
+  } catch {
+  }
+  return path.join(pkg.srcPath, "index.ts");
+}
+async function parsePackageComplete(packagePath, options) {
+  const packageInfoResult = await parsePackageJson(packagePath, options);
+  if (!packageInfoResult.success) {
+    return packageInfoResult;
+  }
+  const readmePath = await findReadmePath(packageInfoResult.data.packagePath);
+  return ok3({
+    ...packageInfoResult.data,
+    ...readmePath !== void 0 && { readmePath }
+  });
+}
+function getPackageScope(packageName) {
+  if (packageName.startsWith("@")) {
+    const slashIndex = packageName.indexOf("/");
+    if (slashIndex > 0) {
+      return packageName.slice(0, slashIndex);
+    }
+  }
+  return void 0;
+}
+function getUnscopedName(packageName) {
+  if (packageName.startsWith("@")) {
+    const slashIndex = packageName.indexOf("/");
+    if (slashIndex > 0) {
+      return packageName.slice(slashIndex + 1);
+    }
+  }
+  return packageName;
+}
+function buildDocSlug(packageName) {
+  return getUnscopedName(packageName).toLowerCase().replaceAll(/[^a-z0-9-]/g, "-");
+}
+
+// src/parsers/readme-parser.ts
+import { err as err3, ok as ok4 } from "@bfra.me/es/result";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+function parseReadme(content, options) {
+  try {
+    const processor = unified().use(remarkParse);
+    const tree = processor.parse(content);
+    const title = extractTitle(tree);
+    const preamble = extractPreamble(tree);
+    const sections = options?.extractSections === false ? [] : extractSections(tree);
+    return ok4({
+      ...title !== void 0 && { title },
+      ...preamble !== void 0 && { preamble },
+      sections,
+      raw: options?.preserveRaw === false ? "" : content
+    });
+  } catch (error) {
+    return err3({
+      code: "INVALID_SYNTAX",
+      message: "Failed to parse README content",
+      cause: error
+    });
+  }
+}
+async function parseReadmeFile(filePath, options) {
+  try {
+    const fs = await import("fs/promises");
+    const content = await fs.readFile(filePath, "utf-8");
+    return parseReadme(content, options);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return err3({
+        code: "FILE_NOT_FOUND",
+        message: `README file not found: ${filePath}`,
+        filePath,
+        cause: error
+      });
+    }
+    return err3({
+      code: "READ_ERROR",
+      message: `Failed to read README file: ${filePath}`,
+      filePath,
+      cause: error
+    });
+  }
+}
+function extractTitle(tree) {
+  for (const node of tree.children) {
+    if (node.type === "heading" && node.depth === 1) {
+      return extractTextFromNode(node);
+    }
+  }
+  return void 0;
+}
+function extractPreamble(tree) {
+  const preambleNodes = [];
+  for (const node of tree.children) {
+    if (node.type === "heading") {
+      break;
+    }
+    preambleNodes.push(node);
+  }
+  if (preambleNodes.length === 0) {
+    return void 0;
+  }
+  const text = preambleNodes.map(extractTextFromNode).join("\n\n").trim();
+  return text.length > 0 ? text : void 0;
+}
+function extractSections(tree) {
+  const sections = [];
+  const stack = [];
+  for (let i = 0; i < tree.children.length; i++) {
+    const node = tree.children[i];
+    if (node !== void 0 && node.type === "heading") {
+      const heading = extractTextFromNode(node);
+      const level = node.depth;
+      const content = extractSectionContent(tree, i + 1);
+      const newSection = {
+        heading,
+        level,
+        content,
+        children: []
+      };
+      while (stack.length > 0 && (stack.at(-1)?.level ?? 0) >= level) {
+        stack.pop();
+      }
+      if (stack.length === 0) {
+        sections.push(newSection);
+      } else {
+        const parent = stack.at(-1);
+        parent?.section.children.push(newSection);
+      }
+      stack.push({ level, section: newSection });
+    }
+  }
+  return freezeSections(sections);
+}
+function freezeSections(sections) {
+  return sections.map((s) => ({
+    heading: s.heading,
+    level: s.level,
+    content: s.content,
+    children: freezeSections([...s.children])
+  }));
+}
+function extractSectionContent(tree, startIndex) {
+  const contentNodes = [];
+  for (let i = startIndex; i < tree.children.length; i++) {
+    const node = tree.children[i];
+    if (node === void 0 || node.type === "heading") {
+      break;
+    }
+    contentNodes.push(node);
+  }
+  return contentNodes.map(serializeNode).join("\n\n").trim();
+}
+function extractTextFromNode(node) {
+  if ("value" in node && typeof node.value === "string") {
+    return node.value;
+  }
+  if ("children" in node && Array.isArray(node.children)) {
+    return node.children.map(extractTextFromNode).join("");
+  }
+  return "";
+}
+function serializeNode(node) {
+  if (node.type === "paragraph") {
+    return extractTextFromNode(node);
+  }
+  if (node.type === "heading") {
+    const prefix = "#".repeat(node.depth);
+    return `${prefix} ${extractTextFromNode(node)}`;
+  }
+  if (node.type === "code") {
+    return `\`\`\`${node.lang ?? ""}
+${node.value}
+\`\`\``;
+  }
+  if (node.type === "blockquote") {
+    return node.children.map((c) => `> ${serializeNode(c)}`).join("\n");
+  }
+  if (node.type === "list") {
+    const items = node.children.map((item, index) => {
+      if (item.type !== "listItem") return "";
+      const prefix = node.ordered === true ? `${index + 1}. ` : "- ";
+      const content = item.children.map(serializeNode).join("\n");
+      return `${prefix}${content}`;
+    }).filter((s) => s.length > 0);
+    return items.join("\n");
+  }
+  if (node.type === "thematicBreak") {
+    return "---";
+  }
+  if (node.type === "html") {
+    return node.value;
+  }
+  if (node.type === "table") {
+    return serializeTable(node);
+  }
+  return extractTextFromNode(node);
+}
+function serializeTable(node) {
+  if (node.type !== "table" || !("children" in node)) {
+    return "";
+  }
+  const rows = node.children.filter((row) => row.type === "tableRow").map((row) => {
+    const cells = row.children.filter((cell) => cell.type === "tableCell").map((cell) => extractTextFromNode(cell));
+    return `| ${cells.join(" | ")} |`;
+  });
+  if (rows.length === 0) {
+    return "";
+  }
+  const headerRow = rows[0];
+  if (headerRow !== void 0) {
+    const columnCount = (headerRow.match(/\|/g)?.length ?? 2) - 1;
+    const separator = `|${" --- |".repeat(columnCount)}`;
+    rows.splice(1, 0, separator);
+  }
+  return rows.join("\n");
+}
+function findSection(content, headingText) {
+  const normalizedSearch = headingText.toLowerCase();
+  function searchInSections(sections) {
+    for (const section of sections) {
+      if (section.heading.toLowerCase() === normalizedSearch) {
+        return section;
+      }
+      const found = searchInSections(section.children);
+      if (found !== void 0) {
+        return found;
+      }
+    }
+    return void 0;
+  }
+  return searchInSections(content.sections);
+}
+function getSectionsByLevel(content, level) {
+  const result = [];
+  function collectAtLevel(sections) {
+    for (const section of sections) {
+      if (section.level === level) {
+        result.push(section);
+      }
+      collectAtLevel(section.children);
+    }
+  }
+  collectAtLevel(content.sections);
+  return result;
+}
+function flattenSections(content) {
+  const result = [];
+  function collect(sections) {
+    for (const section of sections) {
+      result.push(section);
+      collect(section.children);
+    }
+  }
+  collect(content.sections);
+  return result;
+}
+function getTableOfContents(content) {
+  return flattenSections(content).map((s) => ({
+    heading: s.heading,
+    level: s.level
+  }));
+}
+
+export {
+  hasJSDoc,
+  extractJSDocInfo,
+  parseJSDoc,
+  createProject,
+  parseSourceFile,
+  parseSourceContent,
+  extractExportedFunctions,
+  extractExportedTypes,
+  extractReExports,
+  extractPackageAPI,
+  analyzeTypeScriptFile,
+  analyzeTypeScriptContent,
+  analyzePublicAPI,
+  findExportedSymbols,
+  isSymbolExported,
+  getExportedSymbolInfo,
+  getExportsByKind,
+  isParseError,
+  isSyncError,
+  isJSDocParam,
+  isJSDocTag,
+  isJSDocInfo,
+  isExportedFunction,
+  isExportedType,
+  isReExport,
+  isPackageAPI,
+  isDocConfigSource,
+  isPackageInfo,
+  isReadmeSection,
+  isReadmeContent,
+  isMDXFrontmatter,
+  isValidPackageName,
+  isValidSemver,
+  isValidHeadingLevel,
+  isSafeContent,
+  isSafeFilePath,
+  assertParseError,
+  assertPackageInfo,
+  assertPackageAPI,
+  parsePackageJson,
+  parsePackageJsonContent,
+  extractDocsConfig,
+  findReadmePath,
+  findEntryPoint,
+  parsePackageComplete,
+  getPackageScope,
+  getUnscopedName,
+  buildDocSlug,
+  parseReadme,
+  parseReadmeFile,
+  findSection,
+  getSectionsByLevel,
+  flattenSections,
+  getTableOfContents
+};
+//# sourceMappingURL=chunk-6NKAJT2M.js.map