@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/tables/tbl-pr.js

@@ -0,0 +1,1208 @@
+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);
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+/**
+ * Typed parse/serialize helpers for `w:tblPr` and shared table property types.
+ *
+ * Citations: Transitional `wml.xsd` `CT_TblPrBase`, `CT_TblWidth`, `CT_TblBorders`,
+ * `CT_TblCellMar`, `CT_TblLook`, `ST_JcTable`, `ST_TblWidth`.
+ */
+import { twipsToPoint, pointToTwips } from '../document/length';
+import { parseOnOff, serializeOnOff } from '../document/on-off';
+import { elementChildren, isWml, wValAttribute, wmlAttr, wmlElement, } from '../document/wml';
+export { pointToTwips, twipsToPoint };
+/**
+ * How Word interprets a table row's height (`ST_HeightRule`).
+ *
+ * - `auto`: the row grows and shrinks with its content.
+ * - `atLeast`: the height is a minimum; content can still push it taller.
+ * - `exact`: the height is fixed; overflow is clipped.
+ */
+export var TableRowHeightRule = {
+    Auto: 'auto',
+    AtLeast: 'atLeast',
+    Exact: 'exact',
+};
+/**
+ * Horizontal alignment of a table or table row on the page
+ * (`w:jc` / `ST_JcTable` public subset).
+ *
+ * - {@link TableAlignment.Left}: hug the left margin (Word default; wire `left`).
+ * - {@link TableAlignment.Center}: center between the margins (wire `center`).
+ * - {@link TableAlignment.Right}: hug the right margin (wire `right`).
+ *
+ * @public
+ */
+export var TableAlignment = {
+    Left: 'left',
+    Center: 'center',
+    Right: 'right',
+};
+// ---------------------------------------------------------------------------
+// Shared low-level helpers
+// ---------------------------------------------------------------------------
+export function parseDecimalVal(raw) {
+    if (raw === undefined || !/^-?\d+$/.test(raw)) {
+        return undefined;
+    }
+    return parseInt(raw, 10);
+}
+export function wmlAttrVal(el, localName) {
+    var __ts33_0;
+    return ((__ts33_0 = el.attributes.find(function (a) { return a.localName === localName && (a.prefix === 'w' || a.prefix === ''); })), __ts33_0 == null ? undefined : __ts33_0.value);
+}
+function findWmlChild(parent, localName) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(elementChildren(parent)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, localName)) {
+                return child;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return undefined;
+}
+/**
+ * Replace or remove all children with `localName`; append when missing.
+ * Preserves attributes and unmodeled siblings on the parent element.
+ */
+export function upsertPropChild(parent, parentLocalName, localName, replacement) {
+    var e_2, _a;
+    var children = elementChildren(parent);
+    var next = [];
+    var replaced = false;
+    try {
+        for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
+            var child = children_1_1.value;
+            if (isWml(child, localName)) {
+                if (!replaced && replacement !== undefined) {
+                    next.push(replacement);
+                }
+                replaced = true;
+                continue;
+            }
+            next.push(child);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    if (!replaced && replacement !== undefined) {
+        next.push(replacement);
+    }
+    return wmlElement(parentLocalName, {
+        attributes: parent.attributes,
+        namespaceDeclarations: parent.namespaceDeclarations,
+        children: next,
+    });
+}
+export function emptyPropsToUndefined(el) {
+    if (el === undefined) {
+        return undefined;
+    }
+    if (elementChildren(el).length === 0 && el.attributes.length === 0) {
+        return undefined;
+    }
+    return el;
+}
+// ---------------------------------------------------------------------------
+// Width (CT_TblWidth)
+// ---------------------------------------------------------------------------
+var WIDTH_TYPES = new Set(['auto', 'dxa', 'nil', 'pct']);
+/**
+ * Parse `CT_TblWidth` (`@w:w`, `@w:type`).
+ *
+ * @private
+ */
+export function parseTblWidth(el) {
+    var __ts33_1, __ts33_2;
+    var typeRaw = ((__ts33_1 = wmlAttrVal(el, 'type')), __ts33_1 != null ? __ts33_1 : 'dxa');
+    if (!WIDTH_TYPES.has(typeRaw)) {
+        return undefined;
+    }
+    var type = typeRaw;
+    var wRaw = wmlAttrVal(el, 'w');
+    var n = ((__ts33_2 = parseDecimalVal(wRaw)), __ts33_2 != null ? __ts33_2 : 0);
+    // pct: store fiftieths-of-percent raw via twips bridge (task note).
+    // dxa/auto/nil: twips (may be 0).
+    return { type: type, value: twipsToPoint(n) };
+}
+/**
+ * Serialize `CT_TblWidth`.
+ *
+ * @private
+ */
+export function serializeTblWidth(localName, width) {
+    var w = pointToTwips(width.value);
+    return wmlElement(localName, {
+        attributes: [wmlAttr('w', String(w)), wmlAttr('type', width.type)],
+    });
+}
+// ---------------------------------------------------------------------------
+// Borders
+// ---------------------------------------------------------------------------
+/**
+ * Parse one `CT_Border`.
+ *
+ * @private
+ */
+export function parseBorderEdge(el) {
+    var style = wmlAttrVal(el, 'val');
+    if (style === undefined) {
+        return undefined;
+    }
+    var colorRaw = wmlAttrVal(el, 'color');
+    var szRaw = wmlAttrVal(el, 'sz');
+    var sz = szRaw !== undefined ? parseDecimalVal(szRaw) : undefined;
+    var spaceRaw = wmlAttrVal(el, 'space');
+    var space = spaceRaw !== undefined ? parseDecimalVal(spaceRaw) : undefined;
+    var shadowRaw = wmlAttrVal(el, 'shadow');
+    var shadow;
+    if (shadowRaw !== undefined) {
+        var normalized = shadowRaw.trim().toLowerCase();
+        if (normalized === 'true' || normalized === '1' || normalized === 'on') {
+            shadow = true;
+        }
+        else if (normalized === 'false' || normalized === '0' || normalized === 'off') {
+            shadow = false;
+        }
+    }
+    return __assign({ style: style }, (colorRaw !== undefined ? { color: colorRaw } : {}), (sz !== undefined ? { size: sz } : {}), (space !== undefined ? { space: space } : {}), (shadow !== undefined ? { shadow: shadow } : {}));
+}
+/**
+ * Serialize one border edge element.
+ *
+ * `CT_Border` requires `@w:val`; an edge parsed without a style token
+ * (schema-invalid input) is skipped so the output stays schema-valid.
+ *
+ * @private
+ */
+export function serializeBorderEdge(localName, edge) {
+    if (edge.style === undefined) {
+        return undefined;
+    }
+    var attrs = [wmlAttr('val', edge.style)];
+    if (edge.color !== undefined) {
+        // ST_HexColor / 'auto': strip a leading '#' if present.
+        var color = edge.color;
+        if (color.length > 0 && color.charAt(0) === '#') {
+            color = color.slice(1);
+        }
+        attrs.push(wmlAttr('color', color));
+    }
+    if (edge.size !== undefined) {
+        attrs.push(wmlAttr('sz', String(edge.size)));
+    }
+    if (edge.space !== undefined) {
+        attrs.push(wmlAttr('space', String(edge.space)));
+    }
+    if (edge.shadow !== undefined) {
+        attrs.push(wmlAttr('shadow', edge.shadow ? 'true' : 'false'));
+    }
+    return wmlElement(localName, { attributes: attrs });
+}
+/**
+ * Parse table borders. Maps `start`→`left`, `end`→`right` (Strict → API).
+ *
+ * @private
+ */
+export function parseTblBorders(el) {
+    var e_3, _a;
+    var top;
+    var left;
+    var bottom;
+    var right;
+    var insideH;
+    var insideV;
+    try {
+        for (var _b = __values(elementChildren(el)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (!isWml(child, child.localName)) {
+                continue;
+            }
+            var edge = parseBorderEdge(child);
+            if (edge === undefined) {
+                continue;
+            }
+            switch (child.localName) {
+                case 'top':
+                    top = edge;
+                    break;
+                case 'left':
+                case 'start':
+                    left = edge;
+                    break;
+                case 'bottom':
+                    bottom = edge;
+                    break;
+                case 'right':
+                case 'end':
+                    right = edge;
+                    break;
+                case 'insideH':
+                    insideH = edge;
+                    break;
+                case 'insideV':
+                    insideV = edge;
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return __assign({}, (top !== undefined ? { top: top } : {}), (left !== undefined ? { left: left } : {}), (bottom !== undefined ? { bottom: bottom } : {}), (right !== undefined ? { right: right } : {}), (insideH !== undefined ? { insideH: insideH } : {}), (insideV !== undefined ? { insideV: insideV } : {}));
+}
+/**
+ * Serialize table borders as Transitional `left`/`right` (Word parity).
+ * Preserves unmodeled children (e.g. Strict `start`/`end`) when rewriting.
+ *
+ * @private
+ */
+export function serializeTblBorders(borders, existing) {
+    var e_4, _a;
+    var modeled = new Set(['top', 'left', 'right', 'bottom', 'insideH', 'insideV', 'start', 'end']);
+    var children = [];
+    var pushEdge = function (localName, edge) {
+        var el = edge !== undefined ? serializeBorderEdge(localName, edge) : undefined;
+        if (el !== undefined) {
+            children.push(el);
+        }
+    };
+    pushEdge('top', borders.top);
+    pushEdge('left', borders.left);
+    pushEdge('bottom', borders.bottom);
+    pushEdge('right', borders.right);
+    pushEdge('insideH', borders.insideH);
+    pushEdge('insideV', borders.insideV);
+    if (existing !== undefined) {
+        try {
+            for (var _b = __values(elementChildren(existing)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (!isWml(child, child.localName) || !modeled.has(child.localName)) {
+                    children.push(child);
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    }
+    return wmlElement('tblBorders', { children: children });
+}
+/**
+ * Parse cell borders including diagonals.
+ *
+ * @private
+ */
+export function parseTcBorders(el) {
+    var e_5, _a;
+    var base = parseTblBorders(el);
+    var tl2br;
+    var tr2bl;
+    try {
+        for (var _b = __values(elementChildren(el)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (!isWml(child, child.localName)) {
+                continue;
+            }
+            var edge = parseBorderEdge(child);
+            if (edge === undefined) {
+                continue;
+            }
+            if (child.localName === 'tl2br') {
+                tl2br = edge;
+            }
+            else if (child.localName === 'tr2bl') {
+                tr2bl = edge;
+            }
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return __assign({}, base, (tl2br !== undefined ? { tl2br: tl2br } : {}), (tr2bl !== undefined ? { tr2bl: tr2bl } : {}));
+}
+/**
+ * Serialize cell borders (`w:tcBorders`).
+ *
+ * @private
+ */
+export function serializeTcBorders(borders, existing) {
+    var e_6, _a;
+    var modeled = new Set([
+        'top',
+        'left',
+        'right',
+        'bottom',
+        'insideH',
+        'insideV',
+        'start',
+        'end',
+        'tl2br',
+        'tr2bl',
+    ]);
+    var children = [];
+    var pushEdge = function (localName, edge) {
+        var el = edge !== undefined ? serializeBorderEdge(localName, edge) : undefined;
+        if (el !== undefined) {
+            children.push(el);
+        }
+    };
+    pushEdge('top', borders.top);
+    pushEdge('left', borders.left);
+    pushEdge('bottom', borders.bottom);
+    pushEdge('right', borders.right);
+    pushEdge('insideH', borders.insideH);
+    pushEdge('insideV', borders.insideV);
+    pushEdge('tl2br', borders.tl2br);
+    pushEdge('tr2bl', borders.tr2bl);
+    if (existing !== undefined) {
+        try {
+            for (var _b = __values(elementChildren(existing)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (!isWml(child, child.localName) || !modeled.has(child.localName)) {
+                    children.push(child);
+                }
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+    }
+    return wmlElement('tcBorders', { children: children });
+}
+// ---------------------------------------------------------------------------
+// Margins (CT_TblCellMar / CT_TcMar)
+// ---------------------------------------------------------------------------
+function parseMarginEdge(el) {
+    var typeRaw = wmlAttrVal(el, 'type');
+    // Prefer dxa; accept missing type as dxa (common Word output).
+    if (typeRaw !== undefined && typeRaw !== 'dxa' && typeRaw !== 'auto' && typeRaw !== 'nil') {
+        // pct margins are rare; still accept numeric w as twips-like raw for round-trip via Point
+        if (typeRaw !== 'pct') {
+            return undefined;
+        }
+    }
+    var n = parseDecimalVal(wmlAttrVal(el, 'w'));
+    if (n === undefined) {
+        return undefined;
+    }
+    return twipsToPoint(n);
+}
+/**
+ * Parse table/cell margins. Maps `start`→`left`, `end`→`right`.
+ *
+ * @private
+ */
+export function parseCellMargins(el) {
+    var e_7, _a;
+    var top;
+    var right;
+    var bottom;
+    var left;
+    try {
+        for (var _b = __values(elementChildren(el)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (!isWml(child, child.localName)) {
+                continue;
+            }
+            var len = parseMarginEdge(child);
+            if (len === undefined) {
+                continue;
+            }
+            switch (child.localName) {
+                case 'top':
+                    top = len;
+                    break;
+                case 'right':
+                case 'end':
+                    right = len;
+                    break;
+                case 'bottom':
+                    bottom = len;
+                    break;
+                case 'left':
+                case 'start':
+                    left = len;
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return __assign({}, (top !== undefined ? { top: top } : {}), (right !== undefined ? { right: right } : {}), (bottom !== undefined ? { bottom: bottom } : {}), (left !== undefined ? { left: left } : {}));
+}
+function serializeMarginEdge(localName, value) {
+    return wmlElement(localName, {
+        attributes: [wmlAttr('w', String(pointToTwips(value))), wmlAttr('type', 'dxa')],
+    });
+}
+/**
+ * Serialize margins container (`tblCellMar` or `tcMar`) with Transitional left/right.
+ *
+ * @private
+ */
+export function serializeCellMargins(containerLocalName, margins, existing) {
+    var e_8, _a;
+    var modeled = new Set(['top', 'left', 'right', 'bottom', 'start', 'end']);
+    var children = [];
+    if (margins.top !== undefined) {
+        children.push(serializeMarginEdge('top', margins.top));
+    }
+    if (margins.left !== undefined) {
+        children.push(serializeMarginEdge('left', margins.left));
+    }
+    if (margins.bottom !== undefined) {
+        children.push(serializeMarginEdge('bottom', margins.bottom));
+    }
+    if (margins.right !== undefined) {
+        children.push(serializeMarginEdge('right', margins.right));
+    }
+    if (existing !== undefined) {
+        try {
+            for (var _b = __values(elementChildren(existing)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (!isWml(child, child.localName) || !modeled.has(child.localName)) {
+                    children.push(child);
+                }
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+    }
+    return wmlElement(containerLocalName, { children: children });
+}
+// ---------------------------------------------------------------------------
+// Shading
+// ---------------------------------------------------------------------------
+/**
+ * Parse `w:shd` (pattern is free string per task).
+ *
+ * @private
+ */
+export function parseShd(el) {
+    var fillRaw = wmlAttrVal(el, 'fill');
+    var colorRaw = wmlAttrVal(el, 'color');
+    var valRaw = wmlAttrVal(el, 'val');
+    return __assign({}, (fillRaw !== undefined ? { fill: fillRaw } : {}), (colorRaw !== undefined ? { color: colorRaw } : {}), (valRaw !== undefined ? { pattern: valRaw } : {}));
+}
+/**
+ * Serialize `w:shd` (order: pattern/val, color, fill).
+ *
+ * @private
+ */
+export function serializeShd(shd) {
+    var attrs = [];
+    if (shd.pattern !== undefined) {
+        attrs.push(wmlAttr('val', shd.pattern));
+    }
+    if (shd.color !== undefined) {
+        attrs.push(wmlAttr('color', shd.color));
+    }
+    if (shd.fill !== undefined) {
+        // ST_HexColor / 'auto': strip a leading '#' if present so invalid
+        // authoring input still emits a schema-valid wire value.
+        var fill = shd.fill;
+        if (fill.length > 0 && fill.charAt(0) === '#') {
+            fill = fill.slice(1);
+        }
+        attrs.push(wmlAttr('fill', fill));
+    }
+    return wmlElement('shd', { attributes: attrs });
+}
+// ---------------------------------------------------------------------------
+// Alignment (ST_JcTable subset)
+// ---------------------------------------------------------------------------
+/**
+ * Parse table/row `w:jc` → public left|center|right (start→left, end→right).
+ *
+ * @private
+ */
+export function parseTableAlignment(el) {
+    var raw = wValAttribute(el);
+    if (raw === 'left' || raw === 'start') {
+        return 'left';
+    }
+    if (raw === 'right' || raw === 'end') {
+        return 'right';
+    }
+    if (raw === 'center') {
+        return 'center';
+    }
+    return undefined;
+}
+/**
+ * Serialize table/row alignment as Transitional left|center|right.
+ *
+ * @private
+ */
+export function serializeTableAlignment(alignment) {
+    return wmlElement('jc', { attributes: [wmlAttr('val', alignment)] });
+}
+// ---------------------------------------------------------------------------
+// tblLook
+// ---------------------------------------------------------------------------
+/** ECMA-376 / Word `w:tblLook/@w:val` bit flags (when named attrs absent). */
+var TBLLOOK_FIRST_ROW = 0x0020;
+var TBLLOOK_LAST_ROW = 0x0040;
+var TBLLOOK_FIRST_COLUMN = 0x0080;
+var TBLLOOK_LAST_COLUMN = 0x0100;
+var TBLLOOK_NO_H_BAND = 0x0200;
+var TBLLOOK_NO_V_BAND = 0x0400;
+function parseHexMask(raw) {
+    if (raw === undefined || raw.length === 0) {
+        return undefined;
+    }
+    // TS 3.3 / ES5 parity: avoid String.prototype.startsWith.
+    var cleaned = (raw.indexOf('0x') === 0 || raw.indexOf('0X') === 0) ? raw.slice(2) : raw;
+    if (!/^[0-9a-fA-F]+$/.test(cleaned)) {
+        return undefined;
+    }
+    return parseInt(cleaned, 16);
+}
+function onOffAttr(el, localName) {
+    var raw = wmlAttrVal(el, localName);
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (raw === '1' || raw === 'true' || raw === 'on') {
+        return true;
+    }
+    if (raw === '0' || raw === 'false' || raw === 'off') {
+        return false;
+    }
+    return undefined;
+}
+/**
+ * Parse `w:tblLook` named onOff attrs and/or legacy hex `@w:val`.
+ *
+ * @private
+ */
+export function parseTblLook(el) {
+    var firstRow = onOffAttr(el, 'firstRow');
+    var lastRow = onOffAttr(el, 'lastRow');
+    var firstCol = onOffAttr(el, 'firstColumn');
+    var lastCol = onOffAttr(el, 'lastColumn');
+    var noHBand = onOffAttr(el, 'noHBand');
+    var noVBand = onOffAttr(el, 'noVBand');
+    var mask = parseHexMask(wmlAttrVal(el, 'val'));
+    if (mask !== undefined) {
+        if (firstRow === undefined) {
+            firstRow = (mask & TBLLOOK_FIRST_ROW) !== 0;
+        }
+        if (lastRow === undefined) {
+            lastRow = (mask & TBLLOOK_LAST_ROW) !== 0;
+        }
+        if (firstCol === undefined) {
+            firstCol = (mask & TBLLOOK_FIRST_COLUMN) !== 0;
+        }
+        if (lastCol === undefined) {
+            lastCol = (mask & TBLLOOK_LAST_COLUMN) !== 0;
+        }
+        if (noHBand === undefined) {
+            noHBand = (mask & TBLLOOK_NO_H_BAND) !== 0;
+        }
+        if (noVBand === undefined) {
+            noVBand = (mask & TBLLOOK_NO_V_BAND) !== 0;
+        }
+    }
+    return __assign({}, (firstRow !== undefined ? { firstRow: firstRow } : {}), (lastRow !== undefined ? { lastRow: lastRow } : {}), (firstCol !== undefined ? { firstCol: firstCol } : {}), (lastCol !== undefined ? { lastCol: lastCol } : {}), (noHBand !== undefined ? { noHBand: noHBand } : {}), (noVBand !== undefined ? { noVBand: noVBand } : {}));
+}
+function pushOnOffAttr(attrs, localName, value) {
+    if (value === undefined) {
+        return;
+    }
+    attrs.push(wmlAttr(localName, value ? '1' : '0'));
+}
+/**
+ * Serialize `w:tblLook` with named onOff attributes (preferred over hex-only).
+ *
+ * @private
+ */
+export function serializeTblLook(look) {
+    var attrs = [];
+    pushOnOffAttr(attrs, 'firstRow', look.firstRow);
+    pushOnOffAttr(attrs, 'lastRow', look.lastRow);
+    pushOnOffAttr(attrs, 'firstColumn', look.firstCol);
+    pushOnOffAttr(attrs, 'lastColumn', look.lastCol);
+    pushOnOffAttr(attrs, 'noHBand', look.noHBand);
+    pushOnOffAttr(attrs, 'noVBand', look.noVBand);
+    return wmlElement('tblLook', { attributes: attrs });
+}
+/**
+ * DocIO / transitional ST_Cnf character positions (1-based LTR) → CT_Cnf fields.
+ * Corner bit order (positions 9–12): firstRowLastColumn, firstRowFirstColumn,
+ * lastRowLastColumn, lastRowFirstColumn. Named XML attrs still emit NW→SE order.
+ */
+var CNF_VAL_FIELDS = [
+    'firstRow',
+    'lastRow',
+    'firstColumn',
+    'lastColumn',
+    'oddVBand',
+    'evenVBand',
+    'oddHBand',
+    'evenHBand',
+    'firstRowLastColumn',
+    'firstRowFirstColumn',
+    'lastRowLastColumn',
+    'lastRowFirstColumn',
+];
+var CNF_KNOWN_ATTRS = {
+    val: true,
+    firstRow: true,
+    lastRow: true,
+    firstColumn: true,
+    lastColumn: true,
+    oddVBand: true,
+    evenVBand: true,
+    oddHBand: true,
+    evenHBand: true,
+    firstRowFirstColumn: true,
+    firstRowLastColumn: true,
+    lastRowFirstColumn: true,
+    lastRowLastColumn: true,
+};
+function parseCnfValMask(raw) {
+    if (raw === undefined || raw.length !== 12 || !/^[01]{12}$/.test(raw)) {
+        return undefined;
+    }
+    return raw;
+}
+function cnfStyleHasAny(state) {
+    for (var i = 0; i < CNF_VAL_FIELDS.length; i++) {
+        if (state[CNF_VAL_FIELDS[i]] !== undefined) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * All-false normalized conditional membership.
+ *
+ * @private
+ */
+export function createDefaultCnfStyle() {
+    return {
+        firstRow: false,
+        lastRow: false,
+        firstColumn: false,
+        lastColumn: false,
+        oddVBand: false,
+        evenVBand: false,
+        oddHBand: false,
+        evenHBand: false,
+        firstRowFirstColumn: false,
+        firstRowLastColumn: false,
+        lastRowFirstColumn: false,
+        lastRowLastColumn: false,
+    };
+}
+/**
+ * Coerce partial/optional {@link CnfStyle} into a fully boolean {@link NormalizedCnfStyle}.
+ *
+ * @private
+ */
+export function normalizeCnfStyle(state) {
+    return {
+        firstRow: state !== undefined && state.firstRow === true,
+        lastRow: state !== undefined && state.lastRow === true,
+        firstColumn: state !== undefined && state.firstColumn === true,
+        lastColumn: state !== undefined && state.lastColumn === true,
+        oddVBand: state !== undefined && state.oddVBand === true,
+        evenVBand: state !== undefined && state.evenVBand === true,
+        oddHBand: state !== undefined && state.oddHBand === true,
+        evenHBand: state !== undefined && state.evenHBand === true,
+        firstRowFirstColumn: state !== undefined && state.firstRowFirstColumn === true,
+        firstRowLastColumn: state !== undefined && state.firstRowLastColumn === true,
+        lastRowFirstColumn: state !== undefined && state.lastRowFirstColumn === true,
+        lastRowLastColumn: state !== undefined && state.lastRowLastColumn === true,
+    };
+}
+/**
+ * True when any named flag is true on a normalized state.
+ *
+ * @private
+ */
+export function normalizedCnfStyleHasTrue(state) {
+    for (var i = 0; i < CNF_VAL_FIELDS.length; i++) {
+        if (state[CNF_VAL_FIELDS[i]] === true) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Alias of {@link normalizedCnfStyleHasTrue} (DocIO placement helper name).
+ *
+ * @private
+ */
+export function hasAnyCnfStyleFlag(state) {
+    return normalizedCnfStyleHasTrue(state);
+}
+/**
+ * Parse `w:cnfStyle` named OnOff attributes and/or transitional `@w:val` ST_Cnf.
+ * Named attributes win when both forms are present (same rule as {@link parseTblLook}).
+ *
+ * @private
+ */
+export function parseCnfStyle(el) {
+    // Mutable bag — CnfStyle fields are readonly on the public shape.
+    var named = {
+        firstRow: onOffAttr(el, 'firstRow'),
+        lastRow: onOffAttr(el, 'lastRow'),
+        firstColumn: onOffAttr(el, 'firstColumn'),
+        lastColumn: onOffAttr(el, 'lastColumn'),
+        oddVBand: onOffAttr(el, 'oddVBand'),
+        evenVBand: onOffAttr(el, 'evenVBand'),
+        oddHBand: onOffAttr(el, 'oddHBand'),
+        evenHBand: onOffAttr(el, 'evenHBand'),
+        firstRowFirstColumn: onOffAttr(el, 'firstRowFirstColumn'),
+        firstRowLastColumn: onOffAttr(el, 'firstRowLastColumn'),
+        lastRowFirstColumn: onOffAttr(el, 'lastRowFirstColumn'),
+        lastRowLastColumn: onOffAttr(el, 'lastRowLastColumn'),
+    };
+    var mask = parseCnfValMask(wmlAttrVal(el, 'val'));
+    if (mask !== undefined) {
+        for (var i = 0; i < CNF_VAL_FIELDS.length; i++) {
+            var key = CNF_VAL_FIELDS[i];
+            if (named[key] === undefined) {
+                named[key] = mask.charAt(i) === '1';
+            }
+        }
+    }
+    var out = {};
+    for (var i = 0; i < CNF_VAL_FIELDS.length; i++) {
+        var key = CNF_VAL_FIELDS[i];
+        var value = named[key];
+        if (value !== undefined) {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+/**
+ * Serialize `w:cnfStyle` with `w:val` first, then all twelve named OnOff attrs
+ * as explicit `0`/`1`. Preserves unknown attributes, namespaces, and children.
+ *
+ * @private
+ */
+export function serializeCnfStyle(state, existing) {
+    var val = '';
+    for (var i = 0; i < CNF_VAL_FIELDS.length; i += 1) {
+        var key = CNF_VAL_FIELDS[i];
+        val += state[key] ? '1' : '0';
+    }
+    var attrs = [
+        wmlAttr('val', val),
+        wmlAttr('firstRow', state.firstRow ? '1' : '0'),
+        wmlAttr('lastRow', state.lastRow ? '1' : '0'),
+        wmlAttr('firstColumn', state.firstColumn ? '1' : '0'),
+        wmlAttr('lastColumn', state.lastColumn ? '1' : '0'),
+        wmlAttr('oddVBand', state.oddVBand ? '1' : '0'),
+        wmlAttr('evenVBand', state.evenVBand ? '1' : '0'),
+        wmlAttr('oddHBand', state.oddHBand ? '1' : '0'),
+        wmlAttr('evenHBand', state.evenHBand ? '1' : '0'),
+        wmlAttr('firstRowFirstColumn', state.firstRowFirstColumn ? '1' : '0'),
+        wmlAttr('firstRowLastColumn', state.firstRowLastColumn ? '1' : '0'),
+        wmlAttr('lastRowFirstColumn', state.lastRowFirstColumn ? '1' : '0'),
+        wmlAttr('lastRowLastColumn', state.lastRowLastColumn ? '1' : '0'),
+    ];
+    if (existing !== undefined) {
+        for (var i = 0; i < existing.attributes.length; i += 1) {
+            var attr = existing.attributes[i];
+            if (CNF_KNOWN_ATTRS[attr.localName] === true) {
+                continue;
+            }
+            attrs.push(attr);
+        }
+    }
+    return wmlElement('cnfStyle', {
+        attributes: attrs,
+        namespaceDeclarations: existing !== undefined ? existing.namespaceDeclarations : undefined,
+        children: existing !== undefined ? elementChildren(existing) : undefined,
+    });
+}
+/**
+ * True when any `CnfStyle` flag is explicitly set (including `false`).
+ *
+ * @private
+ */
+export function cnfStyleIsEmpty(state) {
+    return !cnfStyleHasAny(state);
+}
+// ---------------------------------------------------------------------------
+// String-valued children (caption / description)
+// ---------------------------------------------------------------------------
+function parseStringVal(el) {
+    return wValAttribute(el);
+}
+function serializeStringVal(localName, value) {
+    return wmlElement(localName, { attributes: [wmlAttr('val', value)] });
+}
+// ---------------------------------------------------------------------------
+// tblPr read / write
+// ---------------------------------------------------------------------------
+function ensureTblPr(tblPr) {
+    return tblPr != null ? tblPr : wmlElement('tblPr');
+}
+function writeTblChild(tblPr, localName, replacement) {
+    return upsertPropChild(ensureTblPr(tblPr), 'tblPr', localName, replacement);
+}
+/**
+ * @private
+ */
+export function readTableAlignment(tblPr) {
+    var el = findWmlChild(tblPr, 'jc');
+    return el !== undefined ? parseTableAlignment(el) : undefined;
+}
+/**
+ * @private
+ */
+export function writeTableAlignment(tblPr, alignment) {
+    return writeTblChild(tblPr, 'jc', alignment !== undefined ? serializeTableAlignment(alignment) : undefined);
+}
+/**
+ * @private
+ */
+export function readTableIndent(tblPr) {
+    var el = findWmlChild(tblPr, 'tblInd');
+    if (el === undefined) {
+        return undefined;
+    }
+    var n = parseDecimalVal(wmlAttrVal(el, 'w'));
+    if (n === undefined) {
+        return undefined;
+    }
+    return twipsToPoint(n);
+}
+/**
+ * @private
+ */
+export function writeTableIndent(tblPr, indent) {
+    if (indent === undefined) {
+        return writeTblChild(tblPr, 'tblInd', undefined);
+    }
+    var element = wmlElement('tblInd', {
+        attributes: [wmlAttr('w', String(pointToTwips(indent))), wmlAttr('type', 'dxa')],
+    });
+    return writeTblChild(tblPr, 'tblInd', element);
+}
+/**
+ * @private
+ */
+export function readTablePreferredWidth(tblPr) {
+    var el = findWmlChild(tblPr, 'tblW');
+    return el !== undefined ? parseTblWidth(el) : undefined;
+}
+/**
+ * @private
+ */
+export function writeTablePreferredWidth(tblPr, width) {
+    return writeTblChild(tblPr, 'tblW', width !== undefined ? serializeTblWidth('tblW', width) : undefined);
+}
+/**
+ * @private
+ */
+export function readTableBorders(tblPr) {
+    var el = findWmlChild(tblPr, 'tblBorders');
+    if (el === undefined) {
+        return undefined;
+    }
+    var borders = parseTblBorders(el);
+    if (borders.top === undefined &&
+        borders.left === undefined &&
+        borders.bottom === undefined &&
+        borders.right === undefined &&
+        borders.insideH === undefined &&
+        borders.insideV === undefined) {
+        return undefined;
+    }
+    return borders;
+}
+/**
+ * @private
+ */
+export function writeTableBorders(tblPr, borders) {
+    var existing = findWmlChild(tblPr, 'tblBorders');
+    return writeTblChild(tblPr, 'tblBorders', borders !== undefined ? serializeTblBorders(borders, existing) : undefined);
+}
+/**
+ * @private
+ */
+export function readTableCellMargins(tblPr) {
+    var el = findWmlChild(tblPr, 'tblCellMar');
+    if (el === undefined) {
+        return undefined;
+    }
+    var m = parseCellMargins(el);
+    if (m.top === undefined &&
+        m.right === undefined &&
+        m.bottom === undefined &&
+        m.left === undefined) {
+        return undefined;
+    }
+    return m;
+}
+/**
+ * @private
+ */
+export function writeTableCellMargins(tblPr, margins) {
+    var existing = findWmlChild(tblPr, 'tblCellMar');
+    return writeTblChild(tblPr, 'tblCellMar', margins !== undefined ? serializeCellMargins('tblCellMar', margins, existing) : undefined);
+}
+/**
+ * @private
+ */
+export function readTableCellSpacing(tblPr) {
+    var el = findWmlChild(tblPr, 'tblCellSpacing');
+    if (el === undefined) {
+        return undefined;
+    }
+    var n = parseDecimalVal(wmlAttrVal(el, 'w'));
+    if (n === undefined) {
+        return undefined;
+    }
+    return twipsToPoint(n);
+}
+/**
+ * @private
+ */
+export function writeTableCellSpacing(tblPr, spacing) {
+    if (spacing === undefined) {
+        return writeTblChild(tblPr, 'tblCellSpacing', undefined);
+    }
+    var element = wmlElement('tblCellSpacing', {
+        attributes: [wmlAttr('w', String(pointToTwips(spacing))), wmlAttr('type', 'dxa')],
+    });
+    return writeTblChild(tblPr, 'tblCellSpacing', element);
+}
+/**
+ * @private
+ */
+export function readTableShading(tblPr) {
+    var el = findWmlChild(tblPr, 'shd');
+    if (el === undefined) {
+        return undefined;
+    }
+    var shd = parseShd(el);
+    if (shd.fill === undefined && shd.color === undefined && shd.pattern === undefined) {
+        return undefined;
+    }
+    return shd;
+}
+/**
+ * @private
+ */
+export function writeTableShading(tblPr, shading) {
+    return writeTblChild(tblPr, 'shd', shading !== undefined ? serializeShd(shading) : undefined);
+}
+/**
+ * @private
+ */
+export function readTableLook(tblPr) {
+    var el = findWmlChild(tblPr, 'tblLook');
+    if (el === undefined) {
+        return undefined;
+    }
+    var look = parseTblLook(el);
+    if (look.firstRow === undefined &&
+        look.lastRow === undefined &&
+        look.firstCol === undefined &&
+        look.lastCol === undefined &&
+        look.noHBand === undefined &&
+        look.noVBand === undefined) {
+        return undefined;
+    }
+    return look;
+}
+/**
+ * @private
+ */
+export function writeTableLook(tblPr, look) {
+    return writeTblChild(tblPr, 'tblLook', look !== undefined ? serializeTblLook(look) : undefined);
+}
+/**
+ * @private
+ */
+export function readTableCaption(tblPr) {
+    var el = findWmlChild(tblPr, 'tblCaption');
+    return el !== undefined ? parseStringVal(el) : undefined;
+}
+/**
+ * @private
+ */
+export function writeTableCaption(tblPr, caption) {
+    return writeTblChild(tblPr, 'tblCaption', caption !== undefined ? serializeStringVal('tblCaption', caption) : undefined);
+}
+/**
+ * @private
+ */
+export function readTableDescription(tblPr) {
+    var el = findWmlChild(tblPr, 'tblDescription');
+    return el !== undefined ? parseStringVal(el) : undefined;
+}
+/**
+ * @private
+ */
+export function writeTableDescription(tblPr, description) {
+    return writeTblChild(tblPr, 'tblDescription', description !== undefined ? serializeStringVal('tblDescription', description) : undefined);
+}
+/**
+ * Read `w:tblStyle/@w:val`.
+ *
+ * @private
+ */
+export function readTableStyle(tblPr) {
+    var el = findWmlChild(tblPr, 'tblStyle');
+    return el !== undefined ? parseStringVal(el) : undefined;
+}
+/**
+ * Write or clear `w:tblStyle`.
+ *
+ * @private
+ */
+export function writeTableStyle(tblPr, styleId) {
+    return writeTblChild(tblPr, 'tblStyle', styleId !== undefined ? serializeStringVal('tblStyle', styleId) : undefined);
+}
+/**
+ * Read `w:tblLayout/@w:type` → public {@link TableLayout}.
+ *
+ * Absent element → `autoFit`. Unknown wire tokens leave the child untouched and
+ * return `autoFit` for the typed surface (extras preserved on the element).
+ *
+ * @private
+ */
+export function readTableLayout(tblPr) {
+    var el = findWmlChild(tblPr, 'tblLayout');
+    if (el === undefined) {
+        return 'autoFit';
+    }
+    var raw = wmlAttrVal(el, 'type');
+    if (raw === 'fixed') {
+        return 'fixed';
+    }
+    // `autofit`, missing type, or unknown → public autoFit (default algorithm).
+    return 'autoFit';
+}
+/**
+ * Write `w:tblLayout`. Omit-on-default: `autoFit` removes the element;
+ * `fixed` emits `<w:tblLayout w:type="fixed"/>`.
+ *
+ * @private
+ */
+export function writeTableLayout(tblPr, layout) {
+    if (layout === 'autoFit') {
+        return writeTblChild(tblPr, 'tblLayout', undefined);
+    }
+    return writeTblChild(tblPr, 'tblLayout', wmlElement('tblLayout', { attributes: [wmlAttr('type', 'fixed')] }));
+}
+/**
+ * Read `w:tblStyleRowBandSize/@w:val` (`CT_DecimalNumber`).
+ *
+ * Absent or non-integer wire → `undefined` (consumer default band height is 1).
+ * Citations: ECMA-376-1 §17.7.6.7; Transitional `wml.xsd` `CT_TblPrBase`.
+ *
+ * @private
+ */
+export function readTableRowBandSize(tblPr) {
+    var el = findWmlChild(tblPr, 'tblStyleRowBandSize');
+    if (el === undefined) {
+        return undefined;
+    }
+    return parseDecimalVal(wValAttribute(el));
+}
+/**
+ * Write or clear `w:tblStyleRowBandSize`. Emitted only when `size` is defined.
+ *
+ * @private
+ */
+export function writeTableRowBandSize(tblPr, size) {
+    return writeTblChild(tblPr, 'tblStyleRowBandSize', size !== undefined ? serializeStringVal('tblStyleRowBandSize', String(size)) : undefined);
+}
+/**
+ * Read `w:tblStyleColBandSize/@w:val` (`CT_DecimalNumber`).
+ *
+ * Absent or non-integer wire → `undefined` (consumer default band width is 1).
+ * Citations: ECMA-376-1 §17.7.6.5; Transitional `wml.xsd` `CT_TblPrBase`.
+ *
+ * @private
+ */
+export function readTableColumnBandSize(tblPr) {
+    var el = findWmlChild(tblPr, 'tblStyleColBandSize');
+    if (el === undefined) {
+        return undefined;
+    }
+    return parseDecimalVal(wValAttribute(el));
+}
+/**
+ * Write or clear `w:tblStyleColBandSize`. Emitted only when `size` is defined.
+ *
+ * @private
+ */
+export function writeTableColumnBandSize(tblPr, size) {
+    return writeTblChild(tblPr, 'tblStyleColBandSize', size !== undefined ? serializeStringVal('tblStyleColBandSize', String(size)) : undefined);
+}
+// Re-export on-off for tr/tc consumers that need serializeOnOff without extra imports coupling
+export { parseOnOff, serializeOnOff };