@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/tables/index.js

@@ -0,0 +1,2386 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+export * from './border-style-map';
+export * from './borders';
+export * from './collections';
+export * from './format';
+export * from './paddings';
+export * from './tbl-pr-positioning';
+export * from './tbl-pr';
+export * from './tc-pr';
+export * from './tr-pr';
+import { DetachedObjectError } from '../../core/errors/docx-error';
+import { parseBodyBlocks, serializeBodyBlocks } from '../document/body-blocks';
+import { WordDocument, Body } from '../document/document';
+import { Paragraph } from '../document/paragraph';
+import { registerAlwaysOnBodyFeatureBootstrap } from '../document/body-always-on';
+import { registerBodyItemAdapter } from '../document/body-item-adapters';
+import { registerTypedCollectionHooks } from '../document/typed-body-collections';
+import { elementChildren, isWml, wmlAttr, wmlElement } from '../document/wml';
+import { featureId, registerFeature, registerFeatureBlockHandler, registerFeatureBlockParagraphWalker, visitBlocksInDocumentOrder, } from '../../core/registry/index';
+import { hasAnyCnfStyleFlag, normalizeCnfStyle, parseDecimalVal, readTableCaption, readTableColumnBandSize, readTableDescription, readTableIndent, readTableLayout, readTableLook, readTablePreferredWidth, readTableRowBandSize, readTableShading, readTableStyle, pointToTwips, twipsToPoint, wmlAttrVal, writeTableCaption, writeTableColumnBandSize, writeTableDescription, writeTableIndent, writeTableLayout, writeTableLook, writeTablePreferredWidth, writeTableRowBandSize, writeTableStyle, } from './tbl-pr';
+import { BuiltinTableStyle, ConditionalFormattingType, resolveStyleForTarget, styleCollectionFor, stylesFor, } from '../styles/index';
+import { readRowCnfStyle, readRowHeight, readRowIsHeader, writeRowCnfStyle, writeRowHeight, writeRowIsHeader, } from './tr-pr';
+import { readCellCnfStyle, readCellPreferredWidth, readCellShading, readGridSpan, readVerticalMerge, writeCellCnfStyle, writeCellPreferredWidth, writeCellShading, writeGridSpan, writeVerticalMerge, } from './tc-pr';
+import { CellFormat, RowFormat, TableFormat, } from './format';
+import { TableCellCollection, TableRowCollection, } from './collections';
+/**
+ * AutoFit modes for {@link Table.autoFit}, matching DocIO `AutoFitType`.
+ *
+ * - {@link AutoFitType.FitToContent}: auto layout; clear fixed preferred widths.
+ * - {@link AutoFitType.FitToWindow}: auto layout; table 100% width; cell % widths.
+ * - {@link AutoFitType.FixedColumnWidth}: fixed layout; cell DXA widths from grid.
+ *
+ * @public
+ */
+export var AutoFitType = {
+    FitToContent: 'fitToContent',
+    FitToWindow: 'fitToWindow',
+    FixedColumnWidth: 'fixedColumnWidth',
+};
+function autoWidthZero() {
+    return { type: 'auto', value: twipsToPoint(0) };
+}
+var DEFAULT_GRID_COL_TWIPS = 1440;
+var PCT_100_FIFTIETHS = 5000;
+/** Default page content width in points when no section is available (Letter − 72 − 72). */
+var DEFAULT_PAGE_CLIENT_WIDTH_POINTS = 468;
+/**
+ * Distribute `totalTwips` across `columnCount` equal columns without losing remainder.
+ *
+ * @private
+ */
+function equalColumnTwips(totalTwips, columnCount) {
+    var cols = columnCount > 0 ? columnCount : 1;
+    var safeTotal = totalTwips > 0 ? Math.floor(totalTwips) : DEFAULT_GRID_COL_TWIPS * cols;
+    var base = Math.floor(safeTotal / cols);
+    var remainder = safeTotal - base * cols;
+    var out = [];
+    for (var i = 0; i < cols; i += 1) {
+        out.push(base + (i < remainder ? 1 : 0));
+    }
+    return out;
+}
+/**
+ * Build `w:tblGrid` from explicit column widths in twips.
+ *
+ * @private
+ */
+function tblGridFromTwips(widthsTwips) {
+    var cols = [];
+    for (var i = 0; i < widthsTwips.length; i += 1) {
+        var w = widthsTwips[i];
+        cols.push(wmlElement('gridCol', {
+            attributes: [wmlAttr('w', String(w > 0 ? w : DEFAULT_GRID_COL_TWIPS))],
+        }));
+    }
+    return wmlElement('tblGrid', { children: cols });
+}
+var TABLES = featureId('tables');
+function cellColumnSpan(cell) {
+    var span = cell.gridSpan;
+    return span !== undefined && span > 0 ? span : 1;
+}
+function findCoveringCell(row, gridColumn) {
+    var cursor = 0;
+    var cells = row.listCells();
+    for (var i = 0; i < cells.length; i += 1) {
+        var cell = cells[i];
+        if (cell === undefined) {
+            continue;
+        }
+        var span = cellColumnSpan(cell);
+        if (gridColumn >= cursor && gridColumn < cursor + span) {
+            return { cell: cell, startColumn: cursor, cellIndex: i };
+        }
+        cursor += span;
+    }
+    return undefined;
+}
+function cellStartColumn(row, target) {
+    var cursor = 0;
+    var cells = row.listCells();
+    for (var i = 0; i < cells.length; i += 1) {
+        var cell = cells[i];
+        if (cell === target) {
+            return cursor;
+        }
+        cursor += cellColumnSpan(cell);
+    }
+    return -1;
+}
+function cellHasVisibleText(cell) {
+    return cell.text.trim().length > 0;
+}
+/**
+ * A table — ordered grid of rows and cells with table-level formatting.
+ *
+ * Create with {@link Body.appendTable} then size via {@link Table.resetCells}.
+ *
+ * @public
+ */
+var Table = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function Table(prefixMarkup, tblPr, tblGrid, rows) {
+        this.prefixMarkup = prefixMarkup;
+        this.tblPr = tblPr;
+        this.tblGrid = tblGrid;
+        this.tableRows = rows;
+        this.documentOwner = undefined;
+        this.rowsInstance = new TableRowCollection(this);
+        this.tableFormatInstance = new TableFormat(this);
+        this.conditionalFormattingDirty = false;
+    }
+    Object.defineProperty(Table.prototype, "rows", {
+        /** Rows collection (DocIO-aligned). */
+        get: function () {
+            return this.rowsInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    Table.prototype.listRows = function () {
+        return this.tableRows;
+    };
+    /**
+     * @private
+     */
+    Table.prototype.replaceRows = function (rows) {
+        if (rows.length < 1) {
+            throw new DetachedObjectError('A table must retain at least one row');
+        }
+        var previous = this.tableRows;
+        for (var i = 0; i < previous.length; i += 1) {
+            if (rows.indexOf(previous[i]) === -1) {
+                previous[i].setOwnerTable(undefined);
+            }
+        }
+        this.tableRows = rows;
+        for (var i = 0; i < rows.length; i += 1) {
+            rows[i].setOwnerTable(this);
+        }
+        this.rowsInstance.syncFromHost();
+        this.markConditionalFormattingDirty();
+    };
+    /**
+     * @private
+     */
+    Table.prototype.createEmptyRow = function () {
+        return this.buildEmptyRow();
+    };
+    /**
+     * @private
+     */
+    Table.prototype.bindRow = function (row) {
+        row.setOwnerTable(this);
+        if (this.documentOwner !== undefined) {
+            row.bindDocument(this.documentOwner);
+            var cells = row.listCells();
+            for (var i = 0; i < cells.length; i += 1) {
+                cells[i].bindDocument(this.documentOwner);
+            }
+        }
+    };
+    /**
+     * @private
+     */
+    Table.prototype.minRowCount = function () {
+        return 1;
+    };
+    /**
+     * @private
+     */
+    Table.prototype.readTblPr = function () {
+        return this.tblPr;
+    };
+    /**
+     * @private
+     */
+    Table.prototype.writeTblPr = function (next) {
+        this.tblPr = next;
+    };
+    /**
+     * DocIO parity: copy table back fill onto every cell as direct `w:tcPr/w:shd`
+     * (`val="clear"` `color="auto"` `fill=<wire>`). Clearing table backColor
+     * removes cell fills that still match the previous painted fill so independent
+     * cell colors are left alone when possible.
+     *
+     * @private
+     */
+    Table.prototype.applyTableBackColorToCells = function (fill) {
+        var rows = this.tableRows;
+        for (var r = 0; r < rows.length; r += 1) {
+            var cells = rows[r].listCells();
+            for (var c = 0; c < cells.length; c += 1) {
+                var cell = cells[c];
+                var prev = readCellShading(cell.readTcPr());
+                if (fill === undefined) {
+                    // Clear only when the cell has no independent shading beyond
+                    // the DocIO-shaped clear/auto bag (or empty fill).
+                    if (prev === undefined) {
+                        continue;
+                    }
+                    var onlyPaintedFill = (prev.pattern === undefined || prev.pattern === 'clear') &&
+                        (prev.color === undefined || prev.color === 'auto');
+                    if (!onlyPaintedFill) {
+                        continue;
+                    }
+                    cell.writeTcPr(writeCellShading(cell.readTcPr(), undefined));
+                    continue;
+                }
+                var pattern = prev !== undefined &&
+                    prev.pattern !== undefined &&
+                    prev.pattern.length > 0
+                    ? prev.pattern
+                    : 'clear';
+                var color = prev !== undefined && prev.color !== undefined && prev.color.length > 0
+                    ? prev.color
+                    : 'auto';
+                var next = {
+                    fill: fill,
+                    color: color,
+                    pattern: pattern,
+                };
+                cell.writeTcPr(writeCellShading(cell.readTcPr(), next));
+            }
+        }
+    };
+    Object.defineProperty(Table.prototype, "tableFormat", {
+        /** Table-level format facade. */
+        get: function () {
+            return this.tableFormatInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "title", {
+        /**
+         * Accessibility title (`w:tblCaption`). Formerly `caption`.
+         */
+        get: function () {
+            return readTableCaption(this.tblPr);
+        },
+        set: function (value) {
+            this.tblPr = writeTableCaption(this.tblPr, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "description", {
+        get: function () {
+            return readTableDescription(this.tblPr);
+        },
+        set: function (value) {
+            this.tblPr = writeTableDescription(this.tblPr, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "indentFromLeft", {
+        /**
+         * Left indent in points (`w:tblInd`). Formerly `indent`.
+         */
+        get: function () {
+            return readTableIndent(this.tblPr);
+        },
+        set: function (value) {
+            this.tblPr = writeTableIndent(this.tblPr, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "width", {
+        /**
+         * Effective table width in points from the sum of grid column widths
+         * (`w:tblGrid`). When a fixed DXA preferred width is set, that value is
+         * written on the setter; the getter always reports the grid sum.
+         */
+        get: function () {
+            var gridWidths = this.gridColumnWidthsTwips();
+            var totalTwips = 0;
+            for (var i = 0; i < gridWidths.length; i += 1) {
+                totalTwips += gridWidths[i];
+            }
+            if (totalTwips <= 0) {
+                return 0;
+            }
+            return twipsToPoint(totalTwips);
+        },
+        set: function (value) {
+            if (!isFinite(value) || value < 0) {
+                throw new RangeError('Table width must be a non-negative finite number of points, got ' + String(value));
+            }
+            this.tblPr = writeTablePreferredWidth(this.tblPr, {
+                type: 'dxa',
+                value: value,
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "preferredWidth", {
+        /**
+         * @private
+         */
+        get: function () {
+            return readTablePreferredWidth(this.tblPr);
+        },
+        set: function (value) {
+            this.tblPr = writeTablePreferredWidth(this.tblPr, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "layout", {
+        /**
+         * @private
+         */
+        get: function () {
+            return readTableLayout(this.tblPr);
+        },
+        set: function (value) {
+            this.tblPr = writeTableLayout(this.tblPr, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "look", {
+        /**
+         * @private
+         */
+        get: function () {
+            return readTableLook(this.tblPr);
+        },
+        set: function (value) {
+            this.tblPr = writeTableLook(this.tblPr, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "rowBandSize", {
+        /**
+         * Rows per table-style horizontal band (`w:tblStyleRowBandSize/@w:val`).
+         *
+         * Absent on the wire reads as `undefined` (Word default band height is 1).
+         * Setting `undefined` removes the element. Non-finite values throw
+         * `RangeError`. Does not recompute conditional formatting masks.
+         *
+         * @public
+         */
+        get: function () {
+            return readTableRowBandSize(this.tblPr);
+        },
+        set: function (value) {
+            if (value !== undefined && !isFinite(value)) {
+                throw new RangeError('Table rowBandSize must be a finite number or undefined, got ' + String(value));
+            }
+            this.tblPr = writeTableRowBandSize(this.tblPr, value !== undefined ? Math.trunc(value) : undefined);
+            this.markConditionalFormattingDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "columnBandSize", {
+        /**
+         * Columns per table-style vertical band (`w:tblStyleColBandSize/@w:val`).
+         *
+         * Absent on the wire reads as `undefined` (Word default band width is 1).
+         * Setting `undefined` removes the element. Non-finite values throw
+         * `RangeError`. Does not recompute conditional formatting masks.
+         *
+         * @public
+         */
+        get: function () {
+            return readTableColumnBandSize(this.tblPr);
+        },
+        set: function (value) {
+            if (value !== undefined && !isFinite(value)) {
+                throw new RangeError('Table columnBandSize must be a finite number or undefined, got ' + String(value));
+            }
+            this.tblPr = writeTableColumnBandSize(this.tblPr, value !== undefined ? Math.trunc(value) : undefined);
+            this.markConditionalFormattingDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "styleId", {
+        /**
+         * Canonical table style id (`w:tblStyle/@w:val`), when assigned.
+         *
+         * @public
+         */
+        get: function () {
+            return readTableStyle(this.tblPr);
+        },
+        set: function (value) {
+            this.tblPr = writeTableStyle(this.tblPr, value);
+            this.markConditionalFormattingDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "styleName", {
+        /**
+         * Style id of the applied table style (`w:tblStyle/@w:val`).
+         * Matches the id written by {@link Table.applyStyle} / authoring defaults
+         * (e.g. `TableGrid`, `LightShading`). Absent style → `undefined`.
+         *
+         * @public
+         */
+        get: function () {
+            return readTableStyle(this.tblPr);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Apply a built-in, custom, or named table style to this table.
+     *
+     * Resolves the style through the document styles collection, materializing
+     * built-in definitions when needed, and writes `w:tblPr/w:tblStyle`.
+     * Does not change table-look application options.
+     *
+     * @param style Built-in id, live {@link TableStyle}, or style id / name string.
+     * @throws DetachedObjectError when the table is not bound to a document.
+     * @public
+     */
+    Table.prototype.applyStyle = function (style) {
+        if (this.documentOwner === undefined) {
+            throw new DetachedObjectError('Cannot apply a table style to a table that is not attached to a document');
+        }
+        var requested;
+        if (typeof style === 'string') {
+            requested = style;
+        }
+        else {
+            requested = style.styleId;
+        }
+        var resolved = resolveStyleForTarget(stylesFor(this.documentOwner), requested, 'table');
+        this.tblPr = writeTableStyle(this.tblPr, resolved.styleId);
+        this.markConditionalFormattingDirty();
+    };
+    Object.defineProperty(Table.prototype, "applyStyleForFirstRow", {
+        /**
+         * Whether the assigned table style applies first-row conditional formatting.
+         * Maps to `w:tblLook/@w:firstRow`. Absent look → `false`.
+         *
+         * @public
+         */
+        get: function () {
+            var look = this.look;
+            return look !== undefined && look.firstRow === true;
+        },
+        set: function (value) {
+            this.mergeTableLook({ firstRow: value === true });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "applyStyleForLastRow", {
+        /**
+         * Whether the assigned table style applies last-row conditional formatting.
+         * Maps to `w:tblLook/@w:lastRow`. Absent look → `false`.
+         *
+         * @public
+         */
+        get: function () {
+            var look = this.look;
+            return look !== undefined && look.lastRow === true;
+        },
+        set: function (value) {
+            this.mergeTableLook({ lastRow: value === true });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "applyStyleForFirstColumn", {
+        /**
+         * Whether the assigned table style applies first-column conditional formatting.
+         * Maps to `w:tblLook/@w:firstColumn`. Absent look → `false`.
+         *
+         * @public
+         */
+        get: function () {
+            var look = this.look;
+            return look !== undefined && look.firstCol === true;
+        },
+        set: function (value) {
+            this.mergeTableLook({ firstCol: value === true });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "applyStyleForLastColumn", {
+        /**
+         * Whether the assigned table style applies last-column conditional formatting.
+         * Maps to `w:tblLook/@w:lastColumn`. Absent look → `false`.
+         *
+         * @public
+         */
+        get: function () {
+            var look = this.look;
+            return look !== undefined && look.lastCol === true;
+        },
+        set: function (value) {
+            this.mergeTableLook({ lastCol: value === true });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "applyStyleForBandedRows", {
+        /**
+         * Whether the assigned table style applies horizontal band formatting to
+         * alternating table rows. Maps inversely to `w:tblLook/@w:noHBand`.
+         * Absent look → `true`.
+         *
+         * @public
+         */
+        get: function () {
+            var look = this.look;
+            if (look === undefined) {
+                return true;
+            }
+            return look.noHBand !== true;
+        },
+        set: function (value) {
+            this.mergeTableLook({ noHBand: value !== true });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Table.prototype, "applyStyleForBandedColumns", {
+        /**
+         * Whether the assigned table style applies vertical band formatting to
+         * alternating table columns. Maps inversely to `w:tblLook/@w:noVBand`.
+         * Absent look → `true`.
+         *
+         * @public
+         */
+        get: function () {
+            var look = this.look;
+            if (look === undefined) {
+                return true;
+            }
+            return look.noVBand !== true;
+        },
+        set: function (value) {
+            this.mergeTableLook({ noVBand: value !== true });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Merge one or more `w:tblLook` flags without clearing unrelated flags.
+     *
+     * @private
+     */
+    Table.prototype.mergeTableLook = function (partial) {
+        var current = this.look;
+        var next = {
+            firstRow: partial.firstRow !== undefined
+                ? partial.firstRow
+                : current !== undefined ? current.firstRow : undefined,
+            lastRow: partial.lastRow !== undefined
+                ? partial.lastRow
+                : current !== undefined ? current.lastRow : undefined,
+            firstCol: partial.firstCol !== undefined
+                ? partial.firstCol
+                : current !== undefined ? current.firstCol : undefined,
+            lastCol: partial.lastCol !== undefined
+                ? partial.lastCol
+                : current !== undefined ? current.lastCol : undefined,
+            noHBand: partial.noHBand !== undefined
+                ? partial.noHBand
+                : current !== undefined ? current.noHBand : undefined,
+            noVBand: partial.noVBand !== undefined
+                ? partial.noVBand
+                : current !== undefined ? current.noVBand : undefined,
+        };
+        this.tblPr = writeTableLook(this.tblPr, next);
+        this.markConditionalFormattingDirty();
+    };
+    /**
+     * Marks row and cell conditional style membership for recalculation.
+     * Paragraph `w:pPr/w:cnfStyle` is not authored on dirty paths (DocIO parity).
+     *
+     * @private
+     */
+    Table.prototype.markConditionalFormattingDirty = function () {
+        this.conditionalFormattingDirty = true;
+    };
+    /**
+     * Recalculate conditional table-style membership masks on rows and cells
+     * (`w:trPr` / `w:tcPr`). Does not write `w:pPr/w:cnfStyle` — DocIO emits
+     * membership on row/cell only; paragraph cnf is cleared when styles are
+     * removed or when a dirty recompute runs so authored output stays clean.
+     * Nested tables own their own cascade.
+     *
+     * @private
+     */
+    Table.prototype.updateConditionalFormatting = function () {
+        var styleId = this.styleId;
+        var rows = this.tableRows;
+        var rowCount = rows.length;
+        var clearParagraphCnf = function (cell) {
+            var paragraphs = cell.listParagraphs();
+            for (var p = 0; p < paragraphs.length; p += 1) {
+                paragraphs[p].setConditionalFormatting(undefined);
+            }
+        };
+        var clearAllCnf = function () {
+            for (var r = 0; r < rowCount; r += 1) {
+                var row = rows[r];
+                row.setConditionalFormatting(undefined);
+                var cells = row.listCells();
+                for (var c = 0; c < cells.length; c += 1) {
+                    var cell = cells[c];
+                    cell.setConditionalFormatting(undefined);
+                    clearParagraphCnf(cell);
+                }
+            }
+        };
+        if (styleId === undefined || styleId.length === 0) {
+            clearAllCnf();
+            this.conditionalFormattingDirty = false;
+            return;
+        }
+        var tableStyle;
+        var doc = this.documentOwner;
+        if (doc !== undefined) {
+            try {
+                tableStyle = styleCollectionFor(doc).getTableStyle(styleId);
+            }
+            catch (_e) {
+                tableStyle = undefined;
+            }
+        }
+        if (tableStyle === undefined) {
+            // No resolvable table style: preserve source cnf unless dirty.
+            this.conditionalFormattingDirty = false;
+            return;
+        }
+        var condStyles = tableStyle.conditionalFormattingStyles;
+        if (condStyles.count === 0) {
+            this.conditionalFormattingDirty = false;
+            return;
+        }
+        var hasType = function (type) {
+            return condStyles.findByType(type) !== undefined;
+        };
+        var applyFirstRow = this.applyStyleForFirstRow;
+        var applyLastRow = this.applyStyleForLastRow;
+        var applyFirstCol = this.applyStyleForFirstColumn;
+        var applyLastCol = this.applyStyleForLastColumn;
+        var applyHBand = this.applyStyleForBandedRows;
+        var applyVBand = this.applyStyleForBandedColumns;
+        for (var r = 0; r < rowCount; r += 1) {
+            var row = rows[r];
+            var rowIndex = r;
+            // Row trPr cnf: row-level flags only (existing band-size-aware path
+            // retained for trPr; gated on style conditional types).
+            var isFirstRow = hasType(ConditionalFormattingType.FirstRow) && applyFirstRow && rowIndex === 0;
+            var isLastRow = hasType(ConditionalFormattingType.LastRow) &&
+                applyLastRow &&
+                rowIndex !== 0 &&
+                rowIndex === rowCount - 1;
+            var oddHBand = false;
+            var evenHBand = false;
+            if (hasType(ConditionalFormattingType.OddRowBand) &&
+                applyHBand &&
+                rowIndex !== rowCount - 1 &&
+                rowIndex % 2 === 1) {
+                oddHBand = true;
+            }
+            if (hasType(ConditionalFormattingType.EvenRowBand) &&
+                applyHBand &&
+                rowIndex !== 0 &&
+                rowIndex !== rowCount - 1 &&
+                rowIndex % 2 === 0) {
+                evenHBand = true;
+            }
+            var rowFlags = normalizeCnfStyle({
+                firstRow: isFirstRow,
+                lastRow: isLastRow,
+                oddHBand: oddHBand,
+                evenHBand: evenHBand,
+            });
+            row.setConditionalFormatting(rowFlags);
+            var cells = row.listCells();
+            var cellCount = cells.length;
+            for (var c = 0; c < cellCount; c += 1) {
+                var cell = cells[c];
+                var cellIndex = c;
+                var cellState = normalizeCnfStyle({
+                    firstColumn: hasType(ConditionalFormattingType.FirstColumn) &&
+                        cellIndex === 0 &&
+                        applyFirstCol,
+                    lastColumn: hasType(ConditionalFormattingType.LastColumn) &&
+                        cellIndex !== 0 &&
+                        cellIndex === cellCount - 1 &&
+                        applyLastCol,
+                    oddVBand: hasType(ConditionalFormattingType.OddColumnBand) &&
+                        cellIndex !== cellCount - 1 &&
+                        cellIndex % 2 === 1 &&
+                        applyVBand,
+                    evenVBand: hasType(ConditionalFormattingType.EvenColumnBand) &&
+                        cellIndex !== 0 &&
+                        cellIndex !== cellCount - 1 &&
+                        cellIndex % 2 === 0 &&
+                        applyVBand,
+                    firstRowLastColumn: hasType(ConditionalFormattingType.TopRightCell) &&
+                        rowIndex === 0 &&
+                        cellIndex !== 0 &&
+                        cellIndex === cellCount - 1 &&
+                        applyFirstRow &&
+                        applyLastCol,
+                    firstRowFirstColumn: hasType(ConditionalFormattingType.TopLeftCell) &&
+                        rowIndex === 0 &&
+                        cellIndex === 0 &&
+                        applyFirstRow &&
+                        applyFirstCol,
+                    lastRowLastColumn: hasType(ConditionalFormattingType.BottomRightCell) &&
+                        rowIndex !== 0 &&
+                        rowIndex === rowCount - 1 &&
+                        cellIndex !== 0 &&
+                        cellIndex === cellCount - 1 &&
+                        applyLastRow &&
+                        applyLastCol,
+                    lastRowFirstColumn: hasType(ConditionalFormattingType.BottomLeftCell) &&
+                        rowIndex !== 0 &&
+                        rowIndex === rowCount - 1 &&
+                        cellIndex === 0 &&
+                        applyLastRow &&
+                        applyFirstCol,
+                });
+                // DocIO writes cnf on trPr/tcPr only — never author pPr/cnfStyle.
+                if (hasAnyCnfStyleFlag(cellState)) {
+                    cell.setConditionalFormatting(cellState);
+                }
+                else {
+                    cell.setConditionalFormatting(undefined);
+                }
+                clearParagraphCnf(cell);
+            }
+        }
+        this.conditionalFormattingDirty = false;
+    };
+    Object.defineProperty(Table.prototype, "owner", {
+        /**
+         * Owning document when bound.
+         *
+         * @private
+         */
+        get: function () {
+            return this.documentOwner;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Rebuild the table to `rowCount` × `columnCount` empty cells.
+     *
+     * Authoring path: empty cells (no auto paragraph), fixed layout, equal
+     * client-width columns, and `TableGrid` when document-bound.
+     */
+    Table.prototype.resetCells = function (rowCount, columnCount) {
+        if (rowCount < 1 || columnCount < 1) {
+            throw new RangeError('Table must have at least one row and one column');
+        }
+        var rows = [];
+        for (var r = 0; r < rowCount; r += 1) {
+            rows.push(this.buildEmptyRowWithColumns(columnCount));
+        }
+        this.tableRows = rows;
+        this.rowsInstance.syncFromHost();
+        if (this.documentOwner !== undefined) {
+            this.bindDocument(this.documentOwner);
+        }
+        applyAuthoringTableDefaults(this, columnCount);
+        // DocIO paints table backColor onto every cell; rebuilds must re-apply
+        // because paint-at-setter only walks cells that existed when backColor was set.
+        this.reapplyTableBackColorToCells();
+        this.markConditionalFormattingDirty();
+    };
+    Table.prototype.autoFit = function (autoFitType) {
+        switch (autoFitType) {
+            case AutoFitType.FitToContent:
+                this.applyFitToContent();
+                return;
+            case AutoFitType.FitToWindow:
+                this.applyFitToWindow();
+                return;
+            case AutoFitType.FixedColumnWidth:
+                this.applyFixedColumnWidth();
+                return;
+            default: {
+                var _exhaustive = autoFitType;
+                throw new RangeError('Unsupported AutoFitType: ' + String(_exhaustive));
+            }
+        }
+    };
+    /**
+     * Append an empty row with the current column count.
+     * Prefer {@link Table.rows}.add for new code.
+     */
+    Table.prototype.appendRow = function () {
+        return this.rowsInstance.add();
+    };
+    /**
+     * Insert an empty row at `index` (0 … rows.length inclusive).
+     * Prefer {@link Table.rows}.insert for new code.
+     */
+    Table.prototype.insertRow = function (index) {
+        return this.rowsInstance.insert(index);
+    };
+    /**
+     * Remove a row that currently belongs to this table.
+     * Prefer {@link Table.rows}.remove for new code.
+     */
+    Table.prototype.removeRow = function (row) {
+        this.rowsInstance.remove(row);
+    };
+    /**
+     * Merge contiguous structural cells in one row (inclusive cell indexes).
+     */
+    Table.prototype.applyHorizontalMerge = function (rowIndex, startCellIndex, endCellIndex) {
+        if (!Number.isInteger(rowIndex) ||
+            !Number.isInteger(startCellIndex) ||
+            !Number.isInteger(endCellIndex)) {
+            throw new RangeError('applyHorizontalMerge indexes must be integers');
+        }
+        if (startCellIndex > endCellIndex) {
+            throw new RangeError('applyHorizontalMerge range is inverted or empty');
+        }
+        var row = this.tableRows[rowIndex];
+        if (row === undefined) {
+            throw new RangeError('applyHorizontalMerge row index is out of bounds');
+        }
+        var cells = row.listCells();
+        if (startCellIndex < 0 || endCellIndex >= cells.length) {
+            throw new RangeError('applyHorizontalMerge cell index is out of bounds');
+        }
+        if (startCellIndex === endCellIndex) {
+            return;
+        }
+        var startCell = cells[startCellIndex];
+        var endCell = cells[endCellIndex];
+        var fromColumn = cellStartColumn(row, startCell);
+        var toColumn = cellStartColumn(row, endCell) + cellColumnSpan(endCell) - 1;
+        if (fromColumn < 0 || toColumn < fromColumn) {
+            throw new RangeError('applyHorizontalMerge could not resolve grid columns');
+        }
+        this.mergeCells({
+            fromRow: rowIndex,
+            fromColumn: fromColumn,
+            toRow: rowIndex,
+            toColumn: toColumn,
+        });
+    };
+    /**
+     * Vertical merge along one grid column across inclusive row indexes.
+     */
+    Table.prototype.applyVerticalMerge = function (columnIndex, startRowIndex, endRowIndex) {
+        if (!Number.isInteger(columnIndex) ||
+            !Number.isInteger(startRowIndex) ||
+            !Number.isInteger(endRowIndex)) {
+            throw new RangeError('applyVerticalMerge indexes must be integers');
+        }
+        if (startRowIndex > endRowIndex) {
+            throw new RangeError('applyVerticalMerge range is inverted or empty');
+        }
+        if (startRowIndex < 0 || endRowIndex >= this.tableRows.length) {
+            throw new RangeError('applyVerticalMerge row index is out of bounds');
+        }
+        if (columnIndex < 0 || columnIndex >= this.columnCount()) {
+            throw new RangeError('applyVerticalMerge column index is out of bounds');
+        }
+        if (startRowIndex === endRowIndex) {
+            return;
+        }
+        this.mergeCells({
+            fromRow: startRowIndex,
+            fromColumn: columnIndex,
+            toRow: endRowIndex,
+            toColumn: columnIndex,
+        });
+    };
+    /**
+     * @private
+     */
+    Table.prototype.mergeCells = function (range) {
+        var __ts33_0;
+        var __ts33_1;
+        var fromRow = range.fromRow;
+        var fromColumn = range.fromColumn;
+        var toRow = range.toRow;
+        var toColumn = range.toColumn;
+        if (!Number.isInteger(fromRow) ||
+            !Number.isInteger(fromColumn) ||
+            !Number.isInteger(toRow) ||
+            !Number.isInteger(toColumn)) {
+            throw new RangeError('mergeCells range coordinates must be integers');
+        }
+        if (fromRow > toRow || fromColumn > toColumn) {
+            throw new RangeError('mergeCells range is inverted or empty');
+        }
+        if (fromRow < 0 || fromColumn < 0 || toRow >= this.tableRows.length) {
+            throw new RangeError('mergeCells range is out of bounds');
+        }
+        var colCount = this.columnCount();
+        if (toColumn >= colCount) {
+            throw new RangeError('mergeCells range is out of bounds');
+        }
+        var rowSpan = toRow - fromRow + 1;
+        var colSpan = toColumn - fromColumn + 1;
+        if (rowSpan === 1 && colSpan === 1) {
+            var singleRow = this.tableRows[fromRow];
+            if (singleRow === undefined) {
+                throw new RangeError('mergeCells range is out of bounds');
+            }
+            var single = findCoveringCell(singleRow, fromColumn);
+            if (single === undefined) {
+                throw new RangeError('mergeCells range is out of bounds');
+            }
+            return single.cell;
+        }
+        var absorbed = [];
+        var origin;
+        for (var r = fromRow; r <= toRow; r += 1) {
+            var row = this.tableRows[r];
+            if (row === undefined) {
+                throw new RangeError('mergeCells range is out of bounds');
+            }
+            var c = fromColumn;
+            while (c <= toColumn) {
+                var hit = findCoveringCell(row, c);
+                if (hit === undefined) {
+                    throw new RangeError('mergeCells range is out of bounds');
+                }
+                if (hit.startColumn < fromColumn ||
+                    hit.startColumn + cellColumnSpan(hit.cell) - 1 > toColumn) {
+                    throw new RangeError('mergeCells range partially overlaps an existing merged cell');
+                }
+                if (r === fromRow && hit.startColumn === fromColumn) {
+                    origin = hit.cell;
+                }
+                else if (hit.cell !== origin) {
+                    absorbed.push(hit.cell);
+                }
+                c = hit.startColumn + cellColumnSpan(hit.cell);
+            }
+        }
+        if (origin === undefined) {
+            throw new RangeError('mergeCells could not resolve origin cell');
+        }
+        for (var ai = 0; ai < absorbed.length; ai += 1) {
+            this.moveCellContentInto(origin, absorbed[ai]);
+        }
+        var preMergeSpan = new Map();
+        for (var r = fromRow; r <= toRow; r += 1) {
+            var snapRow = this.tableRows[r];
+            if (snapRow === undefined) {
+                throw new RangeError('mergeCells range is out of bounds');
+            }
+            var snapCells = snapRow.listCells();
+            for (var si = 0; si < snapCells.length; si += 1) {
+                var cell = snapCells[si];
+                preMergeSpan.set(cell, cellColumnSpan(cell));
+            }
+        }
+        if (colSpan > 1) {
+            origin.gridSpan = colSpan;
+        }
+        else {
+            origin.gridSpan = undefined;
+        }
+        if (rowSpan > 1) {
+            origin.verticalMerge = 'restart';
+        }
+        else {
+            origin.verticalMerge = undefined;
+        }
+        for (var r = fromRow; r <= toRow; r += 1) {
+            var row = this.tableRows[r];
+            if (row === undefined) {
+                throw new RangeError('mergeCells range is out of bounds');
+            }
+            var keep = [];
+            var cursor = 0;
+            var placedMergeCell = false;
+            var rowCells = row.listCells();
+            for (var ci = 0; ci < rowCells.length; ci += 1) {
+                var cell = rowCells[ci];
+                var span = ((__ts33_0 = preMergeSpan.get(cell)), __ts33_0 != null ? __ts33_0 : cellColumnSpan(cell));
+                var cellStart = cursor;
+                var cellEnd = cursor + span - 1;
+                cursor += span;
+                var overlaps = cellEnd >= fromColumn && cellStart <= toColumn;
+                if (!overlaps) {
+                    keep.push(cell);
+                    continue;
+                }
+                if (r === fromRow && cell === origin) {
+                    keep.push(cell);
+                    placedMergeCell = true;
+                    continue;
+                }
+                if (r > fromRow && cellStart === fromColumn && !placedMergeCell) {
+                    cell.gridSpan = colSpan > 1 ? colSpan : undefined;
+                    cell.verticalMerge = 'continue';
+                    this.ensureAtLeastOneParagraph(cell);
+                    keep.push(cell);
+                    placedMergeCell = true;
+                    continue;
+                }
+            }
+            if (r > fromRow && !placedMergeCell) {
+                var contCell = this.createBoundEmptyCell();
+                contCell.gridSpan = colSpan > 1 ? colSpan : undefined;
+                contCell.verticalMerge = 'continue';
+                var insertAt = 0;
+                var g = 0;
+                while (insertAt < keep.length && g < fromColumn) {
+                    var kept = keep[insertAt];
+                    if (kept === undefined) {
+                        break;
+                    }
+                    g += ((__ts33_1 = preMergeSpan.get(kept)), __ts33_1 != null ? __ts33_1 : cellColumnSpan(kept));
+                    insertAt += 1;
+                }
+                keep.splice(insertAt, 0, contCell);
+            }
+            if (keep.length < 1) {
+                throw new DetachedObjectError('mergeCells would leave a row with no cells');
+            }
+            row.replaceCells(keep);
+        }
+        this.markConditionalFormattingDirty();
+        return origin;
+    };
+    /**
+     * @private
+     */
+    Table.prototype.splitCell = function (cell) {
+        var region = this.getMergeRegion(cell);
+        if (region === undefined || region.origin !== cell) {
+            throw new RangeError('splitCell requires a merge origin cell in this table');
+        }
+        var fromRow = region.fromRow;
+        var fromColumn = region.fromColumn;
+        var toRow = region.toRow;
+        var toColumn = region.toColumn;
+        var released = [];
+        var regionCells = [region.origin];
+        for (var i = 0; i < region.continuations.length; i += 1) {
+            regionCells.push(region.continuations[i]);
+        }
+        for (var r = fromRow; r <= toRow; r += 1) {
+            var row = this.tableRows[r];
+            if (row === undefined) {
+                continue;
+            }
+            var next = [];
+            var cursor = 0;
+            var structuralCells = row.listCells();
+            for (var si = 0; si < structuralCells.length; si += 1) {
+                var structural = structuralCells[si];
+                var span = cellColumnSpan(structural);
+                var start = cursor;
+                cursor += span;
+                var inRegion = false;
+                for (var ri = 0; ri < regionCells.length; ri += 1) {
+                    if (regionCells[ri] === structural) {
+                        inRegion = true;
+                        break;
+                    }
+                }
+                if (!inRegion) {
+                    next.push(structural);
+                    continue;
+                }
+                for (var c = start; c < start + span; c += 1) {
+                    if (c < fromColumn || c > toColumn) {
+                        var piece_1 = this.createBoundEmptyCell();
+                        next.push(piece_1);
+                        released.push(piece_1);
+                        continue;
+                    }
+                    var piece = void 0;
+                    if (r === fromRow && c === fromColumn) {
+                        piece = region.origin;
+                        piece.gridSpan = undefined;
+                        piece.verticalMerge = undefined;
+                    }
+                    else if (c === start && structural !== region.origin) {
+                        piece = structural;
+                        piece.gridSpan = undefined;
+                        piece.verticalMerge = undefined;
+                        this.ensureAtLeastOneParagraph(piece);
+                    }
+                    else {
+                        piece = this.createBoundEmptyCell();
+                    }
+                    next.push(piece);
+                    released.push(piece);
+                }
+            }
+            if (next.length < 1) {
+                throw new DetachedObjectError('splitCell would leave a row with no cells');
+            }
+            row.replaceCells(next);
+        }
+        this.markConditionalFormattingDirty();
+        return released;
+    };
+    /**
+     * @private
+     */
+    Table.prototype.getMergeRegion = function (cell) {
+        var rowIndex = -1;
+        for (var i = 0; i < this.tableRows.length; i += 1) {
+            var rowCells = this.tableRows[i] == null ? undefined : this.tableRows[i].listCells();
+            if (rowCells !== undefined && rowCells.indexOf(cell) !== -1) {
+                rowIndex = i;
+                break;
+            }
+        }
+        if (rowIndex < 0) {
+            return undefined;
+        }
+        var row = this.tableRows[rowIndex];
+        if (row === undefined) {
+            return undefined;
+        }
+        var startCol = cellStartColumn(row, cell);
+        if (startCol < 0) {
+            return undefined;
+        }
+        var span = cellColumnSpan(cell);
+        var vMerge = cell.verticalMerge;
+        if (span <= 1 && vMerge === undefined) {
+            return undefined;
+        }
+        var originRow = rowIndex;
+        var originCell = cell;
+        if (vMerge === 'continue') {
+            var foundRestart = false;
+            for (var r = rowIndex - 1; r >= 0; r -= 1) {
+                var aboveRow = this.tableRows[r];
+                if (aboveRow === undefined) {
+                    break;
+                }
+                var above = findCoveringCell(aboveRow, startCol);
+                if (above === undefined || above.startColumn !== startCol) {
+                    break;
+                }
+                if (cellColumnSpan(above.cell) !== span) {
+                    break;
+                }
+                if (above.cell.verticalMerge === 'restart') {
+                    originRow = r;
+                    originCell = above.cell;
+                    foundRestart = true;
+                    break;
+                }
+                if (above.cell.verticalMerge === 'continue') {
+                    continue;
+                }
+                break;
+            }
+            if (!foundRestart) {
+                return {
+                    fromRow: rowIndex,
+                    fromColumn: startCol,
+                    toRow: rowIndex,
+                    toColumn: startCol + span - 1,
+                    origin: cell,
+                    continuations: [],
+                };
+            }
+        }
+        var originSpan = cellColumnSpan(originCell);
+        var originRowObj = this.tableRows[originRow];
+        if (originRowObj === undefined) {
+            return undefined;
+        }
+        var fromColumn = cellStartColumn(originRowObj, originCell);
+        if (fromColumn < 0) {
+            return undefined;
+        }
+        var toColumn = fromColumn + originSpan - 1;
+        var toRow = originRow;
+        var continuations = [];
+        if (originCell.verticalMerge === 'restart') {
+            for (var r = originRow + 1; r < this.tableRows.length; r += 1) {
+                var contRow = this.tableRows[r];
+                if (contRow === undefined) {
+                    break;
+                }
+                var hit = findCoveringCell(contRow, fromColumn);
+                if (hit === undefined ||
+                    hit.startColumn !== fromColumn ||
+                    cellColumnSpan(hit.cell) !== originSpan ||
+                    hit.cell.verticalMerge !== 'continue') {
+                    break;
+                }
+                toRow = r;
+                continuations.push(hit.cell);
+            }
+        }
+        if (originSpan <= 1 && originCell.verticalMerge === undefined) {
+            return undefined;
+        }
+        return {
+            fromRow: originRow,
+            fromColumn: fromColumn,
+            toRow: toRow,
+            toColumn: toColumn,
+            origin: originCell,
+            continuations: continuations,
+        };
+    };
+    Table.prototype.moveCellContentInto = function (target, source) {
+        if (target === source) {
+            return;
+        }
+        var needBreak = cellHasVisibleText(target) && cellHasVisibleText(source);
+        if (needBreak) {
+            var br = new Paragraph(undefined);
+            target.appendRawBlock({ type: 'paragraph', paragraph: br });
+        }
+        var moved = source.listBlocks().slice();
+        source.replaceItems([]);
+        for (var i = 0; i < moved.length; i += 1) {
+            target.appendRawBlock(moved[i]);
+        }
+        this.ensureAtLeastOneParagraph(source);
+    };
+    Table.prototype.ensureAtLeastOneParagraph = function (cell) {
+        // Merge path only: WordprocessingML cells require ≥1 paragraph after content moves.
+        if (cell.listParagraphs().length === 0) {
+            cell.appendParagraph();
+        }
+    };
+    Table.prototype.createBoundEmptyCell = function () {
+        var cell = new TableCell(this.documentOwner, []);
+        if (this.documentOwner !== undefined) {
+            cell.bindDocument(this.documentOwner);
+        }
+        this.paintTableBackColorOntoCell(cell);
+        return cell;
+    };
+    /**
+     * Re-paint every cell from current `w:tblPr/w:shd` fill (DocIO parity).
+     * No-op when table shading has no fill.
+     *
+     * @private
+     */
+    Table.prototype.reapplyTableBackColorToCells = function () {
+        var shd = readTableShading(this.tblPr);
+        var fill = shd === undefined ? undefined : shd.fill;
+        if (fill === undefined || fill.length === 0) {
+            return;
+        }
+        this.applyTableBackColorToCells(fill);
+    };
+    /**
+     * Copy table-level back fill onto one newly created cell.
+     *
+     * @private
+     */
+    Table.prototype.paintTableBackColorOntoCell = function (cell) {
+        var shd = readTableShading(this.tblPr);
+        if (shd === undefined || shd.fill === undefined || shd.fill.length === 0) {
+            return;
+        }
+        var pattern = shd.pattern !== undefined && shd.pattern.length > 0 ? shd.pattern : 'clear';
+        var color = shd.color !== undefined && shd.color.length > 0 ? shd.color : 'auto';
+        var next = {
+            fill: shd.fill,
+            color: color,
+            pattern: pattern,
+        };
+        cell.writeTcPr(writeCellShading(cell.readTcPr(), next));
+    };
+    /**
+     * @private
+     */
+    Table.prototype.bindDocument = function (document) {
+        this.documentOwner = document;
+        for (var r = 0; r < this.tableRows.length; r += 1) {
+            var row = this.tableRows[r];
+            row.bindDocument(document);
+            var cells = row.listCells();
+            for (var c = 0; c < cells.length; c += 1) {
+                cells[c].bindDocument(document);
+            }
+        }
+    };
+    /**
+     * @private
+     */
+    Table.prototype.toOpenXml = function () {
+        if (this.conditionalFormattingDirty) {
+            this.updateConditionalFormatting();
+        }
+        var children = [];
+        for (var i = 0; i < this.prefixMarkup.length; i += 1) {
+            children.push(this.prefixMarkup[i]);
+        }
+        children.push(this.tblPr);
+        children.push(this.tblGrid);
+        for (var r = 0; r < this.tableRows.length; r += 1) {
+            children.push(this.tableRows[r].toOpenXml());
+        }
+        return wmlElement('tbl', { children: children });
+    };
+    Table.prototype.columnCount = function () {
+        var gridCols = 0;
+        var kids = elementChildren(this.tblGrid);
+        for (var i = 0; i < kids.length; i += 1) {
+            if (isWml(kids[i], 'gridCol')) {
+                gridCols += 1;
+            }
+        }
+        if (gridCols > 0) {
+            return gridCols;
+        }
+        var firstRow = this.tableRows[0];
+        if (firstRow === undefined) {
+            return 1;
+        }
+        var first = firstRow.listCells().length;
+        return first > 0 ? first : 1;
+    };
+    Table.prototype.gridColumnWidthsTwips = function () {
+        var widths = [];
+        var kids = elementChildren(this.tblGrid);
+        for (var i = 0; i < kids.length; i += 1) {
+            var child = kids[i];
+            if (!isWml(child, 'gridCol')) {
+                continue;
+            }
+            var raw = parseDecimalVal(wmlAttrVal(child, 'w'));
+            widths.push(raw !== undefined && raw > 0 ? raw : DEFAULT_GRID_COL_TWIPS);
+        }
+        if (widths.length > 0) {
+            return widths;
+        }
+        var cols = this.columnCount();
+        var out = [];
+        for (var i = 0; i < cols; i += 1) {
+            out.push(DEFAULT_GRID_COL_TWIPS);
+        }
+        return out;
+    };
+    Table.prototype.cellWidthFromGridTwips = function (gridWidths, startColumn, span) {
+        var total = 0;
+        for (var i = 0; i < span; i += 1) {
+            var w = gridWidths[startColumn + i];
+            total += w !== undefined && w > 0 ? w : DEFAULT_GRID_COL_TWIPS;
+        }
+        return total > 0 ? total : DEFAULT_GRID_COL_TWIPS * Math.max(span, 1);
+    };
+    Table.prototype.applyFitToContent = function () {
+        this.layout = 'autoFit';
+        this.preferredWidth = autoWidthZero();
+        for (var r = 0; r < this.tableRows.length; r += 1) {
+            var cells = this.tableRows[r].listCells();
+            for (var c = 0; c < cells.length; c += 1) {
+                cells[c].preferredWidth = autoWidthZero();
+            }
+        }
+    };
+    Table.prototype.applyFitToWindow = function () {
+        var gridWidths = this.gridColumnWidthsTwips();
+        var tableWidthTwips = 0;
+        for (var i = 0; i < gridWidths.length; i += 1) {
+            tableWidthTwips += gridWidths[i];
+        }
+        var divisor = tableWidthTwips > 0 ? tableWidthTwips : DEFAULT_GRID_COL_TWIPS;
+        this.layout = 'autoFit';
+        this.preferredWidth = {
+            type: 'pct',
+            value: twipsToPoint(PCT_100_FIFTIETHS),
+        };
+        for (var r = 0; r < this.tableRows.length; r += 1) {
+            var cursor = 0;
+            var cells = this.tableRows[r].listCells();
+            for (var c = 0; c < cells.length; c += 1) {
+                var cell = cells[c];
+                var span = cellColumnSpan(cell);
+                var existing = cell.preferredWidth;
+                if ((existing == null ? undefined : existing.type) !== 'pct') {
+                    var cellTwips = this.cellWidthFromGridTwips(gridWidths, cursor, span);
+                    var fiftieths = Math.max(0, Math.round((cellTwips / divisor) * PCT_100_FIFTIETHS));
+                    cell.preferredWidth = {
+                        type: 'pct',
+                        value: twipsToPoint(fiftieths),
+                    };
+                }
+                cursor += span;
+            }
+        }
+    };
+    Table.prototype.applyFixedColumnWidth = function () {
+        var gridWidths = this.gridColumnWidthsTwips();
+        this.layout = 'fixed';
+        this.preferredWidth = autoWidthZero();
+        for (var r = 0; r < this.tableRows.length; r += 1) {
+            var cursor = 0;
+            var cells = this.tableRows[r].listCells();
+            for (var c = 0; c < cells.length; c += 1) {
+                var cell = cells[c];
+                var span = cellColumnSpan(cell);
+                var cellTwips = this.cellWidthFromGridTwips(gridWidths, cursor, span);
+                cell.preferredWidth = {
+                    type: 'dxa',
+                    value: twipsToPoint(cellTwips),
+                };
+                cursor += span;
+            }
+        }
+    };
+    Table.prototype.buildEmptyRow = function () {
+        return this.buildEmptyRowWithColumns(this.columnCount());
+    };
+    Table.prototype.buildEmptyRowWithColumns = function (columnCount) {
+        var cells = [];
+        for (var c = 0; c < columnCount; c += 1) {
+            cells.push(this.createBoundEmptyCell());
+        }
+        var row = new TableRow([], undefined, cells, this);
+        if (this.documentOwner !== undefined) {
+            row.bindDocument(this.documentOwner);
+            for (var i = 0; i < cells.length; i += 1) {
+                cells[i].bindDocument(this.documentOwner);
+            }
+        }
+        return row;
+    };
+    /**
+     * @private
+     * Effective cell width in points from the table grid (and cell span).
+     */
+    Table.prototype.effectiveCellWidthPoints = function (cell) {
+        var rows = this.tableRows;
+        for (var r = 0; r < rows.length; r += 1) {
+            var row = rows[r];
+            var cells = row.listCells();
+            var cursor = 0;
+            for (var c = 0; c < cells.length; c += 1) {
+                var current = cells[c];
+                var span = cellColumnSpan(current);
+                if (current === cell) {
+                    var twips = this.cellWidthFromGridTwips(this.gridColumnWidthsTwips(), cursor, span);
+                    return twipsToPoint(twips);
+                }
+                cursor += span;
+            }
+        }
+        return twipsToPoint(DEFAULT_GRID_COL_TWIPS);
+    };
+    return Table;
+}());
+export { Table };
+/**
+ * One row of a table — ordered cells with row-level formatting.
+ *
+ * @public
+ */
+var TableRow = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function TableRow(extras, trPr, cells, ownerTable) {
+        this.rowExtras = extras;
+        this.trPr = trPr;
+        this.tableCells = cells;
+        this.boundDocument = undefined;
+        this.ownerTableRef = ownerTable;
+        this.cellsInstance = new TableCellCollection(this);
+        this.rowFormatInstance = new RowFormat(this);
+        for (var i = 0; i < cells.length; i += 1) {
+            cells[i].setOwnerRow(this);
+        }
+    }
+    /**
+     * @private
+     */
+    TableRow.prototype.setOwnerTable = function (table) {
+        this.ownerTableRef = table;
+    };
+    Object.defineProperty(TableRow.prototype, "cells", {
+        /** Cells collection (DocIO-aligned). */
+        get: function () {
+            return this.cellsInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    TableRow.prototype.listCells = function () {
+        return this.tableCells;
+    };
+    /**
+     * @private
+     * Replace structural cells in this row (merge/split internal).
+     */
+    TableRow.prototype.replaceCells = function (cells) {
+        if (cells.length < 1) {
+            throw new DetachedObjectError('A table row must retain at least one cell');
+        }
+        var previous = this.tableCells;
+        for (var i = 0; i < previous.length; i += 1) {
+            if (cells.indexOf(previous[i]) === -1) {
+                previous[i].setOwnerRow(undefined);
+            }
+        }
+        this.tableCells = cells;
+        for (var i = 0; i < cells.length; i += 1) {
+            cells[i].setOwnerRow(this);
+        }
+        this.cellsInstance.syncFromHost();
+        if (this.ownerTableRef !== undefined) {
+            this.ownerTableRef.markConditionalFormattingDirty();
+        }
+    };
+    /**
+     * @private
+     */
+    TableRow.prototype.createEmptyCell = function () {
+        var cell = new TableCell(this.boundDocument, []);
+        cell.setOwnerRow(this);
+        if (this.boundDocument !== undefined) {
+            cell.bindDocument(this.boundDocument);
+        }
+        if (this.ownerTableRef !== undefined) {
+            this.ownerTableRef.paintTableBackColorOntoCell(cell);
+        }
+        return cell;
+    };
+    /**
+     * @private
+     */
+    TableRow.prototype.bindCell = function (cell) {
+        cell.setOwnerRow(this);
+        if (this.boundDocument !== undefined) {
+            cell.bindDocument(this.boundDocument);
+        }
+    };
+    /**
+     * @private
+     */
+    TableRow.prototype.minCellCount = function () {
+        return 1;
+    };
+    /**
+     * @private
+     * Host probe for {@link TableCellCollection} (nullable; does not throw).
+     */
+    TableRow.prototype.getOwnerTableOrUndefined = function () {
+        return this.ownerTableRef;
+    };
+    /**
+     * @private
+     */
+    TableRow.prototype.readTrPr = function () {
+        return this.trPr;
+    };
+    /**
+     * @private
+     */
+    TableRow.prototype.writeTrPr = function (next) {
+        this.trPr = next;
+    };
+    Object.defineProperty(TableRow.prototype, "rowFormat", {
+        /** Row-level format facade. */
+        get: function () {
+            return this.rowFormatInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableRow.prototype, "ownerTable", {
+        /**
+         * Owning table. Throws {@link DetachedObjectError} when the row is detached.
+         */
+        get: function () {
+            if (this.ownerTableRef === undefined) {
+                throw new DetachedObjectError('This row is no longer attached to a table');
+            }
+            return this.ownerTableRef;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableRow.prototype, "height", {
+        /**
+         * Row height in points (`w:trHeight/@w:val` twips on the wire).
+         * `0` when unset (auto height to content).
+         */
+        get: function () {
+            var bag = readRowHeight(this.trPr);
+            return bag === undefined ? 0 : bag.value;
+        },
+        set: function (value) {
+            if (!isFinite(value) || value < 0) {
+                throw new RangeError('Row height must be a non-negative finite number of points, got ' + String(value));
+            }
+            var prev = readRowHeight(this.trPr);
+            var rule = prev !== undefined
+                ? prev.rule
+                : 'auto';
+            if (value === 0 && rule === 'auto') {
+                this.trPr = writeRowHeight(this.trPr, undefined);
+                return;
+            }
+            this.trPr = writeRowHeight(this.trPr, { value: value, rule: rule });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableRow.prototype, "heightType", {
+        /**
+         * How Word treats {@link TableRow.height} (`w:trHeight/@w:hRule`).
+         * Defaults to `'auto'` when unset.
+         */
+        get: function () {
+            var bag = readRowHeight(this.trPr);
+            return bag === undefined ? 'auto' : bag.rule;
+        },
+        set: function (value) {
+            if (value !== 'auto' &&
+                value !== 'exact' &&
+                value !== 'atLeast') {
+                throw new RangeError('Invalid row heightType: ' + String(value));
+            }
+            var prev = readRowHeight(this.trPr);
+            var heightValue = prev !== undefined ? prev.value : 0;
+            if (value === 'auto' && heightValue === 0) {
+                this.trPr = writeRowHeight(this.trPr, undefined);
+                return;
+            }
+            this.trPr = writeRowHeight(this.trPr, { value: heightValue, rule: value });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableRow.prototype, "isHeader", {
+        /**
+         * When `true`, the row repeats at the top of every page the table spans
+         * (a repeating header row). Defaults to `false`.
+         */
+        get: function () {
+            return readRowIsHeader(this.trPr) === true;
+        },
+        set: function (value) {
+            this.trPr = writeRowIsHeader(this.trPr, value === true ? true : undefined);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     * Records the owning document so appended cells bind to it.
+     */
+    TableRow.prototype.bindDocument = function (document) {
+        this.boundDocument = document;
+        for (var i = 0; i < this.tableCells.length; i += 1) {
+            this.tableCells[i].bindDocument(document);
+        }
+    };
+    /**
+     * @private
+     * Serializes the row back to its `w:tr` element.
+     */
+    /**
+     * Conditional table-style membership on `w:trPr/w:cnfStyle`.
+     *
+     * @public
+     */
+    TableRow.prototype.getConditionalFormatting = function () {
+        return readRowCnfStyle(this.trPr);
+    };
+    /**
+     * Write or clear row conditional formatting membership.
+     *
+     * @param state Normalized flags, or `undefined` to remove.
+     * @public
+     */
+    TableRow.prototype.setConditionalFormatting = function (state) {
+        this.trPr = writeRowCnfStyle(this.trPr, state);
+    };
+    TableRow.prototype.toOpenXml = function () {
+        var children = [];
+        for (var i = 0; i < this.rowExtras.length; i += 1) {
+            children.push(this.rowExtras[i]);
+        }
+        if (this.trPr !== undefined) {
+            children.push(this.trPr);
+        }
+        for (var i = 0; i < this.tableCells.length; i += 1) {
+            children.push(this.tableCells[i].toOpenXml());
+        }
+        return wmlElement('tr', { children: children });
+    };
+    return TableRow;
+}());
+export { TableRow };
+/**
+ * One cell of a table — a body container for paragraphs and nested tables,
+ * with cell-level settings such as width and formatting.
+ *
+ * Nested tables: call {@link Body.appendTable} on the cell, then
+ * {@link Table.resetCells} for size.
+ *
+ * @public
+ */
+var TableCell = /** @class */ (function (_super) {
+    __extends(TableCell, _super);
+    /**
+     * @private
+     */
+    function TableCell(document, blocks) {
+        var _this = _super.call(this, document, blocks) || this;
+        /**
+         * Marks this body as a table-cell owner for {@link Paragraph.isInCell}.
+         *
+         * @private
+         */
+        _this.bodyOwnerKind = 'tableCell';
+        _this.tcPrValue = undefined;
+        _this.cellFormatInstance = new CellFormat(_this);
+        _this.ownerRowRef = undefined;
+        _this.reattachNestedTables();
+        return _this;
+    }
+    /**
+     * @private
+     */
+    TableCell.prototype.setOwnerRow = function (row) {
+        this.ownerRowRef = row;
+    };
+    /**
+     * @private
+     * Apply `w:tcPr` after parse (constructor only takes body blocks).
+     */
+    TableCell.prototype.applyTcPr = function (tcPr) {
+        this.tcPrValue = tcPr;
+    };
+    /**
+     * @private
+     */
+    TableCell.prototype.readTcPr = function () {
+        return this.tcPrValue;
+    };
+    /**
+     * @private
+     */
+    TableCell.prototype.writeTcPr = function (next) {
+        this.tcPrValue = next;
+    };
+    Object.defineProperty(TableCell.prototype, "cellFormat", {
+        /** Cell-level format facade. */
+        get: function () {
+            return this.cellFormatInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableCell.prototype, "gridSpan", {
+        /**
+         * Number of grid columns this cell spans (`w:tcPr/w:gridSpan`).
+         *
+         * @private
+         * Merge plumbing writes this value; public surface is
+         * {@link CellFormat.columnSpan}.
+         */
+        get: function () {
+            return readGridSpan(this.tcPrValue);
+        },
+        set: function (span) {
+            this.tcPrValue = writeGridSpan(this.tcPrValue, span);
+            var row = this.ownerRowRef;
+            if (row !== undefined) {
+                var table = row.getOwnerTableOrUndefined();
+                if (table !== undefined) {
+                    table.markConditionalFormattingDirty();
+                }
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableCell.prototype, "verticalMerge", {
+        /**
+         * Vertical merge wire state (`w:tcPr/w:vMerge`): `'restart'` | `'continue'`.
+         *
+         * @private
+         * Merge algorithm uses this; public surface is
+         * {@link CellFormat.verticalMerge} ({@link CellMerge}).
+         */
+        get: function () {
+            return readVerticalMerge(this.tcPrValue);
+        },
+        set: function (merge) {
+            this.tcPrValue = writeVerticalMerge(this.tcPrValue, merge);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableCell.prototype, "preferredWidth", {
+        /**
+         * Outer width of the cell as authored (`w:tcPr/w:tcW`).
+         *
+         * @private
+         */
+        get: function () {
+            return readCellPreferredWidth(this.tcPrValue);
+        },
+        set: function (value) {
+            this.tcPrValue = writeCellPreferredWidth(this.tcPrValue, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableCell.prototype, "width", {
+        /**
+         * Preferred / effective cell width in points (1/72 inch).
+         *
+         * Fixed DXA `w:tcW` wins when present; otherwise the value is derived from
+         * the parent table grid. Never returns `undefined`.
+         */
+        get: function () {
+            var preferred = readCellPreferredWidth(this.tcPrValue);
+            if (preferred !== undefined && preferred.type === 'dxa') {
+                return preferred.value;
+            }
+            var row = this.ownerRowRef;
+            if (row === undefined) {
+                return twipsToPoint(DEFAULT_GRID_COL_TWIPS);
+            }
+            var table;
+            try {
+                table = row.ownerTable;
+            }
+            catch (_e) {
+                table = undefined;
+            }
+            if (table === undefined) {
+                return twipsToPoint(DEFAULT_GRID_COL_TWIPS);
+            }
+            return table.effectiveCellWidthPoints(this);
+        },
+        set: function (value) {
+            if (!isFinite(value) || value < 0) {
+                throw new RangeError('Cell width must be a non-negative finite number of points, got ' + String(value));
+            }
+            this.tcPrValue = writeCellPreferredWidth(this.tcPrValue, {
+                type: 'dxa',
+                value: value,
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableCell.prototype, "text", {
+        /**
+         * Plain text of the cell, concatenated across all paragraphs.
+         */
+        get: function () {
+            var parts = [];
+            var paras = this.listParagraphs();
+            for (var i = 0; i < paras.length; i += 1) {
+                parts.push(paras[i].text);
+            }
+            return parts.join('');
+        },
+        set: function (value) {
+            var paragraph = this.listParagraphs()[0];
+            if (paragraph === undefined) {
+                paragraph = this.appendParagraph();
+            }
+            // Clear existing modeled text by replacing with a single paragraph text.
+            // Prefer appendText on a fresh empty paragraph path when possible.
+            var current = paragraph.text;
+            if (current.length > 0 || value.length === 0) {
+                // Rebuild: remove all body blocks and put one paragraph with text.
+                this.replaceItems([]);
+                paragraph = this.appendParagraph({ text: value });
+                return;
+            }
+            paragraph.appendText(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableCell.prototype, "nestedTables", {
+        /**
+         * Nested tables contained in this cell body (feature blocks).
+         * Prefer {@link TableCell.appendTable} to create nested tables.
+         */
+        get: function () {
+            var result = [];
+            var blocks = this.listBlocks();
+            for (var i = 0; i < blocks.length; i += 1) {
+                var block = blocks[i];
+                if (block.type === 'feature' && block.featureId === TABLES && block.value instanceof Table) {
+                    result.push(block.value);
+                }
+            }
+            return result;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     * Binds the cell (and nested tables) to a document on attachment.
+     */
+    TableCell.prototype.bindDocument = function (document) {
+        this.setOwningDocument(document);
+        this.reattachNestedTables();
+        var blocks = this.listBlocks();
+        for (var i = 0; i < blocks.length; i += 1) {
+            var block = blocks[i];
+            if (block.type === 'feature' && block.featureId === TABLES && block.value instanceof Table) {
+                block.value.bindDocument(document);
+            }
+        }
+    };
+    /**
+     * @private
+     * Re-attach nested table ownership after construction / content moves.
+     */
+    TableCell.prototype.reattachNestedTables = function () {
+        var doc;
+        try {
+            doc = this.owningDocument();
+        }
+        catch (_e) {
+            doc = undefined;
+        }
+        var blocks = this.listBlocks();
+        for (var i = 0; i < blocks.length; i += 1) {
+            var block = blocks[i];
+            if (block.type === 'feature' && block.featureId === TABLES && block.value instanceof Table) {
+                if (doc !== undefined) {
+                    block.value.bindDocument(doc);
+                }
+            }
+        }
+    };
+    /**
+     * @private
+     * Serializes the cell back to its `w:tc` element.
+     */
+    /**
+     * Conditional table-style membership on `w:tcPr/w:cnfStyle`.
+     *
+     * @public
+     */
+    TableCell.prototype.getConditionalFormatting = function () {
+        return readCellCnfStyle(this.tcPrValue);
+    };
+    /**
+     * Write or clear cell conditional formatting membership.
+     *
+     * @param state Normalized flags, or `undefined` to remove.
+     * @public
+     */
+    TableCell.prototype.setConditionalFormatting = function (state) {
+        this.tcPrValue = writeCellCnfStyle(this.tcPrValue, state);
+    };
+    TableCell.prototype.toOpenXml = function () {
+        var children = [];
+        if (this.tcPrValue !== undefined) {
+            children.push(this.tcPrValue);
+        }
+        var blocks = this.listBlocks();
+        if (blocks.length === 0) {
+            // WordprocessingML cells require ≥1 paragraph on the wire; keep the
+            // public DOM empty and emit a serialize-only empty `w:p`.
+            children.push(wmlElement('p'));
+        }
+        else {
+            var serialized = serializeBodyBlocks(blocks);
+            for (var i = 0; i < serialized.length; i += 1) {
+                children.push(serialized[i]);
+            }
+        }
+        return wmlElement('tc', { children: children });
+    };
+    return TableCell;
+}(Body));
+export { TableCell };
+function defaultTblPr() {
+    return wmlElement('tblPr');
+}
+function defaultTblGrid(columnCount) {
+    var widths = equalColumnTwips(DEFAULT_GRID_COL_TWIPS * columnCount, columnCount);
+    return tblGridFromTwips(widths);
+}
+/**
+ * Client width available for equal column distribution (points).
+ * Top-level uses page width − left/right margins; falls back to Letter − 72 − 72.
+ *
+ * @private
+ */
+function resolveClientWidthPoints(table) {
+    var doc = table['documentOwner'];
+    if (doc !== undefined) {
+        try {
+            var sections = doc.sections;
+            if (sections !== undefined && sections.count > 0) {
+                var setup = sections[0].pageSetup;
+                var pageWidth = setup.pageSize.width;
+                var left = setup.margins.left;
+                var right = setup.margins.right;
+                var client = pageWidth - left - right;
+                if (isFinite(client) && client > 0) {
+                    return client;
+                }
+            }
+        }
+        catch (_e) {
+            /* fall through */
+        }
+    }
+    return DEFAULT_PAGE_CLIENT_WIDTH_POINTS;
+}
+/**
+ * Apply create-path defaults: TableGrid (when bound), fixed layout, equal widths.
+ *
+ * @private
+ */
+function applyAuthoringTableDefaults(table, columnCount) {
+    var cols = columnCount > 0 ? columnCount : 1;
+    var clientPoints = resolveClientWidthPoints(table);
+    var totalTwips = pointToTwips(clientPoints);
+    var widths = equalColumnTwips(totalTwips, cols);
+    table['tblGrid'] = tblGridFromTwips(widths);
+    table.layout = 'fixed';
+    var sum = 0;
+    for (var i = 0; i < widths.length; i += 1) {
+        sum += widths[i];
+    }
+    table['tblPr'] = writeTablePreferredWidth(table['tblPr'], {
+        type: 'dxa',
+        value: twipsToPoint(sum),
+    });
+    var rows = table.listRows();
+    for (var r = 0; r < rows.length; r += 1) {
+        var cursor = 0;
+        var cells = rows[r].listCells();
+        for (var c = 0; c < cells.length; c += 1) {
+            var cell = cells[c];
+            var span = cellColumnSpan(cell);
+            var cellTwips = 0;
+            for (var s = 0; s < span; s += 1) {
+                var w = widths[cursor + s];
+                cellTwips += w !== undefined && w > 0 ? w : DEFAULT_GRID_COL_TWIPS;
+            }
+            cell.preferredWidth = {
+                type: 'dxa',
+                value: twipsToPoint(cellTwips > 0 ? cellTwips : DEFAULT_GRID_COL_TWIPS),
+            };
+            cursor += span;
+        }
+    }
+    var doc = table['documentOwner'];
+    if (doc !== undefined) {
+        try {
+            table.applyStyle(BuiltinTableStyle.TableGrid);
+        }
+        catch (_e) {
+            table['tblPr'] = writeTableStyle(table['tblPr'], BuiltinTableStyle.TableGrid);
+        }
+    }
+    else {
+        table['tblPr'] = writeTableStyle(table['tblPr'], BuiltinTableStyle.TableGrid);
+    }
+}
+/**
+ * Create an empty table with empty cells (no auto-injected paragraphs).
+ * Authoring defaults (style/layout/equal widths) are applied by appendTable/resetCells.
+ *
+ * @private
+ */
+export function createTable(rowCount, columnCount) {
+    if (rowCount < 1 || columnCount < 1) {
+        throw new RangeError('Table must have at least one row and one column');
+    }
+    var rows = [];
+    for (var r = 0; r < rowCount; r += 1) {
+        var cells = [];
+        for (var c = 0; c < columnCount; c += 1) {
+            cells.push(new TableCell(undefined, []));
+        }
+        rows.push(new TableRow([], undefined, cells));
+    }
+    var table = new Table([], defaultTblPr(), defaultTblGrid(columnCount), rows);
+    for (var i = 0; i < rows.length; i += 1) {
+        rows[i].setOwnerTable(table);
+    }
+    return table;
+}
+function parseOwningDocument(ctx) {
+    try {
+        return ctx.owningDocument();
+    }
+    catch (_e) {
+        return undefined;
+    }
+}
+function parseTable(element, ctx) {
+    var __ts33_2;
+    if (!isWml(element, 'tbl')) {
+        return undefined;
+    }
+    var prefix = [];
+    var tblPr;
+    var tblGrid;
+    var rows = [];
+    var kids = elementChildren(element);
+    for (var i = 0; i < kids.length; i += 1) {
+        var child = kids[i];
+        if (isWml(child, 'tblPr') && tblPr === undefined) {
+            tblPr = child;
+            continue;
+        }
+        if (isWml(child, 'tblGrid') && tblGrid === undefined) {
+            tblGrid = child;
+            continue;
+        }
+        if (isWml(child, 'tr')) {
+            rows.push(parseRow(child, ctx));
+            continue;
+        }
+        if (tblPr === undefined) {
+            prefix.push(child);
+        }
+    }
+    if (tblPr === undefined) {
+        tblPr = defaultTblPr();
+    }
+    if (tblGrid === undefined) {
+        var firstRow = rows[0];
+        var cols = ((__ts33_2 =
+            firstRow == null ? undefined : firstRow.listCells().length),
+            __ts33_2 != null ? __ts33_2 : 1);
+        tblGrid = defaultTblGrid(Math.max(cols, 1));
+    }
+    if (rows.length < 1) {
+        // Enforce ≥1 row for modeled tables.
+        var paragraph = new Paragraph(undefined);
+        var cell = new TableCell(parseOwningDocument(ctx), [
+            { type: 'paragraph', paragraph: paragraph },
+        ]);
+        rows.push(new TableRow([], undefined, [cell]));
+    }
+    var table = new Table(prefix, tblPr, tblGrid, rows);
+    for (var i = 0; i < rows.length; i += 1) {
+        rows[i].setOwnerTable(table);
+        if (parseOwningDocument(ctx) !== undefined) {
+            rows[i].bindDocument(parseOwningDocument(ctx));
+        }
+    }
+    if (parseOwningDocument(ctx) !== undefined) {
+        table.bindDocument(parseOwningDocument(ctx));
+    }
+    return table;
+}
+function parseRow(element, ctx) {
+    var extras = [];
+    var trPr;
+    var cells = [];
+    var kids = elementChildren(element);
+    for (var i = 0; i < kids.length; i += 1) {
+        var child = kids[i];
+        if (isWml(child, 'trPr') && trPr === undefined) {
+            trPr = child;
+            continue;
+        }
+        if (isWml(child, 'tc')) {
+            cells.push(parseCell(child, ctx));
+            continue;
+        }
+        extras.push(child);
+    }
+    if (cells.length < 1) {
+        var paragraph = new Paragraph(undefined);
+        cells.push(new TableCell(parseOwningDocument(ctx), [{ type: 'paragraph', paragraph: paragraph }]));
+    }
+    return new TableRow(extras, trPr, cells);
+}
+function parseCell(element, ctx) {
+    var tcPr;
+    var content = [];
+    var kids = elementChildren(element);
+    for (var i = 0; i < kids.length; i += 1) {
+        var child = kids[i];
+        if (isWml(child, 'tcPr') && tcPr === undefined) {
+            tcPr = child;
+            continue;
+        }
+        content.push(child);
+    }
+    var blocks = parseBodyBlocks(content, ctx);
+    var cell = new TableCell(parseOwningDocument(ctx), blocks);
+    cell.applyTcPr(tcPr);
+    return cell;
+}
+var registered = false;
+/**
+ * @private
+ * Test hook
+ */
+export function resetTablesFeatureForTests() {
+    registered = false;
+}
+function visitTableParagraphs(table, visit) {
+    var rows = table.listRows();
+    for (var r = 0; r < rows.length; r += 1) {
+        var cells = rows[r].listCells();
+        for (var c = 0; c < cells.length; c += 1) {
+            // Nested feature blocks (tables, content controls) use registered walkers.
+            visitBlocksInDocumentOrder(cells[c].listBlocks(), visit);
+        }
+    }
+}
+/**
+ * @private
+ * Register the tables feature block handler. Idempotent.
+ */
+export function registerTablesFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: TABLES });
+    registerFeatureBlockHandler({
+        featureId: TABLES,
+        wmlLocalName: 'tbl',
+        tryParse: parseTable,
+    });
+    registerFeatureBlockParagraphWalker({
+        featureId: TABLES,
+        visitParagraphs: function (block, visit) {
+            if (block instanceof Table) {
+                visitTableParagraphs(block, visit);
+            }
+        },
+    });
+    registerBodyItemAdapter({
+        project: function (block) {
+            if (block.featureId === TABLES && block.value instanceof Table) {
+                return block.value;
+            }
+            return undefined;
+        },
+        toBlock: function (item) {
+            if (item instanceof Table) {
+                return { type: 'feature', featureId: TABLES, value: item };
+            }
+            return undefined;
+        },
+        isInstance: function (item) {
+            return item instanceof Table;
+        },
+    });
+    registerTypedCollectionHooks({
+        isTable: function (item) {
+            return item instanceof Table;
+        },
+        createTable: function () {
+            return createTable(1, 1);
+        },
+    });
+}
+/**
+ * Feature id constant for the tables module (used by host features that embed
+ * table blocks, e.g. text box bodies in the drawing module).
+ *
+ * @private
+ */
+export var TABLES_FEATURE_ID = TABLES;
+/**
+ * Type guard for a tables feature block on a {@link BodyItem} list.
+ *
+ * @private
+ */
+export function isTableBlock(block) {
+    if (block instanceof Table) {
+        return true;
+    }
+    if (typeof block !== 'object' || block === null) {
+        return false;
+    }
+    var candidate = block;
+    return (candidate.type === 'feature' &&
+        candidate.featureId === TABLES &&
+        candidate.value instanceof Table);
+}
+/** True when `value` is a public Table body item instance. */
+export function isTableBodyItem(value) {
+    return value instanceof Table;
+}
+Object.defineProperty(Body.prototype, 'appendTable', {
+    value: function () {
+        // Always 1×1; callers size the grid with Table.resetCells(rows, columns).
+        var table = createTable(1, 1);
+        this.appendRawBlock({ type: 'feature', featureId: TABLES, value: table });
+        try {
+            var doc = this.owningDocument();
+            table.bindDocument(doc);
+        }
+        catch (_e) {
+            /* detached body during construction */
+        }
+        // Authoring defaults: TableGrid, fixed layout, equal client-width columns.
+        applyAuthoringTableDefaults(table, 1);
+        // Trailing empty paragraph after the table in the same container (not inside a cell).
+        var blocks = this.listBlocks();
+        var last = blocks.length > 0 ? blocks[blocks.length - 1] : undefined;
+        var alreadyTrailingEmpty = false;
+        if (last !== undefined && last.type === 'paragraph' && last.paragraph !== undefined) {
+            alreadyTrailingEmpty = last.paragraph.items.length === 0;
+        }
+        if (!alreadyTrailingEmpty) {
+            this.appendParagraph();
+        }
+        return table;
+    },
+    writable: true,
+    configurable: true,
+});
+Object.defineProperty(WordDocument.prototype, 'appendTable', {
+    value: function () {
+        return this.firstSectionBody().appendTable();
+    },
+    writable: true,
+    configurable: true,
+});
+registerAlwaysOnBodyFeatureBootstrap(function () {
+    registerTablesFeature();
+});
+registerTablesFeature();