@docen/docx 0.3.1 → 0.3.3

package/dist/extensions/ordered-list.mjs

@@ -1,3 +1,41 @@
-import { w as OrderedList } from "../tiptap-D7pl4I5U.mjs";
-import { n as ORDERED_REFERENCE_PREFIX, r as buildOrderedLevels, t as ORDERED_LEVEL_TEXT } from "../ordered-list-V-3xFQmV.mjs";
+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

@@ -1,34 +1,2 @@
-import { s as Node } from "../core-fBMCCj4D.mjs";
-
-//#region src/extensions/page-break.d.ts
-/**
- * PageBreak — inline atom node for DOCX page breaks (`<w:br w:type="page"/>`).
- *
- * OOXML page breaks live inside a run (inline), so the Tiptap node is inline
- * too (group "inline"). This keeps a break inside its paragraph on round-trip
- * — a break mid-paragraph stays mid-paragraph instead of splitting the
- * paragraph into separate blocks (which would lose the original structure).
- * Sibling to HardBreak: both render `<w:br>`, differing only by type.
- *
- * The DOCX payload (`{ pageBreak: true }`) is inlined in DocxManager — a
- * one-liner with no per-node variance, so no extension helper for it.
- *
- * Inserting a page break must also visually reflow (the C-route paginator only
- * forces a new page after a block *containing* a pageBreak atom). So
- * `setPageBreak` inserts the atom then splits the paragraph — the atom lands at
- * the end of the first half, the trailing text becomes a fresh paragraph, and
- * the paginator's `forcesPageBreakAfter` moves it to the next page (matching
- * Word's Ctrl+Enter behavior).
- */
-declare const PageBreak: Node<any, any>;
-declare module "@tiptap/core" {
-  interface Commands<ReturnType> {
-    pageBreak: {
-      /** Insert a page break at the cursor and split the paragraph so the
-       *  trailing content reflows to the next page. */
-      setPageBreak: () => ReturnType;
-    };
-  }
-}
-//#endregion
+import { c as PageBreak } from "../core-DRaLI8nd.mjs";
 export { PageBreak };

package/dist/extensions/page-break.mjs

@@ -1,2 +1,2 @@
-import { f as PageBreak } from "../core-DEqBHRzE.mjs";
+import { _ as PageBreak } from "../core-B8ba_FNi.mjs";
 export { PageBreak };

package/dist/extensions/paragraph.mjs

@@ -1,2 +1,146 @@
-import { n as parseDocx, r as renderDocx, t as Paragraph } from "../paragraph-BrWH-BOV.mjs";
+import { Paragraph as Paragraph$1 } from "./tiptap.mjs";
+import { alignmentFromElement, attrNative, bordersFromElement, indentFromElement, renderParagraphStyles, shadingFromElement, spacingFromElement } from "./utils.mjs";
+//#region src/extensions/paragraph.ts
+/**
+* Paragraph extension with nested office-open attrs.
+*
+* Attrs mirror ParagraphPropertiesOptionsBase (alignment/indent/spacing/border/
+* shading/frame as nested objects + scalar OOXML properties). DOCX round-trip is
+* 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) continue;
+		if (SECTION_ATTR_KEYS.has(key)) continue;
+		if (key === "styleId") {
+			opts.style = value;
+			continue;
+		}
+		opts[key] = value;
+	}
+	return opts;
+}
+/**
+* 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",
+	"children",
+	"text",
+	"thematicBreak"
+]);
+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;
+	}
+	return attrs;
+}
+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,
+				parseHTML: (el) => alignmentFromElement(el)
+			},
+			indent: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => indentFromElement(el)
+			},
+			spacing: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => spacingFromElement(el)
+			},
+			shading: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => shadingFromElement(el)
+			},
+			border: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => bordersFromElement(el)
+			},
+			frame: attrNative(),
+			run: attrNative(),
+			sectionProperties: attrNative(),
+			sectionHeaders: attrNative(),
+			sectionFooters: attrNative(),
+			keepNext: attrNative(),
+			keepLines: attrNative(),
+			pageBreakBefore: attrNative(),
+			widowControl: attrNative(),
+			contextualSpacing: attrNative(),
+			bidirectional: attrNative(),
+			outlineLevel: attrNative(),
+			textDirection: attrNative(),
+			textAlignment: attrNative(),
+			suppressLineNumbers: attrNative(),
+			wordWrap: attrNative(),
+			overflowPunctuation: attrNative(),
+			autoSpaceEastAsianText: attrNative(),
+			suppressOverlap: attrNative(),
+			suppressAutoHyphens: attrNative(),
+			adjustRightInd: attrNative(),
+			snapToGrid: attrNative(),
+			mirrorIndents: attrNative(),
+			kinsoku: attrNative(),
+			topLinePunct: attrNative(),
+			autoSpaceDE: attrNative(),
+			textboxTightWrap: attrNative(),
+			rightTabStop: attrNative(),
+			leftTabStop: attrNative(),
+			divId: attrNative(),
+			tabStops: attrNative(),
+			cnfStyle: attrNative()
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		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",
+			attrs,
+			0
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
 export { Paragraph, parseDocx, renderDocx };

package/dist/extensions/passthrough.d.mts

@@ -1,2 +1,2 @@
-import { m as Passthrough } from "../core-fBMCCj4D.mjs";
+import { g as Passthrough } from "../core-DRaLI8nd.mjs";
 export { Passthrough };

package/dist/extensions/passthrough.mjs

@@ -1,2 +1,2 @@
-import { d as Passthrough } from "../core-DEqBHRzE.mjs";
+import { g as Passthrough } from "../core-B8ba_FNi.mjs";
 export { Passthrough };

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

@@ -1,4 +1,4 @@
-import { r as Extension } from "../core-fBMCCj4D.mjs";
+import { r as Extension } from "../core-DRaLI8nd.mjs";
 
 //#region src/extensions/section-break.d.ts
 /**
@@ -14,12 +14,29 @@ import { r as Extension } from "../core-fBMCCj4D.mjs";
  * 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: {
-      /** Stamp sectionProperties on the current paragraph, ending a section. */setSectionBreak: () => ReturnType;
+      /** Insert a Next Page section break at the current paragraph. */setSectionBreak: () => ReturnType;
     };
   }
 }

package/dist/extensions/section-break.mjs

@@ -1,2 +1,2 @@
-import { u as SectionBreak } from "../core-DEqBHRzE.mjs";
+import { h as SectionBreak } from "../core-B8ba_FNi.mjs";
 export { SectionBreak };

package/dist/extensions/strike.mjs

@@ -1,2 +1,46 @@
-import { n as parseDocx, r as renderDocx, t as Strike } from "../strike-hWxShOgb.mjs";
+import { Strike as Strike$1 } from "./tiptap.mjs";
+import { attrNative } from "./utils.mjs";
+//#region src/extensions/strike.ts
+/**
+* Strike mark extension with nested office-open attrs.
+*
+* OOXML represents strikethrough on a run via two mutually exclusive booleans:
+* `strike` (single) and `doubleStrike` (double). The mark itself is "single
+* strikethrough"; the `doubleStrike` attr flips it to double. DOCX round-trip
+* is near-identity for the doubleStrike flag; `strike` itself is implied by the
+* mark's presence and handled in renderDocx/parseDocx.
+*
+* Mark attribute-level renderHTML is delegated to the base Strike extension
+* (renders `<s>`); only the DOCX flag needs custom handling.
+*/
+/**
+* attrs → run properties.
+*
+* The mark presence itself means single strikethrough. When `doubleStrike` is
+* set, emit the OOXML double-strike flag instead (the two are mutually
+* exclusive in OOXML). DocxManager calls this with `mark.attrs`.
+*/
+function renderDocx(attrs) {
+	return attrs.doubleStrike ? { doubleStrike: true } : { strike: true };
+}
+/**
+* run properties → attrs.
+*
+* Only the `doubleStrike` flag needs to round-trip; single strike is implied by
+* the mark's existence. `strike` is structural/semantic (the mark) and skipped.
+*/
+function parseDocx(runOpts) {
+	return { doubleStrike: runOpts.doubleStrike ?? null };
+}
+const Strike = Strike$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			doubleStrike: attrNative()
+		};
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
 export { Strike, parseDocx, renderDocx };

package/dist/extensions/table-cell.mjs

@@ -1,2 +1,107 @@
-import { n as parseDocx, r as renderDocx, t as TableCell } from "../table-cell-DmkfYwDc.mjs";
+import { TableCell as TableCell$1 } from "./tiptap.mjs";
+import { attrNative, bordersFromElement, renderTableCellStyles, shadingFromElement } from "./utils.mjs";
+//#region src/extensions/table-cell.ts
+/**
+* Table cell extension with nested office-open attrs.
+*
+* Attrs mirror TableCellPropertiesOptionsBase (shading/margins/borders/width as
+* nested objects + scalar OOXML properties) plus the inherited Tiptap structural
+* names colspan/rowspan/colwidth/align (rendered: false for the OOXML-named ones).
+* DOCX round-trip is near-identity: renderDocx/parseDocx pass OOXML-native attrs
+* through and only map the Tiptap structural names colspan/rowspan/colwidth to
+* OOXML columnSpan/rowSpan/width. CSS conversion happens solely in renderHTML via
+* utils.renderTableCellStyles (consuming nested shading/verticalAlign/noWrap).
+*/
+/** Tiptap structural attrs expressed via OOXML structural fields, not passed through. */
+const SKIP_KEYS = new Set([
+	"colspan",
+	"rowspan",
+	"colwidth",
+	"children"
+]);
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const opts = {};
+	const colspan = typeof attrs.colspan === "number" ? attrs.colspan : void 0;
+	if (colspan && colspan > 1) opts.columnSpan = colspan;
+	const rowspan = typeof attrs.rowspan === "number" ? attrs.rowspan : void 0;
+	if (rowspan && rowspan > 1) opts.rowSpan = rowspan;
+	const colwidth = attrs.colwidth;
+	if (colwidth && colwidth.length > 0) {
+		const totalPx = colwidth.reduce((sum, w) => sum + (w || 0), 0);
+		if (totalPx > 0) opts.width = {
+			size: totalPx * 15,
+			type: "dxa"
+		};
+	}
+	for (const [key, value] of Object.entries(attrs)) {
+		if (SKIP_KEYS.has(key)) continue;
+		if (value !== null && value !== void 0) opts[key] = value;
+	}
+	return opts;
+}
+function parseDocx(opts) {
+	const resolved = typeof opts === "string" ? { text: opts } : opts;
+	const attrs = {};
+	if (resolved.columnSpan != null) attrs.colspan = resolved.columnSpan;
+	if (resolved.rowSpan != null) attrs.rowspan = resolved.rowSpan;
+	if (resolved.width) {
+		const twips = resolved.width.size ?? 0;
+		if (twips) attrs.colwidth = [Math.round(twips / 15)];
+	}
+	for (const [key, value] of Object.entries(resolved)) {
+		if (key === "columnSpan" || key === "rowSpan" || key === "width" || key === "children") continue;
+		attrs[key] = value ?? null;
+	}
+	return attrs;
+}
+const TableCell = TableCell$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			shading: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => shadingFromElement(el)
+			},
+			borders: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => bordersFromElement(el)
+			},
+			verticalAlign: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => el.style.verticalAlign || null
+			},
+			textDirection: attrNative(),
+			width: attrNative(),
+			margins: attrNative(),
+			noWrap: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => el.style.whiteSpace === "nowrap" ? true : null
+			},
+			verticalMerge: attrNative(),
+			horizontalMerge: attrNative(),
+			fitText: attrNative(),
+			hideMark: attrNative(),
+			headers: attrNative(),
+			cnfStyle: attrNative()
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		const styles = renderTableCellStyles(node.attrs);
+		const attrs = { ...HTMLAttributes };
+		if (styles.length > 0) attrs.style = styles.join(";");
+		return [
+			"td",
+			attrs,
+			0
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
 export { TableCell, parseDocx, renderDocx };

package/dist/extensions/table-header.mjs

@@ -1,2 +1,107 @@
-import { n as parseDocx, r as renderDocx, t as TableHeader } from "../table-header-Bwr5GKWg.mjs";
+import { TableHeader as TableHeader$1 } from "./tiptap.mjs";
+import { attrNative, bordersFromElement, renderTableCellStyles, shadingFromElement } from "./utils.mjs";
+//#region src/extensions/table-header.ts
+/**
+* Table header extension with nested office-open attrs (mirrors TableCell).
+*
+* Attrs mirror TableCellPropertiesOptionsBase (shading/margins/borders/width as
+* nested objects + scalar OOXML properties) plus the inherited Tiptap structural
+* names colspan/rowspan/colwidth/align (rendered: false for the OOXML-named ones).
+* DOCX round-trip is near-identity: renderDocx/parseDocx pass OOXML-native attrs
+* through and only map the Tiptap structural names colspan/rowspan/colwidth to
+* OOXML columnSpan/rowSpan/width. CSS conversion happens solely in renderHTML via
+* utils.renderTableCellStyles (consuming nested shading/verticalAlign/noWrap).
+*/
+/** Tiptap structural attrs expressed via OOXML structural fields, not passed through. */
+const SKIP_KEYS = new Set([
+	"colspan",
+	"rowspan",
+	"colwidth",
+	"children"
+]);
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const opts = {};
+	const colspan = attrs.colspan;
+	if (colspan && colspan > 1) opts.columnSpan = colspan;
+	const rowspan = attrs.rowspan;
+	if (rowspan && rowspan > 1) opts.rowSpan = rowspan;
+	const colwidth = attrs.colwidth;
+	if (colwidth && colwidth.length > 0) {
+		const totalPx = colwidth.reduce((sum, w) => sum + (w || 0), 0);
+		if (totalPx > 0) opts.width = {
+			size: totalPx * 15,
+			type: "dxa"
+		};
+	}
+	for (const [key, value] of Object.entries(attrs)) {
+		if (SKIP_KEYS.has(key)) continue;
+		if (value !== null && value !== void 0) opts[key] = value;
+	}
+	return opts;
+}
+function parseDocx(opts) {
+	const resolved = typeof opts === "string" ? { text: opts } : opts;
+	const attrs = {};
+	if (resolved.columnSpan != null) attrs.colspan = resolved.columnSpan;
+	if (resolved.rowSpan != null) attrs.rowspan = resolved.rowSpan;
+	if (resolved.width) {
+		const twips = resolved.width.size ?? 0;
+		if (twips) attrs.colwidth = [Math.round(twips / 15)];
+	}
+	for (const [key, value] of Object.entries(resolved)) {
+		if (key === "columnSpan" || key === "rowSpan" || key === "width" || key === "children") continue;
+		attrs[key] = value ?? null;
+	}
+	return attrs;
+}
+const TableHeader = TableHeader$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			shading: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => shadingFromElement(el)
+			},
+			borders: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => bordersFromElement(el)
+			},
+			verticalAlign: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => el.style.verticalAlign || null
+			},
+			textDirection: attrNative(),
+			width: attrNative(),
+			margins: attrNative(),
+			noWrap: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => el.style.whiteSpace === "nowrap" ? true : null
+			},
+			verticalMerge: attrNative(),
+			horizontalMerge: attrNative(),
+			fitText: attrNative(),
+			hideMark: attrNative(),
+			headers: attrNative(),
+			cnfStyle: attrNative()
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		const styles = renderTableCellStyles(node.attrs);
+		const attrs = { ...HTMLAttributes };
+		if (styles.length > 0) attrs.style = styles.join(";");
+		return [
+			"th",
+			attrs,
+			0
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
 export { TableHeader, parseDocx, renderDocx };

package/dist/extensions/table-row.mjs

@@ -1,2 +1,79 @@
-import { n as parseDocx, r as renderDocx, t as TableRow } from "../table-row-vew1y7WH.mjs";
+import { TableRow as TableRow$1 } from "./tiptap.mjs";
+import { attrNative, cssToTwip } from "./utils.mjs";
+//#region src/extensions/table-row.ts
+/**
+* Table row extension with nested office-open attrs.
+*
+* Attrs mirror TableRowPropertiesOptionsBase (cantSplit/tableHeader/hidden as
+* booleans; height as a nested { value, rule } object; cellSpacing as a native
+* value; widthBefore/widthAfter as TableWidthProperties; etc.). DOCX round-trip
+* is near-identity: renderDocx/parseDocx pass attrs through (omitting the
+* `cells` structural key that DocxManager owns). CSS conversion happens only
+* in renderHTML.
+*/
+/** Structural keys filled by DocxManager (compileTableNode). */
+const SKIP_KEYS = new Set(["cells"]);
+function renderDocx(node) {
+	const attrs = node.attrs ?? {};
+	const opts = {};
+	for (const [key, value] of Object.entries(attrs)) {
+		if (SKIP_KEYS.has(key)) continue;
+		if (value !== null && value !== void 0) opts[key] = value;
+	}
+	return opts;
+}
+function parseDocx(opts) {
+	const attrs = {};
+	for (const [key, value] of Object.entries(opts)) {
+		if (SKIP_KEYS.has(key)) continue;
+		attrs[key] = value ?? null;
+	}
+	return attrs;
+}
+const TableRow = TableRow$1.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			height: {
+				default: null,
+				rendered: false,
+				parseHTML: (el) => {
+					const twips = cssToTwip(el.style.height || el.getAttribute("height") || "");
+					return twips != null ? {
+						value: twips,
+						rule: "atLeast"
+					} : null;
+				}
+			},
+			cantSplit: attrNative(),
+			tableHeader: attrNative(),
+			hidden: attrNative(),
+			divId: attrNative(),
+			gridBefore: attrNative(),
+			gridAfter: attrNative(),
+			rowAlignment: attrNative(),
+			cnfStyle: attrNative(),
+			cellSpacing: attrNative(),
+			widthBefore: attrNative(),
+			widthAfter: attrNative()
+		};
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		const attrs = { ...HTMLAttributes };
+		const styles = [];
+		if (node.attrs.height && typeof node.attrs.height === "object") {
+			const h = node.attrs.height;
+			if (h.value != null) styles.push(`height:${h.value / 20}pt`);
+		}
+		if (styles.length > 0) attrs.style = styles.join(";");
+		return [
+			"tr",
+			attrs,
+			0
+		];
+	},
+	renderDocx,
+	parseDocx
+});
+//#endregion
 export { TableRow, parseDocx, renderDocx };