docx 9.5.1 → 9.5.2

package/dist/index.mjs

@@ -3232,58 +3232,61 @@ function requireSetFunctionLength() {
   };
   return setFunctionLength;
 }
+var applyBind;
+var hasRequiredApplyBind;
+function requireApplyBind() {
+  if (hasRequiredApplyBind) return applyBind;
+  hasRequiredApplyBind = 1;
+  var bind = requireFunctionBind();
+  var $apply = requireFunctionApply();
+  var actualApply2 = requireActualApply();
+  applyBind = function applyBind2() {
+    return actualApply2(bind, $apply, arguments);
+  };
+  return applyBind;
+}
 var hasRequiredCallBind;
 function requireCallBind() {
   if (hasRequiredCallBind) return callBind.exports;
   hasRequiredCallBind = 1;
   (function(module) {
-    var bind = requireFunctionBind();
-    var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
     var setFunctionLength2 = /* @__PURE__ */ requireSetFunctionLength();
-    var $TypeError = /* @__PURE__ */ requireType();
-    var $apply = GetIntrinsic("%Function.prototype.apply%");
-    var $call = GetIntrinsic("%Function.prototype.call%");
-    var $reflectApply = GetIntrinsic("%Reflect.apply%", true) || bind.call($call, $apply);
     var $defineProperty = /* @__PURE__ */ requireEsDefineProperty();
-    var $max = GetIntrinsic("%Math.max%");
+    var callBindBasic = requireCallBindApplyHelpers();
+    var applyBind2 = requireApplyBind();
     module.exports = function callBind2(originalFunction) {
-      if (typeof originalFunction !== "function") {
-        throw new $TypeError("a function is required");
-      }
-      var func = $reflectApply(bind, $call, arguments);
+      var func = callBindBasic(arguments);
+      var adjustedLength = originalFunction.length - (arguments.length - 1);
       return setFunctionLength2(
         func,
-        1 + $max(0, originalFunction.length - (arguments.length - 1)),
+        1 + (adjustedLength > 0 ? adjustedLength : 0),
         true
       );
     };
-    var applyBind = function applyBind2() {
-      return $reflectApply(bind, $apply, arguments);
-    };
     if ($defineProperty) {
-      $defineProperty(module.exports, "apply", { value: applyBind });
+      $defineProperty(module.exports, "apply", { value: applyBind2 });
     } else {
-      module.exports.apply = applyBind;
+      module.exports.apply = applyBind2;
     }
   })(callBind);
   return callBind.exports;
 }
-var callBound;
-var hasRequiredCallBound;
-function requireCallBound() {
-  if (hasRequiredCallBound) return callBound;
-  hasRequiredCallBound = 1;
+var callBound$1;
+var hasRequiredCallBound$1;
+function requireCallBound$1() {
+  if (hasRequiredCallBound$1) return callBound$1;
+  hasRequiredCallBound$1 = 1;
   var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
   var callBind2 = requireCallBind();
   var $indexOf = callBind2(GetIntrinsic("String.prototype.indexOf"));
-  callBound = function callBoundIntrinsic(name, allowMissing) {
+  callBound$1 = function callBoundIntrinsic(name, allowMissing) {
     var intrinsic = GetIntrinsic(name, !!allowMissing);
     if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
       return callBind2(intrinsic);
     }
     return intrinsic;
   };
-  return callBound;
+  return callBound$1;
 }
 var isArguments;
 var hasRequiredIsArguments;
@@ -3291,7 +3294,7 @@ function requireIsArguments() {
   if (hasRequiredIsArguments) return isArguments;
   hasRequiredIsArguments = 1;
   var hasToStringTag = requireShams()();
-  var callBound2 = requireCallBound();
+  var callBound2 = requireCallBound$1();
   var $toString = callBound2("Object.prototype.toString");
   var isStandardArguments = function isArguments2(value) {
     if (hasToStringTag && value && typeof value === "object" && Symbol.toStringTag in value) {
@@ -3471,10 +3474,10 @@ function requireIsCallable() {
   };
   return isCallable;
 }
-var forEach_1;
+var forEach;
 var hasRequiredForEach;
 function requireForEach() {
-  if (hasRequiredForEach) return forEach_1;
+  if (hasRequiredForEach) return forEach;
   hasRequiredForEach = 1;
   var isCallable2 = requireIsCallable();
   var toStr = Object.prototype.toString;
@@ -3510,7 +3513,10 @@ function requireForEach() {
       }
     }
   };
-  var forEach = function forEach2(list, iterator, thisArg) {
+  function isArray(x) {
+    return toStr.call(x) === "[object Array]";
+  }
+  forEach = function forEach2(list, iterator, thisArg) {
     if (!isCallable2(iterator)) {
       throw new TypeError("iterator must be a function");
     }
@@ -3518,7 +3524,7 @@ function requireForEach() {
     if (arguments.length >= 3) {
       receiver = thisArg;
     }
-    if (toStr.call(list) === "[object Array]") {
+    if (isArray(list)) {
       forEachArray(list, iterator, receiver);
     } else if (typeof list === "string") {
       forEachString(list, iterator, receiver);
@@ -3526,8 +3532,7 @@ function requireForEach() {
       forEachObject(list, iterator, receiver);
     }
   };
-  forEach_1 = forEach;
-  return forEach_1;
+  return forEach;
 }
 var possibleTypedArrayNames;
 var hasRequiredPossibleTypedArrayNames;
@@ -3567,22 +3572,45 @@ function requireAvailableTypedArrays() {
   };
   return availableTypedArrays;
 }
+var callBound;
+var hasRequiredCallBound;
+function requireCallBound() {
+  if (hasRequiredCallBound) return callBound;
+  hasRequiredCallBound = 1;
+  var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
+  var callBindBasic = requireCallBindApplyHelpers();
+  var $indexOf = callBindBasic([GetIntrinsic("%String.prototype.indexOf%")]);
+  callBound = function callBoundIntrinsic(name, allowMissing) {
+    var intrinsic = (
+      /** @type {(this: unknown, ...args: unknown[]) => unknown} */
+      GetIntrinsic(name, !!allowMissing)
+    );
+    if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
+      return callBindBasic(
+        /** @type {const} */
+        [intrinsic]
+      );
+    }
+    return intrinsic;
+  };
+  return callBound;
+}
 var whichTypedArray;
 var hasRequiredWhichTypedArray;
 function requireWhichTypedArray() {
   if (hasRequiredWhichTypedArray) return whichTypedArray;
   hasRequiredWhichTypedArray = 1;
-  var forEach = requireForEach();
+  var forEach2 = requireForEach();
   var availableTypedArrays2 = /* @__PURE__ */ requireAvailableTypedArrays();
   var callBind2 = requireCallBind();
-  var callBound2 = requireCallBound();
+  var callBound2 = /* @__PURE__ */ requireCallBound();
   var gOPD2 = /* @__PURE__ */ requireGopd();
+  var getProto2 = requireGetProto();
   var $toString = callBound2("Object.prototype.toString");
   var hasToStringTag = requireShams()();
   var g = typeof globalThis === "undefined" ? commonjsGlobal : globalThis;
   var typedArrays = availableTypedArrays2();
   var $slice = callBound2("String.prototype.slice");
-  var getPrototypeOf = Object.getPrototypeOf;
   var $indexOf = callBound2("Array.prototype.indexOf", true) || function indexOf(array, value) {
     for (var i = 0; i < array.length; i += 1) {
       if (array[i] === value) {
@@ -3592,41 +3620,45 @@ function requireWhichTypedArray() {
     return -1;
   };
   var cache = { __proto__: null };
-  if (hasToStringTag && gOPD2 && getPrototypeOf) {
-    forEach(typedArrays, function(typedArray) {
+  if (hasToStringTag && gOPD2 && getProto2) {
+    forEach2(typedArrays, function(typedArray) {
       var arr = new g[typedArray]();
-      if (Symbol.toStringTag in arr) {
-        var proto = getPrototypeOf(arr);
+      if (Symbol.toStringTag in arr && getProto2) {
+        var proto = getProto2(arr);
         var descriptor = gOPD2(proto, Symbol.toStringTag);
-        if (!descriptor) {
-          var superProto = getPrototypeOf(proto);
+        if (!descriptor && proto) {
+          var superProto = getProto2(proto);
           descriptor = gOPD2(superProto, Symbol.toStringTag);
         }
         cache["$" + typedArray] = callBind2(descriptor.get);
       }
     });
   } else {
-    forEach(typedArrays, function(typedArray) {
+    forEach2(typedArrays, function(typedArray) {
       var arr = new g[typedArray]();
       var fn = arr.slice || arr.set;
       if (fn) {
-        cache["$" + typedArray] = callBind2(fn);
+        cache[
+          /** @type {`$${import('.').TypedArrayName}`} */
+          "$" + typedArray
+        ] = /** @type {import('./types').BoundSlice | import('./types').BoundSet} */
+        // @ts-expect-error TODO FIXME
+        callBind2(fn);
       }
     });
   }
   var tryTypedArrays = function tryAllTypedArrays(value) {
     var found = false;
-    forEach(
-      // eslint-disable-next-line no-extra-parens
-      /** @type {Record<`\$${TypedArrayName}`, Getter>} */
-      /** @type {any} */
+    forEach2(
+      /** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */
       cache,
       /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
       function(getter, typedArray) {
         if (!found) {
           try {
             if ("$" + getter(value) === typedArray) {
-              found = $slice(typedArray, 1);
+              found = /** @type {import('.').TypedArrayName} */
+              $slice(typedArray, 1);
             }
           } catch (e) {
           }
@@ -3637,17 +3669,16 @@ function requireWhichTypedArray() {
   };
   var trySlices = function tryAllSlices(value) {
     var found = false;
-    forEach(
-      // eslint-disable-next-line no-extra-parens
-      /** @type {Record<`\$${TypedArrayName}`, Getter>} */
-      /** @type {any} */
+    forEach2(
+      /** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */
       cache,
-      /** @type {(getter: typeof cache, name: `\$${import('.').TypedArrayName}`) => void} */
+      /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
       function(getter, name) {
         if (!found) {
           try {
             getter(value);
-            found = $slice(name, 1);
+            found = /** @type {import('.').TypedArrayName} */
+            $slice(name, 1);
           } catch (e) {
           }
         }
@@ -9362,9 +9393,10 @@ class ImportedXmlComponent extends XmlComponent {
     return convertToXmlComponent(xmlObj);
   }
   /**
-   * Converts the xml string to a XmlComponent tree.
+   * Creates an ImportedXmlComponent.
    *
-   * @param importedContent xml content of the imported component
+   * @param rootKey the root element name
+   * @param _attr optional attributes for the root element
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   constructor(rootKey, _attr) {
@@ -9656,6 +9688,9 @@ class Border extends IgnoreIfEmptyXmlComponent {
     if (options.right) {
       this.root.push(new BorderElement("w:right", options.right));
     }
+    if (options.between) {
+      this.root.push(new BorderElement("w:between", options.between));
+    }
   }
 }
 class ThematicBreak extends XmlComponent {
@@ -12896,17 +12931,12 @@ class Drawing extends XmlComponent {
   }
 }
 const convertDataURIToBinary = (dataURI) => {
-  if (typeof atob === "function") {
-    const BASE64_MARKER = ";base64,";
-    const base64Index = dataURI.indexOf(BASE64_MARKER);
-    const base64IndexWithOffset = base64Index === -1 ? 0 : base64Index + BASE64_MARKER.length;
-    return new Uint8Array(
-      atob(dataURI.substring(base64IndexWithOffset)).split("").map((c) => c.charCodeAt(0))
-    );
-  } else {
-    const b = require("buffer");
-    return new b.Buffer(dataURI, "base64");
-  }
+  const BASE64_MARKER = ";base64,";
+  const base64Index = dataURI.indexOf(BASE64_MARKER);
+  const base64IndexWithOffset = base64Index === -1 ? 0 : base64Index + BASE64_MARKER.length;
+  return new Uint8Array(
+    atob(dataURI.substring(base64IndexWithOffset)).split("").map((c) => c.charCodeAt(0))
+  );
 };
 const standardizeData = (data) => typeof data === "string" ? convertDataURIToBinary(data) : data;
 const createImageData = (options, key) => ({
@@ -13554,6 +13584,44 @@ class BookmarkEnd extends XmlComponent {
     this.root.push(attributes);
   }
 }
+var NumberedItemReferenceFormat = /* @__PURE__ */ ((NumberedItemReferenceFormat2) => {
+  NumberedItemReferenceFormat2["NONE"] = "none";
+  NumberedItemReferenceFormat2["RELATIVE"] = "relative";
+  NumberedItemReferenceFormat2["NO_CONTEXT"] = "no_context";
+  NumberedItemReferenceFormat2["FULL_CONTEXT"] = "full_context";
+  return NumberedItemReferenceFormat2;
+})(NumberedItemReferenceFormat || {});
+const SWITCH_MAP = {
+  [
+    "relative"
+    /* RELATIVE */
+  ]: "\\r",
+  [
+    "no_context"
+    /* NO_CONTEXT */
+  ]: "\\n",
+  [
+    "full_context"
+    /* FULL_CONTEXT */
+  ]: "\\w",
+  [
+    "none"
+    /* NONE */
+  ]: void 0
+};
+class NumberedItemReference extends SimpleField {
+  constructor(bookmarkId, cachedValue, options = {}) {
+    const {
+      hyperlink = true,
+      referenceFormat = "full_context"
+      /* FULL_CONTEXT */
+    } = options;
+    const baseInstruction = `REF ${bookmarkId}`;
+    const switches = [...hyperlink ? ["\\h"] : [], ...[SWITCH_MAP[referenceFormat]].filter((a) => !!a)];
+    const instruction = `${baseInstruction} ${switches.join(" ")}`;
+    super(instruction, cachedValue);
+  }
+}
 class OutlineLevel extends XmlComponent {
   constructor(level) {
     super("w:outlineLvl");
@@ -21684,6 +21752,8 @@ export {
   NumberFormat$1 as NumberFormat,
   NumberProperties,
   NumberValueElement,
+  NumberedItemReference,
+  NumberedItemReferenceFormat,
   Numbering,
   OnOffElement,
   OutlineLevel,