fumadocs-typescript 2.1.0 → 3.0.1

package/dist/{base-CqMIWAcs.d.ts → base-BltLCalB.d.ts}

@@ -1,16 +1,12 @@
-import ts from 'typescript';
+import { Project, ExportedDeclarations, Type, Symbol } from 'ts-morph';
 
 interface TypescriptConfig {
     files?: string[];
     tsconfigPath?: string;
     /** A root directory to resolve relative path entries in the config file to. e.g. outDir */
     basePath?: string;
-    /**
-     * Default lib directory, use `./node_modules/typescript/lib` if not specified
-     */
-    getDefaultLibLocation?: (() => string) | 'default';
 }
-declare function getProgram(options?: TypescriptConfig): ts.Program;
+declare function getProject(options?: TypescriptConfig): Project;
 
 interface GeneratedDoc {
     name: string;
@@ -24,13 +20,12 @@ interface DocEntry {
     tags: Record<string, string>;
 }
 interface EntryContext {
-    program: ts.Program;
-    checker: ts.TypeChecker;
+    program: Project;
     transform?: Transformer;
-    type: ts.Type;
-    symbol: ts.Symbol;
+    type: Type;
+    declaration: ExportedDeclarations;
 }
-type Transformer = (this: EntryContext, entry: DocEntry, propertyType: ts.Type, propertySymbol: ts.Symbol) => void;
+type Transformer = (this: EntryContext, entry: DocEntry, propertyType: Type, propertySymbol: Symbol) => void;
 interface GenerateOptions {
     /**
      * Allow fields with `@internal` tag
@@ -47,14 +42,13 @@ interface GenerateDocumentationOptions extends GenerateOptions {
     /**
      * Typescript configurations
      */
-    config?: TypescriptConfig | {
-        program: ts.Program;
-    };
+    config?: TypescriptConfig;
+    project?: Project;
 }
 /**
  * Generate documentation for properties in an exported type/interface
  */
-declare function generateDocumentation(file: string, name: string, options?: GenerateDocumentationOptions): GeneratedDoc | undefined;
-declare function generate(program: ts.Program, symbol: ts.Symbol, { allowInternal, transform }: GenerateOptions): GeneratedDoc;
+declare function generateDocumentation(file: string, name: string | undefined, content: string, options?: GenerateDocumentationOptions): GeneratedDoc[];
+declare function generate(program: Project, name: string, declaration: ExportedDeclarations, { allowInternal, transform }: GenerateOptions): GeneratedDoc;
 
-export { type DocEntry as D, type GenerateOptions as G, type TypescriptConfig as T, type GeneratedDoc as a, type GenerateDocumentationOptions as b, generateDocumentation as c, generate as d, getProgram as g };
+export { type DocEntry as D, type GenerateDocumentationOptions as G, type GeneratedDoc as a, type GenerateOptions as b, generateDocumentation as c, generate as d, getProject as g };

package/dist/chunk-XZ3O77SF.js

@@ -0,0 +1,200 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/get-project.ts
+import { Project } from "ts-morph";
+function getProject(options = {}) {
+  var _a;
+  return new Project({
+    tsConfigFilePath: (_a = options.tsconfigPath) != null ? _a : "./tsconfig.json",
+    skipAddingFilesFromTsConfig: true
+  });
+}
+
+// src/generate/base.ts
+import {
+  ts
+} from "ts-morph";
+function generateDocumentation(file, name, content, options = {}) {
+  var _a;
+  const project = (_a = options.project) != null ? _a : getProject(options.config);
+  const sourceFile = project.createSourceFile(file, content, {
+    overwrite: true
+  });
+  const out = [];
+  for (const [k, d] of sourceFile.getExportedDeclarations()) {
+    if (name && name !== k) continue;
+    if (d.length > 1)
+      console.warn(
+        `export ${k} should not have more than one type declaration.`
+      );
+    out.push(generate(project, k, d[0], options));
+  }
+  return out;
+}
+function generate(program, name, declaration, { allowInternal = false, transform }) {
+  var _a;
+  const entryContext = {
+    transform,
+    program,
+    type: declaration.getType(),
+    declaration
+  };
+  const comment = (_a = declaration.getSymbol()) == null ? void 0 : _a.compilerSymbol.getDocumentationComment(
+    program.getTypeChecker().compilerObject
+  );
+  return {
+    name,
+    description: comment ? ts.displayPartsToString(comment) : "",
+    entries: declaration.getType().getProperties().map((prop) => getDocEntry(prop, entryContext)).filter((entry) => allowInternal || !("internal" in entry.tags))
+  };
+}
+function getDocEntry(prop, context) {
+  var _a, _b, _c, _d;
+  const { transform, program } = context;
+  const subType = program.getTypeChecker().getTypeOfSymbolAtLocation(prop, context.declaration);
+  const tags = Object.fromEntries(
+    prop.getJsDocTags().map((tag) => [tag.getName(), ts.displayPartsToString(tag.getText())])
+  );
+  let typeName = subType.getNonNullableType().getText(void 0, ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+  if (subType.getAliasSymbol() && subType.getAliasTypeArguments().length === 0) {
+    typeName = (_b = (_a = subType.getAliasSymbol()) == null ? void 0 : _a.getEscapedName()) != null ? _b : typeName;
+  }
+  if ("remarks" in tags) {
+    typeName = (_d = (_c = new RegExp("^`(?<name>.+)`").exec(tags.remarks)) == null ? void 0 : _c[1]) != null ? _d : typeName;
+  }
+  const entry = {
+    name: prop.getName(),
+    description: ts.displayPartsToString(
+      prop.compilerSymbol.getDocumentationComment(
+        program.getTypeChecker().compilerObject
+      )
+    ),
+    tags,
+    type: typeName
+  };
+  transform == null ? void 0 : transform.call(context, entry, subType, prop);
+  return entry;
+}
+
+// src/markdown.ts
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { toHast } from "mdast-util-to-hast";
+import { getSingletonHighlighter } from "shiki";
+function renderMarkdownToHast(md) {
+  return __async(this, null, function* () {
+    const mdast = fromMarkdown(
+      md.replace(new RegExp("{@link (?<link>[^}]*)}", "g"), "$1"),
+      // replace jsdoc links
+      { mdastExtensions: [gfmFromMarkdown()] }
+    );
+    const highlighter = yield getSingletonHighlighter({
+      themes: ["vitesse-light", "vitesse-dark"]
+    });
+    function preload(contents) {
+      return __async(this, null, function* () {
+        yield Promise.all(
+          contents.map((c) => __async(this, null, function* () {
+            if ("children" in c) yield preload(c.children);
+            if (c.type === "code" && c.lang) {
+              yield highlighter.loadLanguage(
+                c.lang
+              );
+            }
+          }))
+        );
+      });
+    }
+    yield preload(mdast.children);
+    return toHast(mdast, {
+      handlers: {
+        // @ts-expect-error hast with mdx
+        code(_, node) {
+          var _a;
+          const lang = (_a = node.lang) != null ? _a : "plaintext";
+          return highlighter.codeToHast(node.value, {
+            lang,
+            themes: {
+              light: "vitesse-light",
+              dark: "vitesse-dark"
+            },
+            defaultColor: false,
+            transformers: [
+              {
+                name: "rehype-code:pre-process",
+                line(hast) {
+                  if (hast.children.length > 0) return;
+                  hast.children.push({
+                    type: "text",
+                    value: " "
+                  });
+                }
+              }
+            ]
+          }).children;
+        }
+      }
+    });
+  });
+}
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __objRest,
+  __async,
+  getProject,
+  generateDocumentation,
+  generate,
+  renderMarkdownToHast
+};

package/dist/index.d.ts

@@ -1,22 +1,21 @@
-import { G as GenerateOptions, T as TypescriptConfig, a as GeneratedDoc, D as DocEntry } from './base-CqMIWAcs.js';
-export { b as GenerateDocumentationOptions, d as generate, c as generateDocumentation, g as getProgram } from './base-CqMIWAcs.js';
+import { G as GenerateDocumentationOptions, a as GeneratedDoc, D as DocEntry } from './base-BltLCalB.js';
+export { b as GenerateOptions, d as generate, c as generateDocumentation, g as getProject } from './base-BltLCalB.js';
 import fg from 'fast-glob';
 import { Nodes } from 'hast';
-import 'typescript';
+import 'ts-morph';
 
 interface Templates {
     block: (doc: GeneratedDoc, children: string) => string;
     property: (entry: DocEntry) => string;
 }
-interface GenerateMDXOptions extends GenerateOptions {
+interface GenerateMDXOptions extends GenerateDocumentationOptions {
     /**
      * a root directory to resolve relative file paths
      */
     basePath?: string;
     templates?: Partial<Templates>;
-    config?: TypescriptConfig;
 }
-declare function generateMDX(source: string, { basePath, templates: overrides, config: options, ...rest }?: GenerateMDXOptions): string;
+declare function generateMDX(source: string, { basePath, templates: overrides, ...rest }?: GenerateMDXOptions): string;
 
 interface GenerateFilesOptions {
     input: string | string[];
@@ -33,6 +32,6 @@ interface GenerateFilesOptions {
 }
 declare function generateFiles(options: GenerateFilesOptions): Promise<void>;
 
-declare function renderMarkdownToHast(md: string): Nodes;
+declare function renderMarkdownToHast(md: string): Promise<Nodes>;
 
-export { DocEntry, type GenerateFilesOptions, type GenerateMDXOptions, GenerateOptions, GeneratedDoc, generateFiles, generateMDX, renderMarkdownToHast };
+export { DocEntry, GenerateDocumentationOptions, type GenerateFilesOptions, type GenerateMDXOptions, GeneratedDoc, generateFiles, generateMDX, renderMarkdownToHast };

package/dist/index.js

@@ -1,16 +1,17 @@
 import {
   __async,
   __objRest,
+  __spreadProps,
   __spreadValues,
   generate,
   generateDocumentation,
-  getFileSymbol,
-  getProgram,
+  getProject,
   renderMarkdownToHast
-} from "./chunk-HGR3BUTN.js";
+} from "./chunk-XZ3O77SF.js";
 
 // src/generate/mdx.ts
-import * as path from "path";
+import * as path from "node:path";
+import fs from "node:fs";
 var regex = new RegExp("^---type-table---\\r?\\n(?<file>.+?)(?:#(?<name>.+))?\\r?\\n---end---$", "gm");
 var defaultTemplates = {
   block: (doc, c) => `### ${doc.name}
@@ -33,30 +34,17 @@ ${replaceJsDocLinks(value)}`).join("\n")}
 </div>`
 };
 function generateMDX(source, _a = {}) {
-  var _b = _a, {
-    basePath = "./",
-    templates: overrides,
-    config: options
-  } = _b, rest = __objRest(_b, [
-    "basePath",
-    "templates",
-    "config"
-  ]);
+  var _b = _a, { basePath = "./", templates: overrides } = _b, rest = __objRest(_b, ["basePath", "templates"]);
+  var _a2;
   const templates = __spreadValues(__spreadValues({}, defaultTemplates), overrides);
-  const program = getProgram(options);
+  const project = (_a2 = rest.project) != null ? _a2 : getProject(rest.config);
   return source.replace(regex, (...args) => {
     const groups = args[args.length - 1];
     const file = path.resolve(basePath, groups.file);
-    const fileSymbol = getFileSymbol(file, program);
-    if (!fileSymbol) throw new Error(`${file} doesn't exist`);
-    let docs;
-    if (!groups.name) {
-      docs = program.getTypeChecker().getExportsOfModule(fileSymbol).map((symbol) => generate(program, symbol, rest));
-    } else {
-      const symbol = program.getTypeChecker().getExportsOfModule(fileSymbol).find((s) => s.getEscapedName().toString() === groups.name);
-      if (!symbol) throw new Error(`Type ${groups.name} doesn't exist`);
-      docs = [generate(program, symbol, rest)];
-    }
+    const content = fs.readFileSync(file);
+    const docs = generateDocumentation(file, groups.name, content.toString(), __spreadProps(__spreadValues({}, rest), {
+      project
+    }));
     return docs.map(
       (doc) => templates.block(doc, doc.entries.map(templates.property).join("\n"))
     ).join("\n\n");
@@ -67,12 +55,14 @@ function replaceJsDocLinks(md) {
 }
 
 // src/generate/file.ts
-import * as path2 from "path";
-import { mkdir, writeFile, readFile } from "fs/promises";
+import * as path2 from "node:path";
+import { mkdir, writeFile, readFile } from "node:fs/promises";
 import fg from "fast-glob";
 function generateFiles(options) {
   return __async(this, null, function* () {
+    var _a, _b, _c;
     const files = yield fg(options.input, options.globOptions);
+    const project = (_c = (_a = options.options) == null ? void 0 : _a.project) != null ? _c : getProject((_b = options.options) == null ? void 0 : _b.config);
     const produce = files.map((file) => __async(this, null, function* () {
       const absolutePath = path2.resolve(file);
       const outputPath = typeof options.output === "function" ? options.output(file) : path2.resolve(
@@ -80,9 +70,11 @@ function generateFiles(options) {
         `${path2.basename(file, path2.extname(file))}.mdx`
       );
       const content = (yield readFile(absolutePath)).toString();
-      let result = generateMDX(content, __spreadValues({
+      let result = generateMDX(content, __spreadProps(__spreadValues({
         basePath: path2.dirname(absolutePath)
-      }, options.options));
+      }, options.options), {
+        project
+      }));
       if (options.transformOutput) {
         result = options.transformOutput(outputPath, result);
       }
@@ -103,6 +95,6 @@ export {
   generateDocumentation,
   generateFiles,
   generateMDX,
-  getProgram,
+  getProject,
   renderMarkdownToHast
 };

package/dist/ui/index.d.ts

@@ -1,15 +1,47 @@
-import { G as GenerateOptions } from '../base-CqMIWAcs.js';
-import 'typescript';
+import { G as GenerateDocumentationOptions } from '../base-BltLCalB.js';
+import 'ts-morph';
 
+interface AutoTypeTableProps {
+    /**
+     * The path to source TypeScript file.
+     */
+    path?: string;
+    /**
+     * Exported type name to generate from.
+     */
+    name?: string;
+    /**
+     * Set the type to generate from.
+     *
+     * When used with `name`, it generates the type with `name` as export name.
+     *
+     * ```ts
+     * export const myName = MyType;
+     * ```
+     *
+     * When `type` contains multiple lines, `export const` is not added.
+     * You need to export it manually, and specify the type name with `name`.
+     *
+     * ```tsx
+     * <AutoTypeTable
+     *   path="./file.ts"
+     *   type={`import { ReactNode } from "react"
+     *   export const MyName = ReactNode`}
+     *   name="MyName"
+     * />
+     * ```
+     */
+    type?: string;
+    options?: GenerateDocumentationOptions;
+}
+declare function createTypeTable(options?: GenerateDocumentationOptions): {
+    AutoTypeTable: (props: Omit<AutoTypeTableProps, 'options'>) => React.ReactNode;
+};
 /**
  * **Server Component Only**
  *
  * Display properties in an exported interface via Type Table
  */
-declare function AutoTypeTable({ path, name, options, }: {
-    path: string;
-    name: string;
-    options?: GenerateOptions;
-}): React.ReactElement;
+declare function AutoTypeTable({ path, name, type, options, }: AutoTypeTableProps): Promise<React.ReactElement>;
 
-export { AutoTypeTable };
+export { AutoTypeTable, type AutoTypeTableProps, createTypeTable };

package/dist/ui/index.js

@@ -1,44 +1,92 @@
 import {
+  __async,
+  __spreadProps,
+  __spreadValues,
   generateDocumentation,
+  getProject,
   renderMarkdownToHast
-} from "../chunk-HGR3BUTN.js";
+} from "../chunk-XZ3O77SF.js";
 
 // src/ui/auto-type-table.tsx
+import fs from "node:fs/promises";
 import { TypeTable } from "fumadocs-ui/components/type-table";
 import { toJsxRuntime } from "hast-util-to-jsx-runtime";
 import * as runtime from "react/jsx-runtime";
+import defaultMdxComponents from "fumadocs-ui/mdx";
 import "server-only";
-import { jsx as jsx2 } from "react/jsx-runtime";
-function AutoTypeTable({
-  path,
-  name,
-  options
-}) {
-  const output = generateDocumentation(path, name, options);
-  if (!output) throw new Error(`${name} in ${path} doesn't exist`);
-  return /* @__PURE__ */ jsx2(
-    TypeTable,
-    {
-      type: Object.fromEntries(
-        output.entries.map((entry) => [
-          entry.name,
-          {
-            type: entry.type,
-            description: renderMarkdown(entry.description),
-            default: entry.tags.default || entry.tags.defaultValue
-          }
-        ])
-      )
+import { Fragment as Fragment2, jsx as jsx2 } from "react/jsx-runtime";
+function createTypeTable(options = {}) {
+  var _a;
+  const project = (_a = options.project) != null ? _a : getProject(options.config);
+  return {
+    AutoTypeTable(props) {
+      return /* @__PURE__ */ jsx2(AutoTypeTable, __spreadProps(__spreadValues({}, props), { options: __spreadProps(__spreadValues({}, options), { project }) }));
     }
-  );
+  };
+}
+function AutoTypeTable(_0) {
+  return __async(this, arguments, function* ({
+    path,
+    name,
+    type,
+    options = {}
+  }) {
+    let typeName = name;
+    let content = "";
+    if (path) {
+      content = yield fs.readFile(path).then((res) => res.toString());
+    }
+    if (type && type.split("\n").length > 1) {
+      content += `
+${type}`;
+    } else if (type) {
+      typeName != null ? typeName : typeName = "$Fumadocs";
+      content += `
+export type ${typeName} = ${type}`;
+    }
+    const output = generateDocumentation(
+      path != null ? path : "temp.ts",
+      typeName,
+      content,
+      options
+    );
+    if (name && output.length === 0)
+      throw new Error(`${name} in ${path != null ? path : "empty file"} doesn't exist`);
+    return /* @__PURE__ */ jsx2(Fragment2, { children: output.map((item) => __async(this, null, function* () {
+      const entries = item.entries.map(
+        (entry) => __async(this, null, function* () {
+          return [
+            entry.name,
+            {
+              type: entry.type,
+              description: yield renderMarkdown(entry.description),
+              default: entry.tags.default || entry.tags.defaultValue
+            }
+          ];
+        })
+      );
+      return /* @__PURE__ */ jsx2(
+        TypeTable,
+        {
+          type: Object.fromEntries(yield Promise.all(entries))
+        },
+        item.name
+      );
+    })) });
+  });
 }
 function renderMarkdown(md) {
-  return toJsxRuntime(renderMarkdownToHast(md), {
-    Fragment: runtime.Fragment,
-    jsx: runtime.jsx,
-    jsxs: runtime.jsxs
+  return __async(this, null, function* () {
+    return toJsxRuntime(yield renderMarkdownToHast(md), {
+      Fragment: runtime.Fragment,
+      jsx: runtime.jsx,
+      jsxs: runtime.jsxs,
+      // @ts-expect-error -- mdx components
+      components: __spreadProps(__spreadValues({}, defaultMdxComponents), { img: void 0 })
+    });
   });
 }
 export {
-  AutoTypeTable
+  AutoTypeTable,
+  createTypeTable
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-typescript",
-  "version": "2.1.0",
+  "version": "3.0.1",
   "description": "Typescript Integration for Fumadocs",
   "keywords": [
     "NextJs",
@@ -24,32 +24,28 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "ui": [
-        "./dist/ui/index.d.ts"
-      ]
-    }
-  },
   "files": [
     "dist/*"
   ],
   "dependencies": {
+    "@types/node": "22.8.1",
     "fast-glob": "^3.3.1",
-    "hast-util-to-jsx-runtime": "^2.3.0",
-    "mdast-util-from-markdown": "^2.0.1",
+    "hast-util-to-jsx-runtime": "^2.3.2",
+    "mdast-util-from-markdown": "^2.0.2",
     "mdast-util-gfm": "^3.0.0",
-    "mdast-util-to-hast": "^13.2.0"
+    "mdast-util-to-hast": "^13.2.0",
+    "shiki": "^1.22.2",
+    "ts-morph": "^24.0.0"
   },
   "devDependencies": {
-    "@types/estree": "^1.0.5",
+    "@types/estree": "^1.0.6",
     "@types/hast": "^3.0.4",
     "@types/mdast": "^4.0.3",
-    "@types/react": "18.3.5",
-    "@types/react-dom": "18.3.0",
-    "typescript": "^5.5.4",
+    "@types/react": "18.3.12",
+    "@types/react-dom": "18.3.1",
+    "typescript": "^5.6.3",
+    "fumadocs-ui": "14.1.0",
     "eslint-config-custom": "0.0.0",
-    "fumadocs-ui": "13.4.2",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {

package/dist/chunk-HGR3BUTN.js

@@ -1,162 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve2, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve2(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
-// src/program.ts
-import * as path from "path";
-import ts from "typescript";
-function getFileSymbol(file, program) {
-  const checker = program.getTypeChecker();
-  const sourceFile = program.getSourceFile(file);
-  if (!sourceFile) return;
-  return checker.getSymbolAtLocation(sourceFile);
-}
-function getProgram(options = {}) {
-  var _a, _b, _c, _d;
-  const configFile = ts.readJsonConfigFile(
-    (_a = options.tsconfigPath) != null ? _a : "./tsconfig.json",
-    (p) => ts.sys.readFile(p)
-  );
-  const parsed = ts.parseJsonSourceFileConfigFileContent(
-    configFile,
-    ts.sys,
-    (_b = options.basePath) != null ? _b : "./"
-  );
-  parsed.options.incremental = false;
-  const host = ts.createCompilerHost(parsed.options);
-  if (options.getDefaultLibLocation !== "default") {
-    host.getDefaultLibLocation = (_c = options.getDefaultLibLocation) != null ? _c : () => path.resolve("./node_modules/typescript/lib");
-  }
-  return ts.createProgram({
-    rootNames: (_d = options.files) != null ? _d : parsed.fileNames,
-    host,
-    options: parsed.options,
-    configFileParsingDiagnostics: parsed.errors,
-    projectReferences: parsed.projectReferences
-  });
-}
-
-// src/generate/base.ts
-import ts2 from "typescript";
-function generateDocumentation(file, name, options = {}) {
-  const program = options.config && "program" in options.config ? options.config.program : getProgram(options.config);
-  const fileSymbol = getFileSymbol(file, program);
-  if (!fileSymbol) return;
-  const symbol = program.getTypeChecker().getExportsOfModule(fileSymbol).find((e) => e.getEscapedName().toString() === name);
-  if (!symbol) return;
-  return generate(program, symbol, options);
-}
-function generate(program, symbol, { allowInternal = false, transform }) {
-  const checker = program.getTypeChecker();
-  const type = checker.getDeclaredTypeOfSymbol(symbol);
-  const entryContext = {
-    checker,
-    transform,
-    program,
-    type,
-    symbol
-  };
-  return {
-    name: symbol.getEscapedName().toString(),
-    description: ts2.displayPartsToString(
-      symbol.getDocumentationComment(checker)
-    ),
-    entries: type.getProperties().map((prop) => getDocEntry(prop, entryContext)).filter((entry) => allowInternal || !("internal" in entry.tags))
-  };
-}
-function getDocEntry(prop, context) {
-  var _a, _b;
-  const { checker, transform } = context;
-  const subType = checker.getTypeOfSymbol(prop);
-  const tags = Object.fromEntries(
-    prop.getJsDocTags().map((tag) => [tag.name, ts2.displayPartsToString(tag.text)])
-  );
-  let typeName = checker.typeToString(
-    subType.getNonNullableType(),
-    void 0,
-    ts2.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope
-  );
-  if (subType.aliasSymbol && !subType.aliasTypeArguments) {
-    typeName = subType.aliasSymbol.escapedName.toString();
-  }
-  if (tags.remarks) {
-    typeName = (_b = (_a = new RegExp("^`(?<name>.+)`").exec(tags.remarks)) == null ? void 0 : _a[1]) != null ? _b : typeName;
-  }
-  const entry = {
-    name: prop.getName(),
-    description: ts2.displayPartsToString(prop.getDocumentationComment(checker)),
-    tags,
-    type: typeName
-  };
-  transform == null ? void 0 : transform.call(context, entry, subType, prop);
-  return entry;
-}
-
-// src/markdown.ts
-import { fromMarkdown } from "mdast-util-from-markdown";
-import { gfmFromMarkdown } from "mdast-util-gfm";
-import { toHast } from "mdast-util-to-hast";
-function renderMarkdownToHast(md) {
-  const mdast = fromMarkdown(
-    md.replace(new RegExp("{@link (?<link>[^}]*)}", "g"), "$1"),
-    // replace jsdoc links
-    { mdastExtensions: [gfmFromMarkdown()] }
-  );
-  return toHast(mdast);
-}
-
-export {
-  __spreadValues,
-  __objRest,
-  __async,
-  getFileSymbol,
-  getProgram,
-  generateDocumentation,
-  generate,
-  renderMarkdownToHast
-};