doc-codec 1.1.2 → 2.0.0

package/dist/table/tap.cjs

@@ -11,6 +11,8 @@ const SPRM_T_MERGE = 22052;
 const SPRM_T_VERT_MERGE = 54827;
 /** sprmTSetBrc (0xD62F): a TableBrcOperand ([MS-DOC] 2.9.305) restating one cell range's borders on the named sides, with an exact COLORREF rather than TC80's own Ico index. */
 const SPRM_T_SET_BRC = 54831;
+/** sprmTSetBrc80 (0xD620): the Word 97-era spelling of sprmTSetBrc, a TableBrc80Operand ([MS-DOC] 2.9.304) restating one cell range's borders with a palette-indexed Brc80MayBeNil rather than sprmTSetBrc's own exact-colour Brc -- the identical cb/ItcFirstLim/bordersToApply header, differing only in which four-byte border field follows it. A real Word-97-era producer's own NilBrc80 clear (the same all-bits-set sentinel TC80's own Brc80 fields use) reaches applyBrcToCell exactly like sprmTSetBrc's own NilBrc, recording the cleared side on clearedSides so the row-level cascade never re-fills it ([ExaDev/documents.js#945](https://github.com/ExaDev/documents.js/issues/945)). */
+const SPRM_T_SET_BRC80 = 54816;
 /** sprmTDefTableShd80 (0xD609): a DefTableShd80Operand ([MS-DOC] 2.9.52), the Word 97-era array of one Shd80 per cell starting at the row's first. */
 const SPRM_T_DEF_TABLE_SHD80 = 54793;
 /** sprmTDefTableShd3rd (0xD60C): a DefTableShdOperand ([MS-DOC] 2.9.53) shading cells 45-63 -- index 44 onward. */
@@ -27,6 +29,12 @@ const SPRM_T_SET_SHD_ODD = 54830;
 const SPRM_T_DEF_TABLE_SHD_RAW = 54896;
 const SPRM_T_DEF_TABLE_SHD_RAW_2ND = 54897;
 const SPRM_T_DEF_TABLE_SHD_RAW_3RD = 54898;
+/** sprmTTableBorders80 (0xD605): the Word 97-era spelling of the row/table border cascade, a TableBordersOperand80 ([MS-DOC] 2.9.303) over Brc80MayBeNil fields. */
+const SPRM_T_TABLE_BORDERS_80 = 54789;
+/** sprmTTableBorders (0xD613): a TableBordersOperand ([MS-DOC] 2.9.302) over real Brc fields with an exact COLORREF, the modern spelling of the same cascade. */
+const SPRM_T_TABLE_BORDERS = 54803;
+/** sprmTSetShdTable (0xD660): a SHDOperand ([MS-DOC] 2.9.249) whose own text states it as shading for "the entire table" -- but its own spec text carries none of sprmTTableBorders's "unless modified" exception, so this reader applies it as an ordinary per-row sprm to every cell of whichever row's grpprl states it (folded in grpprl order like every other shading sprm above), rather than resolving it across the whole table the way its name implies: a producer writing it on only one row's grpprl shades, per this implementation, only that row. */
+const SPRM_T_SET_SHD_TABLE = 54880;
 /** The first cell index each of the three DefTableShdOperand sprms shades, [MS-DOC] 2.6.3: "Cells 1 - 22 are shaded by sprmTDefTableShd, and cells 23 - 44 are shaded by sprmTDefTableShd2nd" and 45-63 by the third -- one-based there, so zero-based here. */
 const SHD_ARRAY_FIRST_CELL = {
 	[SPRM_T_DEF_TABLE_SHD]: 0,
@@ -87,10 +95,11 @@ function readTdefTableOperand(operand) {
 function withCells(definition, next) {
 	return {
 		columnBoundariesTwips: definition.columnBoundariesTwips,
-		cells: definition.cells.map(next)
+		cells: definition.cells.map(next),
+		rowBorders: definition.rowBorders
 	};
 }
-/** Overlays the sides one TableBrcOperand names onto a cell's existing borders, leaving every side it does not name as TC80's own Brc80 stated it. A named side whose Brc is a NilBrc removes that side's border, which is how a producer states "this cell has no top border" over a row-level one it would otherwise inherit. */
+/** Overlays the sides one TableBrcOperand(80) names onto a cell's existing borders, leaving every side it does not name as TC80's own Brc80 stated it. Shared verbatim by both SPRM_T_SET_BRC and SPRM_T_SET_BRC80's own switch cases, since the two operands differ only in which border field their caller has already decoded (readBrc's exact Brc vs readBrc80's palette-indexed Brc80) -- by the time `border` reaches here, both are the identical ContentBorder|undefined shape. A named side whose Brc/Brc80 is a NilBrc/NilBrc80 explicitly clears that side -- how a producer states "this cell has no top border" over a row-level one it would otherwise inherit -- and is recorded in `clearedSides` so table/read.ts's own row-level cascade can tell that apart from a side this cell has simply never mentioned. TC80's own Brc80 fields cannot state this distinction on their own (they are mandatory for every cell, so "no border" and "never stated" are the identical bytes -- table/read.ts's own applyRowLevelBorderCascade note); only an explicit sprmTSetBrc/sprmTSetBrc80 naming the side carries an unambiguous "clear" signal. A later sprmTSetBrc/sprmTSetBrc80 restating a real border on a previously cleared side un-clears it, matching the ordinary last-Prl-wins fold every sprm in this module already follows. */
 function applyBrcToCell(cell, bordersToApply, border) {
 	const sides = {
 		top: cell.borders?.top,
@@ -98,11 +107,18 @@ function applyBrcToCell(cell, bordersToApply, border) {
 		bottom: cell.borders?.bottom,
 		right: cell.borders?.right
 	};
-	for (const side of require_table_decoration.CELL_BORDER_SIDES) if ((bordersToApply & require_table_decoration.BORDERS_TO_APPLY[side]) !== 0) sides[side] = border;
+	const clearedSides = new Set(cell.clearedSides);
+	for (const side of require_table_decoration.CELL_BORDER_SIDES) {
+		if ((bordersToApply & require_table_decoration.BORDERS_TO_APPLY[side]) === 0) continue;
+		sides[side] = border;
+		if (border === void 0) clearedSides.add(side);
+		else clearedSides.delete(side);
+	}
 	return {
 		horzMerge: cell.horzMerge,
 		vertMerge: cell.vertMerge,
 		borders: require_table_decoration.cellBordersFrom(sides),
+		clearedSides: clearedSides.size > 0 ? clearedSides : void 0,
 		background: cell.background
 	};
 }
@@ -111,17 +127,18 @@ function withBackground(cell, background) {
 		horzMerge: cell.horzMerge,
 		vertMerge: cell.vertMerge,
 		borders: cell.borders,
+		clearedSides: cell.clearedSides,
 		background
 	};
 }
 /** Applies a DefTableShdOperand's ([MS-DOC] 2.9.53) rgShd array from `firstCell` onward. The array carries "only ... elements necessary to define all shaded cells in the row", so cells past its end keep whatever an earlier sprm left them -- an entry that is present and states ShdAuto/ShdNil genuinely clears its own cell, which is how a real producer's full-length array turns a row's unshaded cells back off. */
-function applyShdArray(definition, operand, firstCell, entrySize, colorAt) {
+function applyShdArray(definition, operand, firstCell, entrySize, fillAt) {
 	const cb = require_bytes.readUint8(operand, 0);
 	const count = Math.floor(cb / entrySize);
 	return withCells(definition, (cell, index) => {
 		const entry = index - firstCell;
 		if (entry < 0 || entry >= count) return cell;
-		return withBackground(cell, colorAt(operand, 1 + entry * entrySize));
+		return withBackground(cell, fillAt(operand, 1 + entry * entrySize));
 	});
 }
 /** Applies a TableShadeOperand ([MS-DOC] 2.9.308): cb, an ItcFirstLim naming the range, then a single Shd applied to every cell the range covers -- not one Shd per cell. `step` is 1 for sprmTSetShd and 2 for sprmTSetShdOdd, whose own range covers every other cell from itcFirst. */
@@ -157,6 +174,7 @@ function applyTableSprms(prls, into) {
 						horzMerge: index === itcFirst ? 2 : 1,
 						vertMerge: cell.vertMerge,
 						borders: cell.borders,
+						clearedSides: cell.clearedSides,
 						background: cell.background
 					};
 				});
@@ -170,6 +188,7 @@ function applyTableSprms(prls, into) {
 					horzMerge: cell.horzMerge,
 					vertMerge: vertMergeFlags,
 					borders: cell.borders,
+					clearedSides: cell.clearedSides,
 					background: cell.background
 				} : cell);
 				break;
@@ -183,6 +202,15 @@ function applyTableSprms(prls, into) {
 				into.definition = withCells(into.definition, (cell, index) => index < itcFirst || index >= itcLim ? cell : applyBrcToCell(cell, bordersToApply, border));
 				break;
 			}
+			case SPRM_T_SET_BRC80: {
+				if (into.definition === void 0) break;
+				const itcFirst = require_bytes.readUint8(prl.operand, 1);
+				const itcLim = require_bytes.readUint8(prl.operand, 2);
+				const bordersToApply = require_bytes.readUint8(prl.operand, 3);
+				const border = require_table_decoration.readBrc80(prl.operand, 4);
+				into.definition = withCells(into.definition, (cell, index) => index < itcFirst || index >= itcLim ? cell : applyBrcToCell(cell, bordersToApply, border));
+				break;
+			}
 			case SPRM_T_DEF_TABLE_SHD:
 			case SPRM_T_DEF_TABLE_SHD_2ND:
 			case SPRM_T_DEF_TABLE_SHD_3RD:
@@ -206,6 +234,27 @@ function applyTableSprms(prls, into) {
 			case SPRM_T_SET_SHD_ODD:
 				if (into.definition === void 0) break;
 				into.definition = applyTableShade(into.definition, prl.operand, 2);
+				break;
+			case SPRM_T_TABLE_BORDERS_80:
+				if (into.definition === void 0) break;
+				into.definition = {
+					...into.definition,
+					rowBorders: require_table_decoration.readTableBordersOperand80(prl.operand)
+				};
+				break;
+			case SPRM_T_TABLE_BORDERS:
+				if (into.definition === void 0) break;
+				into.definition = {
+					...into.definition,
+					rowBorders: require_table_decoration.readTableBordersOperand(prl.operand)
+				};
+				break;
+			case SPRM_T_SET_SHD_TABLE: {
+				if (into.definition === void 0) break;
+				const background = require_table_decoration.readShd(prl.operand, 1);
+				into.definition = withCells(into.definition, (cell) => withBackground(cell, background));
+				break;
+			}
 		}
 	}
 	return into;

package/dist/table/tap.d.cts

@@ -1,5 +1,6 @@
 import { t as Prl } from "../sprm-Djg5RNiq.cjs";
-import { Color, ContentCellBorders } from "document-schema.js";
+import { CellBorderSide, TableBordersSet } from "./decoration.cjs";
+import { ContentCellBorders, ContentCellFill } from "document-schema.js";
 //#region src/table/tap.d.ts
 /** TCGRF.horzMerge, [MS-DOC] 2.9.317: 0 not merged, 1 a continuation cell (contributes its layout region, its own contents are not rendered), 2 or 3 the first cell of a horizontally merged set. */
 declare const HORZ_MERGE_CONTINUATION = 1;
@@ -11,14 +12,18 @@ interface TableCellProperties {
   readonly vertMerge: number;
   /** The cell's own four borders, absent when it states none on any side. */
   readonly borders?: ContentCellBorders;
-  /** The cell's own flat background colour, absent when it states no shading or states a pattern Color cannot express (see decoration.ts's readShd). */
-  readonly background?: Color;
+  /** Sides sprmTSetBrc or sprmTSetBrc80 has explicitly named with a NilBrc/NilBrc80 -- a real "this cell has no border here" statement, distinct from a side this cell's own TAP has simply never mentioned. `borders` alone cannot carry that distinction (an absent side means the same thing either way once cellBordersFrom has dropped it), so table/read.ts's own row-level border cascade (applyRowLevelBorderCascade) consults this set too: a side listed here is never filled from the row's cascade, no matter what `borders` says. See applyBrcToCell's own note for why only sprmTSetBrc/sprmTSetBrc80, never TC80's own Brc80 fields, can state this. */
+  readonly clearedSides?: ReadonlySet<CellBorderSide>;
+  /** The cell's own background fill, absent when it states no shading or states a pattern this reader cannot resolve at all (see decoration.ts's readShd). */
+  readonly background?: ContentCellFill;
 }
 interface TableRowDefinition {
   /** rgdxaCenter, in twips: one more entry than there are physical cells in the row -- column i's width is boundaries[i + 1] - boundaries[i]. */
   readonly columnBoundariesTwips: readonly number[];
   /** One entry per physical cell in the row, in document order -- every physical cell the row's own cell marks delimit, horizontally- and vertically-merged-away cells included, exactly as [MS-DOC]'s own model keeps them all present. */
   readonly cells: readonly TableCellProperties[];
+  /** This row's own sprmTTableBorders/sprmTTableBorders80 cascade, unresolved onto any cell -- see this module's own top-of-file note on why table/read.ts's applyRowLevelBorderCascade, not this function, is what actually applies it. */
+  readonly rowBorders?: TableBordersSet;
 }
 interface TableRowProperties {
   definition?: TableRowDefinition;

package/dist/table/tap.d.ts

@@ -1,5 +1,6 @@
 import { t as Prl } from "../sprm-Djg5RNiq.js";
-import { Color, ContentCellBorders } from "document-schema.js";
+import { CellBorderSide, TableBordersSet } from "./decoration.js";
+import { ContentCellBorders, ContentCellFill } from "document-schema.js";
 //#region src/table/tap.d.ts
 /** TCGRF.horzMerge, [MS-DOC] 2.9.317: 0 not merged, 1 a continuation cell (contributes its layout region, its own contents are not rendered), 2 or 3 the first cell of a horizontally merged set. */
 declare const HORZ_MERGE_CONTINUATION = 1;
@@ -11,14 +12,18 @@ interface TableCellProperties {
   readonly vertMerge: number;
   /** The cell's own four borders, absent when it states none on any side. */
   readonly borders?: ContentCellBorders;
-  /** The cell's own flat background colour, absent when it states no shading or states a pattern Color cannot express (see decoration.ts's readShd). */
-  readonly background?: Color;
+  /** Sides sprmTSetBrc or sprmTSetBrc80 has explicitly named with a NilBrc/NilBrc80 -- a real "this cell has no border here" statement, distinct from a side this cell's own TAP has simply never mentioned. `borders` alone cannot carry that distinction (an absent side means the same thing either way once cellBordersFrom has dropped it), so table/read.ts's own row-level border cascade (applyRowLevelBorderCascade) consults this set too: a side listed here is never filled from the row's cascade, no matter what `borders` says. See applyBrcToCell's own note for why only sprmTSetBrc/sprmTSetBrc80, never TC80's own Brc80 fields, can state this. */
+  readonly clearedSides?: ReadonlySet<CellBorderSide>;
+  /** The cell's own background fill, absent when it states no shading or states a pattern this reader cannot resolve at all (see decoration.ts's readShd). */
+  readonly background?: ContentCellFill;
 }
 interface TableRowDefinition {
   /** rgdxaCenter, in twips: one more entry than there are physical cells in the row -- column i's width is boundaries[i + 1] - boundaries[i]. */
   readonly columnBoundariesTwips: readonly number[];
   /** One entry per physical cell in the row, in document order -- every physical cell the row's own cell marks delimit, horizontally- and vertically-merged-away cells included, exactly as [MS-DOC]'s own model keeps them all present. */
   readonly cells: readonly TableCellProperties[];
+  /** This row's own sprmTTableBorders/sprmTTableBorders80 cascade, unresolved onto any cell -- see this module's own top-of-file note on why table/read.ts's applyRowLevelBorderCascade, not this function, is what actually applies it. */
+  readonly rowBorders?: TableBordersSet;
 }
 interface TableRowProperties {
   definition?: TableRowDefinition;

package/dist/table/tap.js

@@ -1,6 +1,6 @@
 import { readInt16LE, readUint16LE, readUint8 } from "../bytes.js";
 import { SGC } from "../prop/sprm.js";
-import { BORDERS_TO_APPLY, CELL_BORDER_SIDES, cellBordersFrom, readBrc, readBrc80, readShd, readShd80 } from "./decoration.js";
+import { BORDERS_TO_APPLY, CELL_BORDER_SIDES, cellBordersFrom, readBrc, readBrc80, readShd, readShd80, readTableBordersOperand, readTableBordersOperand80 } from "./decoration.js";
 //#region src/table/tap.ts
 const SPRM_T_DEF_TABLE = 54792;
 const SPRM_T_DYA_ROW_HEIGHT = 37895;
@@ -10,6 +10,8 @@ const SPRM_T_MERGE = 22052;
 const SPRM_T_VERT_MERGE = 54827;
 /** sprmTSetBrc (0xD62F): a TableBrcOperand ([MS-DOC] 2.9.305) restating one cell range's borders on the named sides, with an exact COLORREF rather than TC80's own Ico index. */
 const SPRM_T_SET_BRC = 54831;
+/** sprmTSetBrc80 (0xD620): the Word 97-era spelling of sprmTSetBrc, a TableBrc80Operand ([MS-DOC] 2.9.304) restating one cell range's borders with a palette-indexed Brc80MayBeNil rather than sprmTSetBrc's own exact-colour Brc -- the identical cb/ItcFirstLim/bordersToApply header, differing only in which four-byte border field follows it. A real Word-97-era producer's own NilBrc80 clear (the same all-bits-set sentinel TC80's own Brc80 fields use) reaches applyBrcToCell exactly like sprmTSetBrc's own NilBrc, recording the cleared side on clearedSides so the row-level cascade never re-fills it ([ExaDev/documents.js#945](https://github.com/ExaDev/documents.js/issues/945)). */
+const SPRM_T_SET_BRC80 = 54816;
 /** sprmTDefTableShd80 (0xD609): a DefTableShd80Operand ([MS-DOC] 2.9.52), the Word 97-era array of one Shd80 per cell starting at the row's first. */
 const SPRM_T_DEF_TABLE_SHD80 = 54793;
 /** sprmTDefTableShd3rd (0xD60C): a DefTableShdOperand ([MS-DOC] 2.9.53) shading cells 45-63 -- index 44 onward. */
@@ -26,6 +28,12 @@ const SPRM_T_SET_SHD_ODD = 54830;
 const SPRM_T_DEF_TABLE_SHD_RAW = 54896;
 const SPRM_T_DEF_TABLE_SHD_RAW_2ND = 54897;
 const SPRM_T_DEF_TABLE_SHD_RAW_3RD = 54898;
+/** sprmTTableBorders80 (0xD605): the Word 97-era spelling of the row/table border cascade, a TableBordersOperand80 ([MS-DOC] 2.9.303) over Brc80MayBeNil fields. */
+const SPRM_T_TABLE_BORDERS_80 = 54789;
+/** sprmTTableBorders (0xD613): a TableBordersOperand ([MS-DOC] 2.9.302) over real Brc fields with an exact COLORREF, the modern spelling of the same cascade. */
+const SPRM_T_TABLE_BORDERS = 54803;
+/** sprmTSetShdTable (0xD660): a SHDOperand ([MS-DOC] 2.9.249) whose own text states it as shading for "the entire table" -- but its own spec text carries none of sprmTTableBorders's "unless modified" exception, so this reader applies it as an ordinary per-row sprm to every cell of whichever row's grpprl states it (folded in grpprl order like every other shading sprm above), rather than resolving it across the whole table the way its name implies: a producer writing it on only one row's grpprl shades, per this implementation, only that row. */
+const SPRM_T_SET_SHD_TABLE = 54880;
 /** The first cell index each of the three DefTableShdOperand sprms shades, [MS-DOC] 2.6.3: "Cells 1 - 22 are shaded by sprmTDefTableShd, and cells 23 - 44 are shaded by sprmTDefTableShd2nd" and 45-63 by the third -- one-based there, so zero-based here. */
 const SHD_ARRAY_FIRST_CELL = {
 	[SPRM_T_DEF_TABLE_SHD]: 0,
@@ -86,10 +94,11 @@ function readTdefTableOperand(operand) {
 function withCells(definition, next) {
 	return {
 		columnBoundariesTwips: definition.columnBoundariesTwips,
-		cells: definition.cells.map(next)
+		cells: definition.cells.map(next),
+		rowBorders: definition.rowBorders
 	};
 }
-/** Overlays the sides one TableBrcOperand names onto a cell's existing borders, leaving every side it does not name as TC80's own Brc80 stated it. A named side whose Brc is a NilBrc removes that side's border, which is how a producer states "this cell has no top border" over a row-level one it would otherwise inherit. */
+/** Overlays the sides one TableBrcOperand(80) names onto a cell's existing borders, leaving every side it does not name as TC80's own Brc80 stated it. Shared verbatim by both SPRM_T_SET_BRC and SPRM_T_SET_BRC80's own switch cases, since the two operands differ only in which border field their caller has already decoded (readBrc's exact Brc vs readBrc80's palette-indexed Brc80) -- by the time `border` reaches here, both are the identical ContentBorder|undefined shape. A named side whose Brc/Brc80 is a NilBrc/NilBrc80 explicitly clears that side -- how a producer states "this cell has no top border" over a row-level one it would otherwise inherit -- and is recorded in `clearedSides` so table/read.ts's own row-level cascade can tell that apart from a side this cell has simply never mentioned. TC80's own Brc80 fields cannot state this distinction on their own (they are mandatory for every cell, so "no border" and "never stated" are the identical bytes -- table/read.ts's own applyRowLevelBorderCascade note); only an explicit sprmTSetBrc/sprmTSetBrc80 naming the side carries an unambiguous "clear" signal. A later sprmTSetBrc/sprmTSetBrc80 restating a real border on a previously cleared side un-clears it, matching the ordinary last-Prl-wins fold every sprm in this module already follows. */
 function applyBrcToCell(cell, bordersToApply, border) {
 	const sides = {
 		top: cell.borders?.top,
@@ -97,11 +106,18 @@ function applyBrcToCell(cell, bordersToApply, border) {
 		bottom: cell.borders?.bottom,
 		right: cell.borders?.right
 	};
-	for (const side of CELL_BORDER_SIDES) if ((bordersToApply & BORDERS_TO_APPLY[side]) !== 0) sides[side] = border;
+	const clearedSides = new Set(cell.clearedSides);
+	for (const side of CELL_BORDER_SIDES) {
+		if ((bordersToApply & BORDERS_TO_APPLY[side]) === 0) continue;
+		sides[side] = border;
+		if (border === void 0) clearedSides.add(side);
+		else clearedSides.delete(side);
+	}
 	return {
 		horzMerge: cell.horzMerge,
 		vertMerge: cell.vertMerge,
 		borders: cellBordersFrom(sides),
+		clearedSides: clearedSides.size > 0 ? clearedSides : void 0,
 		background: cell.background
 	};
 }
@@ -110,17 +126,18 @@ function withBackground(cell, background) {
 		horzMerge: cell.horzMerge,
 		vertMerge: cell.vertMerge,
 		borders: cell.borders,
+		clearedSides: cell.clearedSides,
 		background
 	};
 }
 /** Applies a DefTableShdOperand's ([MS-DOC] 2.9.53) rgShd array from `firstCell` onward. The array carries "only ... elements necessary to define all shaded cells in the row", so cells past its end keep whatever an earlier sprm left them -- an entry that is present and states ShdAuto/ShdNil genuinely clears its own cell, which is how a real producer's full-length array turns a row's unshaded cells back off. */
-function applyShdArray(definition, operand, firstCell, entrySize, colorAt) {
+function applyShdArray(definition, operand, firstCell, entrySize, fillAt) {
 	const cb = readUint8(operand, 0);
 	const count = Math.floor(cb / entrySize);
 	return withCells(definition, (cell, index) => {
 		const entry = index - firstCell;
 		if (entry < 0 || entry >= count) return cell;
-		return withBackground(cell, colorAt(operand, 1 + entry * entrySize));
+		return withBackground(cell, fillAt(operand, 1 + entry * entrySize));
 	});
 }
 /** Applies a TableShadeOperand ([MS-DOC] 2.9.308): cb, an ItcFirstLim naming the range, then a single Shd applied to every cell the range covers -- not one Shd per cell. `step` is 1 for sprmTSetShd and 2 for sprmTSetShdOdd, whose own range covers every other cell from itcFirst. */
@@ -156,6 +173,7 @@ function applyTableSprms(prls, into) {
 						horzMerge: index === itcFirst ? 2 : 1,
 						vertMerge: cell.vertMerge,
 						borders: cell.borders,
+						clearedSides: cell.clearedSides,
 						background: cell.background
 					};
 				});
@@ -169,6 +187,7 @@ function applyTableSprms(prls, into) {
 					horzMerge: cell.horzMerge,
 					vertMerge: vertMergeFlags,
 					borders: cell.borders,
+					clearedSides: cell.clearedSides,
 					background: cell.background
 				} : cell);
 				break;
@@ -182,6 +201,15 @@ function applyTableSprms(prls, into) {
 				into.definition = withCells(into.definition, (cell, index) => index < itcFirst || index >= itcLim ? cell : applyBrcToCell(cell, bordersToApply, border));
 				break;
 			}
+			case SPRM_T_SET_BRC80: {
+				if (into.definition === void 0) break;
+				const itcFirst = readUint8(prl.operand, 1);
+				const itcLim = readUint8(prl.operand, 2);
+				const bordersToApply = readUint8(prl.operand, 3);
+				const border = readBrc80(prl.operand, 4);
+				into.definition = withCells(into.definition, (cell, index) => index < itcFirst || index >= itcLim ? cell : applyBrcToCell(cell, bordersToApply, border));
+				break;
+			}
 			case SPRM_T_DEF_TABLE_SHD:
 			case SPRM_T_DEF_TABLE_SHD_2ND:
 			case SPRM_T_DEF_TABLE_SHD_3RD:
@@ -205,6 +233,27 @@ function applyTableSprms(prls, into) {
 			case SPRM_T_SET_SHD_ODD:
 				if (into.definition === void 0) break;
 				into.definition = applyTableShade(into.definition, prl.operand, 2);
+				break;
+			case SPRM_T_TABLE_BORDERS_80:
+				if (into.definition === void 0) break;
+				into.definition = {
+					...into.definition,
+					rowBorders: readTableBordersOperand80(prl.operand)
+				};
+				break;
+			case SPRM_T_TABLE_BORDERS:
+				if (into.definition === void 0) break;
+				into.definition = {
+					...into.definition,
+					rowBorders: readTableBordersOperand(prl.operand)
+				};
+				break;
+			case SPRM_T_SET_SHD_TABLE: {
+				if (into.definition === void 0) break;
+				const background = readShd(prl.operand, 1);
+				into.definition = withCells(into.definition, (cell) => withBackground(cell, background));
+				break;
+			}
 		}
 	}
 	return into;

package/dist/table/write.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_errors = require("../errors.cjs");
 require("../text/special.cjs");
+const require_prop_fkp_write = require("../prop/fkp-write.cjs");
 const require_table_tap_write = require("./tap-write.cjs");
 //#region src/table/write.ts
 /** sprmPFInTable (0x2416): a Bool8, "MUST be 1 any time the table depth is greater than zero". */
@@ -48,7 +49,64 @@ function columnBoundariesTwips(columnWidthsPt) {
 	}
 	return boundaries;
 }
-function flattenRow(cells, columnCount, boundaries, active) {
+/** A deep copy of `active` -- a fresh Map holding a fresh object per entry, never the same ActiveVerticalMerge instances. flattenTable's own per-row budget check (see its own note below) has to try flattening a row's lost-boundary split as a dry run before committing to it, and placeCell mutates `covered.remaining` on the object a Map entry already holds -- a shallow copy would let that dry run's own mutation bleed into the real, committed state for every row after it. */
+function cloneActive(active) {
+	return new Map(Array.from(active, ([column, merge]) => [column, { ...merge }]));
+}
+/** Where one logical cell lands on the row's own grid, before any lost-boundary splitting: its span in grid columns, and whether it is a vertical-merge continuation of a cell above. `active`'s own cross-row state must evolve identically wherever this runs, since recoverableBoundaries and flattenRow each walk every row with their own fresh map and have to land on the same columns for the second pass's splitting decisions to mean anything. */
+function placeCell(cell, column, active) {
+	const covered = active.get(column);
+	if (cell.blocks.length === 0 && covered !== void 0 && covered.remaining > 0) {
+		covered.remaining -= 1;
+		return {
+			span: covered.span,
+			isContinuation: true
+		};
+	}
+	const span = cell.colSpan ?? 1;
+	const rowSpan = cell.rowSpan ?? 1;
+	if (rowSpan > 1) active.set(column, {
+		span,
+		remaining: rowSpan - 1
+	});
+	return {
+		span,
+		isContinuation: false
+	};
+}
+function recoverableBoundaries(rows) {
+	const stated = /* @__PURE__ */ new Set();
+	const active = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		let column = 0;
+		for (const cell of row.cells) {
+			const { span } = placeCell(cell, column, active);
+			column += span;
+			stated.add(column);
+		}
+	}
+	return stated;
+}
+function distributeLostBoundaries(lostBoundaries, rowCount) {
+	const perRow = Array.from({ length: rowCount }, () => /* @__PURE__ */ new Set());
+	lostBoundaries.forEach((boundary, index) => {
+		const bucket = perRow[index % rowCount];
+		if (bucket === void 0) throw new require_errors.DocFormatError("internal defect: distributeLostBoundaries built fewer row buckets than the row count it was given");
+		bucket.add(boundary);
+	});
+	return perRow;
+}
+function splitAtLostBoundaries(column, span, lostBoundaries) {
+	const subSpans = [];
+	let start = column;
+	for (let position = column + 1; position < column + span; position += 1) if (lostBoundaries.has(position)) {
+		subSpans.push(position - start);
+		start = position;
+	}
+	subSpans.push(column + span - start);
+	return subSpans;
+}
+function flattenRow(cells, columnCount, boundaries, active, lostBoundaries) {
 	const paragraphs = [];
 	const cellsToWrite = [];
 	const firstBoundary = boundaries[0];
@@ -56,36 +114,31 @@ function flattenRow(cells, columnCount, boundaries, active) {
 	const rowBoundariesTwips = [firstBoundary];
 	let column = 0;
 	for (const cell of cells) {
-		const covered = active.get(column);
-		const isContinuation = cell.blocks.length === 0 && covered !== void 0 && covered.remaining > 0;
-		let span;
-		let vertMerge;
-		let blocks;
-		if (isContinuation) {
-			covered.remaining -= 1;
-			span = covered.span;
-			vertMerge = 1;
-			blocks = [];
-		} else {
-			span = cell.colSpan ?? 1;
-			const rowSpan = cell.rowSpan ?? 1;
-			vertMerge = rowSpan > 1 ? 3 : 0;
-			if (rowSpan > 1) active.set(column, {
-				span,
-				remaining: rowSpan - 1
+		const startColumn = column;
+		const { span, isContinuation } = placeCell(cell, startColumn, active);
+		const rowSpan = cell.rowSpan ?? 1;
+		const vertMerge = isContinuation ? 1 : rowSpan > 1 ? 3 : 0;
+		const blocks = isContinuation ? [] : cell.blocks;
+		const subSpans = splitAtLostBoundaries(startColumn, span, lostBoundaries);
+		subSpans.forEach((subSpan, subIndex) => {
+			paragraphs.push(...cellParagraphs(subIndex === 0 ? blocks : []));
+			cellsToWrite.push(subIndex === 0 ? isContinuation ? {
+				vertMerge,
+				horzMerge: subSpans.length > 1 ? 2 : 0
+			} : {
+				vertMerge,
+				horzMerge: subSpans.length > 1 ? 2 : 0,
+				borders: cell.borders,
+				background: cell.background
+			} : {
+				vertMerge,
+				horzMerge: 1
 			});
-			blocks = cell.blocks;
-		}
-		paragraphs.push(...cellParagraphs(blocks));
-		cellsToWrite.push(isContinuation ? { vertMerge } : {
-			vertMerge,
-			borders: cell.borders,
-			background: cell.background
+			column += subSpan;
+			const rightBoundary = boundaries[column];
+			if (rightBoundary === void 0) throw new require_errors.DocFormatError(`a table cell's own colSpan runs past the table's ${columnCount}-column grid`);
+			rowBoundariesTwips.push(rightBoundary);
 		});
-		column += span;
-		const rightBoundary = boundaries[column];
-		if (rightBoundary === void 0) throw new require_errors.DocFormatError(`a table cell's own colSpan runs past the table's ${columnCount}-column grid`);
-		rowBoundariesTwips.push(rightBoundary);
 	}
 	if (column !== columnCount) throw new require_errors.DocFormatError(`a table row's own cells cover ${column} columns (via colSpan), but the table declares ${columnCount} in columnWidthsPt`);
 	return {
@@ -94,27 +147,51 @@ function flattenRow(cells, columnCount, boundaries, active) {
 		rowBoundariesTwips
 	};
 }
-function flattenTable(table) {
+function rowMarkParagraph(rowBoundariesTwips, cellsToWrite, heightPt) {
+	return {
+		runs: [],
+		properties: {},
+		extraGrpprl: rowMarkExtraGrpprl(rowBoundariesTwips, cellsToWrite, heightPt),
+		terminator: 7
+	};
+}
+function rowSplitFits(row, columnCount, boundaries, active, candidateBoundaries, heightPt) {
+	const trial = flattenRow(row.cells, columnCount, boundaries, cloneActive(active), candidateBoundaries);
+	if (trial.cellsToWrite.length > 63) return false;
+	const trialGrpprl = rowMarkExtraGrpprl(trial.rowBoundariesTwips, trial.cellsToWrite, heightPt);
+	return require_prop_fkp_write.fitsAloneOnPapxPage(trialGrpprl);
+}
+function flattenTable(table, blockIndex, onWarning) {
 	const columnCount = table.columnWidthsPt.length;
 	if (columnCount === 0 || table.rows.length === 0) throw new require_errors.DocFormatError("a table must have at least one column and one row to write");
 	const boundaries = columnBoundariesTwips(table.columnWidthsPt);
+	const stated = recoverableBoundaries(table.rows);
+	const lostBoundaries = [];
+	for (let index = 1; index < columnCount; index += 1) if (!stated.has(index)) lostBoundaries.push(index);
+	const lostBoundariesByRow = distributeLostBoundaries(lostBoundaries, table.rows.length);
 	const active = /* @__PURE__ */ new Map();
 	const output = [];
-	for (const row of table.rows) {
-		const { paragraphs, cellsToWrite, rowBoundariesTwips } = flattenRow(row.cells, columnCount, boundaries, active);
+	table.rows.forEach((row, rowIndex) => {
+		const rowLostBoundaries = lostBoundariesByRow[rowIndex];
+		if (rowLostBoundaries === void 0) throw new require_errors.DocFormatError("internal defect: distributeLostBoundaries returned fewer buckets than the table has rows");
+		let rowLostBoundariesToApply = rowLostBoundaries;
+		if (rowLostBoundaries.size > 0 && !rowSplitFits(row, columnCount, boundaries, active, rowLostBoundaries, row.heightPt)) {
+			const ordered = Array.from(rowLostBoundaries);
+			let kept = ordered;
+			while (kept.length > 0 && !rowSplitFits(row, columnCount, boundaries, active, new Set(kept), row.heightPt)) kept = kept.slice(0, -1);
+			rowLostBoundariesToApply = new Set(kept);
+			const droppedCount = ordered.length - kept.length;
+			onWarning?.(kept.length === 0 ? `doc-codec: table at block ${blockIndex}, row ${rowIndex} could not state ${rowLostBoundaries.size === 1 ? "its assigned lost column boundary" : `any of its ${rowLostBoundaries.size} assigned lost column boundaries`} without exceeding a PapxInFkp record's own byte budget or the format's own 63-cell-per-row ceiling; attempting to write it unsplit instead, which narrows columnWidthsPt on read for this table exactly as this writer's own pre-#992 behaviour did -- if this row's own unsplit encoding also overflows this same budget, writeDocContent can still throw its usual DocFormatError further down this same pipeline, after any remaining rows have reported their own warnings` : `doc-codec: table at block ${blockIndex}, row ${rowIndex} could only state ${kept.length} of its ${ordered.length} assigned lost column boundaries without exceeding a PapxInFkp record's own byte budget or the format's own 63-cell-per-row ceiling; dropping the other ${droppedCount} (narrowing columnWidthsPt on read for those boundaries alone)`);
+		}
+		const { paragraphs, cellsToWrite, rowBoundariesTwips } = flattenRow(row.cells, columnCount, boundaries, active, rowLostBoundariesToApply);
 		output.push(...paragraphs);
-		output.push({
-			runs: [],
-			properties: {},
-			extraGrpprl: rowMarkExtraGrpprl(rowBoundariesTwips, cellsToWrite, row.heightPt),
-			terminator: 7
-		});
-	}
+		output.push(rowMarkParagraph(rowBoundariesTwips, cellsToWrite, row.heightPt));
+	});
 	return output;
 }
-function flattenSectionBlocks(blocks) {
+function flattenSectionBlocks(blocks, onWarning) {
 	const output = [];
-	for (const block of blocks) {
+	blocks.forEach((block, blockIndex) => {
 		if (block.kind === "paragraph") {
 			output.push({
 				runs: block.runs,
@@ -122,14 +199,14 @@ function flattenSectionBlocks(blocks) {
 				extraGrpprl: [],
 				terminator: 13
 			});
-			continue;
+			return;
 		}
 		if (block.kind === "table") {
-			output.push(...flattenTable(block));
-			continue;
+			output.push(...flattenTable(block, blockIndex, onWarning));
+			return;
 		}
 		throw new require_errors.DocUnsupportedError(`doc-codec's writer does not yet support '${block.kind}' blocks (see README's scope note)`);
-	}
+	});
 	return output;
 }
 //#endregion

package/dist/table/write.d.cts

@@ -1,13 +1,2 @@
-import { ContentBlock, ContentParagraph, ContentRun } from "document-schema.js";
-//#region src/table/write.d.ts
-interface WriteParagraph {
-  readonly runs: readonly ContentRun[];
-  readonly properties: Pick<ContentParagraph, "alignment" | "indentLeftPt" | "indentFirstLinePt" | "spacingBeforePt" | "spacingAfterPt" | "lineSpacing" | "pageBreakBefore">;
-  /** Extra grpprl bytes appended after encodeParagraphGrpprl's own output -- sprmPFInTable on every table paragraph, plus sprmPFTtp and the row's own TAP on a row's trailing mark. */
-  readonly extraGrpprl: readonly number[];
-  /** The character terminating this paragraph in the text stream: PARAGRAPH_MARK normally, CELL_MARK for a table cell or row mark. */
-  readonly terminator: number;
-}
-declare function flattenSectionBlocks(blocks: readonly ContentBlock[]): WriteParagraph[];
-//#endregion
-export { WriteParagraph, flattenSectionBlocks };
+import { n as WriteWarning, r as flattenSectionBlocks, t as WriteParagraph } from "../write-C_vJizAM.cjs";
+export { WriteParagraph, WriteWarning, flattenSectionBlocks };

package/dist/table/write.d.ts

@@ -1,13 +1,2 @@
-import { ContentBlock, ContentParagraph, ContentRun } from "document-schema.js";
-//#region src/table/write.d.ts
-interface WriteParagraph {
-  readonly runs: readonly ContentRun[];
-  readonly properties: Pick<ContentParagraph, "alignment" | "indentLeftPt" | "indentFirstLinePt" | "spacingBeforePt" | "spacingAfterPt" | "lineSpacing" | "pageBreakBefore">;
-  /** Extra grpprl bytes appended after encodeParagraphGrpprl's own output -- sprmPFInTable on every table paragraph, plus sprmPFTtp and the row's own TAP on a row's trailing mark. */
-  readonly extraGrpprl: readonly number[];
-  /** The character terminating this paragraph in the text stream: PARAGRAPH_MARK normally, CELL_MARK for a table cell or row mark. */
-  readonly terminator: number;
-}
-declare function flattenSectionBlocks(blocks: readonly ContentBlock[]): WriteParagraph[];
-//#endregion
-export { WriteParagraph, flattenSectionBlocks };
+import { n as WriteWarning, r as flattenSectionBlocks, t as WriteParagraph } from "../write-C_vJizAM.js";
+export { WriteParagraph, WriteWarning, flattenSectionBlocks };