@portone/docx-editor 0.2.0 → 0.3.0

package/dist/docx/session.js

@@ -1,7 +1,16 @@
 // src/docx/session.ts
-import { parseNumbering } from "../numbering/parseNumbering.js";
+import {
+  parseNumbering
+} from "../numbering/parseNumbering.js";
+var sessionsOpened = 0;
+function newSessionId() {
+  sessionsOpened += 1;
+  return `d${sessionsOpened}-${Math.random().toString(36).slice(2, 10)}`;
+}
 var SessionStore = class {
   kind = "docxSession";
+  /** Which open document this is. Every block key of it names it, so a block of another document is not taken for one of this one */
+  sessionId;
   parts;
   mainPartPath;
   documentPrefix;
@@ -12,19 +21,12 @@ var SessionStore = class {
   defaults;
   /** The effective automatic tab interval read from settings.xml. Used for display only. */
   defaultTabStopPt;
-  /** The paragraph properties at the base of the OOXML formatting hierarchy. */
-  paragraphDefaults;
   /** The paper this document is written on, read from the first section. Used for display only: the `w:sectPr` itself goes back out in the preserved tail */
   geometry;
-  /** The style chain from styles.xml. Used only to fold the style a paragraph points at into its displayed values */
-  styles;
+  /** Everything the display values of a paragraph or a run are resolved against: the style chain, the defaults, the list definitions */
+  formatting;
   /** The paragraph styles this document defines, in the order styles.xml lists them. What the style picker offers */
   paragraphStyles;
-  /**
-   * The paragraph style every paragraph with no `w:pStyle` of its own wears (`w:default="1"`,
-   * usually Normal). null when the document marks none
-   */
-  defaultParagraphStyleId;
   /** The raw text of numbering.xml. Kept around so list numbers can be drawn on screen. null if there is none */
   numberingXml;
   /** Where numbering.xml sits inside the zip. When a new list is exported it is rewritten at that spot. null if there is none */
@@ -36,6 +38,7 @@ var SessionStore = class {
   /** First-section header and footer stories projected for the page preview. */
   headersFooters;
   constructor(opened) {
+    this.sessionId = opened.sessionId;
     this.parts = opened.parts;
     this.mainPartPath = opened.mainPartPath;
     this.documentPrefix = opened.documentPrefix;
@@ -44,11 +47,9 @@ var SessionStore = class {
     this.blocks = opened.blocks;
     this.defaults = opened.defaults;
     this.defaultTabStopPt = opened.defaultTabStopPt;
-    this.paragraphDefaults = opened.paragraphDefaults;
     this.geometry = opened.geometry;
-    this.styles = opened.styles;
+    this.formatting = opened.formatting;
     this.paragraphStyles = opened.paragraphStyles;
-    this.defaultParagraphStyleId = opened.defaultParagraphStyleId;
     this.numberingXml = opened.numberingXml;
     this.numberingPartPath = opened.numberingPartPath;
     this.comments = opened.comments;
@@ -63,17 +64,42 @@ function sessionOf(session) {
 function documentPartPath(session) {
   return sessionOf(session).mainPartPath;
 }
-function documentNumbering(session) {
-  return parseNumbering(sessionOf(session).numberingXml);
+function documentNumbering(session, options) {
+  return parseNumbering(sessionOf(session).numberingXml, options);
+}
+var BODY_STORY_KEY = "body";
+function blockKey(session, storyKey, index) {
+  return `${session.sessionId}:${storyKey}:${index}`;
+}
+function splitBlockKey(key) {
+  const first = key.indexOf(":");
+  const last = key.lastIndexOf(":");
+  if (first < 1 || last <= first + 1) return null;
+  const indexText = key.slice(last + 1);
+  if (!/^\d+$/.test(indexText)) return null;
+  const index = Number(indexText);
+  if (!Number.isSafeInteger(index)) return null;
+  return {
+    sessionId: key.slice(0, first),
+    storyKey: key.slice(first + 1, last),
+    index
+  };
 }
 function originalBlock(node, session) {
   const srcId = node.attrs.srcId;
-  return typeof srcId === "number" ? session.blocks[srcId] : void 0;
+  if (typeof srcId !== "string") return void 0;
+  const key = splitBlockKey(srcId);
+  if (key === null || key.sessionId !== session.sessionId) return void 0;
+  return key.storyKey === BODY_STORY_KEY ? session.blocks[key.index] : void 0;
 }
 export {
+  BODY_STORY_KEY,
   SessionStore,
+  blockKey,
   documentNumbering,
   documentPartPath,
+  newSessionId,
   originalBlock,
-  sessionOf
+  sessionOf,
+  splitBlockKey
 };

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,15 +1,23 @@
 // src/docx/tableFormatting/editing.ts
-import { normalizeHex, wAttr } from "../../ooxml/units.js";
-import { childByLocalName, escapeXml, localPart } from "../../ooxml/xml.js";
+import { elementXml, wAttrValue } from "../../ooxml/element.js";
+import { wName } from "../../ooxml/names.js";
+import { setAttr } from "../../ooxml/precedence.js";
 import {
+  childElement,
+  editChild,
   parseProps,
   parsePropsXml,
   propsChild,
   renderProps,
-  setPropsChild,
-  TC_PR_ORDER,
-  TR_PR_ORDER
-} from "../propsXml.js";
+  setChild,
+  withAttrs
+} from "../../ooxml/props.js";
+import {
+  ST_EighthPointMeasure,
+  ST_TwipsMeasure,
+  TWIPS_PER_PT
+} from "../../ooxml/simpleTypes.js";
+import { normalizeHex } from "../../ooxml/units.js";
 import {
   NO_BORDER_DEFAULTS,
   NO_CELL_MARGINS,
@@ -22,18 +30,6 @@ var ALL_CELL_SIDES = [
   "left",
   "right"
 ];
-var TC_BORDERS_ORDER = [
-  "top",
-  "start",
-  "left",
-  "bottom",
-  "end",
-  "right",
-  "insideH",
-  "insideV",
-  "tl2br",
-  "tr2bl"
-];
 var SIDE_NAMES = {
   top: ["top"],
   bottom: ["bottom"],
@@ -41,270 +37,219 @@ 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");
+  if (side.tag === null) return false;
+  const val = wAttrValue(side.attrs, "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;
+      if (current.tag !== null || fallback === null || fallback.val === "none") {
+        return null;
+      }
       return inheritedBorderAttrs(fallback, edit.hex);
     }
-    return withAttr(
-      attrsOf(current),
-      "color",
-      edit.hex ?? "auto",
-      THEME_COLOR_ATTRS
-    );
+    return setAttr(current.attrs, name, "color", edit.hex ?? "auto");
   }
   if (edit.line === "none") {
-    return current ? withAttr(attrsOf(current), "val", "none") : [["w:val", "none"]];
+    return current.tag !== null ? setAttr(current.attrs, name, "val", "none") : [[wName("val"), "none"]];
   }
-  if (!current) {
+  if (current.tag === null) {
     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(current.attrs, name, "val", "single"),
+    name,
     "sz",
     `${PRESET_BORDER_EIGHTHS}`
   );
 }
-var BORDER_VAL_BY_CSS_STYLE = {
-  solid: "single",
-  double: "double",
-  dashed: "dashed",
-  dotted: "dotted"
-};
-function inheritedBorderAttrs(border, hex) {
-  const matched = border.match(
-    /^(\d+(?:\.\d+)?)pt (solid|double|dashed|dotted) (#[0-9a-f]{6})$/i
-  );
-  if (!matched) return null;
-  const [, widthText, style, currentColor] = matched;
-  if (hex !== null && normalizeHex(currentColor) === hex) return null;
-  const eighths = Math.round(Number.parseFloat(widthText) * 8);
-  if (!Number.isSafeInteger(eighths) || eighths <= 0) return null;
+function inheritedBorderAttrs(line, hex) {
+  const current = line.color.kind === "rgb" ? normalizeHex(line.color.hex) : null;
+  if (hex !== null && current === hex) return null;
+  const thickness = ST_EighthPointMeasure.format(line.eighths);
+  if (thickness === null) return null;
   return [
-    ["w:val", BORDER_VAL_BY_CSS_STYLE[style.toLowerCase()]],
-    ["w:sz", `${eighths}`],
-    ["w:space", "0"],
-    ["w:color", hex ?? "auto"]
+    [wName("val"), line.val],
+    [wName("sz"), thickness],
+    [wName("space"), "0"],
+    [wName("color"), hex ?? "auto"]
   ];
 }
 function sideNames(borders, side) {
   const [primary, alternate] = SIDE_NAMES[side];
-  const usesAlternate = alternate !== void 0 && borders !== null && childByLocalName(borders, primary) === null && childByLocalName(borders, alternate) !== null;
+  const usesAlternate = alternate !== void 0 && propsChild(borders.children, primary) === void 0 && propsChild(borders.children, alternate) !== void 0;
   if (usesAlternate) return { write: alternate, drop: null };
   return { write: primary, drop: alternate ?? null };
 }
-function editedBorders(current, edit, defaults = NO_BORDER_DEFAULTS) {
-  const props = current === null ? { tag: "w:tcBorders", attrs: null, children: [] } : parseProps(current);
-  const borders = current === null ? null : parsePropsXml(current);
-  if (!props || current !== null && !borders) return null;
+function leafElement(tag, attrs) {
+  return withAttrs({ tag, attrs: null, children: [] }, attrs);
+}
+function containerOf(props, name) {
+  const current = propsChild(props.children, name)?.xml;
+  if (current === void 0) {
+    return { tag: wName(name), attrs: null, children: [] };
+  }
+  return parseProps(current);
+}
+function editedBorders(props, edit, defaults) {
+  const borders = containerOf(props, "tcBorders");
+  if (!borders) return null;
   const sides = edit.kind === "line" ? edit.sides : ALL_CELL_SIDES;
-  const children = sides.reduce((kept, side) => {
+  return sides.reduce((kept, side) => {
+    if (kept === null) return null;
     const { write, drop } = sideNames(borders, side);
-    const currentSide = borders ? childByLocalName(borders, write) : null;
-    const attrs = sideAttrs(currentSide, edit, defaults[side]);
+    const currentSide = childElement(borders, write);
+    if (!currentSide) return null;
+    const attrs = sideAttrs(write, currentSide, edit, defaults[side]);
     if (!attrs) return kept;
-    const tag = currentSide?.nodeName ?? `w:${write}`;
-    const written = setPropsChild(
+    const written = editChild(
       kept,
-      write,
-      elementXml(tag, attrs),
-      TC_BORDERS_ORDER
+      ["tcBorders", write],
+      () => leafElement(currentSide.tag ?? wName(write), attrs)
     );
-    return drop === null ? written : setPropsChild(written, drop, null, TC_BORDERS_ORDER);
-  }, props.children);
-  const xml = renderProps({ ...props, children });
-  return { xml: xml === "" ? null : xml };
+    if (written === null || drop === null) return written;
+    return editChild(written, ["tcBorders", drop], () => null);
+  }, props);
 }
 function hasPattern(shd) {
-  const val = shd ? wAttr(shd, "val") : null;
+  const val = wAttrValue(shd.attrs, "val");
   return val !== null && val !== "clear" && val !== "nil";
 }
 function editedShading(current, fill) {
-  const tag = current?.nodeName ?? "w:shd";
+  const tag = current.tag ?? 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(current.attrs, "shd", "fill", "auto"));
   }
-  if (!current) {
+  if (current.tag === null) {
     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));
-}
-function bordersChange(props, edit, defaults) {
-  const current = propsChild(props.children, "tcBorders")?.xml ?? null;
-  const edited = editedBorders(current, edit, defaults);
-  return edited === null ? null : { name: "tcBorders", xml: edited.xml };
+  const painting = hasPattern(current) ? current.attrs : setAttr(current.attrs, "shd", "val", "clear");
+  return elementXml(tag, setAttr(painting, "shd", "fill", fill));
 }
-var TC_MAR_ORDER = [
-  "top",
-  "start",
-  "left",
-  "bottom",
-  "end",
-  "right"
-];
 var MARGIN_SIDE_NAMES = {
   top: ["top"],
   right: ["end", "right"],
   bottom: ["bottom"],
   left: ["start", "left"]
 };
-function paddingChange(props, values) {
-  const current = propsChild(props.children, "tcMar")?.xml ?? null;
-  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;
+function editedPadding(props, values) {
+  const margins = containerOf(props, "tcMar");
+  if (!margins) return null;
+  let edited = props;
   let wrote = false;
   for (const side of ALL_CELL_SIDES) {
     const points = values[side];
     if (points === void 0) continue;
-    const twips = Math.round(points * 20);
-    if (!Number.isFinite(points) || points < 0 || !Number.isSafeInteger(twips)) {
-      return null;
-    }
-    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}`),
+    if (points < 0) return null;
+    const twips = ST_TwipsMeasure.format(Math.round(points * TWIPS_PER_PT));
+    if (twips === null) return null;
+    const name = MARGIN_SIDE_NAMES[side].find(
+      (spelling) => propsChild(margins.children, spelling) !== void 0
+    ) ?? side;
+    const existing = childElement(margins, name);
+    if (existing === null || edited === null) return null;
+    const attrs = setAttr(
+      setAttr(existing.attrs, name, "w", twips),
+      name,
       "type",
       "dxa"
     );
-    children = setPropsChild(
-      children,
-      name,
-      elementXml(existing?.nodeName ?? `w:${side}`, attrs),
-      TC_MAR_ORDER
+    edited = editChild(
+      edited,
+      ["tcMar", name],
+      () => leafElement(existing.tag ?? wName(side), attrs)
     );
     wrote = true;
   }
-  if (!wrote) return null;
-  return { name: "tcMar", xml: renderProps({ ...parsed, children }) };
+  return wrote ? edited : null;
 }
-function childChange(edit, props, defaults) {
+function editedProps(edit, props, defaults) {
   switch (edit.kind) {
     case "background": {
       const fill = edit.hex === null ? null : normalizeHex(edit.hex);
       if (edit.hex !== null && fill === null) return null;
-      const current = propsChild(props.children, "shd")?.xml ?? null;
-      const shd = current === null ? null : parsePropsXml(current);
-      if (current !== null && !shd) return null;
-      return { name: "shd", xml: editedShading(shd, fill) };
+      const shd = childElement(props, "shd");
+      if (!shd) return null;
+      return setChild(props, "shd", editedShading(shd, fill));
     }
     case "borders":
-      return bordersChange(
+      return editedBorders(
         props,
-        {
-          kind: "line",
-          line: edit.line,
-          sides: edit.sides
-        },
+        { kind: "line", line: edit.line, sides: edit.sides },
         defaults
       );
     case "borderColor": {
       const hex = edit.hex === null ? null : normalizeHex(edit.hex);
       if (edit.hex !== null && hex === null) return null;
-      return bordersChange(props, { kind: "color", hex }, defaults);
+      return editedBorders(props, { kind: "color", hex }, defaults);
     }
     case "verticalAlign": {
-      const current = propsChild(props.children, "vAlign")?.xml ?? null;
-      const element = current === null ? null : parsePropsXml(current);
-      if (current !== null && !element) return null;
-      return {
-        name: "vAlign",
-        xml: elementXml(
-          element?.nodeName ?? "w:vAlign",
-          withAttr(attrsOf(element), "val", edit.align)
+      const current = childElement(props, "vAlign");
+      if (!current) return null;
+      return setChild(
+        props,
+        "vAlign",
+        elementXml(
+          current.tag ?? wName("vAlign"),
+          setAttr(current.attrs, "vAlign", "val", edit.align)
         )
-      };
+      );
     }
     case "padding":
-      return paddingChange(props, edit.values);
+      return editedPadding(props, edit.values);
   }
 }
 function editCellProps(tcPr, edit, defaults = NO_BORDER_DEFAULTS, margins = NO_CELL_MARGINS) {
   const props = tcPr === null ? EMPTY_TC_PR : parseProps(tcPr);
   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({ ...props, children });
+  const edited = editedProps(edit, props, defaults);
+  if (!edited) return null;
+  const rendered = renderProps(edited);
   const next = rendered === "" ? null : rendered;
   if (next === tcPr) return null;
   return { tcPr: next, format: readCellProps(next, defaults, margins) };
 }
 function drawsOwnCellBorder(tcPr) {
-  const el = tcPr === null ? null : parsePropsXml(tcPr);
-  const borders = el ? childByLocalName(el, "tcBorders") : null;
+  const props = tcPr === null ? null : parseProps(tcPr);
+  const borders = props && containerOf(props, "tcBorders");
   if (!borders) return false;
   return ALL_CELL_SIDES.some(
-    (side) => SIDE_NAMES[side].some((name) => drawsLine(childByLocalName(borders, name)))
+    (side) => SIDE_NAMES[side].some((name) => {
+      const element = childElement(borders, name);
+      return element !== null && drawsLine(element);
+    })
   );
 }
 function editRowHeight(trPr, heightPt) {
-  const twips = Math.round(heightPt * 20);
-  if (!Number.isFinite(heightPt) || heightPt <= 0 || !Number.isSafeInteger(twips)) {
-    return null;
-  }
-  const props = trPr === null ? { tag: "w:trPr", attrs: null, children: [] } : parseProps(trPr);
+  const twips = heightPt > 0 ? ST_TwipsMeasure.format(Math.round(heightPt * TWIPS_PER_PT)) : null;
+  if (twips === null) return null;
+  const props = trPr === null ? { tag: wName("trPr"), attrs: null, children: [] } : parseProps(trPr);
   if (!props) return null;
-  const current = propsChild(props.children, "trHeight")?.xml ?? null;
-  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 current = childElement(props, "trHeight");
+  if (!current) return null;
+  const writtenRule = wAttrValue(current.attrs, "hRule");
+  const attrs = setAttr(current.attrs, "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(current.tag ?? wName("trHeight"), nextAttrs);
+  const rendered = renderProps(setChild(props, "trHeight", child));
   if (rendered === trPr) return null;
   const parsed = parsePropsXml(rendered);
   const format = parsed ? readRowFormat(parsed) : null;

package/dist/docx/tableFormatting/reading.d.ts

@@ -3,14 +3,19 @@
  * collapsed-border resolution matches OOXML inheritance without changing exported XML.
  */
 import type { CellFormat, CellMargins, InsideBorders, RowFormat, TableFormat, TableWidth } from "../../model/format";
+import { type BorderLine } from "../../ooxml/units";
 export type { CellMargins, InsideBorders } from "../../model/format";
+/** The parts of a table a table style formats conditionally (`w:tblStylePr/@w:type`, ST_TblStyleOverrideType) */
+export type TableStyleOverrideType = "wholeTable" | "firstRow" | "lastRow" | "firstCol" | "lastCol" | "band1Vert" | "band2Vert" | "band1Horz" | "band2Horz" | "neCell" | "nwCell" | "seCell" | "swCell";
 /**
  * The width written down by `<w:tblW>` or `<w:tcW>`.
  * If we cannot make out what it means it is null, and such a width goes back out unchanged on export.
  *
- * `auto` and `nil` leave the width to the layout, so whatever number stands beside them says nothing.
+ * `auto` and `nil` leave the width to the layout unless the value carries an explicit percentage.
  * A percentage may be written in fiftieths of a percent, as in `w:w="2500"`, or as `w:w="50%"`.
  * Both have to be gathered into the same unit, or the table collapses into a thin strip on screen.
+ * Word lets an explicit `%` override `w:type` (MS-OI29500 §2.1.185(b)); see
+ * spec/notes/simpleTypes.md. A universal measure under `pct` remains unreadable here.
  */
 export declare function readTableWidth(parent: Element | null, name: "tblW" | "tcW"): TableWidth | null;
 /** The sequence of column widths (dxa) set by `<w:tblGrid>`. Revision markup (tblGridChange) is skipped */
@@ -32,12 +37,17 @@ export declare function readCellMarginsOf(parent: Element | null, name: "tblCell
  * their cell padding from.
  */
 export declare function layerCellMargins(style: CellMargins, direct: CellMargins): CellMargins;
-/** The lines a cell falls back on, one per side, already resolved for its spot in the grid */
+/**
+ * The lines a cell falls back on, one per side, already resolved for its spot in the grid.
+ *
+ * They are held as the markup records them rather than as CSS, because a cell that takes one of
+ * them over as a border of its own writes it back into `w:tcBorders`.
+ */
 export interface CellBorderDefaults {
-    top: string | null;
-    bottom: string | null;
-    left: string | null;
-    right: string | null;
+    top: BorderLine | null;
+    bottom: BorderLine | null;
+    left: BorderLine | null;
+    right: BorderLine | null;
 }
 export declare const NO_BORDER_DEFAULTS: CellBorderDefaults;
 /** Which sides of a cell lie on the edge of the table's grid */