@docen/docx 0.3.0 → 0.3.1

package/dist/image-CuEIXoZl.mjs

@@ -0,0 +1,334 @@
+import { _ as Image$1 } from "./tiptap-D7pl4I5U.mjs";
+//#region src/extensions/image.ts
+/**
+* Custom Image extension with node-level renderHTML + renderDocx/parseDocx.
+*
+* Attrs:
+*  - src/alt/title/width/height: Tiptap structural names (kept verbatim so base
+*    image commands work).
+*  - rotation: editor display only (CSS transform) but also carried through DOCX
+*    via transformation.rotation (MediaTransformation.rotation).
+*  - floating/outline: nested office-open objects (Floating / OutlineOptions).
+*  - crop: nested office-open SourceRectangleOptions (srcRect).
+*  - display: editor-only display hint, no OOXML equivalent.
+*
+* DOCX round-trip is near-identity: renderDocx packs attrs into CoreImageOptions;
+* parseDocx unpacks them back. src is a data URL ↔ { type, data } base64.
+* Node-level renderHTML solves the style merge problem (rotation + floating).
+*/
+/** Attribute spec for a nested office-open value stored as JSON in a data-* attr. */
+const attrDataJson = (name) => ({
+	default: null,
+	rendered: false,
+	parseHTML: (element) => {
+		const raw = element.getAttribute(name);
+		if (!raw) return null;
+		try {
+			return JSON.parse(raw);
+		} catch {
+			return null;
+		}
+	}
+});
+/**
+* Tiptap JSON image node → CoreImageOptions-shaped object.
+*
+* Returns `{ image: ImageOptions }` (structural wrapper) or null when no
+* embedded image data is available (external URLs need pre-fetching).
+* rotation is carried via transformation.rotation (not dropped).
+*/
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const imageOpts = {};
+	const src = attrs.src;
+	if (src?.startsWith("data:image/")) {
+		const match = src.match(/^data:image\/([\w.+-]+);base64,(.+)$/);
+		if (match) {
+			imageOpts.type = match[1] === "jpeg" ? "jpg" : match[1];
+			const binary = atob(match[2]);
+			const bytes = new Uint8Array(binary.length);
+			for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+			imageOpts.data = bytes;
+		}
+	}
+	if (!imageOpts.data) return null;
+	const transformation = {
+		width: attrs.width ?? 600,
+		height: attrs.height ?? 400
+	};
+	const rotation = attrs.rotation;
+	if (rotation != null) transformation.rotation = rotation;
+	imageOpts.transformation = transformation;
+	const altText = {};
+	if (attrs.alt) altText.name = attrs.alt;
+	if (attrs.title) altText.description = attrs.title;
+	if (Object.keys(altText).length > 0) imageOpts.altText = altText;
+	if (attrs.floating) imageOpts.floating = attrs.floating;
+	if (attrs.crop) imageOpts.sourceRectangle = attrs.crop;
+	if (attrs.outline) imageOpts.outline = attrs.outline;
+	if (attrs.nonVisualProperties) imageOpts.nonVisualProperties = attrs.nonVisualProperties;
+	if (attrs.effectExtent) transformation.effectExtent = attrs.effectExtent;
+	if (attrs.graphicFrameLocks) imageOpts.graphicFrameLocks = attrs.graphicFrameLocks;
+	if (attrs.blipEffects) imageOpts.blipEffects = attrs.blipEffects;
+	if (attrs.useLocalDpi !== null && attrs.useLocalDpi !== void 0) imageOpts.useLocalDpi = attrs.useLocalDpi;
+	if (attrs.fill) imageOpts.fill = attrs.fill;
+	if (attrs.effects) imageOpts.effects = attrs.effects;
+	if (attrs.tile) imageOpts.tile = attrs.tile;
+	if (attrs.runPropertiesRawXml) imageOpts.runPropertiesRawXml = attrs.runPropertiesRawXml;
+	return { image: imageOpts };
+}
+/**
+* ImageOptions-shaped object → Tiptap attrs.
+*
+* Near-identity unpack: transformation → width/height/rotation, altText → alt/title,
+* floating/srcRect(→crop)/outline passed through verbatim. src is reconstructed by
+* DocxManager from the image data bytes (kept out of parseDocx).
+*/
+function parseDocx(imageOpts) {
+	const opts = imageOpts ?? {};
+	const attrs = {};
+	const transformation = opts.transformation;
+	if (transformation) {
+		if (typeof transformation.width === "number") attrs.width = transformation.width;
+		if (typeof transformation.height === "number") attrs.height = transformation.height;
+		if (typeof transformation.rotation === "number") attrs.rotation = transformation.rotation;
+	}
+	const altText = opts.altText;
+	if (altText) {
+		if (altText.name) attrs.alt = altText.name;
+		if (altText.description) attrs.title = altText.description;
+	}
+	if (opts.floating) attrs.floating = opts.floating;
+	if (opts.sourceRectangle) attrs.crop = opts.sourceRectangle;
+	if (opts.outline) attrs.outline = opts.outline;
+	if (opts.nonVisualProperties) attrs.nonVisualProperties = opts.nonVisualProperties;
+	const effectExtent = opts.transformation?.effectExtent;
+	if (effectExtent) attrs.effectExtent = effectExtent;
+	if (opts.graphicFrameLocks) attrs.graphicFrameLocks = opts.graphicFrameLocks;
+	if (opts.blipEffects) attrs.blipEffects = opts.blipEffects;
+	if (opts.useLocalDpi !== void 0) attrs.useLocalDpi = opts.useLocalDpi;
+	if (opts.fill) attrs.fill = opts.fill;
+	if (opts.effects) attrs.effects = opts.effects;
+	if (opts.tile) attrs.tile = opts.tile;
+	if (opts.runPropertiesRawXml) attrs.runPropertiesRawXml = opts.runPropertiesRawXml;
+	return attrs;
+}
+/**
+* Render crop as background-image styles for byte-accurate four-sided srcRect.
+*
+* object-fit:cover scales uniformly, so it only matches single-axis crops; for
+* two-sided crops it shrinks the whole image and shows too much. background-size
+* scales each axis independently (W/visibleW × H/visibleH), so the visible
+* srcRect region always maps exactly onto the extent box. background-position
+* then shifts the original so the cropped-left/top region falls outside the box.
+*
+* Requires a div[role=img] host (see Image.renderHTML) — an <img> cannot
+* background-crop itself, since its src is always painted in the foreground.
+*/
+function renderCropAttrs(crop, ctx = {}) {
+	const c = crop;
+	const leftPct = (c.left || 0) / 1e5;
+	const topPct = (c.top || 0) / 1e5;
+	const rightPct = (c.right || 0) / 1e5;
+	const bottomPct = (c.bottom || 0) / 1e5;
+	const visibleW = 1 - leftPct - rightPct;
+	const visibleH = 1 - topPct - bottomPct;
+	const w = ctx.width ?? 0;
+	const h = ctx.height ?? 0;
+	const bgW = visibleW > 0 ? w / visibleW : w;
+	const bgH = visibleH > 0 ? h / visibleH : h;
+	const posX = leftPct + rightPct > 0 ? leftPct / (leftPct + rightPct) * 100 : 50;
+	const posY = topPct + bottomPct > 0 ? topPct / (topPct + bottomPct) * 100 : 50;
+	return { style: [
+		`background-image:url(${ctx.src ?? ""})`,
+		`background-size:${bgW.toFixed(2)}px ${bgH.toFixed(2)}px`,
+		`background-position:${posX.toFixed(2)}% ${posY.toFixed(2)}%`,
+		"background-repeat:no-repeat"
+	].join(";") };
+}
+function renderImageStyles(attrs) {
+	const styles = [];
+	if (attrs.display) styles.push(`display:${attrs.display}`);
+	if (attrs.rotation) styles.push(`transform:rotate(${attrs.rotation}deg)`);
+	const f = attrs.floating;
+	if (f) {
+		styles.push(f.behindDocument ? "z-index:-1" : "z-index:1");
+		const wrapType = f.wrap?.type ?? 0;
+		if (wrapType === 0) styles.push("position:absolute");
+		else if (wrapType === 1) {
+			const align = f.horizontalPosition?.align;
+			if (align === "left" || align === "inside") styles.push("float:left");
+			else if (align === "right" || align === "outside") styles.push("float:right");
+			else styles.push("float:left");
+		} else if (wrapType === 2) {
+			styles.push("float:left");
+			styles.push("shape-outside:margin-box");
+		} else if (wrapType === 3) {
+			styles.push("display:block");
+			styles.push("clear:both");
+		} else styles.push("display:inline-block");
+		const m = f.margins;
+		if (m) {
+			if (m.top) styles.push(`margin-top:${(m.top * 96 / 1440).toFixed(1)}pt`);
+			if (m.bottom) styles.push(`margin-bottom:${(m.bottom * 96 / 1440).toFixed(1)}pt`);
+			if (m.left) styles.push(`margin-left:${(m.left * 96 / 1440).toFixed(1)}pt`);
+			if (m.right) styles.push(`margin-right:${(m.right * 96 / 1440).toFixed(1)}pt`);
+		}
+	}
+	return styles;
+}
+/**
+* Stamp the nested office-open attrs onto an HTML attribute map as JSON
+* data-* pairs. Shared by the cropped-div and plain-img render branches so the
+* fidelity fields (floating/outline/nonVisualProperties/…) round-trip through
+* HTML identically. `crop` is handled separately (crop branch only).
+*/
+const RAW_ATTR_DATA = [
+	["floating", "data-floating"],
+	["outline", "data-outline"],
+	["nonVisualProperties", "data-non-visual"],
+	["effectExtent", "data-effect-extent"],
+	["graphicFrameLocks", "data-graphic-frame-locks"],
+	["blipEffects", "data-blip-effects"],
+	["useLocalDpi", "data-use-local-dpi"],
+	["fill", "data-fill"],
+	["effects", "data-effects"],
+	["tile", "data-tile"],
+	["runPropertiesRawXml", "data-run-properties-raw-xml"]
+];
+function attachRawAttrs(target, attrs) {
+	for (const [attr, data] of RAW_ATTR_DATA) {
+		const value = attrs[attr];
+		if (value !== null && value !== void 0) target[data] = JSON.stringify(value);
+	}
+}
+const Image = Image$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			display: {
+				default: null,
+				rendered: false,
+				parseHTML: () => this.options.inline ? "inline-block" : null
+			},
+			rotation: {
+				default: null,
+				rendered: false,
+				parseHTML: (element) => {
+					const match = (element.getAttribute("style") || "").match(/transform:\s*rotate\(([\d.]+)deg\)/);
+					return match ? parseFloat(match[1]) : null;
+				}
+			},
+			floating: {
+				default: null,
+				rendered: false,
+				parseHTML: (element) => {
+					const raw = element.getAttribute("data-floating");
+					if (!raw) return null;
+					try {
+						return JSON.parse(raw);
+					} catch {
+						return null;
+					}
+				}
+			},
+			outline: {
+				default: null,
+				rendered: false,
+				parseHTML: (element) => {
+					const raw = element.getAttribute("data-outline");
+					if (!raw) return null;
+					try {
+						return JSON.parse(raw);
+					} catch {
+						return null;
+					}
+				}
+			},
+			crop: {
+				default: null,
+				rendered: false,
+				parseHTML: (element) => {
+					const raw = element.getAttribute("data-crop");
+					if (!raw) return null;
+					try {
+						return JSON.parse(raw);
+					} catch {
+						return null;
+					}
+				}
+			},
+			nonVisualProperties: attrDataJson("data-non-visual"),
+			effectExtent: attrDataJson("data-effect-extent"),
+			graphicFrameLocks: attrDataJson("data-graphic-frame-locks"),
+			blipEffects: attrDataJson("data-blip-effects"),
+			useLocalDpi: attrDataJson("data-use-local-dpi"),
+			fill: attrDataJson("data-fill"),
+			effects: attrDataJson("data-effects"),
+			tile: attrDataJson("data-tile"),
+			runPropertiesRawXml: attrDataJson("data-run-properties-raw-xml")
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		const attrs = node.attrs;
+		if (attrs.crop) {
+			const width = attrs.width;
+			const height = attrs.height;
+			const styles = renderImageStyles(attrs);
+			const crop = renderCropAttrs(attrs.crop, {
+				width,
+				height,
+				src: attrs.src
+			});
+			styles.push(crop.style, `width:${width}px`, `height:${height}px`);
+			const divAttrs = {
+				"data-image": "crop",
+				role: "img",
+				style: styles.join(";")
+			};
+			if (attrs.alt) divAttrs["aria-label"] = attrs.alt;
+			if (attrs.title) divAttrs["title"] = attrs.title;
+			attachRawAttrs(divAttrs, attrs);
+			divAttrs["data-crop"] = JSON.stringify(attrs.crop);
+			return ["div", divAttrs];
+		}
+		const htmlAttrs = { ...HTMLAttributes };
+		const styles = renderImageStyles(attrs);
+		if (styles.length > 0) htmlAttrs.style = styles.join(";");
+		attachRawAttrs(htmlAttrs, attrs);
+		return ["img", htmlAttrs];
+	},
+	parseHTML() {
+		return [{
+			tag: "div[data-image=crop]",
+			getAttrs: (el) => parseCropDiv(el)
+		}, { tag: "img[src]" }];
+	},
+	renderDocx,
+	parseDocx
+});
+/**
+* Reverse-parse a cropped div[role=img] back into image attrs.
+*
+* Covers only what the attribute-level parseHTML rules cannot recover from a
+* div: src (background-image), width/height (inline style extent box), and
+* alt/title (aria-label/title). rotation/crop/floating/outline are left to
+* their attribute parseHTML rules, which read the style/data-* the div carries.
+*/
+function parseCropDiv(el) {
+	const style = el.getAttribute("style") || "";
+	const attrs = {};
+	const bgMatch = style.match(/background-image:\s*url\(\s*([^)]+?)\s*\)/);
+	if (bgMatch) attrs.src = bgMatch[1].replace(/^['"]|['"]$/g, "");
+	const wMatch = style.match(/(?:^|;)\s*width:\s*([\d.]+)px/);
+	const hMatch = style.match(/(?:^|;)\s*height:\s*([\d.]+)px/);
+	if (wMatch) attrs.width = parseFloat(wMatch[1]);
+	if (hMatch) attrs.height = parseFloat(hMatch[1]);
+	const ariaLabel = el.getAttribute("aria-label");
+	if (ariaLabel) attrs.alt = ariaLabel;
+	const title = el.getAttribute("title");
+	if (title) attrs.title = title;
+	return attrs;
+}
+//#endregion
+export { renderDocx as i, parseDocx as n, renderCropAttrs as r, Image as t };

package/dist/index.d.mts

@@ -1,12 +1,14 @@
-import { a as JSONContent, c as StarterKit, d as docxExtensions, f as tiptapMarkExtensions, l as StarterKitOptions, p as tiptapNodeExtensions, t as AnyExtension } from "./core-omBKMRtl.mjs";
-import { ImageFetchHandler, PrepareStep, fetchImageHandler, prepareDocument, prepareImages } from "./converters/prepare.mjs";
-import { DocxGenerateOptions, DocxManager, compileDocument, generateDOCX, generateDOCXStream, generateDOCXSync, parseDOCX, resolveDocument } from "./converters/docx.mjs";
-import { generateHTML, parseHTML } from "./converters/html.mjs";
-import { generateMarkdown, parseMarkdown } from "./converters/markdown.mjs";
-import { DocxPatchContent, DocxPatchOptions, patchDOCX } from "./converters/patch.mjs";
-import { DocxEditorOptions, createDocxEditor } from "./editor.mjs";
+import { n as createDocument, t as Document } from "./document-BH1y4qHM.mjs";
+import { a as JSONContent, c as DocxKit, d as docxExtensions, f as tiptapMarkExtensions, l as DocxKitOptions, p as tiptapNodeExtensions, t as AnyExtension } from "./core-fBMCCj4D.mjs";
+import { i as prepareDocument, n as PrepareStep, o as prepareImages, r as fetchImageHandler, t as ImageFetchHandler } from "./prepare-CPAvcv6q.mjs";
+import { a as generateDOCX, c as parseDOCX, i as compileDocument, l as resolveDocument, n as DocxGenerateOptions, o as generateDOCXStream, r as DocxManager, s as generateDOCXSync } from "./docx-C5wyjI-0.mjs";
+import { n as parseHTML, t as generateHTML } from "./html-DCC_DSHv.mjs";
+import { n as parseMarkdown, t as generateMarkdown } from "./markdown-D0k0sRYS.mjs";
+import { n as DocxPatchOptions, r as patchDOCX, t as DocxPatchContent } from "./patch-Cdp5WKJz.mjs";
+import { a as inlineStyles, i as effectiveRunProps, n as StylesOptions, o as quickStyles, s as stylesToCss, t as QuickStyleEntry } from "./styles-ugspkrxz.mjs";
+import { n as createDocxEditor, t as DocxEditorOptions } from "./editor-DReY3Rb9.mjs";
 import { JSONContent as TiptapJSONContent } from "@tiptap/core";
-import { AlignmentType, BookmarkOptions, BorderOptions, BordersOptions, DocumentOptions, EmphasisMarkType, ExternalHyperlinkOptions, Floating, FontAttributesProperties, FrameOptions, HeadingLevel, HeightRule, HighlightColor, ImageChild, ImageOptions, IndentAttributesProperties, InternalHyperlinkOptions, LeaderType, LevelParagraphStylePropertiesOptions, LineRuleType, Margins, MathChild, MathInput, MediaTransformation, ParagraphChild, ParagraphOptions, ParagraphPropertiesOptions, ParagraphPropertiesOptionsBase, ParagraphPropertiesOptionsBase as ParagraphPropertiesOptionsBase$1, ParagraphRunPropertiesOptions, ParagraphStylePropertiesOptions, RubyOptions, RunOptions, RunPropertiesOptions, RunStylePropertiesOptions, RunStylePropertiesOptions as RunStylePropertiesOptions$1, SectionChild, SectionOptions, ShadingAttributesProperties, SpacingProperties, TabStopDefinition, TabStopPosition, TabStopType, TableBordersOptions, TableCellBordersOptions, TableCellOptions, TableCellOptions as TableCellOptions$1, TableFloatOptions, TableLayoutType, TableLookOptions, TableOptions, TableOptions as TableOptions$1, TableRowOptions, TableRowPropertiesOptionsBase, TableRowPropertiesOptionsBase as TableRowPropertiesOptionsBase$1, TableVerticalAlign, TableWidthProperties, TextAlignmentType, UnderlineType, WidthType } from "@office-open/docx";
+import { AlignmentType, BookmarkOptions, BorderOptions, BordersOptions, DocumentOptions, EmphasisMarkType, ExternalHyperlinkOptions, Floating, Floating as Floating$1, FontAttributesProperties, FrameOptions, HeadingLevel, HeightRule, HighlightColor, ImageChild, ImageOptions, ImageOptions as ImageOptions$1, IndentAttributesProperties, InternalHyperlinkOptions, LeaderType, LevelParagraphStylePropertiesOptions, LineRuleType, Margins, MathChild, MathInput, MediaTransformation, ParagraphChild, ParagraphOptions, ParagraphPropertiesOptions, ParagraphPropertiesOptionsBase, ParagraphRunPropertiesOptions, ParagraphStylePropertiesOptions, RubyOptions, RunOptions, RunPropertiesOptions, RunStylePropertiesOptions, SectionChild, SectionOptions, SectionPropertiesOptions, ShadingAttributesProperties, SpacingProperties, TabStopDefinition, TabStopPosition, TabStopType, TableBordersOptions, TableCellBordersOptions, TableCellOptions, TableFloatOptions, TableLayoutType, TableLookOptions, TableOptions, TableRowOptions, TableRowPropertiesOptionsBase, TableVerticalAlign, TableWidthProperties, TextAlignmentType, UnderlineType, WidthType } from "@office-open/docx";
 
 //#region src/types.d.ts
 /**
@@ -20,14 +22,14 @@ type AttrNullable<T> = { [K in keyof T]-?: T[K] | null };
  * indent/spacing/border/run/frame are nested objects (matching office-open),
  * so one `indent` attr replaces 13 flattened indent attrs.
  */
-type ParagraphAttrs = AttrNullable<ParagraphPropertiesOptionsBase$1>;
+type ParagraphAttrs = AttrNullable<ParagraphPropertiesOptionsBase>;
 /**
  * Text style mark attrs — mirrors RunStylePropertiesOptions.
  *
  * Omits properties handled by dedicated marks (bold, italic, strike,
  * doubleStrike, subScript, superScript). `size` is in POINTS.
  */
-type TextStyleAttrs = AttrNullable<Omit<RunStylePropertiesOptions$1, "bold" | "boldComplexScript" | "italic" | "italicComplexScript" | "strike" | "doubleStrike" | "subScript" | "superScript">>;
+type TextStyleAttrs = AttrNullable<Omit<RunStylePropertiesOptions, "bold" | "boldComplexScript" | "italic" | "italicComplexScript" | "strike" | "doubleStrike" | "subScript" | "superScript">>;
 /**
  * Link mark attrs.
  */
@@ -41,19 +43,19 @@ interface LinkAttrs {
 /**
  * Table attrs — mirrors TableOptions (minus `rows`, which is structural).
  */
-type TableAttrs = AttrNullable<Omit<TableOptions$1, "rows">>;
+type TableAttrs = AttrNullable<Omit<TableOptions, "rows">>;
 /**
  * Table row attrs — mirrors TableRowPropertiesOptionsBase.
  * height is nested { value, rule } matching office-open.
  */
-type TableRowAttrs = AttrNullable<TableRowPropertiesOptionsBase$1>;
+type TableRowAttrs = AttrNullable<TableRowPropertiesOptionsBase>;
 /**
  * Table cell / header attrs — mirrors TableCellOptions.
  *
  * colspan/rowspan/colwidth kept as Tiptap structural names (base extension
  * dependent); office-open columnSpan/rowSpan are mapped in renderDocx.
  */
-type TableCellAttrs = AttrNullable<Omit<TableCellOptions$1, "children" | "columnSpan" | "rowSpan">> & {
+type TableCellAttrs = AttrNullable<Omit<TableCellOptions, "children" | "columnSpan" | "rowSpan">> & {
   /** Horizontal span (Tiptap base name; maps to office-open columnSpan). */colspan: number; /** Vertical span (Tiptap base name; maps to office-open rowSpan). */
   rowspan: number; /** Column width in pixels per cell (Tiptap base name). */
   colwidth: number[] | null;
@@ -70,10 +72,33 @@ interface ImageAttrs {
   width: number | null;
   height: number | null;
   rotation: number | null;
-  floating: Record<string, unknown> | null;
-  outline: Record<string, unknown> | null;
-  crop: Record<string, unknown> | null;
+  floating: Floating$1 | null;
+  outline: NonNullable<ImageOptions$1["outline"]> | null;
+  crop: NonNullable<ImageOptions$1["sourceRectangle"]> | null;
   display: string | null;
+  nonVisualProperties: NonNullable<ImageOptions$1["nonVisualProperties"]> | null;
+  effectExtent: {
+    l: number;
+    t: number;
+    r: number;
+    b: number;
+  } | null;
+  graphicFrameLocks: NonNullable<ImageOptions$1["graphicFrameLocks"]> | null;
+  blipEffects: NonNullable<ImageOptions$1["blipEffects"]> | null;
+  useLocalDpi: boolean | null;
+  fill: NonNullable<ImageOptions$1["fill"]> | null;
+  effects: NonNullable<ImageOptions$1["effects"]> | null;
+  tile: NonNullable<ImageOptions$1["tile"]> | null;
+  runPropertiesRawXml: string | null;
+}
+/**
+ * Emoji node attrs.
+ * `name` is the shortcode (base @tiptap/extension-emoji); `emoji` is the
+ * resolved glyph cached for DOCX export (null when only the shortcode is known).
+ */
+interface EmojiAttrs {
+  name: string | null;
+  emoji: string | null;
 }
 /**
  * Strike mark attrs.
@@ -120,7 +145,7 @@ type Mark = {
 interface ParagraphNode extends TiptapJSONContent {
   type: "paragraph";
   attrs?: ParagraphAttrs;
-  content?: Array<TextNode | HardBreakNode | ImageNode>;
+  content?: Array<TextNode | HardBreakNode | ImageNode | EmojiNode>;
 }
 interface HeadingNode extends TiptapJSONContent {
   type: "heading";
@@ -143,6 +168,16 @@ interface CodeBlockNode extends TiptapJSONContent {
 interface HorizontalRuleNode extends TiptapJSONContent {
   type: "horizontalRule";
 }
+/**
+ * Header/footer slots in Tiptap JSON — each slot is the JSONContent[] produced
+ * by resolving that slot's SectionChild[] (paragraphs/tables/…). Mirrors
+ * SectionOptions.headers/footers in the runtime model.
+ */
+interface HeaderFooterSlots {
+  default?: TiptapJSONContent[];
+  first?: TiptapJSONContent[];
+  even?: TiptapJSONContent[];
+}
 interface BulletListNode extends TiptapJSONContent {
   type: "bulletList";
   content?: Array<ListItemNode>;
@@ -195,6 +230,21 @@ interface ImageNode extends TiptapJSONContent {
   type: "image";
   attrs?: ImageAttrs;
 }
+/**
+ * Drawing group (wpg) carried as an opaque blob — the full WpgGroupRunOptions
+ * (pictures/shapes/nested groups + transform) round-trips verbatim. The editor
+ * doesn't model the group interior; renderHTML paints the first picture only.
+ */
+interface ImageGroupNode extends TiptapJSONContent {
+  type: "imageGroup";
+  attrs?: {
+    wpgGroup: Record<string, unknown> | null;
+  };
+}
+interface EmojiNode extends TiptapJSONContent {
+  type: "emoji";
+  attrs?: EmojiAttrs;
+}
 interface DetailsNode extends TiptapJSONContent {
   type: "details";
   content?: Array<DetailsSummaryNode | DetailsContentNode>;
@@ -210,4 +260,4 @@ interface DetailsContentNode extends TiptapJSONContent {
 type InlineContent = TextNode | HardBreakNode;
 type BlockNode = ParagraphNode | HeadingNode | BlockquoteNode | CodeBlockNode | HorizontalRuleNode | BulletListNode | OrderedListNode | TaskListNode | TableNode | ImageNode | DetailsNode;
 //#endregion
-export { type AlignmentType, type AnyExtension, type AttrNullable, type BlockNode, type BlockquoteNode, type BookmarkOptions, type BorderOptions, type BordersOptions, type BulletListNode, type CodeBlockNode, type DetailsContentNode, type DetailsNode, type DetailsSummaryNode, type DocumentOptions, type DocxEditorOptions, type DocxGenerateOptions, DocxManager, type DocxPatchContent, type DocxPatchOptions, type EmphasisMarkType, type ExternalHyperlinkOptions, type Floating, type FontAttributesProperties, type FrameOptions, type HardBreakNode, type HeadingLevel, type HeadingNode, type HeightRule, type HighlightColor, type HorizontalRuleNode, type ImageAttrs, type ImageChild, type ImageFetchHandler, type ImageNode, type ImageOptions, type IndentAttributesProperties, type InlineContent, type InternalHyperlinkOptions, type JSONContent, type LeaderType, type LevelParagraphStylePropertiesOptions, type LineRuleType, type LinkAttrs, type ListItemNode, type Margins, type Mark, type MathChild, type MathInput, type MediaTransformation, type OrderedListNode, type ParagraphAttrs, type ParagraphChild, type ParagraphNode, type ParagraphOptions, type ParagraphPropertiesOptions, type ParagraphPropertiesOptionsBase, type ParagraphRunPropertiesOptions, type ParagraphStylePropertiesOptions, type PrepareStep, type RubyOptions, type RunOptions, type RunPropertiesOptions, type RunStylePropertiesOptions, type SectionChild, type SectionOptions, type ShadingAttributesProperties, type SpacingProperties, StarterKit, type StarterKitOptions, type StrikeAttrs, type TabStopDefinition, type TabStopPosition, type TabStopType, type TableAttrs, type TableBordersOptions, type TableCellAttrs, type TableCellBordersOptions, type TableCellNode, type TableCellOptions, type TableFloatOptions, type TableHeaderNode, type TableLayoutType, type TableLookOptions, type TableNode, type TableOptions, type TableRowAttrs, type TableRowNode, type TableRowOptions, type TableRowPropertiesOptionsBase, type TableVerticalAlign, type TableWidthProperties, type TaskItemNode, type TaskListNode, type TextAlignmentType, type TextNode, type TextStyleAttrs, type UnderlineType, type WidthType, compileDocument, createDocxEditor, docxExtensions, fetchImageHandler, generateDOCX, generateDOCXStream, generateDOCXSync, generateHTML, generateMarkdown, parseDOCX, parseHTML, parseMarkdown, patchDOCX, prepareDocument, prepareImages, resolveDocument, tiptapMarkExtensions, tiptapNodeExtensions };
+export { type AlignmentType, type AnyExtension, type AttrNullable, type BlockNode, type BlockquoteNode, type BookmarkOptions, type BorderOptions, type BordersOptions, type BulletListNode, type CodeBlockNode, type DetailsContentNode, type DetailsNode, type DetailsSummaryNode, Document, type DocumentOptions, type DocxEditorOptions, type DocxGenerateOptions, DocxKit, type DocxKitOptions, DocxManager, type DocxPatchContent, type DocxPatchOptions, type EmojiAttrs, type EmojiNode, type EmphasisMarkType, type ExternalHyperlinkOptions, type Floating, type FontAttributesProperties, type FrameOptions, type HardBreakNode, type HeaderFooterSlots, type HeadingLevel, type HeadingNode, type HeightRule, type HighlightColor, type HorizontalRuleNode, type ImageAttrs, type ImageChild, type ImageFetchHandler, type ImageGroupNode, type ImageNode, type ImageOptions, type IndentAttributesProperties, type InlineContent, type InternalHyperlinkOptions, type JSONContent, type LeaderType, type LevelParagraphStylePropertiesOptions, type LineRuleType, type LinkAttrs, type ListItemNode, type Margins, type Mark, type MathChild, type MathInput, type MediaTransformation, type OrderedListNode, type ParagraphAttrs, type ParagraphChild, type ParagraphNode, type ParagraphOptions, type ParagraphPropertiesOptions, type ParagraphPropertiesOptionsBase, type ParagraphRunPropertiesOptions, type ParagraphStylePropertiesOptions, type PrepareStep, type QuickStyleEntry, type RubyOptions, type RunOptions, type RunPropertiesOptions, type RunStylePropertiesOptions, type SectionChild, type SectionOptions, type SectionPropertiesOptions, type ShadingAttributesProperties, type SpacingProperties, type StrikeAttrs, type StylesOptions, type TabStopDefinition, type TabStopPosition, type TabStopType, type TableAttrs, type TableBordersOptions, type TableCellAttrs, type TableCellBordersOptions, type TableCellNode, type TableCellOptions, type TableFloatOptions, type TableHeaderNode, type TableLayoutType, type TableLookOptions, type TableNode, type TableOptions, type TableRowAttrs, type TableRowNode, type TableRowOptions, type TableRowPropertiesOptionsBase, type TableVerticalAlign, type TableWidthProperties, type TaskItemNode, type TaskListNode, type TextAlignmentType, type TextNode, type TextStyleAttrs, type UnderlineType, type WidthType, compileDocument, createDocument, createDocxEditor, docxExtensions, effectiveRunProps, fetchImageHandler, generateDOCX, generateDOCXStream, generateDOCXSync, generateHTML, generateMarkdown, inlineStyles, parseDOCX, parseHTML, parseMarkdown, patchDOCX, prepareDocument, prepareImages, quickStyles, resolveDocument, stylesToCss, tiptapMarkExtensions, tiptapNodeExtensions };

package/dist/index.mjs

@@ -1,8 +1,10 @@
-import { a as StarterKit, c as tiptapMarkExtensions, l as tiptapNodeExtensions, s as docxExtensions } from "./core-CFIQVRfx.mjs";
-import { createDocxEditor } from "./editor.mjs";
-import { fetchImageHandler, prepareDocument, prepareImages } from "./converters/prepare.mjs";
-import { DocxManager, compileDocument, generateDOCX, generateDOCXStream, generateDOCXSync, parseDOCX, resolveDocument } from "./converters/docx.mjs";
-import { patchDOCX } from "./converters/patch.mjs";
-import { generateHTML, parseHTML } from "./converters/html.mjs";
-import { generateMarkdown, parseMarkdown } from "./converters/markdown.mjs";
-export { DocxManager, StarterKit, compileDocument, createDocxEditor, docxExtensions, fetchImageHandler, generateDOCX, generateDOCXStream, generateDOCXSync, generateHTML, generateMarkdown, parseDOCX, parseHTML, parseMarkdown, patchDOCX, prepareDocument, prepareImages, resolveDocument, tiptapMarkExtensions, tiptapNodeExtensions };
+import { a as DocxKit, c as tiptapMarkExtensions, l as tiptapNodeExtensions, s as docxExtensions } from "./core-DEqBHRzE.mjs";
+import { n as createDocument, t as Document } from "./document-CvTym-FM.mjs";
+import { t as createDocxEditor } from "./editor-Bf3CxQnY.mjs";
+import { i as prepareImages, n as prepareDocument, t as fetchImageHandler } from "./prepare-Bdk8Cjkf.mjs";
+import { a as generateDOCXSync, i as generateDOCXStream, n as compileDocument, o as parseDOCX, r as generateDOCX, s as resolveDocument, t as DocxManager } from "./docx-CONyAedl.mjs";
+import { t as patchDOCX } from "./patch-IZ13tXTu.mjs";
+import { n as parseHTML, t as generateHTML } from "./html-DedDWPoO.mjs";
+import { n as parseMarkdown, t as generateMarkdown } from "./markdown-BzJmRsBs.mjs";
+import { a as stylesToCss, i as quickStyles, n as effectiveRunProps, r as inlineStyles } from "./styles-QSX3RhxK.mjs";
+export { Document, DocxKit, DocxManager, compileDocument, createDocument, createDocxEditor, docxExtensions, effectiveRunProps, fetchImageHandler, generateDOCX, generateDOCXStream, generateDOCXSync, generateHTML, generateMarkdown, inlineStyles, parseDOCX, parseHTML, parseMarkdown, patchDOCX, prepareDocument, prepareImages, quickStyles, resolveDocument, stylesToCss, tiptapMarkExtensions, tiptapNodeExtensions };

package/dist/markdown-BzJmRsBs.mjs

@@ -0,0 +1,18 @@
+import { s as docxExtensions } from "./core-DEqBHRzE.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 { parseMarkdown as n, generateMarkdown as t };

package/dist/markdown-D0k0sRYS.d.mts

@@ -0,0 +1,13 @@
+import { a as JSONContent } from "./core-fBMCCj4D.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 { parseMarkdown as n, generateMarkdown as t };

package/dist/mention-C-dTR6MK.mjs

@@ -0,0 +1,44 @@
+import "./tiptap-D7pl4I5U.mjs";
+//#region src/extensions/mention.ts
+/**
+* Mention extension — owns the DOCX expression of an inline mention.
+*
+* A mention is an atom node carrying `{ id, label }`. DOCX has no mention
+* element, but an inline text-SDT (CT_SdtRun) is a reversible carrier: the
+* `id` rides in the SDT alias, the `label` as the SDT's run text, and a fixed
+* tag marks the type so resolve can recover the mention. (customXml would also
+* carry the id but triggers Word's i4i patent warning; SDT does not.)
+*/
+/** SDT tag marking a mention content control. */
+const MENTION_TAG = "docen-mention";
+/** Inline text-SDT carrying a mention (id in alias, label as run text). */
+function createMention(id, label) {
+	return { sdt: {
+		properties: {
+			tag: MENTION_TAG,
+			alias: id,
+			text: {}
+		},
+		children: [{ text: label }]
+	} };
+}
+/** True if an inline SDT child carries a mention. */
+function isMention(child) {
+	if (typeof child !== "object" || child === null || !("sdt" in child)) return false;
+	return child.sdt?.properties?.tag === MENTION_TAG;
+}
+/** Read a mention SDT → `{ id, label }`. */
+function readMention(child) {
+	const sdt = child.sdt;
+	const id = sdt?.properties?.alias ?? "";
+	let label = "";
+	const first = sdt?.children?.[0];
+	if (typeof first === "string") label = first;
+	else if (first && typeof first === "object" && "text" in first) label = String(first.text ?? "");
+	return {
+		id,
+		label
+	};
+}
+//#endregion
+export { readMention as i, createMention as n, isMention as r, MENTION_TAG as t };

package/dist/ordered-list-V-3xFQmV.mjs

@@ -0,0 +1,41 @@
+import "./tiptap-D7pl4I5U.mjs";
+import { LevelFormat } from "@office-open/docx";
+//#region src/extensions/ordered-list.ts
+/**
+* OrderedList extension — owns the DOCX expression of an ordered list.
+*
+* A Tiptap orderedList maps to a sequence of paragraphs referencing one
+* abstractNum (decimal). The reference is keyed by `start` so lists with the
+* same start share a definition; DocxManager gives each list its own instance
+* for independent counting. This module owns that abstractNum shape; DocxManager
+* owns the cross-paragraph tree walk, start recovery, and numbering-instance
+* bookkeeping.
+*/
+/** Reference prefix for generated ordered-list abstractNum definitions. */
+const ORDERED_REFERENCE_PREFIX = "docen-ordered";
+/** lvlText per nesting depth (level 0 → "%1.", … level 8 → "%9."). */
+const ORDERED_LEVEL_TEXT = [
+	"%1.",
+	"%2.",
+	"%3.",
+	"%4.",
+	"%5.",
+	"%6.",
+	"%7.",
+	"%8.",
+	"%9."
+];
+/**
+* Build nine decimal numbering levels for an ordered list. Level 0 carries
+* `start`; deeper levels restart at 1 (Word convention).
+*/
+function buildOrderedLevels(start) {
+	return Array.from({ length: 9 }, (_, level) => ({
+		level,
+		format: LevelFormat.DECIMAL,
+		start: level === 0 ? start : 1,
+		text: ORDERED_LEVEL_TEXT[level]
+	}));
+}
+//#endregion
+export { ORDERED_REFERENCE_PREFIX as n, buildOrderedLevels as r, ORDERED_LEVEL_TEXT as t };