docxmlater 11.0.9 → 12.0.1

package/src/processors/SelectiveRevisionAcceptor.ts

@@ -15,10 +15,11 @@
 import type { Document } from '../core/Document.js';
 import type { Paragraph, ParagraphContent } from '../elements/Paragraph.js';
 import { Revision, RevisionType } from '../elements/Revision.js';
-import type { Run } from '../elements/Run.js';
+import type { Run, RunFormatting } from '../elements/Run.js';
 import { isRunContent, isHyperlinkContent } from '../elements/RevisionContent.js';
 import { ChangeCategory } from './ChangelogGenerator.js';
 import { SelectionCriteria } from './RevisionAwareProcessor.js';
+import { mergeParagraphsWithDeletedMarks } from './InMemoryRevisionAcceptor.js';
 
 /**
  * Result of selective revision acceptance.
@@ -62,9 +63,23 @@ export class SelectiveRevisionAcceptor {
     const hasFullApi = typeof (doc as any).getAllParagraphs === 'function';
 
     if (hasFullApi) {
+      const acceptedMarkDeletions: Paragraph[] = [];
       this.walkAllParagraphs(doc, (paragraph) => {
-        this.processSelectiveParagraph(paragraph, criteria, 'accept', accepted, remaining);
+        this.processSelectiveParagraph(
+          paragraph,
+          criteria,
+          'accept',
+          accepted,
+          remaining,
+          acceptedMarkDeletions
+        );
       });
+      // Accepted paragraph-mark deletions combine the paragraph with its
+      // following sibling (ECMA-376 §17.13.5.15) — same merge the all-or-
+      // nothing acceptor performs.
+      if (acceptedMarkDeletions.length > 0) {
+        mergeParagraphsWithDeletedMarks(doc, new Set(acceptedMarkDeletions));
+      }
     } else {
       // Fallback: Filter revisions from RevisionManager only (for backward compatibility)
       const revisionManager = doc.getRevisionManager();
@@ -257,7 +272,8 @@ export class SelectiveRevisionAcceptor {
     criteria: SelectionCriteria,
     action: 'accept' | 'reject',
     processedIds: string[],
-    remainingIds: string[]
+    remainingIds: string[],
+    acceptedMarkDeletions?: Paragraph[]
   ): void {
     const content = paragraph.getContent();
     const newContent: ParagraphContent[] = [];
@@ -267,15 +283,18 @@ export class SelectiveRevisionAcceptor {
         const revisionId = item.getId().toString();
 
         if (this.matchesCriteria(item, criteria)) {
-          // This revision matches the criteria - process it
-          processedIds.push(revisionId);
-
           if (action === 'accept') {
             // Accept: Transform based on revision type
+            processedIds.push(revisionId);
             this.acceptRevisionItem(item, newContent);
-          } else {
+          } else if (this.rejectRevisionItem(item, newContent, paragraph)) {
             // Reject: Transform opposite of accept
-            this.rejectRevisionItem(item, newContent);
+            processedIds.push(revisionId);
+          } else {
+            // The revision was kept in place (its previous-property
+            // snapshot could not be restored), so report it as remaining
+            // rather than rejected — it must stay in the RevisionManager.
+            remainingIds.push(revisionId);
           }
         } else {
           // This revision doesn't match - keep it
@@ -291,13 +310,18 @@ export class SelectiveRevisionAcceptor {
     // Replace paragraph content with the transformed content
     paragraph.setContent(newContent);
 
-    // Handle paragraph mark revision markers (w:del/w:ins in w:pPr/w:rPr)
-    // Both accept and reject clear the marker — these are metadata-only markers (no content),
-    // so there is no content to add or remove, only the marker itself to clear.
+    // Handle paragraph mark revision markers (w:del/w:ins in w:pPr/w:rPr).
+    // Rejecting a mark deletion just restores the mark (clear the marker);
+    // ACCEPTING one means the paragraph's contents combine with the following
+    // paragraph (ECMA-376 §17.13.5.15), so the paragraph is recorded for the
+    // post-walk merge pass in addition to clearing the marker.
     const formatting = paragraph.getFormatting();
     if (formatting.paragraphMarkDeletion) {
       const del = formatting.paragraphMarkDeletion;
       if (this.matchesMarkerCriteria(del, criteria)) {
+        if (action === 'accept') {
+          acceptedMarkDeletions?.push(paragraph);
+        }
         paragraph.clearParagraphMarkDeletion();
         processedIds.push(del.id.toString());
       } else {
@@ -415,8 +439,17 @@ export class SelectiveRevisionAcceptor {
    * Reject a single revision item (opposite of accept).
    * - Rejecting an insertion removes the content
    * - Rejecting a deletion keeps the content (unwraps it)
+   * - Rejecting a run/paragraph property change restores the previous
+   *   properties snapshot (ECMA-376 §17.13.5.30/§17.13.5.31)
+   *
+   * @returns true if the revision was rejected, false if it was kept in
+   *   place because its previous-property snapshot could not be restored
    */
-  private static rejectRevisionItem(revision: Revision, newContent: ParagraphContent[]): void {
+  private static rejectRevisionItem(
+    revision: Revision,
+    newContent: ParagraphContent[],
+    paragraph: Paragraph
+  ): boolean {
     const revisionType = revision.getType();
     const childContent = revision.getContent();
 
@@ -424,7 +457,7 @@ export class SelectiveRevisionAcceptor {
       case 'insert':
       case 'moveTo':
         // Reject insertion: Remove the inserted content entirely
-        break;
+        return true;
 
       case 'delete':
       case 'moveFrom':
@@ -436,19 +469,46 @@ export class SelectiveRevisionAcceptor {
             newContent.push(child);
           }
         }
-        break;
+        return true;
+
+      case 'runPropertiesChange': {
+        const previous = revision.getPreviousProperties();
+        if (!previous) {
+          // No snapshot to restore from — keep the tracked change so the
+          // prior formatting is not silently lost.
+          newContent.push(revision);
+          return false;
+        }
+        for (const child of childContent) {
+          if (isRunContent(child)) {
+            const run = child as Run;
+            // w:rPrChange carries the complete pre-change run properties,
+            // so rejecting replaces (not merges) the run's formatting.
+            // Run.formatting is private; written directly the same way
+            // DocumentParser populates parsed properties.
+            (run as unknown as { formatting: RunFormatting }).formatting = {
+              ...(previous as RunFormatting),
+            };
+            newContent.push(run);
+          } else if (isHyperlinkContent(child)) {
+            newContent.push(child);
+          }
+        }
+        return true;
+      }
 
-      case 'runPropertiesChange':
-      case 'paragraphPropertiesChange':
-      case 'tablePropertiesChange':
-      case 'tableExceptionPropertiesChange':
-      case 'tableRowPropertiesChange':
-      case 'tableCellPropertiesChange':
-      case 'sectionPropertiesChange':
-      case 'numberingChange':
-        // Rejecting property changes: Would need to restore old properties
-        // For now, just keep content without the change metadata
-        // (Full implementation would restore previousProperties)
+      case 'paragraphPropertiesChange': {
+        const previous = revision.getPreviousProperties();
+        if (!previous) {
+          newContent.push(revision);
+          return false;
+        }
+        // The snapshot uses the same key names as ParagraphFormatting
+        // (see Revision.PROPERTY_KEY_TO_ELEMENT), so the recorded values
+        // are written back onto the containing paragraph. Only recorded
+        // keys are touched: internal bookkeeping fields (revision markers,
+        // paraId) are not part of a w:pPrChange snapshot.
+        Object.assign(paragraph.formatting, previous);
         for (const child of childContent) {
           if (isRunContent(child)) {
             newContent.push(child as Run);
@@ -456,11 +516,26 @@ export class SelectiveRevisionAcceptor {
             newContent.push(child);
           }
         }
-        break;
+        return true;
+      }
+
+      case 'tablePropertiesChange':
+      case 'tableExceptionPropertiesChange':
+      case 'tableRowPropertiesChange':
+      case 'tableCellPropertiesChange':
+      case 'sectionPropertiesChange':
+      case 'numberingChange':
+        // The element these snapshots belong to (table/row/cell/section/
+        // numbering definition) is not reachable from paragraph content,
+        // so the previous properties cannot be restored here. Keep the
+        // revision in place rather than discarding the snapshot.
+        newContent.push(revision);
+        return false;
 
       default:
         // Unknown type - keep the revision as-is for safety
         newContent.push(revision);
+        return true;
     }
   }
 
@@ -477,8 +552,69 @@ export class SelectiveRevisionAcceptor {
     criteria: SelectionCriteria,
     action: 'accept' | 'reject'
   ): SelectiveAcceptResult {
-    // Preview is the same as the actual operation but without side effects
-    return action === 'accept' ? this.accept(doc, criteria) : this.reject(doc, criteria);
+    const processed: string[] = [];
+    const remaining: string[] = [];
+
+    // Delegating to accept()/reject() would mutate paragraph content and
+    // splice revisions out of the RevisionManager, so preview classifies
+    // with the same traversal and criteria but never transforms anything.
+    const hasFullApi = typeof (doc as any).getAllParagraphs === 'function';
+
+    if (hasFullApi) {
+      this.walkAllParagraphs(doc, (paragraph) => {
+        for (const item of paragraph.getContent()) {
+          if (item instanceof Revision) {
+            if (this.matchesCriteria(item, criteria)) {
+              processed.push(item.getId().toString());
+            } else {
+              remaining.push(item.getId().toString());
+            }
+          }
+        }
+
+        const formatting = paragraph.getFormatting();
+        if (formatting.paragraphMarkDeletion) {
+          const del = formatting.paragraphMarkDeletion;
+          if (this.matchesMarkerCriteria(del, criteria)) {
+            processed.push(del.id.toString());
+          } else {
+            remaining.push(del.id.toString());
+          }
+        }
+        if (formatting.paragraphMarkInsertion) {
+          const ins = formatting.paragraphMarkInsertion;
+          if (this.matchesMarkerCriteria(ins, criteria)) {
+            processed.push(ins.id.toString());
+          } else {
+            remaining.push(ins.id.toString());
+          }
+        }
+      });
+    } else {
+      // Fallback: Filter revisions from RevisionManager only (for backward compatibility)
+      const revisionManager = doc.getRevisionManager();
+      if (revisionManager) {
+        for (const rev of revisionManager.getAllRevisions()) {
+          if (this.matchesCriteria(rev, criteria)) {
+            processed.push(rev.getId().toString());
+          } else {
+            remaining.push(rev.getId().toString());
+          }
+        }
+      }
+    }
+
+    return {
+      accepted: action === 'accept' ? processed : [],
+      rejected: action === 'reject' ? processed : [],
+      remaining,
+      summary: {
+        totalProcessed: processed.length + remaining.length,
+        acceptedCount: action === 'accept' ? processed.length : 0,
+        rejectedCount: action === 'reject' ? processed.length : 0,
+        remainingCount: remaining.length,
+      },
+    };
   }
 
   /**

package/src/processors/cnfStyleDecoder.ts

@@ -78,25 +78,31 @@ const BIT_POSITIONS: Record<keyof CnfStyleFlags, number> = {
 
 /**
  * Priority order for conditional formatting resolution
- * More specific conditions (corners) override less specific (edges, banding)
- * Per ECMA-376, this is the order in which conditionals should be applied
+ *
+ * ECMA-376 §17.7.6.6 applies conditional formats in sequence (banding, then
+ * first/last row, first/last column, then corners top-left through
+ * bottom-right) with subsequent formats overriding earlier ones. First-match
+ * consumers need the opposite: the last-applied (winning) member of each
+ * group listed first, so when two conditionals in the same group co-apply
+ * (e.g. firstRow + lastRow in a single-row table) resolution picks the one
+ * Word actually renders.
  */
 export const CONDITIONAL_PRIORITY_ORDER: (keyof CnfStyleFlags)[] = [
-  // Corner cells (most specific)
-  'nwCell',
-  'neCell',
-  'swCell',
+  // Corner cells (most specific; spec applies nw, ne, sw, se — se wins)
   'seCell',
-  // Edge rows/columns
-  'firstRow',
+  'swCell',
+  'neCell',
+  'nwCell',
+  // Edge rows/columns (within each pair, last is applied after first)
   'lastRow',
-  'firstCol',
+  'firstRow',
   'lastCol',
-  // Banding (least specific)
-  'band1Horz',
+  'firstCol',
+  // Banding (least specific; even banding is applied after odd)
   'band2Horz',
-  'band1Vert',
+  'band1Horz',
   'band2Vert',
+  'band1Vert',
 ];
 
 /**

package/src/processors/stripTrackedChanges.ts

@@ -67,19 +67,30 @@ class TrackedChangesStripper {
     // STEP 2: Process insertions - keep content, remove wrapper
     content = this.processInsertions(content);
 
-    // STEP 3: Process deletions - remove entirely
+    // STEP 3: Remove rows whose w:trPr carries a row-deletion marker
+    // (self-closing <w:del/> per ECMA-376 §17.13.5.14 marks the ENTIRE
+    // row as deleted). Must run before the marker itself is stripped in
+    // STEP 4, otherwise the row would silently survive as un-deleted.
+    content = this.removeDeletedRows(content);
+
+    // STEP 4: Remove self-closing revision markers (paragraph-mark
+    // deletions in w:pPr/w:rPr per ECMA-376 §17.13.5.15, etc.). Must run
+    // BEFORE the block-removal steps: their [^>]* also matches the
+    // trailing '/' of `<w:del .../>`, which would turn the marker into an
+    // opening tag and swallow everything up to the next closing tag,
+    // corrupting the part.
+    content = this.removeSelfClosingRevisionTags(content);
+
+    // STEP 5: Process deletions - remove entirely
     content = this.processDeletions(content);
 
-    // STEP 4: Process move operations
+    // STEP 6: Process move operations
     content = this.processMoveFrom(content);
     content = this.processMoveTo(content);
 
-    // STEP 5: Remove all property change tracking elements
+    // STEP 7: Remove all property change tracking elements
     content = this.removePropertyChanges(content);
 
-    // STEP 6: Remove any remaining self-closing revision tags
-    content = this.removeSelfClosingRevisionTags(content);
-
     // Update the file in the zip
     this.zipHandler.updateFile(partPath, content);
   }
@@ -160,6 +171,30 @@ class TrackedChangesStripper {
     return result;
   }
 
+  /**
+   * Remove entire <w:tr> rows marked as tracked deletions.
+   *
+   * Per ECMA-376 Part 1 §17.13.5.14, a self-closing `<w:del/>` inside
+   * `<w:trPr>` marks the whole row as deleted — stripping just the marker
+   * would resurrect the row instead of removing it. Mirrors the row-level
+   * pass in acceptRevisions.ts: the negative lookaheads keep the match
+   * anchored to a single row (it cannot slip past a cell boundary or a
+   * nested-table row and latch onto a later row's trPr-with-del).
+   */
+  private removeDeletedRows(xml: string): string {
+    const rowDelPattern =
+      /<w:tr\b[^>]*>(?:(?!<w:tc\b|<w:tr\b|<\/w:tr>)[\s\S])*?<w:trPr\b(?:\s[^>]*)?>(?:(?!<\/w:trPr>)[\s\S])*?<w:del\b[^>]*\/>(?:(?!<\/w:trPr>)[\s\S])*?<\/w:trPr>(?:(?!<w:tr\b|<\/w:tr>)[\s\S])*?<\/w:tr>/g;
+
+    let result = xml;
+    let previousLength = 0;
+    while (result.length !== previousLength) {
+      previousLength = result.length;
+      result = result.replace(rowDelPattern, '');
+    }
+
+    return result;
+  }
+
   /**
    * Process <w:del> elements - remove entire element
    * Uses iterative replacement to handle nested deletions
@@ -241,13 +276,15 @@ class TrackedChangesStripper {
 
   /**
    * Remove self-closing revision tags
+   * `\b` (not `\s+`) so attribute-less markers like `<w:del/>` are also
+   * caught while `<w:delText>` is not.
    */
   private removeSelfClosingRevisionTags(xml: string): string {
     const patterns = [
-      /<w:ins\s+[^>]*\/>/g,
-      /<w:del\s+[^>]*\/>/g,
-      /<w:moveFrom\s+[^>]*\/>/g,
-      /<w:moveTo\s+[^>]*\/>/g,
+      /<w:ins\b[^>]*\/>/g,
+      /<w:del\b[^>]*\/>/g,
+      /<w:moveFrom\b[^>]*\/>/g,
+      /<w:moveTo\b[^>]*\/>/g,
     ];
 
     let result = xml;

package/src/utils/deepClone.ts

@@ -10,6 +10,12 @@
  * For simple objects (like formatting options), this is more efficient
  * than JSON.parse(JSON.stringify()) and doesn't lose non-serializable values.
  *
+ * Cyclic and shared references are handled via an internal seen-cache: an
+ * object encountered more than once during a single clone is cloned exactly
+ * once, so circular graphs cannot overflow the stack and shared sub-objects
+ * (including shared Date and RegExp instances) retain a single shared identity
+ * in the result.
+ *
  * @param obj - Object to clone
  * @returns Deep cloned copy of the object
  *
@@ -23,21 +29,50 @@
  * ```
  */
 export function deepClone<T>(obj: T): T {
+  // Map of already-cloned source objects to their clones, scoped to this call.
+  // Guards against infinite recursion on cyclic input and preserves the
+  // identity of references shared by multiple parents within the same graph.
+  return cloneInternal(obj, new WeakMap<object, unknown>());
+}
+
+function cloneInternal<T>(obj: T, seen: WeakMap<object, unknown>): T {
   // Handle primitive types and null
   if (obj === null || typeof obj !== 'object') {
     return obj;
   }
 
-  // Handle Date
+  // Return the existing clone for any object already seen in this call. Placed
+  // before the Date/RegExp branches so a single Date/RegExp instance shared by
+  // multiple nodes resolves to one shared clone (the JSDoc shared-identity
+  // guarantee), not a fresh copy per reference.
+  const existing = seen.get(obj as object);
+  if (existing !== undefined) {
+    return existing as T;
+  }
+
+  // Handle Date (immutable value copy; cannot form a cycle). Registered in
+  // `seen` so repeat references to the same instance share this clone.
   if (obj instanceof Date) {
-    return new Date(obj.getTime()) as T;
+    const dateCopy = new Date(obj.getTime());
+    seen.set(obj as object, dateCopy);
+    return dateCopy as T;
+  }
+
+  // Handle RegExp (immutable value copy; cannot form a cycle). Registered in
+  // `seen` so repeat references to the same instance share this clone.
+  if (obj instanceof RegExp) {
+    const regexpCopy = new RegExp(obj.source, obj.flags);
+    seen.set(obj as object, regexpCopy);
+    return regexpCopy as T;
   }
 
   // Handle Array
   if (Array.isArray(obj)) {
     const arrCopy: unknown[] = [];
+    // Register before recursing so self/back references resolve to this clone.
+    seen.set(obj as object, arrCopy);
     for (let i = 0; i < obj.length; i++) {
-      arrCopy[i] = deepClone(obj[i]);
+      arrCopy[i] = cloneInternal(obj[i], seen);
     }
     return arrCopy as T;
   }
@@ -45,8 +80,9 @@ export function deepClone<T>(obj: T): T {
   // Handle Map
   if (obj instanceof Map) {
     const mapCopy = new Map();
+    seen.set(obj, mapCopy);
     obj.forEach((value, key) => {
-      mapCopy.set(deepClone(key), deepClone(value));
+      mapCopy.set(cloneInternal(key, seen), cloneInternal(value, seen));
     });
     return mapCopy as T;
   }
@@ -54,23 +90,21 @@ export function deepClone<T>(obj: T): T {
   // Handle Set
   if (obj instanceof Set) {
     const setCopy = new Set();
+    seen.set(obj, setCopy);
     obj.forEach((value) => {
-      setCopy.add(deepClone(value));
+      setCopy.add(cloneInternal(value, seen));
     });
     return setCopy as T;
   }
 
-  // Handle RegExp
-  if (obj instanceof RegExp) {
-    return new RegExp(obj.source, obj.flags) as T;
-  }
-
   // Handle plain objects
   const objCopy = Object.create(Object.getPrototypeOf(obj)) as Record<string, unknown>;
-  for (const key in obj) {
-    if (obj.hasOwnProperty(key)) {
-      objCopy[key] = deepClone((obj as Record<string, unknown>)[key]);
-    }
+  seen.set(obj as object, objCopy);
+  // Object.keys avoids the prototype-builtins shadowing risk of
+  // obj.hasOwnProperty(key) (matches sibling deepEqual.ts) and yields the same
+  // own-enumerable string keys the previous for..in + hasOwnProperty loop did.
+  for (const key of Object.keys(obj as object)) {
+    objCopy[key] = cloneInternal((obj as Record<string, unknown>)[key], seen);
   }
 
   return objCopy as T;

package/src/utils/units.ts

@@ -145,7 +145,9 @@ export function emusToPixels(emus: number, dpi: number = STANDARD_DPI): number {
  * @returns Value in twips
  */
 export function pointsToTwips(points: number): number {
-  return points * UNITS.TWIPS_PER_POINT;
+  // Round to nearest integer — twips attributes (w:spacing, w:ind) require
+  // ST_DecimalNumber-based integer values
+  return Math.round(points * UNITS.TWIPS_PER_POINT);
 }
 
 /**

package/src/utils/validation.ts

@@ -23,29 +23,28 @@ export function validateDocxStructure(filePaths: string[]): void {
 
 /**
  * Checks if a file path represents a binary file based on extension
+ *
+ * Uses a text-extension whitelist rather than a binary-extension whitelist:
+ * misclassifying text as binary only changes its in-memory representation
+ * (Buffer instead of string), but misclassifying binary as text corrupts the
+ * bytes through a lossy UTF-8 decode. OOXML packages can embed arbitrary
+ * binary parts (.xlsx/.pdf OLE packages, .odttf obfuscated fonts, .emz/.wmz
+ * compressed metafiles, extensionless parts), so anything not known to be
+ * text must be preserved byte-for-byte.
+ *
  * @param filePath - The file path to check
  * @returns True if the file is likely binary
  */
 export function isBinaryFile(filePath: string): boolean {
-  const binaryExtensions = [
-    '.png',
-    '.jpg',
-    '.jpeg',
-    '.gif',
-    '.bmp',
-    '.tiff',
-    '.ico',
-    '.emf',
-    '.wmf',
-    '.bin',
-    '.dat',
-    '.ttf',
-    '.otf',
-    '.woff',
-  ];
+  const textExtensions = ['.xml', '.rels', '.svg', '.txt', '.html', '.css', '.js'];
 
-  const extension = filePath.substring(filePath.lastIndexOf('.')).toLowerCase();
-  return binaryExtensions.includes(extension);
+  const dotIndex = filePath.lastIndexOf('.');
+  if (dotIndex === -1) {
+    return true;
+  }
+
+  const extension = filePath.substring(dotIndex).toLowerCase();
+  return !textExtensions.includes(extension);
 }
 
 /**
@@ -55,12 +54,15 @@ export function isBinaryFile(filePath: string): boolean {
  *
  * **Security:** This function validates paths to prevent:
  * - Path traversal attacks (../, ..\, URL-encoded variants)
- * - Absolute paths (C:\, /etc/, etc.)
+ * - Absolute Windows paths (C:\, D:, etc.) — rejected
  * - Malicious DOCX files attempting directory escape
  *
+ * Unix absolute paths (/etc/...) are sanitized to archive-relative paths
+ * by stripping leading slashes, not rejected.
+ *
  * @param path - The path to normalize
  * @returns Normalized path
- * @throws {Error} If path contains path traversal sequences, absolute paths, or URL-encoded attacks
+ * @throws {Error} If path contains path traversal sequences, absolute Windows paths, or URL-encoded attacks
  */
 export function normalizePath(path: string): string {
   // First convert all backslashes to forward slashes for consistent checking
@@ -97,15 +99,6 @@ export function normalizePath(path: string): string {
     );
   }
 
-  // Security: Prevent Unix absolute paths
-  // After removing leading slashes, if it starts with / it's suspicious
-  if (path.startsWith('/') && normalized.startsWith('/')) {
-    throw new Error(
-      `Invalid file path: "${path}" appears to be an absolute Unix path. ` +
-        `Only relative paths are allowed in DOCX archives.`
-    );
-  }
-
   return normalized;
 }
 
@@ -161,6 +154,11 @@ export function validateTwips(value: number, fieldName = 'value'): void {
     throw new Error(`${fieldName} must be a finite number, got ${value}`);
   }
 
+  // ST_TwipsMeasure/ST_SignedTwipsMeasure are ST_DecimalNumber-based — integers only
+  if (!Number.isInteger(value)) {
+    throw new Error(`${fieldName} must be an integer (in twips), got ${value}`);
+  }
+
   // Reasonable range: ±22 inches (31680 twips)
   const MIN_TWIPS = -31680;
   const MAX_TWIPS = 31680;
@@ -304,7 +302,7 @@ export function validateAlignment(
 
 /**
  * Validates a font size (in half-points for Word)
- * Reasonable range: 2-1638 (1-819 points)
+ * Reasonable range: 2-3276 (1-1638 points)
  * @param size - The font size in half-points to validate
  * @param fieldName - Name of the field (for error messages)
  * @throws {Error} If the size is invalid
@@ -318,9 +316,9 @@ export function validateFontSize(size: number, fieldName = 'font size'): void {
     throw new Error(`${fieldName} must be an integer (in half-points), got ${size}`);
   }
 
-  // Reasonable range: 2-1638 half-points (1-819 points)
+  // Word's limit is 1-1638 points, i.e. 2-3276 half-points for w:sz (ST_HpsMeasure)
   const MIN_SIZE = 2;
-  const MAX_SIZE = 1638;
+  const MAX_SIZE = 3276;
 
   if (size < MIN_SIZE || size > MAX_SIZE) {
     throw new Error(