writr 6.1.1 → 6.1.3

package/dist/writr.mjs

@@ -0,0 +1,848 @@
+import fs from "node:fs";
+import { dirname } from "node:path";
+import { Hookified } from "hookified";
+import parse from "html-react-parser";
+import * as yaml from "js-yaml";
+import rehypeHighlight from "rehype-highlight";
+import rehypeKatex from "rehype-katex";
+import rehypeRaw from "rehype-raw";
+import rehypeSlug from "rehype-slug";
+import rehypeStringify from "rehype-stringify";
+import remarkEmoji from "remark-emoji";
+import remarkGfm from "remark-gfm";
+import remarkGithubBlockquoteAlert from "remark-github-blockquote-alert";
+import remarkMath from "remark-math";
+import remarkMDX from "remark-mdx";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import remarkToc from "remark-toc";
+import { unified } from "unified";
+import { CacheableMemory } from "cacheable";
+import { Hashery } from "hashery";
+import { Output, generateText } from "ai";
+import { z } from "zod";
+//#region src/writr-cache.ts
+var WritrCache = class {
+	_store = new CacheableMemory();
+	_hashStore = new CacheableMemory();
+	_hash = new Hashery();
+	get store() {
+		return this._store;
+	}
+	get hashStore() {
+		return this._hashStore;
+	}
+	get(markdown, options) {
+		const key = this.hash(markdown, options);
+		return this._store.get(key);
+	}
+	set(markdown, value, options) {
+		const key = this.hash(markdown, options);
+		this._store.set(key, value);
+	}
+	clear() {
+		this._store.clear();
+		this._hashStore.clear();
+	}
+	hash(markdown, options) {
+		const content = {
+			markdown,
+			options: this.sanitizeOptions(options)
+		};
+		const key = JSON.stringify(content);
+		const result = this._hashStore.get(key);
+		if (result) return result;
+		const hash = this._hash.toHashSync(content);
+		this._hashStore.set(key, hash);
+		return hash;
+	}
+	/**
+	* Sanitizes render options to only include serializable properties for caching.
+	* This prevents issues with structuredClone when options contain Promises, functions, or circular references.
+	* @param {RenderOptions} [options] The render options to sanitize
+	* @returns {RenderOptions | undefined} A new object with only the known RenderOptions properties
+	*/
+	sanitizeOptions(options) {
+		if (!options) return;
+		const sanitized = {};
+		if (options.emoji !== void 0) sanitized.emoji = options.emoji;
+		/* v8 ignore next -- @preserve */
+		if (options.toc !== void 0) sanitized.toc = options.toc;
+		if (options.slug !== void 0) sanitized.slug = options.slug;
+		if (options.highlight !== void 0) sanitized.highlight = options.highlight;
+		if (options.gfm !== void 0) sanitized.gfm = options.gfm;
+		if (options.math !== void 0) sanitized.math = options.math;
+		if (options.mdx !== void 0) sanitized.mdx = options.mdx;
+		if (options.caching !== void 0) sanitized.caching = options.caching;
+		return sanitized;
+	}
+};
+//#endregion
+//#region src/types.ts
+let WritrHooks = /* @__PURE__ */ function(WritrHooks) {
+	WritrHooks["beforeRender"] = "beforeRender";
+	WritrHooks["afterRender"] = "afterRender";
+	WritrHooks["saveToFile"] = "saveToFile";
+	WritrHooks["renderToFile"] = "renderToFile";
+	WritrHooks["loadFromFile"] = "loadFromFile";
+	return WritrHooks;
+}({});
+//#endregion
+//#region src/writr-ai-cache.ts
+var WritrAICache = class {
+	_store = new CacheableMemory();
+	_hashStore = new CacheableMemory();
+	_hash = new Hashery();
+	get store() {
+		return this._store;
+	}
+	get hashStore() {
+		return this._hashStore;
+	}
+	get(key, context) {
+		const hash = this.hash(key, context);
+		return this._store.get(hash);
+	}
+	set(key, context, value) {
+		const hash = this.hash(key, context);
+		this._store.set(hash, value);
+	}
+	hash(key, context) {
+		const content = {
+			key,
+			context
+		};
+		const cacheKey = JSON.stringify(content);
+		const result = this._hashStore.get(cacheKey);
+		if (result) return result;
+		const hash = this._hash.toHashSync(content);
+		this._hashStore.set(cacheKey, hash);
+		return hash;
+	}
+	clear() {
+		this._store.clear();
+		this._hashStore.clear();
+	}
+};
+//#endregion
+//#region src/writr-ai.ts
+const AVERAGE_WORDS_PER_MINUTE = 200;
+/**
+* AI companion for a {@link Writr} instance.
+*
+* WritrAI provides metadata generation, SEO generation,
+* translation, and metadata application for markdown documents.
+*/
+var WritrAI = class {
+	writr;
+	/**
+	* The AI SDK model used for all generation requests.
+	*/
+	model;
+	/**
+	* The prompt templates used by this WritrAI instance.
+	*/
+	prompts;
+	/**
+	* Optional in-memory cache for generated AI results.
+	*/
+	cache;
+	/**
+	* Creates a new WritrAI instance bound to a specific Writr document.
+	*
+	* @param writr - The base Writr instance this AI helper operates on.
+	* @param options - The AI model and optional cache/prompt settings.
+	*/
+	constructor(writr, options) {
+		this.writr = writr;
+		this.model = options.model;
+		this.prompts = options.prompts ?? {};
+		this.cache = options.cache ? new WritrAICache() : void 0;
+	}
+	/**
+	* Generates metadata for the current markdown document.
+	*
+	* Pass `allowedTags`, `allowedKeywords`, or `allowedCategories` to constrain the
+	* AI to a controlled vocabulary — values are enforced via a Zod response schema
+	* (`z.array(z.enum(...))` for tags/keywords, `z.enum(...)` for category) so the
+	* model cannot return anything outside the list. Providing a non-empty `allowed*`
+	* array also implicitly enables its corresponding field.
+	*
+	* @param options - Controls which metadata fields should be generated.
+	* @returns A metadata object for the current document.
+	*
+	* @example
+	* ```typescript
+	* const metadata = await writr.ai.getMetadata({
+	*   allowedTags: ['javascript', 'typescript', 'python'],
+	*   allowedCategories: ['tutorial', 'guide', 'blog'],
+	* });
+	* // metadata.tags ⊆ allowedTags, metadata.category ∈ allowedCategories
+	* ```
+	*/
+	async getMetadata(options) {
+		const cacheKey = `metadata:${JSON.stringify(options ?? {})}`;
+		const cached = this.cache?.get(cacheKey, this.writr.content);
+		if (cached) return cached;
+		const fields = this.resolveMetadataFields(options);
+		const result = {};
+		if (fields.includes("wordCount")) result.wordCount = this.computeWordCount();
+		if (fields.includes("readingTime")) result.readingTime = this.computeReadingTime();
+		const aiFields = fields.filter((f) => f !== "wordCount" && f !== "readingTime");
+		if (aiFields.length > 0) {
+			const schema = this.buildMetadataSchema(aiFields, options);
+			let prompt = this.prompts.metadata ?? "Analyze the following markdown document and generate metadata for it. Be concise and accurate.";
+			const aiFieldSet = new Set(aiFields);
+			const constraints = [];
+			if (aiFieldSet.has("tags") && options?.allowedTags?.length) constraints.push(`Tags must be selected from: ${options.allowedTags.join(", ")}`);
+			if (aiFieldSet.has("keywords") && options?.allowedKeywords?.length) constraints.push(`Keywords must be selected from: ${options.allowedKeywords.join(", ")}`);
+			if (aiFieldSet.has("category") && options?.allowedCategories?.length) constraints.push(`Category must be one of: ${options.allowedCategories.join(", ")}`);
+			if (constraints.length > 0) prompt += `\n\nConstraints:\n${constraints.map((c) => `- ${c}`).join("\n")}`;
+			const { output } = await generateText({
+				model: this.model,
+				output: Output.object({ schema }),
+				prompt: `${prompt}\n\n---\n\n${this.writr.content}`
+			});
+			Object.assign(result, output);
+		}
+		this.cache?.set(cacheKey, this.writr.content, result);
+		return result;
+	}
+	/**
+	* Generates SEO metadata for the current markdown document.
+	*
+	* @param options - Controls which SEO fields should be generated.
+	* @returns An SEO metadata object for the current document.
+	*/
+	async getSEO(options) {
+		const cacheKey = `seo:${JSON.stringify(options ?? {})}`;
+		const cached = this.cache?.get(cacheKey, this.writr.content);
+		if (cached) return cached;
+		const fields = this.resolveSEOFields(options);
+		const schema = this.buildSEOSchema(fields);
+		const prompt = this.prompts.seo ?? "Analyze the following markdown document and generate SEO metadata for it. Be concise and accurate.";
+		const { output } = await generateText({
+			model: this.model,
+			output: Output.object({ schema }),
+			prompt: `${prompt}\n\n---\n\n${this.writr.content}`
+		});
+		const result = output;
+		this.cache?.set(cacheKey, this.writr.content, result);
+		return result;
+	}
+	/**
+	* Generates a translated version of the current document.
+	*
+	* @param options - Translation settings including target locale.
+	* @returns A new translated Writr instance.
+	*/
+	async getTranslation(options) {
+		const cacheKey = `translation:${JSON.stringify(options)}`;
+		const cached = this.cache?.get(cacheKey, this.writr.content);
+		if (cached) return new Writr(cached);
+		const fromClause = options.from ? ` from ${options.from}` : "";
+		const frontMatterClause = options.translateFrontMatter ? " Also translate any string values in the YAML frontmatter." : " Preserve the YAML frontmatter exactly as-is without translating it.";
+		const prompt = this.prompts.translation ?? `Translate the following markdown document${fromClause} to ${options.to}.${frontMatterClause} Preserve all markdown formatting, links, code blocks, and structure. Return only the translated markdown document with no additional commentary.`;
+		let { text } = await generateText({
+			model: this.model,
+			prompt: `${prompt}\n\n---\n\n${this.writr.content}`
+		});
+		text = this.stripCodeFence(text);
+		this.cache?.set(cacheKey, this.writr.content, text);
+		return new Writr(text);
+	}
+	/**
+	* Generates metadata and applies it to the document frontmatter.
+	*
+	* @param options - Controls generation, overwrite behavior, and field mapping.
+	* @returns A result object describing what metadata was generated and applied.
+	*/
+	async applyMetadata(options) {
+		const generated = await this.getMetadata(options?.generate);
+		const frontMatter = { ...this.writr.frontMatter };
+		const fieldMap = options?.fieldMap ?? {};
+		const overwrite = options?.overwrite;
+		const applied = [];
+		const overwritten = [];
+		const skipped = [];
+		const overwriteSet = Array.isArray(overwrite) ? new Set(overwrite) : void 0;
+		for (const key of Object.keys(generated)) {
+			const value = generated[key];
+			if (value === void 0) continue;
+			const frontMatterKey = fieldMap[key] ?? key;
+			if (!(frontMatterKey in frontMatter)) {
+				frontMatter[frontMatterKey] = value;
+				applied.push(key);
+			} else if (overwrite === true || overwriteSet?.has(key)) {
+				frontMatter[frontMatterKey] = value;
+				overwritten.push(key);
+			} else skipped.push(key);
+		}
+		this.writr.frontMatter = frontMatter;
+		return {
+			writr: this.writr,
+			generated,
+			applied,
+			overwritten,
+			skipped
+		};
+	}
+	resolveMetadataFields(options) {
+		const allFields = [
+			"title",
+			"tags",
+			"keywords",
+			"description",
+			"preview",
+			"summary",
+			"category",
+			"topic",
+			"audience",
+			"difficulty",
+			"readingTime",
+			"wordCount"
+		];
+		if (!options) return allFields;
+		const effective = { ...options };
+		if (effective.allowedTags?.length && effective.tags === void 0) effective.tags = true;
+		if (effective.allowedKeywords?.length && effective.keywords === void 0) effective.keywords = true;
+		if (effective.allowedCategories?.length && effective.category === void 0) effective.category = true;
+		return allFields.filter((field) => effective[field] === true);
+	}
+	resolveSEOFields(options) {
+		const allFields = ["slug", "openGraph"];
+		if (!options) return allFields;
+		return allFields.filter((field) => options[field] === true);
+	}
+	buildMetadataSchema(fields, options) {
+		const fieldSet = new Set(fields);
+		const entries = [];
+		if (fieldSet.has("title")) entries.push(["title", z.string().describe("The best-fit title for the document")]);
+		if (fieldSet.has("tags")) {
+			const uniqueTags = options?.allowedTags?.length ? [...new Set(options.allowedTags)] : void 0;
+			const itemSchema = uniqueTags?.length ? z.enum(uniqueTags) : z.string();
+			entries.push(["tags", z.array(itemSchema).describe(uniqueTags?.length ? `Human-friendly labels selected from: ${uniqueTags.join(", ")}` : "Human-friendly labels for organizing the document")]);
+		}
+		if (fieldSet.has("keywords")) {
+			const uniqueKeywords = options?.allowedKeywords?.length ? [...new Set(options.allowedKeywords)] : void 0;
+			const itemSchema = uniqueKeywords?.length ? z.enum(uniqueKeywords) : z.string();
+			entries.push(["keywords", z.array(itemSchema).describe(uniqueKeywords?.length ? `Search-oriented terms selected from: ${uniqueKeywords.join(", ")}` : "Search-oriented terms related to the document")]);
+		}
+		if (fieldSet.has("description")) entries.push(["description", z.string().describe("A concise meta-style description of the document")]);
+		if (fieldSet.has("preview")) entries.push(["preview", z.string().describe("A short teaser or preview of the content")]);
+		if (fieldSet.has("summary")) entries.push(["summary", z.string().describe("A slightly longer overview of the document")]);
+		if (fieldSet.has("category")) {
+			const uniqueCategories = options?.allowedCategories?.length ? [...new Set(options.allowedCategories)] : void 0;
+			const schema = uniqueCategories?.length ? z.enum(uniqueCategories) : z.string();
+			entries.push(["category", schema.describe(uniqueCategories?.length ? `A broad grouping selected from: ${uniqueCategories.join(", ")}` : "A broad grouping such as \"docs\", \"guide\", or \"blog\"")]);
+		}
+		if (fieldSet.has("topic")) entries.push(["topic", z.string().describe("The primary subject the document is about")]);
+		if (fieldSet.has("audience")) entries.push(["audience", z.string().describe("The intended audience such as \"developers\" or \"beginners\"")]);
+		if (fieldSet.has("difficulty")) entries.push(["difficulty", z.enum([
+			"beginner",
+			"intermediate",
+			"advanced"
+		]).describe("The estimated skill level required to understand the document")]);
+		return z.object(Object.fromEntries(entries));
+	}
+	buildSEOSchema(fields) {
+		const fieldSet = new Set(fields);
+		const entries = [];
+		if (fieldSet.has("slug")) entries.push(["slug", z.string().describe("A URL-safe identifier for the document")]);
+		if (fieldSet.has("openGraph")) entries.push(["openGraph", z.object({
+			title: z.string().describe("The social sharing title"),
+			description: z.string().describe("The social sharing description"),
+			image: z.string().describe("The image URL for social sharing").nullable()
+		}).describe("Open Graph metadata")]);
+		return z.object(Object.fromEntries(entries));
+	}
+	computeWordCount() {
+		return this.writr.body.replace(/```[\s\S]*?```/g, "").replace(/`[^`]*`/g, "").replace(/[#*_[\]()>~|-]/g, " ").split(/\s+/).filter((word) => word.length > 0).length;
+	}
+	computeReadingTime() {
+		const wordCount = this.computeWordCount();
+		return Math.max(1, Math.ceil(wordCount / AVERAGE_WORDS_PER_MINUTE));
+	}
+	stripCodeFence(text) {
+		const trimmed = text.trim();
+		const match = /^```\w*\n([\s\S]*?)```$/.exec(trimmed);
+		return match ? match[1].trim() : text;
+	}
+};
+//#endregion
+//#region src/writr.ts
+var Writr = class extends Hookified {
+	engine;
+	_options = { renderOptions: {
+		emoji: true,
+		toc: true,
+		slug: true,
+		highlight: true,
+		gfm: true,
+		math: true,
+		mdx: false,
+		rawHtml: false,
+		caching: true
+	} };
+	_content = "";
+	_cache = new WritrCache();
+	_ai;
+	/**
+	* Initialize Writr. Accepts a string or options object.
+	* @param {string | WritrOptions} [arguments1] If you send in a string, it will be used as the markdown content. If you send in an object, it will be used as the options.
+	* @param {WritrOptions} [arguments2] This is if you send in the content in the first argument and also want to send in options.
+	*
+	* @example
+	* const writr = new Writr('Hello, world!', {caching: false});
+	*/
+	constructor(arguments1, arguments2) {
+		const options = typeof arguments1 === "object" ? arguments1 : arguments2;
+		super({
+			throwOnEmitError: options?.throwOnEmitError,
+			throwOnHookError: options?.throwOnHookError,
+			throwOnEmptyListeners: options?.throwOnEmptyListeners,
+			eventLogger: options?.eventLogger
+		});
+		if (typeof arguments1 === "string") this._content = arguments1;
+		else if (arguments1) this._options = this.mergeOptions(this._options, arguments1);
+		if (arguments2) this._options = this.mergeOptions(this._options, arguments2);
+		this.engine = this.createProcessor(this._options.renderOptions ?? {});
+		if (this._options.ai) this._ai = new WritrAI(this, this._options.ai);
+	}
+	/**
+	* Get the options.
+	* @type {WritrOptions}
+	*/
+	get options() {
+		return this._options;
+	}
+	/**
+	* Get the WritrAI instance if AI options were provided.
+	* @type {WritrAI | undefined}
+	*/
+	get ai() {
+		return this._ai;
+	}
+	/**
+	* Get the Content. This is the markdown content and front matter if it exists.
+	* @type {WritrOptions}
+	*/
+	get content() {
+		return this._content;
+	}
+	/**
+	* Set the Content. This is the markdown content and front matter if it exists.
+	* @type {WritrOptions}
+	*/
+	set content(value) {
+		this._content = value;
+	}
+	/**
+	* Get the cache.
+	* @type {WritrCache}
+	*/
+	get cache() {
+		return this._cache;
+	}
+	/**
+	* Get the front matter raw content.
+	* @type {string} The front matter content including the delimiters.
+	*/
+	get frontMatterRaw() {
+		if (!this._content.trimStart().startsWith("---")) return "";
+		const match = /^\s*(---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$))/.exec(this._content);
+		if (match) return match[1];
+		return "";
+	}
+	/**
+	* Get the body content without the front matter.
+	* @type {string} The markdown content without the front matter.
+	*/
+	get body() {
+		const frontMatter = this.frontMatterRaw;
+		if (frontMatter === "") return this._content;
+		return this._content.slice(this._content.indexOf(frontMatter) + frontMatter.length).trim();
+	}
+	/**
+	* Get the markdown content. This is an alias for the body property.
+	* @type {string} The markdown content.
+	*/
+	get markdown() {
+		return this.body;
+	}
+	/**
+	* Get the front matter content as an object.
+	* @type {Record<string, any>} The front matter content as an object.
+	*/
+	get frontMatter() {
+		const frontMatter = this.frontMatterRaw;
+		const match = /^---\s*([\s\S]*?)\s*---\s*/.exec(frontMatter);
+		if (match) try {
+			return yaml.load(match[1].trim());
+		} catch (error) {
+			/* v8 ignore next -- @preserve */
+			this.emit("error", error);
+		}
+		return {};
+	}
+	/**
+	* Set the front matter content as an object.
+	* @type {Record<string, any>} The front matter content as an object.
+	*/
+	set frontMatter(data) {
+		try {
+			const frontMatter = this.frontMatterRaw;
+			const newFrontMatter = `---\n${yaml.dump(data)}---\n`;
+			this._content = this._content.replace(frontMatter, newFrontMatter);
+		} catch (error) {
+			/* v8 ignore next -- @preserve */
+			this.emit("error", error);
+		}
+	}
+	/**
+	* Get the front matter value for a key.
+	* @param {string} key The key to get the value for.
+	* @returns {T} The value for the key.
+	*/
+	getFrontMatterValue(key) {
+		return this.frontMatter[key];
+	}
+	/**
+	* Render the markdown content to HTML.
+	* @param {RenderOptions} [options] The render options.
+	* @returns {Promise<string>} The rendered HTML content.
+	*/
+	async render(options) {
+		try {
+			let { engine } = this;
+			if (options) {
+				options = {
+					...this._options.renderOptions,
+					...options
+				};
+				engine = this.createProcessor(options);
+			}
+			const renderData = {
+				content: this._content,
+				body: this.body,
+				options
+			};
+			await this.hook("beforeRender", renderData);
+			const resultData = { result: "" };
+			if (this.isCacheEnabled(renderData.options)) {
+				const cached = this._cache.get(renderData.content, renderData.options);
+				if (cached) return cached;
+			}
+			const file = await engine.process(renderData.body);
+			resultData.result = String(file);
+			if (this.isCacheEnabled(renderData.options)) this._cache.set(renderData.content, resultData.result, renderData.options);
+			await this.hook("afterRender", resultData);
+			return resultData.result;
+		} catch (error) {
+			this.emit("error", error);
+		}
+		return "";
+	}
+	/**
+	* Render the markdown content to HTML synchronously.
+	* @param {RenderOptions} [options] The render options.
+	* @returns {string} The rendered HTML content.
+	*/
+	renderSync(options) {
+		try {
+			let { engine } = this;
+			if (options) {
+				options = {
+					...this._options.renderOptions,
+					...options
+				};
+				engine = this.createProcessor(options);
+			}
+			const renderData = {
+				content: this._content,
+				body: this.body,
+				options
+			};
+			this.hook("beforeRender", renderData);
+			const resultData = { result: "" };
+			/* v8 ignore next -- @preserve */
+			if (this.isCacheEnabled(renderData.options)) {
+				const cached = this._cache.get(renderData.content, renderData.options);
+				if (cached) return cached;
+			}
+			const file = engine.processSync(renderData.body);
+			resultData.result = String(file);
+			if (this.isCacheEnabled(renderData.options)) this._cache.set(renderData.content, resultData.result, renderData.options);
+			this.hook("afterRender", resultData);
+			return resultData.result;
+		} catch (error) {
+			this.emit("error", error);
+		}
+		return "";
+	}
+	/**
+	* Validate the markdown content by attempting to render it.
+	* @param {string} [content] The markdown content to validate. If not provided, uses the current content.
+	* @param {RenderOptions} [options] The render options.
+	* @returns {Promise<WritrValidateResult>} An object with a valid boolean and optional error.
+	*/
+	async validate(content, options) {
+		const originalContent = this._content;
+		try {
+			if (content !== void 0) this._content = content;
+			let { engine } = this;
+			if (options) {
+				options = {
+					...this._options.renderOptions,
+					...options,
+					caching: false
+				};
+				engine = this.createProcessor(options);
+			}
+			await engine.run(engine.parse(this.body));
+			if (content !== void 0) this._content = originalContent;
+			return { valid: true };
+		} catch (error) {
+			if (content !== void 0) this._content = originalContent;
+			return {
+				valid: false,
+				error
+			};
+		}
+	}
+	/**
+	* Validate the markdown content by attempting to render it synchronously.
+	* @param {string} [content] The markdown content to validate. If not provided, uses the current content.
+	* @param {RenderOptions} [options] The render options.
+	* @returns {WritrValidateResult} An object with a valid boolean and optional error.
+	*/
+	validateSync(content, options) {
+		const originalContent = this._content;
+		try {
+			if (content !== void 0) this._content = content;
+			let { engine } = this;
+			if (options) {
+				options = {
+					...this._options.renderOptions,
+					...options,
+					caching: false
+				};
+				engine = this.createProcessor(options);
+			}
+			engine.runSync(engine.parse(this.body));
+			if (content !== void 0) this._content = originalContent;
+			return { valid: true };
+		} catch (error) {
+			this.emit("error", error);
+			if (content !== void 0) this._content = originalContent;
+			return {
+				valid: false,
+				error
+			};
+		}
+	}
+	/**
+	* Render the markdown content and save it to a file. If the directory doesn't exist it will be created.
+	* @param {string} filePath The file path to save the rendered markdown content to.
+	* @param {RenderOptions} [options] the render options.
+	*/
+	async renderToFile(filePath, options) {
+		try {
+			const { writeFile, mkdir } = fs.promises;
+			const directoryPath = dirname(filePath);
+			const content = await this.render(options);
+			await mkdir(directoryPath, { recursive: true });
+			const data = {
+				filePath,
+				content
+			};
+			await this.hook("renderToFile", data);
+			await writeFile(data.filePath, data.content);
+		} catch (error) {
+			this.emit("error", error);
+		}
+	}
+	/**
+	* Render the markdown content and save it to a file synchronously. If the directory doesn't exist it will be created.
+	* @param {string} filePath The file path to save the rendered markdown content to.
+	* @param {RenderOptions} [options] the render options.
+	*/
+	renderToFileSync(filePath, options) {
+		try {
+			const directoryPath = dirname(filePath);
+			const content = this.renderSync(options);
+			fs.mkdirSync(directoryPath, { recursive: true });
+			const data = {
+				filePath,
+				content
+			};
+			this.hook("renderToFile", data);
+			fs.writeFileSync(data.filePath, data.content);
+		} catch (error) {
+			this.emit("error", error);
+		}
+	}
+	/**
+	* Render the markdown content to React.
+	* @param {RenderOptions} [options] The render options.
+	* @param {HTMLReactParserOptions} [reactParseOptions] The HTML React parser options.
+	* @returns {Promise<string | React.JSX.Element | React.JSX.Element[]>} The rendered React content.
+	*/
+	async renderReact(options, reactParseOptions) {
+		try {
+			return parse(await this.render(options), reactParseOptions);
+		} catch (error) {
+			this.emit("error", error);
+		}
+		return "";
+	}
+	/**
+	* Render the markdown content to React synchronously.
+	* @param {RenderOptions} [options] The render options.
+	* @param {HTMLReactParserOptions} [reactParseOptions] The HTML React parser options.
+	* @returns {string | React.JSX.Element | React.JSX.Element[]} The rendered React content.
+	*/
+	renderReactSync(options, reactParseOptions) {
+		try {
+			return parse(this.renderSync(options), reactParseOptions);
+		} catch (error) {
+			this.emit("error", error);
+		}
+		return "";
+	}
+	/**
+	* Load markdown content from a file.
+	* @param {string} filePath The file path to load the markdown content from.
+	* @returns {Promise<void>}
+	*/
+	async loadFromFile(filePath) {
+		try {
+			const { readFile } = fs.promises;
+			const data = { content: "" };
+			data.content = await readFile(filePath, "utf8");
+			await this.hook("loadFromFile", data);
+			this._content = data.content;
+		} catch (error) {
+			this.emit("error", error);
+		}
+	}
+	/**
+	* Load markdown content from a file synchronously.
+	* @param {string} filePath The file path to load the markdown content from.
+	* @returns {void}
+	*/
+	loadFromFileSync(filePath) {
+		try {
+			const data = { content: "" };
+			data.content = fs.readFileSync(filePath, "utf8");
+			this.hook("loadFromFile", data);
+			this._content = data.content;
+		} catch (error) {
+			this.emit("error", error);
+		}
+	}
+	/**
+	* Save the markdown content to a file. If the directory doesn't exist it will be created.
+	* @param {string} filePath The file path to save the markdown content to.
+	* @returns {Promise<void>}
+	*/
+	async saveToFile(filePath) {
+		try {
+			const { writeFile, mkdir } = fs.promises;
+			await mkdir(dirname(filePath), { recursive: true });
+			const data = {
+				filePath,
+				content: this._content
+			};
+			await this.hook("saveToFile", data);
+			await writeFile(data.filePath, data.content);
+		} catch (error) {
+			this.emit("error", error);
+		}
+	}
+	/**
+	* Save the markdown content to a file synchronously. If the directory doesn't exist it will be created.
+	* @param {string} filePath The file path to save the markdown content to.
+	* @returns {void}
+	*/
+	saveToFileSync(filePath) {
+		try {
+			const directoryPath = dirname(filePath);
+			fs.mkdirSync(directoryPath, { recursive: true });
+			const data = {
+				filePath,
+				content: this._content
+			};
+			this.hook("saveToFile", data);
+			fs.writeFileSync(data.filePath, data.content);
+		} catch (error) {
+			this.emit("error", error);
+		}
+	}
+	mergeOptions(current, options) {
+		if (options.throwOnEmitError !== void 0) this.throwOnEmitError = options.throwOnEmitError;
+		/* v8 ignore next -- @preserve */
+		if (options.renderOptions) {
+			current.renderOptions ??= {};
+			this.mergeRenderOptions(current.renderOptions, options.renderOptions);
+		}
+		if (options.ai) current.ai = options.ai;
+		return current;
+	}
+	isCacheEnabled(options) {
+		if (options?.caching !== void 0) return options.caching;
+		/* v8 ignore next -- @preserve */
+		return this._options?.renderOptions?.caching ?? false;
+	}
+	createProcessor(options) {
+		const processor = unified().use(remarkParse);
+		if (options.gfm) {
+			processor.use(remarkGfm);
+			processor.use(remarkGithubBlockquoteAlert);
+		}
+		if (options.toc) processor.use(remarkToc);
+		if (options.emoji) processor.use(remarkEmoji);
+		if (options.mdx) processor.use(remarkMDX);
+		if (options.math) processor.use(remarkMath);
+		const rehypeOptions = {};
+		if (options.rawHtml) rehypeOptions.allowDangerousHtml = true;
+		if (options.mdx) rehypeOptions.handlers = {
+			mdxJsxFlowElement: mdxJsxHandler,
+			mdxJsxTextElement: mdxJsxHandler
+		};
+		processor.use(remarkRehype, rehypeOptions);
+		if (options.rawHtml) processor.use(rehypeRaw);
+		if (options.slug) processor.use(rehypeSlug);
+		if (options.highlight) processor.use(rehypeHighlight);
+		if (options.math) processor.use(rehypeKatex);
+		processor.use(rehypeStringify);
+		return processor;
+	}
+	mergeRenderOptions(current, options) {
+		if (options.emoji !== void 0) current.emoji = options.emoji;
+		if (options.toc !== void 0) current.toc = options.toc;
+		if (options.slug !== void 0) current.slug = options.slug;
+		if (options.highlight !== void 0) current.highlight = options.highlight;
+		if (options.gfm !== void 0) current.gfm = options.gfm;
+		if (options.math !== void 0) current.math = options.math;
+		if (options.mdx !== void 0) current.mdx = options.mdx;
+		if (options.rawHtml !== void 0) current.rawHtml = options.rawHtml;
+		if (options.caching !== void 0) current.caching = options.caching;
+		return current;
+	}
+};
+function mdxJsxHandler(state, node) {
+	const properties = {};
+	for (const attr of node.attributes) if (attr.type === "mdxJsxAttribute") {
+		if (attr.value === null) properties[attr.name] = true;
+		else if (typeof attr.value === "string") properties[attr.name] = attr.value;
+	}
+	return {
+		type: "element",
+		tagName: node.name ?? "div",
+		properties,
+		children: state.all(node)
+	};
+}
+//#endregion
+export { Writr, WritrAI, WritrAICache, WritrHooks };