@docen/docx 0.3.0

package/dist/converters/docx.mjs

@@ -0,0 +1,624 @@
+import { parseDocx, renderDocx } from "../extensions/heading.mjs";
+import { parseDocx as parseDocx$1, renderDocx as renderDocx$1 } from "../extensions/image.mjs";
+import { parseDocx as parseDocx$2, renderDocx as renderDocx$2 } from "../extensions/paragraph.mjs";
+import { parseDocx as parseDocx$3, renderDocx as renderDocx$3 } from "../extensions/strike.mjs";
+import { parseDocx as parseDocx$4, renderDocx as renderDocx$4 } from "../extensions/table.mjs";
+import { parseDocx as parseDocx$5, renderDocx as renderDocx$5 } from "../extensions/table-cell.mjs";
+import { parseDocx as parseDocx$6, renderDocx as renderDocx$6 } from "../extensions/table-header.mjs";
+import { parseDocx as parseDocx$7, renderDocx as renderDocx$7 } from "../extensions/table-row.mjs";
+import { parseDocx as parseDocx$8, renderDocx as renderDocx$8 } from "../extensions/text-style.mjs";
+import { prepareDocument } from "./prepare.mjs";
+import { generateDocument, generateDocumentStream, generateDocumentSync, parseDocument } from "@office-open/docx";
+//#region src/converters/docx.ts
+/** Remove keys with null/undefined values */
+function cleanAttrs(attrs) {
+	const result = {};
+	for (const [key, value] of Object.entries(attrs)) if (value !== null && value !== void 0) result[key] = value;
+	return result;
+}
+/** Merge consecutive text nodes with same marks */
+function mergeTextNodes(nodes) {
+	const result = [];
+	for (const node of nodes) {
+		if (node.type === "text" && result.length > 0 && result[result.length - 1].type === "text") {
+			const prev = result[result.length - 1];
+			if (JSON.stringify(prev.marks) === JSON.stringify(node.marks)) {
+				prev.text = (prev.text ?? "") + (node.text ?? "");
+				continue;
+			}
+		}
+		result.push({ ...node });
+	}
+	return result;
+}
+/**
+* Manages DOCX serialization (Tiptap JSON ↔ DocumentOptions).
+*
+* Each extension provides renderDocx/parseDocx for its own attrs mapping.
+* DocxManager handles tree walking, child assembly, and dispatching.
+*/
+var DocxManager = class {
+	compile(json) {
+		const children = [];
+		if (json.content) for (const node of json.content) {
+			const child = this.compileSectionChild(node);
+			if (!child) continue;
+			if (Array.isArray(child)) children.push(...child);
+			else children.push(child);
+		}
+		return { sections: [{ children }] };
+	}
+	resolve(docOpts) {
+		const sections = docOpts.sections ?? [];
+		if (sections.length === 0) return {
+			type: "doc",
+			content: [{ type: "paragraph" }]
+		};
+		const children = sections[0].children ?? [];
+		const content = [];
+		for (const child of children) {
+			const node = this.resolveSectionChild(child);
+			if (node) content.push(node);
+		}
+		return {
+			type: "doc",
+			content: content.length > 0 ? content : [{ type: "paragraph" }]
+		};
+	}
+	compileSectionChild(node) {
+		switch (node.type) {
+			case "paragraph": return { paragraph: this.compileParagraphNode(node) };
+			case "heading": return { paragraph: this.compileHeadingNode(node) };
+			case "blockquote":
+				for (const child of node.content ?? []) if (child.type === "paragraph") return { paragraph: this.compileParagraphNode(child) };
+				return null;
+			case "codeBlock": return { paragraph: this.compileCodeBlock(node) };
+			case "horizontalRule": return { paragraph: { thematicBreak: true } };
+			case "table": return { table: this.compileTableNode(node) };
+			case "image": {
+				const imageRun = renderDocx$1(node);
+				if (!imageRun) return null;
+				return { paragraph: { children: [imageRun] } };
+			}
+			case "bulletList":
+			case "orderedList":
+			case "taskList": return this.compileListFromNode(node);
+			default: return null;
+		}
+	}
+	compileParagraphNode(node) {
+		const opts = renderDocx$2(node);
+		const childList = this.compileInlineContent(node.content);
+		if (childList.length > 0) opts.children = childList;
+		return this.simplifyParagraph(opts);
+	}
+	compileHeadingNode(node) {
+		const opts = renderDocx(node);
+		const childList = this.compileInlineContent(node.content);
+		if (childList.length > 0) opts.children = childList;
+		return this.simplifyParagraph(opts);
+	}
+	compileCodeBlock(node) {
+		const text = (node.content ?? []).map((c) => c.text ?? "").join("");
+		return {
+			style: "Code",
+			...node.attrs?.language ? { run: { font: "Consolas" } } : {},
+			text
+		};
+	}
+	/** Simple text optimization: merge plain runs into text field */
+	simplifyParagraph(opts) {
+		const children = opts.children;
+		if (!children || children.length === 0) return opts;
+		if (children.every((c) => typeof c === "object" && c !== null && "text" in c && Object.keys(c).length === 1)) {
+			const combined = children.map((c) => c.text).join("");
+			delete opts.children;
+			if (combined && Object.keys(opts).length === 0) return combined;
+			if (combined) opts.text = combined;
+		}
+		return opts;
+	}
+	compileTableNode(node) {
+		const opts = renderDocx$4(node);
+		const colCount = this.getTableColumnCount(node);
+		const rows = [];
+		let activeSpans = [];
+		for (const rowNode of node.content ?? []) {
+			if (rowNode.type !== "tableRow") continue;
+			const rowOpts = renderDocx$7(rowNode);
+			const pmCells = (rowNode.content ?? []).filter((c) => c.type === "tableCell" || c.type === "tableHeader");
+			const currentSpans = [...activeSpans].sort((a, b) => a.colStart - b.colStart);
+			const newSpans = [];
+			const compiledCells = [];
+			let colIdx = 0;
+			let cellIdx = 0;
+			let spanIdx = 0;
+			while (spanIdx < currentSpans.length || cellIdx < pmCells.length) {
+				const nextSpanCol = spanIdx < currentSpans.length ? currentSpans[spanIdx].colStart : Infinity;
+				if (colIdx >= nextSpanCol) {
+					const span = currentSpans[spanIdx];
+					compiledCells.push({
+						verticalMerge: "continue",
+						columnSpan: span.colspan,
+						children: [{ paragraph: "" }]
+					});
+					colIdx += span.colspan;
+					spanIdx++;
+				} else {
+					const cell = this.compileTableCellNode(pmCells[cellIdx]);
+					const cs = cell.columnSpan ?? 1;
+					const rs = cell.rowSpan ?? 1;
+					if (rs > 1) {
+						delete cell.rowSpan;
+						cell.verticalMerge = "restart";
+						newSpans.push({
+							colStart: colIdx,
+							colspan: cs,
+							remainingRows: rs - 1
+						});
+					}
+					compiledCells.push(cell);
+					colIdx += cs;
+					cellIdx++;
+				}
+			}
+			rowOpts.cells = compiledCells;
+			rows.push(rowOpts);
+			for (const span of currentSpans) span.remainingRows--;
+			activeSpans = [...currentSpans.filter((s) => s.remainingRows > 0), ...newSpans];
+		}
+		opts.rows = rows;
+		if (colCount > 0) {
+			const { columnWidths, tableWidth } = this.computeColumnWidths(node, colCount, opts);
+			opts.columnWidths = columnWidths;
+			if (!opts.width) opts.width = tableWidth;
+			if (!opts.layout) opts.layout = "autofit";
+		}
+		return opts;
+	}
+	/** Count grid columns from the first table row (summing colspan). */
+	getTableColumnCount(tableNode) {
+		for (const rowNode of tableNode.content ?? []) {
+			if (rowNode.type !== "tableRow") continue;
+			let count = 0;
+			for (const cell of rowNode.content ?? []) if (cell.type === "tableCell" || cell.type === "tableHeader") count += cell.attrs?.colspan ?? 1;
+			return count;
+		}
+		return 0;
+	}
+	/**
+	* Compute tblGrid column widths (twips) from first-row cell colwidth attrs.
+	* Returns columnWidths array and the appropriate tableWidth.
+	*/
+	computeColumnWidths(tableNode, colCount, _opts) {
+		const DEFAULT_CONTENT_TWIPS = 9026;
+		const tableColWidths = tableNode.attrs?.columnWidths;
+		if (tableColWidths && tableColWidths.length > 0) {
+			const filled = tableColWidths.slice(0, colCount);
+			while (filled.length < colCount) filled.push(filled[filled.length - 1] ?? Math.floor(DEFAULT_CONTENT_TWIPS / colCount));
+			return {
+				columnWidths: filled,
+				tableWidth: {
+					size: filled.reduce((a, b) => a + b, 0),
+					type: "dxa"
+				}
+			};
+		}
+		const widths = Array.from({ length: colCount }, () => null);
+		for (const rowNode of tableNode.content ?? []) {
+			if (rowNode.type !== "tableRow") continue;
+			let colIdx = 0;
+			for (const cell of rowNode.content ?? []) {
+				if (cell.type !== "tableCell" && cell.type !== "tableHeader") continue;
+				const colspan = cell.attrs?.colspan ?? 1;
+				const colwidth = cell.attrs?.colwidth;
+				if (colwidth) for (let i = 0; i < colspan && colIdx + i < colCount; i++) {
+					const px = colwidth[i] ?? colwidth[0];
+					if (px) widths[colIdx + i] = px * 15;
+				}
+				colIdx += colspan;
+			}
+			break;
+		}
+		if (!widths.some((w) => w !== null)) {
+			const equal = Math.floor(DEFAULT_CONTENT_TWIPS / colCount);
+			return {
+				columnWidths: Array(colCount).fill(equal),
+				tableWidth: {
+					size: 5e3,
+					type: "pct"
+				}
+			};
+		}
+		const explicit = widths.filter((w) => w !== null);
+		const avg = Math.floor(explicit.reduce((a, b) => a + b, 0) / explicit.length);
+		const filled = widths.map((w) => w ?? avg);
+		return {
+			columnWidths: filled,
+			tableWidth: {
+				size: filled.reduce((a, b) => a + b, 0),
+				type: "dxa"
+			}
+		};
+	}
+	compileTableCellNode(cellNode) {
+		const cellOpts = cellNode.type === "tableHeader" ? renderDocx$6(cellNode) : renderDocx$5(cellNode);
+		const cellAlign = cellNode.attrs?.align ?? null;
+		const cellChildren = [];
+		for (const paraNode of cellNode.content ?? []) {
+			const para = this.compileParagraphNode(paraNode);
+			const paraObj = typeof para === "string" ? { text: para } : para;
+			if (cellAlign && !paraObj.alignment) paraObj.alignment = cellAlign;
+			cellChildren.push({ paragraph: paraObj });
+		}
+		if (cellChildren.length > 0) cellOpts.children = cellChildren;
+		return cellOpts;
+	}
+	compileListFromNode(node) {
+		const items = [];
+		for (const listItem of node.content ?? []) {
+			if (listItem.type !== "listItem" && listItem.type !== "taskItem") continue;
+			for (const child of listItem.content ?? []) if (child.type === "paragraph" || child.type === "heading") {
+				const para = this.compileParagraphNode(child);
+				const paraObj = typeof para === "string" ? { text: para } : para;
+				if (node.type === "bulletList") paraObj.bullet = { level: 0 };
+				else if (node.type === "orderedList") paraObj.numbering = {
+					reference: "default-numbering",
+					level: 0
+				};
+				items.push({ paragraph: paraObj });
+			}
+		}
+		return items.length > 0 ? items : null;
+	}
+	compileInlineContent(content) {
+		if (!content) return [];
+		const children = [];
+		for (const node of content) switch (node.type) {
+			case "text":
+				this.compileTextNode(node, children);
+				break;
+			case "hardBreak":
+				children.push({ break: 1 });
+				break;
+			case "image": {
+				const imageRun = renderDocx$1(node);
+				if (imageRun) children.push(imageRun);
+				break;
+			}
+		}
+		return children;
+	}
+	compileTextNode(node, children) {
+		const text = node.text ?? "";
+		if (!text) return;
+		const marks = node.marks ?? [];
+		const runOpts = { text };
+		for (const mark of marks) switch (mark.type) {
+			case "bold":
+				runOpts.bold = true;
+				break;
+			case "italic":
+				runOpts.italic = true;
+				break;
+			case "underline":
+				runOpts.underline = { type: "single" };
+				break;
+			case "strike": {
+				const strikeProps = renderDocx$3(mark.attrs ?? {});
+				Object.assign(runOpts, strikeProps);
+				break;
+			}
+			case "subscript":
+				runOpts.subScript = true;
+				break;
+			case "superscript":
+				runOpts.superScript = true;
+				break;
+			case "highlight":
+				runOpts.highlight = mark.attrs?.color ?? "yellow";
+				break;
+			case "code":
+				runOpts.font = "Consolas";
+				break;
+			case "textStyle": {
+				const tsProps = renderDocx$8(mark.attrs ?? {});
+				Object.assign(runOpts, tsProps);
+				break;
+			}
+			case "link": {
+				const href = mark.attrs?.href;
+				if (href) {
+					const { text: _, ...runWithoutText } = runOpts;
+					const linkChildren = [];
+					if (text) linkChildren.push({
+						...runWithoutText,
+						text
+					});
+					children.push({ hyperlink: {
+						link: href.startsWith("#") ? void 0 : href,
+						anchor: href.startsWith("#") ? href.slice(1) : void 0,
+						children: linkChildren
+					} });
+					return;
+				}
+				break;
+			}
+		}
+		children.push(runOpts);
+	}
+	resolveSectionChild(child) {
+		if ("paragraph" in child) return this.resolveParagraph(child.paragraph);
+		if ("table" in child) return this.resolveTable(child.table);
+		return null;
+	}
+	resolveParagraph(opts) {
+		const resolved = typeof opts === "string" ? { text: opts } : opts;
+		const headingLevel = resolved.heading ? HEADING_LEVEL_MAP[resolved.heading] : void 0;
+		const nodeType = headingLevel ? "heading" : "paragraph";
+		const attrs = headingLevel ? parseDocx(resolved) : parseDocx$2(resolved);
+		if (resolved.bullet) return this.resolveListItem(resolved, "bulletList", attrs);
+		if (resolved.numbering) return this.resolveListItem(resolved, "orderedList", attrs);
+		const content = this.resolveInlineContent(resolved);
+		const cleanAttrsObj = cleanAttrs(attrs);
+		const node = { type: nodeType };
+		if (Object.keys(cleanAttrsObj).length > 0) node.attrs = cleanAttrsObj;
+		if (content.length > 0) node.content = content;
+		return node;
+	}
+	resolveListItem(opts, listType, paraAttrs) {
+		const content = this.resolveInlineContent(opts);
+		const cleanAttrsObj = cleanAttrs(paraAttrs);
+		const paragraphNode = { type: "paragraph" };
+		if (Object.keys(cleanAttrsObj).length > 0) paragraphNode.attrs = cleanAttrsObj;
+		if (content.length > 0) paragraphNode.content = content;
+		return {
+			type: listType,
+			content: [{
+				type: "listItem",
+				content: [paragraphNode]
+			}]
+		};
+	}
+	resolveTable(tableOpts) {
+		const attrs = parseDocx$4(tableOpts);
+		const rows = tableOpts.rows ?? [];
+		const content = [];
+		let activeSpans = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const rowAttrs = parseDocx$7(row);
+			const cells = row.cells ?? [];
+			const cellNodes = [];
+			const nextActiveSpans = /* @__PURE__ */ new Map();
+			let colIdx = 0;
+			for (const cell of cells) {
+				const cellColspan = cell.columnSpan ?? 1;
+				const vMerge = cell.verticalMerge;
+				if (vMerge === "continue") {
+					const owner = activeSpans.get(colIdx);
+					if (owner) {
+						const ownerAttrs = owner.attrs ??= {};
+						ownerAttrs.rowspan = (ownerAttrs.rowspan ?? 1) + 1;
+						for (let c = colIdx; c < colIdx + cellColspan; c++) nextActiveSpans.set(c, owner);
+					}
+					colIdx += cellColspan;
+					continue;
+				}
+				const isHeader = row.tableHeader;
+				const cellAttrs = isHeader ? parseDocx$6(cell) : parseDocx$5(cell);
+				delete cellAttrs.verticalMerge;
+				const cellChildren = cell.children ?? [];
+				const cellContent = [];
+				for (const cc of cellChildren) {
+					const resolved = this.resolveSectionChild(cc);
+					if (resolved) cellContent.push(resolved);
+				}
+				const cellNode = { type: isHeader ? "tableHeader" : "tableCell" };
+				if (Object.keys(cellAttrs).length > 0) cellNode.attrs = cleanAttrs(cellAttrs);
+				if (cellContent.length > 0) cellNode.content = cellContent;
+				if (vMerge === "restart") for (let c = colIdx; c < colIdx + cellColspan; c++) nextActiveSpans.set(c, cellNode);
+				cellNodes.push(cellNode);
+				colIdx += cellColspan;
+			}
+			activeSpans = nextActiveSpans;
+			const rowNode = { type: "tableRow" };
+			if (Object.keys(rowAttrs).length > 0) rowNode.attrs = cleanAttrs(rowAttrs);
+			if (cellNodes.length > 0) rowNode.content = cellNodes;
+			content.push(rowNode);
+		}
+		const node = { type: "table" };
+		if (Object.keys(attrs).length > 0) node.attrs = cleanAttrs(attrs);
+		if (content.length > 0) node.content = content;
+		return node;
+	}
+	/**
+	* Resolve a paragraph's inline content. @office-open collapses a plain-text
+	* paragraph (a single run with no properties) to a bare string or a `{ text }`
+	* object with no `children` — recover that text here so it round-trips back to
+	* a text node instead of being dropped.
+	*/
+	resolveInlineContent(opts) {
+		const content = this.resolveParagraphChildren(opts.children);
+		if (content.length === 0 && opts.text) {
+			const marks = this.resolveMarks(opts);
+			const node = {
+				type: "text",
+				text: opts.text
+			};
+			if (marks) node.marks = marks;
+			return [node];
+		}
+		return content;
+	}
+	resolveParagraphChildren(children) {
+		if (!children || children.length === 0) return [];
+		const nodes = [];
+		for (const child of children) {
+			if (typeof child === "string") {
+				if (child) nodes.push({
+					type: "text",
+					text: child
+				});
+				continue;
+			}
+			if (typeof child === "object" && child !== null) {
+				const resolved = this.resolveParagraphChild(child);
+				if (resolved) nodes.push(...Array.isArray(resolved) ? resolved : [resolved]);
+			}
+		}
+		return nodes;
+	}
+	resolveParagraphChild(child) {
+		if ("text" in child || "children" in child || "break" in child) return this.resolveRun(child);
+		if ("image" in child) return this.resolveImage(child.image);
+		if ("hyperlink" in child) return this.resolveHyperlink(child.hyperlink);
+		if ("pageBreak" in child) return {
+			type: "paragraph",
+			attrs: { pageBreak: true }
+		};
+		if ("columnBreak" in child) return { type: "hardBreak" };
+		return null;
+	}
+	resolveRun(opts) {
+		const text = opts.text;
+		if (text === void 0 && !opts.children) return null;
+		if (opts.children && !text) {
+			const parts = [];
+			for (const c of opts.children) if (typeof c === "string") parts.push(c);
+			if (parts.length === 0) return null;
+			return {
+				type: "text",
+				text: parts.join(""),
+				marks: this.resolveMarks(opts)
+			};
+		}
+		return {
+			type: "text",
+			text: text ?? "",
+			marks: this.resolveMarks(opts)
+		};
+	}
+	resolveMarks(opts) {
+		const marks = [];
+		if (opts.bold) marks.push({ type: "bold" });
+		if (opts.italic) marks.push({ type: "italic" });
+		if (opts.underline) marks.push({ type: "underline" });
+		if (opts.strike) {
+			const strikeAttrs = parseDocx$3(opts);
+			marks.push({
+				type: "strike",
+				attrs: { doubleStrike: strikeAttrs.doubleStrike ?? null }
+			});
+		}
+		if (opts.subScript) marks.push({ type: "subscript" });
+		if (opts.superScript) marks.push({ type: "superscript" });
+		if (opts.highlight) marks.push({ type: "highlight" });
+		if (opts.font === "Consolas" || opts.font === "monospace") marks.push({ type: "code" });
+		const textStyleAttrs = parseDocx$8(opts);
+		if (opts.font === "Consolas" || opts.font === "monospace") delete textStyleAttrs.font;
+		if (Object.keys(textStyleAttrs).length > 0) marks.push({
+			type: "textStyle",
+			attrs: textStyleAttrs
+		});
+		return marks.length > 0 ? marks : void 0;
+	}
+	resolveImage(imageOpts) {
+		const attrs = parseDocx$1(imageOpts);
+		const data = imageOpts.data;
+		const type = imageOpts.type;
+		if (data && type) attrs.src = `data:image/${type};base64,${typeof btoa !== "undefined" ? btoa(String.fromCharCode(...data instanceof ArrayBuffer ? new Uint8Array(data) : data)) : Buffer.from(data).toString("base64")}`;
+		return {
+			type: "image",
+			attrs
+		};
+	}
+	resolveHyperlink(hyperlink) {
+		const href = hyperlink.link ?? (hyperlink.anchor ? `#${hyperlink.anchor}` : "");
+		if (!href) return null;
+		const content = this.resolveParagraphChildren((hyperlink.children ?? []).map((c) => c));
+		if (content.length > 0) {
+			const merged = mergeTextNodes(content);
+			for (const node of merged) if (node.type === "text") node.marks = [...node.marks ?? [], {
+				type: "link",
+				attrs: {
+					href,
+					target: "_blank",
+					rel: "noopener noreferrer nofollow",
+					class: null,
+					title: hyperlink.tooltip ?? null
+				}
+			}];
+			return merged;
+		}
+		return null;
+	}
+};
+const HEADING_LEVEL_MAP = {
+	Heading1: 1,
+	Heading2: 2,
+	Heading3: 3,
+	Heading4: 4,
+	Heading5: 5,
+	Heading6: 6,
+	Title: 1
+};
+const defaultManager = new DocxManager();
+/**
+* Parse a DOCX file into Tiptap JSON (runtime model).
+*
+* Combines @office-open/docx's `parseDocument` (DOCX binary → DocumentOptions)
+* with `DocxManager.resolve` (DocumentOptions → Tiptap JSON).
+*/
+function parseDOCX(data) {
+	return defaultManager.resolve(parseDocument(data));
+}
+/**
+* Generate a DOCX file from Tiptap JSON (runtime model), asynchronously.
+*
+* Pipeline: `prepareDocument` (default: fetch http images, in place) →
+* `DocxManager.compile` → @office-open/docx's `generateDocument`. `packer.type`
+* controls the output format (default: `"nodebuffer"` → Buffer). Non-blocking
+* (fflate Web Workers). With the default `prepare`, the input `json` is mutated
+* in place (http image URLs become embedded data URLs).
+*/
+async function generateDOCX(json, options) {
+	const { prepare = true, packer } = options ?? {};
+	if (prepare !== false) await prepareDocument(json, prepare === true ? void 0 : prepare);
+	return generateDocument(compileDocument(json), packer);
+}
+/**
+* Generate a DOCX file synchronously — fastest throughput, blocks the event loop.
+*
+* Pipeline: `DocxManager.compile` → `generateDocumentSync`. Does **not** run
+* `prepareDocument` (it is async); call `await prepareDocument(json)` first
+* when http images need embedding.
+*/
+function generateDOCXSync(json, packerOptions) {
+	return generateDocumentSync(compileDocument(json), packerOptions);
+}
+/**
+* Generate a DOCX file as a `ReadableStream<Uint8Array>` — for large documents
+* or streaming HTTP responses.
+*
+* Pipeline: `prepareDocument` (default: fetch http images, in place) →
+* `DocxManager.compile` → `generateDocumentStream`. Async due to preparation.
+*/
+async function generateDOCXStream(json, options) {
+	const { prepare = true, packer } = options ?? {};
+	if (prepare !== false) await prepareDocument(json, prepare === true ? void 0 : prepare);
+	return generateDocumentStream(compileDocument(json), packer);
+}
+/**
+* Convert DocumentOptions (persistence model) to Tiptap JSON (runtime model).
+*/
+function resolveDocument(docOpts) {
+	return defaultManager.resolve(docOpts);
+}
+/**
+* Convert Tiptap JSON (runtime model) to DocumentOptions (persistence model).
+*/
+function compileDocument(json) {
+	return defaultManager.compile(json);
+}
+//#endregion
+export { DocxManager, compileDocument, generateDOCX, generateDOCXStream, generateDOCXSync, parseDOCX, resolveDocument };

package/dist/converters/html.d.mts

@@ -0,0 +1,14 @@
+import { a as JSONContent, i as Extensions } from "../core-omBKMRtl.mjs";
+import { ParseOptions } from "@tiptap/pm/model";
+
+//#region src/converters/html.d.ts
+/**
+ * Parse HTML string to Tiptap JSON.
+ */
+declare function parseHTML(html: string, extensions?: Extensions, options?: ParseOptions): JSONContent;
+/**
+ * Generate HTML string from Tiptap JSON.
+ */
+declare function generateHTML(doc: JSONContent, extensions?: Extensions): string;
+//#endregion
+export { generateHTML, parseHTML };

package/dist/converters/html.mjs

@@ -0,0 +1,18 @@
+import { s as docxExtensions } from "../core-CFIQVRfx.mjs";
+import { generateHTML as generateHTML$1, generateJSON } from "@tiptap/html";
+//#region src/converters/html.ts
+const defaultExtensions = docxExtensions;
+/**
+* Parse HTML string to Tiptap JSON.
+*/
+function parseHTML(html, extensions, options) {
+	return generateJSON(html, extensions ?? defaultExtensions, options);
+}
+/**
+* Generate HTML string from Tiptap JSON.
+*/
+function generateHTML(doc, extensions) {
+	return generateHTML$1(doc, extensions ?? defaultExtensions);
+}
+//#endregion
+export { generateHTML, parseHTML };

package/dist/converters/markdown.d.mts

@@ -0,0 +1,13 @@
+import { a as JSONContent } from "../core-omBKMRtl.mjs";
+
+//#region src/converters/markdown.d.ts
+/**
+ * Parse Markdown string to Tiptap JSON.
+ */
+declare function parseMarkdown(markdown: string): JSONContent;
+/**
+ * Generate Markdown string from Tiptap JSON.
+ */
+declare function generateMarkdown(doc: JSONContent): string;
+//#endregion
+export { generateMarkdown, parseMarkdown };

package/dist/converters/markdown.mjs

@@ -0,0 +1,18 @@
+import { s as docxExtensions } from "../core-CFIQVRfx.mjs";
+import { Markdown, MarkdownManager } from "@tiptap/markdown";
+//#region src/converters/markdown.ts
+const markdownManager = new MarkdownManager({ extensions: [...docxExtensions, Markdown] });
+/**
+* Parse Markdown string to Tiptap JSON.
+*/
+function parseMarkdown(markdown) {
+	return markdownManager.parse(markdown);
+}
+/**
+* Generate Markdown string from Tiptap JSON.
+*/
+function generateMarkdown(doc) {
+	return markdownManager.serialize(doc);
+}
+//#endregion
+export { generateMarkdown, parseMarkdown };