@portone/docx-editor 0.2.0 → 0.2.1

package/dist/docx/sdt.js

@@ -1,4 +1,6 @@
 // src/docx/sdt.ts
+import { elementXml, emptyTagXml, openTagXml } from "../ooxml/element.js";
+import { wName } from "../ooxml/names.js";
 import { wAttr } from "../ooxml/units.js";
 import { attrString, elementChildren, serializeXml } from "../ooxml/xml.js";
 import {
@@ -31,7 +33,7 @@ function readSdtWrapper(el) {
   const attrs = attrString(el);
   const val = lockValue(sdtPr);
   return {
-    prefix: (attrs ? `<w:sdt ${attrs}>` : "<w:sdt>") + head.map(serializeXml).join(""),
+    prefix: openTagXml(wName("sdt"), attrs) + head.map(serializeXml).join(""),
     content,
     contentsLocked: val !== null && CONTENTS_LOCKED.includes(val),
     deletionLocked: val !== null && DELETION_LOCKED.includes(val)
@@ -53,8 +55,8 @@ function newControlId() {
   return Math.floor(Math.random() * 2147483647);
 }
 function renderPrefix(props) {
-  const open = props.attrs ? `<${props.tag} ${props.attrs}>` : `<${props.tag}>`;
-  return open + props.children.map((child) => child.xml).join("");
+  const inner = props.children.map((child) => (child.before ?? "") + child.xml).join("");
+  return openTagXml(props.tag, props.attrs) + inner + (props.tail ?? "");
 }
 var NAMES_NOTHING = ["id", "lock"];
 function namesNothing(prefix) {
@@ -66,31 +68,31 @@ function namesNothing(prefix) {
   return props.children.every((child) => NAMES_NOTHING.includes(child.name));
 }
 function emptyProps(props) {
-  return props.attrs ? `<${props.tag} ${props.attrs}/>` : `<${props.tag}/>`;
+  return emptyTagXml(props.tag, props.attrs);
 }
 function editSdtPrefix(prefix, edits) {
   const sdt = parseProps(`${prefix}</w:sdt>`);
   const sdtPr = sdt && propsChild(sdt.children, "sdtPr");
   const props = sdtPr ? parseProps(sdtPr.xml) : null;
   if (!sdt || !props) return null;
-  const children = edits.reduce(
-    (kept, [name, xml]) => setPropsChild(kept, name, xml, SDT_PR_ORDER),
-    props.children
+  const rendered = renderProps(
+    edits.reduce(
+      (kept, [name, xml]) => setPropsChild(kept, name, xml, SDT_PR_ORDER),
+      props
+    )
   );
-  const rendered = renderProps({ ...props, children });
-  return renderPrefix({
-    ...sdt,
-    children: setPropsChild(
-      sdt.children,
+  return renderPrefix(
+    setPropsChild(
+      sdt,
       "sdtPr",
       rendered === "" ? emptyProps(props) : rendered,
       SDT_ORDER
     )
-  });
+  );
 }
 function copiedControlPrefix(prefix, id) {
   const copied = editSdtPrefix(prefix, [
-    ["id", `<w:id w:val="${id}"/>`],
+    ["id", elementXml(wName("id"), [[wName("val"), `${id}`]])],
     ["dataBinding", null]
   ]);
   return copied ?? prefix;

package/dist/docx/serializeBlock.js

@@ -18,8 +18,7 @@ function serializeBlock(node, session, refs = NO_EXPORT_REFS) {
   if (node.type.name === "paragraph") return serializeParagraph(node, refs);
   if (node.type.name === "table") return serializeTable(node, refs);
   if (node.type.name === "rawBlock") return preservedXml(node);
-  if (node.type.name === "bookmarkBlock") return serializeRaw(node, session);
-  if (node.type.name === "docxRaw") return serializeRaw(node, session);
+  if (node.type.isInGroup("preserved")) return serializeRaw(node, session);
   throw new DocxExportError(
     "unsupported-content",
     `block we cannot serialize: ${node.type.name}`

package/dist/docx/serializeParagraph.d.ts

@@ -10,6 +10,7 @@
  */
 import type { Node as PMNode } from "prosemirror-model";
 import { type ExportRefs } from "./exportRefs";
-export declare function openTag(name: string, attrs: unknown): string;
+/** The attribute text a node attr holds, which is either what the original wrote or nothing */
+export declare function rawAttrsOf(value: unknown): string | null;
 export declare function preservedXml(node: PMNode): string;
 export declare function serializeParagraph(node: PMNode, refs?: ExportRefs): string;

package/dist/docx/serializeParagraph.js

@@ -1,4 +1,5 @@
 // src/docx/serializeParagraph.ts
+import { elementXml, emptyTagXml, openTagXml } from "../ooxml/element.js";
 import { DocxExportError } from "../ooxml/errors.js";
 import {
   imageDrawingXml,
@@ -6,6 +7,7 @@ import {
   toImageSrc,
   withExtent
 } from "../ooxml/image.js";
+import { wName } from "../ooxml/names.js";
 import { escapeXml } from "../ooxml/xml.js";
 import { NO_EXPORT_REFS } from "./exportRefs.js";
 import { relIdIn, withRelId } from "./hyperlink.js";
@@ -16,11 +18,8 @@ function sameMark(a, b) {
 function markOf(node, name) {
   return node.marks.find((mark) => mark.type.name === name) ?? null;
 }
-function openTag(name, attrs) {
-  return typeof attrs === "string" ? `<${name} ${attrs}>` : `<${name}>`;
-}
-function emptyTag(name, attrs) {
-  return typeof attrs === "string" ? `<${name} ${attrs}/>` : `<${name}/>`;
+function rawAttrsOf(value) {
+  return typeof value === "string" ? value : null;
 }
 function renderImage(node, images) {
   const extent = toImageExtent(node.attrs.extent);
@@ -51,19 +50,28 @@ function renderInline(node, images) {
   if (node.isText) {
     const tab = markOf(node, "tab");
     return (node.text ?? "").split("	").flatMap((text, index, pieces) => {
-      const rendered = text ? [`<w:t xml:space="preserve">${escapeXml(text)}</w:t>`] : [];
-      return index < pieces.length - 1 ? [...rendered, emptyTag("w:tab", tab?.attrs.tabAttrs)] : rendered;
+      const rendered = text ? [
+        elementXml(
+          wName("t"),
+          [["xml:space", "preserve"]],
+          [escapeXml(text)]
+        )
+      ] : [];
+      return index < pieces.length - 1 ? [
+        ...rendered,
+        emptyTagXml(wName("tab"), rawAttrsOf(tab?.attrs.tabAttrs))
+      ] : rendered;
     }).join("");
   }
   if (node.type.name === "hardBreak")
-    return emptyTag("w:br", node.attrs.brAttrs);
+    return emptyTagXml(wName("br"), rawAttrsOf(node.attrs.brAttrs));
   if (node.type.name === "image") return renderImage(node, images);
   if (node.type.name === "commentReference") {
     const original = node.attrs.referenceXml;
     if (typeof original === "string") return original;
     const id = node.attrs.id;
     if (typeof id === "string") {
-      return `<w:commentReference w:id="${escapeXml(id)}"/>`;
+      return elementXml(wName("commentReference"), [[wName("id"), id]]);
     }
     throw new DocxExportError(
       "lost-original",
@@ -76,7 +84,7 @@ function renderInline(node, images) {
     const id = node.attrs.id;
     const name = node.attrs.kind === "endnote" ? "endnoteReference" : "footnoteReference";
     if (typeof id === "string") {
-      return `<w:${name} w:id="${escapeXml(id)}"/>`;
+      return elementXml(wName(name), [[wName("id"), id]]);
     }
     throw new DocxExportError(
       "lost-original",
@@ -117,7 +125,10 @@ function addInline(parts, child, images) {
       );
     }
     const name = child.type.name === "commentStart" ? "commentRangeStart" : "commentRangeEnd";
-    parts.push({ kind: "raw", xml: `<w:${name} w:id="${escapeXml(id)}"/>` });
+    parts.push({
+      kind: "raw",
+      xml: elementXml(wName(name), [[wName("id"), id]])
+    });
     return;
   }
   const piece = renderInline(child, images);
@@ -150,7 +161,7 @@ function splitParagraphGroups(paragraph, refs) {
 }
 function renderParagraphPart(part) {
   if (part.kind === "raw") return part.xml;
-  const open = openTag("w:r", part.mark?.attrs.rAttrs);
+  const open = openTagXml(wName("r"), rawAttrsOf(part.mark?.attrs.rAttrs));
   const rPr = part.mark?.attrs.rPr;
   return open + (typeof rPr === "string" ? rPr : "") + part.pieces.join("") + "</w:r>";
 }
@@ -196,13 +207,13 @@ function renderParagraphGroup(group, refs) {
   return `${prefix}<w:sdtContent>${body}</w:sdtContent></w:sdt>`;
 }
 function serializeParagraph(node, refs = NO_EXPORT_REFS) {
-  const open = openTag("w:p", node.attrs.pAttrs);
+  const open = openTagXml(wName("p"), rawAttrsOf(node.attrs.pAttrs));
   const pPr = node.attrs.pPr;
   const body = splitParagraphGroups(node, refs).map((group) => renderParagraphGroup(group, refs)).join("");
   return open + (typeof pPr === "string" ? pPr : "") + body + "</w:p>";
 }
 export {
-  openTag,
   preservedXml,
+  rawAttrsOf,
   serializeParagraph
 };

package/dist/docx/serializeTable.js

@@ -5,18 +5,22 @@ import {
   toTableWidth,
   widthNumber
 } from "../model/format.js";
+import { elementXml, openTagXml } from "../ooxml/element.js";
 import { DocxExportError } from "../ooxml/errors.js";
+import { wName } from "../ooxml/names.js";
 import { NO_EXPORT_REFS } from "./exportRefs.js";
 import {
+  innerXml,
   parseProps,
+  propsChild,
   renderProps,
   setPropsChild,
   TBL_PR_ORDER,
   TC_PR_ORDER
 } from "./propsXml.js";
 import {
-  openTag,
   preservedXml,
+  rawAttrsOf,
   serializeParagraph
 } from "./serializeParagraph.js";
 function propsOf(xml, tag) {
@@ -27,15 +31,24 @@ function propsOf(xml, tag) {
   }
   return parsed;
 }
-function widthXml(name, width) {
-  return `<w:${name} w:w="${widthNumber(width) ?? 0}" w:type="${width.type}"/>`;
+function modelled(name, attrs, replacing) {
+  const inner = replacing === void 0 ? "" : innerXml(replacing);
+  return elementXml(wName(name), attrs, inner === "" ? [] : [inner]);
+}
+function widthXml(name, width, replacing) {
+  return modelled(
+    name,
+    [
+      [wName("w"), `${widthNumber(width) ?? 0}`],
+      [wName("type"), width.type]
+    ],
+    replacing
+  );
 }
 function withWidth(props, name, width, order) {
   if (!width) return props;
-  return {
-    ...props,
-    children: setPropsChild(props.children, name, widthXml(name, width), order)
-  };
+  const replacing = propsChild(props.children, name)?.xml;
+  return setPropsChild(props, name, widthXml(name, width, replacing), order);
 }
 function tablePropsXml(table) {
   const props = propsOf(table.attrs.tblPr, "w:tblPr");
@@ -45,26 +58,27 @@ function tablePropsXml(table) {
 function tableGridXml(table) {
   const gridCols = toGridCols(table.attrs.gridCols);
   if (gridCols.length === 0) return "";
-  const cols = gridCols.map((w) => `<w:gridCol w:w="${w}"/>`).join("");
-  return `<w:tblGrid>${cols}</w:tblGrid>`;
+  const cols = gridCols.map((w) => elementXml(wName("gridCol"), [[wName("w"), `${w}`]])).join("");
+  return elementXml(wName("tblGrid"), [], [cols]);
 }
 function cellPropsXml(cell, role) {
   const props = propsOf(cell.attrs.tcPr, "w:tcPr");
   const colspan = spanCount(cell.attrs.colspan);
   const rowspan = spanCount(cell.attrs.rowspan);
-  const gridSpan = colspan > 1 ? `<w:gridSpan w:val="${colspan}"/>` : null;
-  const vMerge = role === "continue" ? "<w:vMerge/>" : rowspan > 1 ? '<w:vMerge w:val="restart"/>' : null;
-  let children = setPropsChild(
-    props.children,
+  const gridSpan = colspan > 1 ? modelled(
     "gridSpan",
-    gridSpan,
-    TC_PR_ORDER
-  );
-  children = setPropsChild(children, "vMerge", vMerge, TC_PR_ORDER);
+    [[wName("val"), `${colspan}`]],
+    propsChild(props.children, "gridSpan")?.xml
+  ) : null;
+  const vMerge = role === "continue" ? elementXml(wName("vMerge"), []) : rowspan > 1 ? modelled(
+    "vMerge",
+    [[wName("val"), "restart"]],
+    propsChild(props.children, "vMerge")?.xml
+  ) : null;
+  const spanned = setPropsChild(props, "gridSpan", gridSpan, TC_PR_ORDER);
+  const merged = setPropsChild(spanned, "vMerge", vMerge, TC_PR_ORDER);
   const width = toTableWidth(cell.attrs.tcW);
-  return renderProps(
-    withWidth({ ...props, children }, "tcW", width, TC_PR_ORDER)
-  );
+  return renderProps(withWidth(merged, "tcW", width, TC_PR_ORDER));
 }
 function cellBlockXml(block, refs) {
   if (block.type.name === "paragraph") return serializeParagraph(block, refs);
@@ -81,8 +95,8 @@ function wrapInSdt(xml, cell, role) {
   return `${prefix}<w:sdtContent>${xml}</w:sdtContent></w:sdt>`;
 }
 function cellXml(cell, role, refs) {
-  const body = role === "continue" ? "<w:p/>" : cell.children.map((block) => cellBlockXml(block, refs)).join("");
-  const xml = openTag("w:tc", cell.attrs.tcAttrs) + cellPropsXml(cell, role) + body + "</w:tc>";
+  const body = role === "continue" ? elementXml(wName("p"), []) : cell.children.map((block) => cellBlockXml(block, refs)).join("");
+  const xml = openTagXml(wName("tc"), rawAttrsOf(cell.attrs.tcAttrs)) + cellPropsXml(cell, role) + body + "</w:tc>";
   return wrapInSdt(xml, cell, role);
 }
 function placeRow(row, covering) {
@@ -116,7 +130,7 @@ function rowXml(row, covering, refs) {
   const cells = placeRow(row, covering).map((placed) => cellXml(placed.cell, placed.role, refs)).join("");
   const tblPrEx = row.attrs.tblPrEx;
   const trPr = row.attrs.trPr;
-  return openTag("w:tr", row.attrs.trAttrs) + (typeof tblPrEx === "string" ? tblPrEx : "") + (typeof trPr === "string" ? trPr : "") + cells + "</w:tr>";
+  return openTagXml(wName("tr"), rawAttrsOf(row.attrs.trAttrs)) + (typeof tblPrEx === "string" ? tblPrEx : "") + (typeof trPr === "string" ? trPr : "") + cells + "</w:tr>";
 }
 function serializeTable(table, refs = NO_EXPORT_REFS) {
   const covering = [];
@@ -127,7 +141,7 @@ function serializeTable(table, refs = NO_EXPORT_REFS) {
       "a vertical merge in the table reaches past the last row"
     );
   }
-  return openTag("w:tbl", table.attrs.tblAttrs) + tablePropsXml(table) + tableGridXml(table) + rows + "</w:tbl>";
+  return openTagXml(wName("tbl"), rawAttrsOf(table.attrs.tblAttrs)) + tablePropsXml(table) + tableGridXml(table) + rows + "</w:tbl>";
 }
 export {
   serializeTable

package/dist/docx/storyProjection.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The document story as the parts of the package see it: which blocks the editor models and
+ * writes back itself, and the text those blocks go back out as.
+ *
+ * Two files saying the same thing can spell it differently. A block carries the XML it arrived
+ * as on its attrs, so a table Word wrote (`w:w` before `w:type` inside a `w:tcW`) and the same
+ * table this editor wrote (the other way round) compare unequal attr for attr, and a comparison
+ * over the model would call that a body edit. Writing both stories out through the one writer
+ * takes the wording out of the comparison and leaves what the story says, because the writer
+ * reaches a fixed point on its own output: opening what it wrote and writing it again gives the
+ * same text (the test beside this file holds that over every fixture).
+ *
+ * What falls out of the comparison is of two kinds, and the test beside this file keeps them
+ * apart. One is two spellings of a single thing, which the writer settles on one of; forgiving
+ * those is the point, and the set of them is open. The other is content the writer builds afresh
+ * instead of reading, a table's grid and a drawing's extent among it, which the comparison cannot
+ * report because it can no longer see it. That second set is enumerated and meant to shrink: a
+ * case joining it is a preservation defect in the writer, not a detail of the comparison.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { SessionStore } from "./session";
+/** A document and the package it was opened from, which is what writing it back out takes */
+export interface Story {
+    readonly doc: PMNode;
+    readonly session: SessionStore;
+}
+/** Whether this is a block the editor takes apart and writes back itself, rather than one it keeps as it came */
+export declare function isModelledBlock(node: PMNode): boolean;
+/**
+ * Every top-level block as the writer puts it out, with the markup that is allowed to have
+ * changed taken away first.
+ *
+ * null where a block cannot be written back at all, which is a story no comparison can be held
+ * over: a caller judging two files answers such a story the way it answers a changed one.
+ */
+export declare function comparableStory(story: Story, strip: (node: PMNode) => PMNode): readonly string[] | null;

package/dist/docx/storyProjection.js

@@ -0,0 +1,23 @@
+// src/docx/storyProjection.ts
+import { DocxExportError } from "../ooxml/errors.js";
+import { NO_EXPORT_REFS } from "./exportRefs.js";
+import { serializeBlock } from "./serializeBlock.js";
+function isModelledBlock(node) {
+  return node.type.isInGroup("modelled");
+}
+function comparableStory(story, strip) {
+  const blocks = [];
+  try {
+    story.doc.forEach((block) => {
+      blocks.push(serializeBlock(strip(block), story.session, NO_EXPORT_REFS));
+    });
+  } catch (error) {
+    if (error instanceof DocxExportError) return null;
+    throw error;
+  }
+  return blocks;
+}
+export {
+  comparableStory,
+  isModelledBlock
+};

package/dist/docx/tableFormatting/editing.js

@@ -1,6 +1,9 @@
 // src/docx/tableFormatting/editing.ts
+import { attrPairs, elementXml } from "../../ooxml/element.js";
+import { wName } from "../../ooxml/names.js";
+import { setAttr } from "../../ooxml/precedence.js";
 import { normalizeHex, wAttr } from "../../ooxml/units.js";
-import { childByLocalName, escapeXml, localPart } from "../../ooxml/xml.js";
+import { childByLocalName } from "../../ooxml/xml.js";
 import {
   parseProps,
   parsePropsXml,
@@ -41,55 +44,34 @@ var SIDE_NAMES = {
   right: ["right", "end"]
 };
 var PRESET_BORDER_EIGHTHS = 4;
-var THEME_COLOR_ATTRS = ["themeColor", "themeTint", "themeShade"];
-var THEME_FILL_ATTRS = ["themeFill", "themeFillTint", "themeFillShade"];
 var EMPTY_TC_PR = { tag: "w:tcPr", attrs: null, children: [] };
-function attrsOf(el) {
-  return el ? Array.from(el.attributes).map((attr) => [attr.name, attr.value]) : [];
-}
-function withAttr(attrs, name, value, overridden = []) {
-  const kept = attrs.filter(([attr]) => !overridden.includes(localPart(attr)));
-  const at = kept.findIndex(([attr]) => localPart(attr) === name);
-  if (at === -1) return [...kept, [`w:${name}`, value]];
-  return kept.map(
-    (attr, index) => index === at ? [attr[0], value] : attr
-  );
-}
-function elementXml(tag, attrs) {
-  const text = attrs.map(([name, value]) => `${name}="${escapeXml(value)}"`).join(" ");
-  return `<${tag} ${text}/>`;
-}
 function drawsLine(side) {
   if (!side) return false;
   const val = wAttr(side, "val");
   return val !== null && val !== "nil" && val !== "none";
 }
-function sideAttrs(current, edit, fallback = null) {
+function sideAttrs(name, current, edit, fallback = null) {
   if (edit.kind === "color") {
     if (!drawsLine(current)) {
       if (current || !fallback || fallback === "none") return null;
       return inheritedBorderAttrs(fallback, edit.hex);
     }
-    return withAttr(
-      attrsOf(current),
-      "color",
-      edit.hex ?? "auto",
-      THEME_COLOR_ATTRS
-    );
+    return setAttr(attrPairs(current), name, "color", edit.hex ?? "auto");
   }
   if (edit.line === "none") {
-    return current ? withAttr(attrsOf(current), "val", "none") : [["w:val", "none"]];
+    return current ? setAttr(attrPairs(current), name, "val", "none") : [[wName("val"), "none"]];
   }
   if (!current) {
     return [
-      ["w:val", "single"],
-      ["w:sz", `${PRESET_BORDER_EIGHTHS}`],
-      ["w:space", "0"],
-      ["w:color", "auto"]
+      [wName("val"), "single"],
+      [wName("sz"), `${PRESET_BORDER_EIGHTHS}`],
+      [wName("space"), "0"],
+      [wName("color"), "auto"]
     ];
   }
-  return withAttr(
-    withAttr(attrsOf(current), "val", "single"),
+  return setAttr(
+    setAttr(attrPairs(current), name, "val", "single"),
+    name,
     "sz",
     `${PRESET_BORDER_EIGHTHS}`
   );
@@ -110,10 +92,10 @@ function inheritedBorderAttrs(border, hex) {
   const eighths = Math.round(Number.parseFloat(widthText) * 8);
   if (!Number.isSafeInteger(eighths) || eighths <= 0) return null;
   return [
-    ["w:val", BORDER_VAL_BY_CSS_STYLE[style.toLowerCase()]],
-    ["w:sz", `${eighths}`],
-    ["w:space", "0"],
-    ["w:color", hex ?? "auto"]
+    [wName("val"), BORDER_VAL_BY_CSS_STYLE[style.toLowerCase()]],
+    [wName("sz"), `${eighths}`],
+    [wName("space"), "0"],
+    [wName("color"), hex ?? "auto"]
   ];
 }
 function sideNames(borders, side) {
@@ -127,12 +109,12 @@ function editedBorders(current, edit, defaults = NO_BORDER_DEFAULTS) {
   const borders = current === null ? null : parsePropsXml(current);
   if (!props || current !== null && !borders) return null;
   const sides = edit.kind === "line" ? edit.sides : ALL_CELL_SIDES;
-  const children = sides.reduce((kept, side) => {
+  const edited = sides.reduce((kept, side) => {
     const { write, drop } = sideNames(borders, side);
     const currentSide = borders ? childByLocalName(borders, write) : null;
-    const attrs = sideAttrs(currentSide, edit, defaults[side]);
+    const attrs = sideAttrs(write, currentSide, edit, defaults[side]);
     if (!attrs) return kept;
-    const tag = currentSide?.nodeName ?? `w:${write}`;
+    const tag = currentSide?.nodeName ?? wName(write);
     const written = setPropsChild(
       kept,
       write,
@@ -140,8 +122,8 @@ function editedBorders(current, edit, defaults = NO_BORDER_DEFAULTS) {
       TC_BORDERS_ORDER
     );
     return drop === null ? written : setPropsChild(written, drop, null, TC_BORDERS_ORDER);
-  }, props.children);
-  const xml = renderProps({ ...props, children });
+  }, props);
+  const xml = renderProps(edited);
   return { xml: xml === "" ? null : xml };
 }
 function hasPattern(shd) {
@@ -149,23 +131,20 @@ function hasPattern(shd) {
   return val !== null && val !== "clear" && val !== "nil";
 }
 function editedShading(current, fill) {
-  const tag = current?.nodeName ?? "w:shd";
+  const tag = current?.nodeName ?? wName("shd");
   if (fill === null) {
     if (!hasPattern(current)) return null;
-    return elementXml(
-      tag,
-      withAttr(attrsOf(current), "fill", "auto", THEME_FILL_ATTRS)
-    );
+    return elementXml(tag, setAttr(attrPairs(current), "shd", "fill", "auto"));
   }
   if (!current) {
     return elementXml(tag, [
-      ["w:val", "clear"],
-      ["w:color", "auto"],
-      ["w:fill", fill]
+      [wName("val"), "clear"],
+      [wName("color"), "auto"],
+      [wName("fill"), fill]
     ]);
   }
-  const painting = hasPattern(current) ? attrsOf(current) : withAttr(attrsOf(current), "val", "clear");
-  return elementXml(tag, withAttr(painting, "fill", fill, THEME_FILL_ATTRS));
+  const painting = hasPattern(current) ? attrPairs(current) : setAttr(attrPairs(current), "shd", "val", "clear");
+  return elementXml(tag, setAttr(painting, "shd", "fill", fill));
 }
 function bordersChange(props, edit, defaults) {
   const current = propsChild(props.children, "tcBorders")?.xml ?? null;
@@ -191,7 +170,7 @@ function paddingChange(props, values) {
   const margins = current === null ? null : parsePropsXml(current);
   const parsed = current === null ? { tag: "w:tcMar", attrs: null, children: [] } : parseProps(current);
   if (!parsed || current !== null && !margins) return null;
-  let children = parsed.children;
+  let edited = parsed;
   let wrote = false;
   for (const side of ALL_CELL_SIDES) {
     const points = values[side];
@@ -202,21 +181,22 @@ function paddingChange(props, values) {
     }
     const existing = margins ? MARGIN_SIDE_NAMES[side].map((name2) => childByLocalName(margins, name2)).find((element) => element !== null) ?? null : null;
     const name = existing?.localName ?? side;
-    const attrs = withAttr(
-      withAttr(attrsOf(existing), "w", `${twips}`),
+    const attrs = setAttr(
+      setAttr(attrPairs(existing), name, "w", `${twips}`),
+      name,
       "type",
       "dxa"
     );
-    children = setPropsChild(
-      children,
+    edited = setPropsChild(
+      edited,
       name,
-      elementXml(existing?.nodeName ?? `w:${side}`, attrs),
+      elementXml(existing?.nodeName ?? wName(side), attrs),
       TC_MAR_ORDER
     );
     wrote = true;
   }
   if (!wrote) return null;
-  return { name: "tcMar", xml: renderProps({ ...parsed, children }) };
+  return { name: "tcMar", xml: renderProps(edited) };
 }
 function childChange(edit, props, defaults) {
   switch (edit.kind) {
@@ -250,8 +230,8 @@ function childChange(edit, props, defaults) {
       return {
         name: "vAlign",
         xml: elementXml(
-          element?.nodeName ?? "w:vAlign",
-          withAttr(attrsOf(element), "val", edit.align)
+          element?.nodeName ?? wName("vAlign"),
+          setAttr(attrPairs(element), "vAlign", "val", edit.align)
         )
       };
     }
@@ -264,13 +244,9 @@ function editCellProps(tcPr, edit, defaults = NO_BORDER_DEFAULTS, margins = NO_C
   if (!props) return null;
   const change = childChange(edit, props, defaults);
   if (!change) return null;
-  const children = setPropsChild(
-    props.children,
-    change.name,
-    change.xml,
-    TC_PR_ORDER
+  const rendered = renderProps(
+    setPropsChild(props, change.name, change.xml, TC_PR_ORDER)
   );
-  const rendered = renderProps({ ...props, children });
   const next = rendered === "" ? null : rendered;
   if (next === tcPr) return null;
   return { tcPr: next, format: readCellProps(next, defaults, margins) };
@@ -294,17 +270,17 @@ function editRowHeight(trPr, heightPt) {
   const element = current === null ? null : parsePropsXml(current);
   if (current !== null && !element) return null;
   const writtenRule = element ? wAttr(element, "hRule") : null;
-  const attrs = withAttr(attrsOf(element), "val", `${twips}`);
-  const nextAttrs = withAttr(
+  const attrs = setAttr(attrPairs(element), "trHeight", "val", `${twips}`);
+  const nextAttrs = setAttr(
     attrs,
+    "trHeight",
     "hRule",
     writtenRule === "exact" ? "exact" : "atLeast"
   );
-  const child = elementXml(element?.nodeName ?? "w:trHeight", nextAttrs);
-  const rendered = renderProps({
-    ...props,
-    children: setPropsChild(props.children, "trHeight", child, TR_PR_ORDER)
-  });
+  const child = elementXml(element?.nodeName ?? wName("trHeight"), nextAttrs);
+  const rendered = renderProps(
+    setPropsChild(props, "trHeight", child, TR_PR_ORDER)
+  );
   if (rendered === trPr) return null;
   const parsed = parsePropsXml(rendered);
   const format = parsed ? readRowFormat(parsed) : null;

package/dist/docx/tableTemplate.js

@@ -1,4 +1,6 @@
 // src/docx/tableTemplate.ts
+import { elementXml } from "../ooxml/element.js";
+import { wName } from "../ooxml/names.js";
 import { docxSchema } from "../schema/index.js";
 import { A4_PORTRAIT, bodyWidth } from "./pageGeometry.js";
 import { parsePropsXml } from "./propsXml.js";
@@ -25,14 +27,33 @@ var BORDER_SIDES = [
   "insideV"
 ];
 function borderXml(side) {
-  return `<w:${side} w:val="single" w:sz="${BORDER_EIGHTHS}" w:space="0" w:color="000000"/>`;
+  return elementXml(wName(side), [
+    [wName("val"), "single"],
+    [wName("sz"), `${BORDER_EIGHTHS}`],
+    [wName("space"), "0"],
+    [wName("color"), "000000"]
+  ]);
 }
 function tablePropsXml(width) {
   const borders = BORDER_SIDES.map(borderXml).join("");
-  return `<w:tblPr><w:tblW w:w="${width}" w:type="dxa"/><w:tblBorders>${borders}</w:tblBorders><w:tblLayout w:type="fixed"/></w:tblPr>`;
+  return elementXml(
+    wName("tblPr"),
+    [],
+    [
+      widthXml("tblW", width),
+      elementXml(wName("tblBorders"), [], [borders]),
+      elementXml(wName("tblLayout"), [[wName("type"), "fixed"]])
+    ]
+  );
+}
+function widthXml(name, width) {
+  return elementXml(wName(name), [
+    [wName("w"), `${width}`],
+    [wName("type"), "dxa"]
+  ]);
 }
 function cellPropsXml(width) {
-  return `<w:tcPr><w:tcW w:w="${width}" w:type="dxa"/></w:tcPr>`;
+  return elementXml(wName("tcPr"), [], [widthXml("tcW", width)]);
 }
 function evenGridCols(cols, total) {
   const base = Math.floor(total / cols);