@ox-content/unplugin 2.9.0 → 2.10.0

package/dist/src.mjs

@@ -1,48 +1,824 @@
+import { createRequire } from "node:module";
 import { createUnplugin } from "unplugin";
 import { createFilter } from "@rollup/pluginutils";
+import MarkdownIt from "markdown-it";
+import rehypeParse from "rehype-parse";
+import rehypeRemark from "rehype-remark";
+import rehypeStringify from "rehype-stringify";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { unified } from "unified";
+const utf8Decoder = new TextDecoder("utf-8");
+function parseTransferEnvelope(buffer) {
+	if (buffer.byteLength < 24) return null;
+	const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+	if (view.getUint32(0, true) !== 1381259343) return null;
+	if (view.getUint16(4, true) !== 1) throw new Error("[ox-content] Unsupported transfer buffer version.");
+	const kind = view.getUint16(6, true);
+	const payloadVersion = view.getUint32(8, true);
+	const sectionCount = view.getUint32(12, true);
+	const rootHandle = view.getUint32(16, true);
+	if (24 + sectionCount * 12 > buffer.byteLength) throw new Error("[ox-content] Transfer buffer section table is truncated.");
+	const sections = /* @__PURE__ */ new Map();
+	for (let index = 0; index < sectionCount; index += 1) {
+		const base = 24 + index * 12;
+		const id = view.getUint32(base, true);
+		const offset = view.getUint32(base + 4, true);
+		const len = view.getUint32(base + 8, true);
+		if (offset + len > buffer.byteLength) throw new Error("[ox-content] Transfer buffer references an invalid section.");
+		sections.set(id, {
+			id,
+			offset,
+			len
+		});
+	}
+	return {
+		kind,
+		payloadVersion,
+		rootHandle,
+		sections
+	};
+}
+function requireTransferSection(envelope, id, message) {
+	const section = envelope.sections.get(id);
+	if (!section) throw new Error(message);
+	return section;
+}
+function sliceTransferSection(buffer, section) {
+	return buffer.subarray(section.offset, section.offset + section.len);
+}
+function decodeTransferSectionUtf8(buffer, envelope, id, message) {
+	return utf8Decoder.decode(sliceTransferSection(buffer, requireTransferSection(envelope, id, message)));
+}
+//#endregion
+//#region src/mdast-raw.ts
+const LEGACY_MAGIC = 827475021;
+const LEGACY_VERSION = 1;
+const LEGACY_HEADER_LEN = 28;
+const NODE_RECORD_LEN = 60;
+const NONE_U32 = 4294967295;
+const MDAST_PAYLOAD_VERSION = 1;
+const MDAST_SECTION_NODES = 1;
+const MDAST_SECTION_CHILD_INDICES = 2;
+const MDAST_SECTION_ALIGNS = 3;
+const MDAST_SECTION_STRINGS = 4;
+const MDAST_SECTION_SOURCE_ORIGIN$1 = 7;
+const KIND_ROOT = 0;
+const KIND_PARAGRAPH = 1;
+const KIND_HEADING = 2;
+const KIND_THEMATIC_BREAK = 3;
+const KIND_BLOCKQUOTE = 4;
+const KIND_LIST = 5;
+const KIND_LIST_ITEM = 6;
+const KIND_CODE = 7;
+const KIND_HTML = 8;
+const KIND_TABLE = 9;
+const KIND_TABLE_ROW = 10;
+const KIND_TABLE_CELL = 11;
+const KIND_TEXT = 12;
+const KIND_EMPHASIS = 13;
+const KIND_STRONG = 14;
+const KIND_INLINE_CODE = 15;
+const KIND_BREAK = 16;
+const KIND_LINK = 17;
+const KIND_IMAGE = 18;
+const KIND_DELETE = 19;
+const KIND_FOOTNOTE_REFERENCE = 20;
+const KIND_DEFINITION = 21;
+const KIND_FOOTNOTE_DEFINITION = 22;
+const FLAG_ORDERED = 1;
+const FLAG_SPREAD = 2;
+const FLAG_CHECKED_PRESENT = 4;
+const FLAG_CHECKED_VALUE = 8;
+function deserializeMdastFromRaw(buffer, source) {
+	const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+	const decoder = new TextDecoder("utf-8");
+	const { nodeCount, childCount, alignCount, rootIndex, nodesOffset, childIndicesOffset, alignsOffset, stringsOffset, stringsEnd } = resolveMdastLayout(buffer, view);
+	if (stringsEnd > buffer.byteLength) throw new Error("[ox-content] mdast raw transfer buffer is truncated.");
+	const sourceIndex = buildSourceIndex(source);
+	const sourceOrigin = readSourceOrigin(buffer, view);
+	const readString = (offset, len) => {
+		if (offset === NONE_U32) return;
+		const start = stringsOffset + offset;
+		const end = start + len;
+		if (end > stringsEnd) throw new Error("[ox-content] mdast raw transfer buffer references an invalid string.");
+		return decoder.decode(buffer.subarray(start, end));
+	};
+	const readPosition = (startOffset, endOffset) => {
+		const start = pointForByteOffset(startOffset, sourceIndex);
+		const end = pointForByteOffset(endOffset, sourceIndex);
+		if (!sourceOrigin) return {
+			start,
+			end
+		};
+		return {
+			start: applySourceOrigin(start, sourceOrigin),
+			end: applySourceOrigin(end, sourceOrigin)
+		};
+	};
+	const readChildIndex = (index) => {
+		if (index >= childCount) throw new Error("[ox-content] mdast raw transfer buffer references an invalid child index.");
+		return view.getUint32(childIndicesOffset + index * 4, true);
+	};
+	const readChildren = (start, len) => {
+		if (start + len > childCount) throw new Error("[ox-content] mdast raw transfer buffer has an invalid child range.");
+		const children = [];
+		for (let index = 0; index < len; index += 1) children.push(readNode(readChildIndex(start + index)));
+		return children;
+	};
+	const readAlign = (start, len) => {
+		if (start + len > alignCount) throw new Error("[ox-content] mdast raw transfer buffer has an invalid table alignment range.");
+		const align = [];
+		for (let index = 0; index < len; index += 1) {
+			const value = buffer[alignsOffset + start + index];
+			align.push(value === 1 ? "left" : value === 2 ? "center" : value === 3 ? "right" : null);
+		}
+		return align;
+	};
+	const readNode = (index) => {
+		if (index >= nodeCount) throw new Error("[ox-content] mdast raw transfer buffer references an invalid node.");
+		const base = nodesOffset + index * NODE_RECORD_LEN;
+		const kind = view.getUint8(base);
+		const flags = view.getUint8(base + 1);
+		const spanStart = view.getUint32(base + 4, true);
+		const spanEnd = view.getUint32(base + 8, true);
+		const childStart = view.getUint32(base + 12, true);
+		const childLen = view.getUint32(base + 16, true);
+		const num0 = view.getUint32(base + 20, true);
+		const num1 = view.getUint32(base + 24, true);
+		const str0 = readString(view.getUint32(base + 28, true), view.getUint32(base + 32, true));
+		const str1 = readString(view.getUint32(base + 36, true), view.getUint32(base + 40, true));
+		const str2 = readString(view.getUint32(base + 44, true), view.getUint32(base + 48, true));
+		const str3 = readString(view.getUint32(base + 52, true), view.getUint32(base + 56, true));
+		const children = childLen > 0 ? readChildren(childStart, childLen) : void 0;
+		const position = readPosition(spanStart, spanEnd);
+		switch (kind) {
+			case KIND_ROOT: return {
+				type: "root",
+				children: children ?? [],
+				position
+			};
+			case KIND_PARAGRAPH: return {
+				type: "paragraph",
+				children: children ?? [],
+				position
+			};
+			case KIND_HEADING: return {
+				type: "heading",
+				depth: num0,
+				children: children ?? [],
+				position
+			};
+			case KIND_THEMATIC_BREAK: return {
+				type: "thematicBreak",
+				position
+			};
+			case KIND_BLOCKQUOTE: return {
+				type: "blockquote",
+				children: children ?? [],
+				position
+			};
+			case KIND_LIST: {
+				const node = {
+					type: "list",
+					ordered: (flags & FLAG_ORDERED) !== 0,
+					spread: (flags & FLAG_SPREAD) !== 0,
+					children: children ?? [],
+					position
+				};
+				if (num0 !== NONE_U32) node.start = num0;
+				return node;
+			}
+			case KIND_LIST_ITEM: {
+				const node = {
+					type: "listItem",
+					spread: (flags & FLAG_SPREAD) !== 0,
+					children: children ?? [],
+					position
+				};
+				if ((flags & FLAG_CHECKED_PRESENT) !== 0) node.checked = (flags & FLAG_CHECKED_VALUE) !== 0;
+				return node;
+			}
+			case KIND_CODE: {
+				const node = {
+					type: "code",
+					value: str2 ?? "",
+					position
+				};
+				if (str0 !== void 0) node.lang = str0;
+				if (str1 !== void 0) node.meta = str1;
+				return node;
+			}
+			case KIND_HTML: return {
+				type: "html",
+				value: str0 ?? "",
+				position
+			};
+			case KIND_TABLE: return {
+				type: "table",
+				align: readAlign(num0, num1),
+				children: children ?? [],
+				position
+			};
+			case KIND_TABLE_ROW: return {
+				type: "tableRow",
+				children: children ?? [],
+				position
+			};
+			case KIND_TABLE_CELL: return {
+				type: "tableCell",
+				children: children ?? [],
+				position
+			};
+			case KIND_TEXT: return {
+				type: "text",
+				value: str0 ?? "",
+				position
+			};
+			case KIND_EMPHASIS: return {
+				type: "emphasis",
+				children: children ?? [],
+				position
+			};
+			case KIND_STRONG: return {
+				type: "strong",
+				children: children ?? [],
+				position
+			};
+			case KIND_INLINE_CODE: return {
+				type: "inlineCode",
+				value: str0 ?? "",
+				position
+			};
+			case KIND_BREAK: return {
+				type: "break",
+				position
+			};
+			case KIND_LINK: {
+				const node = {
+					type: "link",
+					url: str0 ?? "",
+					children: children ?? [],
+					position
+				};
+				if (str1 !== void 0) node.title = str1;
+				return node;
+			}
+			case KIND_IMAGE: {
+				const node = {
+					type: "image",
+					url: str0 ?? "",
+					position
+				};
+				if (str1 !== void 0) node.alt = str1;
+				if (str2 !== void 0) node.title = str2;
+				return node;
+			}
+			case KIND_DELETE: return {
+				type: "delete",
+				children: children ?? [],
+				position
+			};
+			case KIND_FOOTNOTE_REFERENCE: {
+				const node = {
+					type: "footnoteReference",
+					identifier: str0 ?? "",
+					position
+				};
+				if (str1 !== void 0) node.label = str1;
+				return node;
+			}
+			case KIND_DEFINITION: {
+				const node = {
+					type: "definition",
+					identifier: str0 ?? "",
+					url: str2 ?? "",
+					position
+				};
+				if (str1 !== void 0) node.label = str1;
+				if (str3 !== void 0) node.title = str3;
+				return node;
+			}
+			case KIND_FOOTNOTE_DEFINITION: {
+				const node = {
+					type: "footnoteDefinition",
+					identifier: str0 ?? "",
+					children: children ?? [],
+					position
+				};
+				if (str1 !== void 0) node.label = str1;
+				return node;
+			}
+			default: throw new Error(`[ox-content] Unsupported mdast raw node kind: ${kind}`);
+		}
+	};
+	const root = readNode(rootIndex);
+	if (root.type !== "root" || !Array.isArray(root.children)) throw new Error("[ox-content] Native parser returned an invalid mdast root.");
+	return root;
+}
+function readSourceOrigin(buffer, view) {
+	const section = parseTransferEnvelope(buffer)?.sections.get(MDAST_SECTION_SOURCE_ORIGIN$1);
+	if (!section) return;
+	if (section.len !== 16) throw new Error("[ox-content] mdast transfer source origin section is misaligned.");
+	return {
+		byteOffset: view.getUint32(section.offset, true),
+		offset: view.getUint32(section.offset + 4, true),
+		line: view.getUint32(section.offset + 8, true),
+		column: view.getUint32(section.offset + 12, true)
+	};
+}
+function resolveMdastLayout(buffer, view) {
+	const envelope = parseTransferEnvelope(buffer);
+	if (envelope) {
+		if (envelope.kind !== 1) throw new Error("[ox-content] Transfer buffer does not contain an mdast payload.");
+		if (envelope.payloadVersion !== MDAST_PAYLOAD_VERSION) throw new Error("[ox-content] Unsupported mdast transfer payload version.");
+		const nodesSection = requireTransferSection(envelope, MDAST_SECTION_NODES, "[ox-content] mdast transfer is missing the nodes section.");
+		const childIndicesSection = requireTransferSection(envelope, MDAST_SECTION_CHILD_INDICES, "[ox-content] mdast transfer is missing the child indices section.");
+		const alignsSection = requireTransferSection(envelope, MDAST_SECTION_ALIGNS, "[ox-content] mdast transfer is missing the table alignments section.");
+		const stringsSection = requireTransferSection(envelope, MDAST_SECTION_STRINGS, "[ox-content] mdast transfer is missing the string table section.");
+		if (nodesSection.len % NODE_RECORD_LEN !== 0) throw new Error("[ox-content] mdast transfer nodes section is misaligned.");
+		if (childIndicesSection.len % 4 !== 0) throw new Error("[ox-content] mdast transfer child indices section is misaligned.");
+		return {
+			nodeCount: nodesSection.len / NODE_RECORD_LEN,
+			childCount: childIndicesSection.len / 4,
+			alignCount: alignsSection.len,
+			rootIndex: envelope.rootHandle,
+			nodesOffset: nodesSection.offset,
+			childIndicesOffset: childIndicesSection.offset,
+			alignsOffset: alignsSection.offset,
+			stringsOffset: stringsSection.offset,
+			stringsEnd: stringsSection.offset + stringsSection.len
+		};
+	}
+	const magic = view.getUint32(0, true);
+	const version = view.getUint32(4, true);
+	if (magic !== LEGACY_MAGIC || version !== LEGACY_VERSION) throw new Error("[ox-content] Invalid mdast raw transfer buffer.");
+	const nodeCount = view.getUint32(8, true);
+	const childCount = view.getUint32(12, true);
+	const alignCount = view.getUint32(16, true);
+	const stringBytesLen = view.getUint32(20, true);
+	const rootIndex = view.getUint32(24, true);
+	const nodesOffset = LEGACY_HEADER_LEN;
+	const childIndicesOffset = nodesOffset + nodeCount * NODE_RECORD_LEN;
+	const alignsOffset = childIndicesOffset + childCount * 4;
+	const stringsOffset = alignsOffset + alignCount;
+	return {
+		nodeCount,
+		childCount,
+		alignCount,
+		rootIndex,
+		nodesOffset,
+		childIndicesOffset,
+		alignsOffset,
+		stringsOffset,
+		stringsEnd: stringsOffset + stringBytesLen
+	};
+}
+function buildSourceIndex(source) {
+	const points = [{
+		byteOffset: 0,
+		offset: 0,
+		line: 1,
+		column: 1
+	}];
+	let byteOffset = 0;
+	let offset = 0;
+	let line = 1;
+	let column = 1;
+	for (const character of source) {
+		byteOffset += utf8ByteLength(character);
+		offset += character.length;
+		if (character === "\n") {
+			line += 1;
+			column = 1;
+		} else column += 1;
+		points.push({
+			byteOffset,
+			offset,
+			line,
+			column
+		});
+	}
+	return points;
+}
+function pointForByteOffset(byteOffset, points) {
+	const maxByteOffset = points[points.length - 1]?.byteOffset ?? 0;
+	const clampedOffset = Math.max(0, Math.min(byteOffset, maxByteOffset));
+	let low = 0;
+	let high = points.length - 1;
+	while (low <= high) {
+		const middle = low + high >> 1;
+		const point = points[middle];
+		const nextPoint = points[middle + 1];
+		if (clampedOffset < point.byteOffset) high = middle - 1;
+		else if (nextPoint && clampedOffset >= nextPoint.byteOffset) low = middle + 1;
+		else return {
+			line: point.line,
+			column: point.column,
+			offset: point.offset
+		};
+	}
+	const point = points[points.length - 1] ?? {
+		byteOffset: 0,
+		offset: 0,
+		line: 1,
+		column: 1
+	};
+	return {
+		line: point.line,
+		column: point.column,
+		offset: point.offset
+	};
+}
+function applySourceOrigin(point, origin) {
+	return {
+		line: point.line + origin.line - 1,
+		column: point.line === 1 ? point.column + origin.column - 1 : point.column,
+		offset: point.offset + origin.offset
+	};
+}
+function utf8ByteLength(character) {
+	const codePoint = character.codePointAt(0);
+	if (codePoint === void 0) return 0;
+	if (codePoint <= 127) return 1;
+	if (codePoint <= 2047) return 2;
+	if (codePoint <= 65535) return 3;
+	return 4;
+}
+//#endregion
+//#region src/mdast.ts
+const require$1 = createRequire(import.meta.url);
+let cachedNapiBindings$1;
+const DEFAULT_MDAST_OPTIONS = {
+	gfm: true,
+	footnotes: true,
+	taskLists: true,
+	tables: true,
+	strikethrough: true,
+	autolinks: true
+};
+/**
+* Unified parser plugin backed by Ox Content's native mdast parser.
+*
+* This lets existing remark/unified plugins run on top of Ox Content's parser
+* while keeping a more mdast-native integration point.
+*/
+function oxContentMdast(options = {}) {
+	this.parser = (document) => parseMarkdownToMdast(document, options);
+}
+/**
+* Defines an Ox Content-native mdast plugin.
+*/
+function defineMdastPlugin(name, transform) {
+	return {
+		name,
+		transform
+	};
+}
+/**
+* Parses markdown source into an mdast-compatible tree using the native parser.
+*/
+function parseMarkdownToMdast(source, options = {}) {
+	const napi = loadNapiBindings$1();
+	const resolvedOptions = resolveMdastOptions(options);
+	const parserOptions = {
+		gfm: resolvedOptions.gfm,
+		footnotes: resolvedOptions.footnotes,
+		taskLists: resolvedOptions.taskLists,
+		tables: resolvedOptions.tables,
+		strikethrough: resolvedOptions.strikethrough,
+		autolinks: resolvedOptions.autolinks
+	};
+	return deserializeMdastFromRaw(requireNapiMethod$1(napi.parseTransferRaw, "parseTransferRaw")(source, "mdast", parserOptions), source);
+}
+/**
+* Wraps an Ox Content-native mdast plugin as a standard unified transformer.
+*/
+function toUnifiedMdastPlugin(plugin, context) {
+	return () => {
+		return async (tree) => {
+			return await plugin.transform(tree, context) ?? tree;
+		};
+	};
+}
+/**
+* Extracts a nested TOC tree from mdast after mdast-stage plugins have run.
+*/
+function extractTocFromMdast(root, maxDepth) {
+	const headings = [];
+	visitMdast(root, (node) => {
+		if (node.type !== "heading") return;
+		const depth = typeof node.depth === "number" ? node.depth : 0;
+		if (depth < 1 || depth > maxDepth) return;
+		const text = collectMdastText(node);
+		headings.push({
+			depth,
+			text,
+			slug: slugify$1(text),
+			children: []
+		});
+	});
+	return buildTocTree$1(headings);
+}
+/**
+* Creates the context passed to Ox Content-native mdast plugins.
+*/
+function createMdastPluginContext(filePath, source, frontmatter, options, sourceOffset) {
+	return {
+		filePath,
+		source,
+		frontmatter,
+		sourceOffset,
+		options
+	};
+}
+function loadNapiBindings$1() {
+	if (cachedNapiBindings$1) return cachedNapiBindings$1;
+	if (cachedNapiBindings$1 === null) throw new Error("[ox-content] Failed to load @ox-content/napi. Please ensure the NAPI module is built. Run: mise run build:napi");
+	try {
+		cachedNapiBindings$1 = require$1("@ox-content/napi");
+		return cachedNapiBindings$1;
+	} catch {
+		cachedNapiBindings$1 = null;
+		throw new Error("[ox-content] Failed to load @ox-content/napi. Please ensure the NAPI module is built. Run: mise run build:napi");
+	}
+}
+function requireNapiMethod$1(method, name) {
+	if (typeof method === "function") return method;
+	throw new Error(`[ox-content] @ox-content/napi is too old for mdast interop: missing ${name}(). Rebuild the NAPI module with \`vp run build:napi\`.`);
+}
+function resolveMdastOptions(options) {
+	return {
+		gfm: options.gfm ?? DEFAULT_MDAST_OPTIONS.gfm,
+		footnotes: options.footnotes ?? DEFAULT_MDAST_OPTIONS.footnotes,
+		taskLists: options.taskLists ?? DEFAULT_MDAST_OPTIONS.taskLists,
+		tables: options.tables ?? DEFAULT_MDAST_OPTIONS.tables,
+		strikethrough: options.strikethrough ?? DEFAULT_MDAST_OPTIONS.strikethrough,
+		autolinks: options.autolinks ?? DEFAULT_MDAST_OPTIONS.autolinks
+	};
+}
+function buildTocTree$1(entries) {
+	const result = [];
+	const stack = [];
+	for (const entry of entries) {
+		const tocEntry = {
+			depth: entry.depth,
+			text: entry.text,
+			slug: entry.slug,
+			children: []
+		};
+		while (stack.length > 0 && stack[stack.length - 1].depth >= entry.depth) stack.pop();
+		if (stack.length === 0) result.push(tocEntry);
+		else stack[stack.length - 1].children.push(tocEntry);
+		stack.push(tocEntry);
+	}
+	return result;
+}
+function visitMdast(node, visitor) {
+	if (!node || typeof node !== "object") return;
+	if ("type" in node && typeof node.type === "string") visitor(node);
+	if (!Array.isArray(node.children)) return;
+	for (const child of node.children) visitMdast(child, visitor);
+}
+function collectMdastText(node) {
+	if (!node || typeof node !== "object") return "";
+	if (typeof node.value === "string") return node.value;
+	if (!Array.isArray(node.children)) return "";
+	return node.children.map((child) => collectMdastText(child)).join("");
+}
+function slugify$1(text) {
+	return text.toLowerCase().replace(/[^\p{L}\p{N}\s-]+/gu, " ").trim().split(/\s+/).filter(Boolean).join("-");
+}
+//#endregion
 //#region src/transform.ts
 /**
+* Markdown transformation logic for @ox-content/unplugin.
+*
+* Uses Rust-based parser via NAPI bindings for optimal performance.
+*/
+const require = createRequire(import.meta.url);
+let cachedNapiBindings;
+const MDAST_SECTION_CONTENT = 5;
+const MDAST_SECTION_FRONTMATTER = 6;
+const MDAST_SECTION_SOURCE_ORIGIN = 7;
+const PREPARED_SOURCE_SECTION_CONTENT = 1;
+const PREPARED_SOURCE_SECTION_FRONTMATTER = 2;
+const PREPARED_SOURCE_SECTION_SOURCE_ORIGIN = 3;
+/**
 * Transforms Markdown content into a JavaScript module.
-* Uses Rust-based renderer via NAPI bindings for optimal performance.
+* Uses Rust-based parsing, and switches to a unified/mdast pipeline when
+* JavaScript mdast/remark/rehype plugins are configured.
 *
 * Note: This requires the @ox-content/napi package to be built.
-* NAPI bindings are loaded dynamically to support both Node.js and build-time execution.
 */
 async function transformMarkdown(source, filePath, options) {
-	let napi;
+	const transformed = hasMarkdownItPlugins(options) ? await transformWithMarkdownIt(source, filePath, options) : hasUnifiedPlugins(options) ? await transformWithUnified(source, filePath, options) : transformWithNativePipeline(loadNapiBindings(), source, options);
+	let nextHtml = transformed.html;
+	for (const plugin of options.plugin.oxContent) nextHtml = await plugin(nextHtml);
+	return {
+		code: generateModuleCode(nextHtml, transformed.frontmatter, transformed.toc, filePath),
+		html: nextHtml,
+		frontmatter: transformed.frontmatter,
+		toc: transformed.toc
+	};
+}
+function loadNapiBindings() {
+	if (cachedNapiBindings) return cachedNapiBindings;
+	if (cachedNapiBindings === null) throw new Error("[ox-content] Failed to load @ox-content/napi. Please ensure the NAPI module is built. Run: nix develop -c vp run build:napi");
 	try {
-		napi = await import("@ox-content/napi");
+		cachedNapiBindings = require("@ox-content/napi");
+		return cachedNapiBindings;
 	} catch {
-		throw new Error("[ox-content] Failed to load @ox-content/napi. Please ensure the NAPI module is built. Run: nix develop -c vp run build:napi");
+		cachedNapiBindings = null;
+		throw new Error("[ox-content] Failed to load @ox-content/napi. Please ensure the NAPI module is built. Run: mise run build:napi");
 	}
-	const result = napi.transform(source, {
+}
+function createNapiTransformOptions(options) {
+	const codeAnnotations = options.codeAnnotations ?? {
+		enabled: false,
+		metaKey: "annotate"
+	};
+	return {
 		gfm: options.gfm,
 		footnotes: options.footnotes,
-		task_lists: options.taskLists,
+		taskLists: options.taskLists,
 		tables: options.tables,
 		strikethrough: options.strikethrough,
-		toc_max_depth: options.tocMaxDepth,
-		code_annotations: options.codeAnnotations.enabled,
-		code_annotation_meta_key: options.codeAnnotations.metaKey
-	});
-	if (result.errors.length > 0) console.warn("[ox-content] Transform warnings:", result.errors);
-	let frontmatter;
+		autolinks: options.gfm,
+		frontmatter: options.frontmatter,
+		tocMaxDepth: options.tocMaxDepth,
+		codeAnnotations: codeAnnotations.enabled,
+		codeAnnotationMetaKey: codeAnnotations.metaKey
+	};
+}
+function parseFrontmatterJson(json) {
+	if (json.length === 0) return {};
 	try {
-		frontmatter = JSON.parse(result.frontmatter);
+		const value = JSON.parse(json);
+		return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 	} catch {
-		frontmatter = {};
+		return {};
 	}
+}
+function prepareSourceWithRust(napi, source, options) {
+	return deserializePreparedSource(requireNapiMethod(napi.prepareSourceRaw, "prepareSourceRaw")(source, { frontmatter: options.frontmatter }));
+}
+function hasUnifiedPlugins(options) {
+	return options.plugin.mdast.length > 0 || options.plugin.remark.length > 0 || options.plugin.rehype.length > 0;
+}
+function hasMarkdownItPlugins(options) {
+	return options.plugin.markdownIt.length > 0;
+}
+function hasMdastOrRemarkPlugins(options) {
+	return options.plugin.mdast.length > 0 || options.plugin.remark.length > 0;
+}
+function transformWithNativePipeline(napi, source, options) {
+	const result = napi.transform(source, createNapiTransformOptions(options));
+	if (result.errors.length > 0) console.warn("[ox-content] Transform warnings:", result.errors);
 	const flatToc = result.toc.map((item) => ({
 		...item,
 		children: []
 	}));
-	const toc = options.toc ? buildTocTree(flatToc) : [];
-	let html = result.html;
-	for (const plugin of options.plugin.oxContent) html = await plugin(html);
 	return {
-		code: generateModuleCode(html, frontmatter, toc, filePath),
+		html: result.html,
+		frontmatter: parseFrontmatterJson(result.frontmatter),
+		toc: options.toc ? buildTocTree(flatToc) : []
+	};
+}
+function transformWithNativeMdastPipeline(napi, source, options) {
+	return deserializeNativeMdastTransform(requireNapiMethod(napi.transformMdastRaw, "transformMdastRaw")(source, createNapiTransformOptions(options)));
+}
+function deserializeNativeMdastTransform(buffer) {
+	const envelope = parseTransferEnvelope(buffer);
+	if (!envelope) throw new Error("[ox-content] Native mdast transform buffer is not a transfer envelope.");
+	const content = decodeTransferSectionUtf8(buffer, envelope, MDAST_SECTION_CONTENT, "[ox-content] mdast transform transfer is missing the content section.");
+	const frontmatter = parseFrontmatterJson(decodeTransferSectionUtf8(buffer, envelope, MDAST_SECTION_FRONTMATTER, "[ox-content] mdast transform transfer is missing the frontmatter section."));
+	return {
+		tree: deserializeMdastFromRaw(buffer, content),
+		content,
+		frontmatter,
+		sourceOffset: readSourceOriginFromEnvelope(buffer, envelope, MDAST_SECTION_SOURCE_ORIGIN)
+	};
+}
+function deserializePreparedSource(buffer) {
+	const envelope = parseTransferEnvelope(buffer);
+	if (!envelope || envelope.kind !== 3) throw new Error("[ox-content] Prepared source buffer is not a transfer envelope.");
+	return {
+		content: decodeTransferSectionUtf8(buffer, envelope, PREPARED_SOURCE_SECTION_CONTENT, "[ox-content] prepared source transfer is missing the content section."),
+		frontmatter: parseFrontmatterJson(decodeTransferSectionUtf8(buffer, envelope, PREPARED_SOURCE_SECTION_FRONTMATTER, "[ox-content] prepared source transfer is missing the frontmatter section.")),
+		sourceOffset: readSourceOriginFromEnvelope(buffer, envelope, PREPARED_SOURCE_SECTION_SOURCE_ORIGIN)
+	};
+}
+async function transformWithMarkdownIt(fullSource, filePath, options) {
+	const { content: markdownContent, frontmatter, sourceOffset } = prepareSourceWithRust(loadNapiBindings(), fullSource, options);
+	const markdownIt = createMarkdownItRenderer(options);
+	applyMarkdownItPlugins(markdownIt, options.plugin.markdownIt);
+	const env = createMarkdownItEnv(filePath, fullSource, markdownContent, frontmatter, sourceOffset);
+	const tokens = markdownIt.parse(markdownContent, env);
+	const html = markdownIt.renderer.render(tokens, markdownIt.options, env);
+	const bridgeData = {
+		html,
+		tokens,
+		env
+	};
+	if (hasMdastOrRemarkPlugins(options)) return transformMarkdownItWithUnified(bridgeData, fullSource, markdownContent, filePath, frontmatter, options);
+	if (options.plugin.rehype.length > 0) return {
+		html: await transformHtmlWithRehype(html, filePath, fullSource, markdownContent, frontmatter, options, "markdown-it", bridgeData),
+		frontmatter,
+		toc: options.toc ? extractTocFromMarkdownItTokens(tokens, options.tocMaxDepth) : []
+	};
+	return {
 		html,
 		frontmatter,
+		toc: options.toc ? extractTocFromMarkdownItTokens(tokens, options.tocMaxDepth) : []
+	};
+}
+async function transformMarkdownItWithUnified(markdownIt, fullSource, markdownContent, filePath, frontmatter, options) {
+	const mdastContext = createMdastPluginContext(filePath, fullSource, frontmatter, options, markdownIt.env.oxContent.sourceOffset);
+	const { plugins: remarkPlugins, options: remarkRehypeOptions } = extractUnifiedPluginWithOptions(options.plugin.remark, remarkRehype);
+	const { plugins: rehypePlugins, options: rehypeStringifyOptions } = extractUnifiedPluginWithOptions(options.plugin.rehype, rehypeStringify);
+	const processor = unified();
+	processor.use(rehypeParse, { fragment: true });
+	processor.use(rehypeRemark);
+	applyUnifiedPlugins(processor, options.plugin.mdast.map((plugin) => isOxContentMdastPlugin(plugin) ? toUnifiedMdastPlugin(plugin, mdastContext) : plugin));
+	applyUnifiedPlugins(processor, remarkPlugins);
+	let toc = [];
+	processor.use(() => {
+		return (tree) => {
+			if (options.toc) toc = extractTocFromMdast(tree, options.tocMaxDepth);
+			return tree;
+		};
+	});
+	const frozenMdastProcessor = processor.freeze();
+	if (resolveUnifiedCompilerStrategy(frozenMdastProcessor) === "custom") {
+		const { processor: compiledProcessor, input } = processorFromMarkdownItProcessor(frozenMdastProcessor(), markdownIt, filePath, fullSource, markdownContent, frontmatter, "markdown-it");
+		return {
+			html: await processUnifiedFile(compiledProcessor, input),
+			frontmatter,
+			toc
+		};
+	}
+	const hastProcessor = frozenMdastProcessor();
+	hastProcessor.use(remarkRehype, {
+		allowDangerousHtml: true,
+		...remarkRehypeOptions
+	});
+	applyUnifiedPlugins(hastProcessor, rehypePlugins);
+	const frozenHastProcessor = hastProcessor.freeze();
+	const finalProcessor = frozenHastProcessor();
+	if (resolveUnifiedCompilerStrategy(frozenHastProcessor) === "default") finalProcessor.use(rehypeStringify, {
+		allowDangerousHtml: true,
+		...rehypeStringifyOptions
+	});
+	const { processor: compiledProcessor, input } = processorFromMarkdownItProcessor(finalProcessor, markdownIt, filePath, fullSource, markdownContent, frontmatter, "markdown-it");
+	return {
+		html: await processUnifiedFile(compiledProcessor, input),
+		frontmatter,
+		toc
+	};
+}
+async function transformWithUnified(fullSource, filePath, options) {
+	const { plugins: remarkPlugins, options: remarkRehypeOptions } = extractUnifiedPluginWithOptions(options.plugin.remark, remarkRehype);
+	const { plugins: rehypePlugins, options: rehypeStringifyOptions } = extractUnifiedPluginWithOptions(options.plugin.rehype, rehypeStringify);
+	const parserStrategy = detectUnifiedParserStrategy(fullSource, filePath, options, remarkPlugins);
+	const nativePayload = parserStrategy === "native" ? transformWithNativeMdastPipeline(loadNapiBindings(), fullSource, options) : null;
+	const preparedInput = parserStrategy === "native" ? null : prepareSourceWithRust(loadNapiBindings(), fullSource, options);
+	const markdownContent = nativePayload?.content ?? preparedInput?.content ?? fullSource;
+	const frontmatter = nativePayload?.frontmatter ?? preparedInput?.frontmatter ?? {};
+	const sourceOffset = nativePayload?.sourceOffset ?? preparedInput?.sourceOffset;
+	const mdastContext = createMdastPluginContext(filePath, fullSource, frontmatter, options, sourceOffset);
+	const processor = unified();
+	applyUnifiedPlugins(processor, options.plugin.mdast.map((plugin) => isOxContentMdastPlugin(plugin) ? toUnifiedMdastPlugin(plugin, mdastContext) : plugin));
+	applyUnifiedPlugins(processor, remarkPlugins);
+	installUnifiedParser(processor, parserStrategy, options, nativePayload?.tree);
+	let toc = [];
+	processor.use(() => {
+		return (tree) => {
+			if (options.toc) toc = extractTocFromMdast(tree, options.tocMaxDepth);
+			return tree;
+		};
+	});
+	const frozenMdastProcessor = processor.freeze();
+	if (resolveUnifiedCompilerStrategy(frozenMdastProcessor) === "custom") return {
+		html: await processUnifiedFile(frozenMdastProcessor(), createUnifiedFileInput(parserStrategy, fullSource, markdownContent, filePath, frontmatter, sourceOffset)),
+		frontmatter,
+		toc
+	};
+	const hastProcessor = frozenMdastProcessor();
+	hastProcessor.use(remarkRehype, {
+		allowDangerousHtml: true,
+		...remarkRehypeOptions
+	});
+	applyUnifiedPlugins(hastProcessor, rehypePlugins);
+	const frozenHastProcessor = hastProcessor.freeze();
+	const finalProcessor = frozenHastProcessor();
+	if (resolveUnifiedCompilerStrategy(frozenHastProcessor) === "default") finalProcessor.use(rehypeStringify, {
+		allowDangerousHtml: true,
+		...rehypeStringifyOptions
+	});
+	return {
+		html: await processUnifiedFile(finalProcessor, createUnifiedFileInput(parserStrategy, fullSource, markdownContent, filePath, frontmatter, sourceOffset)),
+		frontmatter,
 		toc
 	};
 }
@@ -66,6 +842,285 @@ function buildTocTree(entries) {
 	}
 	return result;
 }
+function applyUnifiedPlugins(processor, plugins) {
+	for (const plugin of plugins) {
+		if (Array.isArray(plugin)) {
+			const [attacher, ...pluginOptions] = plugin;
+			if (pluginOptions.length === 0) processor.use(attacher);
+			else if (pluginOptions.length === 1) processor.use(attacher, pluginOptions[0]);
+			else processor.use(attacher, pluginOptions);
+			continue;
+		}
+		processor.use(plugin);
+	}
+}
+function applyMarkdownItPlugins(markdownIt, plugins) {
+	for (const plugin of plugins) {
+		if (Array.isArray(plugin)) {
+			const [fn, ...pluginOptions] = plugin;
+			markdownIt.use(fn, ...pluginOptions);
+			continue;
+		}
+		markdownIt.use(plugin);
+	}
+}
+function isOxContentMdastPlugin(plugin) {
+	return Boolean(plugin) && typeof plugin === "object" && "transform" in plugin;
+}
+function installUnifiedParser(processor, strategy, options, nativeTree) {
+	if (strategy === "custom") return;
+	if (strategy === "remark") {
+		processor.use(remarkParse);
+		return;
+	}
+	if (nativeTree) {
+		processor.use(function usePreparsedMdast() {
+			this.parser = () => nativeTree;
+		});
+		return;
+	}
+	processor.use(oxContentMdast, {
+		gfm: options.gfm,
+		footnotes: options.footnotes,
+		taskLists: options.taskLists,
+		tables: options.tables,
+		strikethrough: options.strikethrough,
+		autolinks: options.gfm
+	});
+}
+function resolveUnifiedParserStrategy(processor) {
+	if (hasUnifiedCustomParser(processor)) return "custom";
+	if (hasRemarkSyntaxExtensions(processor)) return "remark";
+	return "native";
+}
+function resolveUnifiedCompilerStrategy(processor) {
+	return hasUnifiedCustomCompiler(processor) ? "custom" : "default";
+}
+function detectUnifiedParserStrategy(fullSource, filePath, options, remarkPlugins) {
+	const stagedProcessor = unified();
+	const detectionContext = createMdastPluginContext(filePath, fullSource, {}, options);
+	applyUnifiedPlugins(stagedProcessor, options.plugin.mdast.map((plugin) => isOxContentMdastPlugin(plugin) ? toUnifiedMdastPlugin(plugin, detectionContext) : plugin));
+	applyUnifiedPlugins(stagedProcessor, remarkPlugins);
+	return resolveUnifiedParserStrategy(stagedProcessor.freeze());
+}
+function selectUnifiedInput(strategy, fullSource, markdownContent) {
+	return strategy === "native" ? markdownContent : fullSource;
+}
+function createUnifiedFileInput(strategy, fullSource, markdownContent, filePath, frontmatter, sourceOffset) {
+	return {
+		path: filePath,
+		value: strategy === "markdown-it" ? markdownContent : selectUnifiedInput(strategy, fullSource, markdownContent),
+		data: createUnifiedFileData(strategy, fullSource, markdownContent, frontmatter, { sourceOffset })
+	};
+}
+function createUnifiedFileData(parser, fullSource, markdownContent, frontmatter, extra) {
+	return {
+		frontmatter,
+		matter: frontmatter,
+		...extra?.sourceOffset ? { sourceOffset: extra.sourceOffset } : {},
+		oxContent: {
+			parser,
+			frontmatter,
+			source: fullSource,
+			content: markdownContent,
+			...extra?.sourceOffset ? { sourceOffset: extra.sourceOffset } : {},
+			...extra
+		}
+	};
+}
+function hasUnifiedCustomParser(processor) {
+	const candidate = processor;
+	return typeof candidate.Parser === "function" || typeof candidate.parser === "function";
+}
+function hasUnifiedCustomCompiler(processor) {
+	const candidate = processor;
+	return typeof candidate.Compiler === "function" || typeof candidate.compiler === "function";
+}
+async function processUnifiedFile(processor, input) {
+	const file = await processor.process(input);
+	return String(file);
+}
+function processorFromMarkdownItProcessor(processor, markdownIt, filePath, fullSource, markdownContent, frontmatter, parser) {
+	return {
+		processor,
+		input: {
+			path: filePath,
+			value: markdownIt.html,
+			data: createUnifiedFileData(parser, fullSource, markdownContent, frontmatter, {
+				html: markdownIt.html,
+				markdownIt: {
+					env: markdownIt.env,
+					tokens: markdownIt.tokens
+				}
+			})
+		}
+	};
+}
+function createMarkdownItRenderer(options) {
+	const markdownIt = new MarkdownIt({
+		html: true,
+		linkify: options.gfm
+	});
+	if (!options.tables) markdownIt.disable("table");
+	if (!options.strikethrough) markdownIt.disable("strikethrough");
+	return markdownIt;
+}
+function createMarkdownItEnv(filePath, fullSource, markdownContent, frontmatter, sourceOffset) {
+	return {
+		filePath,
+		frontmatter,
+		matter: frontmatter,
+		...sourceOffset ? { sourceOffset } : {},
+		oxContent: {
+			parser: "markdown-it",
+			frontmatter,
+			source: fullSource,
+			content: markdownContent,
+			...sourceOffset ? { sourceOffset } : {}
+		}
+	};
+}
+function extractTocFromMarkdownItTokens(tokens, maxDepth) {
+	const headings = [];
+	for (let index = 0; index < tokens.length; index += 1) {
+		const openToken = tokens[index];
+		if (openToken?.type !== "heading_open") continue;
+		const depth = Number.parseInt(openToken.tag?.replace(/^h/i, "") ?? "", 10);
+		if (!Number.isFinite(depth) || depth < 1 || depth > maxDepth) continue;
+		const inlineToken = tokens[index + 1];
+		if (inlineToken?.type !== "inline") continue;
+		const text = collectMarkdownItText(inlineToken);
+		if (text.length === 0) continue;
+		headings.push({
+			depth,
+			text,
+			slug: getMarkdownItTokenAttr(openToken, "id") ?? slugify(text),
+			children: []
+		});
+	}
+	return buildTocTree(headings);
+}
+function collectMarkdownItText(token) {
+	if (Array.isArray(token.children) && token.children.length > 0) return token.children.map((child) => collectMarkdownItText(child)).join("");
+	return typeof token.content === "string" ? token.content : "";
+}
+function getMarkdownItTokenAttr(token, name) {
+	if (!Array.isArray(token.attrs)) return;
+	return token.attrs.find(([key]) => key === name)?.[1];
+}
+function readSourceOriginFromEnvelope(buffer, envelope, sectionId) {
+	const section = envelope.sections.get(sectionId);
+	if (!section) return;
+	if (section.len !== 16) throw new Error("[ox-content] source origin transfer section is misaligned.");
+	const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+	return {
+		byteOffset: view.getUint32(section.offset, true),
+		offset: view.getUint32(section.offset + 4, true),
+		line: view.getUint32(section.offset + 8, true),
+		column: view.getUint32(section.offset + 12, true)
+	};
+}
+function slugify(text) {
+	return text.toLowerCase().replace(/[^\p{L}\p{N}\s-]+/gu, " ").trim().split(/\s+/).filter(Boolean).join("-");
+}
+function requireNapiMethod(method, name) {
+	if (typeof method === "function") return method;
+	throw new Error(`[ox-content] @ox-content/napi is too old for unified interop: missing ${name}(). Rebuild the NAPI module with \`vp run build:napi\`.`);
+}
+async function transformHtmlWithRehype(html, filePath, fullSource, markdownContent, frontmatter, options, parser, extra) {
+	const { plugins: rehypePlugins, options: rehypeStringifyOptions } = extractUnifiedPluginWithOptions(options.plugin.rehype, rehypeStringify);
+	const stagedProcessor = unified();
+	stagedProcessor.use(rehypeParse, { fragment: true });
+	applyUnifiedPlugins(stagedProcessor, rehypePlugins);
+	const frozenProcessor = stagedProcessor.freeze();
+	const processor = frozenProcessor();
+	if (resolveUnifiedCompilerStrategy(frozenProcessor) === "default") processor.use(rehypeStringify, {
+		allowDangerousHtml: true,
+		...rehypeStringifyOptions
+	});
+	return processUnifiedFile(processor, {
+		path: filePath,
+		value: html,
+		data: createUnifiedFileData(parser, fullSource, markdownContent, frontmatter, {
+			html,
+			...extra
+		})
+	});
+}
+function hasRemarkSyntaxExtensions(processor) {
+	const data = processor.data();
+	return hasOwnDataField(data, "micromarkExtensions") || hasOwnDataField(data, "fromMarkdownExtensions");
+}
+function hasOwnDataField(data, key) {
+	return Object.prototype.hasOwnProperty.call(data, key);
+}
+function extractUnifiedPluginWithOptions(plugins, targetPlugin) {
+	let extractedOptions;
+	const nextPlugins = [];
+	for (const plugin of plugins) {
+		const result = filterUnifiedPlugin(plugin, targetPlugin);
+		extractedOptions = mergeUnifiedPluginOptions(extractedOptions, result.options);
+		if (result.keep) nextPlugins.push(result.plugin);
+	}
+	return {
+		plugins: nextPlugins,
+		options: extractedOptions
+	};
+}
+function filterUnifiedPlugin(plugin, targetPlugin) {
+	if (isUnifiedPreset(plugin)) {
+		const { plugins: _plugins, ...rest } = plugin;
+		let extractedOptions;
+		const nextPlugins = [];
+		for (const nestedPlugin of plugin.plugins ?? []) {
+			const result = filterUnifiedPlugin(nestedPlugin, targetPlugin);
+			extractedOptions = mergeUnifiedPluginOptions(extractedOptions, result.options);
+			if (result.keep) nextPlugins.push(result.plugin);
+		}
+		if (nextPlugins.length === 0 && plugin.settings === void 0) return {
+			keep: false,
+			plugin,
+			options: extractedOptions
+		};
+		return {
+			keep: true,
+			plugin: {
+				...rest,
+				...nextPlugins.length > 0 ? { plugins: nextPlugins } : {}
+			},
+			options: extractedOptions
+		};
+	}
+	const { attacher, options } = splitUnifiedPlugin(plugin);
+	if (attacher === targetPlugin) return {
+		keep: false,
+		plugin,
+		options
+	};
+	return {
+		keep: true,
+		plugin
+	};
+}
+function mergeUnifiedPluginOptions(left, right) {
+	if (left === void 0) return right;
+	if (right === void 0) return left;
+	return {
+		...left,
+		...right
+	};
+}
+function isUnifiedPreset(plugin) {
+	return Boolean(plugin) && typeof plugin === "object" && !Array.isArray(plugin) && ("plugins" in plugin || "settings" in plugin);
+}
+function splitUnifiedPlugin(plugin) {
+	if (!Array.isArray(plugin)) return { attacher: plugin };
+	const [attacher, firstOption] = plugin;
+	return {
+		attacher,
+		options: firstOption && typeof firstOption === "object" ? firstOption : void 0
+	};
+}
 /**
 * Generates the JavaScript module code.
 */
@@ -180,6 +1235,7 @@ function resolveOptions(options) {
 		plugin: {
 			oxContent: options.plugin?.oxContent ?? [],
 			markdownIt: options.plugin?.markdownIt ?? [],
+			mdast: options.plugin?.mdast ?? [],
 			remark: options.plugin?.remark ?? [],
 			rehype: options.plugin?.rehype ?? []
 		},
@@ -254,4 +1310,4 @@ const unpluginFactory = (rawOptions = {}) => {
 */
 const unplugin = /* @__PURE__ */ createUnplugin(unpluginFactory);
 //#endregion
-export { transformMarkdown as n, unplugin as t };
+export { extractTocFromMdast as a, toUnifiedMdastPlugin as c, defineMdastPlugin as i, transformMarkdown as n, oxContentMdast as o, createMdastPluginContext as r, parseMarkdownToMdast as s, unplugin as t };