@andesine/converters 0.1.0

package/dist/index.js

@@ -0,0 +1,40 @@
+import { getHeadingAnchors } from "./anchors.js";
+import { a as element, c as textContent, i as ConversionError, l as textNode, n as createExportConverter, r as createImportConverter, t as createConverter, u as withMark } from "./chunks/core-DC64ddB7.js";
+//#region src/images.ts
+/**
+* Create an async imageURL callback from published asset references.
+* @param assets - Assets from the same entry and snapshot as the document being converted.
+* @param options - Image variant or async variant selector. Defaults to "display".
+* @returns A callback that looks up node.attrs.assetID and returns the supplied URL unchanged.
+* It does not fetch images, refresh expiring URLs, or fall back to another variant.
+* @throws ConversionError when the callback cannot find the requested asset and variant.
+*/
+const createImageURLResolver = (assets, options = {}) => {
+	const urls = /* @__PURE__ */ new Map();
+	for (const asset of assets) {
+		const variants = urls.get(asset.assetID) || /* @__PURE__ */ new Map();
+		variants.set(asset.variant, asset.url);
+		urls.set(asset.assetID, variants);
+	}
+	return async (node) => {
+		const assetID = node.attrs?.assetID;
+		const variant = typeof options.variant === "function" ? await options.variant(node) : options.variant ?? "display";
+		const url = typeof assetID === "string" ? urls.get(assetID)?.get(variant) : void 0;
+		if (!url) throw new ConversionError(`Image asset ${String(assetID)} has no URL for variant ${variant}`);
+		return url;
+	};
+};
+/**
+* Supply converter options derived from a published-content response or full list item.
+* @param page - An object with the document's published asset references; no SDK type is required.
+* @param options - Image variant settings passed to createImageURLResolver().
+* @returns An imageURL callback only. Title, fragment, and property defaults remain unchanged.
+* Missing asset URLs throw ConversionError when an image is converted, not during this call.
+* @example
+* const html = await toHTML(page.content, { ...publishedContentOptions(page), title: "omit" });
+*/
+const publishedContentOptions = (page, options) => ({ imageURL: createImageURLResolver(page.assets, options) });
+//#endregion
+export { ConversionError, createConverter, createExportConverter, createImageURLResolver, createImportConverter, element, getHeadingAnchors, publishedContentOptions, textContent, textNode, withMark };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/images.ts"],"sourcesContent":["import type { Awaitable, ContentNode } from \"./types\";\nimport { ConversionError } from \"./utils\";\n\ninterface ImageAsset {\n  assetID: string;\n  variant: string;\n  url: string;\n}\ninterface ImageURLOptions {\n  /** Variant to resolve, or an async selector for each image. Defaults to \"display\". */\n  variant?: string | ((node: ContentNode) => Awaitable<string>);\n}\ninterface PublishedImageContent {\n  assets: readonly ImageAsset[];\n}\n\n/**\n * Create an async imageURL callback from published asset references.\n * @param assets - Assets from the same entry and snapshot as the document being converted.\n * @param options - Image variant or async variant selector. Defaults to \"display\".\n * @returns A callback that looks up node.attrs.assetID and returns the supplied URL unchanged.\n * It does not fetch images, refresh expiring URLs, or fall back to another variant.\n * @throws ConversionError when the callback cannot find the requested asset and variant.\n */\nconst createImageURLResolver = (assets: readonly ImageAsset[], options: ImageURLOptions = {}) => {\n  const urls = new Map<string, Map<string, string>>();\n\n  for (const asset of assets) {\n    const variants = urls.get(asset.assetID) || new Map<string, string>();\n    variants.set(asset.variant, asset.url);\n    urls.set(asset.assetID, variants);\n  }\n\n  return async (node: ContentNode): Promise<string> => {\n    const assetID = node.attrs?.assetID;\n    const variant =\n      typeof options.variant === \"function\"\n        ? await options.variant(node)\n        : (options.variant ?? \"display\");\n    const url = typeof assetID === \"string\" ? urls.get(assetID)?.get(variant) : undefined;\n\n    if (!url) {\n      throw new ConversionError(`Image asset ${String(assetID)} has no URL for variant ${variant}`);\n    }\n\n    return url;\n  };\n};\n/**\n * Supply converter options derived from a published-content response or full list item.\n * @param page - An object with the document's published asset references; no SDK type is required.\n * @param options - Image variant settings passed to createImageURLResolver().\n * @returns An imageURL callback only. Title, fragment, and property defaults remain unchanged.\n * Missing asset URLs throw ConversionError when an image is converted, not during this call.\n * @example\n * const html = await toHTML(page.content, { ...publishedContentOptions(page), title: \"omit\" });\n */\nconst publishedContentOptions = (page: PublishedImageContent, options?: ImageURLOptions) => ({\n  imageURL: createImageURLResolver(page.assets, options)\n});\n\nexport { createImageURLResolver, publishedContentOptions };\nexport type { ImageAsset, ImageURLOptions, PublishedImageContent };\n"],"mappings":";;;;;;;;;;;AAwBA,MAAM,0BAA0B,QAA+B,UAA2B,CAAC,MAAM;CAC/F,MAAM,uBAAO,IAAI,IAAiC;CAElD,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,KAAK,IAAI,MAAM,OAAO,qBAAK,IAAI,IAAoB;EACpE,SAAS,IAAI,MAAM,SAAS,MAAM,GAAG;EACrC,KAAK,IAAI,MAAM,SAAS,QAAQ;CAClC;CAEA,OAAO,OAAO,SAAuC;EACnD,MAAM,UAAU,KAAK,OAAO;EAC5B,MAAM,UACJ,OAAO,QAAQ,YAAY,aACvB,MAAM,QAAQ,QAAQ,IAAI,IACzB,QAAQ,WAAW;EAC1B,MAAM,MAAM,OAAO,YAAY,WAAW,KAAK,IAAI,OAAO,CAAC,EAAE,IAAI,OAAO,IAAI,KAAA;EAE5E,IAAI,CAAC,KACH,MAAM,IAAI,gBAAgB,eAAe,OAAO,OAAO,EAAE,0BAA0B,SAAS;EAG9F,OAAO;CACT;AACF;;;;;;;;;;AAUA,MAAM,2BAA2B,MAA6B,aAA+B,EAC3F,UAAU,uBAAuB,KAAK,QAAQ,OAAO,EACvD"}

package/dist/markdoc.d.ts

@@ -0,0 +1,49 @@
+import { a as Converter, f as ExportConverterOptions, i as ConvertedAST, m as FormatAdapter, o as ConverterOptions, r as ContentNode, y as ImportConverterOptions } from "./chunks/types-SDFWRP3z.js";
+import Markdoc from "@markdoc/markdoc";
+//#region src/markdoc.d.ts
+type MarkdocNode = InstanceType<typeof Markdoc.Ast.Node>;
+type MarkdocOptions = ConverterOptions<MarkdocNode>;
+/** Markdoc adapter for createConverter(), including its parser and node/mark mappings. */
+declare const markdocAdapter: FormatAdapter<MarkdocNode>;
+/**
+ * Create a reusable async Markdoc converter with application-specific defaults.
+ * @param options - Default mappings and handlers; per-call maps merge by key and callbacks may be async.
+ * @returns String and AST import/export methods. Defaults use an H1 title, unwrap fragments, and omit properties.
+ * Custom elements use Markdoc tags with static properties.
+ */
+declare const createMarkdocConverter: (options?: MarkdocOptions) => Converter<import("@markdoc/markdoc").Node>;
+/**
+ * Export ProseMirror JSON as Markdoc.
+ * @param document - Entry or fragment document. Fragment wrappers are removed by default.
+ * @param options - Title/property/fragment mappings and async handlers; imageURL resolves images.
+ * @returns Serialized Markdoc. Omitted metadata and unwrapped fragment boundaries are not recoverable.
+ * @throws ConversionError for unsupported content, unresolved images, or invalid mappings; handler errors pass through.
+ */
+declare const toMarkdoc: (document: ContentNode, options?: ExportConverterOptions<import("@markdoc/markdoc").Node> | undefined) => Promise<string>;
+/**
+ * Import Markdoc as ProseMirror JSON without saving content or uploading assets.
+ * @param source - Source text to parse. Custom elements use Markdoc tags with static properties.
+ * @param options - Import mappings and async handlers. imageAssetID must resolve image URLs.
+ * @returns An entry document; use document: "fragment" to omit the title and retain the first H1 as body content.
+ * @throws ConversionError for unsupported content/mappings; parser and handler errors pass through.
+ */
+declare const fromMarkdoc: (source: string, options?: ImportConverterOptions<import("@markdoc/markdoc").Node> | undefined) => Promise<ContentNode>;
+/**
+ * Export ProseMirror JSON as a Markdoc AST with separate frontmatter.
+ * @param document - Source entry or fragment document.
+ * @param options - Export mappings and async handlers, including imageURL for images.
+ * @returns The format tree and metadata without string serialization.
+ * @throws The same conversion errors as toMarkdoc(), including unsupported frontmatter mappings.
+ */
+declare const toMarkdocAST: (document: ContentNode, options?: ExportConverterOptions<import("@markdoc/markdoc").Node> | undefined) => Promise<ConvertedAST<import("@markdoc/markdoc").Node>>;
+/**
+ * Import a parsed Markdoc AST and its frontmatter as ProseMirror JSON.
+ * @param input - Tree and frontmatter object; use an empty object when metadata is absent.
+ * @param options - Import mappings and async handlers, including imageAssetID for images.
+ * @returns An entry document by default, or a fragment document when requested.
+ * @throws The same conversion errors as fromMarkdoc(), excluding string-parser errors.
+ */
+declare const fromMarkdocAST: (input: ConvertedAST<import("@markdoc/markdoc").Node>, options?: ImportConverterOptions<import("@markdoc/markdoc").Node> | undefined) => Promise<ContentNode>;
+//#endregion
+export { type MarkdocNode, type MarkdocOptions, createMarkdocConverter, fromMarkdoc, fromMarkdocAST, markdocAdapter, toMarkdoc, toMarkdocAST };
+//# sourceMappingURL=markdoc.d.ts.map

package/dist/markdoc.js

@@ -0,0 +1,310 @@
+import { a as element, c as textContent, i as ConversionError, l as textNode, o as isJSONValue, s as lookup, t as createConverter, u as withMark } from "./chunks/core-DC64ddB7.js";
+import { n as paragraphContent } from "./chunks/decode-B-xzTJFV.js";
+import { n as normalizeMarkdown, t as markdownStringifyOptions } from "./chunks/stringify-DdPaV2y4.js";
+import { unified } from "unified";
+import remarkStringify from "remark-stringify";
+import remarkGFM from "remark-gfm";
+import Markdoc from "@markdoc/markdoc";
+//#region src/markdoc/serialize.ts
+const processor = unified().use(remarkGFM).use(remarkStringify, {
+	...markdownStringifyOptions,
+	unsafe: [{
+		character: "{",
+		after: "%"
+	}]
+});
+const serializeMarkdoc = (tree) => {
+	const convert = (node) => {
+		const attrs = node.attributes;
+		const children = node.children.flatMap(convert);
+		const inline = children;
+		switch (node.type) {
+			case "document": return [{
+				type: "root",
+				children
+			}];
+			case "inline":
+			case "thead":
+			case "tbody": return children;
+			case "text": return [{
+				type: "text",
+				value: String(attrs.content || "")
+			}];
+			case "paragraph": return [{
+				type: "paragraph",
+				children: inline
+			}];
+			case "heading": return [{
+				type: "heading",
+				depth: Number(attrs.level || 1),
+				children: inline
+			}];
+			case "strong": return [{
+				type: "strong",
+				children: inline
+			}];
+			case "em": return [{
+				type: "emphasis",
+				children: inline
+			}];
+			case "s": return [{
+				type: "delete",
+				children: inline
+			}];
+			case "code": return [{
+				type: "inlineCode",
+				value: String(attrs.content || "")
+			}];
+			case "link": return [{
+				type: "link",
+				url: String(attrs.href || ""),
+				children: inline
+			}];
+			case "image": return [{
+				type: "image",
+				url: String(attrs.src || ""),
+				alt: String(attrs.alt || ""),
+				title: attrs.title || null
+			}];
+			case "blockquote": return [{
+				type: "blockquote",
+				children
+			}];
+			case "list": return [{
+				type: "list",
+				ordered: Boolean(attrs.ordered),
+				start: Number(attrs.start || 1),
+				children
+			}];
+			case "item": return [{
+				type: "listItem",
+				children
+			}];
+			case "fence": return [{
+				type: "code",
+				lang: String(attrs.language || ""),
+				value: String(attrs.content || "")
+			}];
+			case "hardbreak": return [{ type: "break" }];
+			case "softbreak": return [{
+				type: "text",
+				value: "\n"
+			}];
+			case "hr": return [{ type: "thematicBreak" }];
+			case "table": return [{
+				type: "table",
+				children
+			}];
+			case "tr": return [{
+				type: "tableRow",
+				children
+			}];
+			case "td":
+			case "th": return [{
+				type: "tableCell",
+				children: inline
+			}];
+			case "tag": {
+				const opening = Markdoc.format(new Markdoc.Ast.Node("tag", attrs, [], node.tag)).trim();
+				const body = processor.stringify(normalizeMarkdown({
+					type: "root",
+					children
+				}));
+				return [{
+					type: "html",
+					value: children.length ? `${opening.replace(/\s*\/%\}$/, " %}")}\n\n${body}\n{% /${node.tag} %}` : opening
+				}];
+			}
+			default: throw new ConversionError(`Unsupported Markdoc AST node: ${node.type}`);
+		}
+	};
+	const nodes = convert(tree);
+	const root = nodes[0]?.type === "root" ? nodes[0] : {
+		type: "root",
+		children: nodes
+	};
+	return processor.stringify(normalizeMarkdown(root));
+};
+//#endregion
+//#region src/markdoc.ts
+const markTypes = {
+	bold: "strong",
+	italic: "em",
+	strike: "s",
+	code: "code",
+	link: "link"
+};
+/** Markdoc adapter for createConverter(), including its parser and node/mark mappings. */
+const markdocAdapter = {
+	name: "Markdoc",
+	frontmatter: true,
+	type: (node) => node.type,
+	elementName: (node) => node.type === "tag" ? node.tag : void 0,
+	markName: (node) => Object.entries(markTypes).find(([, type]) => type === node.type)?.[0],
+	root: (children) => new Markdoc.Ast.Node("document", {}, children),
+	parse: (source) => Markdoc.parse(source),
+	stringify: serializeMarkdoc,
+	async encode(node, context) {
+		const attrs = node.attrs || {};
+		const children = await context.children(node);
+		const inline = () => [new Markdoc.Ast.Node("inline", {}, children)];
+		switch (node.type) {
+			case "text": return new Markdoc.Ast.Node("text", { content: node.text || "" });
+			case "paragraph": return new Markdoc.Ast.Node("paragraph", {}, inline());
+			case "heading": return new Markdoc.Ast.Node("heading", {
+				level: Number(attrs.level || 1),
+				...context.anchor ? { id: context.anchor } : {}
+			}, inline());
+			case "blockquote": return new Markdoc.Ast.Node("blockquote", {}, children);
+			case "bulletList":
+			case "orderedList": return new Markdoc.Ast.Node("list", {
+				ordered: node.type === "orderedList",
+				start: attrs.start || 1,
+				marker: node.type === "orderedList" ? "." : "-"
+			}, children);
+			case "listItem": return new Markdoc.Ast.Node("item", {}, children);
+			case "codeBlock": return new Markdoc.Ast.Node("fence", {
+				language: attrs.language || "",
+				content: textContent(node)
+			});
+			case "hardBreak": return new Markdoc.Ast.Node("hardbreak");
+			case "horizontalRule": return new Markdoc.Ast.Node("hr");
+			case "image": return new Markdoc.Ast.Node("paragraph", {}, [new Markdoc.Ast.Node("inline", {}, [new Markdoc.Ast.Node("image", {
+				src: await context.imageURL(node),
+				alt: String(attrs.alt || ""),
+				title: String(attrs.caption || "")
+			})])]);
+			case "element": {
+				const props = attrs.props || {};
+				if (!isJSONValue(props)) throw new ConversionError("Markdoc attributes must contain static JSON values", context.path);
+				return new Markdoc.Ast.Node("tag", props, children, String(attrs.name || "Element"));
+			}
+			case "table": return new Markdoc.Ast.Node("table", {}, children.length ? [new Markdoc.Ast.Node("thead", {}, children.slice(0, 1)), new Markdoc.Ast.Node("tbody", {}, children.slice(1))] : []);
+			case "tableRow": return new Markdoc.Ast.Node("tr", {}, children);
+			case "tableCell":
+			case "tableHeader":
+				if (Number(attrs.colspan || 1) !== 1 || Number(attrs.rowspan || 1) !== 1 || children.length > 1 || children.some((child) => child.type !== "paragraph")) throw new ConversionError("Markdoc tables require single-paragraph cells without spans", context.path);
+				return new Markdoc.Ast.Node(node.type === "tableHeader" ? "th" : "td", {}, children.flatMap((child) => child.children));
+			default: throw new ConversionError(`Unsupported Markdoc node: ${node.type}`, context.path);
+		}
+	},
+	mark(mark, children, context) {
+		const type = lookup(markTypes, mark.type);
+		if (!type) throw new ConversionError(`Unsupported Markdoc mark: ${mark.type}`, context.path);
+		if (mark.type === "code") {
+			if (children.some((node) => node.type !== "text")) throw new ConversionError("Code marks must wrap plain text", context.path);
+			return new Markdoc.Ast.Node("code", { content: children.map((node) => node.attributes.content).join("") });
+		}
+		return new Markdoc.Ast.Node(type, mark.type === "link" ? { href: mark.attrs?.href || "" } : {}, children);
+	},
+	async decode(node, context) {
+		const attrs = node.attributes;
+		if (node.errors.length) throw new ConversionError(`Invalid Markdoc: ${node.errors[0].message}`, context.path);
+		if (!isJSONValue(attrs)) throw new ConversionError("Dynamic Markdoc attributes require a custom handler", context.path);
+		const children = await context.children(node.children);
+		const mark = Object.entries(markTypes).find(([, type]) => type === node.type)?.[0];
+		if (mark === "code") return withMark(textNode(String(attrs.content || "")), { type: "code" });
+		if (mark) return withMark(children, {
+			type: mark,
+			...mark === "link" ? { attrs: { href: attrs.href } } : {}
+		});
+		switch (node.type) {
+			case "document":
+			case "inline":
+			case "thead":
+			case "tbody": return children;
+			case "text": return textNode(String(attrs.content || ""));
+			case "paragraph": return paragraphContent(children);
+			case "heading": return {
+				type: "heading",
+				attrs: { level: attrs.level || 1 },
+				content: children
+			};
+			case "blockquote": return {
+				type: "blockquote",
+				content: children
+			};
+			case "list": return {
+				type: attrs.ordered ? "orderedList" : "bulletList",
+				...attrs.ordered ? { attrs: { start: attrs.start || 1 } } : {},
+				content: children
+			};
+			case "item": return {
+				type: "listItem",
+				content: paragraphContent(children)
+			};
+			case "fence": return {
+				type: "codeBlock",
+				attrs: { language: attrs.language || null },
+				content: textNode(String(attrs.content || "").replace(/\n$/, ""))
+			};
+			case "hardbreak": return { type: "hardBreak" };
+			case "softbreak": return textNode("\n");
+			case "hr": return { type: "horizontalRule" };
+			case "image": return context.image({
+				url: String(attrs.src || ""),
+				alt: String(attrs.alt || ""),
+				title: attrs.title
+			});
+			case "tag": return element(node.tag || "Element", attrs, children.length ? paragraphContent(children) : []);
+			case "table": return {
+				type: "table",
+				content: children
+			};
+			case "tr": return {
+				type: "tableRow",
+				content: children
+			};
+			case "th":
+			case "td": return {
+				type: node.type === "th" ? "tableHeader" : "tableCell",
+				content: paragraphContent(children)
+			};
+			default: throw new ConversionError(`Unsupported Markdoc syntax: ${node.type}`, context.path);
+		}
+	}
+};
+/**
+* Create a reusable async Markdoc converter with application-specific defaults.
+* @param options - Default mappings and handlers; per-call maps merge by key and callbacks may be async.
+* @returns String and AST import/export methods. Defaults use an H1 title, unwrap fragments, and omit properties.
+* Custom elements use Markdoc tags with static properties.
+*/
+const createMarkdocConverter = (options) => createConverter(markdocAdapter, options);
+const converter = createMarkdocConverter();
+/**
+* Export ProseMirror JSON as Markdoc.
+* @param document - Entry or fragment document. Fragment wrappers are removed by default.
+* @param options - Title/property/fragment mappings and async handlers; imageURL resolves images.
+* @returns Serialized Markdoc. Omitted metadata and unwrapped fragment boundaries are not recoverable.
+* @throws ConversionError for unsupported content, unresolved images, or invalid mappings; handler errors pass through.
+*/
+const toMarkdoc = converter.encode;
+/**
+* Import Markdoc as ProseMirror JSON without saving content or uploading assets.
+* @param source - Source text to parse. Custom elements use Markdoc tags with static properties.
+* @param options - Import mappings and async handlers. imageAssetID must resolve image URLs.
+* @returns An entry document; use document: "fragment" to omit the title and retain the first H1 as body content.
+* @throws ConversionError for unsupported content/mappings; parser and handler errors pass through.
+*/
+const fromMarkdoc = converter.decode;
+/**
+* Export ProseMirror JSON as a Markdoc AST with separate frontmatter.
+* @param document - Source entry or fragment document.
+* @param options - Export mappings and async handlers, including imageURL for images.
+* @returns The format tree and metadata without string serialization.
+* @throws The same conversion errors as toMarkdoc(), including unsupported frontmatter mappings.
+*/
+const toMarkdocAST = converter.toAST;
+/**
+* Import a parsed Markdoc AST and its frontmatter as ProseMirror JSON.
+* @param input - Tree and frontmatter object; use an empty object when metadata is absent.
+* @param options - Import mappings and async handlers, including imageAssetID for images.
+* @returns An entry document by default, or a fragment document when requested.
+* @throws The same conversion errors as fromMarkdoc(), excluding string-parser errors.
+*/
+const fromMarkdocAST = converter.fromAST;
+//#endregion
+export { createMarkdocConverter, fromMarkdoc, fromMarkdocAST, markdocAdapter, toMarkdoc, toMarkdocAST };
+
+//# sourceMappingURL=markdoc.js.map

package/dist/markdoc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdoc.js","names":[],"sources":["../src/markdoc/serialize.ts","../src/markdoc.ts"],"sourcesContent":["import Markdoc from \"@markdoc/markdoc\";\nimport { unified } from \"unified\";\nimport remarkStringify from \"remark-stringify\";\nimport remarkGFM from \"remark-gfm\";\nimport type {\n  Root,\n  RootContent,\n  PhrasingContent,\n  BlockContent,\n  ListContent,\n  TableContent,\n  RowContent\n} from \"mdast\";\nimport { ConversionError } from \"../utils\";\nimport { normalizeMarkdown } from \"../markdown/normalize\";\nimport { markdownStringifyOptions } from \"../markdown/stringify\";\n\ntype MarkdocNode = InstanceType<typeof Markdoc.Ast.Node>;\ntype MarkdownNode = Root | RootContent;\n\n// Markdoc's formatter preserves source-like text. Use a Markdown serializer to\n// escape literal Markdown characters in newly created content.\nconst processor = unified()\n  .use(remarkGFM)\n  .use(remarkStringify, {\n    ...markdownStringifyOptions,\n    unsafe: [{ character: \"{\", after: \"%\" }]\n  });\nconst serializeMarkdoc = (tree: MarkdocNode): string => {\n  const convert = (node: MarkdocNode): MarkdownNode[] => {\n    const attrs = node.attributes;\n    const children = node.children.flatMap(convert);\n    const inline = children as PhrasingContent[];\n\n    switch (node.type) {\n      case \"document\":\n        return [{ type: \"root\", children: children as RootContent[] }];\n      case \"inline\":\n      case \"thead\":\n      case \"tbody\":\n        return children;\n      case \"text\":\n        return [{ type: \"text\", value: String(attrs.content || \"\") }];\n      case \"paragraph\":\n        return [{ type: \"paragraph\", children: inline }];\n      case \"heading\":\n        return [\n          {\n            type: \"heading\",\n            depth: Number(attrs.level || 1) as 1 | 2 | 3 | 4 | 5 | 6,\n            children: inline\n          }\n        ];\n      case \"strong\":\n        return [{ type: \"strong\", children: inline }];\n      case \"em\":\n        return [{ type: \"emphasis\", children: inline }];\n      case \"s\":\n        return [{ type: \"delete\", children: inline }];\n      case \"code\":\n        return [{ type: \"inlineCode\", value: String(attrs.content || \"\") }];\n      case \"link\":\n        return [{ type: \"link\", url: String(attrs.href || \"\"), children: inline }];\n      case \"image\":\n        return [\n          {\n            type: \"image\",\n            url: String(attrs.src || \"\"),\n            alt: String(attrs.alt || \"\"),\n            title: attrs.title || null\n          }\n        ];\n      case \"blockquote\":\n        return [{ type: \"blockquote\", children: children as BlockContent[] }];\n      case \"list\":\n        return [\n          {\n            type: \"list\",\n            ordered: Boolean(attrs.ordered),\n            start: Number(attrs.start || 1),\n            children: children as ListContent[]\n          }\n        ];\n      case \"item\":\n        return [{ type: \"listItem\", children: children as BlockContent[] }];\n      case \"fence\":\n        return [\n          { type: \"code\", lang: String(attrs.language || \"\"), value: String(attrs.content || \"\") }\n        ];\n      case \"hardbreak\":\n        return [{ type: \"break\" }];\n      case \"softbreak\":\n        return [{ type: \"text\", value: \"\\n\" }];\n      case \"hr\":\n        return [{ type: \"thematicBreak\" }];\n      case \"table\":\n        return [{ type: \"table\", children: children as TableContent[] }];\n      case \"tr\":\n        return [{ type: \"tableRow\", children: children as RowContent[] }];\n      case \"td\":\n      case \"th\":\n        return [{ type: \"tableCell\", children: inline }];\n      case \"tag\": {\n        const opening = Markdoc.format(new Markdoc.Ast.Node(\"tag\", attrs, [], node.tag)).trim();\n        const body = processor.stringify(\n          normalizeMarkdown({ type: \"root\", children: children as RootContent[] })\n        );\n        const value = children.length\n          ? `${opening.replace(/\\s*\\/%\\}$/, \" %}\")}\\n\\n${body}\\n{% /${node.tag} %}`\n          : opening;\n\n        return [{ type: \"html\", value }];\n      }\n      default:\n        throw new ConversionError(`Unsupported Markdoc AST node: ${node.type}`);\n    }\n  };\n  const nodes = convert(tree);\n  const root: Root =\n    nodes[0]?.type === \"root\" ? nodes[0] : { type: \"root\", children: nodes as RootContent[] };\n\n  return processor.stringify(normalizeMarkdown(root));\n};\n\nexport { serializeMarkdoc };\n","import Markdoc from \"@markdoc/markdoc\";\nimport { serializeMarkdoc } from \"./markdoc/serialize\";\nimport { createConverter } from \"./core\";\nimport {\n  ConversionError,\n  lookup,\n  element,\n  isJSONValue,\n  textContent,\n  textNode,\n  withMark\n} from \"./utils\";\nimport { paragraphContent } from \"./markdown/decode\";\nimport type { ConverterOptions, FormatAdapter } from \"./types\";\n\ntype MarkdocNode = InstanceType<typeof Markdoc.Ast.Node>;\ntype MarkdocOptions = ConverterOptions<MarkdocNode>;\n\nconst markTypes: Record<string, string> = {\n  bold: \"strong\",\n  italic: \"em\",\n  strike: \"s\",\n  code: \"code\",\n  link: \"link\"\n};\n/** Markdoc adapter for createConverter(), including its parser and node/mark mappings. */\nconst markdocAdapter: FormatAdapter<MarkdocNode> = {\n  name: \"Markdoc\",\n  frontmatter: true,\n  type: (node) => node.type,\n  elementName: (node) => (node.type === \"tag\" ? node.tag : undefined),\n  markName: (node) => Object.entries(markTypes).find(([, type]) => type === node.type)?.[0],\n  root: (children) => new Markdoc.Ast.Node(\"document\", {}, children),\n  parse: (source) => Markdoc.parse(source),\n  stringify: serializeMarkdoc,\n  async encode(node, context) {\n    const attrs = node.attrs || {};\n    const children = await context.children(node);\n    const inline = () => [new Markdoc.Ast.Node(\"inline\", {}, children)];\n\n    switch (node.type) {\n      case \"text\":\n        return new Markdoc.Ast.Node(\"text\", { content: node.text || \"\" });\n      case \"paragraph\":\n        return new Markdoc.Ast.Node(\"paragraph\", {}, inline());\n      case \"heading\":\n        return new Markdoc.Ast.Node(\n          \"heading\",\n          { level: Number(attrs.level || 1), ...(context.anchor ? { id: context.anchor } : {}) },\n          inline()\n        );\n      case \"blockquote\":\n        return new Markdoc.Ast.Node(\"blockquote\", {}, children);\n      case \"bulletList\":\n      case \"orderedList\":\n        return new Markdoc.Ast.Node(\n          \"list\",\n          {\n            ordered: node.type === \"orderedList\",\n            start: attrs.start || 1,\n            marker: node.type === \"orderedList\" ? \".\" : \"-\"\n          },\n          children\n        );\n      case \"listItem\":\n        return new Markdoc.Ast.Node(\"item\", {}, children);\n      case \"codeBlock\":\n        return new Markdoc.Ast.Node(\"fence\", {\n          language: attrs.language || \"\",\n          content: textContent(node)\n        });\n      case \"hardBreak\":\n        return new Markdoc.Ast.Node(\"hardbreak\");\n      case \"horizontalRule\":\n        return new Markdoc.Ast.Node(\"hr\");\n      case \"image\":\n        return new Markdoc.Ast.Node(\"paragraph\", {}, [\n          new Markdoc.Ast.Node(\"inline\", {}, [\n            new Markdoc.Ast.Node(\"image\", {\n              src: await context.imageURL(node),\n              alt: String(attrs.alt || \"\"),\n              title: String(attrs.caption || \"\")\n            })\n          ])\n        ]);\n      case \"element\": {\n        const props = (attrs.props || {}) as Record<string, unknown>;\n\n        if (!isJSONValue(props))\n          throw new ConversionError(\n            \"Markdoc attributes must contain static JSON values\",\n            context.path\n          );\n\n        return new Markdoc.Ast.Node(\"tag\", props, children, String(attrs.name || \"Element\"));\n      }\n      case \"table\":\n        return new Markdoc.Ast.Node(\n          \"table\",\n          {},\n          children.length\n            ? [\n                new Markdoc.Ast.Node(\"thead\", {}, children.slice(0, 1)),\n                new Markdoc.Ast.Node(\"tbody\", {}, children.slice(1))\n              ]\n            : []\n        );\n      case \"tableRow\":\n        return new Markdoc.Ast.Node(\"tr\", {}, children);\n      case \"tableCell\":\n      case \"tableHeader\": {\n        if (\n          Number(attrs.colspan || 1) !== 1 ||\n          Number(attrs.rowspan || 1) !== 1 ||\n          children.length > 1 ||\n          children.some((child) => child.type !== \"paragraph\")\n        ) {\n          throw new ConversionError(\n            \"Markdoc tables require single-paragraph cells without spans\",\n            context.path\n          );\n        }\n        return new Markdoc.Ast.Node(\n          node.type === \"tableHeader\" ? \"th\" : \"td\",\n          {},\n          children.flatMap((child) => child.children)\n        );\n      }\n      default:\n        throw new ConversionError(`Unsupported Markdoc node: ${node.type}`, context.path);\n    }\n  },\n  mark(mark, children, context) {\n    const type = lookup(markTypes, mark.type);\n\n    if (!type) throw new ConversionError(`Unsupported Markdoc mark: ${mark.type}`, context.path);\n    if (mark.type === \"code\") {\n      if (children.some((node) => node.type !== \"text\"))\n        throw new ConversionError(\"Code marks must wrap plain text\", context.path);\n\n      return new Markdoc.Ast.Node(\"code\", {\n        content: children.map((node) => node.attributes.content).join(\"\")\n      });\n    }\n    return new Markdoc.Ast.Node(\n      type as MarkdocNode[\"type\"],\n      mark.type === \"link\" ? { href: mark.attrs?.href || \"\" } : {},\n      children\n    );\n  },\n  async decode(node, context) {\n    const attrs = node.attributes;\n\n    if (node.errors.length)\n      throw new ConversionError(`Invalid Markdoc: ${node.errors[0].message}`, context.path);\n    if (!isJSONValue(attrs))\n      throw new ConversionError(\n        \"Dynamic Markdoc attributes require a custom handler\",\n        context.path\n      );\n\n    const children = await context.children(node.children);\n    const mark = Object.entries(markTypes).find(([, type]) => type === node.type)?.[0];\n\n    if (mark === \"code\") return withMark(textNode(String(attrs.content || \"\")), { type: \"code\" });\n    if (mark)\n      return withMark(children, {\n        type: mark,\n        ...(mark === \"link\" ? { attrs: { href: attrs.href } } : {})\n      });\n\n    switch (node.type) {\n      case \"document\":\n      case \"inline\":\n      case \"thead\":\n      case \"tbody\":\n        return children;\n      case \"text\":\n        return textNode(String(attrs.content || \"\"));\n      case \"paragraph\":\n        return paragraphContent(children);\n      case \"heading\":\n        return { type: \"heading\", attrs: { level: attrs.level || 1 }, content: children };\n      case \"blockquote\":\n        return { type: \"blockquote\", content: children };\n      case \"list\":\n        return {\n          type: attrs.ordered ? \"orderedList\" : \"bulletList\",\n          ...(attrs.ordered ? { attrs: { start: attrs.start || 1 } } : {}),\n          content: children\n        };\n      case \"item\":\n        return { type: \"listItem\", content: paragraphContent(children) };\n      case \"fence\":\n        return {\n          type: \"codeBlock\",\n          attrs: { language: attrs.language || null },\n          content: textNode(String(attrs.content || \"\").replace(/\\n$/, \"\"))\n        };\n      case \"hardbreak\":\n        return { type: \"hardBreak\" };\n      case \"softbreak\":\n        return textNode(\"\\n\");\n      case \"hr\":\n        return { type: \"horizontalRule\" };\n      case \"image\":\n        return context.image({\n          url: String(attrs.src || \"\"),\n          alt: String(attrs.alt || \"\"),\n          title: attrs.title\n        });\n      case \"tag\":\n        return element(\n          node.tag || \"Element\",\n          attrs,\n          children.length ? paragraphContent(children) : []\n        );\n      case \"table\":\n        return { type: \"table\", content: children };\n      case \"tr\":\n        return { type: \"tableRow\", content: children };\n      case \"th\":\n      case \"td\":\n        return {\n          type: node.type === \"th\" ? \"tableHeader\" : \"tableCell\",\n          content: paragraphContent(children)\n        };\n      default:\n        throw new ConversionError(`Unsupported Markdoc syntax: ${node.type}`, context.path);\n    }\n  }\n};\n/**\n * Create a reusable async Markdoc converter with application-specific defaults.\n * @param options - Default mappings and handlers; per-call maps merge by key and callbacks may be async.\n * @returns String and AST import/export methods. Defaults use an H1 title, unwrap fragments, and omit properties.\n * Custom elements use Markdoc tags with static properties.\n */\nconst createMarkdocConverter = (options?: MarkdocOptions) =>\n  createConverter(markdocAdapter, options);\nconst converter = createMarkdocConverter();\n/**\n * Export ProseMirror JSON as Markdoc.\n * @param document - Entry or fragment document. Fragment wrappers are removed by default.\n * @param options - Title/property/fragment mappings and async handlers; imageURL resolves images.\n * @returns Serialized Markdoc. Omitted metadata and unwrapped fragment boundaries are not recoverable.\n * @throws ConversionError for unsupported content, unresolved images, or invalid mappings; handler errors pass through.\n */\nconst toMarkdoc = converter.encode;\n/**\n * Import Markdoc as ProseMirror JSON without saving content or uploading assets.\n * @param source - Source text to parse. Custom elements use Markdoc tags with static properties.\n * @param options - Import mappings and async handlers. imageAssetID must resolve image URLs.\n * @returns An entry document; use document: \"fragment\" to omit the title and retain the first H1 as body content.\n * @throws ConversionError for unsupported content/mappings; parser and handler errors pass through.\n */\nconst fromMarkdoc = converter.decode;\n/**\n * Export ProseMirror JSON as a Markdoc AST with separate frontmatter.\n * @param document - Source entry or fragment document.\n * @param options - Export mappings and async handlers, including imageURL for images.\n * @returns The format tree and metadata without string serialization.\n * @throws The same conversion errors as toMarkdoc(), including unsupported frontmatter mappings.\n */\nconst toMarkdocAST = converter.toAST;\n/**\n * Import a parsed Markdoc AST and its frontmatter as ProseMirror JSON.\n * @param input - Tree and frontmatter object; use an empty object when metadata is absent.\n * @param options - Import mappings and async handlers, including imageAssetID for images.\n * @returns An entry document by default, or a fragment document when requested.\n * @throws The same conversion errors as fromMarkdoc(), excluding string-parser errors.\n */\nconst fromMarkdocAST = converter.fromAST;\n\nexport {\n  createMarkdocConverter,\n  markdocAdapter,\n  toMarkdoc,\n  fromMarkdoc,\n  toMarkdocAST,\n  fromMarkdocAST\n};\nexport type { MarkdocNode, MarkdocOptions };\n"],"mappings":"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"}

package/dist/markdown.d.ts

@@ -0,0 +1,48 @@
+import { a as Converter, f as ExportConverterOptions, i as ConvertedAST, m as FormatAdapter, o as ConverterOptions, r as ContentNode, y as ImportConverterOptions } from "./chunks/types-SDFWRP3z.js";
+import { t as MarkdownNode } from "./chunks/decode-BLP2Olia.js";
+//#region src/markdown.d.ts
+type MarkdownOptions = ConverterOptions<MarkdownNode>;
+/** Markdown/GFM adapter for createConverter(), including its parser and node/mark mappings. */
+declare const markdownAdapter: FormatAdapter<MarkdownNode>;
+/**
+ * Create a reusable async Markdown/GFM converter with application-specific defaults.
+ * @param options - Default mappings and handlers; per-call maps merge by key and callbacks may be async.
+ * @returns String and AST import/export methods. Defaults use an H1 title, unwrap fragments, and omit properties.
+ * Markdown cannot preserve custom elements without handlers.
+ */
+declare const createMarkdownConverter: (options?: MarkdownOptions) => Converter<MarkdownNode>;
+/**
+ * Export ProseMirror JSON as Markdown/GFM.
+ * @param document - Entry or fragment document. Fragment wrappers are removed by default.
+ * @param options - Title/property/fragment mappings and async handlers; imageURL resolves images.
+ * @returns Serialized Markdown/GFM. Omitted metadata and unwrapped fragment boundaries are not recoverable.
+ * @throws ConversionError for unsupported content, unresolved images, or invalid mappings; handler errors pass through.
+ */
+declare const toMarkdown: (document: ContentNode, options?: ExportConverterOptions<MarkdownNode> | undefined) => Promise<string>;
+/**
+ * Import Markdown/GFM as ProseMirror JSON without saving content or uploading assets.
+ * @param source - Source text to parse. Markdown cannot preserve custom elements without handlers.
+ * @param options - Import mappings and async handlers. imageAssetID must resolve image URLs.
+ * @returns An entry document; use document: "fragment" to omit the title and retain the first H1 as body content.
+ * @throws ConversionError for unsupported content/mappings; parser and handler errors pass through.
+ */
+declare const fromMarkdown: (source: string, options?: ImportConverterOptions<MarkdownNode> | undefined) => Promise<ContentNode>;
+/**
+ * Export ProseMirror JSON as a Markdown/GFM AST with separate frontmatter.
+ * @param document - Source entry or fragment document.
+ * @param options - Export mappings and async handlers, including imageURL for images.
+ * @returns The format tree and metadata without string serialization.
+ * @throws The same conversion errors as toMarkdown(), including unsupported frontmatter mappings.
+ */
+declare const toMarkdownAST: (document: ContentNode, options?: ExportConverterOptions<MarkdownNode> | undefined) => Promise<ConvertedAST<MarkdownNode>>;
+/**
+ * Import a parsed Markdown/GFM AST and its frontmatter as ProseMirror JSON.
+ * @param input - Tree and frontmatter object; use an empty object when metadata is absent.
+ * @param options - Import mappings and async handlers, including imageAssetID for images.
+ * @returns An entry document by default, or a fragment document when requested.
+ * @throws The same conversion errors as fromMarkdown(), excluding string-parser errors.
+ */
+declare const fromMarkdownAST: (input: ConvertedAST<MarkdownNode>, options?: ImportConverterOptions<MarkdownNode> | undefined) => Promise<ContentNode>;
+//#endregion
+export { type MarkdownNode, type MarkdownOptions, createMarkdownConverter, fromMarkdown, fromMarkdownAST, markdownAdapter, toMarkdown, toMarkdownAST };
+//# sourceMappingURL=markdown.d.ts.map

package/dist/markdown.js

@@ -0,0 +1,49 @@
+import { t as createConverter } from "./chunks/core-DC64ddB7.js";
+import { t as createMarkdownAdapter } from "./chunks/adapter-CeNgvE5W.js";
+//#region src/markdown.ts
+/** Markdown/GFM adapter for createConverter(), including its parser and node/mark mappings. */
+const markdownAdapter = createMarkdownAdapter();
+/**
+* Create a reusable async Markdown/GFM converter with application-specific defaults.
+* @param options - Default mappings and handlers; per-call maps merge by key and callbacks may be async.
+* @returns String and AST import/export methods. Defaults use an H1 title, unwrap fragments, and omit properties.
+* Markdown cannot preserve custom elements without handlers.
+*/
+const createMarkdownConverter = (options) => createConverter(markdownAdapter, options);
+const converter = createMarkdownConverter();
+/**
+* Export ProseMirror JSON as Markdown/GFM.
+* @param document - Entry or fragment document. Fragment wrappers are removed by default.
+* @param options - Title/property/fragment mappings and async handlers; imageURL resolves images.
+* @returns Serialized Markdown/GFM. Omitted metadata and unwrapped fragment boundaries are not recoverable.
+* @throws ConversionError for unsupported content, unresolved images, or invalid mappings; handler errors pass through.
+*/
+const toMarkdown = converter.encode;
+/**
+* Import Markdown/GFM as ProseMirror JSON without saving content or uploading assets.
+* @param source - Source text to parse. Markdown cannot preserve custom elements without handlers.
+* @param options - Import mappings and async handlers. imageAssetID must resolve image URLs.
+* @returns An entry document; use document: "fragment" to omit the title and retain the first H1 as body content.
+* @throws ConversionError for unsupported content/mappings; parser and handler errors pass through.
+*/
+const fromMarkdown = converter.decode;
+/**
+* Export ProseMirror JSON as a Markdown/GFM AST with separate frontmatter.
+* @param document - Source entry or fragment document.
+* @param options - Export mappings and async handlers, including imageURL for images.
+* @returns The format tree and metadata without string serialization.
+* @throws The same conversion errors as toMarkdown(), including unsupported frontmatter mappings.
+*/
+const toMarkdownAST = converter.toAST;
+/**
+* Import a parsed Markdown/GFM AST and its frontmatter as ProseMirror JSON.
+* @param input - Tree and frontmatter object; use an empty object when metadata is absent.
+* @param options - Import mappings and async handlers, including imageAssetID for images.
+* @returns An entry document by default, or a fragment document when requested.
+* @throws The same conversion errors as fromMarkdown(), excluding string-parser errors.
+*/
+const fromMarkdownAST = converter.fromAST;
+//#endregion
+export { createMarkdownConverter, fromMarkdown, fromMarkdownAST, markdownAdapter, toMarkdown, toMarkdownAST };
+
+//# sourceMappingURL=markdown.js.map

package/dist/markdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.js","names":[],"sources":["../src/markdown.ts"],"sourcesContent":["import { createConverter } from \"./core\";\nimport { createMarkdownAdapter } from \"./markdown/adapter\";\nimport type { ConverterOptions } from \"./types\";\nimport type { MarkdownNode } from \"./markdown/decode\";\n\ntype MarkdownOptions = ConverterOptions<MarkdownNode>;\n\n/** Markdown/GFM adapter for createConverter(), including its parser and node/mark mappings. */\nconst markdownAdapter = createMarkdownAdapter();\n/**\n * Create a reusable async Markdown/GFM converter with application-specific defaults.\n * @param options - Default mappings and handlers; per-call maps merge by key and callbacks may be async.\n * @returns String and AST import/export methods. Defaults use an H1 title, unwrap fragments, and omit properties.\n * Markdown cannot preserve custom elements without handlers.\n */\nconst createMarkdownConverter = (options?: MarkdownOptions) =>\n  createConverter(markdownAdapter, options);\nconst converter = createMarkdownConverter();\n/**\n * Export ProseMirror JSON as Markdown/GFM.\n * @param document - Entry or fragment document. Fragment wrappers are removed by default.\n * @param options - Title/property/fragment mappings and async handlers; imageURL resolves images.\n * @returns Serialized Markdown/GFM. Omitted metadata and unwrapped fragment boundaries are not recoverable.\n * @throws ConversionError for unsupported content, unresolved images, or invalid mappings; handler errors pass through.\n */\nconst toMarkdown = converter.encode;\n/**\n * Import Markdown/GFM as ProseMirror JSON without saving content or uploading assets.\n * @param source - Source text to parse. Markdown cannot preserve custom elements without handlers.\n * @param options - Import mappings and async handlers. imageAssetID must resolve image URLs.\n * @returns An entry document; use document: \"fragment\" to omit the title and retain the first H1 as body content.\n * @throws ConversionError for unsupported content/mappings; parser and handler errors pass through.\n */\nconst fromMarkdown = converter.decode;\n/**\n * Export ProseMirror JSON as a Markdown/GFM AST with separate frontmatter.\n * @param document - Source entry or fragment document.\n * @param options - Export mappings and async handlers, including imageURL for images.\n * @returns The format tree and metadata without string serialization.\n * @throws The same conversion errors as toMarkdown(), including unsupported frontmatter mappings.\n */\nconst toMarkdownAST = converter.toAST;\n/**\n * Import a parsed Markdown/GFM AST and its frontmatter as ProseMirror JSON.\n * @param input - Tree and frontmatter object; use an empty object when metadata is absent.\n * @param options - Import mappings and async handlers, including imageAssetID for images.\n * @returns An entry document by default, or a fragment document when requested.\n * @throws The same conversion errors as fromMarkdown(), excluding string-parser errors.\n */\nconst fromMarkdownAST = converter.fromAST;\n\nexport {\n  createMarkdownConverter,\n  markdownAdapter,\n  toMarkdown,\n  fromMarkdown,\n  toMarkdownAST,\n  fromMarkdownAST\n};\nexport type { MarkdownOptions, MarkdownNode };\n"],"mappings":";;;;AAQA,MAAM,kBAAkB,sBAAsB;;;;;;;AAO9C,MAAM,2BAA2B,YAC/B,gBAAgB,iBAAiB,OAAO;AAC1C,MAAM,YAAY,wBAAwB;;;;;;;;AAQ1C,MAAM,aAAa,UAAU;;;;;;;;AAQ7B,MAAM,eAAe,UAAU;;;;;;;;AAQ/B,MAAM,gBAAgB,UAAU;;;;;;;;AAQhC,MAAM,kBAAkB,UAAU"}

package/dist/mdx.d.ts

@@ -0,0 +1,50 @@
+import { a as Converter, f as ExportConverterOptions, i as ConvertedAST, m as FormatAdapter, o as ConverterOptions, r as ContentNode, y as ImportConverterOptions } from "./chunks/types-SDFWRP3z.js";
+import { t as MarkdownNode } from "./chunks/decode-BLP2Olia.js";
+import { MdxJsxFlowElement } from "mdast-util-mdx-jsx";
+//#region src/mdx.d.ts
+type MDXNode = MarkdownNode | MdxJsxFlowElement;
+type MDXOptions = ConverterOptions<MDXNode>;
+/** MDX adapter for createConverter(), including its parser and node/mark mappings. */
+declare const mdxAdapter: FormatAdapter<MDXNode>;
+/**
+ * Create a reusable async MDX converter with application-specific defaults.
+ * @param options - Default mappings and handlers; per-call maps merge by key and callbacks may be async.
+ * @returns String and AST import/export methods. Defaults use an H1 title, unwrap fragments, and omit properties.
+ * Custom elements use static JSON properties; executable expressions require custom handlers.
+ */
+declare const createMDXConverter: (options?: MDXOptions) => Converter<MDXNode>;
+/**
+ * Export ProseMirror JSON as MDX.
+ * @param document - Entry or fragment document. Fragment wrappers are removed by default.
+ * @param options - Title/property/fragment mappings and async handlers; imageURL resolves images.
+ * @returns Serialized MDX. Omitted metadata and unwrapped fragment boundaries are not recoverable.
+ * @throws ConversionError for unsupported content, unresolved images, or invalid mappings; handler errors pass through.
+ */
+declare const toMDX: (document: ContentNode, options?: ExportConverterOptions<MDXNode> | undefined) => Promise<string>;
+/**
+ * Import MDX as ProseMirror JSON without saving content or uploading assets.
+ * @param source - Source text to parse. Custom elements use static JSON properties; executable expressions require custom handlers.
+ * @param options - Import mappings and async handlers. imageAssetID must resolve image URLs.
+ * @returns An entry document; use document: "fragment" to omit the title and retain the first H1 as body content.
+ * @throws ConversionError for unsupported content/mappings; parser and handler errors pass through.
+ */
+declare const fromMDX: (source: string, options?: ImportConverterOptions<MDXNode> | undefined) => Promise<ContentNode>;
+/**
+ * Export ProseMirror JSON as a MDX AST with separate frontmatter.
+ * @param document - Source entry or fragment document.
+ * @param options - Export mappings and async handlers, including imageURL for images.
+ * @returns The format tree and metadata without string serialization.
+ * @throws The same conversion errors as toMDX(), including unsupported frontmatter mappings.
+ */
+declare const toMDXAST: (document: ContentNode, options?: ExportConverterOptions<MDXNode> | undefined) => Promise<ConvertedAST<MDXNode>>;
+/**
+ * Import a parsed MDX AST and its frontmatter as ProseMirror JSON.
+ * @param input - Tree and frontmatter object; use an empty object when metadata is absent.
+ * @param options - Import mappings and async handlers, including imageAssetID for images.
+ * @returns An entry document by default, or a fragment document when requested.
+ * @throws The same conversion errors as fromMDX(), excluding string-parser errors.
+ */
+declare const fromMDXAST: (input: ConvertedAST<MDXNode>, options?: ImportConverterOptions<MDXNode> | undefined) => Promise<ContentNode>;
+//#endregion
+export { type MDXNode, type MDXOptions, createMDXConverter, fromMDX, fromMDXAST, mdxAdapter, toMDX, toMDXAST };
+//# sourceMappingURL=mdx.d.ts.map