fumadocs-typescript 5.0.0 → 5.1.0

package/dist/index.js

@@ -1,438 +1,322 @@
-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 { 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";
+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
-  });
+	return new Project({
+		tsConfigFilePath: 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
+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;
 }
 
-// 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?.cache ? options.cache : null;
+	let instance;
+	function getProject() {
+		instance ??= options?.project ?? createProject(options);
+		return instance;
+	}
+	return {
+		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);
+		}
+	};
 }
 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))
-    )
-  };
+	const entryContext = {
+		transform,
+		program,
+		type: declaration.getType(),
+		declaration
+	};
+	const comment = declaration.getSymbol()?.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") {
+			const match = /`(?<name>.+)`$/.exec(tag.text)?.[1];
+			if (match) type = match;
+			continue;
+		}
+		if (tag.name === "remarks") {
+			const match = /^`(?<name>.+)`/.exec(tag.text)?.[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?.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(_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();
-  });
+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
+*
+* 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(), 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: []
+				};
+			});
+			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";
+		});
+		await Promise.all(queue);
+	};
 }
 
-// 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 {
+		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));
+		},
+		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;
+			}
+		}
+	};
 }
-export {
-  createFileSystemGeneratorCache,
-  createGenerator,
-  createProject,
-  remarkAutoTypeTable,
-  renderMarkdownToHast
-};
+
+//#endregion
+export { createFileSystemGeneratorCache, createGenerator, createProject, remarkAutoTypeTable };