fumadocs-typescript 5.0.1 → 5.1.1

package/dist/base-Dvhn4vZx.d.ts

@@ -111,5 +111,4 @@ declare function createGenerator(config?: GeneratorOptions | Project): {
   generateTypeTable(props: BaseTypeTableProps, options?: GenerateTypeTableOptions): Promise<GeneratedDoc[]>;
 };
 //#endregion
-export { GeneratorOptions as a, Cache as c, createProject as d, Generator as i, BaseTypeTableProps as l, GenerateOptions as n, RawTag as o, GeneratedDoc as r, createGenerator as s, DocEntry as t, GenerateTypeTableOptions as u };
-//# sourceMappingURL=base-Dvhn4vZx.d.ts.map
+export { GeneratorOptions as a, Cache as c, createProject as d, Generator as i, BaseTypeTableProps as l, GenerateOptions as n, RawTag as o, GeneratedDoc as r, createGenerator as s, DocEntry as t, GenerateTypeTableOptions as u };

package/dist/index.d.ts

@@ -1,11 +1,14 @@
 import { a as GeneratorOptions, c as Cache, d as createProject, i as Generator, l as BaseTypeTableProps, n as GenerateOptions, o as RawTag, r as GeneratedDoc, s as createGenerator, t as DocEntry, u as GenerateTypeTableOptions } from "./base-Dvhn4vZx.js";
+import { ResolvedShikiConfig } from "fumadocs-core/highlight/config";
 import { Nodes } from "hast";
 import { Root } from "mdast";
 import { Transformer } from "unified";
 
 //#region src/markdown.d.ts
-declare function renderTypeToHast(type: string): Promise<Nodes>;
-declare function renderMarkdownToHast(md: string): Promise<Nodes>;
+interface MarkdownRenderer {
+  renderTypeToHast: (type: string) => Nodes | Promise<Nodes>;
+  renderMarkdownToHast: (md: string) => Nodes | Promise<Nodes>;
+}
 //#endregion
 //#region src/lib/remark-auto-type-table.d.ts
 interface RemarkAutoTypeTableOptions {
@@ -17,8 +20,12 @@ interface RemarkAutoTypeTableOptions {
    * @defaultValue 'TypeTable'
    */
   outputName?: string;
-  renderMarkdown?: typeof renderMarkdownToHast;
-  renderType?: typeof renderTypeToHast;
+  /**
+   * config for Shiki when using default `renderMarkdown` & `renderType`.
+   */
+  shiki?: ResolvedShikiConfig;
+  renderMarkdown?: MarkdownRenderer['renderMarkdownToHast'];
+  renderType?: MarkdownRenderer['renderTypeToHast'];
   /**
    * Customise type table generation
    */
@@ -42,5 +49,4 @@ declare function remarkAutoTypeTable(config?: RemarkAutoTypeTableOptions): Trans
 //#region src/cache/fs-cache.d.ts
 declare function createFileSystemGeneratorCache(dir: string): Cache;
 //#endregion
-export { Cache, DocEntry, GenerateOptions, GeneratedDoc, Generator, GeneratorOptions, RawTag, RemarkAutoTypeTableOptions, TypeTableProps, createFileSystemGeneratorCache, createGenerator, createProject, remarkAutoTypeTable, renderMarkdownToHast };
-//# sourceMappingURL=index.d.ts.map
+export { Cache, DocEntry, GenerateOptions, GeneratedDoc, Generator, GeneratorOptions, type MarkdownRenderer, RawTag, RemarkAutoTypeTableOptions, TypeTableProps, createFileSystemGeneratorCache, createGenerator, createProject, remarkAutoTypeTable };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { a as _asyncToGenerator, i as renderTypeToHast, n as parseTags, o as _objectWithoutProperties, r as renderMarkdownToHast, t as _objectSpread2 } from "./objectSpread2-BbbttTvx.js";
+import { n as markdownRenderer, t as parseTags } from "./parse-tags-B09hzgIX.js";
 import * as ts$1 from "ts-morph";
 import { Project, ts } from "ts-morph";
 import * as fs$1 from "node:fs/promises";
@@ -11,40 +11,30 @@ import { createHash } from "node:crypto";
 
 //#region src/create-project.ts
 function createProject(options = {}) {
-	var _options$tsconfigPath;
 	return new Project({
-		tsConfigFilePath: (_options$tsconfigPath = options.tsconfigPath) !== null && _options$tsconfigPath !== void 0 ? _options$tsconfigPath : "./tsconfig.json",
+		tsConfigFilePath: options.tsconfigPath ?? "./tsconfig.json",
 		skipAddingFilesFromTsConfig: true
 	});
 }
 
 //#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);
+async function getTypeTableOutput(gen, { name, type, ...props }, options) {
+	const file = props.path && options?.basePath ? join(options.basePath, props.path) : props.path;
+	let typeName = name;
+	let content = "";
+	if (file) content = (await fs$1.readFile(file)).toString();
+	if (type && type.split("\n").length > 1) content += `\n${type}`;
+	else if (type) {
+		typeName ??= "$Fumadocs";
+		content += `\nexport type ${typeName} = ${type}`;
+	}
+	const output = await gen.generateDocumentation({
+		path: file ?? "temp.ts",
+		content
+	}, typeName, options);
+	if (name && output.length === 0) throw new Error(`${name} in ${file ?? "empty file"} doesn't exist`);
+	return output;
 }
 
 //#endregion
@@ -93,33 +83,29 @@ function dedupe(arr) {
 //#region src/lib/base.ts
 function createGenerator(config) {
 	const options = config instanceof Project ? { project: config } : config;
-	const cache = (options === null || options === void 0 ? void 0 : options.cache) ? options.cache : null;
+	const cache = 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));
+		instance ??= 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;
-			})();
+		async generateDocumentation(file, name, options$1) {
+			const content = file.content ?? (await fs.readFile(path.resolve(file.path))).toString();
+			const cacheKey = `${file.path}:${name}:${content}`;
+			if (cache) {
+				const cached = await 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?.write(cacheKey, out);
+			return out;
 		},
 		generateTypeTable(props, options$1) {
 			return getTypeTableOutput(this, props, options$1);
@@ -127,14 +113,13 @@ function createGenerator(config) {
 	};
 }
 function generate(program, name, declaration, { allowInternal = false, transform } = {}) {
-	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);
+	const comment = declaration.getSymbol()?.compilerSymbol.getDocumentationComment(program.getTypeChecker().compilerObject);
 	return {
 		name,
 		description: comment ? ts.displayPartsToString(comment) : "",
@@ -154,14 +139,12 @@ function getDocEntry(prop, context) {
 	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];
+			const match = /`(?<name>.+)`$/.exec(tag.text)?.[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];
+			const match = /^`(?<name>.+)`/.exec(tag.text)?.[1];
 			if (match) simplifiedType = match;
 		}
 	}
@@ -174,7 +157,7 @@ function getDocEntry(prop, context) {
 		required: !isOptional,
 		deprecated: tags.some((tag) => tag.name === "deprecated")
 	};
-	transform === null || transform === void 0 || transform.call(context, entry, subType, prop);
+	transform?.call(context, entry, subType, prop);
 	return entry;
 }
 
@@ -209,60 +192,35 @@ function objectBuilder() {
 		}
 	};
 }
-function buildTypeProp(_x4, _x5) {
-	return _buildTypeProp.apply(this, arguments);
-}
-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);
+async function buildTypeProp(entries, renderer) {
+	async function onItem(entry) {
+		const node = objectBuilder();
+		const tags = parseTags(entry.tags);
+		node.addJsxProperty("type", await renderer.renderTypeToHast(entry.simplifiedType));
+		node.addJsxProperty("typeDescription", await renderer.renderTypeToHast(entry.type));
+		node.addExpressionNode("required", valueToEstree(entry.required));
+		if (tags.default) node.addJsxProperty("default", await renderer.renderTypeToHast(tags.default));
+		if (tags.returns) node.addJsxProperty("returns", await renderer.renderMarkdownToHast(tags.returns));
+		if (tags.params) node.addExpressionNode("parameters", {
+			type: "ArrayExpression",
+			elements: await Promise.all(tags.params.map(onParam))
+		});
+		if (entry.description) node.addJsxProperty("description", await renderer.renderMarkdownToHast(entry.description));
+		return node.build();
+	}
+	async function onParam(param) {
+		const node = objectBuilder();
+		node.addExpressionNode("name", valueToEstree(param.name));
+		if (param.description) node.addJsxProperty("description", await renderer.renderMarkdownToHast(param.description));
+		return node.build();
+	}
+	const prop = objectBuilder();
+	const output = await Promise.all(entries.map(async (entry) => ({
+		name: entry.name,
+		node: await onItem(entry)
+	})));
+	for (const node of output) prop.addExpressionNode(node.name, node.node);
+	return prop.build();
 }
 /**
 * Compile `auto-type-table` into Fumadocs UI compatible TypeTable
@@ -270,78 +228,72 @@ function _buildTypeProp() {
 * 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 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 });
+	const { name = "auto-type-table", outputName = "TypeTable", options: generateOptions = {}, remarkStringify = true, generator = createGenerator(), renderMarkdown, renderType, shiki } = config;
+	let renderer;
+	if (renderMarkdown && renderType) renderer = {
+		renderMarkdownToHast: renderMarkdown,
+		renderTypeToHast: renderType
+	};
+	else {
+		renderer = markdownRenderer(shiki);
+		if (renderMarkdown) renderer.renderMarkdownToHast = renderMarkdown;
+		if (renderType) renderer.renderTypeToHast = renderType;
+	}
+	return async (tree, file) => {
+		const queue = [];
+		async function run(node, props) {
+			let basePath = props.cwd ? file.cwd : generateOptions.basePath;
+			if (file.dirname) basePath ??= file.dirname;
+			const rendered = (await generator.generateTypeTable(props, {
+				...generateOptions,
+				basePath
+			})).map(async (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: await buildTypeProp(doc.entries, renderer)
+								}]
+							} }
+						}
+					}],
+					children: []
 				};
-				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);
+			Object.assign(node, {
+				type: "root",
+				attributes: [],
+				children: await Promise.all(rendered)
+			});
+		}
+		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";
 		});
-		return function(_x9, _x10) {
-			return _ref3.apply(this, arguments);
-		};
-	}();
+		await Promise.all(queue);
+	};
 }
 
 //#endregion
@@ -350,26 +302,21 @@ function createFileSystemGeneratorCache(dir) {
 	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));
-			})();
+		async write(input, data) {
+			const hash = createHash("SHA256").update(input).digest("hex").slice(0, 12);
+			await initDirPromise;
+			await 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;
-				}
-			})();
+		async read(input) {
+			const hash = createHash("SHA256").update(input).digest("hex").slice(0, 12);
+			try {
+				return JSON.parse((await fs.readFile(path.join(dir, `${hash}.json`))).toString());
+			} catch {
+				return;
+			}
 		}
 	};
 }
 
 //#endregion
-export { createFileSystemGeneratorCache, createGenerator, createProject, remarkAutoTypeTable, renderMarkdownToHast };
-//# sourceMappingURL=index.js.map
+export { createFileSystemGeneratorCache, createGenerator, createProject, remarkAutoTypeTable };

package/dist/parse-tags-B09hzgIX.js

@@ -0,0 +1,68 @@
+import { remark } from "remark";
+import { remarkGfm } from "fumadocs-core/mdx-plugins/remark-gfm";
+import { createRehypeCode } from "fumadocs-core/mdx-plugins/rehype-code.core";
+import remarkRehype from "remark-rehype";
+import { highlightHast } from "fumadocs-core/highlight/core";
+import { configDefault } from "fumadocs-core/highlight";
+
+//#region src/markdown.ts
+function markdownRenderer(shiki = configDefault) {
+	const processor = remark().use(remarkGfm).use(remarkRehype).use(createRehypeCode(shiki), {
+		lazy: true,
+		langs: ["ts", "tsx"],
+		transformers: [],
+		parseMetaString: void 0
+	});
+	return {
+		async renderTypeToHast(type) {
+			return {
+				type: "element",
+				tagName: "span",
+				properties: { class: "shiki" },
+				children: [{
+					type: "element",
+					tagName: "code",
+					properties: {},
+					children: (await highlightHast(type, {
+						config: shiki,
+						lang: "ts",
+						structure: "inline"
+					})).children
+				}]
+			};
+		},
+		renderMarkdownToHast(md) {
+			md = md.replace(/{@link (?<link>[^}]*)}/g, "$1");
+			return processor.run(processor.parse(md));
+		}
+	};
+}
+
+//#endregion
+//#region src/lib/parse-tags.ts
+/**
+* Parse tags, only returns recognized fields.
+*/
+function parseTags(tags) {
+	const typed = {};
+	for (const { name: key, text } of tags) {
+		if (key === "default" || key === "defaultValue") {
+			typed.default = text;
+			continue;
+		}
+		if (key === "param") {
+			const [param, description] = text.split("-", 2);
+			typed.params ??= [];
+			typed.params.push({
+				name: param.trim(),
+				description: description.trim()
+			});
+			continue;
+		}
+		if (key === "returns") typed.returns = text;
+	}
+	return typed;
+}
+
+//#endregion
+export { markdownRenderer as n, parseTags as t };

package/dist/ui/index.d.ts

@@ -1,24 +1,27 @@
 import { i as Generator, l as BaseTypeTableProps, u as GenerateTypeTableOptions } from "../base-Dvhn4vZx.js";
 import * as runtime from "react/jsx-runtime";
 import "server-only";
+import { ResolvedShikiConfig } from "fumadocs-core/highlight/config";
 import { ReactNode } from "react";
 
 //#region src/ui/auto-type-table.d.ts
-type AutoTypeTableProps = BaseTypeTableProps;
+interface JSXMarkdownRenderer {
+  renderMarkdown: (md: string) => Promise<ReactNode>;
+  renderType: (type: string) => Promise<ReactNode>;
+}
+interface AutoTypeTableProps extends BaseTypeTableProps, Partial<JSXMarkdownRenderer> {
+  generator: Generator;
+  /** Shiki configuration when using default `renderMarkdown` & `renderType` */
+  shiki?: ResolvedShikiConfig;
+  options?: GenerateTypeTableOptions;
+}
 declare function AutoTypeTable({
   generator,
   options,
   renderType,
   renderMarkdown,
+  shiki,
   ...props
-}: AutoTypeTableProps & {
-  generator: Generator;
-  renderMarkdown?: typeof renderMarkdownDefault;
-  renderType?: typeof renderTypeDefault;
-  options?: GenerateTypeTableOptions;
-}): Promise<Promise<runtime.JSX.Element>[]>;
-declare function renderTypeDefault(type: string): Promise<ReactNode>;
-declare function renderMarkdownDefault(md: string): Promise<ReactNode>;
+}: AutoTypeTableProps): Promise<Promise<runtime.JSX.Element>[]>;
 //#endregion
-export { AutoTypeTable, AutoTypeTableProps };
-//# sourceMappingURL=index.d.ts.map
+export { AutoTypeTable, AutoTypeTableProps };

package/dist/ui/index.js

@@ -1,4 +1,4 @@
-import { a as _asyncToGenerator, i as renderTypeToHast, n as parseTags, o as _objectWithoutProperties, r as renderMarkdownToHast, t as _objectSpread2 } from "../objectSpread2-BbbttTvx.js";
+import { n as markdownRenderer, t as parseTags } from "../parse-tags-B09hzgIX.js";
 import { TypeTable } from "fumadocs-ui/components/type-table";
 import { toJsxRuntime } from "hast-util-to-jsx-runtime";
 import * as runtime from "react/jsx-runtime";
@@ -7,80 +7,45 @@ import defaultMdxComponents from "fumadocs-ui/mdx";
 import "server-only";
 
 //#region src/ui/auto-type-table.tsx
-const _excluded = [
-	"generator",
-	"options",
-	"renderType",
-	"renderMarkdown"
-];
-function AutoTypeTable(_x3) {
-	return _AutoTypeTable.apply(this, arguments);
-}
-function _AutoTypeTable() {
-	_AutoTypeTable = _asyncToGenerator(function* (_ref) {
-		let { generator, options = {}, renderType = renderTypeDefault, renderMarkdown = renderMarkdownDefault } = _ref, props = _objectWithoutProperties(_ref, _excluded);
-		return (yield generator.generateTypeTable(props, options)).map(function() {
-			var _ref3 = _asyncToGenerator(function* (item) {
-				const entries = item.entries.map(function() {
-					var _ref2 = _asyncToGenerator(function* (entry) {
-						var _tags$params;
-						const tags = parseTags(entry.tags);
-						const paramNodes = [];
-						for (const param of (_tags$params = tags.params) !== null && _tags$params !== void 0 ? _tags$params : []) paramNodes.push({
-							name: param.name,
-							description: param.description ? yield renderMarkdown(param.description) : void 0
-						});
-						return [entry.name, {
-							type: yield renderType(entry.simplifiedType),
-							typeDescription: yield renderType(entry.type),
-							description: yield renderMarkdown(entry.description),
-							default: tags.default ? yield renderType(tags.default) : void 0,
-							parameters: paramNodes,
-							required: entry.required,
-							deprecated: entry.deprecated,
-							returns: tags.returns ? yield renderMarkdown(tags.returns) : void 0
-						}];
-					});
-					return function(_x) {
-						return _ref2.apply(this, arguments);
-					};
-				}());
-				return /* @__PURE__ */ jsx(TypeTable, { type: Object.fromEntries(yield Promise.all(entries)) }, item.name);
+async function AutoTypeTable({ generator, options = {}, renderType, renderMarkdown, shiki, ...props }) {
+	if (!renderType || !renderMarkdown) {
+		const renderer = markdownRenderer(shiki);
+		renderType ??= async (v) => toJsx(await renderer.renderTypeToHast(v));
+		renderMarkdown ??= async (v) => toJsx(await renderer.renderMarkdownToHast(v));
+	}
+	return (await generator.generateTypeTable(props, options)).map(async (item) => {
+		const entries = item.entries.map(async (entry) => {
+			const tags = parseTags(entry.tags);
+			const paramNodes = [];
+			for (const param of tags.params ?? []) paramNodes.push({
+				name: param.name,
+				description: param.description ? await renderMarkdown(param.description) : void 0
 			});
-			return function(_x2) {
-				return _ref3.apply(this, arguments);
-			};
-		}());
+			return [entry.name, {
+				type: await renderType(entry.simplifiedType),
+				typeDescription: await renderType(entry.type),
+				description: await renderMarkdown(entry.description),
+				default: tags.default ? await renderType(tags.default) : void 0,
+				parameters: paramNodes,
+				required: entry.required,
+				deprecated: entry.deprecated,
+				returns: tags.returns ? await renderMarkdown(tags.returns) : void 0
+			}];
+		});
+		return /* @__PURE__ */ jsx(TypeTable, { type: Object.fromEntries(await Promise.all(entries)) }, item.name);
 	});
-	return _AutoTypeTable.apply(this, arguments);
 }
 function toJsx(hast) {
 	return toJsxRuntime(hast, {
 		Fragment: runtime.Fragment,
 		jsx: runtime.jsx,
 		jsxs: runtime.jsxs,
-		components: _objectSpread2(_objectSpread2({}, defaultMdxComponents), {}, { img: void 0 })
-	});
-}
-function renderTypeDefault(_x4) {
-	return _renderTypeDefault.apply(this, arguments);
-}
-function _renderTypeDefault() {
-	_renderTypeDefault = _asyncToGenerator(function* (type) {
-		return toJsx(yield renderTypeToHast(type));
-	});
-	return _renderTypeDefault.apply(this, arguments);
-}
-function renderMarkdownDefault(_x5) {
-	return _renderMarkdownDefault.apply(this, arguments);
-}
-function _renderMarkdownDefault() {
-	_renderMarkdownDefault = _asyncToGenerator(function* (md) {
-		return toJsx(yield renderMarkdownToHast(md));
+		components: {
+			...defaultMdxComponents,
+			img: void 0
+		}
 	});
-	return _renderMarkdownDefault.apply(this, arguments);
 }
 
 //#endregion
-export { AutoTypeTable };
-//# sourceMappingURL=index.js.map
+export { AutoTypeTable };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-typescript",
-  "version": "5.0.1",
+  "version": "5.1.1",
   "description": "Typescript Integration for Fumadocs",
   "keywords": [
     "Docs",
@@ -38,28 +38,28 @@
     "remark-rehype": "^11.1.2",
     "tinyglobby": "^0.2.15",
     "ts-morph": "^27.0.2",
-    "unist-util-visit": "^5.0.0"
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.1.0"
   },
   "devDependencies": {
     "@mdx-js/mdx": "^3.1.1",
     "@types/estree": "^1.0.8",
     "@types/hast": "^3.0.4",
     "@types/mdast": "^4.0.4",
-    "@types/node": "24.10.2",
-    "@types/react": "^19.2.7",
+    "@types/node": "25.1.0",
+    "@types/react": "^19.2.10",
     "@types/react-dom": "^19.2.3",
-    "tsdown": "^0.18.3",
+    "tsdown": "^0.19.0",
     "typescript": "^5.9.3",
-    "unified": "^11.0.5",
     "eslint-config-custom": "0.0.0",
-    "fumadocs-core": "16.4.2",
-    "fumadocs-ui": "16.4.2",
+    "fumadocs-core": "16.5.0",
+    "fumadocs-ui": "16.5.0",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "@types/react": "*",
-    "fumadocs-core": "^15.7.0 || ^16.0.0",
-    "fumadocs-ui": "^15.7.0 || ^16.0.0",
+    "fumadocs-core": "^16.5.0",
+    "fumadocs-ui": "^16.5.0",
     "react": "*",
     "typescript": "*"
   },

package/dist/base-Dvhn4vZx.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base-Dvhn4vZx.d.ts","names":[],"sources":["../src/create-project.ts","../src/lib/type-table.ts","../src/cache/index.ts","../src/lib/base.ts"],"sourcesContent":[],"mappings":";;;UAEiB,gBAAA;;EAAA,YAAA,CAAA,EAAA,MAAgB;EAOjB;;;iBAAA,aAAA,WAAuB,mBAAwB;;;UCL9C,kBAAA;;ADFjB;AAOA;;;;ACLA;EAmCiB,IAAA,CAAA,EAAA,MAAA;;;;ACvCjB;;;;ACkBA;AAMA;AAWA;AAGC;;;;;;AAMkC;;;;;EAOT,IAAA,CAAA,EAAA,MAAA;AAG1B;AAcY,UF7BK,wBAAA,SAAiC,eE6BhB,CAAA;EAEjB;;;EAAyB,QAAA,CAAA,EAAA,MAAA;;;;UDtEzB,KAAA;+CAC8B;iDACE;AFAjD;;;AAOgB,UGSC,YAAA,CHTY;;;WGYlB;AFjBX;AAmCiB,UEfA,QAAA,CFeA;;;;ECvCA,cAAK,EAAA,MACyB;QC6BvC;;;AAZR;AAMiB,UAWA,MAAA,CAXQ;EAWR,IAAA,EAAA,MAAM;EAKb,IAAA,EAAA,MAAA;;UAAA,YAAA,CAEI;EACN,OAAA,EAFG,OAEH;EACO,SAAA,CAAA,EAFD,WAEC;EAAoB,IAAA,EAD3B,IAC2B;EAG9B,WAAA,EAHU,oBAGC;;KAAX,WAAA,GAEI,CAAA,IAAA,EADD,YACC,EAAA,KAAA,EAAA,QAAA,EAAA,YAAA,EACO,IADP,EAAA,cAAA,EAES,MAFT,EAAA,GAAA,IAAA;AACO,UAIC,eAAA,CAJD;EACE;;AAGlB;AAcA;AAEA;EAMU,aAAA,CAAA,EAAA,OAAA;EAEE;;;EAGI,SAAA,CAAA,EAhBF,WAgBiB;;AAA6B,KAbhD,SAAA,GAAY,UAaoC,CAAA,OAblB,eAakB,CAAA;AAsB5C,UAjCC,gBAAA,SAAyB,gBAiC1B,CAAA;EAAe;;;;;EAyBoD,KAAA,CAAA,EApDzE,KAoDyE,GAAA,KAAA;EAAA,OAAA,CAAA,EAlDvE,OAkDuE;;iBA/CnE,eAAA,UAAyB,mBAAmB;;;;yCAsB5C,kBAAe,QAAA;2BAyBF,8BAA8B,2BAAwB,QAAA"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/markdown.ts","../src/lib/remark-auto-type-table.ts","../src/cache/fs-cache.ts"],"sourcesContent":[],"mappings":";;;;;;iBAuBsB,gBAAA,gBAAgC,QAAQ;iBA8BxC,oBAAA,cAAkC,QAAQ;;;UCiD/C,0BAAA;ED/EK;AA8BtB;;;;ACiDA;;EAYsB,UAAA,CAAA,EAAA,MAAA;EAKV,cAAA,CAAA,EAAA,OANc,oBAMd;EAOE,UAAA,CAAA,EAAA,OAZQ,gBAYR;EAAS;AAGvB;AASA;EACU,OAAA,CAAA,EApBE,wBAoBF;EACK;;;EAAD,eAAA,CAAA,EAAA,OAAA;cAdA;;UAGG,cAAA,SAAuB;EC5HxB,GAAA,CAAA,EAAA,IAAA;;;;;;;iBDqIA,mBAAA,UACN,6BACP,YAAY,MAAM;;;iBCvIL,8BAAA,eAA6C"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["fs","types: string[]","ts","dedupe","out: T[]","instance: Project | undefined","out: GeneratedDoc[]","options","entryContext: EntryContext","entry: DocEntry","out: ObjectExpression","queue: Promise<void>[]","props: Record<string, string | true>"],"sources":["../src/create-project.ts","../src/lib/type-table.ts","../src/lib/get-simple-form.ts","../src/lib/base.ts","../src/lib/remark-auto-type-table.ts","../src/cache/fs-cache.ts"],"sourcesContent":["import { Project } from 'ts-morph';\n\nexport interface TypescriptConfig {\n  files?: string[];\n  tsconfigPath?: string;\n  /** A root directory to resolve relative path entries in the config file to. e.g. outDir */\n  basePath?: string;\n}\n\nexport function createProject(options: TypescriptConfig = {}): Project {\n  return new Project({\n    tsConfigFilePath: options.tsconfigPath ?? './tsconfig.json',\n    skipAddingFilesFromTsConfig: true,\n  });\n}\n","import * as fs from 'node:fs/promises';\nimport { type GenerateOptions, type Generator } from '@/lib/base';\nimport { join } from 'node:path';\n\nexport interface BaseTypeTableProps {\n  /**\n   * The path to source TypeScript file.\n   */\n  path?: string;\n\n  /**\n   * Exported type name to generate from.\n   */\n  name?: string;\n\n  /**\n   * Set the type to generate from.\n   *\n   * When used with `name`, it generates the type with `name` as export name.\n   *\n   * ```ts\n   * export const myName = MyType;\n   * ```\n   *\n   * When `type` contains multiple lines, `export const` is not added.\n   * You need to export it manually, and specify the type name with `name`.\n   *\n   * ```tsx\n   * <AutoTypeTable\n   *   path=\"./file.ts\"\n   *   type={`import { ReactNode } from \"react\"\n   *   export const MyName = ReactNode`}\n   *   name=\"MyName\"\n   * />\n   * ```\n   */\n  type?: string;\n}\n\nexport interface GenerateTypeTableOptions extends GenerateOptions {\n  /**\n   * base path to resolve `path` prop\n   */\n  basePath?: string;\n}\n\nexport async function getTypeTableOutput(\n  gen: Generator,\n  { name, type, ...props }: BaseTypeTableProps,\n  options?: GenerateTypeTableOptions,\n) {\n  const file = props.path && options?.basePath ? join(options.basePath, props.path) : props.path;\n  let typeName = name;\n  let content = '';\n\n  if (file) {\n    content = (await fs.readFile(file)).toString();\n  }\n\n  if (type && type.split('\\n').length > 1) {\n    content += `\\n${type}`;\n  } else if (type) {\n    typeName ??= '$Fumadocs';\n    content += `\\nexport type ${typeName} = ${type}`;\n  }\n\n  const output = await gen.generateDocumentation(\n    { path: file ?? 'temp.ts', content },\n    typeName,\n    options,\n  );\n\n  if (name && output.length === 0)\n    throw new Error(`${name} in ${file ?? 'empty file'} doesn't exist`);\n\n  return output;\n}\n","import * as ts from 'ts-morph';\n\nexport function getSimpleForm(\n  type: ts.Type,\n  checker: ts.TypeChecker,\n  noUndefined = false,\n  location?: ts.Node,\n): string {\n  if (type.isUndefined() && noUndefined) return '';\n\n  const alias = type.getAliasSymbol();\n  if (alias) {\n    const args = type.getAliasTypeArguments();\n    if (args.length === 0) return alias.getName();\n\n    return `${alias.getName()}<${args.map((arg) => getSimpleForm(arg, checker)).join(', ')}>`;\n  }\n\n  if (type.isUnion()) {\n    const types: string[] = [];\n    for (const t of type.getUnionTypes()) {\n      const str = getSimpleForm(t, checker, noUndefined);\n      if (str.length > 0 && str !== 'never') types.unshift(str);\n    }\n\n    return types.length > 0\n      ? // boolean | null will become true | false | null, need to ensure it's still returned as boolean\n        dedupe(types).join(' | ').replace('true | false', 'boolean')\n      : 'never';\n  }\n\n  if (type.isIntersection()) {\n    const types: string[] = [];\n    for (const t of type.getIntersectionTypes()) {\n      const str = getSimpleForm(t, checker, noUndefined);\n      if (str.length > 0 && str !== 'never') types.unshift(str);\n    }\n\n    return dedupe(types).join(' & ');\n  }\n\n  if (type.isTuple()) {\n    const elements = type\n      .getTupleElements()\n      .map((t) => getSimpleForm(t, checker))\n      .join(', ');\n\n    return `[${elements}]`;\n  }\n\n  if (type.isArray() || type.isReadonlyArray()) {\n    return 'array';\n  }\n\n  if (type.getCallSignatures().length > 0) {\n    return 'function';\n  }\n\n  if (type.isClassOrInterface() || type.isObject()) {\n    return 'object';\n  }\n\n  return type.getText(location, ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);\n}\n\nfunction dedupe<T>(arr: T[]): T[] {\n  const dedupe = new Set<T>();\n  const out: T[] = [];\n\n  for (const item of arr) {\n    if (!dedupe.has(item)) {\n      out.push(item);\n      dedupe.add(item);\n    }\n  }\n\n  return out;\n}\n","import {\n  type ExportedDeclarations,\n  Project,\n  type Symbol as TsSymbol,\n  ts,\n  type Type,\n} from 'ts-morph';\nimport { createProject, type TypescriptConfig } from '@/create-project';\nimport fs from 'node:fs/promises';\nimport {\n  type BaseTypeTableProps,\n  type GenerateTypeTableOptions,\n  getTypeTableOutput,\n} from '@/lib/type-table';\nimport path from 'node:path';\nimport { getSimpleForm } from '@/lib/get-simple-form';\nimport type { Cache } from '@/cache';\n\nexport interface GeneratedDoc {\n  name: string;\n  description: string;\n  entries: DocEntry[];\n}\n\nexport interface DocEntry {\n  name: string;\n  description: string;\n  type: string;\n  simplifiedType: string;\n\n  tags: RawTag[];\n  required: boolean;\n  deprecated: boolean;\n}\n\nexport interface RawTag {\n  name: string;\n  text: string;\n}\n\ninterface EntryContext {\n  program: Project;\n  transform?: Transformer;\n  type: Type;\n  declaration: ExportedDeclarations;\n}\n\ntype Transformer = (\n  this: EntryContext,\n  entry: DocEntry,\n  propertyType: Type,\n  propertySymbol: TsSymbol,\n) => void;\n\nexport interface GenerateOptions {\n  /**\n   * Allow fields with `@internal` tag\n   *\n   * @defaultValue false\n   */\n  allowInternal?: boolean;\n\n  /**\n   * Modify output property entry\n   */\n  transform?: Transformer;\n}\n\nexport type Generator = ReturnType<typeof createGenerator>;\n\nexport interface GeneratorOptions extends TypescriptConfig {\n  /**\n   * cache results, note that some options are not marked as dependency.\n   *\n   * @defaultValue false\n   */\n  cache?: Cache | false;\n\n  project?: Project;\n}\n\nexport function createGenerator(config?: GeneratorOptions | Project) {\n  const options =\n    config instanceof Project\n      ? {\n          project: config,\n        }\n      : config;\n  const cache = options?.cache ? options.cache : null;\n  let instance: Project | undefined;\n\n  function getProject() {\n    instance ??= options?.project ?? createProject(options);\n    return instance;\n  }\n\n  return {\n    async generateDocumentation(\n      file: {\n        path: string;\n        content?: string;\n      },\n      name: string | undefined,\n      options?: GenerateOptions,\n    ) {\n      const content = file.content ?? (await fs.readFile(path.resolve(file.path))).toString();\n      const cacheKey = `${file.path}:${name}:${content}`;\n      if (cache) {\n        const cached = (await cache.read(cacheKey)) as GeneratedDoc[] | undefined;\n        if (cached) return cached;\n      }\n      const sourceFile = getProject().createSourceFile(file.path, content, {\n        overwrite: true,\n      });\n      const out: GeneratedDoc[] = [];\n\n      for (const [k, d] of sourceFile.getExportedDeclarations()) {\n        if (name && name !== k) continue;\n\n        if (d.length > 1)\n          console.warn(`export ${k} should not have more than one type declaration.`);\n\n        out.push(generate(getProject(), k, d[0], options));\n      }\n\n      void cache?.write(cacheKey, out);\n      return out;\n    },\n    generateTypeTable(props: BaseTypeTableProps, options?: GenerateTypeTableOptions) {\n      return getTypeTableOutput(this, props, options);\n    },\n  };\n}\n\nfunction generate(\n  program: Project,\n  name: string,\n  declaration: ExportedDeclarations,\n  { allowInternal = false, transform }: GenerateOptions = {},\n): GeneratedDoc {\n  const entryContext: EntryContext = {\n    transform,\n    program,\n    type: declaration.getType(),\n    declaration,\n  };\n\n  const comment = declaration\n    .getSymbol()\n    ?.compilerSymbol.getDocumentationComment(program.getTypeChecker().compilerObject);\n\n  return {\n    name,\n    description: comment ? ts.displayPartsToString(comment) : '',\n    entries: declaration\n      .getType()\n      .getProperties()\n      .map((prop) => getDocEntry(prop, entryContext))\n      .filter((entry) => entry && (allowInternal || !('internal' in entry.tags))) as DocEntry[],\n  };\n}\n\nfunction getDocEntry(prop: TsSymbol, context: EntryContext): DocEntry | undefined {\n  const { transform, program } = context;\n  if (context.type.isClass() && prop.getName().startsWith('#')) {\n    return;\n  }\n\n  const subType = prop.getTypeAtLocation(context.declaration);\n  const isOptional = prop.isOptional();\n  const tags = prop.getJsDocTags().map(\n    (tag) =>\n      ({\n        name: tag.getName(),\n        text: ts.displayPartsToString(tag.getText()),\n      }) satisfies RawTag,\n  );\n\n  let type = subType.getText(\n    context.declaration,\n    ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts.TypeFormatFlags.NoTruncation,\n  );\n  let simplifiedType = getSimpleForm(\n    subType,\n    program.getTypeChecker(),\n    isOptional,\n    context.declaration,\n  );\n\n  for (const tag of tags) {\n    // replace full type with @fumadocsType\n    if (tag.name === 'fumadocsType') {\n      const match = /`(?<name>.+)`$/.exec(tag.text)?.[1];\n      if (match) type = match;\n      continue;\n    }\n\n    // replace simplified type with @remarks\n    if (tag.name === 'remarks') {\n      const match = /^`(?<name>.+)`/.exec(tag.text)?.[1];\n      if (match) simplifiedType = match;\n    }\n  }\n\n  const entry: DocEntry = {\n    name: prop.getName(),\n    description: ts.displayPartsToString(\n      prop.compilerSymbol.getDocumentationComment(program.getTypeChecker().compilerObject),\n    ),\n    tags,\n    type,\n    simplifiedType,\n    required: !isOptional,\n    deprecated: tags.some((tag) => tag.name === 'deprecated'),\n  };\n\n  transform?.call(context, entry, subType, prop);\n\n  return entry;\n}\n","import type { Root } from 'mdast';\nimport type { Nodes } from 'hast';\nimport type { Transformer } from 'unified';\nimport type { Expression, ExpressionStatement, ObjectExpression, Program } from 'estree';\nimport { createGenerator, type DocEntry, type Generator } from '@/lib/base';\nimport { renderMarkdownToHast, renderTypeToHast } from '@/markdown';\nimport { valueToEstree } from 'estree-util-value-to-estree';\nimport { visit } from 'unist-util-visit';\nimport { type BaseTypeTableProps, type GenerateTypeTableOptions } from '@/lib/type-table';\nimport { toEstree } from 'hast-util-to-estree';\nimport { type ParameterTag, parseTags } from '@/lib/parse-tags';\n\nfunction objectBuilder() {\n  const out: ObjectExpression = {\n    type: 'ObjectExpression',\n    properties: [],\n  };\n\n  return {\n    addExpressionNode(key: string, expression: Expression) {\n      out.properties.push({\n        type: 'Property',\n        method: false,\n        shorthand: false,\n        computed: false,\n        key: {\n          type: 'Identifier',\n          name: key,\n        },\n        kind: 'init',\n        value: expression,\n      });\n    },\n    addJsxProperty(key: string, hast: Nodes) {\n      const estree = toEstree(hast, {\n        elementAttributeNameCase: 'react',\n      }).body[0] as ExpressionStatement;\n\n      this.addExpressionNode(key, estree.expression);\n    },\n    build() {\n      return out;\n    },\n  };\n}\n\nasync function buildTypeProp(\n  entries: DocEntry[],\n  {\n    renderMarkdown = renderMarkdownToHast,\n    renderType = renderTypeToHast,\n  }: RemarkAutoTypeTableOptions,\n): Promise<ObjectExpression> {\n  async function onItem(entry: DocEntry) {\n    const node = objectBuilder();\n    const tags = parseTags(entry.tags);\n    node.addJsxProperty('type', await renderType(entry.simplifiedType));\n    node.addJsxProperty('typeDescription', await renderType(entry.type));\n    node.addExpressionNode('required', valueToEstree(entry.required));\n\n    if (tags.default) node.addJsxProperty('default', await renderType(tags.default));\n\n    if (tags.returns) node.addJsxProperty('returns', await renderMarkdown(tags.returns));\n\n    if (tags.params) {\n      node.addExpressionNode('parameters', {\n        type: 'ArrayExpression',\n        elements: await Promise.all(tags.params.map(onParam)),\n      });\n    }\n\n    if (entry.description) {\n      node.addJsxProperty('description', await renderMarkdown(entry.description));\n    }\n\n    return node.build();\n  }\n\n  async function onParam(param: ParameterTag) {\n    const node = objectBuilder();\n    node.addExpressionNode('name', valueToEstree(param.name));\n    if (param.description)\n      node.addJsxProperty('description', await renderMarkdown(param.description));\n\n    return node.build();\n  }\n\n  const prop = objectBuilder();\n  const output = await Promise.all(\n    entries.map(async (entry) => ({\n      name: entry.name,\n      node: await onItem(entry),\n    })),\n  );\n\n  for (const node of output) {\n    prop.addExpressionNode(node.name, node.node);\n  }\n\n  return prop.build();\n}\n\nexport interface RemarkAutoTypeTableOptions {\n  /**\n   * @defaultValue 'auto-type-table'\n   */\n  name?: string;\n\n  /**\n   * @defaultValue 'TypeTable'\n   */\n  outputName?: string;\n\n  renderMarkdown?: typeof renderMarkdownToHast;\n  renderType?: typeof renderTypeToHast;\n\n  /**\n   * Customise type table generation\n   */\n  options?: GenerateTypeTableOptions;\n\n  /**\n   * generate required `value` property for `remark-stringify`\n   */\n  remarkStringify?: boolean;\n\n  generator?: Generator;\n}\n\nexport interface TypeTableProps extends BaseTypeTableProps {\n  cwd?: true;\n}\n\n/**\n * Compile `auto-type-table` into Fumadocs UI compatible TypeTable\n *\n * MDX is required to use this plugin.\n */\nexport function remarkAutoTypeTable(\n  config: RemarkAutoTypeTableOptions = {},\n): Transformer<Root, Root> {\n  const {\n    name = 'auto-type-table',\n    outputName = 'TypeTable',\n    options: generateOptions = {},\n    remarkStringify = true,\n    generator = createGenerator(),\n  } = config;\n\n  return async (tree, file) => {\n    const queue: Promise<void>[] = [];\n    async function run(node: object, props: TypeTableProps) {\n      let basePath = props.cwd ? file.cwd : generateOptions.basePath;\n      if (file.dirname) {\n        basePath ??= file.dirname;\n      }\n\n      const output = await generator.generateTypeTable(props, {\n        ...generateOptions,\n        basePath,\n      });\n\n      const rendered = output.map(async (doc) => {\n        return {\n          type: 'mdxJsxFlowElement',\n          name: outputName,\n          attributes: [\n            {\n              type: 'mdxJsxAttribute',\n              name: 'type',\n              value: {\n                type: 'mdxJsxAttributeValueExpression',\n                value: remarkStringify ? JSON.stringify(doc, null, 2) : '',\n                data: {\n                  estree: {\n                    type: 'Program',\n                    sourceType: 'module',\n                    body: [\n                      {\n                        type: 'ExpressionStatement',\n                        expression: await buildTypeProp(doc.entries, config),\n                      },\n                    ],\n                  } satisfies Program,\n                },\n              },\n            },\n          ],\n          children: [],\n        };\n      });\n\n      Object.assign(node, {\n        type: 'root',\n        attributes: [],\n        children: await Promise.all(rendered),\n      } as Root);\n    }\n\n    visit(tree, 'mdxJsxFlowElement', (node) => {\n      if (node.name !== name) return;\n      const props: Record<string, string | true> = {};\n      const onError = (message: string, cause?: Error) => {\n        const location = node.position\n          ? `${file.path}:${node.position.start.line}:${node.position.start.column}`\n          : file.path;\n        throw new Error(`${location} from <auto-type-table>: ${message}`, {\n          cause,\n        });\n      };\n\n      for (const attr of node.attributes) {\n        if (attr.type !== 'mdxJsxAttribute') {\n          onError('only named attributes are allowed.');\n        } else if (typeof attr.value === 'string') {\n          props[attr.name] = attr.value;\n        } else if (attr.value === null) {\n          props[attr.name] = true;\n        } else {\n          onError('only string & boolean attributes are allowed.');\n        }\n      }\n\n      queue.push(\n        run(node, props).catch((err) => {\n          onError('failed to generate type table', err);\n        }),\n      );\n      return 'skip';\n    });\n\n    await Promise.all(queue);\n  };\n}\n","import fs from 'node:fs/promises';\nimport { createHash } from 'node:crypto';\nimport path from 'node:path';\nimport type { Cache } from '@/cache/index';\n\nexport function createFileSystemGeneratorCache(dir: string): Cache {\n  // call `path.resolve` so Vercel NFT will include the cache directory in production.\n  dir = path.resolve(dir);\n  const initDirPromise = fs.mkdir(dir, { recursive: true }).catch(() => {\n    // it fails on Vercel as of 2025 12 May, we can skip it\n  });\n\n  return {\n    async write(input, data) {\n      const hash = createHash('SHA256').update(input).digest('hex').slice(0, 12);\n\n      await initDirPromise;\n      await fs.writeFile(path.join(dir, `${hash}.json`), JSON.stringify(data));\n    },\n    async read(input) {\n      const hash = createHash('SHA256').update(input).digest('hex').slice(0, 12);\n\n      try {\n        return JSON.parse((await fs.readFile(path.join(dir, `${hash}.json`))).toString());\n      } catch {\n        return;\n      }\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/objectSpread2-BbbttTvx.js

@@ -1,203 +0,0 @@
-import { remark } from "remark";
-import { remarkGfm } from "fumadocs-core/mdx-plugins/remark-gfm";
-import { rehypeCode } from "fumadocs-core/mdx-plugins/rehype-code";
-import remarkRehype from "remark-rehype";
-import { getHighlighter } from "fumadocs-core/highlight";
-
-//#region \0@oxc-project+runtime@0.103.0/helpers/objectWithoutPropertiesLoose.js
-function _objectWithoutPropertiesLoose(r, e) {
-	if (null == r) return {};
-	var t = {};
-	for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
-		if (e.includes(n)) continue;
-		t[n] = r[n];
-	}
-	return t;
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.103.0/helpers/objectWithoutProperties.js
-function _objectWithoutProperties(e, t) {
-	if (null == e) return {};
-	var o, r, i = _objectWithoutPropertiesLoose(e, t);
-	if (Object.getOwnPropertySymbols) {
-		var s = Object.getOwnPropertySymbols(e);
-		for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
-	}
-	return i;
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.103.0/helpers/asyncToGenerator.js
-function asyncGeneratorStep(n, t, e, r, o, a, c) {
-	try {
-		var i = n[a](c), u = i.value;
-	} catch (n$1) {
-		e(n$1);
-		return;
-	}
-	i.done ? t(u) : Promise.resolve(u).then(r, o);
-}
-function _asyncToGenerator(n) {
-	return function() {
-		var t = this, e = arguments;
-		return new Promise(function(r, o) {
-			var a = n.apply(t, e);
-			function _next(n$1) {
-				asyncGeneratorStep(a, r, o, _next, _throw, "next", n$1);
-			}
-			function _throw(n$1) {
-				asyncGeneratorStep(a, r, o, _next, _throw, "throw", n$1);
-			}
-			_next(void 0);
-		});
-	};
-}
-
-//#endregion
-//#region src/markdown.ts
-const shikiOptions = {
-	lazy: true,
-	langs: ["ts", "tsx"],
-	transformers: [],
-	parseMetaString: void 0,
-	themes: {
-		light: "github-light",
-		dark: "github-dark"
-	}
-};
-const processor = remark().use(remarkGfm).use(remarkRehype).use(rehypeCode, shikiOptions);
-function renderTypeToHast(_x) {
-	return _renderTypeToHast.apply(this, arguments);
-}
-function _renderTypeToHast() {
-	_renderTypeToHast = _asyncToGenerator(function* (type) {
-		return {
-			type: "element",
-			tagName: "span",
-			properties: { class: "shiki" },
-			children: [{
-				type: "element",
-				tagName: "code",
-				properties: {},
-				children: (yield getHighlighter("js", {
-					langs: ["ts"],
-					themes: Object.values(shikiOptions.themes)
-				})).codeToHast(type, {
-					lang: "ts",
-					structure: "inline",
-					themes: shikiOptions.themes,
-					defaultColor: false
-				}).children
-			}]
-		};
-	});
-	return _renderTypeToHast.apply(this, arguments);
-}
-function renderMarkdownToHast(_x2) {
-	return _renderMarkdownToHast.apply(this, arguments);
-}
-function _renderMarkdownToHast() {
-	_renderMarkdownToHast = _asyncToGenerator(function* (md) {
-		md = md.replace(new RegExp("{@link (?<link>[^}]*)}", "g"), "$1");
-		return processor.run(processor.parse(md));
-	});
-	return _renderMarkdownToHast.apply(this, arguments);
-}
-
-//#endregion
-//#region src/lib/parse-tags.ts
-/**
-* Parse tags, only returns recognized fields.
-*/
-function parseTags(tags) {
-	const typed = {};
-	for (const { name: key, text } of tags) {
-		if (key === "default" || key === "defaultValue") {
-			typed.default = text;
-			continue;
-		}
-		if (key === "param") {
-			var _typed$params;
-			const [param, description] = text.split("-", 2);
-			(_typed$params = typed.params) !== null && _typed$params !== void 0 || (typed.params = []);
-			typed.params.push({
-				name: param.trim(),
-				description: description.trim()
-			});
-			continue;
-		}
-		if (key === "returns") typed.returns = text;
-	}
-	return typed;
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.103.0/helpers/typeof.js
-function _typeof(o) {
-	"@babel/helpers - typeof";
-	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
-		return typeof o$1;
-	} : function(o$1) {
-		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
-	}, _typeof(o);
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.103.0/helpers/toPrimitive.js
-function toPrimitive(t, r) {
-	if ("object" != _typeof(t) || !t) return t;
-	var e = t[Symbol.toPrimitive];
-	if (void 0 !== e) {
-		var i = e.call(t, r || "default");
-		if ("object" != _typeof(i)) return i;
-		throw new TypeError("@@toPrimitive must return a primitive value.");
-	}
-	return ("string" === r ? String : Number)(t);
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.103.0/helpers/toPropertyKey.js
-function toPropertyKey(t) {
-	var i = toPrimitive(t, "string");
-	return "symbol" == _typeof(i) ? i : i + "";
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.103.0/helpers/defineProperty.js
-function _defineProperty(e, r, t) {
-	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-		value: t,
-		enumerable: !0,
-		configurable: !0,
-		writable: !0
-	}) : e[r] = t, e;
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.103.0/helpers/objectSpread2.js
-function ownKeys(e, r) {
-	var t = Object.keys(e);
-	if (Object.getOwnPropertySymbols) {
-		var o = Object.getOwnPropertySymbols(e);
-		r && (o = o.filter(function(r$1) {
-			return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
-		})), t.push.apply(t, o);
-	}
-	return t;
-}
-function _objectSpread2(e) {
-	for (var r = 1; r < arguments.length; r++) {
-		var t = null != arguments[r] ? arguments[r] : {};
-		r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
-			_defineProperty(e, r$1, t[r$1]);
-		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
-			Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
-		});
-	}
-	return e;
-}
-
-//#endregion
-export { _asyncToGenerator as a, renderTypeToHast as i, parseTags as n, _objectWithoutProperties as o, renderMarkdownToHast as r, _objectSpread2 as t };
-//# sourceMappingURL=objectSpread2-BbbttTvx.js.map

package/dist/objectSpread2-BbbttTvx.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"objectSpread2-BbbttTvx.js","names":["typed: TypedTags"],"sources":["../src/markdown.ts","../src/lib/parse-tags.ts"],"sourcesContent":["import type { ElementContent, Nodes } from 'hast';\nimport { remark } from 'remark';\nimport { remarkGfm } from 'fumadocs-core/mdx-plugins/remark-gfm';\nimport { rehypeCode, type RehypeCodeOptions } from 'fumadocs-core/mdx-plugins/rehype-code';\nimport remarkRehype from 'remark-rehype';\nimport { getHighlighter } from 'fumadocs-core/highlight';\n\nconst shikiOptions = {\n  lazy: true,\n  langs: ['ts', 'tsx'],\n\n  // disable default transformers & meta parser\n  transformers: [],\n  parseMetaString: undefined,\n\n  themes: {\n    light: 'github-light',\n    dark: 'github-dark',\n  },\n} satisfies RehypeCodeOptions;\n\nconst processor = remark().use(remarkGfm).use(remarkRehype).use(rehypeCode, shikiOptions);\n\nexport async function renderTypeToHast(type: string): Promise<Nodes> {\n  const highlighter = await getHighlighter('js', {\n    langs: ['ts'],\n    themes: Object.values(shikiOptions.themes),\n  });\n\n  const nodes = highlighter.codeToHast(type, {\n    lang: 'ts',\n    structure: 'inline',\n    themes: shikiOptions.themes,\n    defaultColor: false,\n  });\n\n  return {\n    type: 'element',\n    tagName: 'span',\n    properties: {\n      class: 'shiki',\n    },\n    children: [\n      {\n        type: 'element',\n        tagName: 'code',\n        properties: {},\n        children: nodes.children as ElementContent[],\n      },\n    ],\n  };\n}\n\nexport async function renderMarkdownToHast(md: string): Promise<Nodes> {\n  md = md.replace(/{@link (?<link>[^}]*)}/g, '$1'); // replace jsdoc links\n\n  return processor.run(processor.parse(md));\n}\n","import { RawTag } from '@/lib/base';\n\nexport interface ParameterTag {\n  name: string;\n  description?: string;\n}\n\nexport interface TypedTags {\n  default?: string;\n  params?: ParameterTag[];\n  returns?: string;\n}\n\n/**\n * Parse tags, only returns recognized fields.\n */\nexport function parseTags(tags: RawTag[]): TypedTags {\n  const typed: TypedTags = {};\n\n  for (const { name: key, text } of tags) {\n    if (key === 'default' || key === 'defaultValue') {\n      typed.default = text;\n      continue;\n    }\n\n    if (key === 'param') {\n      const [param, description] = text.split('-', 2);\n\n      typed.params ??= [];\n      typed.params.push({\n        name: param.trim(),\n        description: description.trim(),\n      });\n      continue;\n    }\n\n    if (key === 'returns') {\n      typed.returns = text;\n    }\n  }\n\n  return typed;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA,MAAM,eAAe;CACnB,MAAM;CACN,OAAO,CAAC,MAAM,MAAM;CAGpB,cAAc,EAAE;CAChB,iBAAiB;CAEjB,QAAQ;EACN,OAAO;EACP,MAAM;EACP;CACF;AAED,MAAM,YAAY,QAAQ,CAAC,IAAI,UAAU,CAAC,IAAI,aAAa,CAAC,IAAI,YAAY,aAAa;AAEzF,SAAsB,iBAAiB;;;;wDAA8B;AAanE,SAAO;GACL,MAAM;GACN,SAAS;GACT,YAAY,EACV,OAAO,SACR;GACD,UAAU,CACR;IACE,MAAM;IACN,SAAS;IACT,YAAY,EAAE;IACd,iBAvBoB,eAAe,MAAM;KAC7C,OAAO,CAAC,KAAK;KACb,QAAQ,OAAO,OAAO,aAAa,OAAO;KAC3C,CAAC,EAEwB,WAAW,MAAM;KACzC,MAAM;KACN,WAAW;KACX,QAAQ,aAAa;KACrB,cAAc;KACf,CAAC,CAaoB;IACjB,CACF;GACF;;;;AAGH,SAAsB,qBAAqB;;;;0DAA4B;AACrE,OAAK,GAAG,QAAQ,yCAAyB,EAAE,KAAK;AAEhD,SAAO,UAAU,IAAI,UAAU,MAAM,GAAG,CAAC;;;;;;;;;;ACxC3C,SAAgB,UAAU,MAA2B;CACnD,MAAMA,QAAmB,EAAE;AAE3B,MAAK,MAAM,EAAE,MAAM,KAAK,UAAU,MAAM;AACtC,MAAI,QAAQ,aAAa,QAAQ,gBAAgB;AAC/C,SAAM,UAAU;AAChB;;AAGF,MAAI,QAAQ,SAAS;;GACnB,MAAM,CAAC,OAAO,eAAe,KAAK,MAAM,KAAK,EAAE;AAE/C,0BAAM,iDAAN,MAAM,SAAW,EAAE;AACnB,SAAM,OAAO,KAAK;IAChB,MAAM,MAAM,MAAM;IAClB,aAAa,YAAY,MAAM;IAChC,CAAC;AACF;;AAGF,MAAI,QAAQ,UACV,OAAM,UAAU;;AAIpB,QAAO"}

package/dist/ui/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/ui/auto-type-table.tsx"],"sourcesContent":[],"mappings":";;;;;;KAYY,kBAAA,GAAqB;AAArB,iBAEU,aAAA,CAFW;EAAA,SAAA;EAAA,OAAkB;EAAA,UAAA;EAAA,cAAA;EAAA,GAAA;CAAA,EAQhD,kBARgD,GAAA;EAE7B,SAAA,EAOT,SAPsB;EACjC,cAAA,CAAA,EAAA,OAQwB,qBARxB;EACA,UAAA,CAAA,EAAA,OAQoB,iBARpB;EACA,OAAA,CAAA,EAQU,wBARV;CACA,CAAA,EAQD,OARC,CAQD,OARC,CAQD,OAAA,CAAA,GAAA,CAAA,OARC,CAAA,EAAA,CAAA;iBAmDa,iBAAA,CAjDZ,IAAA,EAAA,MAAA,CAAA,EAiD6C,OAjD7C,CAiDqD,SAjDrD,CAAA;iBAqDY,qBAAA,CApDF,EAAA,EAAA,MAAA,CAAA,EAoDqC,OApDrC,CAoD6C,SApD7C,CAAA"}

package/dist/ui/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["paramNodes: ParameterNode[]"],"sources":["../../src/ui/auto-type-table.tsx"],"sourcesContent":["import { type ParameterNode, type TypeNode, TypeTable } from 'fumadocs-ui/components/type-table';\nimport { type Jsx, toJsxRuntime } from 'hast-util-to-jsx-runtime';\nimport * as runtime from 'react/jsx-runtime';\nimport defaultMdxComponents from 'fumadocs-ui/mdx';\nimport { renderMarkdownToHast, renderTypeToHast } from '@/markdown';\nimport 'server-only';\nimport type { ReactNode } from 'react';\nimport { type BaseTypeTableProps, type GenerateTypeTableOptions } from '@/lib/type-table';\nimport { type Generator } from '@/lib/base';\nimport type { Nodes } from 'hast';\nimport { parseTags } from '@/lib/parse-tags';\n\nexport type AutoTypeTableProps = BaseTypeTableProps;\n\nexport async function AutoTypeTable({\n  generator,\n  options = {},\n  renderType = renderTypeDefault,\n  renderMarkdown = renderMarkdownDefault,\n  ...props\n}: AutoTypeTableProps & {\n  generator: Generator;\n\n  renderMarkdown?: typeof renderMarkdownDefault;\n  renderType?: typeof renderTypeDefault;\n  options?: GenerateTypeTableOptions;\n}) {\n  const output = await generator.generateTypeTable(props, options);\n\n  return output.map(async (item) => {\n    const entries = item.entries.map(async (entry) => {\n      const tags = parseTags(entry.tags);\n      const paramNodes: ParameterNode[] = [];\n\n      for (const param of tags.params ?? []) {\n        paramNodes.push({\n          name: param.name,\n          description: param.description ? await renderMarkdown(param.description) : undefined,\n        });\n      }\n\n      return [\n        entry.name,\n        {\n          type: await renderType(entry.simplifiedType),\n          typeDescription: await renderType(entry.type),\n          description: await renderMarkdown(entry.description),\n          default: tags.default ? await renderType(tags.default) : undefined,\n          parameters: paramNodes,\n          required: entry.required,\n          deprecated: entry.deprecated,\n          returns: tags.returns ? await renderMarkdown(tags.returns) : undefined,\n        } as TypeNode,\n      ];\n    });\n\n    return <TypeTable key={item.name} type={Object.fromEntries(await Promise.all(entries))} />;\n  });\n}\n\nfunction toJsx(hast: Nodes) {\n  return toJsxRuntime(hast, {\n    Fragment: runtime.Fragment,\n    jsx: runtime.jsx as Jsx,\n    jsxs: runtime.jsxs as Jsx,\n    components: { ...defaultMdxComponents, img: undefined },\n  });\n}\n\nasync function renderTypeDefault(type: string): Promise<ReactNode> {\n  return toJsx(await renderTypeToHast(type));\n}\n\nasync function renderMarkdownDefault(md: string): Promise<ReactNode> {\n  return toJsx(await renderMarkdownToHast(md));\n}\n"],"mappings":";;;;;;;;;;CAeE;CACA;CACA;CACA;;AAJF,SAAsB,cAAc;;;;qDAYjC;MAZiC,EAClC,WACA,UAAU,EAAE,EACZ,aAAa,mBACb,iBAAiB,gCACd;AAUH,gBAFqB,UAAU,kBAAkB,OAAO,QAAQ,EAElD;4CAAW,MAAS;IAChC,MAAM,UAAU,KAAK,QAAQ;8CAAW,OAAU;;MAChD,MAAM,OAAO,UAAU,MAAM,KAAK;MAClC,MAAMA,aAA8B,EAAE;AAEtC,WAAK,MAAM,yBAAS,KAAK,6DAAU,EAAE,CACnC,YAAW,KAAK;OACd,MAAM,MAAM;OACZ,aAAa,MAAM,oBAAoB,eAAe,MAAM,YAAY,GAAG;OAC5E,CAAC;AAGJ,aAAO,CACL,MAAM,MACN;OACE,YAAY,WAAW,MAAM,eAAe;OAC5C,uBAAuB,WAAW,MAAM,KAAK;OAC7C,mBAAmB,eAAe,MAAM,YAAY;OACpD,SAAS,KAAK,gBAAgB,WAAW,KAAK,QAAQ,GAAG;OACzD,YAAY;OACZ,UAAU,MAAM;OAChB,YAAY,MAAM;OAClB,SAAS,KAAK,gBAAgB,eAAe,KAAK,QAAQ,GAAG;OAC9D,CACF;;qBAvBqC;;;QAwBtC;AAEF,WAAO,oBAAC,aAA0B,MAAM,OAAO,kBAAkB,QAAQ,IAAI,QAAQ,CAAC,IAA/D,KAAK,KAA8D;;mBA3BnE;;;MA4BvB;;;;AAGJ,SAAS,MAAM,MAAa;AAC1B,QAAO,aAAa,MAAM;EACxB,UAAU,QAAQ;EAClB,KAAK,QAAQ;EACb,MAAM,QAAQ;EACd,8CAAiB,6BAAsB,KAAK;EAC7C,CAAC;;AAGJ,SAAe,kBAAkB;;;;yDAAkC;AACjE,SAAO,YAAY,iBAAiB,KAAK,CAAC;;;;AAG5C,SAAe,sBAAsB;;;;2DAAgC;AACnE,SAAO,YAAY,qBAAqB,GAAG,CAAC"}