@portone/docx-editor 0.3.0 → 0.5.0

package/dist/docx/tableFormatting/conditions.js

@@ -0,0 +1,196 @@
+// src/docx/tableFormatting/conditions.ts
+import { ST_OnOff } from "../../ooxml/simpleTypes.js";
+import { borderLineOfCss, wAttr } from "../../ooxml/units.js";
+import { childByLocalName } from "../../ooxml/xml.js";
+import {
+  layerCellMargins,
+  NO_BAND_SIZES,
+  NO_CELL_MARGINS,
+  NO_INSIDE_BORDERS,
+  NO_TABLE_STYLE_CONDITIONS
+} from "./reading.js";
+var NO_LOOK = {
+  firstRow: false,
+  lastRow: false,
+  firstColumn: false,
+  lastColumn: false,
+  noHBand: false,
+  noVBand: false
+};
+var LEGACY_LOOK_BITS = {
+  firstRow: 32,
+  lastRow: 64,
+  firstColumn: 128,
+  lastColumn: 256,
+  noHBand: 512,
+  noVBand: 1024
+};
+var SHORT_HEX = /^[0-9a-fA-F]{4}$/;
+function legacyLook(value) {
+  const bits = value !== null && SHORT_HEX.test(value) ? Number.parseInt(value, 16) : 0;
+  return {
+    firstRow: (bits & LEGACY_LOOK_BITS.firstRow) !== 0,
+    lastRow: (bits & LEGACY_LOOK_BITS.lastRow) !== 0,
+    firstColumn: (bits & LEGACY_LOOK_BITS.firstColumn) !== 0,
+    lastColumn: (bits & LEGACY_LOOK_BITS.lastColumn) !== 0,
+    noHBand: (bits & LEGACY_LOOK_BITS.noHBand) !== 0,
+    noVBand: (bits & LEGACY_LOOK_BITS.noVBand) !== 0
+  };
+}
+function readTableLook(tblPr) {
+  const el = tblPr ? childByLocalName(tblPr, "tblLook") : null;
+  if (!el) return NO_LOOK;
+  const legacy = legacyLook(wAttr(el, "val"));
+  const written = (name) => ST_OnOff.parse(wAttr(el, name)) ?? legacy[name];
+  return {
+    firstRow: written("firstRow"),
+    lastRow: written("lastRow"),
+    firstColumn: written("firstColumn"),
+    lastColumn: written("lastColumn"),
+    noHBand: written("noHBand"),
+    noVBand: written("noVBand")
+  };
+}
+function bandWidth(size) {
+  return size ?? 1;
+}
+function bandedRows(grid, look) {
+  return [look.firstRow ? 1 : 0, look.lastRow ? grid.rows - 1 : grid.rows];
+}
+function bandedColumns(grid, look) {
+  return [
+    look.firstColumn ? 1 : 0,
+    look.lastColumn ? grid.cols - 1 : grid.cols
+  ];
+}
+function bandAt(at, [from, to], size) {
+  if (at < from || at >= to) return null;
+  const index = Math.floor((at - from) / size);
+  return {
+    first: index % 2 === 0,
+    start: from + index * size,
+    end: Math.min(from + (index + 1) * size, to)
+  };
+}
+function rowsOf(grid, top, bottom) {
+  return { top, bottom, left: 0, right: grid.cols };
+}
+function columnsOf(grid, left, right) {
+  return { top: 0, bottom: grid.rows, left, right };
+}
+function cellPlacement(rect, grid, look, bands) {
+  const found = [];
+  const add = (type, region) => {
+    found.push({ type, region });
+  };
+  add("wholeTable", rowsOf(grid, 0, grid.rows));
+  const column = look.noVBand ? null : bandAt(rect.left, bandedColumns(grid, look), bandWidth(bands.col));
+  if (column) {
+    add(
+      column.first ? "band1Vert" : "band2Vert",
+      columnsOf(grid, column.start, column.end)
+    );
+  }
+  const row = look.noHBand ? null : bandAt(rect.top, bandedRows(grid, look), bandWidth(bands.row));
+  if (row) {
+    add(
+      row.first ? "band1Horz" : "band2Horz",
+      rowsOf(grid, row.start, row.end)
+    );
+  }
+  const firstRow = look.firstRow && rect.top === 0;
+  const lastRow = look.lastRow && rect.bottom === grid.rows && grid.rows > 1;
+  const firstCol = look.firstColumn && rect.left === 0;
+  const lastCol = look.lastColumn && rect.right === grid.cols && grid.cols > 1;
+  if (firstRow) add("firstRow", rowsOf(grid, 0, 1));
+  if (lastRow) add("lastRow", rowsOf(grid, grid.rows - 1, grid.rows));
+  if (firstCol) add("firstCol", columnsOf(grid, 0, 1));
+  if (lastCol) add("lastCol", columnsOf(grid, grid.cols - 1, grid.cols));
+  const corner = (type, top, left) => {
+    add(type, { top, bottom: top + 1, left, right: left + 1 });
+  };
+  if (firstRow && firstCol) corner("nwCell", 0, 0);
+  if (firstRow && lastCol) corner("neCell", 0, grid.cols - 1);
+  if (lastRow && firstCol) corner("swCell", grid.rows - 1, 0);
+  if (lastRow && lastCol) corner("seCell", grid.rows - 1, grid.cols - 1);
+  return { rect, grid, conditions: found };
+}
+var NO_CELL_SOURCES = {
+  outer: null,
+  inside: NO_INSIDE_BORDERS,
+  margins: NO_CELL_MARGINS,
+  look: NO_LOOK,
+  bands: NO_BAND_SIZES,
+  conditions: NO_TABLE_STYLE_CONDITIONS,
+  styleId: null
+};
+function edgesIn(rect, region) {
+  return {
+    top: rect.top === region.top,
+    bottom: rect.bottom === region.bottom,
+    left: rect.left === region.left,
+    right: rect.right === region.right
+  };
+}
+function tableBorderDefaults(edges, outer, inside) {
+  return {
+    top: borderLineOfCss(
+      edges.top ? outer?.borderTop ?? null : inside.horizontal
+    ),
+    bottom: borderLineOfCss(
+      edges.bottom ? outer?.borderBottom ?? null : inside.horizontal
+    ),
+    left: borderLineOfCss(
+      edges.left ? outer?.borderLeft ?? null : inside.vertical
+    ),
+    right: borderLineOfCss(
+      edges.right ? outer?.borderRight ?? null : inside.vertical
+    )
+  };
+}
+function conditionBorderDefaults(base, format, edges) {
+  const line = (onEdge, edge, within) => borderLineOfCss(onEdge ? edge : within);
+  return {
+    top: line(edges.top, format.borders.top, format.inside.horizontal) ?? base.top,
+    bottom: line(edges.bottom, format.borders.bottom, format.inside.horizontal) ?? base.bottom,
+    left: line(edges.left, format.borders.left, format.inside.vertical) ?? base.left,
+    right: line(edges.right, format.borders.right, format.inside.vertical) ?? base.right
+  };
+}
+function cellDefaultsFor(rect, grid, sources) {
+  const placement = cellPlacement(rect, grid, sources.look, sources.bands);
+  const whole = { top: 0, bottom: grid.rows, left: 0, right: grid.cols };
+  let borders = tableBorderDefaults(
+    edgesIn(rect, whole),
+    sources.outer,
+    sources.inside
+  );
+  let margins = sources.margins;
+  let background = null;
+  let verticalAlign = null;
+  for (const { type, region } of placement.conditions) {
+    const format = sources.conditions[type];
+    if (!format) continue;
+    borders = conditionBorderDefaults(borders, format, edgesIn(rect, region));
+    margins = layerCellMargins(margins, format.margins);
+    background = format.background ?? background;
+    verticalAlign = format.verticalAlign ?? verticalAlign;
+  }
+  return {
+    borders,
+    margins,
+    background,
+    verticalAlign,
+    placement: {
+      tableStyleId: sources.styleId,
+      conditions: placement.conditions.map((condition) => condition.type)
+    }
+  };
+}
+export {
+  NO_CELL_SOURCES,
+  NO_LOOK,
+  cellDefaultsFor,
+  cellPlacement,
+  readTableLook
+};

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

@@ -3,8 +3,8 @@
  * only the child and attributes named by the edit are changed, and unsupported formatting stays
  * untouched.
  */
-import type { CellFormat, CellMargins, CellVerticalAlign, RowFormat } from "../../model/format";
-import { type CellBorderDefaults } from "./reading";
+import type { CellFormat, CellVerticalAlign, RowFormat } from "../../model/format";
+import { type CellDefaults } from "./reading";
 export interface CellProps {
     /** The whole `<w:tcPr>...</w:tcPr>` XML. null for a cell with no formatting */
     tcPr: string | null;
@@ -45,11 +45,15 @@ export type CellFormatEdit =
 /**
  * The cell formatting XML and display values after one piece of formatting is changed.
  *
+ * What the cell falls back on is what an edit measures against: switching a side off writes `none`
+ * over whatever line was being drawn there, and recoloring writes only where a line is drawn at
+ * all, so the defaults handed in have to be the ones the cell is actually drawn with.
+ *
  * null when there is nothing to do: a fragment whose shape could not be made out, a value that
  * cannot be written into the document, or a cell already in the state the job wants. In every one
  * of those cases the cell keeps its original XML.
  */
-export declare function editCellProps(tcPr: string | null, edit: CellFormatEdit, defaults?: CellBorderDefaults, margins?: CellMargins): CellProps | null;
+export declare function editCellProps(tcPr: string | null, edit: CellFormatEdit, defaults?: CellDefaults): CellProps | null;
 /**
  * Whether the cell's own formatting draws a line on any side.
  * A border color has nothing to act on when it does not, because the lines on screen are then the

package/dist/docx/tableFormatting/editing.js

@@ -19,8 +19,7 @@ import {
 } from "../../ooxml/simpleTypes.js";
 import { normalizeHex } from "../../ooxml/units.js";
 import {
-  NO_BORDER_DEFAULTS,
-  NO_CELL_MARGINS,
+  NO_CELL_DEFAULTS,
   readCellProps,
   readRowFormat
 } from "./reading.js";
@@ -212,15 +211,15 @@ function editedProps(edit, props, defaults) {
       return editedPadding(props, edit.values);
   }
 }
-function editCellProps(tcPr, edit, defaults = NO_BORDER_DEFAULTS, margins = NO_CELL_MARGINS) {
+function editCellProps(tcPr, edit, defaults = NO_CELL_DEFAULTS) {
   const props = tcPr === null ? EMPTY_TC_PR : parseProps(tcPr);
   if (!props) return null;
-  const edited = editedProps(edit, props, defaults);
+  const edited = editedProps(edit, props, defaults.borders);
   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) };
+  return { tcPr: next, format: readCellProps(next, defaults) };
 }
 function drawsOwnCellBorder(tcPr) {
   const props = tcPr === null ? null : parseProps(tcPr);

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

@@ -2,11 +2,11 @@
  * Reads table formatting for display. Table borders and margins are folded into cell values so CSS
  * collapsed-border resolution matches OOXML inheritance without changing exported XML.
  */
-import type { CellFormat, CellMargins, InsideBorders, RowFormat, TableFormat, TableWidth } from "../../model/format";
+import { type BandSizes, type CellFormat, type CellMargins, type CellStyleFormat, type CellVerticalAlign, type InsideBorders, type RowFormat, type RunFormat, type TableFormat, type TableStyleConditions, type TableStyleOverrideType, type 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";
+import type { ParagraphPlacement } from "../formatting/resolve";
+import type { ParagraphFormatLayer } from "../formatting/tabStops";
+export type { BandSizes, CellMargins, CellStyleFormat, InsideBorders, TableStyleConditions, TableStyleOverrideType, } from "../../model/format";
 /**
  * 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.
@@ -50,7 +50,7 @@ export interface CellBorderDefaults {
     right: BorderLine | null;
 }
 export declare const NO_BORDER_DEFAULTS: CellBorderDefaults;
-/** Which sides of a cell lie on the edge of the table's grid */
+/** Which sides of a cell lie on the edge of a part of the table */
 export interface GridEdges {
     top: boolean;
     bottom: boolean;
@@ -69,19 +69,48 @@ export interface GridSize {
     cols: number;
 }
 /**
- * Which sides of the block a cell covers lie on the edge of the grid, merges included.
- * Everything that works out a cell's lines asks this first, whether the cell is being imported,
- * created fresh, or looked up again in a table on screen.
+ * Everything one cell falls back on for what it did not write down itself, worked out from where
+ * it sits in the grid by `cellDefaultsFor`. Everything that reads or edits a cell takes one of
+ * these, so the lines a cell draws and the lines an edit measures against are always the same.
  */
-export declare function gridEdgesOf(rect: GridRect, grid: GridSize): GridEdges;
+export interface CellDefaults {
+    borders: CellBorderDefaults;
+    margins: CellMargins;
+    background: string | null;
+    verticalAlign: CellVerticalAlign | null;
+    /** What the paragraphs inside the cell resolve their formatting against */
+    placement: ParagraphPlacement;
+}
+export declare const NO_CELL_DEFAULTS: CellDefaults;
+export declare const NO_BAND_SIZES: BandSizes;
+/** How many rows and columns one band of a table style is made of, read from the style's `w:tblPr` */
+export declare function readBandSizes(tblPr: Element | null): BandSizes;
+export declare function layerBandSizes(style: BandSizes, over: BandSizes): BandSizes;
+export declare const NO_CELL_STYLE_FORMAT: CellStyleFormat;
+export declare const NO_TABLE_STYLE_CONDITIONS: TableStyleConditions;
+/**
+ * The formatting one conditional format of a table style lays down (`w:tblStylePr`).
+ * Its `w:tblPr` speaks for the region as a whole and its `w:tcPr` for the cells in it, so the
+ * cell values are read with the table values underneath them.
+ */
+export interface ConditionalTableFormat {
+    paragraph: ParagraphFormatLayer;
+    run: RunFormat;
+    table: TableFormat;
+    cell: CellStyleFormat;
+}
 /**
- * The lines the four sides of one cell fall back on.
+ * What a conditional format lays down for the cells of its region.
  *
- * A side on the edge of the grid falls on the table's outer border, and one facing another cell on
- * the table's inside line. An outer side the document wrote as `none` is passed through as it is:
- * the table switched that line off, and nothing is to bring it back.
+ * The `w:tcPr` of a conditional format writes the lines of the region rather than of every cell in
+ * it: `insideH` and `insideV` are the lines between the cells it covers, which is how the header
+ * row of a style with `insideV` set to `nil` is drawn as one unbroken band.
  */
-export declare function cellBorderDefaults(edges: GridEdges, outer: TableFormat | null, inside: InsideBorders): CellBorderDefaults;
+export declare function readCellStyleFormat(tcPr: Element | null, tblPr: Element | null): CellStyleFormat;
+/** Lays one conditional format over the one a style further up the `basedOn` chain wrote for the same part */
+export declare function layerCellStyleFormat(base: CellStyleFormat, over: CellStyleFormat): CellStyleFormat;
+/** The conditions a table style lays down for its cells alone, which is what a table carries for its cells to draw */
+export declare function cellConditionsOf(conditions: Readonly<Partial<Record<TableStyleOverrideType, ConditionalTableFormat>>>): TableStyleConditions;
 /** The name of the table style `w:tblStyle` points at. null if it points at none */
 export declare function tblStyleIdOf(tblPr: Element | null): string | null;
 export declare function readTableFormat(tblPr: Element | null): TableFormat | null;
@@ -89,11 +118,12 @@ export declare function readRowFormat(trPr: Element | null): RowFormat | null;
 /**
  * Cell formatting.
  * A side for which the cell has not written down its own border uses the line that side falls on,
- * which is the table's outer border or its inside line depending on where the cell sits.
- * The padding works the same way: what the cell wrote down wins, and the table's cell margins lie
- * underneath it. null if there is nothing at all to draw.
+ * which is the table's outer border, its inside line, or the line a conditional format of its
+ * style draws there, depending on where the cell sits.
+ * The fill, the vertical alignment and the padding work the same way: what the cell wrote down
+ * wins, and what it falls back on lies underneath. null if there is nothing at all to draw.
  */
-export declare function readCellFormat(tcPr: Element | null, defaults: CellBorderDefaults, margins?: CellMargins): CellFormat | null;
+export declare function readCellFormat(tcPr: Element | null, defaults?: CellDefaults): CellFormat | null;
 /** The inside lines the table lays down, read from the table's own formatting XML */
 export declare function insideBordersOf(tblPr: string | null): InsideBorders;
 /** The cell margins the table lays down, read from the table's own formatting XML */
@@ -102,5 +132,5 @@ export declare function cellMarginsOf(tblPr: string | null): CellMargins;
  * Reads a cell formatting fragment we operated on back into display values, along the same path
  * the import takes. The same fragment always yields the same display values.
  */
-export declare function readCellProps(tcPr: string | null, defaults: CellBorderDefaults, margins?: CellMargins): CellFormat | null;
+export declare function readCellProps(tcPr: string | null, defaults?: CellDefaults): CellFormat | null;
 /** The formatting a cell holds. The original XML and the display values read out of it form a pair */

package/dist/docx/tableFormatting/reading.js

@@ -1,6 +1,10 @@
 // src/docx/tableFormatting/reading.ts
+import {
+  TABLE_STYLE_CONDITIONS
+} from "../../model/format.js";
 import { parsePropsXml } from "../../ooxml/props.js";
 import {
+  ST_DecimalNumber,
   ST_MeasurementOrPercent,
   ST_SignedTwipsMeasure,
   ST_TwipsMeasure
@@ -8,7 +12,6 @@ import {
 import {
   ALIGN_BY_JC,
   borderLineCss,
-  borderLineOfCss,
   borderSide,
   childValue,
   isOn,
@@ -109,30 +112,89 @@ var NO_BORDER_DEFAULTS = {
   left: null,
   right: null
 };
-function gridEdgesOf(rect, grid) {
+var NO_CELL_DEFAULTS = {
+  borders: NO_BORDER_DEFAULTS,
+  margins: NO_CELL_MARGINS,
+  background: null,
+  verticalAlign: null,
+  placement: { tableStyleId: null, conditions: [] }
+};
+var NO_BAND_SIZES = { row: null, col: null };
+function bandSize(tblPr, name) {
+  const count = ST_DecimalNumber.parse(childValue(tblPr, name));
+  return count !== null && count > 0 ? count : null;
+}
+function readBandSizes(tblPr) {
+  if (!tblPr) return NO_BAND_SIZES;
+  return {
+    row: bandSize(tblPr, "tblStyleRowBandSize"),
+    col: bandSize(tblPr, "tblStyleColBandSize")
+  };
+}
+function layerBandSizes(style, over) {
+  return { row: over.row ?? style.row, col: over.col ?? style.col };
+}
+var NO_CELL_STYLE_BORDERS = {
+  top: null,
+  bottom: null,
+  left: null,
+  right: null
+};
+var NO_CELL_STYLE_FORMAT = {
+  background: null,
+  borders: NO_CELL_STYLE_BORDERS,
+  inside: NO_INSIDE_BORDERS,
+  margins: NO_CELL_MARGINS,
+  verticalAlign: null
+};
+var NO_TABLE_STYLE_CONDITIONS = {};
+function conditionBorders(tcBorders, table) {
   return {
-    top: rect.top === 0,
-    bottom: rect.bottom === grid.rows,
-    left: rect.left === 0,
-    right: rect.right === grid.cols
+    top: borderSide(tcBorders, "top") ?? table.borderTop ?? null,
+    bottom: borderSide(tcBorders, "bottom") ?? table.borderBottom ?? null,
+    left: borderSide(tcBorders, "left") ?? borderSide(tcBorders, "start") ?? table.borderLeft ?? null,
+    right: borderSide(tcBorders, "right") ?? borderSide(tcBorders, "end") ?? table.borderRight ?? null
   };
 }
-function cellBorderDefaults(edges, outer, inside) {
+function readCellStyleFormat(tcPr, tblPr) {
+  const table = readTableFormat(tblPr) ?? {};
+  const tcBorders = tcPr ? childByLocalName(tcPr, "tcBorders") : null;
   return {
-    top: borderLineOfCss(
-      edges.top ? outer?.borderTop ?? null : inside.horizontal
-    ),
-    bottom: borderLineOfCss(
-      edges.bottom ? outer?.borderBottom ?? null : inside.horizontal
-    ),
-    left: borderLineOfCss(
-      edges.left ? outer?.borderLeft ?? null : inside.vertical
-    ),
-    right: borderLineOfCss(
-      edges.right ? outer?.borderRight ?? null : inside.vertical
-    )
+    background: (tcPr ? shadingOf(tcPr) : null) ?? table.background ?? null,
+    borders: conditionBorders(tcBorders, table),
+    inside: layerInsideBorders(readInsideBorders(tblPr), {
+      horizontal: borderSide(tcBorders, "insideH"),
+      vertical: borderSide(tcBorders, "insideV")
+    }),
+    margins: readCellMarginsOf(tcPr, "tcMar"),
+    verticalAlign: tcPr ? cellVerticalAlignOf(tcPr) : null
   };
 }
+function layerCellStyleBorders(base, over) {
+  return {
+    top: over.top ?? base.top,
+    bottom: over.bottom ?? base.bottom,
+    left: over.left ?? base.left,
+    right: over.right ?? base.right
+  };
+}
+function layerCellStyleFormat(base, over) {
+  return {
+    background: over.background ?? base.background,
+    borders: layerCellStyleBorders(base.borders, over.borders),
+    inside: layerInsideBorders(base.inside, over.inside),
+    margins: layerCellMargins(base.margins, over.margins),
+    verticalAlign: over.verticalAlign ?? base.verticalAlign
+  };
+}
+function cellConditionsOf(conditions) {
+  const cells = {};
+  for (const type of TABLE_STYLE_CONDITIONS) {
+    const format = conditions[type];
+    if (format) cells[type] = format.cell;
+  }
+  return cells;
+}
 function tblStyleIdOf(tblPr) {
   return tblPr ? childValue(tblPr, "tblStyle") : null;
 }
@@ -178,6 +240,9 @@ var CELL_VERTICAL_ALIGN_BY_VAL = {
   center: "center",
   bottom: "bottom"
 };
+function cellVerticalAlignOf(tcPr) {
+  return CELL_VERTICAL_ALIGN_BY_VAL[childValue(tcPr, "vAlign") ?? ""] ?? null;
+}
 function readCellPadding(tcPr, margins) {
   const padding = layerCellMargins(margins, readCellMarginsOf(tcPr, "tcMar"));
   const format = {};
@@ -187,24 +252,26 @@ function readCellPadding(tcPr, margins) {
   if (padding.leftPt !== null) format.paddingLeftPt = padding.leftPt;
   return format;
 }
-function readCellFormat(tcPr, defaults, margins = NO_CELL_MARGINS) {
+function readCellFormat(tcPr, defaults = NO_CELL_DEFAULTS) {
   const borders = tcPr ? childByLocalName(tcPr, "tcBorders") : null;
+  const lines = defaults.borders;
   const format = {};
-  const top = borderSide(borders, "top") ?? borderLineCss(defaults.top);
+  const top = borderSide(borders, "top") ?? borderLineCss(lines.top);
   if (top) format.borderTop = top;
-  const bottom = borderSide(borders, "bottom") ?? borderLineCss(defaults.bottom);
+  const bottom = borderSide(borders, "bottom") ?? borderLineCss(lines.bottom);
   if (bottom) format.borderBottom = bottom;
-  const left = borderSide(borders, "left") ?? borderSide(borders, "start") ?? borderLineCss(defaults.left);
+  const left = borderSide(borders, "left") ?? borderSide(borders, "start") ?? borderLineCss(lines.left);
   if (left) format.borderLeft = left;
-  const right = borderSide(borders, "right") ?? borderSide(borders, "end") ?? borderLineCss(defaults.right);
+  const right = borderSide(borders, "right") ?? borderSide(borders, "end") ?? borderLineCss(lines.right);
   if (right) format.borderRight = right;
-  if (tcPr) {
-    const background = shadingOf(tcPr);
-    if (background) format.background = background;
-    const verticalAlign = CELL_VERTICAL_ALIGN_BY_VAL[childValue(tcPr, "vAlign") ?? ""];
-    if (verticalAlign) format.verticalAlign = verticalAlign;
-  }
-  const padded = { ...format, ...readCellPadding(tcPr, margins) };
+  const background = (tcPr ? shadingOf(tcPr) : null) ?? defaults.background;
+  if (background) format.background = background;
+  const verticalAlign = (tcPr ? cellVerticalAlignOf(tcPr) : null) ?? defaults.verticalAlign;
+  if (verticalAlign) format.verticalAlign = verticalAlign;
+  const padded = {
+    ...format,
+    ...readCellPadding(tcPr, defaults.margins)
+  };
   return Object.keys(padded).length > 0 ? padded : null;
 }
 function insideBordersOf(tblPr) {
@@ -215,23 +282,30 @@ function cellMarginsOf(tblPr) {
   const el = tblPr === null ? null : parsePropsXml(tblPr);
   return readCellMarginsOf(el, "tblCellMar");
 }
-function readCellProps(tcPr, defaults, margins = NO_CELL_MARGINS) {
+function readCellProps(tcPr, defaults = NO_CELL_DEFAULTS) {
   const el = tcPr === null ? null : parsePropsXml(tcPr);
-  return readCellFormat(el, defaults, margins);
+  return readCellFormat(el, defaults);
 }
 export {
+  NO_BAND_SIZES,
   NO_BORDER_DEFAULTS,
+  NO_CELL_DEFAULTS,
   NO_CELL_MARGINS,
+  NO_CELL_STYLE_FORMAT,
   NO_INSIDE_BORDERS,
-  cellBorderDefaults,
+  NO_TABLE_STYLE_CONDITIONS,
+  cellConditionsOf,
   cellMarginsOf,
-  gridEdgesOf,
   insideBordersOf,
+  layerBandSizes,
   layerCellMargins,
+  layerCellStyleFormat,
   layerInsideBorders,
+  readBandSizes,
   readCellFormat,
   readCellMarginsOf,
   readCellProps,
+  readCellStyleFormat,
   readGridCols,
   readInsideBorders,
   readRowFormat,

package/dist/docx/tableFormatting.d.ts

@@ -1,2 +1,3 @@
+export * from "./tableFormatting/conditions";
 export * from "./tableFormatting/editing";
 export * from "./tableFormatting/reading";

package/dist/docx/tableFormatting.js

@@ -1,3 +1,4 @@
 // src/docx/tableFormatting.ts
+export * from "./tableFormatting/conditions.js";
 export * from "./tableFormatting/editing.js";
 export * from "./tableFormatting/reading.js";

package/dist/docx/tableTemplate.js

@@ -5,9 +5,8 @@ import { orderedElement, parsePropsXml } from "../ooxml/props.js";
 import { docxSchema } from "../schema/index.js";
 import { A4_PORTRAIT, bodyWidth } from "./pageGeometry.js";
 import {
-  cellBorderDefaults,
-  gridEdgesOf,
-  NO_CELL_MARGINS,
+  cellDefaultsFor,
+  NO_CELL_SOURCES,
   readCellFormat,
   readInsideBorders,
   readTableFormat,
@@ -81,7 +80,7 @@ function cellTemplate(width, defaults) {
     tcPr,
     tcW: readTableWidth(el, "tcW"),
     // A new table writes no `tblCellMar`, so its cells take their padding from the stylesheet
-    format: readCellFormat(el, defaults, NO_CELL_MARGINS)
+    format: readCellFormat(el, defaults)
   };
 }
 function cellNode(props) {
@@ -109,17 +108,18 @@ function createTableNode(rows, cols, geometry = A4_PORTRAIT) {
   const gridCols = evenGridCols(cols, total);
   const tblPr = tablePropsXml(total);
   const tblPrEl = parsePropsXml(tblPr);
-  const inside = readInsideBorders(tblPrEl);
   const outer = readTableFormat(tblPrEl);
+  const sources = {
+    ...NO_CELL_SOURCES,
+    outer,
+    inside: readInsideBorders(tblPrEl)
+  };
   const cellAt = (row, col) => cellTemplate(
     gridCols[col],
-    cellBorderDefaults(
-      gridEdgesOf(
-        { top: row, bottom: row + 1, left: col, right: col + 1 },
-        { rows, cols }
-      ),
-      outer,
-      inside
+    cellDefaultsFor(
+      { top: row, bottom: row + 1, left: col, right: col + 1 },
+      { rows, cols },
+      sources
     )
   );
   return docxSchema.nodes.table.create(

package/dist/editor/clipboard/htmlReader.d.ts

@@ -0,0 +1,30 @@
+import { Slice } from "prosemirror-model";
+import type { Transaction } from "prosemirror-state";
+import { type NewLists } from "../../numbering/listRegistry";
+import type { ListKinds } from "./internalChannel";
+import type { HtmlReadContext } from "./readContext";
+/**
+ * The paragraph style a copy carries, which is the one thing a paste needs that the drawing does
+ * not already say. It is the style's id alone, where the editor draws the whole `w:pPr`.
+ */
+export declare const COPIED_STYLE_ATTRIBUTE = "data-style";
+/** What a paste puts in: the content, and the definitions of the lists it started */
+export interface PastedContent {
+    slice: Slice;
+    newLists: NewLists;
+    /**
+     * What the numbers this slice's paragraphs name meant where it was copied
+     * (`./internalChannel`). Absent for a reading that gave the lists it read numbers of its own,
+     * which knows what kind each is from the markup it read them out of.
+     */
+    listKinds?: ListKinds;
+}
+/** The content one piece of already parsed markup reads as, or null when it reads as nothing */
+export declare function readHtml(root: ParentNode, context: HtmlReadContext): PastedContent | null;
+/** The same reading, for a caller holding the markup as a string rather than as elements */
+export declare function readHtmlSlice(context: HtmlReadContext, source: string): PastedContent | null;
+/**
+ * The transaction a paste is put in with: the content, and the definitions of the lists it started
+ * recorded on the document node so that the export writes them out and undo takes them back.
+ */
+export declare function withPastedContent(tr: Transaction, content: PastedContent): Transaction;