@docx4j/core-ts 0.5.0 → 0.7.0

package/dist/model/content/story.d.mts

@@ -0,0 +1,47 @@
+import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
+import { type Element } from './tree.mjs';
+/** One paragraph of a story: its element, the array holding it, and its text's place in the story's text. */
+export interface StoryParagraph {
+    element: Element<wml.P>;
+    container: Element[];
+    /** Where its text starts and ends in `StoryLayout.text`. */
+    start: number;
+    end: number;
+}
+/**
+ * A story's text in Word's default view (CR-012 phase 4; checks 30, 31, 48 and 51): each paragraph's text
+ * followed by its mark, `\r`, but a mark tracked as deleted (CR-012 section 19, check 58); in a table a row's cells a `\t` apart, each cell's paragraphs a mark apart
+ * (its last mark not written), and the row ended by `\r\n`. Unlike `Body.text` the story's last mark is
+ * kept, so that every paragraph's text is followed by what Word puts after it.
+ */
+export interface StoryLayout {
+    text: string;
+    /** The paragraphs a reader takes, in document order (tables and controls descended into). */
+    paragraphs: StoryParagraph[];
+    /** The index in `paragraphs` of a `w:p`, or -1 where the walk didn't meet it. */
+    indexOf(p: wml.P): number;
+}
+/**
+ * Whether a paragraph's mark is written in Word's default view: not where it is tracked as deleted, which reads as
+ * nothing there, the paragraphs staying apart (check 58 cases 6 to 8, CR-012 section 19), nor where it is tracked as
+ * moved from, as the paragraph's runs are (CR-002 section 64). A cell's last paragraph is ended by the cell's `\t`
+ * whatever its mark (cases 9 and 10).
+ */
+export declare const shownInDefaultView: (p: wml.P) => boolean;
+/** Whether a paragraph's mark is written in the original view, the marks Reject All keeps: not one tracked as inserted, nor as moved to. */
+export declare const shownInOriginalView: (p: wml.P) => boolean;
+/**
+ * Lays out the blocks `items`, each paragraph's text read by `textOf` (its `Paragraph.text`, or another view's), its
+ * mark written where `markShown` says (Word's default view's rule unless another view's is given).
+ */
+export declare function storyLayout(items: Element[], textOf: (element: Element<wml.P>, container: Element[]) => string, markShown?: (p: wml.P) => boolean): StoryLayout;
+/**
+ * The story a paragraph stands in: the outermost array of block content above it, and the object holding
+ * that array. A text box's paragraphs are a story of their own (the array in its `w:txbxContent`), since a
+ * range never crosses a text box's edge; so is a branch of a kept `mc:AlternateContent` that Word doesn't
+ * read (CR-013's twin stories), where the selected branch is part of the story around it.
+ */
+export declare function storyOf(p: wml.P): {
+    items: Element[];
+    owner: object;
+};

package/dist/model/content/story.mjs

@@ -0,0 +1,95 @@
+import { Docx4JException } from '../../opc/exceptions.mjs';
+import { typeNameOf, childrenOf, rowsOf, cellsOf, selectedBranchOf, BRANCH_TYPES } from './tree.mjs';
+/**
+ * Whether a paragraph's mark is written in Word's default view: not where it is tracked as deleted, which reads as
+ * nothing there, the paragraphs staying apart (check 58 cases 6 to 8, CR-012 section 19), nor where it is tracked as
+ * moved from, as the paragraph's runs are (CR-002 section 64). A cell's last paragraph is ended by the cell's `\t`
+ * whatever its mark (cases 9 and 10).
+ */
+export const shownInDefaultView = (p) => { var _a, _b, _c, _d; return ((_b = (_a = p.pPr) === null || _a === void 0 ? void 0 : _a.rPr) === null || _b === void 0 ? void 0 : _b.del) === undefined && ((_d = (_c = p.pPr) === null || _c === void 0 ? void 0 : _c.rPr) === null || _d === void 0 ? void 0 : _d.moveFrom) === undefined; };
+/** Whether a paragraph's mark is written in the original view, the marks Reject All keeps: not one tracked as inserted, nor as moved to. */
+export const shownInOriginalView = (p) => { var _a, _b, _c, _d; return ((_b = (_a = p.pPr) === null || _a === void 0 ? void 0 : _a.rPr) === null || _b === void 0 ? void 0 : _b.ins) === undefined && ((_d = (_c = p.pPr) === null || _c === void 0 ? void 0 : _c.rPr) === null || _d === void 0 ? void 0 : _d.moveTo) === undefined; };
+/**
+ * Lays out the blocks `items`, each paragraph's text read by `textOf` (its `Paragraph.text`, or another view's), its
+ * mark written where `markShown` says (Word's default view's rule unless another view's is given).
+ */
+export function storyLayout(items, textOf, markShown = shownInDefaultView) {
+    const pieces = [];
+    let length = 0;
+    const push = (piece) => { pieces.push(piece); length += piece.length; };
+    const pop = () => { length -= pieces.pop().length; };
+    const paragraphs = [];
+    // Word's default view: the cells a tab apart, the row ended by \r\n (checks 30, 31 and 51; check 48's \t after
+    // every cell and row was All Markup's, with hidden text shown)
+    const visitRow = (row) => {
+        cellsOf(row, 'read').forEach((cell, i) => {
+            var _a;
+            if (i > 0)
+                push('\t');
+            visit((_a = childrenOf(cell.element.value)) !== null && _a !== void 0 ? _a : []);
+            if (pieces[pieces.length - 1] === '\r')
+                pop();
+        });
+        push('\r\n');
+    };
+    const visit = (blocks) => {
+        for (const el of blocks) {
+            const tn = typeNameOf(el);
+            if (tn === 'org_docx4j_wml.P') {
+                const text = textOf(el, blocks);
+                paragraphs.push({ element: el, container: blocks, start: length, end: length + text.length });
+                push(text);
+                if (markShown(el.value))
+                    push('\r');
+                continue;
+            }
+            const v = el.value;
+            if (typeof v !== 'object' || v === null)
+                continue;
+            if (tn === 'org_docx4j_wml.Tbl') {
+                for (const row of rowsOf(v, 'read'))
+                    visitRow(row.element.value);
+                continue;
+            }
+            // a row-level content control's content: its rows (check 53: its text is its cells a \t apart)
+            if (tn === 'org_docx4j_wml.Tr') {
+                visitRow(v);
+                continue;
+            }
+            const children = childrenOf(v, 'read');
+            if (children)
+                visit(children);
+        }
+    };
+    visit(items);
+    const index = new Map(paragraphs.map((p, i) => [p.element.value, i]));
+    return { text: pieces.join(''), paragraphs, indexOf: (p) => { var _a; return (_a = index.get(p)) !== null && _a !== void 0 ? _a : -1; } };
+}
+/**
+ * The story a paragraph stands in: the outermost array of block content above it, and the object holding
+ * that array. A text box's paragraphs are a story of their own (the array in its `w:txbxContent`), since a
+ * range never crosses a text box's edge; so is a branch of a kept `mc:AlternateContent` that Word doesn't
+ * read (CR-013's twin stories), where the selected branch is part of the story around it.
+ */
+export function storyOf(p) {
+    let story;
+    for (let o = p.PARENT; o !== undefined; o = o.PARENT) {
+        const tn = o.TYPE_NAME;
+        // a paragraph above this one: p is in a text box, whose content is its story
+        if (tn === 'org_docx4j_wml.P')
+            break;
+        if (tn !== undefined && BRANCH_TYPES.has(tn)) {
+            const ac = o.PARENT;
+            const items = o.any;
+            if (ac && items && selectedBranchOf(ac) !== items)
+                return { items, owner: o };
+            continue;
+        }
+        const content = o.content;
+        if (Array.isArray(content))
+            story = { items: content, owner: o };
+    }
+    if (!story)
+        throw new Docx4JException('This paragraph is in no story: it is not in a body, a cell, a note or a comment');
+    return story;
+}

package/dist/model/content/tableColumns.d.mts

@@ -10,7 +10,7 @@ export declare function layoutModeOf(tbl: wml.Tbl): TableLayoutMode;
 export declare function textWidthTwips(container: {
     sectPr?: wml.SectPr;
 } | undefined): number;
-/** The grid's column widths in twips; a table without a `w:tblGrid` gets one from its first row (equal columns over the text width when the cells state none). */
+/** The grid's column widths in twips; a table without a `w:tblGrid` gets one from its first row as Word reads it (equal columns over the text width when the cells state none). */
 export declare function gridWidthsOf(tbl: wml.Tbl, textWidth: number): number[];
 /** The form a cell's width takes: its own `w:tcW` type, else the table's `w:tblW` type, else twips (section 42.2 item 4). */
 export declare function widthTypeOf(tc: wml.Tc | undefined, tbl: wml.Tbl): string;

package/dist/model/content/tableColumns.mjs

@@ -1,7 +1,7 @@
 import { deepCopy } from '@docx4j/generated-objects-ts';
 import { tc as cellElementOf } from '@docx4j/generated-objects-ts/builders/wml';
 import { Docx4JException } from '../../opc/exceptions.mjs';
-import { rowsOf, cellsOf, childrenOf, linkParents, paragraphOf } from './tree.mjs';
+import { rowsOf, cellsOf, cellLayoutsOf, childrenOf, linkParents, paragraphOf } from './tree.mjs';
 import { wrapInsertedRuns } from './tracking.mjs';
 /** The default text width in twips (A4 with 2.54 cm margins), as the objects package's `tbl` builder uses. */
 export const DEFAULT_TEXT_WIDTH = 9026;
@@ -42,14 +42,14 @@ function setSpan(tc, count) {
     else
         delete tcPr.gridSpan;
 }
-/** The grid's column widths in twips; a table without a `w:tblGrid` gets one from its first row (equal columns over the text width when the cells state none). */
+/** The grid's column widths in twips; a table without a `w:tblGrid` gets one from its first row as Word reads it (equal columns over the text width when the cells state none). */
 export function gridWidthsOf(tbl, textWidth) {
     var _a, _b, _c, _d;
     const grid = (_a = tbl.tblGrid) === null || _a === void 0 ? void 0 : _a.gridCol;
     if (grid && grid.length > 0)
         return grid.map((col) => { var _a; return Number((_a = col.w) !== null && _a !== void 0 ? _a : 0); });
-    const first = rowsOf(tbl)[0];
-    const cells = first ? cellsOf(first.element.value) : [];
+    const first = rowsOf(tbl, 'read')[0];
+    const cells = first ? cellsOf(first.element.value, 'read') : [];
     const columns = Math.max(1, cells.reduce((n, cell) => n + spanOf(cell.element.value), 0));
     const each = Math.floor(textWidth / columns);
     const widths = [];
@@ -158,6 +158,33 @@ function paragraphPropertiesFrom(template) {
             delete rPr[key];
     return Object.keys(out).length > 0 ? out : undefined;
 }
+/**
+ * The rows the column passes walk: every branch's of a kept row-level `mc:AlternateContent`, since the
+ * grid is every branch's; a row's cells along each of its layouts (`cellLayoutsOf`), so a cell-level
+ * element's every branch gains and loses the columns its selected branch does (CR-013 phase 3).
+ */
+function everyRow(tbl) {
+    return rowsOf(tbl, 'every').map((row) => row.element.value);
+}
+/** Each cell of a row once, with the grid columns it covers, along the row's layouts. */
+function cellExtentsOf(tr) {
+    var _a, _b;
+    const out = [];
+    const seen = new Set();
+    for (const layout of cellLayoutsOf(tr)) {
+        let at = Number((_b = (_a = rowMember(tr, 'gridBefore')) === null || _a === void 0 ? void 0 : _a.value.val) !== null && _b !== void 0 ? _b : 0);
+        for (const cell of layout) {
+            const tc = cell.element.value;
+            const end = at + spanOf(tc);
+            if (!seen.has(tc)) {
+                seen.add(tc);
+                out.push({ cell, start: at, end });
+            }
+            at = end;
+        }
+    }
+    return out;
+}
 /** The new cells of one row, each a `w:tc` of one paragraph with the template's shading and paragraph properties. */
 function newCells(count, values, template) {
     var _a, _b;
@@ -204,49 +231,73 @@ export function insertGridColumns(tbl, textWidth, gridIndex, count, values, trac
     const copied = old[gridIndex < old.length ? gridIndex : old.length - 1];
     const unscaled = [...old.slice(0, gridIndex), ...Array.from({ length: count }, () => copied), ...old.slice(gridIndex)];
     const widths = mode === 'window' ? rescaled(unscaled, old.reduce((a, b) => a + b, 0)) : unscaled;
-    const rows = rowsOf(tbl).map((row) => row.element.value);
+    // the rows a reader sees, which `values` and the result are by; then every other branch's (CR-013 phase 3)
+    const read = rowsOf(tbl, 'read').map((row) => row.element.value);
+    const rows = [...read, ...everyRow(tbl).filter((tr) => !read.includes(tr))];
+    // a row's plan per layout: a cell-level element's branches each get the new cells where the boundary falls in them
     const plans = rows.map((tr) => planRow(tr, gridIndex));
     // an AutoFit-to-contents add changes no width, and Office JS records nothing for it (check 41c)
     const record = tracker && mode !== 'contents' ? recordTable(tbl, rows, tracker) : undefined;
     const result = { cells: [] };
-    plans.forEach((plan, rowIndex) => {
-        var _a, _b;
-        const tr = plan.tr;
-        if (plan.skipped) {
-            plan.skipped.value.val = Number((_a = plan.skipped.value.val) !== null && _a !== void 0 ? _a : 0) + count;
-            result.cells.push([]);
-            return;
-        }
-        const cells = newCells(count, values === null || values === void 0 ? void 0 : values[rowIndex], plan.template);
-        plan.container.splice(plan.at, 0, ...cells);
-        const owner = ownerOfCells(tr, plan.container);
-        for (const cell of cells)
-            linkParents(cell, owner);
-        if (tracker)
+    const added = [];
+    plans.forEach((rowPlans, rowIndex) => {
+        const shown = [];
+        rowPlans.forEach((plan, layout) => {
+            var _a, _b;
+            const tr = plan.tr;
+            if (plan.skipped) {
+                plan.skipped.value.val = Number((_a = plan.skipped.value.val) !== null && _a !== void 0 ? _a : 0) + count;
+                return;
+            }
+            const cells = newCells(count, rowIndex < read.length ? values === null || values === void 0 ? void 0 : values[rowIndex] : undefined, plan.template);
+            plan.container.splice(plan.at, 0, ...cells);
+            const owner = ownerOfCells(tr, plan.container);
             for (const cell of cells)
-                for (const block of (_b = childrenOf(cell.value)) !== null && _b !== void 0 ? _b : [])
-                    wrapInsertedRuns(tracker, childrenOf(block.value), block.value);
-        result.cells.push(cells);
+                linkParents(cell, owner);
+            if (tracker)
+                for (const cell of cells)
+                    for (const block of (_b = childrenOf(cell.value)) !== null && _b !== void 0 ? _b : [])
+                        wrapInsertedRuns(tracker, childrenOf(block.value), block.value);
+            added.push(...cells);
+            if (layout === 0)
+                shown.push(...cells);
+        });
+        if (rowIndex < read.length)
+            result.cells.push(shown);
     });
     // the grid, the table's width, and the cells' widths in their forms
     writeGrid(tbl, widths);
     const tblW = (_a = tbl.tblPr) === null || _a === void 0 ? void 0 : _a.tblW;
     if (mode === 'fixed' && (tblW === null || tblW === void 0 ? void 0 : tblW.type) === 'dxa')
         tblW.w = Number((_b = tblW.w) !== null && _b !== void 0 ? _b : 0) + copied * count;
-    writeCellWidths(tbl, widths, mode === 'window' ? 'all' : result.cells.flat().map((c) => c.value));
+    writeCellWidths(tbl, widths, mode === 'window' ? 'all' : added.map((c) => c.value));
     if (record)
-        record(result.cells.flat().map((c) => c.value), { unscaled, scaled: widths });
+        record(added.map((c) => c.value), { unscaled, scaled: widths });
     return result;
 }
-/** Where the boundary falls in a row: at or inside a cell (the new cells go before it), in its skipped columns, or after its last cell. */
+/**
+ * Where the boundary falls in a row, along each of its layouts (`cellLayoutsOf`): at or inside a cell
+ * (the new cells go before it), in its skipped columns, or after its last cell. A place two layouts
+ * share (outside a cell-level element) is planned once, so each list gains the new cells once.
+ */
 function planRow(tr, gridIndex) {
-    var _a, _b, _c;
+    var _a;
     const before = rowMember(tr, 'gridBefore');
     const after = rowMember(tr, 'gridAfter');
     const skippedBefore = Number((_a = before === null || before === void 0 ? void 0 : before.value.val) !== null && _a !== void 0 ? _a : 0);
     if (before && gridIndex < skippedBefore)
-        return { tr, skipped: before };
-    const cells = cellsOf(tr);
+        return [{ tr, skipped: before }];
+    const plans = [];
+    const planned = (plan) => plans.some((p) => (p.skipped !== undefined && p.skipped === plan.skipped) || (p.container !== undefined && p.container === plan.container && p.at === plan.at));
+    for (const cells of cellLayoutsOf(tr)) {
+        const plan = planLayout(tr, cells, gridIndex, skippedBefore, after);
+        if (!planned(plan))
+            plans.push(plan);
+    }
+    return plans;
+}
+function planLayout(tr, cells, gridIndex, skippedBefore, after) {
+    var _a, _b;
     let at = skippedBefore;
     for (const cell of cells) {
         const tc = cell.element.value;
@@ -256,26 +307,21 @@ function planRow(tr, gridIndex) {
             return { tr, container: cell.container, at: cell.container.indexOf(cell.element), template: tc };
         at = end;
     }
-    const skippedAfter = Number((_b = after === null || after === void 0 ? void 0 : after.value.val) !== null && _b !== void 0 ? _b : 0);
+    const skippedAfter = Number((_a = after === null || after === void 0 ? void 0 : after.value.val) !== null && _a !== void 0 ? _a : 0);
     if (after && gridIndex < at + skippedAfter)
         return { tr, skipped: after };
     const last = cells[cells.length - 1];
     if (!last)
-        return { tr, container: ((_c = tr.content) !== null && _c !== void 0 ? _c : (tr.content = [])), at: tr.content.length, template: undefined };
+        return { tr, container: ((_b = tr.content) !== null && _b !== void 0 ? _b : (tr.content = [])), at: tr.content.length, template: undefined };
     return { tr, container: last.container, at: last.container.indexOf(last.element) + 1, template: last.element.value };
 }
-/** Every cell's `w:tcW` from the grid (`all`), or only the given cells', each in the form it takes. */
+/** Every cell's `w:tcW` from the grid (`all`), or only the given cells', each in the form it takes, in every branch. */
 function writeCellWidths(tbl, widths, which) {
-    var _a, _b;
-    for (const row of rowsOf(tbl)) {
-        const tr = row.element.value;
-        let at = Number((_b = (_a = rowMember(tr, 'gridBefore')) === null || _a === void 0 ? void 0 : _a.value.val) !== null && _b !== void 0 ? _b : 0);
-        for (const cell of cellsOf(tr)) {
+    for (const tr of everyRow(tbl)) {
+        for (const { cell, start, end } of cellExtentsOf(tr)) {
             const tc = cell.element.value;
-            const end = at + spanOf(tc);
             if (which === 'all' || which.includes(tc))
-                writeCellWidth(tc, tbl, widths, at, end);
-            at = end;
+                writeCellWidth(tc, tbl, widths, start, end);
         }
     }
 }
@@ -299,7 +345,7 @@ function recordTable(tbl, rows, tracker) {
     const recordGrid = !((_a = tbl.tblGrid) === null || _a === void 0 ? void 0 : _a.tblGridChange);
     const oldCells = [];
     for (const tr of rows)
-        for (const cell of cellsOf(tr)) {
+        for (const cell of cellsOf(tr, 'every')) {
             const tc = cell.element.value;
             if (!((_b = tc.tcPr) === null || _b === void 0 ? void 0 : _b.tcPrChange))
                 oldCells.push([tc, recordedCellProperties(tc)]);
@@ -361,18 +407,10 @@ function mergedEdges(unscaled, scaled) {
 }
 /** Each cell's column extent in the grid as it is now, through the rows' spans and skipped columns. */
 function cellExtents(tbl) {
-    var _a, _b;
     const out = new Map();
-    for (const row of rowsOf(tbl)) {
-        const tr = row.element.value;
-        let at = Number((_b = (_a = rowMember(tr, 'gridBefore')) === null || _a === void 0 ? void 0 : _a.value.val) !== null && _b !== void 0 ? _b : 0);
-        for (const cell of cellsOf(tr)) {
-            const tc = cell.element.value;
-            const end = at + spanOf(tc);
-            out.set(tc, { start: at, end });
-            at = end;
-        }
-    }
+    for (const tr of everyRow(tbl))
+        for (const { cell, start, end } of cellExtentsOf(tr))
+            out.set(cell.element.value, { start, end });
     return out;
 }
 /** A cell's properties as a record holds them: everything but the markers and an earlier record. */
@@ -381,7 +419,7 @@ function recordedCellProperties(tc) {
 }
 /** Whether a cell is still in the table (a deleted column's cells are not). */
 function isInTable(tc, tbl) {
-    return rowsOf(tbl).some((row) => cellsOf(row.element.value).some((cell) => cell.element.value === tc));
+    return everyRow(tbl).some((tr) => cellsOf(tr, 'every').some((cell) => cell.element.value === tc));
 }
 function without(value, keys) {
     const out = {};
@@ -407,22 +445,23 @@ export function deleteGridColumns(tbl, textWidth, columnIndex, count, tracker) {
     if (columnIndex < 0 || columnIndex + count > old.length)
         throw new Docx4JException(`No columns ${columnIndex} to ${columnIndex + count - 1} in a grid of ${old.length} columns`);
     const mode = layoutModeOf(tbl);
-    const record = tracker && mode !== 'contents' ? recordTable(tbl, rowsOf(tbl).map((row) => row.element.value), tracker) : undefined;
+    const record = tracker && mode !== 'contents' ? recordTable(tbl, everyRow(tbl), tracker) : undefined;
     const from = columnIndex;
     const to = columnIndex + count;
     const overlap = (start, end) => Math.max(0, Math.min(end, to) - Math.max(start, from));
-    for (const row of rowsOf(tbl)) {
-        const tr = row.element.value;
+    // every branch's rows, and every branch's cells at their grid columns (CR-013 phase 3)
+    for (const tr of everyRow(tbl)) {
+        const extents = cellExtentsOf(tr);
         const before = rowMember(tr, 'gridBefore');
         const skippedBefore = Number((_a = before === null || before === void 0 ? void 0 : before.value.val) !== null && _a !== void 0 ? _a : 0);
+        // the row's last cell edge, before anything shrinks: every layout ends there
+        const lastEdge = extents.reduce((edge, extent) => Math.max(edge, extent.end), skippedBefore);
         if (before)
             before.value.val = skippedBefore - overlap(0, skippedBefore);
-        let at = skippedBefore;
-        for (const cell of cellsOf(tr)) {
+        for (const { cell, start, end } of extents) {
             const tc = cell.element.value;
-            const span = spanOf(tc);
-            const end = at + span;
-            const covered = overlap(at, end);
+            const span = end - start;
+            const covered = overlap(start, end);
             if (covered === span) {
                 const i = cell.container.indexOf(cell.element);
                 if (i >= 0)
@@ -431,12 +470,11 @@ export function deleteGridColumns(tbl, textWidth, columnIndex, count, tracker) {
             else if (covered > 0) {
                 setSpan(tc, span - covered);
             }
-            at = end;
         }
         const after = rowMember(tr, 'gridAfter');
         if (after) {
             const skippedAfter = Number((_b = after.value.val) !== null && _b !== void 0 ? _b : 0);
-            after.value.val = skippedAfter - overlap(at, at + skippedAfter);
+            after.value.val = skippedAfter - overlap(lastEdge, lastEdge + skippedAfter);
         }
     }
     const removed = old.slice(from, to).reduce((a, b) => a + b, 0);
@@ -453,32 +491,22 @@ export function deleteGridColumns(tbl, textWidth, columnIndex, count, tracker) {
 }
 /** The cells whose span no longer matches their stated twips width: those that shrank. */
 function shrunkCells(tbl) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e;
     const out = [];
     const widths = (_c = (_b = (_a = tbl.tblGrid) === null || _a === void 0 ? void 0 : _a.gridCol) === null || _b === void 0 ? void 0 : _b.map((col) => { var _a; return Number((_a = col.w) !== null && _a !== void 0 ? _a : 0); })) !== null && _c !== void 0 ? _c : [];
-    for (const row of rowsOf(tbl)) {
-        const tr = row.element.value;
-        let at = Number((_e = (_d = rowMember(tr, 'gridBefore')) === null || _d === void 0 ? void 0 : _d.value.val) !== null && _e !== void 0 ? _e : 0);
-        for (const cell of cellsOf(tr)) {
+    for (const tr of everyRow(tbl)) {
+        for (const { cell, start, end } of cellExtentsOf(tr)) {
             const tc = cell.element.value;
-            const end = at + spanOf(tc);
-            const tcW = (_f = tc.tcPr) === null || _f === void 0 ? void 0 : _f.tcW;
-            if ((tcW === null || tcW === void 0 ? void 0 : tcW.type) === 'dxa' && Number((_g = tcW.w) !== null && _g !== void 0 ? _g : 0) !== widths.slice(at, end).reduce((a, b) => a + b, 0))
+            const tcW = (_d = tc.tcPr) === null || _d === void 0 ? void 0 : _d.tcW;
+            if ((tcW === null || tcW === void 0 ? void 0 : tcW.type) === 'dxa' && Number((_e = tcW.w) !== null && _e !== void 0 ? _e : 0) !== widths.slice(start, end).reduce((a, b) => a + b, 0))
                 out.push(tc);
-            at = end;
         }
     }
     return out;
 }
 /** The grid columns a cell covers: its start and the one past its end. */
 export function gridRangeOf(tr, tc) {
-    var _a, _b;
-    let at = Number((_b = (_a = rowMember(tr, 'gridBefore')) === null || _a === void 0 ? void 0 : _a.value.val) !== null && _b !== void 0 ? _b : 0);
-    for (const cell of cellsOf(tr)) {
-        const end = at + spanOf(cell.element.value);
-        if (cell.element.value === tc)
-            return { start: at, end };
-        at = end;
-    }
-    return undefined;
+    // along the row's layouts, so a cell after a cell-level mc:AlternateContent is placed past its columns
+    const extent = cellExtentsOf(tr).find(({ cell }) => cell.element.value === tc);
+    return extent ? { start: extent.start, end: extent.end } : undefined;
 }

package/dist/model/content/tableRevisions.d.mts

@@ -9,15 +9,20 @@ export declare function tableRecordsOf(tbl: wml.Tbl): TableRecords | undefined;
 export declare function hasTableRecords(tbl: wml.Tbl): boolean;
 /** A row's text as Office JS reports it: its cells with a tab between them, then `\r\n` (checks 27 and 28). */
 export declare function rowText(tr: wml.Tr): string;
-/** The text of a table's change: the table's where its own properties or grid changed, else the changed rows'. */
+/**
+ * The text of a table's change: the table's where its own properties or grid changed, else the changed
+ * rows', read in the selected branch, what Word shows: so a change whose records are all in other
+ * branches has no text (docx4j's `Tables.changeText`, its `aTableChangesTextReadsTheBranchWordReads`).
+ */
 export declare function tableChangeText(tbl: wml.Tbl): string;
-/** Accepting keeps the properties as they are and drops every record; a row's `w:trPr` left empty goes. */
+/** Accepting keeps the properties as they are and drops every record, in every branch; a row's `w:trPr` left empty goes. */
 export declare function acceptTable(tbl: wml.Tbl): void;
 /**
  * Rejecting puts the recorded table back: its properties, its grid, and each row and cell in the
  * change as recorded - a row in the change without a `w:trPrChange` cleared, having had no properties
  * (check 28, from a saved file) - then collapses a merged grid (check 27: a width change records the
  * old cells over a grid of the old and new column edges together). Rows outside the change are left.
+ * Every branch of a kept row- or cell-level `mc:AlternateContent` is restored (CR-013 phase 3).
  */
 export declare function rejectTable(tbl: wml.Tbl): void;
 /** A row's `w:trPr` with nothing left in it goes, as Word writes none. */
@@ -25,6 +30,9 @@ export declare function pruneRow(tr: wml.Tr): void;
 /**
  * Grid columns that no row keeps apart become one: the edges any row's cells (or its `w:gridBefore`
  * and `w:gridAfter`) fall on are kept, the others merged, and each cell's `w:gridSpan` and each row's
- * skipped columns counted again over the kept columns.
+ * skipped columns counted again over the kept columns. The grid is every branch's: every row-level
+ * branch's rows are counted, and a row's cells along each of its layouts (`cellLayoutsOf`, one per
+ * reading of a cell-level `mc:AlternateContent`), every branch spanning the same columns (CR-013 phase 3,
+ * docx4j's `Lister.cellLayoutsOf`; phase 2 counted every branch's cells along one row).
  */
 export declare function collapseGrid(tbl: wml.Tbl): void;