@andesine/converters 0.1.0

package/dist/chunks/types-SDFWRP3z.d.ts

@@ -0,0 +1,185 @@
+//#region src/types.d.ts
+interface ContentMark {
+  type: string;
+  attrs?: Record<string, unknown>;
+}
+interface ContentNode {
+  type: string;
+  attrs?: Record<string, unknown>;
+  content?: ContentNode[];
+  marks?: ContentMark[];
+  text?: string;
+}
+interface ImageReference {
+  url: string;
+  alt: string;
+  title?: string;
+}
+interface EncodeContext<T> {
+  /** Generated heading anchor for this node, when available. Stable within the full document. */
+  anchor?: string;
+  /** Merged factory defaults and per-call options. */
+  options: ExportConverterOptions<T>;
+  /** Child indexes identifying the current node in the source document. */
+  path: readonly number[];
+  /** Encode another node at the current path, applying custom handlers and marks. */
+  encode(node: ContentNode): Promise<T[]>;
+  /** Encode child nodes in order, updating their paths and awaiting async handlers. */
+  children(node: ContentNode): Promise<T[]>;
+  /** Resolve an image through imageURL; throws ConversionError if no URL is supplied. */
+  imageURL(node: ContentNode): Promise<string>;
+}
+interface DecodeContext<T> {
+  /** Merged factory defaults and per-call options. */
+  options: ImportConverterOptions<T>;
+  /** Child indexes identifying the current node in the parsed tree. */
+  path: readonly number[];
+  /** Decode another format node at the current path, applying custom handlers. */
+  decode(node: T): Promise<ContentNode[]>;
+  /** Decode child nodes in order, updating their paths and awaiting async handlers. */
+  children(nodes: readonly T[]): Promise<ContentNode[]>;
+  /** Resolve a URL through imageAssetID and create an image node; does not upload assets. */
+  image(reference: ImageReference): Promise<ContentNode>;
+}
+interface EncodeHandlers<T> {
+  /** Handlers keyed by ProseMirror node type. "*" handles otherwise unmatched node types. */
+  nodes?: Record<string, (node: ContentNode, context: EncodeContext<T>) => Awaitable<HandlerResult<T>>>;
+  /** Handlers keyed by Andesine element name; exact and "*" matches precede node handlers. */
+  elements?: Record<string, (node: ContentNode, context: EncodeContext<T>) => Awaitable<HandlerResult<T>>>;
+  /** Handlers keyed by mark type, with "*" as fallback. Receives already encoded children. */
+  marks?: Record<string, (mark: ContentMark, children: T[], context: EncodeContext<T>) => Awaitable<HandlerResult<T>>>;
+}
+interface DecodeHandlers<T> {
+  /** Handlers keyed by adapter node type, with "*" as fallback. */
+  nodes?: Record<string, (node: T, context: DecodeContext<T>) => Awaitable<HandlerResult<ContentNode>>>;
+  /** Element-name handlers, including "*", checked before mark-name and node-type handlers. */
+  elements?: Record<string, (node: T, context: DecodeContext<T>) => Awaitable<HandlerResult<ContentNode>>>;
+  /** Mark-name handlers, including "*", checked after element handlers and before node handlers. */
+  marks?: Record<string, (node: T, context: DecodeContext<T>) => Awaitable<HandlerResult<ContentNode>>>;
+}
+interface BaseConverterOptions {
+  /** Map the title to an H1 by default, omit it, or use frontmatter in supported formats. */
+  title?: "heading" | "omit" | {
+    as: "frontmatter";
+    key?: string;
+  };
+  /** Omit properties by default, or map labels and values to frontmatter. Duplicate keys throw. */
+  properties?: "omit" | {
+    as: "frontmatter";
+  };
+  /** Fragment mappings. Defaults to unwrapping content; unwrapped boundaries cannot be restored. */
+  fragments?: {
+    /** Fallback for fragments without a named mapping. Defaults to "unwrap". */
+    default?: FragmentMapping;
+    /** Overrides keyed by fragment name, merged by key with factory defaults. */
+    named?: Record<string, FragmentMapping>;
+  };
+}
+/** Options used only when exporting ProseMirror JSON to another format. */
+interface ExportConverterOptions<T> extends BaseConverterOptions {
+  /** Resolve an image asset to a URL during export. Required for image output except plain text. */
+  imageURL?: (node: ContentNode) => Awaitable<string>;
+  /** Export handlers. Return one node, multiple nodes, or null to omit; async handlers are awaited. */
+  encode?: EncodeHandlers<T>;
+}
+/** Options used only when importing another format as ProseMirror JSON. */
+interface ImportConverterOptions<T> extends BaseConverterOptions {
+  /** Import an entry with a title by default, or a fragment without consuming an H1 as title. */
+  document?: "entry" | "fragment";
+  /** On import, wrap body content in this named fragment. Defaults to leaving it unwrapped. */
+  targetFragment?: string;
+  /** Resolve an imported image URL to an existing asset ID. Uploading/saving is the caller's job. */
+  imageAssetID?: (image: ImageReference) => Awaitable<string>;
+  /** Import handlers. Handler maps merge by key with factory defaults; async handlers are awaited. */
+  decode?: DecodeHandlers<T>;
+}
+/** Defaults for a converter that supports both directions. */
+interface ConverterOptions<T> extends ExportConverterOptions<T>, ImportConverterOptions<T> {}
+interface ConvertedAST<T> {
+  /** Target format tree, without serialized frontmatter. */
+  tree: T;
+  /** Metadata extracted or supplied through title and property mappings. */
+  frontmatter: Record<string, unknown>;
+}
+/** Export-only methods. Import methods are absent both in TypeScript and at runtime. */
+interface ExportConverter<T> {
+  /**
+   * Export ProseMirror JSON as a format string.
+   * @param document - An entry or fragment document.
+   * @param options - Per-call overrides; handler maps and named fragments merge with defaults.
+   * @returns Serialized content, including mapped frontmatter when supported.
+   * @throws ConversionError for unsupported content, unresolved images, or invalid mappings.
+   * Custom handler and serializer failures pass through unchanged.
+   */
+  encode(document: ContentNode, options?: ExportConverterOptions<T>): Promise<string>;
+  /**
+   * Export a document as the target format's AST and separate frontmatter.
+   * @param document - Source ProseMirror document.
+   * @param options - Per-call mappings and handlers merged over factory defaults.
+   * @returns The converted tree and metadata without string serialization.
+   * @throws The same conversion errors as encode(), including unsupported frontmatter mappings.
+   */
+  toAST(document: ContentNode, options?: ExportConverterOptions<T>): Promise<ConvertedAST<T>>;
+}
+/** Import-only methods. Export methods are absent both in TypeScript and at runtime. */
+interface ImportConverter<T> {
+  /**
+   * Import a format string as ProseMirror JSON.
+   * @param source - Text in the adapter's format, with optional supported frontmatter.
+   * @param options - Per-call overrides; imageAssetID resolves imported images without uploading.
+   * @returns An entry document by default; document: "fragment" omits the title node.
+   * @throws ConversionError for unsupported content or mappings; parser/handler errors pass through.
+   */
+  decode(source: string, options?: ImportConverterOptions<T>): Promise<ContentNode>;
+  /**
+   * Import an already parsed AST and its metadata.
+   * @param input - Format tree and frontmatter object; use an empty object when metadata is absent.
+   * @param options - Per-call mappings and handlers merged over factory defaults.
+   * @returns ProseMirror JSON without parsing a string or saving content.
+   * @throws The same conversion errors as decode(), excluding string-parser errors.
+   */
+  fromAST(input: ConvertedAST<T>, options?: ImportConverterOptions<T>): Promise<ContentNode>;
+}
+/** Shared conversion methods returned by the full format factories. No method saves or uploads content. */
+interface Converter<T> extends ExportConverter<T>, ImportConverter<T> {}
+interface BaseFormatAdapter {
+  /** Human-readable format name used in errors. */
+  name: string;
+  /** Whether the format supports frontmatter mappings. Defaults to false. */
+  frontmatter?: boolean;
+}
+/** Export adapter: no parser, decode handler, or format-node lookup is required. */
+interface ExportFormatAdapter<T> extends BaseFormatAdapter {
+  /** Wrap converted child nodes in the format's root node. */
+  root(children: T[]): T;
+  /** Serialize the format tree; the shared converter writes frontmatter separately. */
+  stringify(tree: T): Awaitable<string>;
+  /** Encode a node without a custom handler. Shared title/property/fragment mappings run first. */
+  encode(node: ContentNode, context: EncodeContext<T>): Awaitable<HandlerResult<T>>;
+  /** Apply a mark to encoded children when no custom mark handler matches. */
+  mark(mark: ContentMark, children: T[], context: EncodeContext<T>): Awaitable<HandlerResult<T>>;
+}
+/** Import adapter: no root builder, serializer, encode handler, or mark writer is required. */
+interface ImportFormatAdapter<T> extends BaseFormatAdapter {
+  /** Return the format node type used to select decode node handlers. */
+  type(node: T): string;
+  /** Return a custom element name for decode element-handler lookup, if present. */
+  elementName?(node: T): string | undefined;
+  /** Return a mark name for decode mark-handler lookup, if present. */
+  markName?(node: T): string | undefined;
+  /** Parse source text after the shared converter removes supported frontmatter. */
+  parse(source: string): Awaitable<T>;
+  /** Decode a format node when no custom decode handler matches. */
+  decode(node: T, context: DecodeContext<T>): Awaitable<HandlerResult<ContentNode>>;
+}
+/** Adapter contract for a format supporting both import and export. */
+interface FormatAdapter<T> extends ExportFormatAdapter<T>, ImportFormatAdapter<T> {}
+type Awaitable<T> = T | Promise<T>;
+type HandlerResult<T> = T | T[] | null;
+type FragmentMapping = "unwrap" | "omit" | {
+  as: "element";
+  name: string;
+};
+//#endregion
+export { ImageReference as _, Converter as a, ImportFormatAdapter as b, DecodeHandlers as c, ExportConverter as d, ExportConverterOptions as f, HandlerResult as g, FragmentMapping as h, ConvertedAST as i, EncodeContext as l, FormatAdapter as m, ContentMark as n, ConverterOptions as o, ExportFormatAdapter as p, ContentNode as r, DecodeContext as s, Awaitable as t, EncodeHandlers as u, ImportConverter as v, ImportConverterOptions as y };
+//# sourceMappingURL=types-SDFWRP3z.d.ts.map

package/dist/html.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 { Root, RootContent } from "hast";
+//#region src/html.d.ts
+type HTMLNode = Root | RootContent;
+type HTMLOptions = ConverterOptions<HTMLNode>;
+/** HTML adapter for createConverter(), including its parser and node/mark mappings. */
+declare const htmlAdapter: FormatAdapter<HTMLNode>;
+/**
+ * Create a reusable async HTML 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 Andesine data attributes; frontmatter mappings are not supported.
+ */
+declare const createHTMLConverter: (options?: HTMLOptions) => Converter<HTMLNode>;
+/**
+ * Export ProseMirror JSON as HTML.
+ * @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 HTML. 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 toHTML: (document: ContentNode, options?: ExportConverterOptions<HTMLNode> | undefined) => Promise<string>;
+/**
+ * Import HTML as ProseMirror JSON without saving content or uploading assets.
+ * @param source - Source text to parse. Custom elements use Andesine data attributes; frontmatter mappings are not supported.
+ * @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 fromHTML: (source: string, options?: ImportConverterOptions<HTMLNode> | undefined) => Promise<ContentNode>;
+/**
+ * Export ProseMirror JSON as a HTML 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 toHTML(), including unsupported frontmatter mappings.
+ */
+declare const toHTMLAST: (document: ContentNode, options?: ExportConverterOptions<HTMLNode> | undefined) => Promise<ConvertedAST<HTMLNode>>;
+/**
+ * Import a parsed HTML 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 fromHTML(), excluding string-parser errors.
+ */
+declare const fromHTMLAST: (input: ConvertedAST<HTMLNode>, options?: ImportConverterOptions<HTMLNode> | undefined) => Promise<ContentNode>;
+//#endregion
+export { type HTMLNode, type HTMLOptions, createHTMLConverter, fromHTML, fromHTMLAST, htmlAdapter, toHTML, toHTMLAST };
+//# sourceMappingURL=html.d.ts.map

package/dist/html.js

@@ -0,0 +1,252 @@
+import { a as element, c as textContent, i as ConversionError, l as textNode, 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 { fromHtml } from "hast-util-from-html";
+import { toHtml } from "hast-util-to-html";
+//#region src/html.ts
+const tag = (tagName, children = [], properties = {}) => ({
+	type: "element",
+	tagName,
+	properties,
+	children
+});
+const htmlText = (node) => node.type === "text" ? node.value : "children" in node ? node.children.map(htmlText).join("") : "";
+const safeURL = (value, image = false) => {
+	const url = new URL(value, "https://example.com");
+	if (!(image ? ["http:", "https:"] : [
+		"http:",
+		"https:",
+		"mailto:",
+		"tel:"
+	]).includes(url.protocol)) throw new ConversionError(`Unsupported URL protocol: ${url.protocol}`);
+	return value;
+};
+const htmlMarks = {
+	strong: "bold",
+	b: "bold",
+	em: "italic",
+	i: "italic",
+	s: "strike",
+	del: "strike",
+	code: "code",
+	a: "link",
+	sub: "subscript",
+	sup: "superscript",
+	mark: "highlight"
+};
+/** HTML adapter for createConverter(), including its parser and node/mark mappings. */
+const htmlAdapter = {
+	name: "HTML",
+	type: (node) => node.type === "element" ? node.tagName : node.type,
+	elementName: (node) => node.type === "element" ? String(node.properties.dataAndesineElement || node.tagName) : void 0,
+	markName: (node) => node.type === "element" ? lookup(htmlMarks, node.tagName) : void 0,
+	root: (children) => ({
+		type: "root",
+		children
+	}),
+	parse: (source) => fromHtml(source, { fragment: true }),
+	stringify: (tree) => toHtml(tree),
+	async encode(node, context) {
+		const attrs = node.attrs || {};
+		const children = await context.children(node);
+		switch (node.type) {
+			case "text": return {
+				type: "text",
+				value: node.text || ""
+			};
+			case "paragraph": return tag("p", children);
+			case "heading": return tag(`h${Math.max(1, Math.min(6, Number(attrs.level || 1)))}`, children, context.anchor ? { id: context.anchor } : {});
+			case "blockquote": return tag("blockquote", children);
+			case "bulletList": return tag("ul", children);
+			case "orderedList": return tag("ol", children, { start: Number(attrs.start || 1) });
+			case "taskList": return tag("ul", children, { dataType: "taskList" });
+			case "listItem": return tag("li", children);
+			case "taskItem": return tag("li", children, {
+				dataType: "taskItem",
+				dataChecked: Boolean(attrs.checked) ? "true" : "false"
+			});
+			case "hardBreak": return tag("br");
+			case "horizontalRule": return tag("hr");
+			case "codeBlock": return tag("pre", [tag("code", [{
+				type: "text",
+				value: textContent(node)
+			}], { dataLanguage: String(attrs.language || "") })]);
+			case "image": {
+				const image = tag("img", [], {
+					src: safeURL(await context.imageURL(node), true),
+					alt: String(attrs.alt || "")
+				});
+				return attrs.caption ? tag("figure", [image, tag("figcaption", [{
+					type: "text",
+					value: String(attrs.caption)
+				}])]) : image;
+			}
+			case "table": return tag("table", [tag("tbody", children)]);
+			case "tableRow": return tag("tr", children);
+			case "tableCell":
+			case "tableHeader": return tag(node.type === "tableHeader" ? "th" : "td", children, {
+				colSpan: Number(attrs.colspan || 1),
+				rowSpan: Number(attrs.rowspan || 1)
+			});
+			case "element": return tag("div", children, {
+				dataAndesineElement: String(attrs.name || "Element"),
+				dataAndesineProps: JSON.stringify(attrs.props || {})
+			});
+			default: throw new ConversionError(`Unsupported HTML node: ${node.type}`, context.path);
+		}
+	},
+	mark(mark, children, context) {
+		const name = Object.entries(htmlMarks).find(([, type]) => type === mark.type)?.[0];
+		if (!name) throw new ConversionError(`Unsupported HTML mark: ${mark.type}`, context.path);
+		return tag(name, children, mark.type === "link" ? { href: safeURL(String(mark.attrs?.href || "")) } : {});
+	},
+	async decode(node, context) {
+		if (node.type === "text") return textNode(node.value.replace(/[ \t\r\n\f]+/g, " "));
+		if (node.type !== "root" && node.type !== "element") throw new ConversionError(`Unsupported HTML syntax: ${node.type}`, context.path);
+		const name = node.type === "element" ? node.tagName : "root";
+		const props = node.type === "element" ? node.properties : {};
+		if (name === "pre") {
+			const code = node.children.find((child) => child.type === "element" && child.tagName === "code");
+			return {
+				type: "codeBlock",
+				attrs: { language: (code?.type === "element" ? code.properties.dataLanguage || String(code.properties.className || "").match(/language-([\w+-]+)/)?.[1] : void 0) || null },
+				content: textNode(htmlText(node))
+			};
+		}
+		if (name === "img") return context.image({
+			url: safeURL(String(props.src || ""), true),
+			alt: String(props.alt || ""),
+			title: props.title ? String(props.title) : void 0
+		});
+		if (name === "figure") {
+			const image = node.children.find((child) => child.type === "element" && child.tagName === "img");
+			const caption = node.children.find((child) => child.type === "element" && child.tagName === "figcaption");
+			if (!image || image.type !== "element") throw new ConversionError("HTML figures require an image", context.path);
+			return context.image({
+				url: safeURL(String(image.properties.src || ""), true),
+				alt: String(image.properties.alt || ""),
+				title: caption ? htmlText(caption) : void 0
+			});
+		}
+		const blockContainer = [
+			"root",
+			"div",
+			"section",
+			"article",
+			"main",
+			"ul",
+			"ol",
+			"table",
+			"thead",
+			"tbody",
+			"tfoot",
+			"tr",
+			"blockquote"
+		].includes(name);
+		const decoded = await context.children(node.children);
+		const children = blockContainer ? decoded.filter((child, index) => {
+			if (child.type !== "text" || /[^ \t\r\n\f]/.test(child.text || "")) return true;
+			return [decoded[index - 1], decoded[index + 1]].every((sibling) => sibling && ["text", "hardBreak"].includes(sibling.type));
+		}) : decoded;
+		const mark = lookup(htmlMarks, name);
+		if (props.dataAndesineElement) return element(String(props.dataAndesineElement), JSON.parse(String(props.dataAndesineProps || "{}")), children);
+		if (mark) return withMark(children, {
+			type: mark,
+			...mark === "link" ? { attrs: { href: safeURL(String(props.href || "")) } } : {}
+		});
+		if (/^h[1-6]$/.test(name)) return {
+			type: "heading",
+			attrs: { level: Number(name[1]) },
+			content: children
+		};
+		switch (name) {
+			case "root":
+			case "div":
+			case "section":
+			case "article":
+			case "main": return paragraphContent(children);
+			case "thead":
+			case "tbody":
+			case "tfoot": return children;
+			case "p": return paragraphContent(children);
+			case "blockquote": return {
+				type: "blockquote",
+				content: paragraphContent(children)
+			};
+			case "ul":
+			case "ol": return {
+				type: name === "ol" ? "orderedList" : props.dataType === "taskList" ? "taskList" : "bulletList",
+				...name === "ol" ? { attrs: { start: Number(props.start || 1) } } : {},
+				content: children
+			};
+			case "li": return {
+				type: props.dataType === "taskItem" ? "taskItem" : "listItem",
+				...props.dataType === "taskItem" ? { attrs: { checked: props.dataChecked === "true" } } : {},
+				content: paragraphContent(children)
+			};
+			case "br": return { type: "hardBreak" };
+			case "hr": return { type: "horizontalRule" };
+			case "table": return {
+				type: "table",
+				content: children
+			};
+			case "tr": return {
+				type: "tableRow",
+				content: children
+			};
+			case "th":
+			case "td": return {
+				type: name === "th" ? "tableHeader" : "tableCell",
+				attrs: {
+					colspan: Number(props.colSpan || 1),
+					rowspan: Number(props.rowSpan || 1)
+				},
+				content: paragraphContent(children)
+			};
+			default: throw new ConversionError(`Unsupported HTML element: ${name}`, context.path);
+		}
+	}
+};
+/**
+* Create a reusable async HTML 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 Andesine data attributes; frontmatter mappings are not supported.
+*/
+const createHTMLConverter = (options) => createConverter(htmlAdapter, options);
+const converter = createHTMLConverter();
+/**
+* Export ProseMirror JSON as HTML.
+* @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 HTML. Omitted metadata and unwrapped fragment boundaries are not recoverable.
+* @throws ConversionError for unsupported content, unresolved images, or invalid mappings; handler errors pass through.
+*/
+const toHTML = converter.encode;
+/**
+* Import HTML as ProseMirror JSON without saving content or uploading assets.
+* @param source - Source text to parse. Custom elements use Andesine data attributes; frontmatter mappings are not supported.
+* @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 fromHTML = converter.decode;
+/**
+* Export ProseMirror JSON as a HTML 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 toHTML(), including unsupported frontmatter mappings.
+*/
+const toHTMLAST = converter.toAST;
+/**
+* Import a parsed HTML 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 fromHTML(), excluding string-parser errors.
+*/
+const fromHTMLAST = converter.fromAST;
+//#endregion
+export { createHTMLConverter, fromHTML, fromHTMLAST, htmlAdapter, toHTML, toHTMLAST };
+
+//# sourceMappingURL=html.js.map

package/dist/html.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.js","names":[],"sources":["../src/html.ts"],"sourcesContent":["import { fromHtml } from \"hast-util-from-html\";\nimport { toHtml } from \"hast-util-to-html\";\nimport type { Element, ElementContent, Properties, Root, RootContent } from \"hast\";\nimport { createConverter } from \"./core\";\nimport { paragraphContent } from \"./markdown/decode\";\nimport { ConversionError, lookup, element, textContent, textNode, withMark } from \"./utils\";\nimport type { ConverterOptions, FormatAdapter } from \"./types\";\n\ntype HTMLNode = Root | RootContent;\ntype HTMLOptions = ConverterOptions<HTMLNode>;\n\nconst tag = (tagName: string, children: HTMLNode[] = [], properties: Properties = {}): Element => ({\n  type: \"element\",\n  tagName,\n  properties,\n  children: children as ElementContent[]\n});\nconst htmlText = (node: HTMLNode): string =>\n  node.type === \"text\"\n    ? node.value\n    : \"children\" in node\n      ? node.children.map(htmlText).join(\"\")\n      : \"\";\nconst safeURL = (value: string, image = false): string => {\n  const url = new URL(value, \"https://example.com\");\n  const allowed = image ? [\"http:\", \"https:\"] : [\"http:\", \"https:\", \"mailto:\", \"tel:\"];\n\n  if (!allowed.includes(url.protocol))\n    throw new ConversionError(`Unsupported URL protocol: ${url.protocol}`);\n\n  return value;\n};\nconst htmlMarks: Record<string, string> = {\n  strong: \"bold\",\n  b: \"bold\",\n  em: \"italic\",\n  i: \"italic\",\n  s: \"strike\",\n  del: \"strike\",\n  code: \"code\",\n  a: \"link\",\n  sub: \"subscript\",\n  sup: \"superscript\",\n  mark: \"highlight\"\n};\n/** HTML adapter for createConverter(), including its parser and node/mark mappings. */\nconst htmlAdapter: FormatAdapter<HTMLNode> = {\n  name: \"HTML\",\n  type: (node) => (node.type === \"element\" ? node.tagName : node.type),\n  elementName: (node) =>\n    node.type === \"element\"\n      ? String(node.properties.dataAndesineElement || node.tagName)\n      : undefined,\n  markName: (node) => (node.type === \"element\" ? lookup(htmlMarks, node.tagName) : undefined),\n  root: (children) => ({ type: \"root\", children: children as RootContent[] }),\n  parse: (source) => fromHtml(source, { fragment: true }),\n  stringify: (tree) => toHtml(tree),\n  async encode(node, context) {\n    const attrs = node.attrs || {};\n    const children = await context.children(node);\n\n    switch (node.type) {\n      case \"text\":\n        return { type: \"text\", value: node.text || \"\" };\n      case \"paragraph\":\n        return tag(\"p\", children);\n      case \"heading\":\n        return tag(\n          `h${Math.max(1, Math.min(6, Number(attrs.level || 1)))}`,\n          children,\n          context.anchor ? { id: context.anchor } : {}\n        );\n      case \"blockquote\":\n        return tag(\"blockquote\", children);\n      case \"bulletList\":\n        return tag(\"ul\", children);\n      case \"orderedList\":\n        return tag(\"ol\", children, { start: Number(attrs.start || 1) });\n      case \"taskList\":\n        return tag(\"ul\", children, { dataType: \"taskList\" });\n      case \"listItem\":\n        return tag(\"li\", children);\n      case \"taskItem\":\n        return tag(\"li\", children, {\n          dataType: \"taskItem\",\n          dataChecked: Boolean(attrs.checked) ? \"true\" : \"false\"\n        });\n      case \"hardBreak\":\n        return tag(\"br\");\n      case \"horizontalRule\":\n        return tag(\"hr\");\n      case \"codeBlock\":\n        return tag(\"pre\", [\n          tag(\"code\", [{ type: \"text\", value: textContent(node) }], {\n            dataLanguage: String(attrs.language || \"\")\n          })\n        ]);\n      case \"image\": {\n        const image = tag(\"img\", [], {\n          src: safeURL(await context.imageURL(node), true),\n          alt: String(attrs.alt || \"\")\n        });\n\n        return attrs.caption\n          ? tag(\"figure\", [\n              image,\n              tag(\"figcaption\", [{ type: \"text\", value: String(attrs.caption) }])\n            ])\n          : image;\n      }\n      case \"table\":\n        return tag(\"table\", [tag(\"tbody\", children)]);\n      case \"tableRow\":\n        return tag(\"tr\", children);\n      case \"tableCell\":\n      case \"tableHeader\":\n        return tag(node.type === \"tableHeader\" ? \"th\" : \"td\", children, {\n          colSpan: Number(attrs.colspan || 1),\n          rowSpan: Number(attrs.rowspan || 1)\n        });\n      case \"element\":\n        return tag(\"div\", children, {\n          dataAndesineElement: String(attrs.name || \"Element\"),\n          dataAndesineProps: JSON.stringify(attrs.props || {})\n        });\n      default:\n        throw new ConversionError(`Unsupported HTML node: ${node.type}`, context.path);\n    }\n  },\n  mark(mark, children, context) {\n    const name = Object.entries(htmlMarks).find(([, type]) => type === mark.type)?.[0];\n\n    if (!name) throw new ConversionError(`Unsupported HTML mark: ${mark.type}`, context.path);\n\n    return tag(\n      name,\n      children,\n      mark.type === \"link\" ? { href: safeURL(String(mark.attrs?.href || \"\")) } : {}\n    );\n  },\n  async decode(node, context) {\n    if (node.type === \"text\") return textNode(node.value.replace(/[ \\t\\r\\n\\f]+/g, \" \"));\n    if (node.type !== \"root\" && node.type !== \"element\")\n      throw new ConversionError(`Unsupported HTML syntax: ${node.type}`, context.path);\n\n    const name = node.type === \"element\" ? node.tagName : \"root\";\n    const props = node.type === \"element\" ? node.properties : {};\n\n    if (name === \"pre\") {\n      const code = node.children.find(\n        (child) => child.type === \"element\" && child.tagName === \"code\"\n      );\n      const language =\n        code?.type === \"element\"\n          ? code.properties.dataLanguage ||\n            String(code.properties.className || \"\").match(/language-([\\w+-]+)/)?.[1]\n          : undefined;\n\n      return {\n        type: \"codeBlock\",\n        attrs: { language: language || null },\n        content: textNode(htmlText(node))\n      };\n    }\n    if (name === \"img\")\n      return context.image({\n        url: safeURL(String(props.src || \"\"), true),\n        alt: String(props.alt || \"\"),\n        title: props.title ? String(props.title) : undefined\n      });\n    if (name === \"figure\") {\n      const image = node.children.find(\n        (child) => child.type === \"element\" && child.tagName === \"img\"\n      );\n      const caption = node.children.find(\n        (child) => child.type === \"element\" && child.tagName === \"figcaption\"\n      );\n\n      if (!image || image.type !== \"element\")\n        throw new ConversionError(\"HTML figures require an image\", context.path);\n\n      return context.image({\n        url: safeURL(String(image.properties.src || \"\"), true),\n        alt: String(image.properties.alt || \"\"),\n        title: caption ? htmlText(caption) : undefined\n      });\n    }\n    const blockContainer = [\n      \"root\",\n      \"div\",\n      \"section\",\n      \"article\",\n      \"main\",\n      \"ul\",\n      \"ol\",\n      \"table\",\n      \"thead\",\n      \"tbody\",\n      \"tfoot\",\n      \"tr\",\n      \"blockquote\"\n    ].includes(name);\n    const decoded = await context.children(node.children);\n    const children = blockContainer\n      ? decoded.filter((child, index) => {\n          if (child.type !== \"text\" || /[^ \\t\\r\\n\\f]/.test(child.text || \"\")) return true;\n\n          // Keep word separators inside inline runs, but omit indentation around blocks.\n          return [decoded[index - 1], decoded[index + 1]].every(\n            (sibling) => sibling && [\"text\", \"hardBreak\"].includes(sibling.type)\n          );\n        })\n      : decoded;\n    const mark = lookup(htmlMarks, name);\n\n    if (props.dataAndesineElement) {\n      return element(\n        String(props.dataAndesineElement),\n        JSON.parse(String(props.dataAndesineProps || \"{}\")),\n        children\n      );\n    }\n    if (mark)\n      return withMark(children, {\n        type: mark,\n        ...(mark === \"link\" ? { attrs: { href: safeURL(String(props.href || \"\")) } } : {})\n      });\n    if (/^h[1-6]$/.test(name))\n      return { type: \"heading\", attrs: { level: Number(name[1]) }, content: children };\n\n    switch (name) {\n      case \"root\":\n      case \"div\":\n      case \"section\":\n      case \"article\":\n      case \"main\":\n        return paragraphContent(children);\n      case \"thead\":\n      case \"tbody\":\n      case \"tfoot\":\n        return children;\n      case \"p\":\n        return paragraphContent(children);\n      case \"blockquote\":\n        return { type: \"blockquote\", content: paragraphContent(children) };\n      case \"ul\":\n      case \"ol\":\n        return {\n          type:\n            name === \"ol\"\n              ? \"orderedList\"\n              : props.dataType === \"taskList\"\n                ? \"taskList\"\n                : \"bulletList\",\n          ...(name === \"ol\" ? { attrs: { start: Number(props.start || 1) } } : {}),\n          content: children\n        };\n      case \"li\":\n        return {\n          type: props.dataType === \"taskItem\" ? \"taskItem\" : \"listItem\",\n          ...(props.dataType === \"taskItem\"\n            ? { attrs: { checked: props.dataChecked === \"true\" } }\n            : {}),\n          content: paragraphContent(children)\n        };\n      case \"br\":\n        return { type: \"hardBreak\" };\n      case \"hr\":\n        return { type: \"horizontalRule\" };\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: name === \"th\" ? \"tableHeader\" : \"tableCell\",\n          attrs: { colspan: Number(props.colSpan || 1), rowspan: Number(props.rowSpan || 1) },\n          content: paragraphContent(children)\n        };\n      default:\n        throw new ConversionError(`Unsupported HTML element: ${name}`, context.path);\n    }\n  }\n};\n/**\n * Create a reusable async HTML 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 Andesine data attributes; frontmatter mappings are not supported.\n */\nconst createHTMLConverter = (options?: HTMLOptions) => createConverter(htmlAdapter, options);\nconst converter = createHTMLConverter();\n/**\n * Export ProseMirror JSON as HTML.\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 HTML. 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 toHTML = converter.encode;\n/**\n * Import HTML as ProseMirror JSON without saving content or uploading assets.\n * @param source - Source text to parse. Custom elements use Andesine data attributes; frontmatter mappings are not supported.\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 fromHTML = converter.decode;\n/**\n * Export ProseMirror JSON as a HTML 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 toHTML(), including unsupported frontmatter mappings.\n */\nconst toHTMLAST = converter.toAST;\n/**\n * Import a parsed HTML 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 fromHTML(), excluding string-parser errors.\n */\nconst fromHTMLAST = converter.fromAST;\n\nexport { createHTMLConverter, htmlAdapter, toHTML, fromHTML, toHTMLAST, fromHTMLAST };\nexport type { HTMLNode, HTMLOptions };\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,115 @@
+import { _ as ImageReference, a as Converter, b as ImportFormatAdapter, c as DecodeHandlers, d as ExportConverter, f as ExportConverterOptions, g as HandlerResult, h as FragmentMapping, i as ConvertedAST, l as EncodeContext, m as FormatAdapter, n as ContentMark, o as ConverterOptions, p as ExportFormatAdapter, r as ContentNode, s as DecodeContext, t as Awaitable, u as EncodeHandlers, v as ImportConverter, y as ImportConverterOptions } from "./chunks/types-SDFWRP3z.js";
+import { HeadingAnchor, getHeadingAnchors } from "./anchors.js";
+//#region src/core.d.ts
+/**
+ * Build an async export-only converter using the shared content mappings.
+ *
+ * @param adapter - Root builder, serializer, and export node/mark handlers. No import stubs are needed.
+ * @param defaults - Reusable options. Per-call handler maps and named fragment mappings merge by key.
+ * @returns Only encode() and toAST(), both async. Handlers and image callbacks may be async.
+ * Import methods are absent at runtime and in TypeScript. No content is saved.
+ * Unsupported nodes and marks are handled by the adapter, usually by throwing ConversionError.
+ * Defaults render titles as H1s, unwrap fragments, and omit properties. Removed boundaries and
+ * omitted data cannot be recovered on import; choose explicit mappings when preservation matters.
+ */
+declare const createExportConverter: <T>(adapter: ExportFormatAdapter<T>, defaults?: ExportConverterOptions<T>) => ExportConverter<T>;
+/**
+ * Build an async import-only converter using the shared content mappings.
+ *
+ * @param adapter - Parser, decode handler, and node-type lookup. No export stubs are needed.
+ * @param defaults - Reusable import mappings and handlers, merged by key with per-call overrides.
+ * @returns Only decode() and fromAST(), both async. Parsers, handlers, and image callbacks may
+ * be async. Export methods are absent at runtime and in TypeScript. No content is saved.
+ * Imports create an entry with a title by default; document: "fragment" retains headings as body
+ * content. Unsupported input is handled by the adapter; parser and handler errors pass through.
+ */
+declare const createImportConverter: <T>(adapter: ImportFormatAdapter<T>, defaults?: ImportConverterOptions<T>) => ImportConverter<T>;
+/**
+ * Build an async converter for a custom format that supports both import and export.
+ *
+ * @param adapter - Full adapter with parser, serializer, and mappings for both directions.
+ * @param defaults - Shared defaults and direction-specific handlers. Per-call maps merge by key.
+ * @returns encode(), toAST(), decode(), and fromAST(), composed from the one-way factories.
+ * Each method accepts options for its own direction. No content is saved or uploaded.
+ * Defaults render titles as H1s, unwrap fragments, and omit properties. Removed boundaries and
+ * omitted data cannot be recovered on import; choose explicit mappings when preservation matters.
+ */
+declare const createConverter: <T>(adapter: FormatAdapter<T>, defaults?: ConverterOptions<T>) => Converter<T>;
+//#endregion
+//#region src/utils.d.ts
+/** A conversion failure, optionally located at a child-index path in the source tree. */
+declare class ConversionError extends Error {
+  readonly path: readonly number[];
+  /**
+   * @param message - Description of the unsupported content or invalid mapping.
+   * @param path - Child indexes appended to the message; defaults to the document root.
+   */
+  constructor(message: string, path?: readonly number[]);
+}
+/**
+ * Concatenate a node's descendant text without changing the source.
+ * @param node - ProseMirror node to read.
+ * @returns Raw text with no added block separators, markup, or hard-break replacement.
+ */
+declare const textContent: (node: ContentNode) => string;
+/**
+ * Create text content suitable for a node handler.
+ * @param text - Literal text to include.
+ * @returns One text node, or an empty array for an empty string.
+ */
+declare const textNode: (text: string) => ContentNode[];
+/**
+ * Append a mark to all descendant text nodes without modifying the input nodes.
+ * @param nodes - Content to mark. Existing marks are retained, including duplicates.
+ * @param mark - Mark to append to each text node.
+ * @returns Mapped nodes; unchanged leaf nodes and existing marks may retain their references.
+ */
+declare const withMark: (nodes: ContentNode[], mark: ContentMark) => ContentNode[];
+/**
+ * Create an Andesine element node with static JSON properties and a source representation.
+ * @param name - Element name, starting with a letter and containing letters, digits, _, ., or -.
+ * @param props - Static JSON properties with valid attribute names; executable expressions are rejected.
+ * @param content - Child nodes. The supplied content array is retained.
+ * @param selfClosing - Whether the source uses a self-closing tag; defaults to true for empty content.
+ * @returns A ProseMirror element node for use in import handlers.
+ * @throws ConversionError for invalid names, property keys, or non-JSON property values.
+ */
+declare const element: (name: string, props: Record<string, unknown>, content: ContentNode[], selfClosing?: boolean) => ContentNode;
+//#endregion
+//#region src/images.d.ts
+interface ImageAsset {
+  assetID: string;
+  variant: string;
+  url: string;
+}
+interface ImageURLOptions {
+  /** Variant to resolve, or an async selector for each image. Defaults to "display". */
+  variant?: string | ((node: ContentNode) => Awaitable<string>);
+}
+interface PublishedImageContent {
+  assets: readonly ImageAsset[];
+}
+/**
+ * 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.
+ */
+declare const createImageURLResolver: (assets: readonly ImageAsset[], options?: ImageURLOptions) => (node: ContentNode) => Promise<string>;
+/**
+ * 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" });
+ */
+declare const publishedContentOptions: (page: PublishedImageContent, options?: ImageURLOptions) => {
+  imageURL: (node: ContentNode) => Promise<string>;
+};
+//#endregion
+export { type Awaitable, type ContentMark, type ContentNode, ConversionError, type ConvertedAST, type Converter, type ConverterOptions, type DecodeContext, type DecodeHandlers, type EncodeContext, type EncodeHandlers, type ExportConverter, type ExportConverterOptions, type ExportFormatAdapter, type FormatAdapter, type FragmentMapping, type HandlerResult, type HeadingAnchor, type ImageAsset, type ImageReference, type ImageURLOptions, type ImportConverter, type ImportConverterOptions, type ImportFormatAdapter, type PublishedImageContent, createConverter, createExportConverter, createImageURLResolver, createImportConverter, element, getHeadingAnchors, publishedContentOptions, textContent, textNode, withMark };
+//# sourceMappingURL=index.d.ts.map