@json-to-office/core-docx 0.19.0 → 0.21.0

package/dist/index.js

@@ -1692,253 +1692,7 @@ var init_docxImagePositioning = __esm({
   }
 });
 
-// src/utils/numberingConfig.ts
-var numberingConfig_exports = {};
-__export(numberingConfig_exports, {
-  NumberingRegistry: () => NumberingRegistry,
-  createBulletListConfig: () => createBulletListConfig,
-  createNumberedListConfig: () => createNumberedListConfig,
-  createNumberingConfig: () => createNumberingConfig,
-  globalNumberingRegistry: () => globalNumberingRegistry
-});
-import { AlignmentType as AlignmentType3, convertInchesToTwip, LevelFormat } from "docx";
-function getLevelFormat(format2) {
-  if (!format2) return LevelFormat.BULLET;
-  return LEVEL_FORMAT_MAP[format2] || LevelFormat.BULLET;
-}
-function getAlignment2(alignment) {
-  if (!alignment) return AlignmentType3.LEFT;
-  return ALIGNMENT_MAP[alignment] || AlignmentType3.LEFT;
-}
-function createDefaultLevel(level, format2 = LevelFormat.BULLET, text) {
-  const baseIndent = 0.5 * (level + 1);
-  const hangingIndent = 0.25;
-  return {
-    level,
-    format: format2,
-    text: text || (format2 === LevelFormat.BULLET ? "\u2022" : "%1."),
-    alignment: AlignmentType3.LEFT,
-    style: {
-      paragraph: {
-        indent: {
-          left: convertInchesToTwip(baseIndent),
-          hanging: convertInchesToTwip(hangingIndent)
-        }
-      }
-    }
-  };
-}
-function createNumberingConfig(config) {
-  const levels = [];
-  for (const levelConfig of config.levels) {
-    const format2 = getLevelFormat(levelConfig.format);
-    const alignment = getAlignment2(levelConfig.alignment);
-    const text = levelConfig.text || (format2 === LevelFormat.BULLET ? "\u2022" : `%${levelConfig.level + 1}.`);
-    const baseIndent = levelConfig.indent?.left !== void 0 ? levelConfig.indent.left / 72 : 0.5 * (levelConfig.level + 1);
-    const hangingIndent = levelConfig.indent?.hanging !== void 0 ? levelConfig.indent.hanging / 72 : 0.25;
-    const level = {
-      level: levelConfig.level,
-      format: format2,
-      text,
-      alignment,
-      style: {
-        paragraph: {
-          indent: {
-            left: convertInchesToTwip(baseIndent),
-            hanging: convertInchesToTwip(hangingIndent)
-          }
-        }
-      },
-      // Add start number if specified
-      ...levelConfig.start !== void 0 && { start: levelConfig.start }
-    };
-    levels.push(level);
-  }
-  return {
-    reference: config.reference,
-    levels
-  };
-}
-function createBulletListConfig(reference, bullet = "\u2022") {
-  return {
-    reference,
-    levels: [
-      createDefaultLevel(0, LevelFormat.BULLET, bullet),
-      createDefaultLevel(1, LevelFormat.BULLET, "\u25E6"),
-      createDefaultLevel(2, LevelFormat.BULLET, "\u25AA")
-    ]
-  };
-}
-function createNumberedListConfig(reference, start = 1) {
-  return {
-    reference,
-    levels: [
-      { ...createDefaultLevel(0, LevelFormat.DECIMAL, "%1."), start },
-      createDefaultLevel(1, LevelFormat.LOWER_LETTER, "%2."),
-      createDefaultLevel(2, LevelFormat.LOWER_ROMAN, "%3.")
-    ]
-  };
-}
-var LEVEL_FORMAT_MAP, ALIGNMENT_MAP, NumberingRegistry, globalNumberingRegistry;
-var init_numberingConfig = __esm({
-  "src/utils/numberingConfig.ts"() {
-    "use strict";
-    LEVEL_FORMAT_MAP = {
-      decimal: LevelFormat.DECIMAL,
-      upperRoman: LevelFormat.UPPER_ROMAN,
-      lowerRoman: LevelFormat.LOWER_ROMAN,
-      upperLetter: LevelFormat.UPPER_LETTER,
-      lowerLetter: LevelFormat.LOWER_LETTER,
-      bullet: LevelFormat.BULLET,
-      ordinal: LevelFormat.ORDINAL,
-      cardinalText: LevelFormat.CARDINAL_TEXT,
-      ordinalText: LevelFormat.ORDINAL_TEXT,
-      hex: LevelFormat.HEX,
-      chicago: LevelFormat.CHICAGO,
-      ideographDigital: LevelFormat.IDEOGRAPH__DIGITAL,
-      japaneseCounting: LevelFormat.JAPANESE_COUNTING,
-      aiueo: LevelFormat.AIUEO,
-      iroha: LevelFormat.IROHA,
-      decimalFullWidth: LevelFormat.DECIMAL_FULL_WIDTH,
-      decimalHalfWidth: LevelFormat.DECIMAL_HALF_WIDTH,
-      japaneseLegal: LevelFormat.JAPANESE_LEGAL,
-      japaneseDigitalTenThousand: LevelFormat.JAPANESE_DIGITAL_TEN_THOUSAND,
-      decimalEnclosedCircle: LevelFormat.DECIMAL_ENCLOSED_CIRCLE,
-      decimalFullWidth2: LevelFormat.DECIMAL_FULL_WIDTH2,
-      aiueoFullWidth: LevelFormat.AIUEO_FULL_WIDTH,
-      irohaFullWidth: LevelFormat.IROHA_FULL_WIDTH,
-      decimalZero: LevelFormat.DECIMAL_ZERO,
-      ganada: LevelFormat.GANADA,
-      chosung: LevelFormat.CHOSUNG,
-      decimalEnclosedFullstop: LevelFormat.DECIMAL_ENCLOSED_FULLSTOP,
-      decimalEnclosedParen: LevelFormat.DECIMAL_ENCLOSED_PARENTHESES,
-      decimalEnclosedCircleChinese: LevelFormat.DECIMAL_ENCLOSED_CIRCLE_CHINESE,
-      ideographEnclosedCircle: LevelFormat.IDEOGRAPH_ENCLOSED_CIRCLE,
-      ideographTraditional: LevelFormat.IDEOGRAPH_TRADITIONAL,
-      ideographZodiac: LevelFormat.IDEOGRAPH_ZODIAC,
-      ideographZodiacTraditional: LevelFormat.IDEOGRAPH_ZODIAC_TRADITIONAL,
-      taiwaneseCounting: LevelFormat.TAIWANESE_COUNTING,
-      ideographLegalTraditional: LevelFormat.IDEOGRAPH_LEGAL_TRADITIONAL,
-      taiwaneseCountingThousand: LevelFormat.TAIWANESE_COUNTING_THOUSAND,
-      taiwaneseDigital: LevelFormat.TAIWANESE_DIGITAL,
-      chineseCounting: LevelFormat.CHINESE_COUNTING,
-      chineseLegalSimplified: LevelFormat.CHINESE_LEGAL_SIMPLIFIED,
-      chineseCountingThousand: LevelFormat.CHINESE_COUNTING_THOUSAND,
-      koreanDigital: LevelFormat.KOREAN_DIGITAL,
-      koreanCounting: LevelFormat.KOREAN_COUNTING,
-      koreanLegal: LevelFormat.KOREAN_LEGAL,
-      koreanDigital2: LevelFormat.KOREAN_DIGITAL2,
-      vietnameseCounting: LevelFormat.VIETNAMESE_COUNTING,
-      russianLower: LevelFormat.RUSSIAN_LOWER,
-      russianUpper: LevelFormat.RUSSIAN_UPPER,
-      none: LevelFormat.NONE,
-      numberInDash: LevelFormat.NUMBER_IN_DASH,
-      hebrew1: LevelFormat.HEBREW1,
-      hebrew2: LevelFormat.HEBREW2,
-      arabicAlpha: LevelFormat.ARABIC_ALPHA,
-      arabicAbjad: LevelFormat.ARABIC_ABJAD,
-      hindiVowels: LevelFormat.HINDI_VOWELS,
-      hindiConsonants: LevelFormat.HINDI_CONSONANTS,
-      hindiNumbers: LevelFormat.HINDI_NUMBERS,
-      hindiCounting: LevelFormat.HINDI_COUNTING,
-      thaiLetters: LevelFormat.THAI_LETTERS,
-      thaiNumbers: LevelFormat.THAI_NUMBERS,
-      thaiCounting: LevelFormat.THAI_COUNTING
-    };
-    ALIGNMENT_MAP = {
-      start: AlignmentType3.START,
-      end: AlignmentType3.END,
-      left: AlignmentType3.LEFT,
-      right: AlignmentType3.RIGHT,
-      center: AlignmentType3.CENTER
-    };
-    NumberingRegistry = class {
-      configs = /* @__PURE__ */ new Map();
-      counter = 0;
-      /**
-       * Register a numbering configuration
-       */
-      register(config) {
-        const reference = config.reference;
-        this.configs.set(reference, config);
-        return reference;
-      }
-      /**
-       * Generate a unique reference ID
-       */
-      generateReference(prefix = "list") {
-        return `${prefix}-${++this.counter}`;
-      }
-      /**
-       * Get all registered configurations as an array suitable for INumberingOptions
-       */
-      getAll() {
-        return Array.from(this.configs.values());
-      }
-      /**
-       * Clear all configurations
-       */
-      clear() {
-        this.configs.clear();
-        this.counter = 0;
-      }
-      /**
-       * Check if a reference exists
-       */
-      has(reference) {
-        return this.configs.has(reference);
-      }
-      /**
-       * Get a configuration by reference
-       */
-      get(reference) {
-        return this.configs.get(reference);
-      }
-    };
-    globalNumberingRegistry = new NumberingRegistry();
-  }
-});
-
-// src/utils/fixFloatingImageIds.ts
-var fixFloatingImageIds_exports = {};
-__export(fixFloatingImageIds_exports, {
-  fixFloatingImageIds: () => fixFloatingImageIds
-});
-import AdmZip from "adm-zip";
-async function fixFloatingImageIds(docxPath) {
-  try {
-    const zip = new AdmZip(docxPath);
-    const documentEntry = zip.getEntry("word/document.xml");
-    if (!documentEntry) {
-      throw new Error("document.xml not found in DOCX");
-    }
-    let documentXml = documentEntry.getData().toString("utf8");
-    let idCounter = 1;
-    documentXml = documentXml.replace(
-      /<wp:docPr\s+id="(\d+)"/g,
-      (_match) => {
-        const newId = idCounter++;
-        return `<wp:docPr id="${newId}"`;
-      }
-    );
-    zip.updateFile("word/document.xml", Buffer.from(documentXml, "utf8"));
-    zip.writeZip(docxPath);
-    console.log(
-      `Fixed ${idCounter - 1} duplicate floating image docPr IDs in ${docxPath}`
-    );
-  } catch (error) {
-    console.error("Failed to fix floating image issues:", error);
-    throw error;
-  }
-}
-var init_fixFloatingImageIds = __esm({
-  "src/utils/fixFloatingImageIds.ts"() {
-    "use strict";
-  }
-});
-
 // src/core/generator.ts
-import { Packer } from "docx";
 import { writeFileSync } from "fs";
 
 // src/types/index.ts
@@ -2111,8 +1865,8 @@ function resolveComponentTree(components, theme) {
 }
 
 // src/core/structure.ts
-async function processDocument(document, theme, themeName) {
-  const metadata = createDocumentMetadata(document.props);
+async function processDocument(document, theme, themeName, generationDate) {
+  const metadata = createDocumentMetadata(document.props, generationDate);
   const docDefaults = document.props.componentDefaults;
   const mergedComponentDefaults = docDefaults ? mergeWithDefaults2(docDefaults, theme.componentDefaults || {}) : void 0;
   const docNoProofWords = document.props.noProofWords;
@@ -2150,13 +1904,13 @@ async function processDocument(document, theme, themeName) {
     language: document.props.language
   };
 }
-function createDocumentMetadata(props) {
+function createDocumentMetadata(props, generationDate = /* @__PURE__ */ new Date()) {
   return {
     title: props.metadata?.title,
     subtitle: props.metadata?.subtitle,
     author: props.metadata?.author,
     company: props.metadata?.company,
-    date: props.metadata?.date ? new Date(props.metadata.date) : /* @__PURE__ */ new Date()
+    date: props.metadata?.date ? new Date(props.metadata.date) : generationDate
   };
 }
 async function extractSections(components, context) {
@@ -3819,7 +3573,39 @@ function parseTextWithHyperlinks(text, baseStyle = {}, options = {}) {
   return runs;
 }
 
+// src/utils/generationContext.ts
+import { AsyncLocalStorage } from "async_hooks";
+var generationDateStorage = new AsyncLocalStorage();
+function runWithGenerationDate(date, callback) {
+  return generationDateStorage.run(date, callback);
+}
+function getGenerationDate() {
+  return generationDateStorage.getStore() ?? /* @__PURE__ */ new Date();
+}
+
 // src/utils/placeholderProcessor.ts
+function styledPlaceholderText(text, context) {
+  return new TextRun2({
+    text,
+    font: context?.style?.font,
+    size: context?.style?.size,
+    color: context?.style?.color,
+    bold: context?.style?.bold,
+    italics: context?.style?.italics,
+    underline: context?.style?.underline,
+    language: context?.style?.language,
+    noProof: context?.style?.noProof
+  });
+}
+function placeholderDate(context) {
+  return context?.date ?? getGenerationDate();
+}
+function isoDate(date) {
+  return date.toISOString().slice(0, 10);
+}
+function isoDateTime(date) {
+  return date.toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "Z");
+}
 var PlaceholderRegistry = class {
   static handlers = /* @__PURE__ */ new Map();
   /**
@@ -3875,8 +3661,6 @@ function processTextWithPlaceholders(text, baseStyle = {}, context = {}, noProof
         const placeholderResult = handler({ ...context, style: baseStyle });
         if (Array.isArray(placeholderResult)) {
           result.push(...placeholderResult);
-        } else if (placeholderResult instanceof TextRun2) {
-          result.push(placeholderResult);
         } else if (typeof placeholderResult === "string") {
           result.push(
             ...createTextRunsWithNewlines2(
@@ -3885,6 +3669,8 @@ function processTextWithPlaceholders(text, baseStyle = {}, context = {}, noProof
               noProofWords
             )
           );
+        } else {
+          result.push(placeholderResult);
         }
       } else {
         result.push(
@@ -3999,59 +3785,51 @@ function initializeBuiltinPlaceholders() {
       underline: context?.style?.underline
     });
   });
-  PlaceholderRegistry.register("DATE", (context) => {
-    const today = /* @__PURE__ */ new Date();
-    const dateString = today.toLocaleDateString();
-    return new TextRun2({
-      text: dateString,
-      font: context?.style?.font,
-      size: context?.style?.size,
-      color: context?.style?.color,
-      bold: context?.style?.bold,
-      italics: context?.style?.italics,
-      underline: context?.style?.underline
-    });
-  });
-  PlaceholderRegistry.register("DATETIME", (context) => {
-    const now = /* @__PURE__ */ new Date();
-    const dateTimeString = now.toLocaleString();
-    return new TextRun2({
-      text: dateTimeString,
-      font: context?.style?.font,
-      size: context?.style?.size,
-      color: context?.style?.color,
-      bold: context?.style?.bold,
-      italics: context?.style?.italics,
-      underline: context?.style?.underline
-    });
-  });
-  PlaceholderRegistry.register("YEAR", (context) => {
-    const year = (/* @__PURE__ */ new Date()).getFullYear().toString();
-    return new TextRun2({
-      text: year,
-      font: context?.style?.font,
-      size: context?.style?.size,
-      color: context?.style?.color,
-      bold: context?.style?.bold,
-      italics: context?.style?.italics,
-      underline: context?.style?.underline
-    });
-  });
+  PlaceholderRegistry.register(
+    "DATE",
+    (context) => styledPlaceholderText(isoDate(placeholderDate(context)), context)
+  );
+  PlaceholderRegistry.register(
+    "DATETIME",
+    (context) => styledPlaceholderText(isoDateTime(placeholderDate(context)), context)
+  );
+  PlaceholderRegistry.register(
+    "YEAR",
+    (context) => styledPlaceholderText(
+      String(placeholderDate(context).getUTCFullYear()),
+      context
+    )
+  );
 }
 initializeBuiltinPlaceholders();
 
 // src/utils/revisionUtils.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 var DEFAULT_REVISION_AUTHOR = "json-to-office";
 var DEFAULT_REVISION_DATE = "1970-01-01T00:00:00Z";
 var RevisionIdRegistry = class {
-  counter = 0;
+  fallbackCounter = 0;
+  scopes = new AsyncLocalStorage2();
+  runScoped(callback) {
+    return this.scopes.run({ counter: 0 }, callback);
+  }
   next() {
-    this.counter += 1;
-    return this.counter;
+    const state = this.scopes.getStore();
+    if (state) {
+      state.counter += 1;
+      return state.counter;
+    }
+    this.fallbackCounter += 1;
+    return this.fallbackCounter;
   }
   /** Test-only: deterministic ids for snapshot assertions. */
   clear() {
-    this.counter = 0;
+    const state = this.scopes.getStore();
+    if (state) {
+      state.counter = 0;
+    } else {
+      this.fallbackCounter = 0;
+    }
   }
 };
 var globalRevisionIdRegistry = new RevisionIdRegistry();
@@ -4179,7 +3957,10 @@ async function clearComponentCache() {
   }
 }
 async function renderComponentWithCache(component, theme, themeName, context, bypassCache = false) {
-  const forceBypassForType = component.name === "toc" || component.name === "section" || component.name === "visual" || componentHasRevision(component);
+  const forceBypassForType = component.name === "toc" || component.name === "section" || component.name === "visual" || component.name === "heading" || // Both explicit lists and markdown-list paragraphs register numbering in
+  // the current document scope. Cached paragraphs can otherwise reference
+  // definitions that only existed in a previous render.
+  component.name === "list" || component.name === "paragraph" || "id" in component || componentHasRevision(component);
   if (!componentCache) {
     initializeComponentCache();
   }
@@ -4189,8 +3970,9 @@ async function renderComponentWithCache(component, theme, themeName, context, by
   const componentProps = JSON.stringify(component.props || {});
   const themeHash = createThemeHash(theme);
   const contextKey = context?.section ? `${context.section.currentLayout}:${context.section.columnCount}` : "no-section";
+  const generationDateKey = getGenerationDate().toISOString();
   const childrenKey = "children" in component && component.children ? `:children:${JSON.stringify(component.children)}` : "";
-  const cacheKey = `component:${component.name}:${themeHash}:${contextKey}:${componentProps}${childrenKey}`;
+  const cacheKey = `component:${component.name}:${themeHash}:${contextKey}:${generationDateKey}:${componentProps}${childrenKey}`;
   const cached = await componentCache.get(cacheKey);
   if (cached) {
     return cached.result;
@@ -4261,19 +4043,27 @@ init_styles();
 init_defaults();
 
 // src/utils/bookmarkRegistry.ts
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
 var BookmarkRegistry = class {
-  bookmarks = /* @__PURE__ */ new Map();
-  counter = 0;
+  fallback = { bookmarks: /* @__PURE__ */ new Map() };
+  scopes = new AsyncLocalStorage3();
+  get state() {
+    return this.scopes.getStore() ?? this.fallback;
+  }
+  /** Run work with an isolated registry that follows its async call chain. */
+  runScoped(callback) {
+    return this.scopes.run({ bookmarks: /* @__PURE__ */ new Map() }, callback);
+  }
   /**
    * Register a bookmark
    */
   register(id, title, type) {
-    if (this.bookmarks.has(id)) {
+    if (this.state.bookmarks.has(id)) {
       console.warn(
         `Duplicate bookmark ID: ${id}. Using the latest registration.`
       );
     }
-    this.bookmarks.set(id, { id, title, type });
+    this.state.bookmarks.set(id, { id, title, type });
   }
   /**
    * Generate a unique bookmark ID from text
@@ -4283,7 +4073,7 @@ var BookmarkRegistry = class {
     const baseId = text.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").substring(0, 40);
     let id = baseId;
     let attempt = 0;
-    while (this.bookmarks.has(id) && attempt < 100) {
+    while (this.state.bookmarks.has(id) && attempt < 100) {
       id = `${baseId}-${++attempt}`;
     }
     return id;
@@ -4292,26 +4082,25 @@ var BookmarkRegistry = class {
    * Check if a bookmark exists
    */
   exists(id) {
-    return this.bookmarks.has(id);
+    return this.state.bookmarks.has(id);
   }
   /**
    * Get bookmark info by ID
    */
   get(id) {
-    return this.bookmarks.get(id);
+    return this.state.bookmarks.get(id);
   }
   /**
    * Get all registered bookmarks
    */
   getAll() {
-    return Array.from(this.bookmarks.values());
+    return Array.from(this.state.bookmarks.values());
   }
   /**
    * Clear all bookmarks
    */
   clear() {
-    this.bookmarks.clear();
-    this.counter = 0;
+    this.state.bookmarks.clear();
   }
   /**
    * Validate that all internal hyperlink references exist
@@ -5599,8 +5388,173 @@ function renderHeadingComponent(component, theme, themeName) {
   return [header];
 }
 
+// src/utils/numberingConfig.ts
+import { AlignmentType as AlignmentType3, convertInchesToTwip, LevelFormat } from "docx";
+import { AsyncLocalStorage as AsyncLocalStorage4 } from "async_hooks";
+var LEVEL_FORMAT_MAP = {
+  decimal: LevelFormat.DECIMAL,
+  upperRoman: LevelFormat.UPPER_ROMAN,
+  lowerRoman: LevelFormat.LOWER_ROMAN,
+  upperLetter: LevelFormat.UPPER_LETTER,
+  lowerLetter: LevelFormat.LOWER_LETTER,
+  bullet: LevelFormat.BULLET,
+  ordinal: LevelFormat.ORDINAL,
+  cardinalText: LevelFormat.CARDINAL_TEXT,
+  ordinalText: LevelFormat.ORDINAL_TEXT,
+  hex: LevelFormat.HEX,
+  chicago: LevelFormat.CHICAGO,
+  ideographDigital: LevelFormat.IDEOGRAPH__DIGITAL,
+  japaneseCounting: LevelFormat.JAPANESE_COUNTING,
+  aiueo: LevelFormat.AIUEO,
+  iroha: LevelFormat.IROHA,
+  decimalFullWidth: LevelFormat.DECIMAL_FULL_WIDTH,
+  decimalHalfWidth: LevelFormat.DECIMAL_HALF_WIDTH,
+  japaneseLegal: LevelFormat.JAPANESE_LEGAL,
+  japaneseDigitalTenThousand: LevelFormat.JAPANESE_DIGITAL_TEN_THOUSAND,
+  decimalEnclosedCircle: LevelFormat.DECIMAL_ENCLOSED_CIRCLE,
+  decimalFullWidth2: LevelFormat.DECIMAL_FULL_WIDTH2,
+  aiueoFullWidth: LevelFormat.AIUEO_FULL_WIDTH,
+  irohaFullWidth: LevelFormat.IROHA_FULL_WIDTH,
+  decimalZero: LevelFormat.DECIMAL_ZERO,
+  ganada: LevelFormat.GANADA,
+  chosung: LevelFormat.CHOSUNG,
+  decimalEnclosedFullstop: LevelFormat.DECIMAL_ENCLOSED_FULLSTOP,
+  decimalEnclosedParen: LevelFormat.DECIMAL_ENCLOSED_PARENTHESES,
+  decimalEnclosedCircleChinese: LevelFormat.DECIMAL_ENCLOSED_CIRCLE_CHINESE,
+  ideographEnclosedCircle: LevelFormat.IDEOGRAPH_ENCLOSED_CIRCLE,
+  ideographTraditional: LevelFormat.IDEOGRAPH_TRADITIONAL,
+  ideographZodiac: LevelFormat.IDEOGRAPH_ZODIAC,
+  ideographZodiacTraditional: LevelFormat.IDEOGRAPH_ZODIAC_TRADITIONAL,
+  taiwaneseCounting: LevelFormat.TAIWANESE_COUNTING,
+  ideographLegalTraditional: LevelFormat.IDEOGRAPH_LEGAL_TRADITIONAL,
+  taiwaneseCountingThousand: LevelFormat.TAIWANESE_COUNTING_THOUSAND,
+  taiwaneseDigital: LevelFormat.TAIWANESE_DIGITAL,
+  chineseCounting: LevelFormat.CHINESE_COUNTING,
+  chineseLegalSimplified: LevelFormat.CHINESE_LEGAL_SIMPLIFIED,
+  chineseCountingThousand: LevelFormat.CHINESE_COUNTING_THOUSAND,
+  koreanDigital: LevelFormat.KOREAN_DIGITAL,
+  koreanCounting: LevelFormat.KOREAN_COUNTING,
+  koreanLegal: LevelFormat.KOREAN_LEGAL,
+  koreanDigital2: LevelFormat.KOREAN_DIGITAL2,
+  vietnameseCounting: LevelFormat.VIETNAMESE_COUNTING,
+  russianLower: LevelFormat.RUSSIAN_LOWER,
+  russianUpper: LevelFormat.RUSSIAN_UPPER,
+  none: LevelFormat.NONE,
+  numberInDash: LevelFormat.NUMBER_IN_DASH,
+  hebrew1: LevelFormat.HEBREW1,
+  hebrew2: LevelFormat.HEBREW2,
+  arabicAlpha: LevelFormat.ARABIC_ALPHA,
+  arabicAbjad: LevelFormat.ARABIC_ABJAD,
+  hindiVowels: LevelFormat.HINDI_VOWELS,
+  hindiConsonants: LevelFormat.HINDI_CONSONANTS,
+  hindiNumbers: LevelFormat.HINDI_NUMBERS,
+  hindiCounting: LevelFormat.HINDI_COUNTING,
+  thaiLetters: LevelFormat.THAI_LETTERS,
+  thaiNumbers: LevelFormat.THAI_NUMBERS,
+  thaiCounting: LevelFormat.THAI_COUNTING
+};
+var ALIGNMENT_MAP = {
+  start: AlignmentType3.START,
+  end: AlignmentType3.END,
+  left: AlignmentType3.LEFT,
+  right: AlignmentType3.RIGHT,
+  center: AlignmentType3.CENTER
+};
+function getLevelFormat(format2) {
+  if (!format2) return LevelFormat.BULLET;
+  return LEVEL_FORMAT_MAP[format2] || LevelFormat.BULLET;
+}
+function getAlignment2(alignment) {
+  if (!alignment) return AlignmentType3.LEFT;
+  return ALIGNMENT_MAP[alignment] || AlignmentType3.LEFT;
+}
+function createNumberingConfig(config) {
+  const levels = [];
+  for (const levelConfig of config.levels) {
+    const format2 = getLevelFormat(levelConfig.format);
+    const alignment = getAlignment2(levelConfig.alignment);
+    const text = levelConfig.text || (format2 === LevelFormat.BULLET ? "\u2022" : `%${levelConfig.level + 1}.`);
+    const baseIndent = levelConfig.indent?.left !== void 0 ? levelConfig.indent.left / 72 : 0.5 * (levelConfig.level + 1);
+    const hangingIndent = levelConfig.indent?.hanging !== void 0 ? levelConfig.indent.hanging / 72 : 0.25;
+    const level = {
+      level: levelConfig.level,
+      format: format2,
+      text,
+      alignment,
+      style: {
+        paragraph: {
+          indent: {
+            left: convertInchesToTwip(baseIndent),
+            hanging: convertInchesToTwip(hangingIndent)
+          }
+        }
+      },
+      // Add start number if specified
+      ...levelConfig.start !== void 0 && { start: levelConfig.start }
+    };
+    levels.push(level);
+  }
+  return {
+    reference: config.reference,
+    levels
+  };
+}
+var NumberingRegistry = class {
+  fallback = {
+    configs: /* @__PURE__ */ new Map(),
+    counter: 0
+  };
+  scopes = new AsyncLocalStorage4();
+  get state() {
+    return this.scopes.getStore() ?? this.fallback;
+  }
+  /** Run work with an isolated registry that follows its async call chain. */
+  runScoped(callback) {
+    return this.scopes.run({ configs: /* @__PURE__ */ new Map(), counter: 0 }, callback);
+  }
+  /**
+   * Register a numbering configuration
+   */
+  register(config) {
+    const reference = config.reference;
+    this.state.configs.set(reference, config);
+    return reference;
+  }
+  /**
+   * Generate a unique reference ID
+   */
+  generateReference(prefix = "list") {
+    return `${prefix}-${++this.state.counter}`;
+  }
+  /**
+   * Get all registered configurations as an array suitable for INumberingOptions
+   */
+  getAll() {
+    return Array.from(this.state.configs.values());
+  }
+  /**
+   * Clear all configurations
+   */
+  clear() {
+    this.state.configs.clear();
+    this.state.counter = 0;
+  }
+  /**
+   * Check if a reference exists
+   */
+  has(reference) {
+    return this.state.configs.has(reference);
+  }
+  /**
+   * Get a configuration by reference
+   */
+  get(reference) {
+    return this.state.configs.get(reference);
+  }
+};
+var globalNumberingRegistry = new NumberingRegistry();
+
 // src/components/paragraph.ts
-init_numberingConfig();
 function parseMarkdownList(text) {
   const lines = text.split("\n");
   const items = [];
@@ -5726,7 +5680,6 @@ function renderParagraphComponent(component, theme, themeName) {
 }
 
 // src/components/list.ts
-init_numberingConfig();
 function createLevelsFromSimplifiedProps(props) {
   const levels = [];
   let format2;
@@ -6150,17 +6103,22 @@ async function renderTableComponent(component, theme, themeName) {
 
 // src/components/section.ts
 import { Paragraph as Paragraph4, BookmarkStart, BookmarkEnd } from "docx";
-function generateSectionBookmarkId() {
-  const linkId = Math.floor(Math.random() * 1e6);
+function generateSectionBookmarkId(context) {
+  const custom = context.custom ??= {};
+  const state = custom.sectionBookmarks ??= {
+    next: 1
+  };
+  const ordinal = state.next++;
+  const linkId = 1e6 + ordinal;
   return {
-    id: `_Section_${linkId}_${Date.now()}`,
+    id: `_NestedSection_${ordinal}`,
     linkId
   };
 }
 async function renderSectionComponent(component, theme, themeName, context) {
   if (!isSectionComponent(component)) return [];
   const elements = [];
-  const { id: sectionBookmarkId, linkId: bookmarkLinkId } = generateSectionBookmarkId();
+  const { id: sectionBookmarkId, linkId: bookmarkLinkId } = generateSectionBookmarkId(context);
   elements.push(
     new Paragraph4({
       children: [new BookmarkStart(sectionBookmarkId, bookmarkLinkId)],
@@ -6576,9 +6534,23 @@ Cause: ${cause}`
     height
   };
 }
+function withThemeColors(config, theme) {
+  const options = config.options;
+  if (!options || options.colors || !theme?.colors) return config;
+  const palette = [
+    theme.colors.primary,
+    theme.colors.secondary,
+    theme.colors.accent
+  ].filter((c) => typeof c === "string" && c.length > 0).map((c) => c.startsWith("#") ? c : `#${c}`);
+  if (palette.length === 0) return config;
+  return {
+    ...config,
+    options: { ...config.options, colors: palette }
+  };
+}
 async function renderHighchartsComponent(component, theme, themeName, context) {
   if (!isHighchartsComponent(component)) return [];
-  const config = component.props;
+  const config = withThemeColors(component.props, theme);
   const chartResult = await generateChart(
     config,
     context?.services?.highcharts
@@ -6775,13 +6747,23 @@ function getAlignment3(alignment) {
   }
 }
 async function renderDocument(structure, layout, options) {
+  return runWithGenerationDate(
+    structure.metadata.date,
+    () => globalBookmarkRegistry.runScoped(
+      () => globalRevisionIdRegistry.runScoped(
+        () => globalNumberingRegistry.runScoped(
+          () => renderDocumentScoped(structure, layout, options)
+        )
+      )
+    )
+  );
+}
+async function renderDocumentScoped(structure, layout, options) {
   if (options?.cache) {
     initializeComponentCache(options.cache);
   } else if (!options?.bypassCache) {
     initializeComponentCache();
   }
-  const { globalNumberingRegistry: globalNumberingRegistry2 } = await Promise.resolve().then(() => (init_numberingConfig(), numberingConfig_exports));
-  globalNumberingRegistry2.clear();
   const sections = [];
   const context = createRenderContext(
     structure,
@@ -6838,7 +6820,8 @@ async function renderDocument(structure, layout, options) {
       structure.themeName,
       context,
       sectionOrdinal,
-      closeBookmark
+      closeBookmark,
+      options?.bypassCache === true
     );
     if (layoutSection.isUserSection) {
       sectionBookmarkCounter++;
@@ -6847,7 +6830,7 @@ async function renderDocument(structure, layout, options) {
       sections.push(rendered);
     }
   }
-  const numberingConfigs = globalNumberingRegistry2.getAll();
+  const numberingConfigs = globalNumberingRegistry.getAll();
   return new Document({
     styles: createWordStyles(structure.theme, structure.language),
     sections,
@@ -7015,7 +6998,7 @@ async function renderHeaderFooterComponents(components, theme, themeName, contex
   }
   return elements;
 }
-async function renderSection(section, theme, themeName, context, sectionOrdinal, closeBookmark) {
+async function renderSection(section, theme, themeName, context, sectionOrdinal, closeBookmark, bypassCache = false) {
   const elements = [];
   const isFirstLayoutOfUserSection = section.isUserSection;
   const sharedLinkId = section.belongsToUserSection && sectionOrdinal ? sectionOrdinal : void 0;
@@ -7053,8 +7036,7 @@ async function renderSection(section, theme, themeName, context, sectionOrdinal,
       theme,
       themeName,
       sectionContext,
-      false
-      // Don't bypass cache
+      bypassCache
     );
     elements.push(...rendered);
   }
@@ -7204,6 +7186,75 @@ async function resolveDocumentFonts(document, theme, fonts, warnings) {
 // src/core/generator.ts
 import { applyExportMode, scopedThemeName } from "@json-to-office/shared";
 
+// src/utils/packageDocument.ts
+import AdmZip2 from "adm-zip";
+import { Packer } from "docx";
+
+// src/utils/fixFloatingImageIds.ts
+import AdmZip from "adm-zip";
+function fixFloatingImageIdsInBuffer(buffer) {
+  const zip = new AdmZip(buffer);
+  const documentEntry = zip.getEntry("word/document.xml");
+  if (!documentEntry) {
+    throw new Error("document.xml not found in DOCX");
+  }
+  let idCounter = 1;
+  const documentXml = documentEntry.getData().toString("utf8").replace(/<wp:docPr\s+id="(\d+)"/g, () => {
+    const newId = idCounter++;
+    return `<wp:docPr id="${newId}"`;
+  });
+  zip.updateFile(documentEntry, Buffer.from(documentXml, "utf8"));
+  return zip.toBuffer();
+}
+
+// src/utils/packageDocument.ts
+var DEFAULT_GENERATION_DATE = /* @__PURE__ */ new Date("2000-01-01T00:00:00.000Z");
+function resolveGenerationDate(options) {
+  if (options?.generatedAt !== void 0) {
+    const date = new Date(options.generatedAt);
+    if (Number.isNaN(date.getTime())) {
+      throw new RangeError("generatedAt must be a valid date");
+    }
+    if (date.getUTCFullYear() < 1980) {
+      throw new RangeError(
+        "generatedAt must be on or after 1980-01-01 for ZIP compatibility"
+      );
+    }
+    return date;
+  }
+  return options?.deterministic === false ? /* @__PURE__ */ new Date() : new Date(DEFAULT_GENERATION_DATE);
+}
+function toDosTime(date) {
+  const dosDate = (date.getUTCFullYear() - 1980 & 127) << 9 | date.getUTCMonth() + 1 << 5 | date.getUTCDate();
+  const dosTime = date.getUTCHours() << 11 | date.getUTCMinutes() << 5 | date.getUTCSeconds() >> 1;
+  return (dosDate << 16 | dosTime) >>> 0;
+}
+function canonicalizeDocxBuffer(buffer, generatedAt = DEFAULT_GENERATION_DATE) {
+  const zip = new AdmZip2(buffer);
+  const isoTimestamp = generatedAt.toISOString();
+  const coreProperties = zip.getEntry("docProps/core.xml");
+  if (coreProperties) {
+    const normalized = coreProperties.getData().toString("utf8").replace(
+      /(<dcterms:(?:created|modified)\b[^>]*>)[^<]*(<\/dcterms:(?:created|modified)>)/g,
+      `$1${isoTimestamp}$2`
+    );
+    zip.updateFile(coreProperties, Buffer.from(normalized, "utf8"));
+  }
+  const zipTimestamp = toDosTime(generatedAt);
+  for (const entry of zip.getEntries()) {
+    entry.header.timeval = zipTimestamp;
+  }
+  return zip.toBuffer();
+}
+async function packageDocument(document, options) {
+  const packed = await Packer.toBuffer(document);
+  const fixed = fixFloatingImageIdsInBuffer(packed);
+  if (options?.deterministic === false) {
+    return fixed;
+  }
+  return canonicalizeDocxBuffer(fixed, resolveGenerationDate(options));
+}
+
 // src/json/parser.ts
 import {
   JsonDocumentParser,
@@ -7375,7 +7426,8 @@ async function generateDocument(document, options) {
     options?.customThemes,
     options?.services,
     options?.fonts,
-    options?.warnings
+    options?.warnings,
+    resolveGenerationDate(options)
   );
 }
 async function generateFromConfig(props, components, options) {
@@ -7386,7 +7438,7 @@ async function generateFromConfig(props, components, options) {
   };
   return await generateDocument(reportComponent, options);
 }
-async function generateDocumentWithCustomThemes(documentIn, customThemes, services, fonts, warnings) {
+async function generateDocumentWithCustomThemes(documentIn, customThemes, services, fonts, warnings, generationDate) {
   let document = documentIn;
   let themeName = document.props.theme || "minimal";
   let theme;
@@ -7424,7 +7476,12 @@ async function generateDocumentWithCustomThemes(documentIn, customThemes, servic
     }
   }
   await resolveDocumentFonts(document, theme, fonts, warnings);
-  const structure = await processDocument(document, theme, themeName);
+  const structure = await processDocument(
+    document,
+    theme,
+    themeName,
+    generationDate
+  );
   const layout = applyLayout(structure.sections, theme, themeName);
   const renderedDocument = await renderDocument(structure, layout, {
     bypassCache: false,
@@ -7472,7 +7529,8 @@ async function generateDocumentFromJson(jsonConfig, options) {
     options?.customThemes,
     options?.services,
     options?.fonts,
-    options?.warnings
+    options?.warnings,
+    resolveGenerationDate(options)
   );
 }
 function validateJsonSchema(jsonConfig) {
@@ -7480,11 +7538,11 @@ function validateJsonSchema(jsonConfig) {
 }
 async function generateBufferFromJson(jsonConfig, options) {
   const document = await generateDocumentFromJson(jsonConfig, options);
-  return await Packer.toBuffer(document);
+  return packageDocument(document, options);
 }
 async function generateAndSaveFromJson(jsonConfig, filename, options) {
   const document = await generateDocumentFromJson(jsonConfig, options);
-  await saveDocument(document, filename);
+  await saveDocument(document, filename, options);
 }
 async function generateDocumentFromFile(filePath, options) {
   const jsonDefinition = await loadJsonDefinition(filePath);
@@ -7492,25 +7550,19 @@ async function generateDocumentFromFile(filePath, options) {
 }
 async function generateBufferFromFile(filePath, options) {
   const document = await generateDocumentFromFile(filePath, options);
-  return await Packer.toBuffer(document);
+  return packageDocument(document, options);
 }
 async function generateAndSaveFromFile(inputFilePath, outputFilePath, options) {
   const document = await generateDocumentFromFile(inputFilePath, options);
-  await saveDocument(document, outputFilePath);
+  await saveDocument(document, outputFilePath, options);
 }
-async function saveDocument(document, filename) {
-  const buffer = await Packer.toBuffer(document);
+async function saveDocument(document, filename, options) {
+  const buffer = await packageDocument(document, options);
   writeFileSync(filename, buffer);
-  try {
-    const { fixFloatingImageIds: fixFloatingImageIds2 } = await Promise.resolve().then(() => (init_fixFloatingImageIds(), fixFloatingImageIds_exports));
-    await fixFloatingImageIds2(filename);
-  } catch (error) {
-    console.warn("Failed to fix floating image IDs (non-critical):", error);
-  }
 }
-async function generateAndSave(document, filename) {
-  const generatedDocument = await generateDocument(document);
-  await saveDocument(generatedDocument, filename);
+async function generateAndSave(document, filename, options) {
+  const generatedDocument = await generateDocument(document, options);
+  await saveDocument(generatedDocument, filename, options);
 }
 var DocumentGenerator = {
   generate: generateDocument,
@@ -7840,7 +7892,6 @@ async function runExample(example, options = {}) {
 
 // src/plugin/createDocumentGenerator.ts
 init_styles();
-import { Packer as Packer2 } from "docx";
 import { applyExportMode as applyExportMode2, scopedThemeName as scopedThemeName2 } from "@json-to-office/shared";
 
 // src/plugin/version-resolver.ts
@@ -8237,7 +8288,10 @@ function createBuilderImpl(state) {
       debug: state.debug,
       enableCache: state.enableCache,
       services: state.services,
-      fonts: state.fonts
+      fonts: state.fonts,
+      validation: state.validation,
+      deterministic: state.deterministic,
+      generatedAt: state.generatedAt
     };
     return createBuilderImpl(
       newState
@@ -8329,10 +8383,20 @@ function createBuilderImpl(state) {
       };
       const [modedDoc] = normalizeDocument(processedDocument);
       await resolveDocumentFonts(modedDoc, modedTheme, state.fonts, warnings);
-      const structure = await processDocument(modedDoc, modedTheme, themeName);
+      const packageOptions = {
+        deterministic: options?.deterministic ?? state.deterministic,
+        generatedAt: options?.generatedAt ?? state.generatedAt
+      };
+      const structure = await processDocument(
+        modedDoc,
+        modedTheme,
+        themeName,
+        resolveGenerationDate(packageOptions)
+      );
       const layout = applyLayout(structure.sections, modedTheme, themeName);
       const generatedDocument = await renderDocument(structure, layout, {
-        services: state.services
+        services: state.services,
+        bypassCache: !state.enableCache
       });
       const preservedDefinition = preserveSet ? {
         ...mode.doc,
@@ -8358,7 +8422,10 @@ function createBuilderImpl(state) {
       standardDefinition,
       preservedDefinition
     } = await generate(document, options);
-    const buffer = await Packer2.toBuffer(doc);
+    const buffer = await packageDocument(doc, {
+      deterministic: options?.deterministic ?? state.deterministic,
+      generatedAt: options?.generatedAt ?? state.generatedAt
+    });
     return { buffer, warnings, standardDefinition, preservedDefinition };
   }
   async function generateFile(document, outputPath, options) {
@@ -8457,7 +8524,9 @@ function createDocumentGenerator(options) {
     enableCache: options.enableCache ?? false,
     services: options.services,
     fonts: options.fonts,
-    validation: options.validation
+    validation: options.validation,
+    deterministic: options.deterministic ?? true,
+    generatedAt: options.generatedAt
   };
   return createBuilderImpl(initialState);
 }