@docen/docx 0.3.0 → 0.3.2

package/dist/extensions/image.mjs

@@ -1,4 +1,6 @@
 import { Image as Image$1 } from "./tiptap.mjs";
+import { floatAnchorScope, floatingToStyles } from "./utils.mjs";
+import { convertEmuToPixels } from "@office-open/core";
 //#region src/extensions/image.ts
 /**
 * Custom Image extension with node-level renderHTML + renderDocx/parseDocx.
@@ -16,6 +18,20 @@ import { Image as Image$1 } from "./tiptap.mjs";
 * 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.
 *
@@ -38,9 +54,11 @@ function renderDocx(node) {
 		}
 	}
 	if (!imageOpts.data) return null;
+	const width = attrs.width ?? 600;
+	const height = attrs.height ?? 400;
 	const transformation = {
-		width: attrs.width ?? 600,
-		height: attrs.height ?? 400
+		width: `${width}px`,
+		height: `${height}px`
 	};
 	const rotation = attrs.rotation;
 	if (rotation != null) transformation.rotation = rotation;
@@ -50,8 +68,17 @@ function renderDocx(node) {
 	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.srcRect = attrs.crop;
+	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 };
 }
 /**
@@ -66,8 +93,8 @@ function parseDocx(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.width === "number") attrs.width = convertEmuToPixels(transformation.width);
+		if (typeof transformation.height === "number") attrs.height = convertEmuToPixels(transformation.height);
 		if (typeof transformation.rotation === "number") attrs.rotation = transformation.rotation;
 	}
 	const altText = opts.altText;
@@ -76,57 +103,92 @@ function parseDocx(imageOpts) {
 		if (altText.description) attrs.title = altText.description;
 	}
 	if (opts.floating) attrs.floating = opts.floating;
-	if (opts.srcRect) attrs.crop = opts.srcRect;
+	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;
 }
-function renderCropAttrs(crop) {
+/**
+* Render crop as the inner <img> style for byte-accurate four-sided srcRect.
+*
+* object-fit:cover scales uniformly, so it only matches single-axis crops.
+* Instead the inner <img> is sized to the un-cropped display size per axis
+* (imgW = W/visibleW, imgH = H/visibleH) and translated so the visible srcRect
+* region maps exactly onto the extent box; the outer box clips (overflow:hidden)
+* the cropped-out left/top region. Mathematically equivalent to a
+* background-size/background-position crop, but keeps a real <img> (alt,
+* accessibility, semantics, drag-to-save).
+*/
+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 visibleWidthPct = 1 - leftPct - rightPct;
-	const visibleHeightPct = 1 - topPct - bottomPct;
-	const posX = visibleWidthPct > 0 ? leftPct / visibleWidthPct * 100 : 0;
-	const posY = visibleHeightPct > 0 ? topPct / visibleHeightPct * 100 : 0;
-	return { style: `object-fit:cover;object-position:${posX.toFixed(2)}% ${posY.toFixed(2)}%` };
+	const visibleW = 1 - leftPct - rightPct;
+	const visibleH = 1 - topPct - bottomPct;
+	const w = ctx.width ?? 0;
+	const h = ctx.height ?? 0;
+	const imgW = visibleW > 0 ? w / visibleW : w;
+	const imgH = visibleH > 0 ? h / visibleH : h;
+	const offX = -(leftPct * imgW);
+	const offY = -(topPct * imgH);
+	return { style: [
+		"display:block",
+		`width:${imgW.toFixed(2)}px`,
+		`height:${imgH.toFixed(2)}px`,
+		`transform:translate(${offX.toFixed(2)}px,${offY.toFixed(2)}px)`,
+		"transform-origin:0 0"
+	].join(";") };
 }
 function renderImageStyles(attrs) {
 	const styles = [];
 	if (attrs.display) styles.push(`display:${attrs.display}`);
+	else if (!attrs.floating) styles.push("display:inline-block");
 	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`);
-		}
-	}
-	if (attrs.crop) {
-		const cropAttrs = renderCropAttrs(attrs.crop);
-		styles.push(cropAttrs.style);
-	}
+	if (attrs.floating) styles.push(...floatingToStyles(attrs.floating, attrs.src, attrs.width));
 	return styles;
 }
+/** Office vector (GDI) formats the browser cannot decode — EMF/WMF render as
+*  a labeled placeholder (Image.renderHTML) instead of an <img> that decodes
+*  to naturalWidth 0 (an empty box). */
+function isVectorImage(src) {
+	return typeof src === "string" && /^data:image\/(?:x-)?(?:emf|wmf)/i.test(src);
+}
+/**
+* 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 {
@@ -144,6 +206,24 @@ const Image = Image$1.extend({
 					return match ? parseFloat(match[1]) : null;
 				}
 			},
+			width: { parseHTML: (element) => {
+				const attr = element.getAttribute("width");
+				if (attr != null) {
+					const n = parseFloat(attr);
+					if (!Number.isNaN(n)) return n;
+				}
+				const m = (element.getAttribute("style") || "").match(/(?:^|;)\s*width:\s*([\d.]+)px/);
+				return m ? parseFloat(m[1]) : null;
+			} },
+			height: { parseHTML: (element) => {
+				const attr = element.getAttribute("height");
+				if (attr != null) {
+					const n = parseFloat(attr);
+					if (!Number.isNaN(n)) return n;
+				}
+				const m = (element.getAttribute("style") || "").match(/(?:^|;)\s*height:\s*([\d.]+)px/);
+				return m ? parseFloat(m[1]) : null;
+			} },
 			floating: {
 				default: null,
 				rendered: false,
@@ -182,20 +262,135 @@ const Image = Image$1.extend({
 						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 styles = renderImageStyles(node.attrs);
-		const attrs = { ...HTMLAttributes };
-		if (styles.length > 0) attrs.style = styles.join(";");
-		if (node.attrs.floating) attrs["data-floating"] = JSON.stringify(node.attrs.floating);
-		if (node.attrs.outline) attrs["data-outline"] = JSON.stringify(node.attrs.outline);
-		if (node.attrs.crop) attrs["data-crop"] = JSON.stringify(node.attrs.crop);
-		return ["img", attrs];
+		const attrs = node.attrs;
+		const floatAnchor = attrs.floating && floatAnchorScope(attrs.floating) === "paragraph" ? "paragraph" : null;
+		if (isVectorImage(attrs.src)) {
+			const styles = renderImageStyles(attrs);
+			if (attrs.width != null) styles.push(`width:${attrs.width}px`);
+			if (attrs.height != null) styles.push(`height:${attrs.height}px`);
+			const divAttrs = {
+				"data-image": "vector",
+				role: "img",
+				"data-vector-src": attrs.src,
+				style: styles.join(";")
+			};
+			if (attrs.alt) divAttrs["aria-label"] = attrs.alt;
+			if (attrs.title) divAttrs["title"] = attrs.title;
+			attachRawAttrs(divAttrs, attrs);
+			if (floatAnchor) divAttrs["data-float-anchor"] = floatAnchor;
+			return [
+				"div",
+				divAttrs,
+				"Vector image"
+			];
+		}
+		if (attrs.crop) {
+			const width = attrs.width;
+			const height = attrs.height;
+			const boxStyles = renderImageStyles(attrs);
+			boxStyles.push("overflow:hidden", `width:${width}px`, `height:${height}px`);
+			const crop = renderCropAttrs(attrs.crop, {
+				width,
+				height
+			});
+			const boxAttrs = {
+				"data-image": "crop",
+				style: boxStyles.join(";")
+			};
+			attachRawAttrs(boxAttrs, attrs);
+			boxAttrs["data-crop"] = JSON.stringify(attrs.crop);
+			if (floatAnchor) boxAttrs["data-float-anchor"] = floatAnchor;
+			const imgAttrs = {
+				src: attrs.src,
+				style: crop.style
+			};
+			if (attrs.alt) imgAttrs.alt = attrs.alt;
+			if (attrs.title) imgAttrs.title = attrs.title;
+			return [
+				"span",
+				boxAttrs,
+				["img", imgAttrs]
+			];
+		}
+		const htmlAttrs = { ...HTMLAttributes };
+		const styles = renderImageStyles(attrs);
+		if (styles.length > 0) htmlAttrs.style = styles.join(";");
+		attachRawAttrs(htmlAttrs, attrs);
+		if (floatAnchor) htmlAttrs["data-float-anchor"] = floatAnchor;
+		return ["img", htmlAttrs];
+	},
+	parseHTML() {
+		return [
+			{
+				tag: "span[data-image=crop]",
+				getAttrs: (el) => parseCropDiv(el)
+			},
+			{
+				tag: "div[data-image=vector]",
+				getAttrs: (el) => parseVectorDiv(el)
+			},
+			{ tag: "img[src]" }
+		];
 	},
 	renderDocx,
 	parseDocx
 });
+/**
+* Reverse-parse a cropped span[extent-box] back into image attrs.
+*
+* src/alt/title live on the inner <img>; width/height on the outer box inline
+* style (the extent box, not the img's un-cropped display size).
+* rotation/crop/floating/outline are left to their attribute parseHTML rules,
+* which read the style/data-* the box carries.
+*/
+function parseCropDiv(el) {
+	const attrs = {};
+	const img = el.querySelector("img");
+	if (img) {
+		const src = img.getAttribute("src");
+		if (src) attrs.src = src;
+		const alt = img.getAttribute("alt");
+		if (alt) attrs.alt = alt;
+		const title = img.getAttribute("title");
+		if (title) attrs.title = title;
+	}
+	const style = el.getAttribute("style") || "";
+	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]);
+	return attrs;
+}
+/** Reverse-parse an EMF/WMF placeholder div back into image attrs: src from
+*  data-vector-src, extent from the inline width/height, alt/title from
+*  aria-label/title. Floating/rotation/etc. round-trip via attribute rules. */
+function parseVectorDiv(el) {
+	const attrs = {};
+	const src = el.getAttribute("data-vector-src");
+	if (src) attrs.src = src;
+	const style = el.getAttribute("style") || "";
+	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 { Image, parseDocx, renderCropAttrs, renderDocx };

package/dist/extensions/index.d.mts

@@ -1,2 +1,4 @@
-import { c as StarterKit, d as docxExtensions, f as tiptapMarkExtensions, l as StarterKitOptions, p as tiptapNodeExtensions } from "../core-omBKMRtl.mjs";
-export { StarterKit, type StarterKitOptions, docxExtensions, tiptapMarkExtensions, tiptapNodeExtensions };
+import { n as createDocument, t as Document } from "../document-BH1y4qHM.mjs";
+import { c as PageBreak, f as docxExtensions, l as DocxKit, m as tiptapNodeExtensions, p as tiptapMarkExtensions, u as DocxKitOptions } from "../core-C9VunJ8o.mjs";
+import { b as sectionLinePitchCss, k as twipsToMm, v as resolveFontName, x as sectionMarginCss, y as resolvePageSize } from "../utils-D87vukzp.mjs";
+export { Document, DocxKit, type DocxKitOptions, PageBreak, createDocument, docxExtensions, resolveFontName, resolvePageSize, sectionLinePitchCss, sectionMarginCss, tiptapMarkExtensions, tiptapNodeExtensions, twipsToMm };

package/dist/extensions/index.mjs

@@ -1,2 +1,4 @@
-import { a as StarterKit, c as tiptapMarkExtensions, l as tiptapNodeExtensions, s as docxExtensions } from "../core-CFIQVRfx.mjs";
-export { StarterKit, docxExtensions, tiptapMarkExtensions, tiptapNodeExtensions };
+import { a as DocxKit, c as tiptapMarkExtensions, g as PageBreak, l as tiptapNodeExtensions, s as docxExtensions } from "../core-DT9IrTzN.mjs";
+import { Document, createDocument } from "./document.mjs";
+import { resolveFontName, resolvePageSize, sectionLinePitchCss, sectionMarginCss, twipsToMm } from "./utils.mjs";
+export { Document, DocxKit, PageBreak, createDocument, docxExtensions, resolveFontName, resolvePageSize, sectionLinePitchCss, sectionMarginCss, tiptapMarkExtensions, tiptapNodeExtensions, twipsToMm };

package/dist/extensions/mention.d.mts

@@ -0,0 +1,25 @@
+import { b as Mention } from "../tiptap-pZsNPsvV.mjs";
+
+//#region src/extensions/mention.d.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. */
+declare const MENTION_TAG = "docen-mention";
+/** Inline text-SDT carrying a mention (id in alias, label as run text). */
+declare function createMention(id: string, label: string): Record<string, unknown>;
+/** True if an inline SDT child carries a mention. */
+declare function isMention(child: unknown): boolean;
+/** Read a mention SDT → `{ id, label }`. */
+declare function readMention(child: unknown): {
+  id: string;
+  label: string;
+};
+//#endregion
+export { MENTION_TAG, Mention, createMention, isMention, readMention };

package/dist/extensions/mention.mjs

@@ -0,0 +1,44 @@
+import { Mention } from "./tiptap.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 { MENTION_TAG, Mention, createMention, isMention, readMention };

package/dist/extensions/ordered-list.d.mts

@@ -0,0 +1,25 @@
+import { x as OrderedList } from "../tiptap-pZsNPsvV.mjs";
+import { LevelsOptions } from "@office-open/docx";
+
+//#region src/extensions/ordered-list.d.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. */
+declare const ORDERED_REFERENCE_PREFIX = "docen-ordered";
+/** lvlText per nesting depth (level 0 → "%1.", … level 8 → "%9."). */
+declare const ORDERED_LEVEL_TEXT: string[];
+/**
+ * Build nine decimal numbering levels for an ordered list. Level 0 carries
+ * `start`; deeper levels restart at 1 (Word convention).
+ */
+declare function buildOrderedLevels(start: number): LevelsOptions[];
+//#endregion
+export { ORDERED_LEVEL_TEXT, ORDERED_REFERENCE_PREFIX, OrderedList, buildOrderedLevels };

package/dist/extensions/ordered-list.mjs

@@ -0,0 +1,41 @@
+import { OrderedList } from "./tiptap.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_LEVEL_TEXT, ORDERED_REFERENCE_PREFIX, OrderedList, buildOrderedLevels };

package/dist/extensions/page-break.d.mts

@@ -0,0 +1,2 @@
+import { c as PageBreak } from "../core-C9VunJ8o.mjs";
+export { PageBreak };

package/dist/extensions/page-break.mjs

@@ -0,0 +1,2 @@
+import { g as PageBreak } from "../core-DT9IrTzN.mjs";
+export { PageBreak };

package/dist/extensions/paragraph.d.mts

@@ -1,2 +1,2 @@
-import { n as parseDocx, r as renderDocx, t as Paragraph } from "../paragraph-fhEXtAN2.mjs";
+import { n as parseDocx, r as renderDocx, t as Paragraph } from "../paragraph-D8mpHo_o.mjs";
 export { Paragraph, parseDocx, renderDocx };

package/dist/extensions/paragraph.mjs

@@ -9,19 +9,36 @@ import { alignmentFromElement, bordersFromElement, indentFromElement, renderPara
 * near-identity: renderDocx/parseDocx pass attrs through; CSS conversion happens
 * only in renderHTML via utils mappers.
 */
+const SECTION_ATTR_KEYS = new Set([
+	"sectionProperties",
+	"sectionHeaders",
+	"sectionFooters"
+]);
 function renderDocx(node) {
 	const attrs = node.attrs ?? {};
 	const opts = {};
-	for (const [key, value] of Object.entries(attrs)) if (value !== null && value !== void 0) opts[key] = value;
+	for (const [key, value] of Object.entries(attrs)) {
+		if (value === null || value === void 0) continue;
+		if (SECTION_ATTR_KEYS.has(key)) continue;
+		if (key === "styleId") {
+			opts.style = value;
+			continue;
+		}
+		opts[key] = value;
+	}
 	return opts;
 }
-/** Structural/semantic keys expressed elsewhere (heading ext, list handling, run children). */
+/**
+* Structural/semantic keys handled elsewhere (heading ext, list handling, run/text
+* children). NOTE: `run` is intentionally NOT skipped — ParagraphOptions.run (the
+* paragraph's default run properties: font/size/color) is kept as an attr for
+* lossless round-trip (e.g. header/footer paragraphs whose styling lives there).
+*/
 const SKIP_KEYS = new Set([
 	"heading",
 	"style",
 	"bullet",
 	"numbering",
-	"run",
 	"children",
 	"text",
 	"thematicBreak"
@@ -29,6 +46,7 @@ const SKIP_KEYS = new Set([
 function parseDocx(opts) {
 	const resolved = typeof opts === "string" ? { text: opts } : opts;
 	const attrs = {};
+	if (resolved.style) attrs.styleId = resolved.style;
 	for (const [key, value] of Object.entries(resolved)) {
 		if (SKIP_KEYS.has(key)) continue;
 		attrs[key] = value ?? null;
@@ -44,6 +62,13 @@ const Paragraph = Paragraph$1.extend({
 	addAttributes() {
 		return {
 			...this.parent?.(),
+			styleId: {
+				default: null,
+				parseHTML: (el) => {
+					const m = (el.getAttribute("class") || "").match(/(?:^|\s)docx-style-(\S+)/);
+					return m ? m[1] : null;
+				}
+			},
 			alignment: {
 				default: null,
 				rendered: false,
@@ -70,6 +95,10 @@ const Paragraph = Paragraph$1.extend({
 				parseHTML: (el) => bordersFromElement(el)
 			},
 			frame: attrNative(),
+			run: attrNative(),
+			sectionProperties: attrNative(),
+			sectionHeaders: attrNative(),
+			sectionFooters: attrNative(),
 			keepNext: attrNative(),
 			keepLines: attrNative(),
 			pageBreakBefore: attrNative(),
@@ -100,8 +129,14 @@ const Paragraph = Paragraph$1.extend({
 		};
 	},
 	renderHTML({ node, HTMLAttributes }) {
-		const styles = renderParagraphStyles(node.attrs);
+		let hasContent = false;
+		node.forEach?.((child) => {
+			if (child.isText || child.type?.name === "hardBreak" || child.type?.name === "image") hasContent = true;
+		});
+		const styles = renderParagraphStyles(node.attrs, { empty: !hasContent });
 		const attrs = { ...HTMLAttributes };
+		const styleId = node.attrs.styleId;
+		attrs.class = styleId ? `docx-style-${styleId}` : "docx-default";
 		if (styles.length > 0) attrs.style = styles.join(";");
 		return [
 			"p",

package/dist/extensions/passthrough.d.mts

@@ -0,0 +1,2 @@
+import { h as Passthrough } from "../core-C9VunJ8o.mjs";
+export { Passthrough };

package/dist/extensions/passthrough.mjs

@@ -0,0 +1,2 @@
+import { h as Passthrough } from "../core-DT9IrTzN.mjs";
+export { Passthrough };