@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/styles/table-style.js

@@ -0,0 +1,1226 @@
+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 __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+/**
+ * Table style live model (`w:style/@w:type="table"`).
+ *
+ * Owns character/paragraph format facades, base table/row/cell property bags,
+ * and conditional formatting styles (`w:tblStylePr`). Mutations rewrite the
+ * DocxStyle shell and notify the styles host.
+ *
+ * @public
+ */
+import { CharacterFormat, parseCharacterFormat, buildRPrChildrenFromSnapshot, } from '../document/character-format';
+import { colorFromWire, colorToHexWire } from '../document/color';
+import { ParagraphFormat, parseParagraphFormat, buildPPrChildrenFromSnapshot, } from '../document/paragraph-format';
+import { elementChildren, isWml, wmlAttr, wmlElement, wValAttribute } from '../document/wml';
+import { readTableBorders, writeTableBorders, readTableCellMargins, writeTableCellMargins, readTableShading, writeTableShading, readTablePreferredWidth, writeTablePreferredWidth, readTableAlignment, writeTableAlignment, readTableLayout, writeTableLayout, readTableCellSpacing, writeTableCellSpacing, readTableIndent, writeTableIndent, readTableRowBandSize, writeTableRowBandSize, readTableColumnBandSize, writeTableColumnBandSize, } from '../tables/tbl-pr';
+import { readRowHeight, writeRowHeight, readRowCantSplit, writeRowCantSplit, readRowIsHeader, writeRowIsHeader, } from '../tables/tr-pr';
+import { readCellBorders, writeCellBorders, readCellShading, writeCellShading, readCellMargins, writeCellMargins, readCellVerticalAlignment, writeCellVerticalAlignment, readCellTextDirection, writeCellTextDirection, readCellPreferredWidth, writeCellPreferredWidth, readHorizontalMerge, writeHorizontalMerge, readVerticalMerge, writeVerticalMerge, } from '../tables/tc-pr';
+import { Borders } from '../tables/borders';
+import { Paddings } from '../tables/paddings';
+import { DocxStyle, parseDocxStyle } from './style';
+import { Style } from './style-base';
+/** Conditional formatting type tokens (`w:tblStylePr/@w:type`). */
+export var ConditionalFormattingType = {
+    WholeTable: 'wholeTable',
+    FirstRow: 'firstRow',
+    LastRow: 'lastRow',
+    FirstColumn: 'firstColumn',
+    LastColumn: 'lastColumn',
+    OddColumnBand: 'band1Vert',
+    EvenColumnBand: 'band2Vert',
+    OddRowBand: 'band1Horz',
+    EvenRowBand: 'band2Horz',
+    TopLeftCell: 'nwCell',
+    TopRightCell: 'neCell',
+    BottomLeftCell: 'swCell',
+    BottomRightCell: 'seCell',
+};
+var CONDITIONAL_TYPE_SET = {
+    wholeTable: true,
+    firstRow: true,
+    lastRow: true,
+    firstColumn: true,
+    lastColumn: true,
+    band1Vert: true,
+    band2Vert: true,
+    band1Horz: true,
+    band2Horz: true,
+    nwCell: true,
+    neCell: true,
+    swCell: true,
+    seCell: true,
+};
+function isConditionalType(value) {
+    return CONDITIONAL_TYPE_SET[value] === true;
+}
+/**
+ * OOXML `w:style` (table) property-group order after metadata:
+ * pPr → rPr → tblPr → trPr → tcPr → tblStylePr*.
+ * @private
+ */
+var TABLE_STYLE_PROP_RANK = {
+    pPr: 0,
+    rPr: 1,
+    tblPr: 2,
+    trPr: 3,
+    tcPr: 4,
+    tblStylePr: 5,
+};
+/**
+ * OOXML `w:tblStylePr` child order: pPr → rPr → tblPr → trPr → tcPr.
+ * @private
+ */
+var TBL_STYLE_PR_CHILD_RANK = {
+    pPr: 0,
+    rPr: 1,
+    tblPr: 2,
+    trPr: 3,
+    tcPr: 4,
+};
+function stylePropRank(localName) {
+    var rank = TABLE_STYLE_PROP_RANK[localName];
+    return rank !== undefined ? rank : undefined;
+}
+function tblStylePrChildRank(localName) {
+    var rank = TBL_STYLE_PR_CHILD_RANK[localName];
+    return rank !== undefined ? rank : undefined;
+}
+/**
+ * Stable-sort modeled property groups; preserve relative order of other nodes.
+ * @private
+ */
+function orderByRank(children, rankOf) {
+    var preamble = [];
+    var ranked = [];
+    var unknown = [];
+    for (var i = 0; i < children.length; i += 1) {
+        var child = children[i];
+        var rank = rankOf(child.localName);
+        if (rank === undefined) {
+            // Keep unknowns that appear before the first ranked group with preamble;
+            // unknowns after ranked groups stay after (ECMA extras / rsid-like).
+            if (ranked.length === 0) {
+                preamble.push(child);
+            }
+            else {
+                unknown.push({ el: child, index: i });
+            }
+            continue;
+        }
+        ranked.push({ rank: rank, el: child, index: i });
+    }
+    ranked.sort(function (a, b) {
+        if (a.rank !== b.rank) {
+            return a.rank - b.rank;
+        }
+        return a.index - b.index;
+    });
+    var out = preamble.slice();
+    for (var i = 0; i < ranked.length; i += 1) {
+        out.push(ranked[i].el);
+    }
+    // Append trailing unknowns in original order (after property groups).
+    unknown.sort(function (a, b) { return a.index - b.index; });
+    for (var i = 0; i < unknown.length; i += 1) {
+        out.push(unknown[i].el);
+    }
+    return out;
+}
+/**
+ * Order children of one `w:tblStylePr` (omit empties is caller's job).
+ * @private
+ */
+function orderTblStylePrChildren(children) {
+    return orderByRank(children, tblStylePrChildRank);
+}
+/**
+ * Rebuild `w:tblStylePr` with schema-ordered children.
+ * @private
+ */
+function orderTblStylePrElement(el) {
+    var kids = elementChildren(el);
+    if (kids.length <= 1) {
+        // Zero or one child — already ordered.
+        if (kids.length === 1) {
+            return el;
+        }
+        return el;
+    }
+    var ordered = orderTblStylePrChildren(kids);
+    var changed = false;
+    for (var i = 0; i < kids.length; i += 1) {
+        if (kids[i] !== ordered[i]) {
+            changed = true;
+            break;
+        }
+    }
+    if (!changed) {
+        return el;
+    }
+    return wmlElement('tblStylePr', {
+        attributes: el.attributes,
+        namespaceDeclarations: el.namespaceDeclarations,
+        children: ordered,
+    });
+}
+/**
+ * Order `w:style` children for table styles and nested `w:tblStylePr` bodies.
+ * @private
+ */
+function orderTableStyleElement(el) {
+    var kids = elementChildren(el);
+    var withOrderedConditionals = [];
+    for (var i = 0; i < kids.length; i += 1) {
+        var child = kids[i];
+        if (isWml(child, 'tblStylePr')) {
+            withOrderedConditionals.push(orderTblStylePrElement(child));
+        }
+        else {
+            withOrderedConditionals.push(child);
+        }
+    }
+    var ordered = orderByRank(withOrderedConditionals, stylePropRank);
+    var changed = ordered.length !== kids.length;
+    if (!changed) {
+        for (var i = 0; i < kids.length; i += 1) {
+            if (kids[i] !== ordered[i]) {
+                changed = true;
+                break;
+            }
+        }
+    }
+    if (!changed) {
+        return el;
+    }
+    return wmlElement('style', {
+        attributes: el.attributes,
+        namespaceDeclarations: el.namespaceDeclarations,
+        children: ordered,
+    });
+}
+function attrLocal(el, localName) {
+    for (var i = 0; i < el.attributes.length; i += 1) {
+        var a = el.attributes[i];
+        if (a.localName === localName) {
+            return a.value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Base table properties on a table style (`w:tblPr` under `w:style`).
+ *
+ * @public
+ */
+var TableStyleTableProperties = /** @class */ (function () {
+    /** @private */
+    function TableStyleTableProperties(owner) {
+        this.owner = owner;
+    }
+    TableStyleTableProperties.prototype.readTblPr = function () {
+        return this.owner.readBaseChild('tblPr');
+    };
+    TableStyleTableProperties.prototype.writeTblPr = function (next) {
+        this.owner.writeBaseChild('tblPr', next);
+    };
+    Object.defineProperty(TableStyleTableProperties.prototype, "borders", {
+        get: function () {
+            if (this.bordersInstance === undefined) {
+                var self_1 = this;
+                var host = {
+                    readEdge: function (key) {
+                        var pr = self_1.readTblPr();
+                        if (pr === undefined) {
+                            return undefined;
+                        }
+                        var bag = readTableBorders(pr);
+                        return bag !== undefined ? bag[key] : undefined;
+                    },
+                    writeEdge: function (key, edge) {
+                        var pr = self_1.readTblPr() !== undefined ? self_1.readTblPr() : wmlElement('tblPr');
+                        var current = readTableBorders(pr) !== undefined ? __assign({}, readTableBorders(pr)) : {};
+                        if (edge === undefined) {
+                            delete current[key];
+                        }
+                        else {
+                            current[key] = edge;
+                        }
+                        var keys = Object.keys(current);
+                        var nextBag = keys.length > 0 ? current : undefined;
+                        self_1.writeTblPr(writeTableBorders(pr, nextBag));
+                    },
+                };
+                this.bordersInstance = new Borders(host);
+            }
+            return this.bordersInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleTableProperties.prototype, "cellSpacing", {
+        get: function () {
+            var pr = this.readTblPr();
+            return pr !== undefined ? readTableCellSpacing(pr) : undefined;
+        },
+        set: function (value) {
+            var pr = this.readTblPr() !== undefined ? this.readTblPr() : wmlElement('tblPr');
+            this.writeTblPr(writeTableCellSpacing(pr, value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleTableProperties.prototype, "leftIndent", {
+        get: function () {
+            var pr = this.readTblPr();
+            return pr !== undefined ? readTableIndent(pr) : undefined;
+        },
+        set: function (value) {
+            var pr = this.readTblPr() !== undefined ? this.readTblPr() : wmlElement('tblPr');
+            this.writeTblPr(writeTableIndent(pr, value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleTableProperties.prototype, "paddings", {
+        get: function () {
+            if (this.paddingsInstance === undefined) {
+                var self_2 = this;
+                var host = {
+                    read: function () {
+                        var pr = self_2.readTblPr();
+                        return pr !== undefined ? readTableCellMargins(pr) : undefined;
+                    },
+                    write: function (value) {
+                        var pr = self_2.readTblPr() !== undefined ? self_2.readTblPr() : wmlElement('tblPr');
+                        self_2.writeTblPr(writeTableCellMargins(pr, value));
+                    },
+                };
+                this.paddingsInstance = new Paddings(host);
+            }
+            return this.paddingsInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleTableProperties.prototype, "preferredWidth", {
+        /** @private */
+        get: function () {
+            var pr = this.readTblPr();
+            return pr !== undefined ? readTablePreferredWidth(pr) : undefined;
+        },
+        set: function (value) {
+            var pr = this.readTblPr() !== undefined ? this.readTblPr() : wmlElement('tblPr');
+            this.writeTblPr(writeTablePreferredWidth(pr, value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleTableProperties.prototype, "alignment", {
+        /** @private */
+        get: function () {
+            var pr = this.readTblPr();
+            return pr !== undefined ? readTableAlignment(pr) : undefined;
+        },
+        set: function (value) {
+            var pr = this.readTblPr() !== undefined ? this.readTblPr() : wmlElement('tblPr');
+            this.writeTblPr(writeTableAlignment(pr, value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleTableProperties.prototype, "layout", {
+        /** @private */
+        get: function () {
+            var pr = this.readTblPr();
+            return pr !== undefined ? readTableLayout(pr) : undefined;
+        },
+        set: function (value) {
+            var pr = this.readTblPr() !== undefined ? this.readTblPr() : wmlElement('tblPr');
+            this.writeTblPr(writeTableLayout(pr, value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleTableProperties.prototype, "shading", {
+        /** @private */
+        get: function () {
+            var pr = this.readTblPr();
+            return pr !== undefined ? readTableShading(pr) : undefined;
+        },
+        set: function (value) {
+            var pr = this.readTblPr() !== undefined ? this.readTblPr() : wmlElement('tblPr');
+            this.writeTblPr(writeTableShading(pr, value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleTableProperties.prototype, "rowStripe", {
+        /**
+         * Rows per horizontal band on the table style (`w:tblStyleRowBandSize/@w:val`).
+         * Styles.xml only; does not write document-body tblPr. Absent → `undefined`.
+         * Non-finite values throw `RangeError`.
+         *
+         * @public
+         */
+        get: function () {
+            var pr = this.readTblPr();
+            return pr !== undefined ? readTableRowBandSize(pr) : undefined;
+        },
+        set: function (value) {
+            if (value !== undefined && !isFinite(value)) {
+                throw new RangeError('TableStyle rowStripe must be a finite number or undefined, got ' + String(value));
+            }
+            var pr = this.readTblPr() !== undefined ? this.readTblPr() : wmlElement('tblPr');
+            this.writeTblPr(writeTableRowBandSize(pr, value !== undefined ? Math.trunc(value) : undefined));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleTableProperties.prototype, "columnStripe", {
+        /**
+         * Columns per vertical band on the table style (`w:tblStyleColBandSize/@w:val`).
+         * Styles.xml only; does not write document-body tblPr. Absent → `undefined`.
+         * Non-finite values throw `RangeError`.
+         *
+         * @public
+         */
+        get: function () {
+            var pr = this.readTblPr();
+            return pr !== undefined ? readTableColumnBandSize(pr) : undefined;
+        },
+        set: function (value) {
+            if (value !== undefined && !isFinite(value)) {
+                throw new RangeError('TableStyle columnStripe must be a finite number or undefined, got ' + String(value));
+            }
+            var pr = this.readTblPr() !== undefined ? this.readTblPr() : wmlElement('tblPr');
+            this.writeTblPr(writeTableColumnBandSize(pr, value !== undefined ? Math.trunc(value) : undefined));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return TableStyleTableProperties;
+}());
+export { TableStyleTableProperties };
+/**
+ * Row properties on a table style (`w:trPr`).
+ *
+ * @public
+ */
+var TableStyleRowProperties = /** @class */ (function () {
+    /** @private */
+    function TableStyleRowProperties(owner, isConditional) {
+        if (isConditional === void 0) { isConditional = false; }
+        this.owner = owner;
+        this.isConditional = isConditional;
+    }
+    TableStyleRowProperties.prototype.readTrPr = function () {
+        if (this.isConditional) {
+            return this.owner.readChild('trPr');
+        }
+        return this.owner.readBaseChild('trPr');
+    };
+    TableStyleRowProperties.prototype.writeTrPr = function (next) {
+        if (this.isConditional) {
+            this.owner.writeChild('trPr', next);
+            return;
+        }
+        this.owner.writeBaseChild('trPr', next);
+    };
+    Object.defineProperty(TableStyleRowProperties.prototype, "height", {
+        get: function () {
+            var pr = this.readTrPr();
+            var h = readRowHeight(pr);
+            return h !== undefined ? h.value : undefined;
+        },
+        set: function (value) {
+            var pr = this.readTrPr();
+            if (value === undefined) {
+                this.writeTrPr(writeRowHeight(pr, undefined));
+                return;
+            }
+            var current = readRowHeight(pr);
+            var rule = current !== undefined && current.rule !== undefined ? current.rule : 'atLeast';
+            this.writeTrPr(writeRowHeight(pr, { value: value, rule: rule }));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleRowProperties.prototype, "allowBreakAcrossPages", {
+        get: function () {
+            var pr = this.readTrPr();
+            var cant = readRowCantSplit(pr);
+            if (cant === undefined) {
+                return true;
+            }
+            return !cant;
+        },
+        set: function (value) {
+            var pr = this.readTrPr();
+            this.writeTrPr(writeRowCantSplit(pr, value ? undefined : true));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleRowProperties.prototype, "isHeader", {
+        get: function () {
+            var pr = this.readTrPr();
+            var v = readRowIsHeader(pr);
+            return v === true;
+        },
+        set: function (value) {
+            var pr = this.readTrPr();
+            this.writeTrPr(writeRowIsHeader(pr, value ? true : undefined));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return TableStyleRowProperties;
+}());
+export { TableStyleRowProperties };
+/**
+ * Cell properties on a table style (`w:tcPr`).
+ *
+ * @public
+ */
+var TableStyleCellProperties = /** @class */ (function () {
+    /** @private */
+    function TableStyleCellProperties(owner, isConditional) {
+        if (isConditional === void 0) { isConditional = false; }
+        this.owner = owner;
+        this.isConditional = isConditional;
+    }
+    TableStyleCellProperties.prototype.readTcPr = function () {
+        if (this.isConditional) {
+            return this.owner.readChild('tcPr');
+        }
+        return this.owner.readBaseChild('tcPr');
+    };
+    TableStyleCellProperties.prototype.writeTcPr = function (next) {
+        if (this.isConditional) {
+            this.owner.writeChild('tcPr', next);
+            return;
+        }
+        this.owner.writeBaseChild('tcPr', next);
+    };
+    Object.defineProperty(TableStyleCellProperties.prototype, "borders", {
+        get: function () {
+            if (this.bordersInstance === undefined) {
+                var self_3 = this;
+                var host = {
+                    readEdge: function (key) {
+                        var pr = self_3.readTcPr();
+                        if (pr === undefined) {
+                            return undefined;
+                        }
+                        var bag = readCellBorders(pr);
+                        return bag !== undefined ? bag[key] : undefined;
+                    },
+                    writeEdge: function (key, edge) {
+                        var pr = self_3.readTcPr() !== undefined ? self_3.readTcPr() : wmlElement('tcPr');
+                        var current = readCellBorders(pr) !== undefined ? __assign({}, readCellBorders(pr)) : {};
+                        if (edge === undefined) {
+                            delete current[key];
+                        }
+                        else {
+                            current[key] = edge;
+                        }
+                        var keys = Object.keys(current);
+                        var nextBag = keys.length > 0 ? current : undefined;
+                        self_3.writeTcPr(writeCellBorders(pr, nextBag));
+                    },
+                };
+                this.bordersInstance = new Borders(host);
+            }
+            return this.bordersInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleCellProperties.prototype, "paddings", {
+        get: function () {
+            if (this.paddingsInstance === undefined) {
+                var self_4 = this;
+                var host = {
+                    read: function () {
+                        var pr = self_4.readTcPr();
+                        return pr !== undefined ? readCellMargins(pr) : undefined;
+                    },
+                    write: function (value) {
+                        var pr = self_4.readTcPr() !== undefined ? self_4.readTcPr() : wmlElement('tcPr');
+                        self_4.writeTcPr(writeCellMargins(pr, value));
+                    },
+                };
+                this.paddingsInstance = new Paddings(host);
+            }
+            return this.paddingsInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleCellProperties.prototype, "backgroundColor", {
+        get: function () {
+            var pr = this.readTcPr();
+            var shd = pr !== undefined ? readCellShading(pr) : undefined;
+            if (shd === undefined || shd.fill === undefined) {
+                return undefined;
+            }
+            return colorFromWire(shd.fill);
+        },
+        set: function (value) {
+            var pr = this.readTcPr() !== undefined ? this.readTcPr() : wmlElement('tcPr');
+            var current = readCellShading(pr);
+            if (value === undefined) {
+                if (current === undefined) {
+                    return;
+                }
+                var next_1 = __assign({}, current);
+                delete next_1.fill;
+                var empty = next_1.fill === undefined && next_1.color === undefined && next_1.pattern === undefined;
+                this.writeTcPr(writeCellShading(pr, empty ? undefined : next_1));
+                return;
+            }
+            var fill = colorToHexWire(value);
+            if (fill.length === 0) {
+                // Transparent → clear fill like character textBackgroundColor path.
+                if (current === undefined) {
+                    return;
+                }
+                var next_2 = __assign({}, current);
+                delete next_2.fill;
+                var empty = next_2.fill === undefined && next_2.color === undefined && next_2.pattern === undefined;
+                this.writeTcPr(writeCellShading(pr, empty ? undefined : next_2));
+                return;
+            }
+            // DocIO direct-format bag: clear + auto + fill (same shape as CellFormat.backColor).
+            var pattern = current !== undefined &&
+                current.pattern !== undefined &&
+                current.pattern.length > 0
+                ? current.pattern
+                : 'clear';
+            var shdColor = current !== undefined && current.color !== undefined && current.color.length > 0
+                ? current.color
+                : 'auto';
+            var next = {
+                fill: fill,
+                color: shdColor,
+                pattern: pattern,
+            };
+            this.writeTcPr(writeCellShading(pr, next));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleCellProperties.prototype, "verticalAlignment", {
+        get: function () {
+            var pr = this.readTcPr();
+            return pr !== undefined ? readCellVerticalAlignment(pr) : undefined;
+        },
+        set: function (value) {
+            var pr = this.readTcPr() !== undefined ? this.readTcPr() : wmlElement('tcPr');
+            this.writeTcPr(writeCellVerticalAlignment(pr, value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleCellProperties.prototype, "textDirection", {
+        get: function () {
+            var pr = this.readTcPr();
+            return pr !== undefined ? readCellTextDirection(pr) : undefined;
+        },
+        set: function (value) {
+            var pr = this.readTcPr() !== undefined ? this.readTcPr() : wmlElement('tcPr');
+            this.writeTcPr(writeCellTextDirection(pr, value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleCellProperties.prototype, "preferredWidth", {
+        /** @private */
+        get: function () {
+            var pr = this.readTcPr();
+            return pr !== undefined ? readCellPreferredWidth(pr) : undefined;
+        },
+        set: function (value) {
+            var pr = this.readTcPr() !== undefined ? this.readTcPr() : wmlElement('tcPr');
+            this.writeTcPr(writeCellPreferredWidth(pr, value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleCellProperties.prototype, "horizontalMerge", {
+        /** @private style-level only; does not mutate body grid merges. */
+        get: function () {
+            var pr = this.readTcPr();
+            return pr !== undefined ? readHorizontalMerge(pr) : undefined;
+        },
+        set: function (value) {
+            var pr = this.readTcPr() !== undefined ? this.readTcPr() : wmlElement('tcPr');
+            this.writeTcPr(writeHorizontalMerge(pr, value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleCellProperties.prototype, "verticalMerge", {
+        /** @private */
+        get: function () {
+            var pr = this.readTcPr();
+            return pr !== undefined ? readVerticalMerge(pr) : undefined;
+        },
+        set: function (value) {
+            var pr = this.readTcPr() !== undefined ? this.readTcPr() : wmlElement('tcPr');
+            this.writeTcPr(writeVerticalMerge(pr, value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return TableStyleCellProperties;
+}());
+export { TableStyleCellProperties };
+/**
+ * One conditional formatting block (`w:tblStylePr`).
+ *
+ * @public
+ */
+var ConditionalFormattingStyle = /** @class */ (function () {
+    /** @private */
+    function ConditionalFormattingStyle(parent, type, element) {
+        this.parent = parent;
+        this.typeValue = type;
+        this.element = element;
+    }
+    Object.defineProperty(ConditionalFormattingStyle.prototype, "conditionalFormattingType", {
+        get: function () {
+            return this.typeValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ConditionalFormattingStyle.prototype, "characterFormat", {
+        get: function () {
+            if (this.characterFormatInstance === undefined) {
+                this.characterFormatInstance = new CharacterFormat(this);
+                var rPr = this.readChild('rPr');
+                if (rPr !== undefined) {
+                    this.characterFormatInstance.hydrate(parseCharacterFormat(rPr));
+                }
+            }
+            return this.characterFormatInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ConditionalFormattingStyle.prototype, "paragraphFormat", {
+        get: function () {
+            if (this.paragraphFormatInstance === undefined) {
+                this.paragraphFormatInstance = new ParagraphFormat(this);
+                var pPr = this.readChild('pPr');
+                if (pPr !== undefined) {
+                    this.paragraphFormatInstance.hydrate(parseParagraphFormat(pPr));
+                }
+            }
+            return this.paragraphFormatInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ConditionalFormattingStyle.prototype, "rowProperties", {
+        get: function () {
+            if (this.rowPropertiesInstance === undefined) {
+                this.rowPropertiesInstance = new TableStyleRowProperties(this, true);
+            }
+            return this.rowPropertiesInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ConditionalFormattingStyle.prototype, "cellProperties", {
+        get: function () {
+            if (this.cellPropertiesInstance === undefined) {
+                this.cellPropertiesInstance = new TableStyleCellProperties(this, true);
+            }
+            return this.cellPropertiesInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ConditionalFormattingStyle.prototype, "tableProperties", {
+        /** Conditional table properties (`w:tblPr` inside tblStylePr). */
+        get: function () {
+            if (this.tablePropertiesInstance === undefined) {
+                this.tablePropertiesInstance = new TableStyleTablePropertiesBridge(this);
+            }
+            return this.tablePropertiesInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /** @private */
+    ConditionalFormattingStyle.prototype.notifyCharacterFormatMutation = function () {
+        this.syncFormatsToElement();
+        this.parent.replaceConditionalElement(this.typeValue, this.element);
+    };
+    /** @private */
+    ConditionalFormattingStyle.prototype.notifyParagraphFormatMutation = function () {
+        this.syncFormatsToElement();
+        this.parent.replaceConditionalElement(this.typeValue, this.element);
+    };
+    /** @private */
+    ConditionalFormattingStyle.prototype.notifyStructureMutation = function () {
+        this.parent.replaceConditionalElement(this.typeValue, this.element);
+    };
+    ConditionalFormattingStyle.prototype.syncFormatsToElement = function () {
+        // Apply format bags without nested notifyStructureMutation mid-sync.
+        if (this.characterFormatInstance !== undefined) {
+            var kids = buildRPrChildrenFromSnapshot(this.characterFormatInstance.snapshot());
+            this.writeChildInternal('rPr', kids.length > 0 ? wmlElement('rPr', { children: kids }) : undefined, false);
+        }
+        if (this.paragraphFormatInstance !== undefined) {
+            var kids = buildPPrChildrenFromSnapshot(this.paragraphFormatInstance.snapshot());
+            this.writeChildInternal('pPr', kids.length > 0 ? wmlElement('pPr', { children: kids }) : undefined, false);
+        }
+    };
+    /** @private */
+    ConditionalFormattingStyle.prototype.readChild = function (localName) {
+        var kids = elementChildren(this.element);
+        for (var i = 0; i < kids.length; i += 1) {
+            if (isWml(kids[i], localName)) {
+                return kids[i];
+            }
+        }
+        return undefined;
+    };
+    /**
+     * Replace/remove a property child and keep OOXML child order.
+     * @private
+     */
+    ConditionalFormattingStyle.prototype.writeChild = function (localName, next) {
+        this.writeChildInternal(localName, next, true);
+    };
+    ConditionalFormattingStyle.prototype.writeChildInternal = function (localName, next, notifyParent) {
+        var kids = elementChildren(this.element);
+        var out = [];
+        var replaced = false;
+        for (var i = 0; i < kids.length; i += 1) {
+            var child = kids[i];
+            if (isWml(child, localName)) {
+                if (!replaced && next !== undefined) {
+                    out.push(next);
+                }
+                replaced = true;
+                continue;
+            }
+            out.push(child);
+        }
+        if (!replaced && next !== undefined) {
+            out.push(next);
+        }
+        var ordered = orderTblStylePrChildren(out);
+        this.element = wmlElement('tblStylePr', {
+            attributes: this.element.attributes,
+            namespaceDeclarations: this.element.namespaceDeclarations,
+            children: ordered,
+        });
+        if (notifyParent) {
+            this.notifyStructureMutation();
+        }
+    };
+    /** @private */
+    ConditionalFormattingStyle.prototype.toElement = function () {
+        this.syncFormatsToElement();
+        // Ensure order even if only opaque trPr/tcPr mutated without CF/PF.
+        this.element = orderTblStylePrElement(this.element);
+        return this.element;
+    };
+    return ConditionalFormattingStyle;
+}());
+export { ConditionalFormattingStyle };
+/**
+ * Minimal table-props bridge for conditional blocks (borders/shading subset).
+ *
+ * @public
+ */
+var TableStyleTablePropertiesBridge = /** @class */ (function () {
+    /** @private */
+    function TableStyleTablePropertiesBridge(owner) {
+        this.owner = owner;
+    }
+    TableStyleTablePropertiesBridge.prototype.readTblPr = function () {
+        return this.owner.readChild('tblPr');
+    };
+    TableStyleTablePropertiesBridge.prototype.writeTblPr = function (next) {
+        this.owner.writeChild('tblPr', next);
+    };
+    Object.defineProperty(TableStyleTablePropertiesBridge.prototype, "borders", {
+        get: function () {
+            if (this.bordersInstance === undefined) {
+                var self_5 = this;
+                var host = {
+                    readEdge: function (key) {
+                        var pr = self_5.readTblPr();
+                        if (pr === undefined) {
+                            return undefined;
+                        }
+                        var bag = readTableBorders(pr);
+                        return bag !== undefined ? bag[key] : undefined;
+                    },
+                    writeEdge: function (key, edge) {
+                        var pr = self_5.readTblPr() !== undefined ? self_5.readTblPr() : wmlElement('tblPr');
+                        var current = readTableBorders(pr) !== undefined ? __assign({}, readTableBorders(pr)) : {};
+                        if (edge === undefined) {
+                            delete current[key];
+                        }
+                        else {
+                            current[key] = edge;
+                        }
+                        var keys = Object.keys(current);
+                        self_5.writeTblPr(writeTableBorders(pr, keys.length > 0 ? current : undefined));
+                    },
+                };
+                this.bordersInstance = new Borders(host);
+            }
+            return this.bordersInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyleTablePropertiesBridge.prototype, "shading", {
+        get: function () {
+            var pr = this.readTblPr();
+            return pr !== undefined ? readTableShading(pr) : undefined;
+        },
+        set: function (value) {
+            var pr = this.readTblPr() !== undefined ? this.readTblPr() : wmlElement('tblPr');
+            this.writeTblPr(writeTableShading(pr, value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return TableStyleTablePropertiesBridge;
+}());
+export { TableStyleTablePropertiesBridge };
+/**
+ * Collection of conditional formatting styles on a TableStyle.
+ *
+ * @public
+ */
+var ConditionalFormattingStyleCollection = /** @class */ (function () {
+    /** @private */
+    function ConditionalFormattingStyleCollection(owner) {
+        this.owner = owner;
+    }
+    Object.defineProperty(ConditionalFormattingStyleCollection.prototype, "count", {
+        get: function () {
+            return this.owner.listConditional().length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ConditionalFormattingStyleCollection.prototype.item = function (index) {
+        var list = this.owner.listConditional();
+        if (index < 0 || index >= list.length) {
+            throw new RangeError('Conditional formatting index out of range');
+        }
+        return list[index];
+    };
+    ConditionalFormattingStyleCollection.prototype.findByType = function (type) {
+        var list = this.owner.listConditional();
+        for (var i = 0; i < list.length; i += 1) {
+            if (list[i].conditionalFormattingType === type) {
+                return list[i];
+            }
+        }
+        return undefined;
+    };
+    ConditionalFormattingStyleCollection.prototype.add = function (type) {
+        var existing = this.findByType(type);
+        if (existing !== undefined) {
+            return existing;
+        }
+        var el = wmlElement('tblStylePr', {
+            attributes: [wmlAttr('type', type)],
+            children: [],
+        });
+        return this.owner.addConditionalElement(type, el);
+    };
+    ConditionalFormattingStyleCollection.prototype.clear = function () {
+        this.owner.clearConditionals();
+    };
+    return ConditionalFormattingStyleCollection;
+}());
+export { ConditionalFormattingStyleCollection };
+/**
+ * Live table style (`w:style` type=table).
+ *
+ * @public
+ */
+var TableStyle = /** @class */ (function (_super) {
+    __extends(TableStyle, _super);
+    /** @private */
+    function TableStyle(shell, host) {
+        var _this = _super.call(this, shell.styleId, 'table', shell.default, shell.customStyle) || this;
+        _this.host = host;
+        _this.paragraphFormatValue = new ParagraphFormat(_this);
+        _this.hydrateFromDocxStyle(shell);
+        return _this;
+    }
+    /** @private */
+    TableStyle.prototype.bindHost = function (host) {
+        this.host = host;
+    };
+    Object.defineProperty(TableStyle.prototype, "paragraphFormat", {
+        /**
+         * Style-level paragraph formatting (`w:pPr`). Stable facade identity.
+         *
+         * @public
+         */
+        get: function () {
+            return this.paragraphFormatValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyle.prototype, "tableProperties", {
+        get: function () {
+            if (this.tablePropertiesInstance === undefined) {
+                this.tablePropertiesInstance = new TableStyleTableProperties(this);
+            }
+            return this.tablePropertiesInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyle.prototype, "rowProperties", {
+        get: function () {
+            if (this.rowPropertiesInstance === undefined) {
+                this.rowPropertiesInstance = new TableStyleRowProperties(this, false);
+            }
+            return this.rowPropertiesInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyle.prototype, "cellProperties", {
+        get: function () {
+            if (this.cellPropertiesInstance === undefined) {
+                this.cellPropertiesInstance = new TableStyleCellProperties(this, false);
+            }
+            return this.cellPropertiesInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableStyle.prototype, "conditionalFormattingStyles", {
+        /**
+         * Conditional table formatting styles (`w:tblStylePr`).
+         *
+         * @public
+         */
+        get: function () {
+            if (this.conditionalCollection === undefined) {
+                this.conditionalCollection = new ConditionalFormattingStyleCollection(this);
+            }
+            return this.conditionalCollection;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    TableStyle.prototype.hydrateParagraphFormat = function (snapshot) {
+        // Called from Style.hydrateFromDocxStyle (suppressDirty already true).
+        this.paragraphFormatValue.hydrate(snapshot);
+    };
+    /**
+     * @private
+     */
+    TableStyle.prototype.serializeParagraphProperties = function (out) {
+        var children = this.paragraphFormatValue.buildPPrChildren();
+        if (children.length > 0) {
+            out.push(wmlElement('pPr', { children: children }));
+        }
+    };
+    /**
+     * Table styles require schema order: meta → pPr → rPr → tblPr → trPr → tcPr → tblStylePr*.
+     * Base {@link Style.serialize} emits opaque children before pPr/rPr; reorder here.
+     *
+     * @private
+     */
+    TableStyle.prototype.serialize = function () {
+        var raw = _super.prototype.serialize.call(this);
+        return orderTableStyleElement(raw);
+    };
+    /** @private */
+    TableStyle.prototype.notifyCharacterFormatMutation = function () {
+        // Base Style facade is source of truth; serialize emits w:rPr.
+        _super.prototype.notifyCharacterFormatMutation.call(this);
+        this.notifyHost();
+    };
+    /** @private */
+    TableStyle.prototype.notifyParagraphFormatMutation = function () {
+        this.ensureAttached();
+        this.markDirty();
+        this.notifyHost();
+    };
+    TableStyle.prototype.notifyHost = function () {
+        if (this.host !== undefined) {
+            this.host.notifyTableStyleMutation();
+        }
+    };
+    /**
+     * @private
+     * Read a base property child from the style shell (pPr/rPr/tblPr/trPr/tcPr).
+     */
+    TableStyle.prototype.readBaseChild = function (localName) {
+        var serialized = this.toDocxStyle().serialize();
+        var kids = elementChildren(serialized);
+        for (var i = 0; i < kids.length; i += 1) {
+            if (isWml(kids[i], localName)) {
+                return kids[i];
+            }
+        }
+        return undefined;
+    };
+    /**
+     * @private
+     * Replace a base property child and rewrite the DocxStyle shell.
+     */
+    TableStyle.prototype.writeBaseChild = function (localName, next) {
+        var shell = this.toDocxStyle();
+        var root = shell.serialize();
+        var kids = elementChildren(root);
+        var out = [];
+        var replaced = false;
+        for (var i = 0; i < kids.length; i += 1) {
+            var child = kids[i];
+            if (isWml(child, localName) && localName !== 'tblStylePr') {
+                if (!replaced && next !== undefined) {
+                    out.push(next);
+                }
+                replaced = true;
+                continue;
+            }
+            out.push(child);
+        }
+        if (!replaced && next !== undefined) {
+            out.push(next);
+        }
+        this.replaceShellFromChildren(shell, root, out);
+        this.conditionalCache = undefined;
+        this.notifyHost();
+    };
+    TableStyle.prototype.replaceShellFromChildren = function (shell, root, children) {
+        // Always persist schema-ordered children so hydrate opaque order is stable.
+        var orderedRoot = orderTableStyleElement(wmlElement('style', {
+            attributes: root.attributes,
+            namespaceDeclarations: root.namespaceDeclarations,
+            children: children,
+        }));
+        var orderedKids = elementChildren(orderedRoot);
+        var parsed = parseDocxStyle(orderedRoot);
+        if (parsed !== undefined) {
+            this.replaceShell(parsed);
+        }
+        else {
+            void shell;
+            this.replaceShell(new DocxStyle(this.styleId, 'table', undefined, undefined, orderedKids.slice()));
+        }
+    };
+    /** @private */
+    TableStyle.prototype.listConditional = function () {
+        if (this.conditionalCache !== undefined) {
+            return this.conditionalCache;
+        }
+        var root = this.toDocxStyle().serialize();
+        var kids = elementChildren(root);
+        var list = [];
+        for (var i = 0; i < kids.length; i += 1) {
+            var child = kids[i];
+            if (!isWml(child, 'tblStylePr')) {
+                continue;
+            }
+            var typeRaw = wValAttribute(child) !== undefined ? wValAttribute(child) : attrLocal(child, 'type');
+            if (typeRaw === undefined || !isConditionalType(typeRaw)) {
+                continue;
+            }
+            list.push(new ConditionalFormattingStyle(this, typeRaw, child));
+        }
+        this.conditionalCache = list;
+        return list;
+    };
+    /** @private */
+    TableStyle.prototype.addConditionalElement = function (type, el) {
+        var orderedEl = orderTblStylePrElement(el);
+        var shell = this.toDocxStyle();
+        var root = shell.serialize();
+        var kids = elementChildren(root).slice();
+        kids.push(orderedEl);
+        this.replaceShellFromChildren(shell, root, kids);
+        this.conditionalCache = undefined;
+        this.notifyHost();
+        return new ConditionalFormattingStyle(this, type, orderedEl);
+    };
+    /** @private */
+    TableStyle.prototype.replaceConditionalElement = function (type, el) {
+        var orderedEl = orderTblStylePrElement(el);
+        var shell = this.toDocxStyle();
+        var root = shell.serialize();
+        var kids = elementChildren(root);
+        var out = [];
+        var replaced = false;
+        for (var i = 0; i < kids.length; i += 1) {
+            var child = kids[i];
+            if (isWml(child, 'tblStylePr')) {
+                var typeRaw = wValAttribute(child) !== undefined ? wValAttribute(child) : attrLocal(child, 'type');
+                if (typeRaw === type) {
+                    if (!replaced) {
+                        out.push(orderedEl);
+                        replaced = true;
+                    }
+                    continue;
+                }
+            }
+            out.push(child);
+        }
+        if (!replaced) {
+            out.push(orderedEl);
+        }
+        this.replaceShellFromChildren(shell, root, out);
+        this.conditionalCache = undefined;
+        this.notifyHost();
+    };
+    /** @private */
+    TableStyle.prototype.clearConditionals = function () {
+        var shell = this.toDocxStyle();
+        var root = shell.serialize();
+        var kids = elementChildren(root).filter(function (c) { return !isWml(c, 'tblStylePr'); });
+        this.replaceShellFromChildren(shell, root, kids);
+        this.conditionalCache = undefined;
+        this.notifyHost();
+    };
+    return TableStyle;
+}(Style));
+export { TableStyle };