@docen/docx 0.3.0 → 0.3.2

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

@@ -0,0 +1,44 @@
+import { r as Extension } from "../core-C9VunJ8o.mjs";
+
+//#region src/extensions/section-break.d.ts
+/**
+ * SectionBreak — command extension that marks a paragraph as a section boundary.
+ *
+ * OOXML sections (sectPr) attach to a section's LAST paragraph's pPr, NOT a
+ * standalone node. So this extension provides only the `setSectionBreak`
+ * command (stamps sectionProperties on the current paragraph); the paragraph
+ * extension carries the sectionProperties/sectionHeaders/sectionFooters attrs,
+ * and DocxManager splits/merges sections in compile/resolve by reading them off
+ * the paragraph.
+ *
+ * The final section's sectPr rides on doc.attrs.sectionProperties (it lives at
+ * <w:body>'s end in OOXML). Single-section documents have no section-carrying
+ * paragraph at all.
+ *
+ * Next Page semantics: `setSectionBreak` stamps sectionProperties on the current
+ * paragraph (making it the section's last paragraph) AND inserts a fresh empty
+ * paragraph after it (the next section's first paragraph), then moves the
+ * selection into that new paragraph. The page-plugin's `forcesPageBreakAfter`
+ * treats a sectionProperties-bearing paragraph as a page break, so repaginate
+ * pushes the new paragraph onto the next page — and the caret follows. This
+ * mirrors Word's "Section Break (Next Page)".
+ *
+ * Split hygiene: pressing Enter inside a section-carrying paragraph must NOT
+ * split it. A split would place the new paragraph past the section boundary —
+ * forcesPageBreakAfter then pushes it onto the next page (next section), and
+ * splitBlock would copy sectionProperties onto it (a second break mark). Word
+ * instead inserts a fresh paragraph BEFORE the section's last paragraph, so the
+ * new paragraph stays in this section and the stamped paragraph remains last.
+ * The Enter shortcut does exactly that; non-section paragraphs fall through to
+ * the default Enter unchanged.
+ */
+declare const SectionBreak: Extension<any, any>;
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    sectionBreak: {
+      /** Insert a Next Page section break at the current paragraph. */setSectionBreak: () => ReturnType;
+    };
+  }
+}
+//#endregion
+export { SectionBreak };

package/dist/extensions/section-break.mjs

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

package/dist/extensions/table.mjs

@@ -85,12 +85,15 @@ const Table = Table$1.extend({
 			const w = a.width;
 			const numSize = typeof w.size === "string" ? parseFloat(w.size) : w.size;
 			if (w.type === "pct") {
-				if (!Number.isNaN(numSize)) styles.push(`width:${numSize / 50}%`);
-			} else if (numSize != null) {
+				if (typeof w.size === "string" && w.size.includes("%")) styles.push(`width:${w.size}`);
+				else if (!Number.isNaN(numSize)) styles.push(`width:${numSize / 50}%`);
+			} else if (w.type === "auto") styles.push("width:100%");
+			else if (numSize != null) {
 				const css = twipToCss(numSize);
 				if (css) styles.push(`width:${css}`);
 			}
-		}
+		} else styles.push("width:100%");
+		styles.push("max-width:100%");
 		if (a.indent && typeof a.indent === "object") {
 			const ind = a.indent;
 			if (ind.size != null) {
@@ -120,7 +123,30 @@ const Table = Table$1.extend({
 				if (css) styles.push(`border-${side}:${css}`);
 			}
 		}
+		const firstRow = node.firstChild;
+		const cellPx = [];
+		if (firstRow) for (let i = 0; i < firstRow.childCount; i++) {
+			const cw = firstRow.child(i).attrs.colwidth;
+			if (Array.isArray(cw) && cw.length) for (const w of cw) cellPx.push(w || 0);
+			else cellPx.push(0);
+		}
+		const hasCellWidths = cellPx.some((w) => w > 0);
+		const tblGridPx = (a.columnWidths ?? []).map((w) => Math.round((w || 0) / 15));
+		const gridPx = tblGridPx.some((w) => w > 0) ? tblGridPx : hasCellWidths ? cellPx : tblGridPx;
 		if (styles.length > 0) attrs.style = styles.join(";");
+		if (gridPx.some((w) => w > 0)) {
+			const gridTotal = gridPx.reduce((sum, w) => sum + w, 0);
+			return [
+				"table",
+				attrs,
+				[
+					"colgroup",
+					{},
+					...gridPx.map((w) => ["col", { style: `width:${gridTotal > 0 ? (w / gridTotal * 100).toFixed(2) : 0}%` }])
+				],
+				["tbody", 0]
+			];
+		}
 		return [
 			"table",
 			attrs,

package/dist/extensions/task-item.d.mts

@@ -0,0 +1,27 @@
+import { A as TaskItem } from "../tiptap-pZsNPsvV.mjs";
+
+//#region src/extensions/task-item.d.ts
+/**
+ * TaskItem extension — owns the DOCX expression of a task-list checkbox.
+ *
+ * DOCX has no native task list, but a clickable checkbox is reversible via an
+ * inline content-control SDT (w14:checkbox). Each task paragraph carries a
+ * leading checkbox SDT tagged "docen-task" so resolve can tell task items apart
+ * from ordinary paragraphs that happen to contain an SDT. The checked state
+ * round-trips through the SDT; DocxManager injects/strips the SDT at the
+ * paragraph boundary and rebuilds the taskList/taskItem tree.
+ */
+/** SDT tag marking our task-item checkbox content control. */
+declare const TASK_CHECKBOX_TAG = "docen-task";
+/**
+ * Inline checkbox SDT (w14:checkbox) for a task item, as a ParagraphChild.
+ * Tagged so resolve can distinguish task items from ordinary SDT-bearing
+ * paragraphs.
+ */
+declare function createTaskCheckbox(checked: boolean): Record<string, unknown>;
+/** True if an inline ParagraphChild is our task checkbox SDT. */
+declare function isTaskCheckbox(child: unknown): boolean;
+/** Read the checked state of a task checkbox SDT child (false if not one). */
+declare function readCheckboxState(child: unknown): boolean;
+//#endregion
+export { TASK_CHECKBOX_TAG, TaskItem, createTaskCheckbox, isTaskCheckbox, readCheckboxState };

package/dist/extensions/task-item.mjs

@@ -0,0 +1,37 @@
+import { TaskItem } from "./tiptap.mjs";
+//#region src/extensions/task-item.ts
+/**
+* TaskItem extension — owns the DOCX expression of a task-list checkbox.
+*
+* DOCX has no native task list, but a clickable checkbox is reversible via an
+* inline content-control SDT (w14:checkbox). Each task paragraph carries a
+* leading checkbox SDT tagged "docen-task" so resolve can tell task items apart
+* from ordinary paragraphs that happen to contain an SDT. The checked state
+* round-trips through the SDT; DocxManager injects/strips the SDT at the
+* paragraph boundary and rebuilds the taskList/taskItem tree.
+*/
+/** SDT tag marking our task-item checkbox content control. */
+const TASK_CHECKBOX_TAG = "docen-task";
+/**
+* Inline checkbox SDT (w14:checkbox) for a task item, as a ParagraphChild.
+* Tagged so resolve can distinguish task items from ordinary SDT-bearing
+* paragraphs.
+*/
+function createTaskCheckbox(checked) {
+	return { sdt: { properties: {
+		tag: TASK_CHECKBOX_TAG,
+		checkbox: { checked }
+	} } };
+}
+/** True if an inline ParagraphChild is our task checkbox SDT. */
+function isTaskCheckbox(child) {
+	if (typeof child !== "object" || child === null || !("sdt" in child)) return false;
+	return (child.sdt?.properties)?.tag === TASK_CHECKBOX_TAG;
+}
+/** Read the checked state of a task checkbox SDT child (false if not one). */
+function readCheckboxState(child) {
+	if (!isTaskCheckbox(child)) return false;
+	return Boolean(child.sdt?.properties?.checkbox?.checked);
+}
+//#endregion
+export { TASK_CHECKBOX_TAG, TaskItem, createTaskCheckbox, isTaskCheckbox, readCheckboxState };

package/dist/extensions/text-style.mjs

@@ -1,5 +1,5 @@
 import { TextStyle as TextStyle$1 } from "./tiptap.mjs";
-import { characterSpacingFromCss, characterSpacingToCss, normalizeColorToHex, resolveFontName, shadingFromCss, shadingToCss, sizeFromCss, sizeToCss } from "./utils.mjs";
+import { characterSpacingFromCss, characterSpacingToCss, normalizeColorToHex, resolveFontFamilyCss, shadingFromCss, shadingToCss, sizeFromCss, sizeToCss } from "./utils.mjs";
 //#region src/extensions/text-style.ts
 /**
 * TextStyle mark with office-open attrs.
@@ -27,6 +27,10 @@ function renderDocx(attrs) {
 	for (const [key, value] of Object.entries(attrs)) {
 		if (SKIP_KEYS.has(key)) continue;
 		if (value === null || value === void 0) continue;
+		if (key === "styleId") {
+			opts.style = value;
+			continue;
+		}
 		opts[key] = value;
 	}
 	return opts;
@@ -34,6 +38,7 @@ function renderDocx(attrs) {
 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;
@@ -49,10 +54,22 @@ const TextStyle = TextStyle$1.extend({
 	addAttributes() {
 		return {
 			...this.parent?.(),
+			styleId: {
+				default: null,
+				parseHTML: (element) => {
+					const m = (element.getAttribute("class") || "").match(/(?:^|\s)docx-char-(\S+)/);
+					return m ? m[1] : null;
+				},
+				renderHTML: (attributes) => {
+					const id = attributes.styleId;
+					return id ? { class: `docx-char-${id}` } : {};
+				}
+			},
 			color: {
 				default: null,
 				parseHTML: (element) => normalizeColorToHex(element.style.color || void 0) ?? null,
 				renderHTML: (attributes) => {
+					if (attributes.color === "auto") return {};
 					const hex = normalizeColorToHex(attributes.color);
 					return hex ? { style: `color:${hex}` } : {};
 				}
@@ -69,7 +86,7 @@ const TextStyle = TextStyle$1.extend({
 				default: null,
 				parseHTML: (element) => element.style.fontFamily || null,
 				renderHTML: (attributes) => {
-					const name = resolveFontName(attributes.font);
+					const name = resolveFontFamilyCss(attributes.font);
 					return name ? { style: `font-family:${name}` } : {};
 				}
 			},
@@ -91,7 +108,7 @@ const TextStyle = TextStyle$1.extend({
 				parseHTML: (element) => shadingFromCss(element.style.backgroundColor),
 				renderHTML: (attributes) => {
 					const css = shadingToCss(attributes.shading);
-					return css ? { style: `background-color:${css}` } : {};
+					return css ? { style: `background-color:${css};color:contrast-color(${css})` } : {};
 				}
 			},
 			underline: attrNative(),

package/dist/extensions/tiptap.d.mts

@@ -1,2 +1,2 @@
-import { A as TableCell, B as UndoRedo, C as Mention, D as Subscript, E as Strike, F as Text, I as TextAlign, L as TextStyle, M as TableRow, N as TaskItem, O as Superscript, P as TaskList, R as TrailingNode, S as Mathematics, T as Paragraph, _ as Image, a as CodeBlockLowlight, b as ListItem, c as DetailsSummary, d as Emoji, f as Gapcursor, g as HorizontalRule, h as Highlight, i as Code, j as TableHeader, k as Table, l as Document, m as Heading, 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";
-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, Strike, Subscript, Superscript, Table, TableCell, TableHeader, TableRow, TaskItem, TaskList, Text, TextAlign, TextStyle, TrailingNode, Underline, UndoRedo };
+import { A as TaskItem, C as Strike, D as TableCell, E as Table, F as Underline, M as Text, N as TextAlign, O as TableHeader, P as TextStyle, S as Paragraph, T as Superscript, _ as Link, a as CodeBlockLowlight, b as Mention, c as DetailsSummary, d as HardBreak, f as Heading, g as Italic, h as Image, i as Code, j as TaskList, k as TableRow, l as Document, m as HorizontalRule, n as Bold, o as Details, p as Highlight, r as BulletList, s as DetailsContent, t as Blockquote, u as Emoji, v as ListItem, w as Subscript, x as OrderedList, y as Mathematics } from "../tiptap-pZsNPsvV.mjs";
+export { Blockquote, Bold, BulletList, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Document, Emoji, HardBreak, Heading, Highlight, HorizontalRule, Image, Italic, Link, ListItem, Mathematics, Mention, OrderedList, Paragraph, Strike, Subscript, Superscript, Table, TableCell, TableHeader, TableRow, TaskItem, TaskList, Text, TextAlign, TextStyle, Underline };

package/dist/extensions/tiptap.mjs

@@ -28,6 +28,4 @@ import { Subscript } from "@tiptap/extension-subscript";
 import { Superscript } from "@tiptap/extension-superscript";
 import { TextStyle } from "@tiptap/extension-text-style";
 import { TextAlign } from "@tiptap/extension-text-align";
-import { Dropcursor, Gapcursor, TrailingNode, UndoRedo } from "@tiptap/extensions";
-import { ListKeymap } from "@tiptap/extension-list";
-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, Strike, Subscript, Superscript, Table, TableCell, TableHeader, TableRow, TaskItem, TaskList, Text, TextAlign, TextStyle, TrailingNode, Underline, UndoRedo };
+export { Blockquote, Bold, BulletList, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Document, Emoji, HardBreak, Heading, Highlight, HorizontalRule, Image, Italic, Link, ListItem, Mathematics, Mention, OrderedList, Paragraph, Strike, Subscript, Superscript, Table, TableCell, TableHeader, TableRow, TaskItem, TaskList, Text, TextAlign, TextStyle, Underline };

package/dist/extensions/types.d.mts

@@ -3,19 +3,21 @@ import { RunOptions } from "@office-open/docx";
 
 //#region src/extensions/types.d.ts
 declare module "@tiptap/core" {
-  interface NodeConfig<Options, Storage> {
+  interface NodeConfig<Options = any, Storage = any> {
     /**
-     * DOCX serialization: Tiptap JSON node → DOCX opts.
-     * Each node extension defines this to convert its attrs to DOCX properties.
+     * DOCX serialization: Tiptap JSON node → DOCX opts, or null when the node
+     * cannot be serialized (e.g. an image with no embedded data — DocxManager
+     * then drops it). Each node extension defines this to convert its attrs to
+     * DOCX properties.
      */
-    renderDocx?: (node: JSONContent) => Record<string, unknown>;
+    renderDocx?: (node: JSONContent) => Record<string, unknown> | null;
     /**
      * DOCX deserialization: DOCX opts → Tiptap JSON attrs.
      * Each node extension defines this to convert DOCX properties back to attrs.
      */
     parseDocx?: (opts: Record<string, unknown>) => Record<string, unknown>;
   }
-  interface MarkConfig<Options, Storage> {
+  interface MarkConfig<Options = any, Storage = any> {
     /**
      * DOCX serialization: mark attrs → RunOptions properties.
      * Each mark extension defines this to contribute run-level properties.

package/dist/extensions/utils.d.mts

@@ -1,49 +1,2 @@
-import { BorderOptions, BordersOptions, IndentAttributesProperties, ShadingAttributesProperties, SpacingProperties } from "@office-open/docx";
-
-//#region src/extensions/utils.d.ts
-/** Normalize a CSS color value to hex (e.g., "red" → "#FF0000", "#ff0000" → "#FF0000"). */
-declare function normalizeColorToHex(color: string | undefined): string | undefined;
-/** Resolve a font value (string or OOXML rFonts { ascii, eastAsia, hAnsi, cs }) to a CSS family name. */
-declare function resolveFontName(font: unknown): string | null;
-/** CSS value (e.g., "18pt") → twip number. 1 pt = 20 twips, 1 px = 15 twips (96 DPI). */
-declare function cssToTwip(value: string | undefined): number | undefined;
-/** Twip value → CSS string (e.g., 360 → "18pt"). */
-declare function twipToCss(value: number | string | undefined): string | null;
-/** OOXML alignment → CSS text-align. */
-declare function alignmentToCss(alignment: string | null | undefined): string | null;
-/** CSS text-align → OOXML alignment. */
-declare function alignmentFromCss(css: string | null | undefined): string | null;
-/** Shading.fill → CSS background-color hex. */
-declare function shadingToCss(shading: ShadingAttributesProperties | null | undefined): string | null;
-/** CSS background-color → ShadingAttributesProperties (fill normalized to hex). */
-declare function shadingFromCss(css: string | null | undefined): ShadingAttributesProperties | null;
-declare function lineSpacingToCss(spacing: SpacingProperties | null | undefined): string | null;
-declare function sizeToCss(size: number | null | undefined): string | null;
-declare function sizeFromCss(css: string | null | undefined): number | null;
-declare function characterSpacingToCss(spacing: number | null | undefined): string | null;
-declare function characterSpacingFromCss(css: string | null | undefined): number | null;
-/** Render a BorderOptions to CSS string. OOXML border.size is in eighths of a point. */
-declare function renderBorderCSS(border: BorderOptions): string | null;
-/**
- * Compute all paragraph-level CSS styles from nested attrs.
- * Shared by Paragraph and Heading extensions for node-level renderHTML.
- * Attrs store office-open native values; mappers here convert to CSS.
- */
-declare function renderParagraphStyles(attrs: Record<string, unknown>): string[];
-/**
- * Compute table cell CSS styles from nested attrs.
- * Shared by TableCell and TableHeader extensions.
- */
-declare function renderTableCellStyles(attrs: Record<string, unknown>): string[];
-/** Parse text-align → OOXML alignment. */
-declare function alignmentFromElement(el: HTMLElement): string | null;
-/** Parse margin-left/right + text-indent → OOXML indent (twips). */
-declare function indentFromElement(el: HTMLElement): IndentAttributesProperties | null;
-/** Parse margin-top/bottom + line-height → OOXML spacing (twips). */
-declare function spacingFromElement(el: HTMLElement): SpacingProperties | null;
-/** Parse border-* → OOXML BordersOptions. */
-declare function bordersFromElement(el: HTMLElement): BordersOptions | null;
-/** Parse background-color → OOXML shading. */
-declare function shadingFromElement(el: HTMLElement): ShadingAttributesProperties | null;
-//#endregion
-export { alignmentFromCss, alignmentFromElement, alignmentToCss, bordersFromElement, characterSpacingFromCss, characterSpacingToCss, cssToTwip, indentFromElement, lineSpacingToCss, normalizeColorToHex, renderBorderCSS, renderParagraphStyles, renderTableCellStyles, resolveFontName, shadingFromCss, shadingFromElement, shadingToCss, sizeFromCss, sizeToCss, spacingFromElement, twipToCss };
+import { C as shadingFromElement, D as spacingFromElement, E as sizeToCss, O as twipToCss, S as shadingFromCss, T as sizeFromCss, _ as resolveFontFamilyCss, a as characterSpacingFromCss, b as sectionLinePitchCss, c as floatAnchorScope, d as lineSpacingToCss, f as normalizeColorToHex, g as renderTableCellStyles, h as renderRunStyles, i as bordersFromElement, k as twipsToMm, l as floatingToStyles, m as renderParagraphStyles, n as alignmentFromElement, o as characterSpacingToCss, p as renderBorderCSS, r as alignmentToCss, s as cssToTwip, t as alignmentFromCss, u as indentFromElement, v as resolveFontName, w as shadingToCss, x as sectionMarginCss, y as resolvePageSize } from "../utils-D87vukzp.mjs";
+export { alignmentFromCss, alignmentFromElement, alignmentToCss, bordersFromElement, characterSpacingFromCss, characterSpacingToCss, cssToTwip, floatAnchorScope, floatingToStyles, indentFromElement, lineSpacingToCss, normalizeColorToHex, renderBorderCSS, renderParagraphStyles, renderRunStyles, renderTableCellStyles, resolveFontFamilyCss, resolveFontName, resolvePageSize, sectionLinePitchCss, sectionMarginCss, shadingFromCss, shadingFromElement, shadingToCss, sizeFromCss, sizeToCss, spacingFromElement, twipToCss, twipsToMm };

package/dist/extensions/utils.mjs

@@ -1,3 +1,4 @@
+import { sectionMarginDefaults, sectionPageSizeDefaults } from "@office-open/docx";
 //#region src/extensions/utils.ts
 /** Common CSS named colors → hex */
 const CSS_COLORS = {
@@ -30,9 +31,23 @@ const CSS_COLORS = {
 	salmon: "#FA8072",
 	tomato: "#FF6347"
 };
-/** Normalize a CSS color value to hex (e.g., "red" → "#FF0000", "#ff0000" → "#FF0000"). */
+/** Normalize a CSS color value to hex (e.g., "red" → "#FF0000", "#ff0000" → "#FF0000").
+*  Accepts a string (CSS name/hex or bare OOXML hex), or an OOXML ColorOptions
+*  object ({ val, themeColor, themeTint, themeShade }) — the object form
+*  resolves to its val (the RGB fallback Word stores alongside themeColor) for
+*  CSS rendering. The themeColor/tint/shade are preserved verbatim in the attrs
+*  and round-trip back to the DOCX (see text-style/paragraph parseDocx), so
+*  theme semantics survive even though only val is rendered here. A pure theme
+*  reference with no val (rare — Word usually stores both) would need theme.xml
+*  to resolve and is left unset. */
 function normalizeColorToHex(color) {
 	if (!color) return void 0;
+	if (typeof color === "object") {
+		const { val } = color;
+		return val ? normalizeColorToHex(val) : void 0;
+	}
+	if (typeof color !== "string") return void 0;
+	if (color === "auto") return void 0;
 	if (color.startsWith("#")) return color.length === 4 ? `#${color[1]}${color[1]}${color[2]}${color[2]}${color[3]}${color[3]}`.toUpperCase() : color.toUpperCase();
 	if (/^[0-9A-Fa-f]{6}$/.test(color)) return `#${color.toUpperCase()}`;
 	if (/^[0-9A-Fa-f]{3}$/.test(color)) return `#${color[0]}${color[0]}${color[1]}${color[1]}${color[2]}${color[2]}`.toUpperCase();
@@ -48,6 +63,26 @@ function resolveFontName(font) {
 	}
 	return null;
 }
+/** Resolve a font value to a CSS font-family list with an eastAsia fallback.
+*  Mirrors Word's per-Unicode-range font selection (MS-OE376): Basic Latin uses
+*  the ascii font, CJK Ideographs use eastAsia. CSS can't split a run by range,
+*  so list ascii first (it carries Basic Latin glyphs) then eastAsia — the
+*  browser falls back to eastAsia for CJK chars the ascii font lacks. Without
+*  this, CJK text renders in the ascii font (e.g. Times) instead of the
+*  document's CJK font (e.g. SimSun). Use this for font-family rendering;
+*  resolveFontName (single name) stays for UI/parse. */
+function resolveFontFamilyCss(font) {
+	if (!font) return null;
+	if (typeof font === "string") return font;
+	if (typeof font === "object") {
+		const f = font;
+		const ascii = f.ascii || f.hAnsi;
+		const ea = f.eastAsia;
+		if (ascii && ea && ascii !== ea) return `"${ascii}","${ea}"`;
+		return ascii || ea || null;
+	}
+	return null;
+}
 /** CSS value (e.g., "18pt") → twip number. 1 pt = 20 twips, 1 px = 15 twips (96 DPI). */
 function cssToTwip(value) {
 	if (!value) return void 0;
@@ -109,12 +144,73 @@ function shadingFromCss(css) {
 		type: "clear"
 	} : null;
 }
-function lineSpacingToCss(spacing) {
+function lineSpacingToCss(spacing, snapToGrid = null) {
 	if (!spacing?.line) return null;
 	const rule = spacing.lineRule;
-	if (rule === "exact" || rule === "exactly" || rule === "atLeast") return `${spacing.line / 20}pt`;
-	const multiple = Number((spacing.line / 240).toFixed(2));
-	return String(multiple);
+	if (rule === "exact" || rule === "exactly" || rule === "atLeast") return `${Number(spacing.line) / 20}pt`;
+	if (snapToGrid === false) return `calc(var(--docen-font-metric, 1.2) * ${Number((Number(spacing.line) / 240).toFixed(2))} * var(--docen-line-base, 1em))`;
+	return `calc(var(--docen-font-metric, 1.2) * var(--docen-line-base, 1em) + var(--docen-line-pitch, 0pt))`;
+}
+/** twips → mm (1 in = 1440 tw = 25.4 mm), 2dp string. */
+function twipsToMm(twips) {
+	return `${(twips / 1440 * 25.4).toFixed(2)}mm`;
+}
+/** Resolve a section's printable page dimensions (twips), honoring orientation.
+*  A landscape section commonly stores portrait dims (w<h) with
+*  `orientation: "landscape"` — swap width/height so width is the larger edge.
+*  Falls back to the engine's default page size (@office-open/docx
+*  `sectionPageSizeDefaults` = A4) when the size is absent or non-numeric — the
+*  engine's `stringifySectionPropertiesXml` fills an empty sectPr the same way,
+*  so edit-time geometry matches render/measure/generate/export. */
+function resolvePageSize(size) {
+	const fallback = {
+		width: sectionPageSizeDefaults.WIDTH,
+		height: sectionPageSizeDefaults.HEIGHT
+	};
+	if (!size || typeof size !== "object") return fallback;
+	const s = size;
+	const w = typeof s.width === "number" ? s.width : void 0;
+	const h = typeof s.height === "number" ? s.height : void 0;
+	if (w == null || h == null) return fallback;
+	return s.orientation === "landscape" && w < h ? {
+		width: h,
+		height: w
+	} : {
+		width: w,
+		height: h
+	};
+}
+/** Page margin (twips) → CSS padding. Sides absent or non-numeric fall back to
+*  the engine's default margins (@office-open/docx `sectionMarginDefaults`:
+*  top/bottom 1440tw, left/right 1800tw — MS Office zh-CN "Normal"), matching
+*  the page-size fallback above and the engine's empty-sectPr behavior. Margins
+*  are left as-is: office-open returns them already rotated for a landscape
+*  section. */
+function sectionMarginCss(margin) {
+	const def = sectionMarginDefaults;
+	const m = margin && typeof margin === "object" ? margin : {};
+	const num = (v, d) => typeof v === "number" ? v : d;
+	return `padding:${[
+		num(m.top, def.TOP),
+		num(m.right, def.RIGHT),
+		num(m.bottom, def.BOTTOM),
+		num(m.left, def.LEFT)
+	].map(twipsToMm).join(" ")}`;
+}
+/** Document grid linePitch (twips) → container CSS line-height.
+*  Per ECMA-376 snapToGrid, the grid linePitch is ADDED to each line (single-
+*  line paragraphs inherit it). So the container line-height (inherited by
+*  paragraphs without their own spacing) is the font's `normal` metric + the
+*  grid pitch, set only when the grid type enables line-snapping (not
+*  "default"). The --docen-line-pitch var carries the pitch so per-paragraph
+*  lineSpacingToCss can add the same pitch; --docen-font-metric is injected per
+*  paragraph by the editor; 1.2 is the fallback for static HTML export. */
+function sectionLinePitchCss(grid) {
+	if (!grid || typeof grid !== "object") return [];
+	const g = grid;
+	if (!g.type || g.type === "default" || typeof g.linePitch !== "number" || !g.linePitch) return [];
+	const pitch = `${(g.linePitch / 20).toFixed(2)}pt`;
+	return [`line-height:calc(var(--docen-font-metric, 1.2) * 1em + ${pitch})`, `--docen-line-pitch:${pitch}`];
 }
 function sizeToCss(size) {
 	if (size == null) return null;
@@ -138,7 +234,7 @@ function characterSpacingFromCss(css) {
 }
 /** Render a BorderOptions to CSS string. OOXML border.size is in eighths of a point. */
 function renderBorderCSS(border) {
-	if (!border || border.style === "none") return null;
+	if (!border || !border.style || border.style === "none" || border.style === "nil") return null;
 	const size = border.size != null ? `${border.size / 8}pt` : "1pt";
 	const cssStyle = {
 		single: "solid",
@@ -146,17 +242,85 @@ function renderBorderCSS(border) {
 		dotted: "dotted",
 		double: "double",
 		dotDash: "dashed",
-		dotDotDash: "dotted"
+		dotDotDash: "dotted",
+		dashSmallGap: "dashed"
 	}[border.style || "single"] || "solid";
 	const hex = border.color && border.color !== "auto" ? normalizeColorToHex(border.color) : null;
 	return hex ? `${cssStyle} ${size} ${hex}` : `${cssStyle} ${size}`;
 }
+const EMU_PER_PX = 9525;
+const EMU_PER_PT = 12700;
+/**
+* Render a drawing's Floating anchor (wp:anchor) to CSS — shared by Image and
+* WpgGroup so anchored drawings render consistently:
+*  - wrapNone (type 0): position:absolute at the EMU offset (text does not flow
+*    around it — "in front of text" / "behind text"); z-index lifts it above or
+*    below the text layer per behindDocument.
+*  - topAndBottom (3): float + clear:both.
+*  - square/tight/through (1/2/4): with an hPos.offset, float:right pulled to
+*    the offset via margin-right so text wraps beside it with no overlap;
+*    otherwise float on the wrap side (tight/through add shape-outside, src).
+* Wrap margins (wp:distT/B/L/R) are EMU, rendered as pt.
+*/
+function floatingToStyles(floating, src, width) {
+	const f = floating;
+	if (!f) return [];
+	const styles = [];
+	styles.push(`z-index:${f.behindDocument ? -1 : f.zIndex ?? 1}`);
+	const wrapType = f.wrap?.type ?? 0;
+	const hOff = f.horizontalPosition?.offset;
+	const vOff = f.verticalPosition?.offset;
+	if (wrapType === 0) {
+		styles.push("position:absolute");
+		if (hOff != null) styles.push(`left:${(hOff / EMU_PER_PX).toFixed(1)}px`);
+		if (vOff != null) styles.push(`top:${(vOff / EMU_PER_PX).toFixed(1)}px`);
+	} else if (wrapType !== 3 && hOff != null && width != null) {
+		const offPx = (hOff / EMU_PER_PX).toFixed(1);
+		styles.push("float:right", `margin-right:calc(100% - ${offPx}px - ${width}px)`);
+		if (vOff != null) styles.push(`margin-top:${(vOff / EMU_PER_PX).toFixed(1)}px`);
+		const m = f.margins;
+		if (m?.left) styles.push(`margin-left:${(m.left / EMU_PER_PT).toFixed(1)}pt`);
+	} else if (wrapType === 3) styles.push("float:left", "clear:both");
+	else {
+		const side = f.wrap?.side;
+		const floatSide = side === "right" || side === "outside" ? "right" : "left";
+		styles.push(`float:${floatSide}`);
+		if ((wrapType === 2 || wrapType === 4) && src) styles.push(`shape-outside:url(${src})`);
+	}
+	if (!(wrapType !== 0 && wrapType !== 3 && hOff != null && width != null) && wrapType !== 0) {
+		const m = f.margins;
+		if (m) {
+			if (m.top) styles.push(`margin-top:${(m.top / EMU_PER_PT).toFixed(1)}pt`);
+			if (m.bottom) styles.push(`margin-bottom:${(m.bottom / EMU_PER_PT).toFixed(1)}pt`);
+			if (m.left) styles.push(`margin-left:${(m.left / EMU_PER_PT).toFixed(1)}pt`);
+			if (m.right) styles.push(`margin-right:${(m.right / EMU_PER_PT).toFixed(1)}pt`);
+		}
+	}
+	return styles;
+}
+/**
+* Where a wrapNone floating drawing's absolute top/left should resolve from.
+*
+* verticalPosition.relative (OOXML vRelativeFrom) defaults to "paragraph"
+* (also "line"); "page"/"margin"/"column" scope to the page box. The drawing is
+* position:absolute, so its offsetParent decides the origin: a
+* paragraph-anchored drawing must sit inside a position:relative <p> (the editor
+* CSS adds that via p:has([data-float-anchor])), otherwise top/left measure
+* from the page top and the drawing floats over the heading/body instead of
+* its own blank paragraph (verified on sample anchored drawing groups). Only
+* relevant for wrapNone (type 0); the float-based wraps stay inline.
+*/
+function floatAnchorScope(floating) {
+	const vRel = floating?.verticalPosition?.relative;
+	if (vRel === "page" || vRel === "margin" || vRel === "column") return "page";
+	return "paragraph";
+}
 /**
 * Compute all paragraph-level CSS styles from nested attrs.
 * Shared by Paragraph and Heading extensions for node-level renderHTML.
 * Attrs store office-open native values; mappers here convert to CSS.
 */
-function renderParagraphStyles(attrs) {
+function renderParagraphStyles(attrs, opts) {
 	const a = attrs;
 	const styles = [];
 	const align = alignmentToCss(a.alignment);
@@ -174,16 +338,18 @@ function renderParagraphStyles(attrs) {
 			if (h) styles.push(`text-indent:-${h}`);
 		} else if (a.indent.firstLineChars != null) styles.push(`text-indent:${a.indent.firstLineChars / 100}em`);
 	}
+	const markLineHeight = a.run?.size != null ? sizeToCss(a.run.size) : null;
+	if (markLineHeight) styles.push(`line-height:${markLineHeight}`);
 	if (a.spacing) {
 		const before = twipToCss(a.spacing.before);
 		if (before) styles.push(`margin-top:${before}`);
 		const after = twipToCss(a.spacing.after);
 		if (after) styles.push(`margin-bottom:${after}`);
-		const lh = lineSpacingToCss(a.spacing);
+		const lh = lineSpacingToCss(a.spacing, opts?.empty ? false : a.snapToGrid);
 		if (lh) styles.push(`line-height:${lh}`);
 	}
 	const bg = shadingToCss(a.shading);
-	if (bg) styles.push(`background-color:${bg}`);
+	if (bg) styles.push(`background-color:${bg}`, `color:contrast-color(${bg})`);
 	if (a.border) {
 		const sides = [
 			["top", a.border.top],
@@ -199,6 +365,35 @@ function renderParagraphStyles(attrs) {
 	return styles;
 }
 /**
+* Compute run-level CSS (font/size/color/weight/…) from office-open run attrs.
+* Shared by text-style marks and the styles→CSS generator (stylesToCss).
+*/
+function renderRunStyles(attrs) {
+	const a = attrs;
+	const styles = [];
+	if (a.bold) styles.push("font-weight:bold");
+	if (a.italic) styles.push("font-style:italic");
+	if (a.smallCaps) styles.push("font-variant:small-caps");
+	if (a.allCaps) styles.push("text-transform:uppercase");
+	const deco = [];
+	if (a.underline) deco.push("underline");
+	if (a.strike || a.doubleStrike) deco.push("line-through");
+	if (deco.length) styles.push(`text-decoration:${deco.join(" ")}`);
+	const font = resolveFontFamilyCss(a.font);
+	if (font) styles.push(`font-family:${font}`);
+	const size = sizeToCss(a.size);
+	if (size) styles.push(`font-size:${size}`);
+	const color = a.color === "auto" ? void 0 : normalizeColorToHex(a.color);
+	if (color) styles.push(`color:${color}`);
+	const spacing = characterSpacingToCss(a.characterSpacing);
+	if (spacing) styles.push(`letter-spacing:${spacing}`);
+	if (a.highlight) {
+		const hl = normalizeColorToHex(typeof a.highlight === "string" ? a.highlight : null);
+		if (hl) styles.push(`background-color:${hl}`, `color:contrast-color(${hl})`);
+	}
+	return styles;
+}
+/**
 * Compute table cell CSS styles from nested attrs.
 * Shared by TableCell and TableHeader extensions.
 */
@@ -207,8 +402,23 @@ function renderTableCellStyles(attrs) {
 	const styles = [];
 	if (a.noWrap) styles.push("white-space:nowrap");
 	const bg = shadingToCss(a.shading);
-	if (bg) styles.push(`background-color:${bg}`);
+	if (bg) styles.push(`background-color:${bg}`, `color:contrast-color(${bg})`);
 	if (a.verticalAlign) styles.push(`vertical-align:${a.verticalAlign}`);
+	if (a.margins) {
+		const m = a.margins;
+		const side = (s) => s && typeof s.size === "number" ? twipToCss(s.size) ?? "0pt" : "0pt";
+		styles.push(`padding:${side(m.top)} ${side(m.right)} ${side(m.bottom)} ${side(m.left)}`);
+	}
+	if (a.borders) for (const side of [
+		"top",
+		"right",
+		"bottom",
+		"left"
+	]) {
+		const b = a.borders[side];
+		if (!b) continue;
+		styles.push(`border-${side}:${renderBorderCSS(b) ?? "none"}`);
+	}
 	return styles;
 }
 /** Parse text-align → OOXML alignment. */
@@ -286,4 +496,4 @@ function shadingFromElement(el) {
 	return shadingFromCss(el.style.backgroundColor || null);
 }
 //#endregion
-export { alignmentFromCss, alignmentFromElement, alignmentToCss, bordersFromElement, characterSpacingFromCss, characterSpacingToCss, cssToTwip, indentFromElement, lineSpacingToCss, normalizeColorToHex, renderBorderCSS, renderParagraphStyles, renderTableCellStyles, resolveFontName, shadingFromCss, shadingFromElement, shadingToCss, sizeFromCss, sizeToCss, spacingFromElement, twipToCss };
+export { alignmentFromCss, alignmentFromElement, alignmentToCss, bordersFromElement, characterSpacingFromCss, characterSpacingToCss, cssToTwip, floatAnchorScope, floatingToStyles, indentFromElement, lineSpacingToCss, normalizeColorToHex, renderBorderCSS, renderParagraphStyles, renderRunStyles, renderTableCellStyles, resolveFontFamilyCss, resolveFontName, resolvePageSize, sectionLinePitchCss, sectionMarginCss, shadingFromCss, shadingFromElement, shadingToCss, sizeFromCss, sizeToCss, spacingFromElement, twipToCss, twipsToMm };

package/dist/extensions/wpg-group.d.mts

@@ -0,0 +1,2 @@
+import { _ as WpgGroup, b as renderWpsText, v as WpsData, y as renderWpsInterior } from "../core-C9VunJ8o.mjs";
+export { WpgGroup, WpsData, renderWpsInterior, renderWpsText };