@docen/docx 0.3.0

package/dist/converters/patch.d.mts

@@ -0,0 +1,53 @@
+import { a as JSONContent } from "../core-omBKMRtl.mjs";
+import { PrepareStep } from "./prepare.mjs";
+import { OutputByType, OutputType, patchDocument } from "@office-open/docx";
+
+//#region src/converters/patch.d.ts
+/**
+ * A patch's replacement content, expressed as Tiptap JSON. `compileDocument`
+ * converts it to office-open `SectionChild[]` before applying.
+ */
+interface DocxPatchContent {
+  content: JSONContent;
+}
+/**
+ * Options for patching a DOCX template.
+ *
+ * Mirrors the legacy `@docen/export-docx` DocxPatchOptions minus `exportOptions`
+ * — `compileDocument` already derives all styling from the Tiptap attrs, so no
+ * separate export configuration is needed.
+ */
+interface DocxPatchOptions<T extends OutputType = OutputType> {
+  /** Template DOCX to patch. */
+  template: Parameters<typeof patchDocument>[0]["data"];
+  /** Placeholder name → replacement content. */
+  patches: Record<string, DocxPatchContent>;
+  /**
+   * Pre-compilation steps run on each patch's content in place (default:
+   * `prepareImages()`). `false` skips; `PrepareStep[]` runs custom steps.
+   * Required when patch content references http image URLs.
+   */
+  prepare?: boolean | PrepareStep[];
+  /** Custom placeholder delimiters (default `{{` / `}}`). */
+  placeholderDelimiters?: {
+    start?: string;
+    end?: string;
+  };
+  /** Keep the template's paragraph styles on patched content. */
+  keepOriginalStyles?: boolean;
+  /** Recurse into nested patches. */
+  recursive?: boolean;
+  /** Output container type. */
+  outputType: T;
+}
+/**
+ * Patch a DOCX template by replacing placeholders with Tiptap-JSON content.
+ *
+ * Each patch's `content` is prepared (default: `prepareImages`, in place) then
+ * compiled (`compileDocument` → `DocumentOptions`); its first section's
+ * `children` become the replacement. Patching is delegated to
+ * `@office-open/docx`'s `patchDocument`.
+ */
+declare function patchDOCX<T extends OutputType>(options: DocxPatchOptions<T>): Promise<OutputByType[T]>;
+//#endregion
+export { DocxPatchContent, DocxPatchOptions, patchDOCX };

package/dist/converters/patch.mjs

@@ -0,0 +1,37 @@
+import { prepareDocument } from "./prepare.mjs";
+import { compileDocument } from "./docx.mjs";
+import { PatchType, patchDocument } from "@office-open/docx";
+//#region src/converters/patch.ts
+/**
+* Patch a DOCX template by replacing placeholders with Tiptap-JSON content.
+*
+* Each patch's `content` is prepared (default: `prepareImages`, in place) then
+* compiled (`compileDocument` → `DocumentOptions`); its first section's
+* `children` become the replacement. Patching is delegated to
+* `@office-open/docx`'s `patchDocument`.
+*/
+async function patchDOCX(options) {
+	const { template, patches, prepare = true, placeholderDelimiters, keepOriginalStyles, recursive, outputType } = options;
+	const patchesObject = {};
+	for (const [key, patchContent] of Object.entries(patches)) {
+		if (prepare !== false) await prepareDocument(patchContent.content, prepare === true ? void 0 : prepare);
+		const children = compileDocument(patchContent.content).sections?.[0]?.children ?? [];
+		patchesObject[key] = {
+			type: PatchType.DOCUMENT,
+			children
+		};
+	}
+	return patchDocument({
+		outputType,
+		data: template,
+		patches: patchesObject,
+		...keepOriginalStyles !== void 0 && { keepOriginalStyles },
+		...recursive !== void 0 && { recursive },
+		...placeholderDelimiters && { placeholderDelimiters: {
+			start: placeholderDelimiters.start ?? "{{",
+			end: placeholderDelimiters.end ?? "}}"
+		} }
+	});
+}
+//#endregion
+export { patchDOCX };

package/dist/converters/prepare.d.mts

@@ -0,0 +1,51 @@
+import { a as JSONContent } from "../core-omBKMRtl.mjs";
+
+//#region src/converters/prepare.d.ts
+/**
+ * A prepare step that transforms Tiptap JSON in place (e.g. fetch external resources).
+ */
+type PrepareStep = (json: JSONContent) => Promise<void>;
+/**
+ * Fetch handler for external image URLs.
+ *
+ * Receives the URL, returns the image binary data.
+ * Override to customize fetching (proxy, auth, caching, etc.).
+ */
+type ImageFetchHandler = (url: string) => Promise<Uint8Array>;
+/**
+ * Default fetch handler using the global `fetch` API (Node 18+ and browsers).
+ */
+declare function fetchImageHandler(url: string): Promise<Uint8Array>;
+/**
+ * Create a prepare step that fetches external image URLs and converts them to data URLs.
+ *
+ * @param handler - Custom fetch handler (defaults to `fetchImageHandler`)
+ *
+ * @example
+ * ```ts
+ * // Use with defaults
+ * await prepareDocument(json);
+ *
+ * // Custom handler
+ * await prepareDocument(json, [prepareImages(myHandler)]);
+ * ```
+ */
+declare function prepareImages(handler?: ImageFetchHandler): PrepareStep;
+/**
+ * Run prepare steps on a Tiptap JSON document before compilation.
+ *
+ * Each step receives the JSON and may mutate it in place (e.g. replace external
+ * URLs with embedded data). Steps run sequentially in order.
+ *
+ * Defaults to `[prepareImages()]` when no steps are provided.
+ *
+ * @example
+ * ```ts
+ * const json = parseHTML(html);
+ * await prepareDocument(json);             // default: fetch images
+ * const docOpts = compileDocument(json);
+ * ```
+ */
+declare function prepareDocument(json: JSONContent, steps?: readonly PrepareStep[]): Promise<void>;
+//#endregion
+export { ImageFetchHandler, PrepareStep, fetchImageHandler, prepareDocument, prepareImages };

package/dist/converters/prepare.mjs

@@ -0,0 +1,76 @@
+//#region src/converters/prepare.ts
+/**
+* Default fetch handler using the global `fetch` API (Node 18+ and browsers).
+*/
+async function fetchImageHandler(url) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Failed to fetch image from ${url}: ${response.status} ${response.statusText}`);
+	const buffer = await response.arrayBuffer();
+	return new Uint8Array(buffer);
+}
+/**
+* Create a prepare step that fetches external image URLs and converts them to data URLs.
+*
+* @param handler - Custom fetch handler (defaults to `fetchImageHandler`)
+*
+* @example
+* ```ts
+* // Use with defaults
+* await prepareDocument(json);
+*
+* // Custom handler
+* await prepareDocument(json, [prepareImages(myHandler)]);
+* ```
+*/
+function prepareImages(handler = fetchImageHandler) {
+	return async (json) => {
+		await walkImages(json, handler);
+	};
+}
+/** Built-in prepare steps, run when no custom steps are provided. */
+const DEFAULT_STEPS = [prepareImages()];
+/**
+* Run prepare steps on a Tiptap JSON document before compilation.
+*
+* Each step receives the JSON and may mutate it in place (e.g. replace external
+* URLs with embedded data). Steps run sequentially in order.
+*
+* Defaults to `[prepareImages()]` when no steps are provided.
+*
+* @example
+* ```ts
+* const json = parseHTML(html);
+* await prepareDocument(json);             // default: fetch images
+* const docOpts = compileDocument(json);
+* ```
+*/
+async function prepareDocument(json, steps = DEFAULT_STEPS) {
+	for (const step of steps) await step(json);
+}
+async function toDataUrl(src, handler) {
+	const data = await handler(src);
+	return `data:${{
+		jpg: "image/jpeg",
+		jpeg: "image/jpeg",
+		png: "image/png",
+		gif: "image/gif",
+		bmp: "image/bmp",
+		svg: "image/svg+xml",
+		webp: "image/webp"
+	}[src.split(".").pop()?.toLowerCase() ?? "png"] ?? "image/png"};base64,${typeof btoa !== "undefined" ? btoa(String.fromCharCode(...data)) : Buffer.from(data).toString("base64")}`;
+}
+async function walkImages(node, handler) {
+	if (node.type === "image" && node.attrs) {
+		const src = node.attrs.src;
+		if (src && (src.startsWith("http://") || src.startsWith("https://"))) try {
+			node.attrs.src = await toDataUrl(src, handler);
+		} catch (error) {
+			console.warn(`Failed to fetch image: ${src}`, error instanceof Error ? error.message : error);
+		}
+	}
+	const tasks = [];
+	for (const child of node.content ?? []) tasks.push(walkImages(child, handler));
+	await Promise.all(tasks);
+}
+//#endregion
+export { fetchImageHandler, prepareDocument, prepareImages };

package/dist/core-CFIQVRfx.mjs

@@ -0,0 +1,88 @@
+import { Blockquote, Bold, BulletList, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Document, Dropcursor, Emoji, Gapcursor, HardBreak, Highlight, HorizontalRule, Italic, Link, ListItem, ListKeymap, Mathematics, Mention, OrderedList, Subscript, Superscript, TaskItem, TaskList, Text, TextAlign as TextAlign$1, TrailingNode, Underline, UndoRedo } from "./extensions/tiptap.mjs";
+import { Heading } from "./extensions/heading.mjs";
+import { Image } from "./extensions/image.mjs";
+import { Paragraph } from "./extensions/paragraph.mjs";
+import { Strike } from "./extensions/strike.mjs";
+import { Table } from "./extensions/table.mjs";
+import { TableCell } from "./extensions/table-cell.mjs";
+import { TableHeader } from "./extensions/table-header.mjs";
+import { TableRow } from "./extensions/table-row.mjs";
+import { TextStyle } from "./extensions/text-style.mjs";
+import { Editor, Extension, Mark, Node } from "@tiptap/core";
+import { all, createLowlight } from "lowlight";
+import { TextAlign } from "@tiptap/extension-text-align";
+//#region src/extensions/extensions.ts
+const tiptapNodeExtensions = [
+	Document,
+	Paragraph,
+	Text,
+	HardBreak,
+	Blockquote,
+	OrderedList,
+	BulletList,
+	ListItem,
+	CodeBlockLowlight.configure({ lowlight: createLowlight(all) }),
+	Details,
+	DetailsSummary,
+	DetailsContent,
+	Emoji,
+	HorizontalRule,
+	Image.configure({ inline: true }),
+	Mathematics,
+	Mention,
+	Table,
+	TableRow,
+	TableCell,
+	TableHeader,
+	TaskList,
+	TaskItem,
+	Heading,
+	TextAlign$1.configure({ types: ["heading", "paragraph"] })
+];
+const tiptapMarkExtensions = [
+	Bold,
+	Code,
+	Highlight,
+	Italic,
+	Link,
+	Strike,
+	Subscript,
+	Superscript,
+	TextStyle,
+	Underline
+];
+const docxExtensions = [...tiptapNodeExtensions, ...tiptapMarkExtensions];
+const StarterKit = Extension.create({
+	name: "docenKit",
+	addExtensions() {
+		const extensions = [];
+		if (this.options.bold !== false) extensions.push(Bold.configure(this.options.bold));
+		if (this.options.blockquote !== false) extensions.push(Blockquote.configure(this.options.blockquote));
+		if (this.options.bulletList !== false) extensions.push(BulletList.configure(this.options.bulletList));
+		if (this.options.code !== false) extensions.push(Code.configure(this.options.code));
+		if (this.options.codeBlock !== false) extensions.push(CodeBlockLowlight.configure({
+			lowlight: createLowlight(all),
+			...this.options.codeBlock
+		}));
+		if (this.options.document !== false) extensions.push(Document);
+		if (this.options.dropcursor !== false) extensions.push(Dropcursor.configure(this.options.dropcursor));
+		if (this.options.gapcursor !== false) extensions.push(Gapcursor);
+		if (this.options.hardBreak !== false) extensions.push(HardBreak.configure(this.options.hardBreak));
+		if (this.options.heading !== false) extensions.push(Heading.configure(this.options.heading));
+		if (this.options.undoRedo !== false) extensions.push(UndoRedo.configure(this.options.undoRedo));
+		if (this.options.horizontalRule !== false) extensions.push(HorizontalRule.configure(this.options.horizontalRule));
+		if (this.options.italic !== false) extensions.push(Italic.configure(this.options.italic));
+		if (this.options.listItem !== false) extensions.push(ListItem.configure(this.options.listItem));
+		if (this.options.listKeymap !== false) extensions.push(ListKeymap.configure(this.options.listKeymap));
+		if (this.options.link !== false) extensions.push(Link.configure(this.options.link));
+		if (this.options.orderedList !== false) extensions.push(OrderedList.configure(this.options.orderedList));
+		if (this.options.paragraph !== false) extensions.push(Paragraph.configure(this.options.paragraph));
+		if (this.options.strike !== false) extensions.push(Strike.configure(this.options.strike));
+		if (this.options.text !== false) extensions.push(Text);
+		if (this.options.underline !== false) extensions.push(Underline.configure(this.options.underline));
+		if (this.options.trailingNode !== false) extensions.push(TrailingNode.configure(this.options.trailingNode));
+		return extensions;
+	}
+});
+//#endregion
+export { StarterKit as a, tiptapMarkExtensions as c, Node as i, tiptapNodeExtensions as l, Extension as n, TextAlign as o, Mark as r, docxExtensions as s, Editor as t };

package/dist/core-omBKMRtl.d.mts

@@ -0,0 +1,34 @@
+import { AnyExtension, Editor, Extension, Extensions, JSONContent as JSONContent$1, Mark, Node } from "@tiptap/core";
+import { TextAlign } from "@tiptap/extension-text-align";
+
+//#region src/extensions/extensions.d.ts
+declare const tiptapNodeExtensions: AnyExtension[];
+declare const tiptapMarkExtensions: AnyExtension[];
+declare const docxExtensions: AnyExtension[];
+interface StarterKitOptions {
+  bold?: Record<string, any> | false;
+  blockquote?: Record<string, any> | false;
+  bulletList?: Record<string, any> | false;
+  code?: Record<string, any> | false;
+  codeBlock?: Record<string, any> | false;
+  document?: false;
+  dropcursor?: Record<string, any> | false;
+  gapcursor?: false;
+  hardBreak?: Record<string, any> | false;
+  heading?: Record<string, any> | false;
+  undoRedo?: Record<string, any> | false;
+  horizontalRule?: Record<string, any> | false;
+  italic?: Record<string, any> | false;
+  listItem?: Record<string, any> | false;
+  listKeymap?: Record<string, any> | false;
+  link?: Record<string, any> | false;
+  orderedList?: Record<string, any> | false;
+  paragraph?: Record<string, any> | false;
+  strike?: Record<string, any> | false;
+  text?: false;
+  underline?: Record<string, any> | false;
+  trailingNode?: Record<string, any> | false;
+}
+declare const StarterKit: Extension<StarterKitOptions, any>;
+//#endregion
+export { JSONContent$1 as a, StarterKit as c, docxExtensions as d, tiptapMarkExtensions as f, Extensions as i, StarterKitOptions as l, Editor as n, Mark as o, tiptapNodeExtensions as p, Extension as r, Node as s, AnyExtension as t, TextAlign as u };

package/dist/core.d.mts

@@ -0,0 +1,2 @@
+import { a as JSONContent, d as docxExtensions, i as Extensions, n as Editor, o as Mark, r as Extension, s as Node, t as AnyExtension } from "./core-omBKMRtl.mjs";
+export { type AnyExtension, Editor, Extension, type Extensions, type JSONContent, Mark, Node, docxExtensions };

package/dist/core.mjs

@@ -0,0 +1,2 @@
+import { i as Node, n as Extension, r as Mark, s as docxExtensions, t as Editor } from "./core-CFIQVRfx.mjs";
+export { Editor, Extension, Mark, Node, docxExtensions };

package/dist/editor.d.mts

@@ -0,0 +1,21 @@
+import { n as Editor, t as AnyExtension } from "./core-omBKMRtl.mjs";
+
+//#region src/editor.d.ts
+interface DocxEditorOptions {
+  /** DOM element to mount the editor */
+  element: HTMLElement;
+  /** Additional Tiptap extensions */
+  extensions?: AnyExtension[];
+  /** Initial content (Tiptap JSON or HTML string) */
+  content?: Record<string, unknown> | string;
+  /** Enable spellcheck (disable for large documents) */
+  spellcheck?: boolean;
+  /** Editor is editable */
+  editable?: boolean;
+}
+/**
+ * Create a Tiptap editor configured for DOCX editing.
+ */
+declare function createDocxEditor(options: DocxEditorOptions): Editor;
+//#endregion
+export { DocxEditorOptions, createDocxEditor };

package/dist/editor.mjs

@@ -0,0 +1,20 @@
+import { s as docxExtensions, t as Editor } from "./core-CFIQVRfx.mjs";
+//#region src/editor.ts
+/**
+* Create a Tiptap editor configured for DOCX editing.
+*/
+function createDocxEditor(options) {
+	const { element, extensions: extraExtensions = [], content, spellcheck = true, editable = true } = options;
+	return new Editor({
+		element,
+		extensions: [...docxExtensions, ...extraExtensions],
+		content: content ?? {
+			type: "doc",
+			content: [{ type: "paragraph" }]
+		},
+		editable,
+		editorProps: { attributes: { spellcheck: spellcheck ? "true" : "false" } }
+	});
+}
+//#endregion
+export { createDocxEditor };

package/dist/extensions/extensions.d.mts

@@ -0,0 +1,12 @@
+import { B as UndoRedo, C as Mention, D as Subscript, F as Text, N as TaskItem, O as Superscript, P as TaskList, R as TrailingNode, S as Mathematics, a as CodeBlockLowlight, b as ListItem, c as DetailsSummary, d as Emoji, f as Gapcursor, g as HorizontalRule, h as Highlight, i as Code, l as Document, n as Bold, o as Details, p as HardBreak, r as BulletList, s as DetailsContent, t as Blockquote, u as Dropcursor, v as Italic, w as OrderedList, x as ListKeymap, y as Link, z as Underline } from "../tiptap-TErPjuNJ.mjs";
+import { t as Heading } from "../heading-BvqBD2zX.mjs";
+import { t as Image } from "../image-Ge1y6uam.mjs";
+import { t as Paragraph } from "../paragraph-fhEXtAN2.mjs";
+import { t as TableRow } from "../table-row-kgzYkZlW.mjs";
+import { t as Table } from "../table-BFkfeRp9.mjs";
+import { t as TableCell } from "../table-cell-D_FV4D2h.mjs";
+import { t as TableHeader } from "../table-header-KGQ2aEkP.mjs";
+import { t as Strike } from "../strike-BgWGvjKr.mjs";
+import { t as TextStyle } from "../text-style-BHdtXkMb.mjs";
+import { c as StarterKit, d as docxExtensions, f as tiptapMarkExtensions, l as StarterKitOptions, p as tiptapNodeExtensions, u as TextAlign } from "../core-omBKMRtl.mjs";
+export { Blockquote, Bold, BulletList, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Document, Dropcursor, Emoji, Gapcursor, HardBreak, Heading, Highlight, HorizontalRule, Image, Italic, Link, ListItem, ListKeymap, Mathematics, Mention, OrderedList, Paragraph, StarterKit, StarterKitOptions, Strike, Subscript, Superscript, Table, TableCell, TableHeader, TableRow, TaskItem, TaskList, Text, TextAlign, TextStyle, TrailingNode, Underline, UndoRedo, docxExtensions, tiptapMarkExtensions, tiptapNodeExtensions };

package/dist/extensions/extensions.mjs

@@ -0,0 +1,12 @@
+import { Blockquote, Bold, BulletList, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Document, Dropcursor, Emoji, Gapcursor, HardBreak, Highlight, HorizontalRule, Italic, Link, ListItem, ListKeymap, Mathematics, Mention, OrderedList, Subscript, Superscript, TaskItem, TaskList, Text, TrailingNode, Underline, UndoRedo } from "./tiptap.mjs";
+import { Heading } from "./heading.mjs";
+import { Image } from "./image.mjs";
+import { Paragraph } from "./paragraph.mjs";
+import { Strike } from "./strike.mjs";
+import { Table } from "./table.mjs";
+import { TableCell } from "./table-cell.mjs";
+import { TableHeader } from "./table-header.mjs";
+import { TableRow } from "./table-row.mjs";
+import { TextStyle } from "./text-style.mjs";
+import { a as StarterKit, c as tiptapMarkExtensions, l as tiptapNodeExtensions, o as TextAlign, s as docxExtensions } from "../core-CFIQVRfx.mjs";
+export { Blockquote, Bold, BulletList, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Document, Dropcursor, Emoji, Gapcursor, HardBreak, Heading, Highlight, HorizontalRule, Image, Italic, Link, ListItem, ListKeymap, Mathematics, Mention, OrderedList, Paragraph, StarterKit, Strike, Subscript, Superscript, Table, TableCell, TableHeader, TableRow, TaskItem, TaskList, Text, TextAlign, TextStyle, TrailingNode, Underline, UndoRedo, docxExtensions, tiptapMarkExtensions, tiptapNodeExtensions };

package/dist/extensions/heading.d.mts

@@ -0,0 +1,2 @@
+import { n as parseDocx, r as renderDocx, t as Heading } from "../heading-BvqBD2zX.mjs";
+export { Heading, parseDocx, renderDocx };

package/dist/extensions/heading.mjs

@@ -0,0 +1,145 @@
+import { Heading as Heading$1 } from "./tiptap.mjs";
+import { alignmentFromElement, bordersFromElement, indentFromElement, renderParagraphStyles, shadingFromElement, spacingFromElement } from "./utils.mjs";
+//#region src/extensions/heading.ts
+/**
+* Heading extension with nested office-open attrs (mirrors Paragraph).
+*
+* Attrs mirror ParagraphPropertiesOptionsBase (alignment/indent/spacing/border/
+* shading/frame as nested objects + scalar OOXML properties) plus the inherited
+* Tiptap `level` (1-6, rendered: false). DOCX round-trip is near-identity:
+* renderDocx/parseDocx pass attrs through and only map `level` ↔ OOXML
+* `heading` (HeadingLevel literal). CSS conversion happens solely in
+* renderHTML via utils mappers.
+*/
+const HEADING_COMPILE_MAP = {
+	1: "Heading1",
+	2: "Heading2",
+	3: "Heading3",
+	4: "Heading4",
+	5: "Heading5",
+	6: "Heading6"
+};
+const HEADING_PARSE_MAP = {
+	Heading1: 1,
+	Heading2: 2,
+	Heading3: 3,
+	Heading4: 4,
+	Heading5: 5,
+	Heading6: 6,
+	Title: 1
+};
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const opts = {};
+	const level = attrs.level;
+	if (level) opts.heading = HEADING_COMPILE_MAP[level] ?? "Heading1";
+	for (const [key, value] of Object.entries(attrs)) {
+		if (key === "level") continue;
+		if (value !== null && value !== void 0) opts[key] = value;
+	}
+	return opts;
+}
+/** Structural/semantic keys expressed elsewhere (heading handled separately, list handling, run children). */
+const SKIP_KEYS = new Set([
+	"heading",
+	"style",
+	"bullet",
+	"numbering",
+	"run",
+	"children",
+	"text",
+	"thematicBreak"
+]);
+function parseDocx(opts) {
+	const resolved = typeof opts === "string" ? { text: opts } : opts;
+	const attrs = {};
+	if (resolved.heading) {
+		const level = HEADING_PARSE_MAP[resolved.heading];
+		if (level) attrs.level = level;
+	}
+	for (const [key, value] of Object.entries(resolved)) {
+		if (SKIP_KEYS.has(key)) continue;
+		attrs[key] = value ?? null;
+	}
+	return attrs;
+}
+const attrNative = () => ({
+	default: null,
+	parseHTML: () => null,
+	rendered: false
+});
+const Heading = Heading$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			alignment: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => alignmentFromElement(el)
+			},
+			indent: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => indentFromElement(el)
+			},
+			spacing: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => spacingFromElement(el)
+			},
+			shading: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => shadingFromElement(el)
+			},
+			border: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => bordersFromElement(el)
+			},
+			frame: attrNative(),
+			keepNext: attrNative(),
+			keepLines: attrNative(),
+			pageBreakBefore: attrNative(),
+			widowControl: attrNative(),
+			contextualSpacing: attrNative(),
+			bidirectional: attrNative(),
+			outlineLevel: attrNative(),
+			textDirection: attrNative(),
+			textAlignment: attrNative(),
+			suppressLineNumbers: attrNative(),
+			wordWrap: attrNative(),
+			overflowPunctuation: attrNative(),
+			autoSpaceEastAsianText: attrNative(),
+			suppressOverlap: attrNative(),
+			suppressAutoHyphens: attrNative(),
+			adjustRightInd: attrNative(),
+			snapToGrid: attrNative(),
+			mirrorIndents: attrNative(),
+			kinsoku: attrNative(),
+			topLinePunct: attrNative(),
+			autoSpaceDE: attrNative(),
+			textboxTightWrap: attrNative(),
+			rightTabStop: attrNative(),
+			leftTabStop: attrNative(),
+			divId: attrNative(),
+			tabStops: attrNative(),
+			cnfStyle: attrNative()
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		const styles = renderParagraphStyles(node.attrs);
+		const level = node.attrs?.level ?? 1;
+		const attrs = { ...HTMLAttributes };
+		if (styles.length > 0) attrs.style = styles.join(";");
+		return [
+			`h${level}`,
+			attrs,
+			0
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
+export { Heading, parseDocx, renderDocx };

package/dist/extensions/image.d.mts

@@ -0,0 +1,2 @@
+import { i as renderDocx, n as parseDocx, r as renderCropAttrs, t as Image } from "../image-Ge1y6uam.mjs";
+export { Image, parseDocx, renderCropAttrs, renderDocx };