docxmlater 11.0.10 → 12.1.0

package/src/elements/Table.ts

@@ -3,11 +3,13 @@
  */
 
 import { Paragraph } from './Paragraph.js';
+import { Run } from './Run.js';
 import { TableRow, RowFormatting } from './TableRow.js';
 import { TableCell, CellFormatting } from './TableCell.js';
 import { Revision } from './Revision.js';
 import { XMLBuilder, XMLElement } from '../xml/XMLBuilder.js';
 import { deepClone } from '../utils/deepClone.js';
+import { formatDateForXml } from '../utils/dateFormatting.js';
 import { TableGridChange } from './TableGridChange.js';
 import {
   TableAlignment as CommonTableAlignment,
@@ -2069,22 +2071,10 @@ export class Table {
       if (this.rows.length <= 1 && !this.trackingContext?.isEnabled()) {
         return false;
       }
-      // When tracking enabled, mark cells with cellDel and wrap content in w:del
+      // When tracking enabled, record the whole-row tracked deletion instead
+      // of removing the row
       if (this.trackingContext?.isEnabled()) {
-        const author = this.trackingContext.getAuthor();
-        const row = this.rows[index]!;
-        for (const cell of row.getCells()) {
-          const cellDelRevision = Revision.createTableCellDelete(author, []);
-          cell.setCellRevision(cellDelRevision);
-          // Wrap paragraph runs in w:del so content appears as deleted
-          for (const para of cell.getParagraphs()) {
-            const runs = para.getRuns();
-            if (runs.length > 0) {
-              const deletion = Revision.createDeletion(author, runs);
-              para.addRevision(deletion);
-            }
-          }
-        }
+        this.markRowAsTrackedDeletion(this.rows[index]!);
         return true;
       }
       this.rows.splice(index, 1);
@@ -2109,6 +2099,47 @@ export class Table {
     return true;
   }
 
+  /**
+   * Marks a row as a tracked deletion. Per ECMA-376 §17.13.5.14 a tracked
+   * whole-row deletion is recorded as `w:del` inside `w:trPr` — not as
+   * per-cell `w:cellDel`, which tracks cell-structure changes and is never
+   * resolved into a row removal by the revision acceptor. The cell text is
+   * additionally wrapped in `w:del` so Word renders it struck through until
+   * the revision is resolved.
+   */
+  private markRowAsTrackedDeletion(row: TableRow): void {
+    const author = this.trackingContext!.getAuthor();
+    const manager = this.trackingContext!.getRevisionManager();
+    row.setRowDeletion({
+      id: String(manager.consumeNextId()),
+      author,
+      date: formatDateForXml(new Date()),
+    });
+    for (const cell of row.getCells()) {
+      for (const para of cell.getParagraphs()) {
+        this.wrapParagraphRunsInTrackedDeletion(para, author);
+      }
+    }
+  }
+
+  /**
+   * Replaces each live run in the paragraph with a delete revision wrapping
+   * it. Replacement (not append) matters: appending the revision would leave
+   * the original run live alongside its `w:del` copy, so the text would
+   * serialize twice and survive an accept. Items already inside revisions
+   * are left alone to avoid double-wrapping.
+   */
+  private wrapParagraphRunsInTrackedDeletion(para: Paragraph, author: string): void {
+    const manager = this.trackingContext!.getRevisionManager();
+    for (const item of para.getContent()) {
+      if (item instanceof Run) {
+        const deletion = Revision.createDeletion(author, item);
+        manager.register(deletion);
+        para.replaceContent(item, [deletion]);
+      }
+    }
+  }
+
   /**
    * Inserts a row at a specific position
    *
@@ -2146,13 +2177,16 @@ export class Table {
     // Insert the row
     this.rows.splice(index, 0, row);
 
-    // When tracking enabled, mark every cell in the new row with cellIns
+    // When tracking enabled, mark the row as a tracked insertion. Per
+    // ECMA-376 §17.13.5.19 a whole-row insertion is recorded as w:ins inside
+    // w:trPr — per-cell w:cellIns tracks cell-structure changes and would not
+    // let Word or the revision acceptor resolve the row as inserted.
     if (this.trackingContext?.isEnabled()) {
-      const author = this.trackingContext.getAuthor();
-      for (const cell of row.getCells()) {
-        const revision = Revision.createTableCellInsert(author, []);
-        cell.setCellRevision(revision);
-      }
+      row.setRowInsertion({
+        id: String(this.trackingContext.getRevisionManager().consumeNextId()),
+        author: this.trackingContext.getAuthor(),
+        date: formatDateForXml(new Date()),
+      });
     }
 
     return row;
@@ -2198,6 +2232,26 @@ export class Table {
         row.insertCellAt(idx, cell);
       }
     }
+
+    // Keep w:tblGrid in sync — toXML() trusts formatting.tableGrid for the
+    // gridCol count whenever it is set (every loaded table has one), so a
+    // stale grid makes rows consume more columns than the grid defines and
+    // Word misassigns fixed-layout widths (ECMA-376 §17.4.49)
+    const grid = this.formatting.tableGrid;
+    if (grid) {
+      const at = index === undefined || index >= grid.length ? grid.length : Math.max(0, index);
+      const left = at > 0 ? grid[at - 1] : undefined;
+      const right = at < grid.length ? grid[at] : undefined;
+      // Mirror a neighbor's width; fall back to 1 inch when the grid has no
+      // usable neighbor (e.g. an empty w:tblGrid) so a numeric width is always
+      // inserted rather than `undefined`.
+      const width =
+        left !== undefined && right !== undefined
+          ? Math.round((left + right) / 2)
+          : (left ?? right ?? 1440);
+      grid.splice(at, 0, width);
+    }
+
     return this;
   }
 
@@ -2220,15 +2274,25 @@ export class Table {
       return false;
     }
 
-    // When tracking enabled, mark cells with cellDel instead of removing
+    // When tracking enabled, mark cells with cellDel instead of removing.
+    // Column deletions keep the cell-level marker (w:cellDel §17.13.5.1) —
+    // a row-level w:del would claim entire rows were deleted.
     if (this.trackingContext?.isEnabled()) {
       const author = this.trackingContext.getAuthor();
+      const manager = this.trackingContext.getRevisionManager();
       let marked = false;
       for (const row of this.rows) {
         const cells = row.getCells();
         if (index < cells.length) {
+          const cell = cells[index]!;
           const revision = Revision.createTableCellDelete(author, []);
-          cells[index]!.setCellRevision(revision);
+          // Register so each marker gets a unique w:id — unregistered
+          // revisions all serialize as w:id="0", which fails validation
+          manager.register(revision);
+          cell.setCellRevision(revision);
+          for (const para of cell.getParagraphs()) {
+            this.wrapParagraphRunsInTrackedDeletion(para, author);
+          }
           marked = true;
         }
       }
@@ -2244,6 +2308,14 @@ export class Table {
       }
     }
 
+    // Keep w:tblGrid in sync — leaving the deleted column's width in
+    // formatting.tableGrid shifts every surviving column onto the wrong
+    // gridCol width in fixed-layout tables (ECMA-376 §17.4.49). The tracked
+    // branch above keeps cells in place, so the grid must not shrink there.
+    if (removed && this.formatting.tableGrid && index < this.formatting.tableGrid.length) {
+      this.formatting.tableGrid.splice(index, 1);
+    }
+
     return removed;
   }
 
@@ -2738,6 +2810,28 @@ export class Table {
           }
         }
       }
+    } else if (endCol > startCol) {
+      // Per ECMA-376 §17.4.17 a gridSpan cell consumes the columns it spans,
+      // so the absorbed w:tc elements must leave the row — keeping them
+      // widens the table grid and misaligns every other row. Their content
+      // moves into the surviving cell first, matching Word's merge behavior.
+      // vMerge 'continue' cells at startCol stay (required by §17.4.84), and
+      // the tracked branch above keeps cells so w:cellMerge markers survive.
+      const absorbedCount = endCol - startCol;
+      for (let row = startRow; row <= endRow; row++) {
+        const tableRow = this.rows[row];
+        if (!tableRow) continue;
+        for (let i = 0; i < absorbedCount; i++) {
+          const absorbed = tableRow.removeCellAt(startCol + 1);
+          if (!absorbed) break;
+          for (const para of absorbed.getParagraphs()) {
+            // Placeholder-empty paragraphs would only pad the merged cell
+            // with blank lines Word's merge does not create
+            if (para.getContent().length === 0) continue;
+            cell.addParagraph(para);
+          }
+        }
+      }
     }
 
     return this;
@@ -2848,12 +2942,13 @@ export class Table {
     const fromCell = this.getCell(fromRow, fromCol);
     const toCell = this.getCell(toRow, toCol);
 
-    if (!fromCell || !toCell) {
+    if (!fromCell || !toCell || fromCell === toCell) {
       return this;
     }
 
-    // Copy all paragraphs from source to target
-    const paragraphs = fromCell.getParagraphs();
+    // Detach paragraphs from the source before re-homing them so the same
+    // Paragraph instances never live in two cells at once
+    const paragraphs = fromCell._detachAllParagraphs();
     for (const para of paragraphs) {
       toCell.addParagraph(para);
     }
@@ -2865,11 +2960,11 @@ export class Table {
     if (formatting.width) toCell.setWidth(formatting.width);
     if (formatting.verticalAlignment) toCell.setVerticalAlignment(formatting.verticalAlignment);
 
-    // Clear source cell (replace with empty paragraph)
+    // Clear source cell by writing an empty cell into the row's live array —
+    // getCells() returns a defensive copy, so assigning into it never persists
     const row = this.getRow(fromRow);
     if (row) {
-      const cells = row.getCells();
-      cells[fromCol] = new TableCell();
+      row.setCellAt(fromCol, new TableCell());
     }
 
     return this;
@@ -2895,17 +2990,18 @@ export class Table {
       return this;
     }
 
-    const cells1 = row1Obj.getCells();
-    const cells2 = row2Obj.getCells();
+    const cell1 = row1Obj.getCell(col1);
+    const cell2 = row2Obj.getCell(col2);
 
-    if (col1 >= cells1.length || col2 >= cells2.length) {
+    if (!cell1 || !cell2 || cell1 === cell2) {
       return this;
     }
 
-    // Swap cells
-    const temp = cells1[col1];
-    cells1[col1] = cells2[col2]!;
-    cells2[col2] = temp!;
+    // Swap through the rows' live cell arrays — getCells() returns a
+    // defensive copy, so swapping inside it never persists. setCellAt also
+    // re-points each cell's parent-row reference.
+    row1Obj.setCellAt(col1, cell2);
+    row2Obj.setCellAt(col2, cell1);
 
     return this;
   }
@@ -2976,22 +3072,10 @@ export class Table {
 
     const actualCount = Math.min(count, this.rows.length - startIndex);
 
-    // When tracking enabled, mark each row's cells with cellDel + w:del
+    // When tracking enabled, record each row as a whole-row tracked deletion
     if (this.trackingContext?.isEnabled()) {
-      const author = this.trackingContext.getAuthor();
       for (let i = startIndex; i < startIndex + actualCount; i++) {
-        const row = this.rows[i]!;
-        for (const cell of row.getCells()) {
-          const cellDelRevision = Revision.createTableCellDelete(author, []);
-          cell.setCellRevision(cellDelRevision);
-          for (const para of cell.getParagraphs()) {
-            const runs = para.getRuns();
-            if (runs.length > 0) {
-              const deletion = Revision.createDeletion(author, runs);
-              para.addRevision(deletion);
-            }
-          }
-        }
+        this.markRowAsTrackedDeletion(this.rows[i]!);
       }
       return true;
     }
@@ -3322,6 +3406,23 @@ export class Table {
       clonedTable.addRow(row.clone());
     }
 
+    // Tracked revision history (w:tblPrChange / w:tblGridChange) lives outside
+    // formatting, so deepClone above cannot carry it — copy explicitly for
+    // parity with TableRow.clone()/TableCell.clone().
+    if (this.tblPrChange) {
+      clonedTable.setTblPrChange(deepClone(this.tblPrChange));
+    }
+    if (this.tblGridChange) {
+      clonedTable.setTblGridChange(
+        new TableGridChange({
+          id: this.tblGridChange.getId(),
+          author: this.tblGridChange.getAuthor(),
+          date: deepClone(this.tblGridChange.getDate()),
+          previousGrid: deepClone(this.tblGridChange.getPreviousGrid()),
+        })
+      );
+    }
+
     return clonedTable;
   }
 

package/src/elements/TableCell.ts

@@ -5,8 +5,10 @@
 import { deepClone } from '../utils/deepClone.js';
 import { formatDateForXml } from '../utils/dateFormatting.js';
 import { XMLBuilder, XMLElement } from '../xml/XMLBuilder.js';
+import { Hyperlink } from './Hyperlink.js';
 import { Paragraph, TextDirection } from './Paragraph.js';
 import { Revision } from './Revision.js';
+import { Run } from './Run.js';
 import {
   BorderStyle as CommonBorderStyle,
   FullBorderStyle as CommonFullBorderStyle,
@@ -242,19 +244,32 @@ export class TableCell {
       return false;
     }
 
-    // When tracking enabled, wrap content in w:del instead of removing
+    // When tracking enabled, wrap content in w:del instead of removing.
+    // Each run is REPLACED by its delete revision — appending the revision
+    // would leave the original run live alongside its w:del copy, so the
+    // text would serialize twice and survive an accept.
     if (this.trackingContext?.isEnabled()) {
       const paragraph = this.paragraphs[index]!;
-      const runs = paragraph.getRuns();
-      if (runs.length > 0) {
-        const author = this.trackingContext.getAuthor();
-        const deletion = Revision.createDeletion(author, runs);
-        this.trackingContext.getRevisionManager().register(deletion);
-        paragraph.addRevision(deletion);
+      const author = this.trackingContext.getAuthor();
+      const manager = this.trackingContext.getRevisionManager();
+      for (const item of paragraph.getContent()) {
+        if (item instanceof Run || item instanceof Hyperlink) {
+          const deletion = Revision.createDeletion(author, item);
+          manager.register(deletion);
+          paragraph.replaceContent(item, [deletion]);
+        }
       }
       return true;
     }
 
+    // Word repairs files where a nested table is the final child of w:tc —
+    // every cell must end with w:p. Refuse to remove the last paragraph when
+    // raw block content sits immediately before it and nothing would follow.
+    const isLastParagraph = index === this.paragraphs.length - 1;
+    if (isLastParagraph && this.rawNestedContent.some((item) => item.position === index)) {
+      return false;
+    }
+
     const removed = this.paragraphs.splice(index, 1);
     const removedPara = removed[0];
     if (removedPara) {
@@ -309,14 +324,20 @@ export class TableCell {
       paragraph._setStylesManager(stylesManager);
     }
 
-    // When tracking enabled, wrap paragraph content in w:ins revision
+    // When tracking enabled, wrap paragraph content in w:ins revisions.
+    // Each top-level Run/Hyperlink is REPLACED by its insert revision in
+    // place — wrapping paragraph.getRuns() and appending the revision would
+    // leave the originals live alongside the w:ins copy, so the text would
+    // serialize twice and survive a reject.
     if (this.trackingContext?.isEnabled()) {
-      const runs = paragraph.getRuns();
-      if (runs.length > 0) {
-        const author = this.trackingContext.getAuthor();
-        const insertion = Revision.createInsertion(author, runs);
-        this.trackingContext.getRevisionManager().register(insertion);
-        paragraph.addRevision(insertion);
+      const author = this.trackingContext.getAuthor();
+      const manager = this.trackingContext.getRevisionManager();
+      for (const item of paragraph.getContent()) {
+        if (item instanceof Run || item instanceof Hyperlink) {
+          const insertion = Revision.createInsertion(author, item);
+          manager.register(insertion);
+          paragraph.replaceContent(item, [insertion]);
+        }
       }
     }
 
@@ -1288,6 +1309,22 @@ export class TableCell {
     return this._parentRow;
   }
 
+  /**
+   * Removes every paragraph from this cell and returns them, bypassing
+   * tracked-change wrapping. Used when content is moved wholesale to another
+   * cell — the paragraphs must leave this cell's array first so the same
+   * Paragraph instances never live in two cells at once.
+   * @internal
+   */
+  _detachAllParagraphs(): Paragraph[] {
+    const detached = this.paragraphs;
+    this.paragraphs = [];
+    for (const para of detached) {
+      para._setParentCell(undefined);
+    }
+    return detached;
+  }
+
   /**
    * Gets the table style ID by traversing up the parent chain.
    * @returns Table style ID or undefined if not in a table or no style set
@@ -1707,6 +1744,7 @@ export class TableCell {
       }
 
       // Insert any remaining raw content after all paragraphs
+      const rawContentEndsCell = rawIndex < sortedRaw.length;
       while (rawIndex < sortedRaw.length) {
         const rawItem = sortedRaw[rawIndex];
         if (rawItem) {
@@ -1718,9 +1756,11 @@ export class TableCell {
         rawIndex++;
       }
 
-      // If we only have raw content and no paragraphs, we need at least one empty paragraph
-      // per ECMA-376 (table cell must contain at least one block-level element)
-      if (this.paragraphs.length === 0) {
+      // Word requires every cell to end with w:p (it repairs files where a
+      // nested w:tbl is the final child of w:tc), so close with an empty
+      // paragraph whenever raw block content ended up last — this also covers
+      // cells that have raw content but no paragraphs at all
+      if (rawContentEndsCell) {
         cellChildren.push(new Paragraph().toXML());
       }
     } else {

package/src/elements/TableOfContents.ts

@@ -247,11 +247,10 @@ export class TableOfContents {
 
     // Add specific styles switch OR heading levels switch
     if (this.includeStyles && this.includeStyles.length > 0) {
-      // Use \t switch to specify exact styles
-      // Format: \t "StyleName,Level," for each style
-      for (const style of this.includeStyles) {
-        instruction += ` \\t "${style.styleName},${style.level},"`;
-      }
+      // Per ECMA-376 §17.16.5.68, \t takes a single field-argument with all
+      // StyleName,Level doublets — Word honors only one \t instance
+      const doublets = this.includeStyles.map((s) => `${s.styleName},${s.level}`).join(',');
+      instruction += ` \\t "${doublets}"`;
     } else {
       // Use \o switch for heading levels
       instruction += ` \\o "1-${this.levels}"`;
@@ -273,11 +272,13 @@ export class TableOfContents {
     }
 
     // Add tab leader switch
-    if (this.tabLeader !== 'dot') {
+    // Per ECMA-376 §17.16.5.68, \p takes the literal separator character(s)
+    // between entry and page number, not an ST_TabTlc letter code.
+    // 'none' omits the switch so Word uses its default separator.
+    if (this.tabLeader !== 'dot' && this.tabLeader !== 'none') {
       const leaderMap = {
-        hyphen: 'h',
-        underscore: 'u',
-        none: 'n',
+        hyphen: '-',
+        underscore: '_',
       };
       instruction += ` \\p "${leaderMap[this.tabLeader]}"`;
     }

package/src/elements/TableRow.ts

@@ -250,6 +250,32 @@ export class TableRow {
     cell._setParentRow(this);
   }
 
+  /**
+   * Replaces the cell at the specified index in the row's live cell array.
+   * getCells() returns a defensive copy, so callers cannot persist a
+   * replacement by writing into that copy — this is the write-through path.
+   * @param index - Position to replace (0-based)
+   * @returns The replaced cell, or undefined if index is out of bounds
+   */
+  setCellAt(index: number, cell: TableCell): TableCell | undefined {
+    if (index < 0 || index >= this.cells.length) return undefined;
+    const previous = this.cells[index];
+    this.cells[index] = cell;
+    cell._setParentRow(this);
+    // During a swap the outgoing cell may already have been re-homed to
+    // another row (or re-inserted elsewhere in this row) — only orphan it
+    // when it genuinely left the table.
+    if (
+      previous &&
+      previous !== cell &&
+      previous._getParentRow() === this &&
+      !this.cells.includes(previous)
+    ) {
+      previous._setParentRow(undefined);
+    }
+    return previous;
+  }
+
   /**
    * Removes and returns the cell at the specified index
    * @param index - Position to remove (0-based)
@@ -283,9 +309,14 @@ export class TableRow {
    * Calculates the total grid span of the row (considering column spans)
    *
    * For tables with merged cells, this returns the number of logical columns
-   * this row spans based on the columnSpan values of each cell.
+   * this row spans based on the columnSpan values of each cell. Per ECMA-376
+   * §17.4.14/§17.4.15, w:gridBefore/w:gridAfter consume grid columns before
+   * the first and after the last cell, so they count toward the row's grid
+   * footprint — otherwise auto-generated w:tblGrid would declare fewer
+   * columns than offset rows actually occupy.
    *
-   * @returns Total grid span (sum of all cell spans, where unspanned cells count as 1)
+   * @returns Total grid span (gridBefore + sum of all cell spans + gridAfter,
+   *   where unspanned cells count as 1)
    *
    * @example
    * ```typescript
@@ -298,11 +329,12 @@ export class TableRow {
    * ```
    */
   getTotalGridSpan(): number {
-    let totalSpan = 0;
+    let totalSpan = this.formatting.gridBefore ?? 0;
     for (const cell of this.cells) {
       const formatting = cell.getFormatting();
       totalSpan += formatting.columnSpan || 1;
     }
+    totalSpan += this.formatting.gridAfter ?? 0;
     return totalSpan;
   }
 

package/src/elements/TextBox.ts

@@ -390,58 +390,73 @@ export class TextBox {
       relativeHeight: 251658240,
     };
 
-    // Position H (horizontal)
-    if (this.position) {
-      const posH = this.position.horizontal;
-      const posHChildren: XMLElement[] = [];
-
-      if (posH.offset !== undefined) {
-        posHChildren.push({
-          name: 'wp:posOffset',
-          children: [posH.offset.toString()],
-        });
-      } else if (posH.alignment) {
-        posHChildren.push({
-          name: 'wp:align',
-          children: [posH.alignment],
-        });
-      }
+    // simplePos (required first child per CT_Anchor)
+    children.push({
+      name: 'wp:simplePos',
+      attributes: { x: '0', y: '0' },
+      selfClosing: true,
+    });
 
-      children.push({
-        name: 'wp:positionH',
-        attributes: {
-          relativeFrom: posH.anchor,
-        },
-        children: posHChildren,
+    // Position H (horizontal) — required child of wp:anchor per CT_Anchor
+    // (minOccurs=1), so fall back to a zero page offset when no explicit
+    // position is configured (anchor-only floating text boxes)
+    const posH = this.position?.horizontal;
+    const posHChildren: XMLElement[] = [];
+
+    if (posH?.offset !== undefined) {
+      posHChildren.push({
+        name: 'wp:posOffset',
+        children: [posH.offset.toString()],
+      });
+    } else if (posH?.alignment) {
+      posHChildren.push({
+        name: 'wp:align',
+        children: [posH.alignment],
+      });
+    } else {
+      posHChildren.push({
+        name: 'wp:posOffset',
+        children: ['0'],
       });
     }
 
-    // Position V (vertical)
-    if (this.position) {
-      const posV = this.position.vertical;
-      const posVChildren: XMLElement[] = [];
+    children.push({
+      name: 'wp:positionH',
+      attributes: {
+        relativeFrom: posH?.anchor ?? 'page',
+      },
+      children: posHChildren,
+    });
 
-      if (posV.offset !== undefined) {
-        posVChildren.push({
-          name: 'wp:posOffset',
-          children: [posV.offset.toString()],
-        });
-      } else if (posV.alignment) {
-        posVChildren.push({
-          name: 'wp:align',
-          children: [posV.alignment],
-        });
-      }
+    // Position V (vertical) — required child of wp:anchor per CT_Anchor
+    const posV = this.position?.vertical;
+    const posVChildren: XMLElement[] = [];
 
-      children.push({
-        name: 'wp:positionV',
-        attributes: {
-          relativeFrom: posV.anchor,
-        },
-        children: posVChildren,
+    if (posV?.offset !== undefined) {
+      posVChildren.push({
+        name: 'wp:posOffset',
+        children: [posV.offset.toString()],
+      });
+    } else if (posV?.alignment) {
+      posVChildren.push({
+        name: 'wp:align',
+        children: [posV.alignment],
+      });
+    } else {
+      posVChildren.push({
+        name: 'wp:posOffset',
+        children: ['0'],
       });
     }
 
+    children.push({
+      name: 'wp:positionV',
+      attributes: {
+        relativeFrom: posV?.anchor ?? 'page',
+      },
+      children: posVChildren,
+    });
+
     // Extent (size)
     children.push({
       name: 'wp:extent',

package/src/formatting/AbstractNumbering.ts

@@ -357,8 +357,10 @@ export class AbstractNumbering {
       children.push(level.toXML());
     });
 
-    // If no levels defined, add a default level 0
-    if (sortedLevels.length === 0) {
+    // If no levels defined, add a default level 0 — except for numStyleLink
+    // definitions, which are pure style references per ECMA-376 §17.9.21 and
+    // must carry no w:lvl children (the linked style supplies the levels)
+    if (sortedLevels.length === 0 && !this.numStyleLink) {
       children.push(NumberingLevel.createDecimalLevel(0).toXML());
     }