@extend-ai/react-docx 0.8.1 → 0.8.3

package/dist/index.cjs

@@ -188,6 +188,10 @@ function __wbg_get_imports() {
       const ret = Object.create(getObject(arg0));
       return addHeapObject(ret);
     },
+    __wbg_from_8a57180716c586ee: function(arg0) {
+      const ret = Array.from(getObject(arg0));
+      return addHeapObject(ret);
+    },
     __wbg_get_52a8a619f7b88df6: function() {
       return handleError(function(arg0, arg1) {
         const ret = Reflect.get(getObject(arg0), getObject(arg1));
@@ -234,6 +238,10 @@ function __wbg_get_imports() {
       const ret = getObject(arg0).length;
       return ret;
     },
+    __wbg_new_0b303268aa395a38: function() {
+      const ret = new Array();
+      return addHeapObject(ret);
+    },
     __wbg_new_20b778a4c5c691c3: function() {
       const ret = new Object();
       return addHeapObject(ret);
@@ -255,6 +263,10 @@ function __wbg_get_imports() {
     __wbg_prototypesetcall_956c7493c68e29b4: function(arg0, arg1, arg2) {
       Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
     },
+    __wbg_push_ceb8ef046afb2041: function(arg0, arg1) {
+      const ret = getObject(arg0).push(getObject(arg1));
+      return ret;
+    },
     __wbg_set_a6ba3ac0e634b822: function() {
       return handleError(function(arg0, arg1, arg2) {
         const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
@@ -595,7 +607,11 @@ function wasmPackageToMaps(raw) {
   for (const [name, asset] of Object.entries(raw.binaryAssets ?? {})) {
     binaryAssets.set(name, toUint8Array(asset));
   }
-  return { parts, binaryAssets };
+  return {
+    parts,
+    binaryAssets,
+    warnings: Array.isArray(raw.warnings) ? [...raw.warnings] : []
+  };
 }
 function mapsToWasmPackage(input) {
   const parts = {};
@@ -609,7 +625,11 @@ function mapsToWasmPackage(input) {
   for (const [name, asset] of input.binaryAssets.entries()) {
     binaryAssets[name] = asset;
   }
-  return { parts, binaryAssets };
+  return {
+    parts,
+    binaryAssets,
+    ...input.warnings && input.warnings.length > 0 ? { warnings: [...input.warnings] } : {}
+  };
 }
 async function wasmParseDocx(bytes) {
   await initWasm();
@@ -656,8 +676,8 @@ __export(src_exports, {
 });
 async function parseDocx(input) {
   const wasmPackage = await wasmParseDocx(input);
-  const { parts, binaryAssets } = wasmPackageToMaps(wasmPackage);
-  return { parts, binaryAssets };
+  const { parts, binaryAssets, warnings } = wasmPackageToMaps(wasmPackage);
+  return { parts, binaryAssets, ...warnings.length > 0 ? { warnings } : {} };
 }
 async function packageToArrayBuffer(pkg) {
   return wasmPackageToArrayBuffer(mapsToWasmPackage(pkg));
@@ -684,7 +704,8 @@ function withPart(pkg, part) {
   parts.set(part.name, part);
   return {
     parts,
-    binaryAssets: new Map(pkg.binaryAssets)
+    binaryAssets: new Map(pkg.binaryAssets),
+    ...pkg.warnings && pkg.warnings.length > 0 ? { warnings: [...pkg.warnings] } : {}
   };
 }
 var WORD_MAIN_NS, DEFAULT_DOCUMENT_XML, DEFAULT_CONTENT_TYPES_XML, DEFAULT_ROOT_RELS_XML, DEFAULT_DOCUMENT_RELS_XML;
@@ -1310,7 +1331,8 @@ __export(src_exports2, {
 async function buildDocModel(pkg) {
   const wasmPackage = mapsToWasmPackage({
     parts: pkg.parts,
-    binaryAssets: pkg.binaryAssets
+    binaryAssets: pkg.binaryAssets,
+    warnings: pkg.warnings
   });
   const model = await wasmBuildDocModelFromPackage(wasmPackage);
   return normalizeDocModel(model);
@@ -16572,14 +16594,53 @@ function resolveListParagraphIndent(paragraph, numberingDefinitions) {
     hangingTwips: nextHangingTwips
   };
 }
-function resolveNumberingMarkerBoxWidthPx(paragraph, numberingDefinitions, numberingLabel) {
+function numberingIndentCandidateWidthPx(paragraph, numberingDefinitions) {
   const resolvedIndent = resolveListParagraphIndent(
     paragraph,
     numberingDefinitions
   );
   const hangingIndentPx = twipsToSignedPixels(resolvedIndent?.hangingTwips);
   const firstLineIndentPx = twipsToSignedPixels(resolvedIndent?.firstLineTwips);
-  const candidateWidthPx = Number.isFinite(hangingIndentPx) && Math.abs(hangingIndentPx) > 0 ? Math.abs(hangingIndentPx) : Number.isFinite(firstLineIndentPx) && firstLineIndentPx < 0 ? Math.abs(firstLineIndentPx) : void 0;
+  return Number.isFinite(hangingIndentPx) && Math.abs(hangingIndentPx) > 0 ? Math.abs(hangingIndentPx) : Number.isFinite(firstLineIndentPx) && firstLineIndentPx < 0 ? Math.abs(firstLineIndentPx) : void 0;
+}
+function resolvedNumberingLevelForParagraph(paragraph, numberingDefinitions) {
+  const numbering = paragraph.style?.numbering;
+  if (!numberingDefinitions || !numbering || !Number.isFinite(numbering.numId) || numbering.numId <= 0) {
+    return void 0;
+  }
+  const effectiveNumId = effectiveNumberingNumIdForParagraph(paragraph, numberingDefinitions) ?? numbering.numId;
+  return findNumberingLevelDefinition(
+    numberingDefinitions,
+    effectiveNumId,
+    Math.max(0, Math.round(numbering.ilvl ?? 0))
+  );
+}
+function numberingTabAdvanceWidthPx(paragraph, numberingDefinitions, numberingLabel) {
+  if (!numberingLabel?.text || numberingLabel.imageSrc || isTableOfContentsParagraph(paragraph)) {
+    return void 0;
+  }
+  const level = resolvedNumberingLevelForParagraph(
+    paragraph,
+    numberingDefinitions
+  );
+  const suffix = level?.suffix ?? "tab";
+  if (suffix !== "tab") {
+    return void 0;
+  }
+  const labelWidthPx = Math.ceil(
+    measureTextWidthPx2(
+      numberingLabel.text.replace(/\t/g, " ").replace(/\u00a0/g, " "),
+      numberingLabel.style,
+      paragraphBaseFontSizePx(paragraph)
+    )
+  );
+  return (Math.floor(labelWidthPx / DEFAULT_TAB_STOP_PX) + 1) * DEFAULT_TAB_STOP_PX;
+}
+function resolveNumberingMarkerBoxWidthPx(paragraph, numberingDefinitions, numberingLabel) {
+  const candidateWidthPx = numberingIndentCandidateWidthPx(
+    paragraph,
+    numberingDefinitions
+  );
   const labelTextForWidth = numberingLabel?.imageSrc ? numberingLabel.trailingText ?? "" : numberingLabel?.text ?? "";
   const normalizedLabelTextForWidth = labelTextForWidth.replace(/\t/g, " ").replace(/\u00a0/g, " ");
   const measuredLabelWidthPx = normalizedLabelTextForWidth.length > 0 ? Math.ceil(
@@ -16605,6 +16666,18 @@ function resolveNumberingMarkerBoxWidthPx(paragraph, numberingDefinitions, numbe
     tocMarkerTargetWidthPx
   );
   if (!Number.isFinite(candidateWidthPx) || candidateWidthPx < 8) {
+    const tabAdvanceWidthPx = numberingTabAdvanceWidthPx(
+      paragraph,
+      numberingDefinitions,
+      numberingLabel
+    );
+    if (tabAdvanceWidthPx !== void 0) {
+      return clampNumber(
+        Math.round(Math.max(tabAdvanceWidthPx, minimumVisualWidthPx)),
+        8,
+        220
+      );
+    }
     return minimumVisualWidthPx > 0 ? clampNumber(Math.round(minimumVisualWidthPx), 8, 220) : void 0;
   }
   return Math.max(
@@ -16619,11 +16692,16 @@ function numberingMarkerStyle(paragraph, numberingDefinitions, numberingLabel, b
     numberingLabel
   );
   const markerGapPx = isTableOfContentsParagraph(paragraph) ? 6 : markerBoxWidthPx ? 0 : 2;
+  const tabSynthesized = markerBoxWidthPx !== void 0 && numberingIndentCandidateWidthPx(paragraph, numberingDefinitions) === void 0 && numberingTabAdvanceWidthPx(
+    paragraph,
+    numberingDefinitions,
+    numberingLabel
+  ) !== void 0;
   return {
     ...baseStyle ?? {},
     display: "inline-flex",
     alignItems: "baseline",
-    justifyContent: "flex-end",
+    justifyContent: tabSynthesized ? "flex-start" : "flex-end",
     verticalAlign: "baseline",
     width: markerBoxWidthPx ? `${markerBoxWidthPx}px` : void 0,
     minWidth: markerBoxWidthPx ? `${markerBoxWidthPx}px` : "1.1em",
@@ -19646,40 +19724,157 @@ function numberToLetters(value) {
   if (!Number.isFinite(value) || value <= 0) {
     return "";
   }
-  let remaining = Math.floor(value);
-  let output = "";
-  while (remaining > 0) {
-    const offset = (remaining - 1) % 26;
-    output = String.fromCharCode(65 + offset) + output;
-    remaining = Math.floor((remaining - 1) / 26);
+  const rounded = Math.floor(value);
+  const letter = String.fromCharCode(65 + (rounded - 1) % 26);
+  return letter.repeat(Math.floor((rounded - 1) / 26) + 1);
+}
+var CARDINAL_ONES = [
+  "zero",
+  "one",
+  "two",
+  "three",
+  "four",
+  "five",
+  "six",
+  "seven",
+  "eight",
+  "nine",
+  "ten",
+  "eleven",
+  "twelve",
+  "thirteen",
+  "fourteen",
+  "fifteen",
+  "sixteen",
+  "seventeen",
+  "eighteen",
+  "nineteen"
+];
+var CARDINAL_TENS = [
+  "",
+  "",
+  "twenty",
+  "thirty",
+  "forty",
+  "fifty",
+  "sixty",
+  "seventy",
+  "eighty",
+  "ninety"
+];
+var ORDINAL_ONES = [
+  "zeroth",
+  "first",
+  "second",
+  "third",
+  "fourth",
+  "fifth",
+  "sixth",
+  "seventh",
+  "eighth",
+  "ninth",
+  "tenth",
+  "eleventh",
+  "twelfth",
+  "thirteenth",
+  "fourteenth",
+  "fifteenth",
+  "sixteenth",
+  "seventeenth",
+  "eighteenth",
+  "nineteenth"
+];
+var ORDINAL_TENS = [
+  "",
+  "",
+  "twentieth",
+  "thirtieth",
+  "fortieth",
+  "fiftieth",
+  "sixtieth",
+  "seventieth",
+  "eightieth",
+  "ninetieth"
+];
+function numberToCardinalText(value) {
+  if (value < 20) {
+    return CARDINAL_ONES[value];
+  }
+  if (value < 100) {
+    const tens = Math.floor(value / 10);
+    const ones = value % 10;
+    return ones === 0 ? CARDINAL_TENS[tens] : `${CARDINAL_TENS[tens]}-${CARDINAL_ONES[ones]}`;
+  }
+  if (value < 1e3) {
+    const hundreds = Math.floor(value / 100);
+    const rest = value % 100;
+    const head = `${CARDINAL_ONES[hundreds]} hundred`;
+    return rest === 0 ? head : `${head} ${numberToCardinalText(rest)}`;
+  }
+  return String(value);
+}
+function numberToOrdinalText(value) {
+  if (value < 20) {
+    return ORDINAL_ONES[value];
+  }
+  if (value < 100) {
+    const tens = Math.floor(value / 10);
+    const ones = value % 10;
+    return ones === 0 ? ORDINAL_TENS[tens] : `${CARDINAL_TENS[tens]}-${ORDINAL_ONES[ones]}`;
+  }
+  if (value < 1e3) {
+    const hundreds = Math.floor(value / 100);
+    const rest = value % 100;
+    return rest === 0 ? `${CARDINAL_ONES[hundreds]} hundredth` : `${CARDINAL_ONES[hundreds]} hundred ${numberToOrdinalText(rest)}`;
+  }
+  return String(value);
+}
+function numberToOrdinalDigits(value) {
+  const mod100 = value % 100;
+  if (mod100 >= 11 && mod100 <= 13) {
+    return `${value}th`;
+  }
+  switch (value % 10) {
+    case 1:
+      return `${value}st`;
+    case 2:
+      return `${value}nd`;
+    case 3:
+      return `${value}rd`;
+    default:
+      return `${value}th`;
   }
-  return output;
 }
 function formatNumberingCounter(format, value) {
-  if (!Number.isFinite(value) || value <= 0) {
+  if (!Number.isFinite(value) || value < 0) {
     return "";
   }
+  const rounded = Math.round(value);
   switch ((format ?? "decimal").toLowerCase()) {
     case "decimal":
-      return String(value);
+      return String(rounded);
+    case "decimalzero":
+      return rounded < 10 ? `0${rounded}` : String(rounded);
     case "upperroman":
-      return numberToRoman(value);
+      return rounded === 0 ? String(rounded) : numberToRoman(rounded);
     case "lowerroman":
-      return numberToRoman(value).toLowerCase();
+      return rounded === 0 ? String(rounded) : numberToRoman(rounded).toLowerCase();
     case "upperletter":
-      return numberToLetters(value);
+      return rounded === 0 ? String(rounded) : numberToLetters(rounded);
     case "lowerletter":
-      return numberToLetters(value).toLowerCase();
+      return rounded === 0 ? String(rounded) : numberToLetters(rounded).toLowerCase();
     case "ordinal":
+      return numberToOrdinalDigits(rounded);
     case "cardinaltext":
+      return numberToCardinalText(rounded);
     case "ordinaltext":
-      return String(value);
+      return numberToOrdinalText(rounded);
     case "bullet":
       return "\u2022";
     case "none":
       return "";
     default:
-      return String(value);
+      return String(rounded);
   }
 }
 function formatPageFieldValue(value, format) {
@@ -19794,10 +19989,10 @@ function numberingStartValue(numbering, numId, ilvl) {
   const instance = numbering.instances.find((item) => item.numId === numId);
   const override = instance?.levelStartOverrides?.[String(ilvl)];
   if (Number.isFinite(override)) {
-    return Math.max(1, Math.round(override));
+    return Math.max(0, Math.round(override));
   }
   const level = findNumberingLevelDefinition(numbering, numId, ilvl);
-  if (Number.isFinite(level?.start) && level?.start > 0) {
+  if (Number.isFinite(level?.start) && level?.start >= 0) {
     return Math.round(level?.start);
   }
   return 1;
@@ -19868,14 +20063,27 @@ function buildParagraphNumberingLabels(model) {
     if (!template || template.trim().length === 0) {
       return;
     }
+    const restartTriggerCeiling = (levelIndex) => {
+      const rawRestart = findNumberingLevelDefinition(
+        numbering,
+        numId,
+        levelIndex
+      )?.lvlRestart;
+      if (rawRestart === void 0 || !Number.isFinite(rawRestart) || Math.round(rawRestart) > levelIndex) {
+        return levelIndex - 1;
+      }
+      const restart = Math.round(rawRestart);
+      return restart <= 0 ? -1 : restart - 1;
+    };
+    const currentRestartCeiling = restartTriggerCeiling(ilvl);
     const counters = countersByNumId.get(numId) ?? [];
     const sharedAbstractCounters = Number.isFinite(abstractNumId) ? abstractCountersByAbstractNumId.get(abstractNumId) ?? [] : void 0;
     let parentCountersChanged = false;
     for (let index = 0; index < ilvl; index += 1) {
-      const abstractCounterValue = sharedAbstractCounters && Number.isFinite(sharedAbstractCounters[index]) ? Math.max(1, Math.round(sharedAbstractCounters[index])) : void 0;
+      const abstractCounterValue = sharedAbstractCounters && Number.isFinite(sharedAbstractCounters[index]) ? Math.max(0, Math.round(sharedAbstractCounters[index])) : void 0;
       if (abstractCounterValue !== void 0) {
         const previousCounter = counters[index];
-        if (!Number.isFinite(previousCounter) || Math.max(1, Math.round(previousCounter)) !== abstractCounterValue) {
+        if ((!Number.isFinite(previousCounter) || Math.max(0, Math.round(previousCounter)) !== abstractCounterValue) && index <= currentRestartCeiling) {
           parentCountersChanged = true;
         }
         counters[index] = abstractCounterValue;
@@ -19888,7 +20096,9 @@ function buildParagraphNumberingLabels(model) {
     const currentValue = parentCountersChanged ? void 0 : counters[ilvl];
     counters[ilvl] = Number.isFinite(currentValue) ? currentValue + 1 : numberingStartValue(numbering, numId, ilvl);
     for (let index = ilvl + 1; index < counters.length; index += 1) {
-      counters[index] = void 0;
+      if (ilvl <= restartTriggerCeiling(index)) {
+        counters[index] = void 0;
+      }
     }
     countersByNumId.set(numId, counters);
     if (sharedAbstractCounters && Number.isFinite(abstractNumId)) {
@@ -19896,7 +20106,9 @@ function buildParagraphNumberingLabels(model) {
         sharedAbstractCounters[index] = counters[index];
       }
       for (let index = ilvl + 1; index < sharedAbstractCounters.length; index += 1) {
-        sharedAbstractCounters[index] = void 0;
+        if (ilvl <= restartTriggerCeiling(index)) {
+          sharedAbstractCounters[index] = void 0;
+        }
       }
       abstractCountersByAbstractNumId.set(
         abstractNumId,
@@ -19906,12 +20118,8 @@ function buildParagraphNumberingLabels(model) {
     const label = template.replaceAll(/%(\d+)/g, (_, rawLevel) => {
       const levelIndex = Math.max(0, Number(rawLevel) - 1);
       const levelValue = counters[levelIndex];
-      const safeValue = Number.isFinite(levelValue) ? Math.max(1, Math.round(levelValue)) : numberingStartValue(numbering, numId, levelIndex);
-      const levelFormat = findNumberingLevelDefinition(
-        numbering,
-        numId,
-        levelIndex
-      )?.format;
+      const safeValue = Number.isFinite(levelValue) ? Math.max(0, Math.round(levelValue)) : numberingStartValue(numbering, numId, levelIndex);
+      const levelFormat = level?.isLgl ? "decimal" : findNumberingLevelDefinition(numbering, numId, levelIndex)?.format;
       return formatNumberingCounter(levelFormat, safeValue);
     });
     if (!label || label.trim().length === 0) {