docxmlater 10.0.4 → 10.1.1

package/src/core/DocumentParser.ts

@@ -4352,6 +4352,7 @@ export class DocumentParser {
       const tooltip = hyperlinkObj["@_w:tooltip"];
       const tgtFrame = hyperlinkObj["@_w:tgtFrame"];
       const history = hyperlinkObj["@_w:history"];
+      const docLocation = hyperlinkObj["@_w:docLocation"];
 
       // Parse runs inside the hyperlink
       const runs = hyperlinkObj["w:r"];
@@ -4470,6 +4471,7 @@ export class DocumentParser {
         relationshipId: finalRelationshipId,
         tgtFrame,
         history,
+        docLocation,
       });
 
       // If we successfully parsed a run with tabs/breaks, use it instead of the default run
@@ -4772,6 +4774,9 @@ export class DocumentParser {
     if (parseOoxmlBoolean(rPrObj["w:i"])) run.setItalic(true);
     if (parseOoxmlBoolean(rPrObj["w:iCs"])) run.setComplexScriptItalic(true);
     if (parseOoxmlBoolean(rPrObj["w:strike"])) run.setStrike(true);
+    if (parseOoxmlBoolean(rPrObj["w:dstrike"])) {
+      (run as any).formatting.dstrike = true;
+    }
     if (parseOoxmlBoolean(rPrObj["w:smallCaps"])) run.setSmallCaps(true);
     if (parseOoxmlBoolean(rPrObj["w:caps"])) run.setAllCaps(true);
 
@@ -6094,14 +6099,14 @@ export class DocumentParser {
       table.setBidiVisual(true);
     }
 
-    // Parse table width
+    // Parse table width — always set when w:tblW is present, including w:w="0" w:type="auto"
+    // (auto-sized tables). Skipping w:w="0" would leave the constructor default (9360/dxa),
+    // causing tblPrChange snapshots to capture wrong "previous" width values.
     if (tblPrObj["w:tblW"]) {
-      const width = parseInt(tblPrObj["w:tblW"]["@_w:w"] || "0", 10);
+      const width = safeParseInt(tblPrObj["w:tblW"]["@_w:w"], 0);
       const widthType = tblPrObj["w:tblW"]["@_w:type"] || "dxa";
-      if (width > 0) {
-        table.setWidth(width);
-        table.setWidthType(widthType);
-      }
+      table.setWidth(width);
+      table.setWidthType(widthType);
     }
 
     // Parse table caption
@@ -6137,6 +6142,12 @@ export class DocumentParser {
       }
     }
 
+    // Parse table indentation (w:tblInd) per ECMA-376 Part 1 §17.4.43
+    if (tblPrObj["w:tblInd"]) {
+      const indentVal = safeParseInt(tblPrObj["w:tblInd"]["@_w:w"], 0);
+      table.setIndent(indentVal);
+    }
+
     // Parse table cell margins (w:tblCellMar) per ECMA-376 Part 1 §17.4.42
     if (tblPrObj["w:tblCellMar"]) {
       const cellMar = tblPrObj["w:tblCellMar"];
@@ -6379,6 +6390,14 @@ export class DocumentParser {
       }
     }
 
+    // Parse divId (w:divId) per ECMA-376 Part 1 §17.4.9
+    if (trPrObj["w:divId"]) {
+      const val = parseInt(trPrObj["w:divId"]["@_w:val"] || "0", 10);
+      if (val > 0) {
+        row.setDivId(val);
+      }
+    }
+
     // Parse table row property change (w:trPrChange) per ECMA-376 Part 1 §17.13.5.38
     if (trPrObj["w:trPrChange"]) {
       const changeObj = trPrObj["w:trPrChange"];
@@ -6531,6 +6550,10 @@ export class DocumentParser {
             borders.left = this.parseBorderElement(bordersObj["w:left"]);
           if (bordersObj["w:right"])
             borders.right = this.parseBorderElement(bordersObj["w:right"]);
+          if (bordersObj["w:tl2br"])
+            borders.tl2br = this.parseBorderElement(bordersObj["w:tl2br"]);
+          if (bordersObj["w:tr2bl"])
+            borders.tr2bl = this.parseBorderElement(bordersObj["w:tr2bl"]);
 
           if (Object.keys(borders).length > 0) {
             cell.setBorders(borders);
@@ -6605,6 +6628,14 @@ export class DocumentParser {
           cell.setHideMark(true);
         }
 
+        // Parse headers (w:headers) per ECMA-376 Part 1 §17.4.26
+        if (tcPr["w:headers"]) {
+          const headersVal = tcPr["w:headers"]["@_w:val"];
+          if (headersVal) {
+            cell.setHeaders(headersVal);
+          }
+        }
+
         // Parse fit text (w:tcFitText) per ECMA-376 Part 1 §17.4.68
         if (tcPr["w:tcFitText"]) {
           cell.setFitText(true);
@@ -7035,6 +7066,46 @@ export class DocumentParser {
           };
         } else if (sdtPr["w:group"]) {
           properties.controlType = "group";
+        } else if (sdtPr["w:citation"]) {
+          properties.controlType = "citation";
+        } else if (sdtPr["w:bibliography"]) {
+          properties.controlType = "bibliography";
+        } else if (sdtPr["w:equation"]) {
+          properties.controlType = "equation";
+        } else if (sdtPr["w:docPartList"]) {
+          properties.controlType = "docPartList";
+          const docPartList = sdtPr["w:docPartList"];
+          properties.buildingBlock = {
+            gallery: docPartList?.["w:docPartGallery"]?.["@_w:val"],
+            category: docPartList?.["w:docPartCategory"]?.["@_w:val"],
+            isList: true,
+          };
+        }
+
+        // Parse placeholder (w:placeholder/w:docPart)
+        const placeholderElement = sdtPr["w:placeholder"];
+        if (placeholderElement) {
+          const docPartVal = placeholderElement?.["w:docPart"]?.["@_w:val"];
+          if (docPartVal) {
+            properties.placeholder = { docPart: docPartVal };
+          }
+        }
+
+        // Parse data binding (w:dataBinding)
+        const dataBindingElement = sdtPr["w:dataBinding"];
+        if (dataBindingElement) {
+          properties.dataBinding = {
+            xpath: dataBindingElement["@_w:xpath"] || "",
+            prefixMappings: dataBindingElement["@_w:prefixMappings"],
+            storeItemId: dataBindingElement["@_w:storeItemID"],
+          };
+        }
+
+        // Parse showing placeholder flag (w:showingPlcHdr)
+        const showingPlcHdr = sdtPr["w:showingPlcHdr"];
+        if (showingPlcHdr) {
+          const val = showingPlcHdr["@_w:val"];
+          properties.showingPlcHdr = val === "1" || val === "true" || val === true;
         }
       }
 
@@ -8602,6 +8673,14 @@ export class DocumentParser {
     const personal =
       styleXml.includes("<w:personal/>") || styleXml.includes("<w:personal ");
 
+    // personalCompose - Style for composing new messages
+    const personalCompose =
+      styleXml.includes("<w:personalCompose/>") || styleXml.includes("<w:personalCompose ");
+
+    // personalReply - Style for replying to messages
+    const personalReply =
+      styleXml.includes("<w:personalReply/>") || styleXml.includes("<w:personalReply ");
+
     // autoRedefine - Update style from formatting
     const autoRedefine =
       styleXml.includes("<w:autoRedefine/>") ||
@@ -8673,6 +8752,8 @@ export class DocumentParser {
       unhideWhenUsed: unhideWhenUsed || undefined,
       locked: locked || undefined,
       personal: personal || undefined,
+      personalCompose: personalCompose || undefined,
+      personalReply: personalReply || undefined,
       autoRedefine: autoRedefine || undefined,
       uiPriority,
       link,
@@ -10046,7 +10127,7 @@ export class DocumentParser {
     if (propsObj["w:tcBorders"]) {
       const borders: any = {};
       const bordersObj = propsObj["w:tcBorders"];
-      for (const side of ['top', 'bottom', 'left', 'right']) {
+      for (const side of ['top', 'bottom', 'left', 'right', 'tl2br', 'tr2bl']) {
         if (bordersObj[`w:${side}`]) {
           borders[side] = this.parseBorderElement(bordersObj[`w:${side}`]);
         }

package/src/elements/Hyperlink.ts

@@ -76,6 +76,8 @@ export interface HyperlinkProperties {
   tgtFrame?: string;
   /** History tracking attribute */
   history?: string;
+  /** Document location for within-document navigation in external files (ECMA-376 §17.16.22) */
+  docLocation?: string;
 }
 
 /**
@@ -95,6 +97,8 @@ export class Hyperlink {
   private tgtFrame?: string;
   /** History tracking attribute */
   private history?: string;
+  /** Document location for within-document navigation in external files */
+  private docLocation?: string;
   /** Tracking context for automatic change tracking */
   private trackingContext?: import('../tracking/TrackingContext').TrackingContext;
   /** Parent paragraph reference for automatic tracking */
@@ -115,6 +119,7 @@ export class Hyperlink {
     this.relationshipId = properties.relationshipId;
     this.tgtFrame = properties.tgtFrame;
     this.history = properties.history;
+    this.docLocation = properties.docLocation;
     this._isEmpty = properties.isEmpty ?? false;
 
     // VALIDATION: Warn about hybrid links (url + anchor)
@@ -263,6 +268,40 @@ export class Hyperlink {
     return this.history;
   }
 
+  /**
+   * Sets the target frame attribute
+   * @param tgtFrame Target frame (e.g., "_blank" for new window)
+   */
+  setTgtFrame(tgtFrame: string | undefined): this {
+    this.tgtFrame = tgtFrame;
+    return this;
+  }
+
+  /**
+   * Sets the history tracking attribute
+   * @param history History value (e.g., "1" to add to history)
+   */
+  setHistory(history: string | undefined): this {
+    this.history = history;
+    return this;
+  }
+
+  /**
+   * Gets the document location attribute (ECMA-376 §17.16.22)
+   */
+  getDocLocation(): string | undefined {
+    return this.docLocation;
+  }
+
+  /**
+   * Sets the document location for within-document navigation in external files
+   * @param docLocation Location string
+   */
+  setDocLocation(docLocation: string | undefined): this {
+    this.docLocation = docLocation;
+    return this;
+  }
+
   /**
    * Gets the display text
    *
@@ -983,6 +1022,9 @@ export class Hyperlink {
       tooltip: this.tooltip,
       relationshipId: this.relationshipId,
       formatting: { ...this.formatting },
+      tgtFrame: this.tgtFrame,
+      history: this.history,
+      docLocation: this.docLocation,
     });
 
     // Copy the run with its formatting
@@ -1053,6 +1095,11 @@ export class Hyperlink {
       attributes["w:history"] = this.history;
     }
 
+    // Document location attribute (ECMA-376 §17.16.22)
+    if (this.docLocation) {
+      attributes["w:docLocation"] = this.docLocation;
+    }
+
     // Empty/invisible hyperlinks have no children (self-closing element)
     if (this._isEmpty) {
       return {

package/src/elements/StructuredDocumentTag.ts

@@ -31,7 +31,11 @@ export type ContentControlType =
   | "checkbox"
   | "picture"
   | "buildingBlock"
-  | "group";
+  | "group"
+  | "citation"
+  | "bibliography"
+  | "docPartList"
+  | "equation";
 
 /**
  * List item for combo box or dropdown
@@ -112,6 +116,28 @@ export interface BuildingBlockProperties {
   gallery?: string;
   /** Building block category */
   category?: string;
+  /** Whether to use docPartList (true) or docPartObj (false, default) */
+  isList?: boolean;
+}
+
+/**
+ * Placeholder properties for SDT
+ */
+export interface SDTPlaceholder {
+  /** Name of the document part to use as placeholder */
+  docPart: string;
+}
+
+/**
+ * Data binding properties for SDT
+ */
+export interface SDTDataBinding {
+  /** XPath expression for the data binding */
+  xpath: string;
+  /** Namespace prefix mappings */
+  prefixMappings?: string;
+  /** Custom XML data store item ID */
+  storeItemId?: string;
 }
 
 /**
@@ -142,6 +168,12 @@ export interface SDTProperties {
   checkbox?: CheckboxProperties;
   /** Building block properties */
   buildingBlock?: BuildingBlockProperties;
+  /** Placeholder (w:placeholder) */
+  placeholder?: SDTPlaceholder;
+  /** Data binding (w:dataBinding) */
+  dataBinding?: SDTDataBinding;
+  /** Whether SDT is currently showing placeholder content */
+  showingPlcHdr?: boolean;
 }
 
 /**
@@ -490,6 +522,38 @@ export class StructuredDocumentTag {
       );
     }
 
+    // Add placeholder
+    if (this.properties.placeholder) {
+      sdtPrChildren.push(
+        XMLBuilder.w("placeholder", {}, [
+          XMLBuilder.wSelf("docPart", { "w:val": this.properties.placeholder.docPart }),
+        ])
+      );
+    }
+
+    // Add showing placeholder flag
+    if (this.properties.showingPlcHdr !== undefined) {
+      sdtPrChildren.push(
+        XMLBuilder.wSelf("showingPlcHdr", {
+          "w:val": this.properties.showingPlcHdr ? "true" : "false",
+        })
+      );
+    }
+
+    // Add data binding
+    if (this.properties.dataBinding) {
+      const dbAttrs: Record<string, string> = {
+        "w:xpath": this.properties.dataBinding.xpath,
+      };
+      if (this.properties.dataBinding.prefixMappings) {
+        dbAttrs["w:prefixMappings"] = this.properties.dataBinding.prefixMappings;
+      }
+      if (this.properties.dataBinding.storeItemId) {
+        dbAttrs["w:storeItemID"] = this.properties.dataBinding.storeItemId;
+      }
+      sdtPrChildren.push(XMLBuilder.wSelf("dataBinding", dbAttrs));
+    }
+
     // Add control type-specific XML
     if (this.properties.controlType) {
       switch (this.properties.controlType) {
@@ -643,6 +707,39 @@ export class StructuredDocumentTag {
         case "group":
           sdtPrChildren.push(XMLBuilder.wSelf("group", {}));
           break;
+
+        case "citation":
+          sdtPrChildren.push(XMLBuilder.wSelf("citation", {}));
+          break;
+
+        case "bibliography":
+          sdtPrChildren.push(XMLBuilder.wSelf("bibliography", {}));
+          break;
+
+        case "equation":
+          sdtPrChildren.push(XMLBuilder.wSelf("equation", {}));
+          break;
+
+        case "docPartList":
+          if (this.properties.buildingBlock) {
+            const dplChildren: XMLElement[] = [];
+            if (this.properties.buildingBlock.gallery) {
+              dplChildren.push(
+                XMLBuilder.wSelf("docPartGallery", {
+                  "w:val": this.properties.buildingBlock.gallery,
+                })
+              );
+            }
+            if (this.properties.buildingBlock.category) {
+              dplChildren.push(
+                XMLBuilder.wSelf("docPartCategory", {
+                  "w:val": this.properties.buildingBlock.category,
+                })
+              );
+            }
+            sdtPrChildren.push(XMLBuilder.w("docPartList", {}, dplChildren));
+          }
+          break;
       }
     }
 
@@ -975,4 +1072,136 @@ export class StructuredDocumentTag {
     const lock = this.properties.lock;
     return lock !== "contentLocked" && lock !== "sdtContentLocked";
   }
+
+  /**
+   * Get the placeholder configuration
+   */
+  getPlaceholder(): SDTPlaceholder | undefined {
+    return this.properties.placeholder;
+  }
+
+  /**
+   * Set the placeholder (w:placeholder/w:docPart)
+   * @param docPart - Name of the document part to use as placeholder
+   */
+  setPlaceholder(docPart: string): this {
+    this.properties.placeholder = { docPart };
+    return this;
+  }
+
+  /**
+   * Get the data binding configuration
+   */
+  getDataBinding(): SDTDataBinding | undefined {
+    return this.properties.dataBinding;
+  }
+
+  /**
+   * Set the data binding (w:dataBinding)
+   * @param xpath - XPath expression
+   * @param prefixMappings - Namespace prefix mappings
+   * @param storeItemId - Custom XML data store item ID
+   */
+  setDataBinding(xpath: string, prefixMappings?: string, storeItemId?: string): this {
+    this.properties.dataBinding = { xpath, prefixMappings, storeItemId };
+    return this;
+  }
+
+  /**
+   * Get whether the SDT is currently showing placeholder content
+   */
+  isShowingPlaceholder(): boolean {
+    return this.properties.showingPlcHdr === true;
+  }
+
+  /**
+   * Set whether the SDT is showing placeholder content
+   * @param val - Whether placeholder is showing
+   */
+  setShowingPlaceholder(val: boolean): this {
+    this.properties.showingPlcHdr = val;
+    return this;
+  }
+
+  /**
+   * Create a citation content control
+   * @param content - Initial content
+   * @param properties - Additional SDT properties
+   */
+  static createCitation(
+    content: SDTContent[] = [],
+    properties: Partial<SDTProperties> = {}
+  ): StructuredDocumentTag {
+    return new StructuredDocumentTag(
+      {
+        id: Date.now() % 1000000000,
+        controlType: "citation",
+        ...properties,
+      },
+      content
+    );
+  }
+
+  /**
+   * Create a bibliography content control
+   * @param content - Initial content
+   * @param properties - Additional SDT properties
+   */
+  static createBibliography(
+    content: SDTContent[] = [],
+    properties: Partial<SDTProperties> = {}
+  ): StructuredDocumentTag {
+    return new StructuredDocumentTag(
+      {
+        id: Date.now() % 1000000000,
+        controlType: "bibliography",
+        ...properties,
+      },
+      content
+    );
+  }
+
+  /**
+   * Create a document part list content control
+   * Uses w:docPartList instead of w:docPartObj
+   * @param gallery - Building block gallery name
+   * @param category - Building block category
+   * @param content - Initial content
+   * @param properties - Additional SDT properties
+   */
+  static createDocPartList(
+    gallery: string,
+    category: string,
+    content: SDTContent[] = [],
+    properties: Partial<SDTProperties> = {}
+  ): StructuredDocumentTag {
+    return new StructuredDocumentTag(
+      {
+        id: Date.now() % 1000000000,
+        controlType: "docPartList",
+        buildingBlock: { gallery, category, isList: true },
+        ...properties,
+      },
+      content
+    );
+  }
+
+  /**
+   * Create an equation content control
+   * @param content - Initial content
+   * @param properties - Additional SDT properties
+   */
+  static createEquation(
+    content: SDTContent[] = [],
+    properties: Partial<SDTProperties> = {}
+  ): StructuredDocumentTag {
+    return new StructuredDocumentTag(
+      {
+        id: Date.now() % 1000000000,
+        controlType: "equation",
+        ...properties,
+      },
+      content
+    );
+  }
 }

package/src/elements/TableCell.ts

@@ -46,6 +46,10 @@ export interface CellBorders {
   bottom?: CellBorder;
   left?: CellBorder;
   right?: CellBorder;
+  /** Diagonal border from top-left to bottom-right per ECMA-376 Part 1 §17.4.84 */
+  tl2br?: CellBorder;
+  /** Diagonal border from top-right to bottom-left per ECMA-376 Part 1 §17.4.85 */
+  tr2bl?: CellBorder;
 }
 
 /**
@@ -102,6 +106,8 @@ export interface CellFormatting {
   cnfStyle?: string; // Conditional formatting style (14-char binary string)
   vMerge?: VerticalMerge; // Vertical cell merge
   hMerge?: 'restart' | 'continue'; // Legacy horizontal merge (w:hMerge) per ECMA-376 Part 1 §17.4.22
+  /** Cell headers attribute for accessibility per ECMA-376 Part 1 §17.4.26 */
+  headers?: string;
 }
 
 /**
@@ -947,6 +953,25 @@ export class TableCell {
     return this.formatting.hMerge;
   }
 
+  /**
+   * Sets the cell headers attribute for accessibility
+   * Links data cells to header cells per ECMA-376 Part 1 §17.4.26
+   * @param headers - Space-separated list of header cell IDs
+   * @returns This cell for chaining
+   */
+  setHeaders(headers: string): this {
+    this.formatting.headers = headers;
+    return this;
+  }
+
+  /**
+   * Gets the cell headers attribute
+   * @returns Headers string or undefined
+   */
+  getHeaders(): string | undefined {
+    return this.formatting.headers;
+  }
+
   /**
    * Gets the cell margins
    * @returns Margins object with top, right, bottom, left or undefined
@@ -1306,7 +1331,7 @@ export class TableCell {
       const borderElements: XMLElement[] = [];
       const borders = this.formatting.borders;
 
-      // Ordered per ECMA-376 CT_TcBorders: top, left, bottom, right
+      // Ordered per ECMA-376 CT_TcBorders: top, left, bottom, right, insideH, insideV, tl2br, tr2bl
       if (borders.top) {
         borderElements.push(XMLBuilder.createBorder("top", borders.top));
       }
@@ -1319,6 +1344,12 @@ export class TableCell {
       if (borders.right) {
         borderElements.push(XMLBuilder.createBorder("right", borders.right));
       }
+      if (borders.tl2br) {
+        borderElements.push(XMLBuilder.createBorder("tl2br", borders.tl2br));
+      }
+      if (borders.tr2bl) {
+        borderElements.push(XMLBuilder.createBorder("tr2bl", borders.tr2bl));
+      }
 
       if (borderElements.length > 0) {
         tcPrChildren.push(XMLBuilder.w("tcBorders", undefined, borderElements));
@@ -1409,6 +1440,10 @@ export class TableCell {
       tcPrChildren.push(XMLBuilder.wSelf("hideMark"));
     }
 
+    // Note: w:headers (cell headers for accessibility) is defined in ECMA-376 Part 1 §17.4.26
+    // but is NOT included in the Transitional schema and fails OOXML validation.
+    // The property is preserved in memory for reading but not generated in XML.
+
     // Add cell revision markers (w:cellIns, w:cellDel, w:cellMerge) per ECMA-376 Part 1 §17.13.5.4-5.6
     if (this.cellRevision) {
       const revType = this.cellRevision.getType();

package/src/elements/TableRow.ts

@@ -74,6 +74,7 @@ export interface RowFormatting {
   cellSpacing?: number; // Row-level cell spacing override in twips
   cellSpacingType?: string; // Cell spacing type (dxa, pct)
   cnfStyle?: string; // Conditional formatting bitmask (per ECMA-376 §17.3.1.8)
+  divId?: number; // HTML div association (per ECMA-376 §17.4.9)
 }
 
 /**
@@ -544,6 +545,25 @@ export class TableRow {
     return this;
   }
 
+  /**
+   * Sets the HTML div ID for web round-trip
+   * Per ECMA-376 Part 1 §17.4.9
+   * @param id - Div ID number
+   * @returns This row for chaining
+   */
+  setDivId(id: number): this {
+    this.formatting.divId = id;
+    return this;
+  }
+
+  /**
+   * Gets the HTML div ID
+   * @returns Div ID or undefined
+   */
+  getDivId(): number | undefined {
+    return this.formatting.divId;
+  }
+
   /**
    * Gets table property exceptions
    * @returns Table property exceptions or undefined
@@ -735,7 +755,10 @@ export class TableRow {
       trPrChildren.push(XMLBuilder.wSelf('cnfStyle', { 'w:val': this.formatting.cnfStyle }));
     }
 
-    // 2. (divId not supported)
+    // 2. divId
+    if (this.formatting.divId !== undefined) {
+      trPrChildren.push(XMLBuilder.wSelf('divId', { 'w:val': this.formatting.divId }));
+    }
 
     // 3. gridBefore
     if (this.formatting.gridBefore !== undefined) {