docxmlater 10.3.5 → 10.4.0

package/src/elements/TableCell.ts

@@ -2,19 +2,16 @@
  * TableCell - Represents a cell in a table
  */
 
+import { deepClone } from '../utils/deepClone';
 import { formatDateForXml } from '../utils/dateFormatting';
 import { XMLBuilder, XMLElement } from '../xml/XMLBuilder';
 import { Paragraph, TextDirection } from './Paragraph';
 import { Revision } from './Revision';
 import {
   BorderStyle as CommonBorderStyle,
-  BorderDefinition,
-  FourSidedBorders,
   CellVerticalAlignment as CommonCellVerticalAlignment,
   ShadingConfig,
-  ShadingPattern,
   buildShadingAttributes,
-  WidthType,
 } from './CommonTypes';
 
 // ============================================================================
@@ -446,6 +443,36 @@ export class TableCell {
     return this;
   }
 
+  /**
+   * Sets the cell background color
+   *
+   * Convenience method that wraps `setShading()` with a clear pattern.
+   * Equivalent to `setShading({ fill: color, pattern: 'clear' })`.
+   *
+   * @param color - Hex color without # (e.g., 'FF0000' for red, 'FFFFFF' for white)
+   * @returns This cell for chaining
+   *
+   * @example
+   * ```typescript
+   * cell.setBackgroundColor('FFFF00');  // Yellow background
+   * cell.setBackgroundColor('F2F2F2');  // Light gray
+   * ```
+   */
+  setBackgroundColor(color: string): this {
+    return this.setShading({ fill: color, pattern: 'clear' });
+  }
+
+  /**
+   * Gets the cell background color
+   *
+   * Returns the fill color from the cell's shading, or undefined if not set.
+   *
+   * @returns Hex color string or undefined
+   */
+  getBackgroundColor(): string | undefined {
+    return this.formatting.shading?.fill;
+  }
+
   /**
    * Sets vertical alignment
    * @param alignment - Vertical alignment
@@ -1262,6 +1289,46 @@ export class TableCell {
     return table.getFormatting().style;
   }
 
+  /**
+   * Creates a deep clone of this cell
+   *
+   * Copies all formatting, paragraphs, raw nested content, and property change
+   * tracking. The clone is independent of the original — changes to one do not
+   * affect the other. Parent row reference is NOT copied (set by addCell/insertCellAt).
+   *
+   * @returns New TableCell instance with the same content and formatting
+   *
+   * @example
+   * ```typescript
+   * const cell = new TableCell({ width: 2400, widthType: 'dxa' });
+   * cell.createParagraph('Hello');
+   * const copy = cell.clone();
+   * copy.createParagraph('World');
+   * // Original cell still has only "Hello"
+   * ```
+   */
+  clone(): TableCell {
+    const clonedCell = new TableCell(deepClone(this.formatting));
+
+    for (const para of this.paragraphs) {
+      clonedCell.addParagraph(para.clone());
+    }
+
+    for (const item of this.rawNestedContent) {
+      clonedCell.addRawNestedContent(item.position, item.xml, item.type);
+    }
+
+    if (this.tcPrChange) {
+      clonedCell.setTcPrChange(deepClone(this.tcPrChange));
+    }
+
+    if (this.cellRevision) {
+      clonedCell.setCellRevision(this.cellRevision);
+    }
+
+    return clonedCell;
+  }
+
   /**
    * Converts the cell to WordprocessingML XML element
    * @returns XMLElement representing the cell
@@ -1314,7 +1381,8 @@ export class TableCell {
       const borderElements: XMLElement[] = [];
       const borders = this.formatting.borders;
 
-      // Ordered per ECMA-376 CT_TcBorders: top, left, bottom, right, insideH, insideV, tl2br, tr2bl
+      // Ordered per ECMA-376 CT_TcBorders (§17.4.67): top, left, bottom, right, tl2br, tr2bl
+      // Note: insideH/insideV are only in CT_TblBorders (table-level), not CT_TcBorders (cell-level)
       if (borders.top) {
         borderElements.push(XMLBuilder.createBorder('top', borders.top));
       }
@@ -1466,8 +1534,12 @@ export class TableCell {
       const prevTcPrChildren: XMLElement[] = [];
       const prev = this.tcPrChange.previousProperties;
       if (prev) {
-        // Ordered per CT_TcPr: tcW → gridSpan → hMerge → vMerge → tcBorders → shd →
-        // noWrap → tcMar → textDirection → tcFitText → vAlign → hideMark → cnfStyle
+        // Ordered per CT_TcPr (ECMA-376 §17.4.70):
+        // cnfStyle → tcW → gridSpan → hMerge → vMerge → tcBorders → shd →
+        // noWrap → tcMar → textDirection → tcFitText → vAlign → hideMark
+        if (prev.cnfStyle) {
+          prevTcPrChildren.push(XMLBuilder.wSelf('cnfStyle', { 'w:val': prev.cnfStyle }));
+        }
         if (prev.width !== undefined) {
           prevTcPrChildren.push(
             XMLBuilder.wSelf('tcW', {
@@ -1491,6 +1563,7 @@ export class TableCell {
         }
         if (prev.borders) {
           const borderElements: XMLElement[] = [];
+          // Ordered per CT_TcBorders (§17.4.67): top, left, bottom, right, tl2br, tr2bl
           if (prev.borders.top)
             borderElements.push(XMLBuilder.createBorder('top', prev.borders.top));
           if (prev.borders.left)
@@ -1499,6 +1572,10 @@ export class TableCell {
             borderElements.push(XMLBuilder.createBorder('bottom', prev.borders.bottom));
           if (prev.borders.right)
             borderElements.push(XMLBuilder.createBorder('right', prev.borders.right));
+          if (prev.borders.tl2br)
+            borderElements.push(XMLBuilder.createBorder('tl2br', prev.borders.tl2br));
+          if (prev.borders.tr2bl)
+            borderElements.push(XMLBuilder.createBorder('tr2bl', prev.borders.tr2bl));
           if (borderElements.length > 0) {
             prevTcPrChildren.push(XMLBuilder.w('tcBorders', undefined, borderElements));
           }
@@ -1550,9 +1627,6 @@ export class TableCell {
         if (prev.hideMark) {
           prevTcPrChildren.push(XMLBuilder.wSelf('hideMark'));
         }
-        if (prev.cnfStyle) {
-          prevTcPrChildren.push(XMLBuilder.wSelf('cnfStyle', { 'w:val': prev.cnfStyle }));
-        }
       }
       const prevTcPr =
         prevTcPrChildren.length > 0

package/src/elements/TableGridChange.ts

@@ -6,7 +6,6 @@
  */
 
 import { XMLElement, XMLBuilder } from '../xml/XMLBuilder';
-import { formatDateForXml } from '../utils/dateFormatting';
 
 /**
  * Table grid column definition
@@ -86,30 +85,17 @@ export class TableGridChange {
     return [...this.previousGrid];
   }
 
-  /**
-   * Formats a date to ISO 8601 format for XML
-   * Uses formatDateForXml() to strip milliseconds which Word does not accept.
-   */
-  private formatDate(date: Date): string {
-    return formatDateForXml(date);
-  }
-
   /**
    * Generates XML for this table grid change
    * @returns XMLElement representing the table grid change
    */
   toXML(): XMLElement {
+    // Per ECMA-376 §17.13.5.35, tblGridChange uses CT_Markup (only w:id)
+    // NOT CT_TrackChange — w:author and w:date are not valid attributes
     const attributes: Record<string, string> = {
       'w:id': this.id.toString(),
     };
 
-    if (this.author) {
-      attributes['w:author'] = this.author;
-    }
-    if (this.date) {
-      attributes['w:date'] = this.formatDate(this.date);
-    }
-
     // Build previous grid
     const gridChildren: XMLElement[] = [];
     for (const col of this.previousGrid) {

package/src/elements/TableRow.ts

@@ -2,14 +2,14 @@
  * TableRow - Represents a row in a table
  */
 
+import { deepClone } from '../utils/deepClone';
 import { TableCell } from './TableCell';
 import { XMLBuilder, XMLElement } from '../xml/XMLBuilder';
-import { TableBorder, TableBorders } from './Table';
+import { TableBorders } from './Table';
 import {
   BasicShadingPattern,
   RowJustification as CommonRowJustification,
   ShadingConfig,
-  buildShadingAttributes,
 } from './CommonTypes';
 import { defaultLogger } from '../utils/logger';
 
@@ -318,6 +318,22 @@ export class TableRow {
     return this;
   }
 
+  /**
+   * Sets the height rule independently of the height value.
+   * Per ECMA-376 §17.18.33, valid values are "auto", "atLeast", "exact".
+   * When undefined, the w:hRule attribute is omitted (defaults to "auto" per spec).
+   * @param rule - Height rule, or undefined to omit (use spec default "auto")
+   * @returns This row for chaining
+   */
+  setHeightRule(rule: RowFormatting['heightRule']): this {
+    const prevRule = this.formatting.heightRule;
+    this.formatting.heightRule = rule;
+    if (this.trackingContext?.isEnabled() && prevRule !== rule) {
+      this.trackingContext.trackTableChange(this, 'heightRule', prevRule, rule);
+    }
+    return this;
+  }
+
   /**
    * Clears the row height, allowing Word to auto-size the row based on content
    * @returns This row for chaining
@@ -859,11 +875,15 @@ export class TableRow {
       const prevTrPrChildren: XMLElement[] = [];
       const prev = this.trPrChange.previousProperties;
       if (prev) {
-        // Ordered per CT_TrPr: cnfStyle → gridBefore → gridAfter → wBefore → wAfter →
+        // Ordered per CT_TrPr (ECMA-376 §17.4.79):
+        // cnfStyle → divId → gridBefore → gridAfter → wBefore → wAfter →
         // cantSplit → trHeight → tblHeader → tblCellSpacing → jc → hidden
         if (prev.cnfStyle) {
           prevTrPrChildren.push(XMLBuilder.wSelf('cnfStyle', { 'w:val': prev.cnfStyle }));
         }
+        if (prev.divId !== undefined) {
+          prevTrPrChildren.push(XMLBuilder.wSelf('divId', { 'w:val': prev.divId }));
+        }
         if (prev.gridBefore !== undefined) {
           prevTrPrChildren.push(XMLBuilder.wSelf('gridBefore', { 'w:val': prev.gridBefore }));
         }
@@ -920,14 +940,10 @@ export class TableRow {
     }
 
     // Build row element
+    // Per ECMA-376 §17.4.78 (CT_Row): tblPrEx → trPr → tc*
     const rowChildren: XMLElement[] = [];
 
-    // Add row properties if there are any
-    if (trPrChildren.length > 0) {
-      rowChildren.push(XMLBuilder.w('trPr', undefined, trPrChildren));
-    }
-
-    // Add table property exceptions (tblPrEx) if present
+    // Add table property exceptions (tblPrEx) - must come BEFORE trPr per CT_Row
     if (this.formatting.tablePropertyExceptions) {
       const tblPrExChildren = this.buildTablePropertyExceptionsXML(
         this.formatting.tablePropertyExceptions
@@ -937,6 +953,11 @@ export class TableRow {
       }
     }
 
+    // Add row properties if there are any
+    if (trPrChildren.length > 0) {
+      rowChildren.push(XMLBuilder.w('trPr', undefined, trPrChildren));
+    }
+
     // Add all cells - each cell is independent
     // Note: gridSpan (columnSpan) means a single cell spans multiple columns in the grid,
     // it does NOT mean subsequent cells should be skipped. Each cell in the array
@@ -948,6 +969,70 @@ export class TableRow {
     return XMLBuilder.w('tr', undefined, rowChildren);
   }
 
+  /**
+   * Gets the text content of all cells as a string array
+   *
+   * @returns Array of cell text values
+   *
+   * @example
+   * ```typescript
+   * const values = row.toArray(); // ['Alice', '30', 'NYC']
+   * ```
+   */
+  toArray(): string[] {
+    return this.cells.map((cell) => cell.getText());
+  }
+
+  /**
+   * Gets the concatenated text of all cells, separated by a delimiter
+   *
+   * @param separator - Separator between cell texts (default: tab)
+   * @returns Concatenated cell text
+   *
+   * @example
+   * ```typescript
+   * console.log(row.getText());       // "Alice\t30\tNYC"
+   * console.log(row.getText(', '));   // "Alice, 30, NYC"
+   * ```
+   */
+  getText(separator = '\t'): string {
+    return this.cells.map((cell) => cell.getText()).join(separator);
+  }
+
+  /**
+   * Creates a deep clone of this row
+   *
+   * Copies all cells (via TableCell.clone()), formatting, and property change
+   * tracking. The clone is independent of the original. Parent table reference
+   * is NOT copied (set by Table.addRow/insertRow).
+   *
+   * @returns New TableRow instance with the same structure and content
+   *
+   * @example
+   * ```typescript
+   * const row = new TableRow(3);
+   * row.getCell(0)?.createParagraph('Cell A');
+   * row.setHeader(true);
+   *
+   * const copy = row.clone();
+   * copy.getCell(0)?.createParagraph('Modified');
+   * // Original row unchanged
+   * ```
+   */
+  clone(): TableRow {
+    const clonedRow = new TableRow(0, deepClone(this.formatting));
+
+    for (const cell of this.cells) {
+      clonedRow.addCell(cell.clone());
+    }
+
+    if (this.trPrChange) {
+      clonedRow.setTrPrChange(deepClone(this.trPrChange));
+    }
+
+    return clonedRow;
+  }
+
   /**
    * Creates a new TableRow
    * @param cellCount - Number of cells to create

package/src/formatting/AbstractNumbering.ts

@@ -34,6 +34,9 @@ export interface AbstractNumberingProperties {
 
   /** Template code (ECMA-376 §17.9.30) - 8-char hex string identifying the template */
   tmpl?: string;
+
+  /** Namespace-scoped unique ID (ECMA-376 §17.9.17) - 8-char hex string */
+  nsid?: string;
 }
 
 /**
@@ -50,6 +53,7 @@ export class AbstractNumbering {
   private numStyleLink?: string;
   private styleLink?: string;
   private tmpl?: string;
+  private nsid?: string;
 
   /**
    * Creates a new abstract numbering definition
@@ -64,6 +68,7 @@ export class AbstractNumbering {
       this.name = name;
       this.levels = new Map();
       this.multiLevelType = 1; // default multilevel
+      this.nsid = AbstractNumbering.generateNsid();
     } else {
       // Object constructor: new AbstractNumbering({ abstractNumId, ... })
       const properties = idOrProps;
@@ -74,6 +79,7 @@ export class AbstractNumbering {
       this.numStyleLink = properties.numStyleLink;
       this.styleLink = properties.styleLink;
       this.tmpl = properties.tmpl;
+      this.nsid = properties.nsid ?? AbstractNumbering.generateNsid();
 
       if (properties.levels) {
         properties.levels.forEach((level) => {
@@ -112,6 +118,31 @@ export class AbstractNumbering {
     return this.abstractNumId;
   }
 
+  /**
+   * Gets the namespace-scoped unique ID (ECMA-376 §17.9.17)
+   */
+  getNsid(): string | undefined {
+    return this.nsid;
+  }
+
+  /**
+   * Sets the namespace-scoped unique ID
+   */
+  setNsid(nsid: string): void {
+    this.nsid = nsid;
+  }
+
+  /**
+   * Generates a random 8-character uppercase hex nsid value
+   */
+  private static generateNsid(): string {
+    const hex = Math.floor(Math.random() * 0xffffffff)
+      .toString(16)
+      .toUpperCase()
+      .padStart(8, '0');
+    return hex;
+  }
+
   /**
    * Gets the name
    */
@@ -281,7 +312,12 @@ export class AbstractNumbering {
 
     // CT_AbstractNum order per ECMA-376: nsid → multiLevelType → tmpl → name → styleLink → numStyleLink → lvl*
 
-    // Add multiLevelType
+    // 1. nsid (ECMA-376 §17.9.17) — namespace-scoped unique identifier
+    if (this.nsid) {
+      children.push(XMLBuilder.wSelf('nsid', { 'w:val': this.nsid }));
+    }
+
+    // 2. multiLevelType
     let multiLevelTypeValue: string;
     if (this.multiLevelType === 1) {
       multiLevelTypeValue = 'multilevel';
@@ -549,6 +585,10 @@ export class AbstractNumbering {
     const tmplMatch = /<w:tmpl[^>]*w:val="([^"]+)"/.exec(xml);
     const tmpl = tmplMatch?.[1] || undefined;
 
+    // Extract nsid (optional, ECMA-376 §17.9.17) — 8-char hex namespace ID
+    const nsidMatch = /<w:nsid[^>]*w:val="([^"]+)"/.exec(xml);
+    const nsid = nsidMatch?.[1] || undefined;
+
     // Create abstract numbering
     const abstractNum = new AbstractNumbering({
       abstractNumId,
@@ -557,6 +597,7 @@ export class AbstractNumbering {
       numStyleLink,
       styleLink,
       tmpl,
+      nsid,
     });
 
     // Extract and parse all levels

package/src/formatting/CLAUDE.md

@@ -12,6 +12,10 @@ Properties: `styleId`, `type`, `name`, `basedOn` (inheritance), `next`, `link`,
 
 **Inheritance:** Styles inherit via `basedOn`. Resolution: default → basedOn chain → own formatting.
 
+**Run properties:** Style.ts delegates rPr generation to `Run.generateRunPropertiesXML()` for full ECMA-376 CT_RPr coverage (38+ elements in correct order).
+
+**Conditional formatting:** `tblStylePr` elements follow CT_Style order: pPr → rPr → tblPr → trPr → tcPr.
+
 Built-in styles: `Normal`, `Heading1`-`Heading6`, `Title`, `Subtitle`, `DefaultParagraphFont`, `TableGrid`.
 
 ### StylesManager (`StylesManager.ts`)

package/src/formatting/NumberingLevel.ts

@@ -444,7 +444,8 @@ export class NumberingLevel {
    * Generates the WordprocessingML XML for this level
    */
   toXML(): XMLElement {
-    // ECMA-376 CT_Lvl element order: start, numFmt, lvlRestart, pStyle, isLgl, suff, lvlText, lvlJc, pPr, rPr
+    // ECMA-376 CT_Lvl element order (§17.9.6):
+    // start, numFmt, lvlRestart, pStyle, isLgl, suff, lvlText, lvlPicBulletId, legacy, lvlJc, pPr, rPr
     const children: XMLElement[] = [];
 
     // 1. Start value
@@ -514,20 +515,23 @@ export class NumberingLevel {
       rPrChildren.push(XMLBuilder.wSelf('iCs'));
     }
 
-    // Underline
-    if (this.properties.underline) {
-      rPrChildren.push(XMLBuilder.wSelf('u', { 'w:val': this.properties.underline }));
-    }
+    // CT_RPr element order per ECMA-376 §17.3.2.28:
+    // ... b, bCs, i, iCs, ... color (#19), ... sz (#24), szCs (#25), ... u (#27)
 
-    // Color
+    // Color (#19)
     if (this.properties.color) {
       rPrChildren.push(XMLBuilder.wSelf('color', { 'w:val': this.properties.color }));
     }
 
-    // Font size
+    // Font size (#24, #25)
     rPrChildren.push(XMLBuilder.wSelf('sz', { 'w:val': this.properties.fontSize.toString() }));
     rPrChildren.push(XMLBuilder.wSelf('szCs', { 'w:val': this.properties.fontSize.toString() }));
 
+    // Underline (#27)
+    if (this.properties.underline) {
+      rPrChildren.push(XMLBuilder.wSelf('u', { 'w:val': this.properties.underline }));
+    }
+
     const rPr = XMLBuilder.w('rPr', undefined, rPrChildren);
     children.push(rPr);
 

package/src/formatting/Style.ts

@@ -5,11 +5,10 @@
 
 import { XMLBuilder, XMLElement } from '../xml/XMLBuilder';
 import { ParagraphFormatting } from '../elements/Paragraph';
-import { RunFormatting } from '../elements/Run';
-import { ShadingConfig, ShadingPattern, buildShadingAttributes } from '../elements/CommonTypes';
+import { Run, RunFormatting } from '../elements/Run';
+import { ShadingConfig, buildShadingAttributes } from '../elements/CommonTypes';
 import { Heading2TableOptions } from '../types/styleConfig';
 import { deepClone } from '../utils/deepClone';
-import { pointsToHalfPoints } from '../utils/units';
 
 /**
  * Style type
@@ -85,6 +84,8 @@ export interface CellMargins {
 export interface TableStyleFormatting {
   /** Table indentation from left margin in twips */
   indent?: number;
+  /** Indent width type per ECMA-376 ST_TblWidth */
+  indentType?: string;
   /** Default cell spacing in twips */
   cellSpacing?: number;
   /** Table borders */
@@ -828,11 +829,28 @@ export class Style {
           );
         }
         if (numPrChildren.length > 0) {
-          // Insert numPr at the beginning of pPr children (per ECMA-376 element order)
-          if (pPr.children) {
-            pPr.children.unshift(XMLBuilder.w('numPr', undefined, numPrChildren));
+          // Per CT_PPrBase, numPr is at position #7: after keepNext, keepLines, pageBreakBefore,
+          // framePr, widowControl — insert after the last of these that's present.
+          const numPrEl = XMLBuilder.w('numPr', undefined, numPrChildren);
+          if (pPr.children && pPr.children.length > 0) {
+            // Find insertion point: after keepNext/keepLines/pageBreakBefore (positions #2-#4)
+            // These are the only elements generateParagraphProperties() emits before numPr
+            let insertIdx = 0;
+            for (let i = 0; i < pPr.children.length; i++) {
+              const child = pPr.children[i];
+              if (child && typeof child !== 'string') {
+                if (
+                  child.name === 'w:keepNext' ||
+                  child.name === 'w:keepLines' ||
+                  child.name === 'w:pageBreakBefore'
+                ) {
+                  insertIdx = i + 1;
+                }
+              }
+            }
+            pPr.children.splice(insertIdx, 0, numPrEl);
           } else {
-            pPr.children = [XMLBuilder.w('numPr', undefined, numPrChildren)];
+            pPr.children = [numPrEl];
           }
         }
       }
@@ -959,63 +977,13 @@ export class Style {
   }
 
   /**
-   * Generates run properties XML
+   * Generates run properties XML.
+   * Delegates to Run.generateRunPropertiesXML() for full ECMA-376 CT_RPr coverage
+   * with correct element ordering (38+ properties).
    */
   private generateRunProperties(formatting: RunFormatting): XMLElement {
-    const rPrChildren: XMLElement[] = [];
-
-    // Add formatting elements — ordered per ECMA-376 CT_RPr
-    if (formatting.font) {
-      rPrChildren.push(
-        XMLBuilder.wSelf('rFonts', {
-          'w:ascii': formatting.font,
-          'w:hAnsi': formatting.font,
-          'w:cs': formatting.font,
-        })
-      );
-    }
-    if (formatting.bold) {
-      rPrChildren.push(XMLBuilder.wSelf('b'));
-    }
-    if (formatting.italic) {
-      rPrChildren.push(XMLBuilder.wSelf('i'));
-    }
-    if (formatting.allCaps) {
-      rPrChildren.push(XMLBuilder.wSelf('caps'));
-    }
-    if (formatting.smallCaps) {
-      rPrChildren.push(XMLBuilder.wSelf('smallCaps'));
-    }
-    if (formatting.strike) {
-      rPrChildren.push(XMLBuilder.wSelf('strike'));
-    }
-    if (formatting.dstrike) {
-      rPrChildren.push(XMLBuilder.wSelf('dstrike'));
-    }
-    if (formatting.color) {
-      rPrChildren.push(XMLBuilder.wSelf('color', { 'w:val': formatting.color }));
-    }
-    if (formatting.size !== undefined) {
-      const halfPoints = pointsToHalfPoints(formatting.size);
-      rPrChildren.push(XMLBuilder.wSelf('sz', { 'w:val': halfPoints }));
-      rPrChildren.push(XMLBuilder.wSelf('szCs', { 'w:val': halfPoints }));
-    }
-    if (formatting.highlight) {
-      rPrChildren.push(XMLBuilder.wSelf('highlight', { 'w:val': formatting.highlight }));
-    }
-    if (formatting.underline) {
-      const underlineValue =
-        typeof formatting.underline === 'string' ? formatting.underline : 'single';
-      rPrChildren.push(XMLBuilder.wSelf('u', { 'w:val': underlineValue }));
-    }
-    if (formatting.subscript) {
-      rPrChildren.push(XMLBuilder.wSelf('vertAlign', { 'w:val': 'subscript' }));
-    }
-    if (formatting.superscript) {
-      rPrChildren.push(XMLBuilder.wSelf('vertAlign', { 'w:val': 'superscript' }));
-    }
-
-    return XMLBuilder.w('rPr', undefined, rPrChildren);
+    const rPr = Run.generateRunPropertiesXML(formatting);
+    return rPr || XMLBuilder.w('rPr', undefined, []);
   }
 
   /**
@@ -1073,7 +1041,7 @@ export class Style {
       tblPrChildren.push(
         XMLBuilder.wSelf('tblInd', {
           'w:w': formatting.indent,
-          'w:type': 'dxa',
+          'w:type': formatting.indentType || 'dxa',
         })
       );
     }
@@ -1254,6 +1222,14 @@ export class Style {
       }
     }
 
+    // Add row properties if specified (trPr before tcPr per CT_Style §17.7.6)
+    if (conditional.rowFormatting) {
+      const trPr = this.generateTableRowProperties(conditional.rowFormatting);
+      if (trPr.children && trPr.children.length > 0) {
+        tblStylePrChildren.push(trPr);
+      }
+    }
+
     // Add cell properties if specified
     if (conditional.cellFormatting) {
       const tcPr = this.generateTableCellProperties(conditional.cellFormatting);
@@ -1262,14 +1238,6 @@ export class Style {
       }
     }
 
-    // Add row properties if specified
-    if (conditional.rowFormatting) {
-      const trPr = this.generateTableRowProperties(conditional.rowFormatting);
-      if (trPr.children && trPr.children.length > 0) {
-        tblStylePrChildren.push(trPr);
-      }
-    }
-
     return XMLBuilder.w('tblStylePr', { 'w:type': conditional.type }, tblStylePrChildren);
   }