@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/tables/format.js

@@ -0,0 +1,716 @@
+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 / row / cell format facades and positioning (DocIO-aligned).
+ *
+ * @public
+ */
+import { createTableBordersHost, createCellBordersHost, Borders } from './borders';
+import { Paddings } from './paddings';
+import { readTableAlignment, readTableBorders, readTableCellMargins, readTableCellSpacing, readTableLayout, readTablePreferredWidth, readTableShading, writeTableAlignment, writeTableBorders, writeTableCellMargins, writeTableCellSpacing, writeTableLayout, writeTablePreferredWidth, writeTableShading, twipsToPoint, pointToTwips, } from './tbl-pr';
+import { readRowCantSplit, readRowShading, writeRowCantSplit, writeRowShading, } from './tr-pr';
+import { readCellBorders, readCellFitText, readCellMargins, readCellNoWrap, readCellShading, readCellTextDirection, readCellVerticalAlignment, readGridSpan, readHorizontalMerge, readIsSamePaddingsAsTable, readVerticalMerge, writeCellBorders, writeCellFitText, writeCellMargins, writeCellNoWrap, writeCellShading, writeCellTextDirection, writeCellVerticalAlignment, writeGridSpan, writeHorizontalMerge, writeIsSamePaddingsAsTable, writeVerticalMerge, } from './tc-pr';
+import { readTablePositioning, writeTablePositioning, } from './tbl-pr-positioning';
+import { colorToHexWire, normalizeColorHex } from '../document/color';
+/**
+ * Horizontal merge / vertical merge token (`ST_Merge` mapping).
+ *
+ * @public
+ */
+export var CellMerge = {
+    None: 'none',
+    Start: 'start',
+    Continue: 'continue',
+};
+/**
+ * Horizontal origin for floating table position (`w:tblpPr/@w:horzAnchor`).
+ *
+ * @public
+ */
+export var TableHorizontalOrigin = {
+    Margin: 'margin',
+    Page: 'page',
+    Column: 'column',
+};
+/**
+ * Vertical origin for floating table position (`w:tblpPr/@w:vertAnchor`).
+ *
+ * @public
+ */
+export var TableVerticalOrigin = {
+    Margin: 'margin',
+    Page: 'page',
+    Paragraph: 'paragraph',
+};
+function shdFill(shd) {
+    return shd == null ? undefined : shd.fill;
+}
+/**
+ * Normalize table/row/cell shading fill input to OOXML wire (`RRGGBB` / `'auto'`).
+ * {@link Color} becomes hex. {@link Color.Transparent} and empty tokens clear fill
+ * (`undefined`) — never invent `fill="auto"` for “no color” authoring.
+ * Explicit string `'auto'` is preserved for load-path / intentional wire parity.
+ * Strings may include a leading `#`; unknown non-hex tokens pass through for load-path compatibility.
+ * @private
+ */
+function shadingFillToWire(value) {
+    if (typeof value === 'number') {
+        var hex_1 = colorToHexWire(value);
+        // Transparent (empty hex) clears fill; do not map to wire `auto`.
+        return hex_1.length > 0 ? hex_1 : undefined;
+    }
+    var raw = value.trim();
+    if (raw.length === 0) {
+        return undefined;
+    }
+    if (raw.toLowerCase() === 'auto') {
+        return 'auto';
+    }
+    var hex = normalizeColorHex(raw);
+    return hex !== undefined ? hex : value;
+}
+/**
+ * Build a `w:shd` bag from a fill wire value.
+ * When a fill is authored, default `pattern` to `clear` and `color` to `auto`
+ * (DocIO / Word direct-format shape) unless previous shading already set them.
+ * Never invents `fill: 'auto'` unless the caller passed that wire value.
+ * Clearing fill drops a DocIO-default-only remainder (`clear`/`auto`) so bare
+ * `w:shd` without a real fill is not left behind.
+ *
+ * @private
+ */
+function shdFromFill(fill, prev) {
+    if (fill === undefined) {
+        if (prev === undefined) {
+            return undefined;
+        }
+        var patternLeft = prev.pattern;
+        var colorLeft = prev.color;
+        // clear + auto (or absent) is only the DocIO default envelope for a real fill.
+        var onlyDocIoDefaults = (patternLeft === undefined || patternLeft === 'clear') &&
+            (colorLeft === undefined || colorLeft === 'auto');
+        if (onlyDocIoDefaults) {
+            return undefined;
+        }
+        if (colorLeft === undefined && patternLeft === undefined) {
+            return undefined;
+        }
+        return __assign({}, (colorLeft !== undefined ? { color: colorLeft } : {}), (patternLeft !== undefined ? { pattern: patternLeft } : {}));
+    }
+    // DocIO cell/table backColor: val="clear" color="auto" fill="<hex|auto>"
+    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';
+    return {
+        fill: fill,
+        color: color,
+        pattern: pattern,
+    };
+}
+function wireMergeToCellMerge(v) {
+    if (v === 'restart') {
+        return CellMerge.Start;
+    }
+    if (v === 'continue') {
+        return CellMerge.Continue;
+    }
+    return CellMerge.None;
+}
+function cellMergeToWire(v) {
+    if (v === CellMerge.Start) {
+        return 'restart';
+    }
+    if (v === CellMerge.Continue) {
+        return 'continue';
+    }
+    return undefined;
+}
+/**
+ * Floating table position (`w:tblpPr`).
+ *
+ * @public
+ */
+var TablePositioning = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function TablePositioning(host) {
+        this.host = host;
+    }
+    TablePositioning.prototype.readBag = function () {
+        var bag = readTablePositioning(this.host.readTblPr());
+        return bag !== undefined ? bag : {};
+    };
+    TablePositioning.prototype.writeBag = function (next) {
+        this.host.writeTblPr(writeTablePositioning(this.host.readTblPr(), next));
+    };
+    Object.defineProperty(TablePositioning.prototype, "horizontalPosition", {
+        get: function () {
+            var v = this.readBag().horizontalPosition;
+            return v !== undefined ? v : 0;
+        },
+        set: function (value) {
+            var prev = this.readBag();
+            this.writeBag({
+                horizontalPosition: value,
+                verticalPosition: prev.verticalPosition,
+                horizontalOrigin: prev.horizontalOrigin,
+                verticalOrigin: prev.verticalOrigin,
+                distanceFromTop: prev.distanceFromTop,
+                distanceFromBottom: prev.distanceFromBottom,
+                distanceFromLeft: prev.distanceFromLeft,
+                distanceFromRight: prev.distanceFromRight,
+                unknownAttributes: prev.unknownAttributes,
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TablePositioning.prototype, "verticalPosition", {
+        get: function () {
+            var v = this.readBag().verticalPosition;
+            return v !== undefined ? v : 0;
+        },
+        set: function (value) {
+            var prev = this.readBag();
+            this.writeBag({
+                horizontalPosition: prev.horizontalPosition,
+                verticalPosition: value,
+                horizontalOrigin: prev.horizontalOrigin,
+                verticalOrigin: prev.verticalOrigin,
+                distanceFromTop: prev.distanceFromTop,
+                distanceFromBottom: prev.distanceFromBottom,
+                distanceFromLeft: prev.distanceFromLeft,
+                distanceFromRight: prev.distanceFromRight,
+                unknownAttributes: prev.unknownAttributes,
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TablePositioning.prototype, "horizontalOrigin", {
+        get: function () {
+            var v = this.readBag().horizontalOrigin;
+            return v !== undefined ? v : TableHorizontalOrigin.Margin;
+        },
+        set: function (value) {
+            var prev = this.readBag();
+            this.writeBag({
+                horizontalPosition: prev.horizontalPosition,
+                verticalPosition: prev.verticalPosition,
+                horizontalOrigin: value,
+                verticalOrigin: prev.verticalOrigin,
+                distanceFromTop: prev.distanceFromTop,
+                distanceFromBottom: prev.distanceFromBottom,
+                distanceFromLeft: prev.distanceFromLeft,
+                distanceFromRight: prev.distanceFromRight,
+                unknownAttributes: prev.unknownAttributes,
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TablePositioning.prototype, "verticalOrigin", {
+        get: function () {
+            var v = this.readBag().verticalOrigin;
+            return v !== undefined ? v : TableVerticalOrigin.Margin;
+        },
+        set: function (value) {
+            var prev = this.readBag();
+            this.writeBag({
+                horizontalPosition: prev.horizontalPosition,
+                verticalPosition: prev.verticalPosition,
+                horizontalOrigin: prev.horizontalOrigin,
+                verticalOrigin: value,
+                distanceFromTop: prev.distanceFromTop,
+                distanceFromBottom: prev.distanceFromBottom,
+                distanceFromLeft: prev.distanceFromLeft,
+                distanceFromRight: prev.distanceFromRight,
+                unknownAttributes: prev.unknownAttributes,
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TablePositioning.prototype, "distanceFromTop", {
+        get: function () {
+            var v = this.readBag().distanceFromTop;
+            return v !== undefined ? v : 0;
+        },
+        set: function (value) {
+            var prev = this.readBag();
+            this.writeBag({
+                horizontalPosition: prev.horizontalPosition,
+                verticalPosition: prev.verticalPosition,
+                horizontalOrigin: prev.horizontalOrigin,
+                verticalOrigin: prev.verticalOrigin,
+                distanceFromTop: value,
+                distanceFromBottom: prev.distanceFromBottom,
+                distanceFromLeft: prev.distanceFromLeft,
+                distanceFromRight: prev.distanceFromRight,
+                unknownAttributes: prev.unknownAttributes,
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TablePositioning.prototype, "distanceFromBottom", {
+        get: function () {
+            var v = this.readBag().distanceFromBottom;
+            return v !== undefined ? v : 0;
+        },
+        set: function (value) {
+            var prev = this.readBag();
+            this.writeBag({
+                horizontalPosition: prev.horizontalPosition,
+                verticalPosition: prev.verticalPosition,
+                horizontalOrigin: prev.horizontalOrigin,
+                verticalOrigin: prev.verticalOrigin,
+                distanceFromTop: prev.distanceFromTop,
+                distanceFromBottom: value,
+                distanceFromLeft: prev.distanceFromLeft,
+                distanceFromRight: prev.distanceFromRight,
+                unknownAttributes: prev.unknownAttributes,
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TablePositioning.prototype, "distanceFromLeft", {
+        get: function () {
+            var v = this.readBag().distanceFromLeft;
+            return v !== undefined ? v : 0;
+        },
+        set: function (value) {
+            var prev = this.readBag();
+            this.writeBag({
+                horizontalPosition: prev.horizontalPosition,
+                verticalPosition: prev.verticalPosition,
+                horizontalOrigin: prev.horizontalOrigin,
+                verticalOrigin: prev.verticalOrigin,
+                distanceFromTop: prev.distanceFromTop,
+                distanceFromBottom: prev.distanceFromBottom,
+                distanceFromLeft: value,
+                distanceFromRight: prev.distanceFromRight,
+                unknownAttributes: prev.unknownAttributes,
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TablePositioning.prototype, "distanceFromRight", {
+        get: function () {
+            var v = this.readBag().distanceFromRight;
+            return v !== undefined ? v : 0;
+        },
+        set: function (value) {
+            var prev = this.readBag();
+            this.writeBag({
+                horizontalPosition: prev.horizontalPosition,
+                verticalPosition: prev.verticalPosition,
+                horizontalOrigin: prev.horizontalOrigin,
+                verticalOrigin: prev.verticalOrigin,
+                distanceFromTop: prev.distanceFromTop,
+                distanceFromBottom: prev.distanceFromBottom,
+                distanceFromLeft: prev.distanceFromLeft,
+                distanceFromRight: value,
+                unknownAttributes: prev.unknownAttributes,
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return TablePositioning;
+}());
+export { TablePositioning };
+/**
+ * Table-level formatting surface.
+ *
+ * @public
+ */
+var TableFormat = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function TableFormat(host) {
+        var _this = this;
+        this.host = host;
+        this.bordersInstance = new Borders(createTableBordersHost(function () { return readTableBorders(_this.host.readTblPr()); }, function (value) {
+            _this.host.writeTblPr(writeTableBorders(_this.host.readTblPr(), value));
+        }), true);
+        var padHost = {
+            read: function () { return readTableCellMargins(_this.host.readTblPr()); },
+            write: function (value) {
+                _this.host.writeTblPr(writeTableCellMargins(_this.host.readTblPr(), value));
+            },
+        };
+        this.paddingsInstance = new Paddings(padHost);
+        this.positioningInstance = new TablePositioning(host);
+    }
+    Object.defineProperty(TableFormat.prototype, "borders", {
+        get: function () {
+            return this.bordersInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableFormat.prototype, "paddings", {
+        get: function () {
+            return this.paddingsInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableFormat.prototype, "positioning", {
+        get: function () {
+            return this.positioningInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableFormat.prototype, "horizontalAlignment", {
+        get: function () {
+            var value = readTableAlignment(this.host.readTblPr());
+            return value !== undefined ? value : 'left';
+        },
+        set: function (value) {
+            if (value !== 'left' && value !== 'center' && value !== 'right') {
+                throw new RangeError('Unsupported TableAlignment value');
+            }
+            this.host.writeTblPr(writeTableAlignment(this.host.readTblPr(), value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableFormat.prototype, "cellSpacing", {
+        get: function () {
+            var value = readTableCellSpacing(this.host.readTblPr());
+            return value !== undefined ? value : 0;
+        },
+        set: function (value) {
+            if (typeof value !== 'number' || !isFinite(value) || value < 0) {
+                throw new RangeError('cellSpacing must be a finite non-negative number');
+            }
+            this.host.writeTblPr(writeTableCellSpacing(this.host.readTblPr(), value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableFormat.prototype, "backColor", {
+        /**
+         * Table background fill (`w:tblPr/w:shd/@w:fill`).
+         *
+         * - **Get (runtime)**: OOXML wire string — hex `RRGGBB`, `'auto'`, or `undefined` when unset.
+         * - **Set**: hex string / `'auto'` (optional leading `#`), a {@link Color} enum value, or
+         *   `undefined` to clear the authored fill. {@link Color.Transparent} clears fill
+         *   (does not invent `w:fill="auto"`).
+         *
+         * TypeScript 3.3 requires identical get/set types, so the declared type is
+         * `string | Color | undefined`; the getter always returns a string when set.
+         */
+        get: function () {
+            return shdFill(readTableShading(this.host.readTblPr()));
+        },
+        set: function (value) {
+            var prev = readTableShading(this.host.readTblPr());
+            var wire = value === undefined ? undefined : shadingFillToWire(value);
+            this.host.writeTblPr(writeTableShading(this.host.readTblPr(), shdFromFill(wire, prev)));
+            // DocIO writes the same fill onto each cell so tcPr/shd carries the color.
+            var apply = this.host.applyTableBackColorToCells;
+            if (apply !== undefined) {
+                apply.call(this.host, wire);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableFormat.prototype, "wrapAround", {
+        /**
+         * When `true`, text may wrap around a floating table (`w:tblpPr` present).
+         * When `false`, the table is inline (no `w:tblpPr`).
+         */
+        get: function () {
+            return readTablePositioning(this.host.readTblPr()) !== undefined;
+        },
+        set: function (value) {
+            if (value) {
+                var existing = readTablePositioning(this.host.readTblPr());
+                if (existing === undefined) {
+                    this.host.writeTblPr(writeTablePositioning(this.host.readTblPr(), {}));
+                }
+                return;
+            }
+            this.host.writeTblPr(writeTablePositioning(this.host.readTblPr(), undefined));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableFormat.prototype, "isAutoResized", {
+        /**
+         * Inverse of fixed layout: `true` when layout is autoFit (default).
+         */
+        get: function () {
+            return readTableLayout(this.host.readTblPr()) !== 'fixed';
+        },
+        set: function (value) {
+            var layout = value ? 'autoFit' : 'fixed';
+            this.host.writeTblPr(writeTableLayout(this.host.readTblPr(), layout));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableFormat.prototype, "preferredWidth", {
+        /**
+         * @private
+         * Preferred width bag used by AutoFit / width helpers.
+         */
+        get: function () {
+            return readTablePreferredWidth(this.host.readTblPr());
+        },
+        set: function (value) {
+            this.host.writeTblPr(writeTablePreferredWidth(this.host.readTblPr(), value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TableFormat.prototype, "layout", {
+        /**
+         * @private
+         */
+        get: function () {
+            return readTableLayout(this.host.readTblPr());
+        },
+        set: function (value) {
+            this.host.writeTblPr(writeTableLayout(this.host.readTblPr(), value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return TableFormat;
+}());
+export { TableFormat };
+/**
+ * Row-level formatting surface.
+ *
+ * @public
+ */
+var RowFormat = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function RowFormat(host) {
+        this.host = host;
+    }
+    Object.defineProperty(RowFormat.prototype, "isBreakAcrossPages", {
+        /**
+         * When `true`, the row may break across pages (Word default).
+         * Maps inversely to `w:cantSplit`.
+         */
+        get: function () {
+            var cant = readRowCantSplit(this.host.readTrPr());
+            return cant !== true;
+        },
+        set: function (value) {
+            // isBreakAcrossPages true → remove cantSplit; false → write cantSplit on.
+            this.host.writeTrPr(writeRowCantSplit(this.host.readTrPr(), value ? undefined : true));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RowFormat.prototype, "backColor", {
+        /**
+         * Row background fill (`w:trPr/w:shd/@w:fill`).
+         *
+         * - **Get (runtime)**: OOXML wire string — hex `RRGGBB`, `'auto'`, or `undefined` when unset.
+         * - **Set**: hex string / `'auto'` (optional leading `#`), a {@link Color} enum value, or
+         *   `undefined` to clear the authored fill. {@link Color.Transparent} clears fill
+         *   (does not invent `w:fill="auto"`).
+         */
+        get: function () {
+            return shdFill(readRowShading(this.host.readTrPr()));
+        },
+        set: function (value) {
+            var prev = readRowShading(this.host.readTrPr());
+            var wire = value === undefined ? undefined : shadingFillToWire(value);
+            this.host.writeTrPr(writeRowShading(this.host.readTrPr(), shdFromFill(wire, prev)));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return RowFormat;
+}());
+export { RowFormat };
+/**
+ * Cell-level formatting surface.
+ *
+ * @public
+ */
+var CellFormat = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function CellFormat(host) {
+        var _this = this;
+        this.host = host;
+        this.bordersInstance = new Borders(createCellBordersHost(function () { return readCellBorders(_this.host.readTcPr()); }, function (value) {
+            _this.host.writeTcPr(writeCellBorders(_this.host.readTcPr(), value));
+        }), false);
+        var padHost = {
+            read: function () { return readCellMargins(_this.host.readTcPr()); },
+            write: function (value) {
+                _this.host.writeTcPr(writeCellMargins(_this.host.readTcPr(), value));
+            },
+        };
+        this.paddingsInstance = new Paddings(padHost);
+    }
+    Object.defineProperty(CellFormat.prototype, "backColor", {
+        /**
+         * Cell background fill (`w:tcPr/w:shd/@w:fill`).
+         *
+         * - **Get (runtime)**: OOXML wire string — hex `RRGGBB`, `'auto'`, or `undefined` when unset.
+         * - **Set**: hex string / `'auto'` (optional leading `#`), a {@link Color} enum value, or
+         *   `undefined` to clear the authored fill. {@link Color.Transparent} clears fill
+         *   (does not invent `w:fill="auto"`).
+         */
+        get: function () {
+            return shdFill(readCellShading(this.host.readTcPr()));
+        },
+        set: function (value) {
+            var prev = readCellShading(this.host.readTcPr());
+            var wire = value === undefined ? undefined : shadingFillToWire(value);
+            this.host.writeTcPr(writeCellShading(this.host.readTcPr(), shdFromFill(wire, prev)));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CellFormat.prototype, "borders", {
+        get: function () {
+            return this.bordersInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CellFormat.prototype, "paddings", {
+        get: function () {
+            return this.paddingsInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CellFormat.prototype, "verticalAlignment", {
+        get: function () {
+            var value = readCellVerticalAlignment(this.host.readTcPr());
+            return value !== undefined ? value : 'top';
+        },
+        set: function (value) {
+            if (value !== 'top' && value !== 'center' && value !== 'bottom') {
+                throw new RangeError('Unsupported verticalAlignment value');
+            }
+            this.host.writeTcPr(writeCellVerticalAlignment(this.host.readTcPr(), value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CellFormat.prototype, "textDirection", {
+        get: function () {
+            var value = readCellTextDirection(this.host.readTcPr());
+            return value !== undefined ? value : 'lr';
+        },
+        set: function (value) {
+            if (value !== 'lr' &&
+                value !== 'rl' &&
+                value !== 'tb' &&
+                value !== 'btLr' &&
+                value !== 'lrV' &&
+                value !== 'rlV') {
+                throw new RangeError('Unsupported textDirection value');
+            }
+            this.host.writeTcPr(writeCellTextDirection(this.host.readTcPr(), value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CellFormat.prototype, "wrapText", {
+        /**
+         * When `true`, cell text wraps (default). Maps inversely to `w:noWrap`.
+         */
+        get: function () {
+            var noWrap = readCellNoWrap(this.host.readTcPr());
+            return noWrap !== true;
+        },
+        set: function (value) {
+            this.host.writeTcPr(writeCellNoWrap(this.host.readTcPr(), value ? undefined : true));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CellFormat.prototype, "fitText", {
+        get: function () {
+            var v = readCellFitText(this.host.readTcPr());
+            return v === true;
+        },
+        set: function (value) {
+            this.host.writeTcPr(writeCellFitText(this.host.readTcPr(), value ? true : undefined));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CellFormat.prototype, "columnSpan", {
+        get: function () {
+            var span = readGridSpan(this.host.readTcPr());
+            return span !== undefined && span > 0 ? span : 1;
+        },
+        set: function (value) {
+            this.host.writeTcPr(writeGridSpan(this.host.readTcPr(), value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CellFormat.prototype, "horizontalMerge", {
+        get: function () {
+            return wireMergeToCellMerge(readHorizontalMerge(this.host.readTcPr()));
+        },
+        set: function (value) {
+            this.host.writeTcPr(writeHorizontalMerge(this.host.readTcPr(), cellMergeToWire(value)));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CellFormat.prototype, "verticalMerge", {
+        get: function () {
+            return wireMergeToCellMerge(readVerticalMerge(this.host.readTcPr()));
+        },
+        set: function (value) {
+            this.host.writeTcPr(writeVerticalMerge(this.host.readTcPr(), cellMergeToWire(value)));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CellFormat.prototype, "samePaddingsAsTable", {
+        get: function () {
+            return readIsSamePaddingsAsTable(this.host.readTcPr());
+        },
+        set: function (value) {
+            this.host.writeTcPr(writeIsSamePaddingsAsTable(this.host.readTcPr(), value));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return CellFormat;
+}());
+export { CellFormat };
+// Silence unused import when point helpers are only re-exported indirectly.
+void twipsToPoint;
+void pointToTwips;