fumadocs-typescript 5.0.0 → 5.0.1

package/dist/index.js

@@ -1,438 +1,375 @@
-import {
-  __async,
-  __objRest,
-  __spreadProps,
-  __spreadValues,
-  parseTags,
-  renderMarkdownToHast,
-  renderTypeToHast
-} from "./chunk-H4DZJVYN.js";
-
-// src/lib/base.ts
-import {
-  Project as Project2,
-  ts as ts2
-} from "ts-morph";
+import { a as _asyncToGenerator, i as renderTypeToHast, n as parseTags, o as _objectWithoutProperties, r as renderMarkdownToHast, t as _objectSpread2 } from "./objectSpread2-BbbttTvx.js";
+import * as ts$1 from "ts-morph";
+import { Project, ts } from "ts-morph";
+import * as fs$1 from "node:fs/promises";
+import fs from "node:fs/promises";
+import path, { join } from "node:path";
+import { valueToEstree } from "estree-util-value-to-estree";
+import { visit } from "unist-util-visit";
+import { toEstree } from "hast-util-to-estree";
+import { createHash } from "node:crypto";
 
-// src/create-project.ts
-import { Project } from "ts-morph";
+//#region src/create-project.ts
 function createProject(options = {}) {
-  var _a;
-  return new Project({
-    tsConfigFilePath: (_a = options.tsconfigPath) != null ? _a : "./tsconfig.json",
-    skipAddingFilesFromTsConfig: true
-  });
+	var _options$tsconfigPath;
+	return new Project({
+		tsConfigFilePath: (_options$tsconfigPath = options.tsconfigPath) !== null && _options$tsconfigPath !== void 0 ? _options$tsconfigPath : "./tsconfig.json",
+		skipAddingFilesFromTsConfig: true
+	});
 }
 
-// src/lib/base.ts
-import fs2 from "fs/promises";
-
-// src/lib/type-table.ts
-import * as fs from "fs/promises";
-import { join } from "path";
-function getTypeTableOutput(gen, _a, options) {
-  return __async(this, null, function* () {
-    var _b = _a, { name, type } = _b, props = __objRest(_b, ["name", "type"]);
-    const file = props.path && (options == null ? void 0 : options.basePath) ? join(options.basePath, props.path) : props.path;
-    let typeName = name;
-    let content = "";
-    if (file) {
-      content = (yield fs.readFile(file)).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 = yield gen.generateDocumentation(
-      { path: file != null ? file : "temp.ts", content },
-      typeName,
-      options
-    );
-    if (name && output.length === 0)
-      throw new Error(`${name} in ${file != null ? file : "empty file"} doesn't exist`);
-    return output;
-  });
+//#endregion
+//#region src/lib/type-table.ts
+const _excluded = ["name", "type"];
+function getTypeTableOutput(_x, _x2, _x3) {
+	return _getTypeTableOutput.apply(this, arguments);
+}
+function _getTypeTableOutput() {
+	_getTypeTableOutput = _asyncToGenerator(function* (gen, _ref, options) {
+		let { name, type } = _ref, props = _objectWithoutProperties(_ref, _excluded);
+		const file = props.path && (options === null || options === void 0 ? void 0 : options.basePath) ? join(options.basePath, props.path) : props.path;
+		let typeName = name;
+		let content = "";
+		if (file) content = (yield fs$1.readFile(file)).toString();
+		if (type && type.split("\n").length > 1) content += `\n${type}`;
+		else if (type) {
+			var _typeName;
+			(_typeName = typeName) !== null && _typeName !== void 0 || (typeName = "$Fumadocs");
+			content += `\nexport type ${typeName} = ${type}`;
+		}
+		const output = yield gen.generateDocumentation({
+			path: file !== null && file !== void 0 ? file : "temp.ts",
+			content
+		}, typeName, options);
+		if (name && output.length === 0) throw new Error(`${name} in ${file !== null && file !== void 0 ? file : "empty file"} doesn't exist`);
+		return output;
+	});
+	return _getTypeTableOutput.apply(this, arguments);
 }
 
-// src/lib/base.ts
-import path from "path";
-
-// src/lib/get-simple-form.ts
-import * as ts from "ts-morph";
+//#endregion
+//#region src/lib/get-simple-form.ts
 function getSimpleForm(type, checker, noUndefined = false, location) {
-  if (type.isUndefined() && noUndefined) return "";
-  const alias = type.getAliasSymbol();
-  if (alias) {
-    const args = type.getAliasTypeArguments();
-    if (args.length === 0) return alias.getName();
-    return `${alias.getName()}<${args.map((arg) => getSimpleForm(arg, checker)).join(", ")}>`;
-  }
-  if (type.isUnion()) {
-    const types = [];
-    for (const t of type.getUnionTypes()) {
-      const str = getSimpleForm(t, checker, noUndefined);
-      if (str.length > 0 && str !== "never") types.unshift(str);
-    }
-    return types.length > 0 ? (
-      // boolean | null will become true | false | null, need to ensure it's still returned as boolean
-      dedupe(types).join(" | ").replace("true | false", "boolean")
-    ) : "never";
-  }
-  if (type.isIntersection()) {
-    const types = [];
-    for (const t of type.getIntersectionTypes()) {
-      const str = getSimpleForm(t, checker, noUndefined);
-      if (str.length > 0 && str !== "never") types.unshift(str);
-    }
-    return dedupe(types).join(" & ");
-  }
-  if (type.isTuple()) {
-    const elements = type.getTupleElements().map((t) => getSimpleForm(t, checker)).join(", ");
-    return `[${elements}]`;
-  }
-  if (type.isArray() || type.isReadonlyArray()) {
-    return "array";
-  }
-  if (type.getCallSignatures().length > 0) {
-    return "function";
-  }
-  if (type.isClassOrInterface() || type.isObject()) {
-    return "object";
-  }
-  return type.getText(
-    location,
-    ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope
-  );
+	if (type.isUndefined() && noUndefined) return "";
+	const alias = type.getAliasSymbol();
+	if (alias) {
+		const args = type.getAliasTypeArguments();
+		if (args.length === 0) return alias.getName();
+		return `${alias.getName()}<${args.map((arg) => getSimpleForm(arg, checker)).join(", ")}>`;
+	}
+	if (type.isUnion()) {
+		const types = [];
+		for (const t of type.getUnionTypes()) {
+			const str = getSimpleForm(t, checker, noUndefined);
+			if (str.length > 0 && str !== "never") types.unshift(str);
+		}
+		return types.length > 0 ? dedupe(types).join(" | ").replace("true | false", "boolean") : "never";
+	}
+	if (type.isIntersection()) {
+		const types = [];
+		for (const t of type.getIntersectionTypes()) {
+			const str = getSimpleForm(t, checker, noUndefined);
+			if (str.length > 0 && str !== "never") types.unshift(str);
+		}
+		return dedupe(types).join(" & ");
+	}
+	if (type.isTuple()) return `[${type.getTupleElements().map((t) => getSimpleForm(t, checker)).join(", ")}]`;
+	if (type.isArray() || type.isReadonlyArray()) return "array";
+	if (type.getCallSignatures().length > 0) return "function";
+	if (type.isClassOrInterface() || type.isObject()) return "object";
+	return type.getText(location, ts$1.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
 }
 function dedupe(arr) {
-  const dedupe2 = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const item of arr) {
-    if (!dedupe2.has(item)) {
-      out.push(item);
-      dedupe2.add(item);
-    }
-  }
-  return out;
+	const dedupe$1 = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const item of arr) if (!dedupe$1.has(item)) {
+		out.push(item);
+		dedupe$1.add(item);
+	}
+	return out;
 }
 
-// src/lib/base.ts
+//#endregion
+//#region src/lib/base.ts
 function createGenerator(config) {
-  const options = config instanceof Project2 ? {
-    project: config
-  } : config;
-  const cache = (options == null ? void 0 : options.cache) ? options.cache : null;
-  let instance;
-  function getProject() {
-    var _a2;
-    instance != null ? instance : instance = (_a2 = options == null ? void 0 : options.project) != null ? _a2 : createProject(options);
-    return instance;
-  }
-  return {
-    generateDocumentation(file, name, options2) {
-      return __async(this, null, function* () {
-        var _a2;
-        const content = (_a2 = file.content) != null ? _a2 : (yield fs2.readFile(path.resolve(file.path))).toString();
-        const cacheKey = `${file.path}:${name}:${content}`;
-        if (cache) {
-          const cached = yield cache.read(cacheKey);
-          if (cached) return cached;
-        }
-        const sourceFile = getProject().createSourceFile(file.path, 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(getProject(), k, d[0], options2));
-        }
-        void (cache == null ? void 0 : cache.write(cacheKey, out));
-        return out;
-      });
-    },
-    generateTypeTable(props, options2) {
-      return getTypeTableOutput(this, props, options2);
-    }
-  };
+	const options = config instanceof Project ? { project: config } : config;
+	const cache = (options === null || options === void 0 ? void 0 : options.cache) ? options.cache : null;
+	let instance;
+	function getProject() {
+		var _instance, _options$project;
+		(_instance = instance) !== null && _instance !== void 0 || (instance = (_options$project = options === null || options === void 0 ? void 0 : options.project) !== null && _options$project !== void 0 ? _options$project : createProject(options));
+		return instance;
+	}
+	return {
+		generateDocumentation(file, name, options$1) {
+			return _asyncToGenerator(function* () {
+				var _file$content;
+				const content = (_file$content = file.content) !== null && _file$content !== void 0 ? _file$content : (yield fs.readFile(path.resolve(file.path))).toString();
+				const cacheKey = `${file.path}:${name}:${content}`;
+				if (cache) {
+					const cached = yield cache.read(cacheKey);
+					if (cached) return cached;
+				}
+				const sourceFile = getProject().createSourceFile(file.path, 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(getProject(), k, d[0], options$1));
+				}
+				cache === null || cache === void 0 || cache.write(cacheKey, out);
+				return out;
+			})();
+		},
+		generateTypeTable(props, options$1) {
+			return getTypeTableOutput(this, props, options$1);
+		}
+	};
 }
 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 ? ts2.displayPartsToString(comment) : "",
-    entries: declaration.getType().getProperties().map((prop) => getDocEntry(prop, entryContext)).filter(
-      (entry) => entry && (allowInternal || !("internal" in entry.tags))
-    )
-  };
+	var _declaration$getSymbo;
+	const entryContext = {
+		transform,
+		program,
+		type: declaration.getType(),
+		declaration
+	};
+	const comment = (_declaration$getSymbo = declaration.getSymbol()) === null || _declaration$getSymbo === void 0 ? void 0 : _declaration$getSymbo.compilerSymbol.getDocumentationComment(program.getTypeChecker().compilerObject);
+	return {
+		name,
+		description: comment ? ts.displayPartsToString(comment) : "",
+		entries: declaration.getType().getProperties().map((prop) => getDocEntry(prop, entryContext)).filter((entry) => entry && (allowInternal || !("internal" in entry.tags)))
+	};
 }
 function getDocEntry(prop, context) {
-  var _a, _b;
-  const { transform, program } = context;
-  if (context.type.isClass() && prop.getName().startsWith("#")) {
-    return;
-  }
-  const subType = prop.getTypeAtLocation(context.declaration);
-  const isOptional = prop.isOptional();
-  const tags = prop.getJsDocTags().map(
-    (tag) => ({
-      name: tag.getName(),
-      text: ts2.displayPartsToString(tag.getText())
-    })
-  );
-  let type = subType.getText(
-    context.declaration,
-    ts2.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts2.TypeFormatFlags.NoTruncation
-  );
-  let simplifiedType = getSimpleForm(
-    subType,
-    program.getTypeChecker(),
-    isOptional,
-    context.declaration
-  );
-  for (const tag of tags) {
-    if (tag.name === "fumadocsType") {
-      const match = (_a = new RegExp("`(?<name>.+)`$").exec(tag.text)) == null ? void 0 : _a[1];
-      if (match) type = match;
-      continue;
-    }
-    if (tag.name === "remarks") {
-      const match = (_b = new RegExp("^`(?<name>.+)`").exec(tag.text)) == null ? void 0 : _b[1];
-      if (match) simplifiedType = match;
-    }
-  }
-  const entry = {
-    name: prop.getName(),
-    description: ts2.displayPartsToString(
-      prop.compilerSymbol.getDocumentationComment(
-        program.getTypeChecker().compilerObject
-      )
-    ),
-    tags,
-    type,
-    simplifiedType,
-    required: !isOptional,
-    deprecated: tags.some((tag) => tag.name === "deprecated")
-  };
-  transform == null ? void 0 : transform.call(context, entry, subType, prop);
-  return entry;
+	const { transform, program } = context;
+	if (context.type.isClass() && prop.getName().startsWith("#")) return;
+	const subType = prop.getTypeAtLocation(context.declaration);
+	const isOptional = prop.isOptional();
+	const tags = prop.getJsDocTags().map((tag) => ({
+		name: tag.getName(),
+		text: ts.displayPartsToString(tag.getText())
+	}));
+	let type = subType.getText(context.declaration, ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts.TypeFormatFlags.NoTruncation);
+	let simplifiedType = getSimpleForm(subType, program.getTypeChecker(), isOptional, context.declaration);
+	for (const tag of tags) {
+		if (tag.name === "fumadocsType") {
+			var _exec;
+			const match = (_exec = new RegExp("`(?<name>.+)`$", "").exec(tag.text)) === null || _exec === void 0 ? void 0 : _exec[1];
+			if (match) type = match;
+			continue;
+		}
+		if (tag.name === "remarks") {
+			var _exec2;
+			const match = (_exec2 = new RegExp("^`(?<name>.+)`", "").exec(tag.text)) === null || _exec2 === void 0 ? void 0 : _exec2[1];
+			if (match) simplifiedType = match;
+		}
+	}
+	const entry = {
+		name: prop.getName(),
+		description: ts.displayPartsToString(prop.compilerSymbol.getDocumentationComment(program.getTypeChecker().compilerObject)),
+		tags,
+		type,
+		simplifiedType,
+		required: !isOptional,
+		deprecated: tags.some((tag) => tag.name === "deprecated")
+	};
+	transform === null || transform === void 0 || transform.call(context, entry, subType, prop);
+	return entry;
 }
 
-// src/lib/remark-auto-type-table.ts
-import { valueToEstree } from "estree-util-value-to-estree";
-import { visit } from "unist-util-visit";
-import { toEstree } from "hast-util-to-estree";
+//#endregion
+//#region src/lib/remark-auto-type-table.ts
 function objectBuilder() {
-  const out = {
-    type: "ObjectExpression",
-    properties: []
-  };
-  return {
-    addExpressionNode(key, expression) {
-      out.properties.push({
-        type: "Property",
-        method: false,
-        shorthand: false,
-        computed: false,
-        key: {
-          type: "Identifier",
-          name: key
-        },
-        kind: "init",
-        value: expression
-      });
-    },
-    addJsxProperty(key, hast) {
-      const estree = toEstree(hast, {
-        elementAttributeNameCase: "react"
-      }).body[0];
-      this.addExpressionNode(key, estree.expression);
-    },
-    build() {
-      return out;
-    }
-  };
+	const out = {
+		type: "ObjectExpression",
+		properties: []
+	};
+	return {
+		addExpressionNode(key, expression) {
+			out.properties.push({
+				type: "Property",
+				method: false,
+				shorthand: false,
+				computed: false,
+				key: {
+					type: "Identifier",
+					name: key
+				},
+				kind: "init",
+				value: expression
+			});
+		},
+		addJsxProperty(key, hast) {
+			const estree = toEstree(hast, { elementAttributeNameCase: "react" }).body[0];
+			this.addExpressionNode(key, estree.expression);
+		},
+		build() {
+			return out;
+		}
+	};
+}
+function buildTypeProp(_x4, _x5) {
+	return _buildTypeProp.apply(this, arguments);
 }
-function buildTypeProp(_0, _1) {
-  return __async(this, arguments, function* (entries, {
-    renderMarkdown = renderMarkdownToHast,
-    renderType = renderTypeToHast
-  }) {
-    function onItem(entry) {
-      return __async(this, null, function* () {
-        const node = objectBuilder();
-        const tags = parseTags(entry.tags);
-        node.addJsxProperty("type", yield renderType(entry.simplifiedType));
-        node.addJsxProperty("typeDescription", yield renderType(entry.type));
-        node.addExpressionNode("required", valueToEstree(entry.required));
-        if (tags.default)
-          node.addJsxProperty("default", yield renderType(tags.default));
-        if (tags.returns)
-          node.addJsxProperty("returns", yield renderMarkdown(tags.returns));
-        if (tags.params) {
-          node.addExpressionNode("parameters", {
-            type: "ArrayExpression",
-            elements: yield Promise.all(tags.params.map(onParam))
-          });
-        }
-        if (entry.description) {
-          node.addJsxProperty(
-            "description",
-            yield renderMarkdown(entry.description)
-          );
-        }
-        return node.build();
-      });
-    }
-    function onParam(param) {
-      return __async(this, null, function* () {
-        const node = objectBuilder();
-        node.addExpressionNode("name", valueToEstree(param.name));
-        if (param.description)
-          node.addJsxProperty(
-            "description",
-            yield renderMarkdown(param.description)
-          );
-        return node.build();
-      });
-    }
-    const prop = objectBuilder();
-    const output = yield Promise.all(
-      entries.map((entry) => __async(null, null, function* () {
-        return {
-          name: entry.name,
-          node: yield onItem(entry)
-        };
-      }))
-    );
-    for (const node of output) {
-      prop.addExpressionNode(node.name, node.node);
-    }
-    return prop.build();
-  });
+function _buildTypeProp() {
+	_buildTypeProp = _asyncToGenerator(function* (entries, { renderMarkdown = renderMarkdownToHast, renderType = renderTypeToHast }) {
+		function onItem(_x) {
+			return _onItem.apply(this, arguments);
+		}
+		function _onItem() {
+			_onItem = _asyncToGenerator(function* (entry) {
+				const node = objectBuilder();
+				const tags = parseTags(entry.tags);
+				node.addJsxProperty("type", yield renderType(entry.simplifiedType));
+				node.addJsxProperty("typeDescription", yield renderType(entry.type));
+				node.addExpressionNode("required", valueToEstree(entry.required));
+				if (tags.default) node.addJsxProperty("default", yield renderType(tags.default));
+				if (tags.returns) node.addJsxProperty("returns", yield renderMarkdown(tags.returns));
+				if (tags.params) node.addExpressionNode("parameters", {
+					type: "ArrayExpression",
+					elements: yield Promise.all(tags.params.map(onParam))
+				});
+				if (entry.description) node.addJsxProperty("description", yield renderMarkdown(entry.description));
+				return node.build();
+			});
+			return _onItem.apply(this, arguments);
+		}
+		function onParam(_x2) {
+			return _onParam.apply(this, arguments);
+		}
+		function _onParam() {
+			_onParam = _asyncToGenerator(function* (param) {
+				const node = objectBuilder();
+				node.addExpressionNode("name", valueToEstree(param.name));
+				if (param.description) node.addJsxProperty("description", yield renderMarkdown(param.description));
+				return node.build();
+			});
+			return _onParam.apply(this, arguments);
+		}
+		const prop = objectBuilder();
+		const output = yield Promise.all(entries.map(function() {
+			var _ref = _asyncToGenerator(function* (entry) {
+				return {
+					name: entry.name,
+					node: yield onItem(entry)
+				};
+			});
+			return function(_x3) {
+				return _ref.apply(this, arguments);
+			};
+		}()));
+		for (const node of output) prop.addExpressionNode(node.name, node.node);
+		return prop.build();
+	});
+	return _buildTypeProp.apply(this, arguments);
 }
+/**
+* Compile `auto-type-table` into Fumadocs UI compatible TypeTable
+*
+* MDX is required to use this plugin.
+*/
 function remarkAutoTypeTable(config = {}) {
-  const {
-    name = "auto-type-table",
-    outputName = "TypeTable",
-    options: generateOptions = {},
-    remarkStringify = true,
-    generator = createGenerator()
-  } = config;
-  return (tree, file) => __async(null, null, function* () {
-    const queue = [];
-    function run(node, props) {
-      return __async(this, null, function* () {
-        let basePath = props.cwd ? file.cwd : generateOptions.basePath;
-        if (file.dirname) {
-          basePath != null ? basePath : basePath = file.dirname;
-        }
-        const output = yield generator.generateTypeTable(props, __spreadProps(__spreadValues({}, generateOptions), {
-          basePath
-        }));
-        const rendered = output.map((doc) => __async(null, null, function* () {
-          return {
-            type: "mdxJsxFlowElement",
-            name: outputName,
-            attributes: [
-              {
-                type: "mdxJsxAttribute",
-                name: "type",
-                value: {
-                  type: "mdxJsxAttributeValueExpression",
-                  value: remarkStringify ? JSON.stringify(doc, null, 2) : "",
-                  data: {
-                    estree: {
-                      type: "Program",
-                      sourceType: "module",
-                      body: [
-                        {
-                          type: "ExpressionStatement",
-                          expression: yield buildTypeProp(doc.entries, config)
-                        }
-                      ]
-                    }
-                  }
-                }
-              }
-            ],
-            children: []
-          };
-        }));
-        Object.assign(node, {
-          type: "root",
-          attributes: [],
-          children: yield Promise.all(rendered)
-        });
-      });
-    }
-    visit(tree, "mdxJsxFlowElement", (node) => {
-      if (node.name !== name) return;
-      const props = {};
-      for (const attr of node.attributes) {
-        if (attr.type !== "mdxJsxAttribute" || typeof attr.value !== "string" && attr.value !== null)
-          throw new Error(
-            "`auto-type-table` only support string & boolean attributes"
-          );
-        props[attr.name] = attr.value;
-      }
-      queue.push(run(node, props));
-      return "skip";
-    });
-    yield Promise.all(queue);
-  });
+	const { name = "auto-type-table", outputName = "TypeTable", options: generateOptions = {}, remarkStringify = true, generator = createGenerator() } = config;
+	return function() {
+		var _ref3 = _asyncToGenerator(function* (tree, file) {
+			const queue = [];
+			function run(_x7, _x8) {
+				return _run.apply(this, arguments);
+			}
+			function _run() {
+				_run = _asyncToGenerator(function* (node, props) {
+					let basePath = props.cwd ? file.cwd : generateOptions.basePath;
+					if (file.dirname) {
+						var _basePath;
+						(_basePath = basePath) !== null && _basePath !== void 0 || (basePath = file.dirname);
+					}
+					const rendered = (yield generator.generateTypeTable(props, _objectSpread2(_objectSpread2({}, generateOptions), {}, { basePath }))).map(function() {
+						var _ref2 = _asyncToGenerator(function* (doc) {
+							return {
+								type: "mdxJsxFlowElement",
+								name: outputName,
+								attributes: [{
+									type: "mdxJsxAttribute",
+									name: "type",
+									value: {
+										type: "mdxJsxAttributeValueExpression",
+										value: remarkStringify ? JSON.stringify(doc, null, 2) : "",
+										data: { estree: {
+											type: "Program",
+											sourceType: "module",
+											body: [{
+												type: "ExpressionStatement",
+												expression: yield buildTypeProp(doc.entries, config)
+											}]
+										} }
+									}
+								}],
+								children: []
+							};
+						});
+						return function(_x6) {
+							return _ref2.apply(this, arguments);
+						};
+					}());
+					Object.assign(node, {
+						type: "root",
+						attributes: [],
+						children: yield Promise.all(rendered)
+					});
+				});
+				return _run.apply(this, arguments);
+			}
+			visit(tree, "mdxJsxFlowElement", (node) => {
+				if (node.name !== name) return;
+				const props = {};
+				const onError = (message, cause) => {
+					const location = node.position ? `${file.path}:${node.position.start.line}:${node.position.start.column}` : file.path;
+					throw new Error(`${location} from <auto-type-table>: ${message}`, { cause });
+				};
+				for (const attr of node.attributes) if (attr.type !== "mdxJsxAttribute") onError("only named attributes are allowed.");
+				else if (typeof attr.value === "string") props[attr.name] = attr.value;
+				else if (attr.value === null) props[attr.name] = true;
+				else onError("only string & boolean attributes are allowed.");
+				queue.push(run(node, props).catch((err) => {
+					onError("failed to generate type table", err);
+				}));
+				return "skip";
+			});
+			yield Promise.all(queue);
+		});
+		return function(_x9, _x10) {
+			return _ref3.apply(this, arguments);
+		};
+	}();
 }
 
-// src/cache/fs-cache.ts
-import fs3 from "fs/promises";
-import { createHash } from "crypto";
-import path2 from "path";
+//#endregion
+//#region src/cache/fs-cache.ts
 function createFileSystemGeneratorCache(dir) {
-  dir = path2.resolve(dir);
-  const initDirPromise = fs3.mkdir(dir, { recursive: true }).catch(() => {
-  });
-  return {
-    write(input, data) {
-      return __async(this, null, function* () {
-        const hash = createHash("SHA256").update(input).digest("hex").slice(0, 12);
-        yield initDirPromise;
-        yield fs3.writeFile(path2.join(dir, `${hash}.json`), JSON.stringify(data));
-      });
-    },
-    read(input) {
-      return __async(this, null, function* () {
-        const hash = createHash("SHA256").update(input).digest("hex").slice(0, 12);
-        try {
-          return JSON.parse(
-            (yield fs3.readFile(path2.join(dir, `${hash}.json`))).toString()
-          );
-        } catch (e) {
-          return;
-        }
-      });
-    }
-  };
+	dir = path.resolve(dir);
+	const initDirPromise = fs.mkdir(dir, { recursive: true }).catch(() => {});
+	return {
+		write(input, data) {
+			return _asyncToGenerator(function* () {
+				const hash = createHash("SHA256").update(input).digest("hex").slice(0, 12);
+				yield initDirPromise;
+				yield fs.writeFile(path.join(dir, `${hash}.json`), JSON.stringify(data));
+			})();
+		},
+		read(input) {
+			return _asyncToGenerator(function* () {
+				const hash = createHash("SHA256").update(input).digest("hex").slice(0, 12);
+				try {
+					return JSON.parse((yield fs.readFile(path.join(dir, `${hash}.json`))).toString());
+				} catch (_unused) {
+					return;
+				}
+			})();
+		}
+	};
 }
-export {
-  createFileSystemGeneratorCache,
-  createGenerator,
-  createProject,
-  remarkAutoTypeTable,
-  renderMarkdownToHast
-};
+
+//#endregion
+export { createFileSystemGeneratorCache, createGenerator, createProject, remarkAutoTypeTable, renderMarkdownToHast };
+//# sourceMappingURL=index.js.map