@portone/docx-editor 0.3.0 → 0.4.0

package/dist/docx/newLists.d.ts

@@ -5,7 +5,16 @@
  * writer rather than being read off it.
  */
 import type { Node as PMNode } from "prosemirror-model";
+import { type NewList } from "../numbering/parseNumbering";
 import type { SessionStore } from "./session";
+/**
+ * How the main part relates the numbering part, and what the package declares that part to hold.
+ *
+ * The reader finds the part by this relationship and the writer relates a new one under it, so
+ * neither can name it differently from the other.
+ */
+export declare const NUMBERING_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering";
+export declare const NUMBERING_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml";
 /**
  * The numbering ids that appeared during editing and have no definition.
  *
@@ -13,8 +22,29 @@ import type { SessionStore } from "./session";
  * because exporting such a document without editing it must not disturb numbering.xml.
  */
 export declare function newNumIds(doc: PMNode, session: SessionStore): number[];
+/** The lists started during editing, split by whether a definition was registered for each */
+export interface StartedLists {
+    /** The definition each list was started with, which is what goes into numbering.xml */
+    readonly defined: ReadonlyMap<number, NewList>;
+    /** The numbers a list was started under that no definition stands behind */
+    readonly unregistered: readonly number[];
+}
+/**
+ * The lists started during editing, each against the definition it was started with.
+ *
+ * The definition is the one the document node carries (`numbering/listRegistry`), which the list
+ * commands and the clipboard record as they start a list. A number carrying none is reported here
+ * rather than written bare, which the export invariants turn into a refusal.
+ */
+export declare function startedLists(doc: PMNode, session: SessionStore): StartedLists;
 /** The numbering part as it was opened, which a new definition is spliced into. null when the document has none */
 export declare function numberingPartOf(session: SessionStore): {
     path: string;
     bytes: Uint8Array;
 } | null;
+/**
+ * Whether the definition of a new list has somewhere to go: the numbering part the document was
+ * opened with, or one written from scratch, which only a package that can declare what the new
+ * part holds may take.
+ */
+export declare function canDefineNewList(session: SessionStore): boolean;

package/dist/docx/newLists.js

@@ -1,6 +1,11 @@
 // src/docx/newLists.ts
 import { toParagraphFormat } from "../model/format.js";
+import { NEW_LISTS_ATTR, newListsOf } from "../numbering/listRegistry.js";
 import { parseNumbering } from "../numbering/parseNumbering.js";
+import { R_NS } from "../ooxml/xml.js";
+import { CONTENT_TYPES_PATH } from "./packageParts.js";
+var NUMBERING_REL_TYPE = `${R_NS}/numbering`;
+var NUMBERING_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml";
 function collectNumIds(node, into) {
   const visit = (candidate) => {
     if (candidate.type.name !== "paragraph") return true;
@@ -25,12 +30,30 @@ function newNumIds(doc, session) {
   const atOpen = numIdsAtOpen(session);
   return Array.from(numIdsIn(doc)).filter((numId) => !defined.has(numId) && !atOpen.has(numId)).sort((a, b) => a - b);
 }
+function startedLists(doc, session) {
+  const registered = newListsOf(doc.attrs[NEW_LISTS_ATTR]);
+  const defined = /* @__PURE__ */ new Map();
+  const unregistered = [];
+  for (const numId of newNumIds(doc, session)) {
+    const list = registered.get(numId);
+    if (list === void 0) unregistered.push(numId);
+    else defined.set(numId, list);
+  }
+  return { defined, unregistered };
+}
 function numberingPartOf(session) {
   const path = session.numberingPartPath;
   const bytes = path === null ? void 0 : session.parts.get(path);
   return path === null || bytes === void 0 ? null : { path, bytes };
 }
+function canDefineNewList(session) {
+  return numberingPartOf(session) !== null || session.parts.has(CONTENT_TYPES_PATH);
+}
 export {
+  NUMBERING_CONTENT_TYPE,
+  NUMBERING_REL_TYPE,
+  canDefineNewList,
   newNumIds,
-  numberingPartOf
+  numberingPartOf,
+  startedLists
 };

package/dist/docx/numberingPlanner.d.ts

@@ -1,8 +1,11 @@
 /**
- * The numbering part with the definition of every list started during editing spliced in.
+ * The numbering part with the definition every list started during editing was started with
+ * spliced in, and the part itself when the document arrived without one.
  *
- * The original text is left as is and only the new definitions go in. Nothing is written when no
- * list was started.
+ * The original text is left as is and only the new definitions go in. A document that has no
+ * numbering part gets one written from scratch, with the relationship that finds it and the
+ * declaration of what it holds asked of the context, so the first list a document takes costs it
+ * nothing outside this planner. Nothing is written when no list was started.
  */
 import type { PartPlanner } from "./partPlan";
 export declare const numberingPlanner: PartPlanner;

package/dist/docx/numberingPlanner.js

@@ -1,17 +1,48 @@
 // src/docx/numberingPlanner.ts
 import { addListDefinitions } from "../numbering/writeNumbering.js";
+import { elementXml, xmlnsAttr } from "../ooxml/element.js";
+import { NAMESPACES, wName } from "../ooxml/names.js";
+import { ensureRootDeclarations } from "../ooxml/partSplice.js";
 import { decodeUtf8, encodeUtf8 } from "../ooxml/xml.js";
-import { newNumIds, numberingPartOf } from "./newLists.js";
+import {
+  NUMBERING_CONTENT_TYPE,
+  NUMBERING_REL_TYPE,
+  numberingPartOf,
+  startedLists
+} from "./newLists.js";
+import { availablePartPath } from "./packageParts.js";
+import { directoryOf } from "./relationships.js";
+function emptyNumberingPart() {
+  return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' + elementXml(wName("numbering"), [xmlnsAttr("w")]);
+}
 var numberingPlanner = {
   name: "numbering",
-  plan(doc, session) {
-    const added = newNumIds(doc, session);
+  plan(doc, session, context) {
+    const { defined } = startedLists(doc, session);
+    if (defined.size === 0) return null;
     const original = numberingPartOf(session);
-    if (added.length === 0 || original === null) return null;
+    if (original === null) {
+      const path = session.numberingPartPath ?? availablePartPath(session.parts, session.mainPartPath, "numbering");
+      if (session.numberingPartPath === null) {
+        context.relationships.add({
+          type: NUMBERING_REL_TYPE,
+          target: path.slice(directoryOf(session.mainPartPath).length)
+        });
+      }
+      context.contentTypes.addOverride(path, NUMBERING_CONTENT_TYPE);
+      return /* @__PURE__ */ new Map([
+        [
+          path,
+          encodeUtf8(addListDefinitions(emptyNumberingPart(), defined), false)
+        ]
+      ]);
+    }
     const { text, hadBom } = decodeUtf8(original.bytes);
-    return /* @__PURE__ */ new Map([
-      [original.path, encodeUtf8(addListDefinitions(text, added), hadBom)]
-    ]);
+    const rewritten = ensureRootDeclarations(
+      addListDefinitions(text, defined),
+      { namespaces: { w: NAMESPACES.w } }
+    );
+    return /* @__PURE__ */ new Map([[original.path, encodeUtf8(rewritten, hadBom)]]);
   }
 };
 export {

package/dist/docx/session.d.ts

@@ -11,7 +11,7 @@ import type { Node as PMNode } from "prosemirror-model";
 import type { DocumentDefaults } from "../model/format";
 import { type Numbering, type NumberingOptions } from "../numbering/parseNumbering";
 import type { ImportedComments } from "./comments";
-import type { FormattingContext, ParagraphStyleOption } from "./formatting";
+import { type FormattingContext, type ParagraphStyleOption } from "./formatting";
 import type { HeadersFooters } from "./headersFooters";
 import type { PageGeometry } from "./pageGeometry";
 export interface ImportedBlock {

package/dist/docx/session.js

@@ -2,6 +2,9 @@
 import {
   parseNumbering
 } from "../numbering/parseNumbering.js";
+import {
+  numberingOptionsFor
+} from "./formatting.js";
 var sessionsOpened = 0;
 function newSessionId() {
   sessionsOpened += 1;
@@ -65,7 +68,14 @@ function documentPartPath(session) {
   return sessionOf(session).mainPartPath;
 }
 function documentNumbering(session, options) {
-  return parseNumbering(sessionOf(session).numberingXml, options);
+  const store = sessionOf(session);
+  return parseNumbering(store.numberingXml, {
+    ...numberingOptionsFor(
+      store.formatting.styles,
+      store.formatting.themeFonts
+    ),
+    ...options
+  });
 }
 var BODY_STORY_KEY = "body";
 function blockKey(session, storyKey, index) {

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

@@ -0,0 +1,76 @@
+/**
+ * Which parts of a table one cell belongs to, and what its table style dresses those parts with.
+ *
+ * A table style says one thing for the header row, another for the first column, another for the
+ * banded rows (`w:tblStylePr`), and `w:tblLook` says which of those a table takes at all. Every
+ * caller that asks what a cell falls back on - the import, a table created fresh, the lines derived
+ * again after the grid moved, and a cell formatting edit - asks here, so a cell is dressed the same
+ * whichever of them asked.
+ *
+ * A conditional format writes the lines of the part it dresses rather than of every cell in it:
+ * its four sides are drawn where a cell lies on the edge of that part and its inside lines between
+ * the cells within it, which is the same rule the table's own lines are drawn by.
+ */
+import type { BandSizes, CellMargins, InsideBorders, TableFormat, TableStyleConditions, TableStyleOverrideType } from "../../model/format";
+import { type CellDefaults, type GridRect, type GridSize } from "./reading";
+/** Which parts of its table style a table takes (`w:tblLook`, §17.4.55) */
+export interface TableLook {
+    firstRow: boolean;
+    lastRow: boolean;
+    firstColumn: boolean;
+    lastColumn: boolean;
+    noHBand: boolean;
+    noVBand: boolean;
+}
+/**
+ * What a table writing no `w:tblLook` at all takes: the banded rows and columns, and neither the
+ * header row, the last row, nor the edge columns (§17.4.55). Switching the banding off is
+ * something a table has to say, which is why both band settings are worded as `no`.
+ */
+export declare const NO_LOOK: TableLook;
+/**
+ * Which parts of its table style this table takes.
+ *
+ * The six attributes are what a document writes today; where one of them is missing the legacy
+ * bitmask answers for it, so a document written either way reads the same.
+ */
+export declare function readTableLook(tblPr: Element | null): TableLook;
+/** One conditional format a cell takes, and the part of the grid it dresses */
+export interface CellCondition {
+    type: TableStyleOverrideType;
+    /** Its four lines are drawn on the edge of this block, and its inside lines within it */
+    region: GridRect;
+}
+/** Where a cell sits, and which parts of the table it therefore belongs to */
+export interface CellPlacement {
+    rect: GridRect;
+    grid: GridSize;
+    /** Lowest first, in the order §17.7.6 lays them over one another */
+    conditions: readonly CellCondition[];
+}
+/**
+ * The parts of the table this cell belongs to, lowest first.
+ *
+ * A cell sits in a row band by the row it starts in and in a column band by the column it starts
+ * in, and it is a corner only where the table takes both the row and the column that meet there.
+ */
+export declare function cellPlacement(rect: GridRect, grid: GridSize, look: TableLook, bands: BandSizes): CellPlacement;
+/** What a table lays down for its cells to draw. What its style laid down is not in the `tblPr`, so it comes along separately */
+export interface TableCellSources {
+    outer: TableFormat | null;
+    inside: InsideBorders;
+    margins: CellMargins;
+    /** The parts of its style the table takes */
+    look: TableLook;
+    bands: BandSizes;
+    /** What the style dresses each of those parts with */
+    conditions: TableStyleConditions;
+    /** The style the paragraphs inside the cells resolve against. null for a table wearing none */
+    styleId: string | null;
+}
+export declare const NO_CELL_SOURCES: TableCellSources;
+/**
+ * What the cell covering this block of the grid falls back on: the table's own lines and margins,
+ * with every conditional format its style dresses a part it belongs to with laid over them.
+ */
+export declare function cellDefaultsFor(rect: GridRect, grid: GridSize, sources: TableCellSources): CellDefaults;

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 */