@tonyclaw/llm-inspector 1.6.0

package/.output/server/_libs/jszip.mjs

@@ -0,0 +1,3049 @@
+import { g as getDefaultExportFromCjs } from "./react.mjs";
+import { r as requireReadable } from "./readable-stream.mjs";
+import { r as requireLib$1 } from "./lie.mjs";
+import { r as requirePako } from "./pako.mjs";
+var utf8 = {};
+var utils = {};
+var support = {};
+var hasRequiredSupport;
+function requireSupport() {
+  if (hasRequiredSupport) return support;
+  hasRequiredSupport = 1;
+  support.base64 = true;
+  support.array = true;
+  support.string = true;
+  support.arraybuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
+  support.nodebuffer = typeof Buffer !== "undefined";
+  support.uint8array = typeof Uint8Array !== "undefined";
+  if (typeof ArrayBuffer === "undefined") {
+    support.blob = false;
+  } else {
+    var buffer = new ArrayBuffer(0);
+    try {
+      support.blob = new Blob([buffer], {
+        type: "application/zip"
+      }).size === 0;
+    } catch (e) {
+      try {
+        var Builder = self.BlobBuilder || self.WebKitBlobBuilder || self.MozBlobBuilder || self.MSBlobBuilder;
+        var builder = new Builder();
+        builder.append(buffer);
+        support.blob = builder.getBlob("application/zip").size === 0;
+      } catch (e2) {
+        support.blob = false;
+      }
+    }
+  }
+  try {
+    support.nodestream = !!requireReadable().Readable;
+  } catch (e) {
+    support.nodestream = false;
+  }
+  return support;
+}
+var base64 = {};
+var hasRequiredBase64;
+function requireBase64() {
+  if (hasRequiredBase64) return base64;
+  hasRequiredBase64 = 1;
+  var utils2 = /* @__PURE__ */ requireUtils();
+  var support2 = /* @__PURE__ */ requireSupport();
+  var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+  base64.encode = function(input) {
+    var output = [];
+    var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+    var i = 0, len = input.length, remainingBytes = len;
+    var isArray = utils2.getTypeOf(input) !== "string";
+    while (i < input.length) {
+      remainingBytes = len - i;
+      if (!isArray) {
+        chr1 = input.charCodeAt(i++);
+        chr2 = i < len ? input.charCodeAt(i++) : 0;
+        chr3 = i < len ? input.charCodeAt(i++) : 0;
+      } else {
+        chr1 = input[i++];
+        chr2 = i < len ? input[i++] : 0;
+        chr3 = i < len ? input[i++] : 0;
+      }
+      enc1 = chr1 >> 2;
+      enc2 = (chr1 & 3) << 4 | chr2 >> 4;
+      enc3 = remainingBytes > 1 ? (chr2 & 15) << 2 | chr3 >> 6 : 64;
+      enc4 = remainingBytes > 2 ? chr3 & 63 : 64;
+      output.push(_keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4));
+    }
+    return output.join("");
+  };
+  base64.decode = function(input) {
+    var chr1, chr2, chr3;
+    var enc1, enc2, enc3, enc4;
+    var i = 0, resultIndex = 0;
+    var dataUrlPrefix = "data:";
+    if (input.substr(0, dataUrlPrefix.length) === dataUrlPrefix) {
+      throw new Error("Invalid base64 input, it looks like a data url.");
+    }
+    input = input.replace(/[^A-Za-z0-9+/=]/g, "");
+    var totalLength = input.length * 3 / 4;
+    if (input.charAt(input.length - 1) === _keyStr.charAt(64)) {
+      totalLength--;
+    }
+    if (input.charAt(input.length - 2) === _keyStr.charAt(64)) {
+      totalLength--;
+    }
+    if (totalLength % 1 !== 0) {
+      throw new Error("Invalid base64 input, bad content length.");
+    }
+    var output;
+    if (support2.uint8array) {
+      output = new Uint8Array(totalLength | 0);
+    } else {
+      output = new Array(totalLength | 0);
+    }
+    while (i < input.length) {
+      enc1 = _keyStr.indexOf(input.charAt(i++));
+      enc2 = _keyStr.indexOf(input.charAt(i++));
+      enc3 = _keyStr.indexOf(input.charAt(i++));
+      enc4 = _keyStr.indexOf(input.charAt(i++));
+      chr1 = enc1 << 2 | enc2 >> 4;
+      chr2 = (enc2 & 15) << 4 | enc3 >> 2;
+      chr3 = (enc3 & 3) << 6 | enc4;
+      output[resultIndex++] = chr1;
+      if (enc3 !== 64) {
+        output[resultIndex++] = chr2;
+      }
+      if (enc4 !== 64) {
+        output[resultIndex++] = chr3;
+      }
+    }
+    return output;
+  };
+  return base64;
+}
+var nodejsUtils;
+var hasRequiredNodejsUtils;
+function requireNodejsUtils() {
+  if (hasRequiredNodejsUtils) return nodejsUtils;
+  hasRequiredNodejsUtils = 1;
+  nodejsUtils = {
+    /**
+     * True if this is running in Nodejs, will be undefined in a browser.
+     * In a browser, browserify won't include this file and the whole module
+     * will be resolved an empty object.
+     */
+    isNode: typeof Buffer !== "undefined",
+    /**
+     * Create a new nodejs Buffer from an existing content.
+     * @param {Object} data the data to pass to the constructor.
+     * @param {String} encoding the encoding to use.
+     * @return {Buffer} a new Buffer.
+     */
+    newBufferFrom: function(data, encoding) {
+      if (Buffer.from && Buffer.from !== Uint8Array.from) {
+        return Buffer.from(data, encoding);
+      } else {
+        if (typeof data === "number") {
+          throw new Error('The "data" argument must not be a number');
+        }
+        return new Buffer(data, encoding);
+      }
+    },
+    /**
+     * Create a new nodejs Buffer with the specified size.
+     * @param {Integer} size the size of the buffer.
+     * @return {Buffer} a new Buffer.
+     */
+    allocBuffer: function(size) {
+      if (Buffer.alloc) {
+        return Buffer.alloc(size);
+      } else {
+        var buf = new Buffer(size);
+        buf.fill(0);
+        return buf;
+      }
+    },
+    /**
+     * Find out if an object is a Buffer.
+     * @param {Object} b the object to test.
+     * @return {Boolean} true if the object is a Buffer, false otherwise.
+     */
+    isBuffer: function(b) {
+      return Buffer.isBuffer(b);
+    },
+    isStream: function(obj) {
+      return obj && typeof obj.on === "function" && typeof obj.pause === "function" && typeof obj.resume === "function";
+    }
+  };
+  return nodejsUtils;
+}
+var external;
+var hasRequiredExternal;
+function requireExternal() {
+  if (hasRequiredExternal) return external;
+  hasRequiredExternal = 1;
+  var ES6Promise = null;
+  if (typeof Promise !== "undefined") {
+    ES6Promise = Promise;
+  } else {
+    ES6Promise = /* @__PURE__ */ requireLib$1();
+  }
+  external = {
+    Promise: ES6Promise
+  };
+  return external;
+}
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  (function(exports$1) {
+    var support2 = /* @__PURE__ */ requireSupport();
+    var base642 = /* @__PURE__ */ requireBase64();
+    var nodejsUtils2 = /* @__PURE__ */ requireNodejsUtils();
+    var external2 = /* @__PURE__ */ requireExternal();
+    function string2binary(str) {
+      var result = null;
+      if (support2.uint8array) {
+        result = new Uint8Array(str.length);
+      } else {
+        result = new Array(str.length);
+      }
+      return stringToArrayLike(str, result);
+    }
+    exports$1.newBlob = function(part, type) {
+      exports$1.checkSupport("blob");
+      try {
+        return new Blob([part], {
+          type
+        });
+      } catch (e) {
+        try {
+          var Builder = self.BlobBuilder || self.WebKitBlobBuilder || self.MozBlobBuilder || self.MSBlobBuilder;
+          var builder = new Builder();
+          builder.append(part);
+          return builder.getBlob(type);
+        } catch (e2) {
+          throw new Error("Bug : can't construct the Blob.");
+        }
+      }
+    };
+    function identity(input) {
+      return input;
+    }
+    function stringToArrayLike(str, array) {
+      for (var i = 0; i < str.length; ++i) {
+        array[i] = str.charCodeAt(i) & 255;
+      }
+      return array;
+    }
+    var arrayToStringHelper = {
+      /**
+       * Transform an array of int into a string, chunk by chunk.
+       * See the performances notes on arrayLikeToString.
+       * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
+       * @param {String} type the type of the array.
+       * @param {Integer} chunk the chunk size.
+       * @return {String} the resulting string.
+       * @throws Error if the chunk is too big for the stack.
+       */
+      stringifyByChunk: function(array, type, chunk) {
+        var result = [], k = 0, len = array.length;
+        if (len <= chunk) {
+          return String.fromCharCode.apply(null, array);
+        }
+        while (k < len) {
+          if (type === "array" || type === "nodebuffer") {
+            result.push(String.fromCharCode.apply(null, array.slice(k, Math.min(k + chunk, len))));
+          } else {
+            result.push(String.fromCharCode.apply(null, array.subarray(k, Math.min(k + chunk, len))));
+          }
+          k += chunk;
+        }
+        return result.join("");
+      },
+      /**
+       * Call String.fromCharCode on every item in the array.
+       * This is the naive implementation, which generate A LOT of intermediate string.
+       * This should be used when everything else fail.
+       * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
+       * @return {String} the result.
+       */
+      stringifyByChar: function(array) {
+        var resultStr = "";
+        for (var i = 0; i < array.length; i++) {
+          resultStr += String.fromCharCode(array[i]);
+        }
+        return resultStr;
+      },
+      applyCanBeUsed: {
+        /**
+         * true if the browser accepts to use String.fromCharCode on Uint8Array
+         */
+        uint8array: (function() {
+          try {
+            return support2.uint8array && String.fromCharCode.apply(null, new Uint8Array(1)).length === 1;
+          } catch (e) {
+            return false;
+          }
+        })(),
+        /**
+         * true if the browser accepts to use String.fromCharCode on nodejs Buffer.
+         */
+        nodebuffer: (function() {
+          try {
+            return support2.nodebuffer && String.fromCharCode.apply(null, nodejsUtils2.allocBuffer(1)).length === 1;
+          } catch (e) {
+            return false;
+          }
+        })()
+      }
+    };
+    function arrayLikeToString(array) {
+      var chunk = 65536, type = exports$1.getTypeOf(array), canUseApply = true;
+      if (type === "uint8array") {
+        canUseApply = arrayToStringHelper.applyCanBeUsed.uint8array;
+      } else if (type === "nodebuffer") {
+        canUseApply = arrayToStringHelper.applyCanBeUsed.nodebuffer;
+      }
+      if (canUseApply) {
+        while (chunk > 1) {
+          try {
+            return arrayToStringHelper.stringifyByChunk(array, type, chunk);
+          } catch (e) {
+            chunk = Math.floor(chunk / 2);
+          }
+        }
+      }
+      return arrayToStringHelper.stringifyByChar(array);
+    }
+    exports$1.applyFromCharCode = arrayLikeToString;
+    function arrayLikeToArrayLike(arrayFrom, arrayTo) {
+      for (var i = 0; i < arrayFrom.length; i++) {
+        arrayTo[i] = arrayFrom[i];
+      }
+      return arrayTo;
+    }
+    var transform = {};
+    transform["string"] = {
+      "string": identity,
+      "array": function(input) {
+        return stringToArrayLike(input, new Array(input.length));
+      },
+      "arraybuffer": function(input) {
+        return transform["string"]["uint8array"](input).buffer;
+      },
+      "uint8array": function(input) {
+        return stringToArrayLike(input, new Uint8Array(input.length));
+      },
+      "nodebuffer": function(input) {
+        return stringToArrayLike(input, nodejsUtils2.allocBuffer(input.length));
+      }
+    };
+    transform["array"] = {
+      "string": arrayLikeToString,
+      "array": identity,
+      "arraybuffer": function(input) {
+        return new Uint8Array(input).buffer;
+      },
+      "uint8array": function(input) {
+        return new Uint8Array(input);
+      },
+      "nodebuffer": function(input) {
+        return nodejsUtils2.newBufferFrom(input);
+      }
+    };
+    transform["arraybuffer"] = {
+      "string": function(input) {
+        return arrayLikeToString(new Uint8Array(input));
+      },
+      "array": function(input) {
+        return arrayLikeToArrayLike(new Uint8Array(input), new Array(input.byteLength));
+      },
+      "arraybuffer": identity,
+      "uint8array": function(input) {
+        return new Uint8Array(input);
+      },
+      "nodebuffer": function(input) {
+        return nodejsUtils2.newBufferFrom(new Uint8Array(input));
+      }
+    };
+    transform["uint8array"] = {
+      "string": arrayLikeToString,
+      "array": function(input) {
+        return arrayLikeToArrayLike(input, new Array(input.length));
+      },
+      "arraybuffer": function(input) {
+        return input.buffer;
+      },
+      "uint8array": identity,
+      "nodebuffer": function(input) {
+        return nodejsUtils2.newBufferFrom(input);
+      }
+    };
+    transform["nodebuffer"] = {
+      "string": arrayLikeToString,
+      "array": function(input) {
+        return arrayLikeToArrayLike(input, new Array(input.length));
+      },
+      "arraybuffer": function(input) {
+        return transform["nodebuffer"]["uint8array"](input).buffer;
+      },
+      "uint8array": function(input) {
+        return arrayLikeToArrayLike(input, new Uint8Array(input.length));
+      },
+      "nodebuffer": identity
+    };
+    exports$1.transformTo = function(outputType, input) {
+      if (!input) {
+        input = "";
+      }
+      if (!outputType) {
+        return input;
+      }
+      exports$1.checkSupport(outputType);
+      var inputType = exports$1.getTypeOf(input);
+      var result = transform[inputType][outputType](input);
+      return result;
+    };
+    exports$1.resolve = function(path) {
+      var parts = path.split("/");
+      var result = [];
+      for (var index = 0; index < parts.length; index++) {
+        var part = parts[index];
+        if (part === "." || part === "" && index !== 0 && index !== parts.length - 1) {
+          continue;
+        } else if (part === "..") {
+          result.pop();
+        } else {
+          result.push(part);
+        }
+      }
+      return result.join("/");
+    };
+    exports$1.getTypeOf = function(input) {
+      if (typeof input === "string") {
+        return "string";
+      }
+      if (Object.prototype.toString.call(input) === "[object Array]") {
+        return "array";
+      }
+      if (support2.nodebuffer && nodejsUtils2.isBuffer(input)) {
+        return "nodebuffer";
+      }
+      if (support2.uint8array && input instanceof Uint8Array) {
+        return "uint8array";
+      }
+      if (support2.arraybuffer && input instanceof ArrayBuffer) {
+        return "arraybuffer";
+      }
+    };
+    exports$1.checkSupport = function(type) {
+      var supported = support2[type.toLowerCase()];
+      if (!supported) {
+        throw new Error(type + " is not supported by this platform");
+      }
+    };
+    exports$1.MAX_VALUE_16BITS = 65535;
+    exports$1.MAX_VALUE_32BITS = -1;
+    exports$1.pretty = function(str) {
+      var res = "", code, i;
+      for (i = 0; i < (str || "").length; i++) {
+        code = str.charCodeAt(i);
+        res += "\\x" + (code < 16 ? "0" : "") + code.toString(16).toUpperCase();
+      }
+      return res;
+    };
+    exports$1.delay = function(callback, args, self2) {
+      setImmediate(function() {
+        callback.apply(self2 || null, args || []);
+      });
+    };
+    exports$1.inherits = function(ctor, superCtor) {
+      var Obj = function() {
+      };
+      Obj.prototype = superCtor.prototype;
+      ctor.prototype = new Obj();
+    };
+    exports$1.extend = function() {
+      var result = {}, i, attr;
+      for (i = 0; i < arguments.length; i++) {
+        for (attr in arguments[i]) {
+          if (Object.prototype.hasOwnProperty.call(arguments[i], attr) && typeof result[attr] === "undefined") {
+            result[attr] = arguments[i][attr];
+          }
+        }
+      }
+      return result;
+    };
+    exports$1.prepareContent = function(name, inputData, isBinary, isOptimizedBinaryString, isBase64) {
+      var promise = external2.Promise.resolve(inputData).then(function(data) {
+        var isBlob = support2.blob && (data instanceof Blob || ["[object File]", "[object Blob]"].indexOf(Object.prototype.toString.call(data)) !== -1);
+        if (isBlob && typeof FileReader !== "undefined") {
+          return new external2.Promise(function(resolve, reject) {
+            var reader = new FileReader();
+            reader.onload = function(e) {
+              resolve(e.target.result);
+            };
+            reader.onerror = function(e) {
+              reject(e.target.error);
+            };
+            reader.readAsArrayBuffer(data);
+          });
+        } else {
+          return data;
+        }
+      });
+      return promise.then(function(data) {
+        var dataType = exports$1.getTypeOf(data);
+        if (!dataType) {
+          return external2.Promise.reject(
+            new Error("Can't read the data of '" + name + "'. Is it in a supported JavaScript type (String, Blob, ArrayBuffer, etc) ?")
+          );
+        }
+        if (dataType === "arraybuffer") {
+          data = exports$1.transformTo("uint8array", data);
+        } else if (dataType === "string") {
+          if (isBase64) {
+            data = base642.decode(data);
+          } else if (isBinary) {
+            if (isOptimizedBinaryString !== true) {
+              data = string2binary(data);
+            }
+          }
+        }
+        return data;
+      });
+    };
+  })(utils);
+  return utils;
+}
+var GenericWorker_1;
+var hasRequiredGenericWorker;
+function requireGenericWorker() {
+  if (hasRequiredGenericWorker) return GenericWorker_1;
+  hasRequiredGenericWorker = 1;
+  function GenericWorker(name) {
+    this.name = name || "default";
+    this.streamInfo = {};
+    this.generatedError = null;
+    this.extraStreamInfo = {};
+    this.isPaused = true;
+    this.isFinished = false;
+    this.isLocked = false;
+    this._listeners = {
+      "data": [],
+      "end": [],
+      "error": []
+    };
+    this.previous = null;
+  }
+  GenericWorker.prototype = {
+    /**
+     * Push a chunk to the next workers.
+     * @param {Object} chunk the chunk to push
+     */
+    push: function(chunk) {
+      this.emit("data", chunk);
+    },
+    /**
+     * End the stream.
+     * @return {Boolean} true if this call ended the worker, false otherwise.
+     */
+    end: function() {
+      if (this.isFinished) {
+        return false;
+      }
+      this.flush();
+      try {
+        this.emit("end");
+        this.cleanUp();
+        this.isFinished = true;
+      } catch (e) {
+        this.emit("error", e);
+      }
+      return true;
+    },
+    /**
+     * End the stream with an error.
+     * @param {Error} e the error which caused the premature end.
+     * @return {Boolean} true if this call ended the worker with an error, false otherwise.
+     */
+    error: function(e) {
+      if (this.isFinished) {
+        return false;
+      }
+      if (this.isPaused) {
+        this.generatedError = e;
+      } else {
+        this.isFinished = true;
+        this.emit("error", e);
+        if (this.previous) {
+          this.previous.error(e);
+        }
+        this.cleanUp();
+      }
+      return true;
+    },
+    /**
+     * Add a callback on an event.
+     * @param {String} name the name of the event (data, end, error)
+     * @param {Function} listener the function to call when the event is triggered
+     * @return {GenericWorker} the current object for chainability
+     */
+    on: function(name, listener) {
+      this._listeners[name].push(listener);
+      return this;
+    },
+    /**
+     * Clean any references when a worker is ending.
+     */
+    cleanUp: function() {
+      this.streamInfo = this.generatedError = this.extraStreamInfo = null;
+      this._listeners = [];
+    },
+    /**
+     * Trigger an event. This will call registered callback with the provided arg.
+     * @param {String} name the name of the event (data, end, error)
+     * @param {Object} arg the argument to call the callback with.
+     */
+    emit: function(name, arg) {
+      if (this._listeners[name]) {
+        for (var i = 0; i < this._listeners[name].length; i++) {
+          this._listeners[name][i].call(this, arg);
+        }
+      }
+    },
+    /**
+     * Chain a worker with an other.
+     * @param {Worker} next the worker receiving events from the current one.
+     * @return {worker} the next worker for chainability
+     */
+    pipe: function(next) {
+      return next.registerPrevious(this);
+    },
+    /**
+     * Same as `pipe` in the other direction.
+     * Using an API with `pipe(next)` is very easy.
+     * Implementing the API with the point of view of the next one registering
+     * a source is easier, see the ZipFileWorker.
+     * @param {Worker} previous the previous worker, sending events to this one
+     * @return {Worker} the current worker for chainability
+     */
+    registerPrevious: function(previous) {
+      if (this.isLocked) {
+        throw new Error("The stream '" + this + "' has already been used.");
+      }
+      this.streamInfo = previous.streamInfo;
+      this.mergeStreamInfo();
+      this.previous = previous;
+      var self2 = this;
+      previous.on("data", function(chunk) {
+        self2.processChunk(chunk);
+      });
+      previous.on("end", function() {
+        self2.end();
+      });
+      previous.on("error", function(e) {
+        self2.error(e);
+      });
+      return this;
+    },
+    /**
+     * Pause the stream so it doesn't send events anymore.
+     * @return {Boolean} true if this call paused the worker, false otherwise.
+     */
+    pause: function() {
+      if (this.isPaused || this.isFinished) {
+        return false;
+      }
+      this.isPaused = true;
+      if (this.previous) {
+        this.previous.pause();
+      }
+      return true;
+    },
+    /**
+     * Resume a paused stream.
+     * @return {Boolean} true if this call resumed the worker, false otherwise.
+     */
+    resume: function() {
+      if (!this.isPaused || this.isFinished) {
+        return false;
+      }
+      this.isPaused = false;
+      var withError = false;
+      if (this.generatedError) {
+        this.error(this.generatedError);
+        withError = true;
+      }
+      if (this.previous) {
+        this.previous.resume();
+      }
+      return !withError;
+    },
+    /**
+     * Flush any remaining bytes as the stream is ending.
+     */
+    flush: function() {
+    },
+    /**
+     * Process a chunk. This is usually the method overridden.
+     * @param {Object} chunk the chunk to process.
+     */
+    processChunk: function(chunk) {
+      this.push(chunk);
+    },
+    /**
+     * Add a key/value to be added in the workers chain streamInfo once activated.
+     * @param {String} key the key to use
+     * @param {Object} value the associated value
+     * @return {Worker} the current worker for chainability
+     */
+    withStreamInfo: function(key, value) {
+      this.extraStreamInfo[key] = value;
+      this.mergeStreamInfo();
+      return this;
+    },
+    /**
+     * Merge this worker's streamInfo into the chain's streamInfo.
+     */
+    mergeStreamInfo: function() {
+      for (var key in this.extraStreamInfo) {
+        if (!Object.prototype.hasOwnProperty.call(this.extraStreamInfo, key)) {
+          continue;
+        }
+        this.streamInfo[key] = this.extraStreamInfo[key];
+      }
+    },
+    /**
+     * Lock the stream to prevent further updates on the workers chain.
+     * After calling this method, all calls to pipe will fail.
+     */
+    lock: function() {
+      if (this.isLocked) {
+        throw new Error("The stream '" + this + "' has already been used.");
+      }
+      this.isLocked = true;
+      if (this.previous) {
+        this.previous.lock();
+      }
+    },
+    /**
+     *
+     * Pretty print the workers chain.
+     */
+    toString: function() {
+      var me = "Worker " + this.name;
+      if (this.previous) {
+        return this.previous + " -> " + me;
+      } else {
+        return me;
+      }
+    }
+  };
+  GenericWorker_1 = GenericWorker;
+  return GenericWorker_1;
+}
+var hasRequiredUtf8;
+function requireUtf8() {
+  if (hasRequiredUtf8) return utf8;
+  hasRequiredUtf8 = 1;
+  (function(exports$1) {
+    var utils2 = /* @__PURE__ */ requireUtils();
+    var support2 = /* @__PURE__ */ requireSupport();
+    var nodejsUtils2 = /* @__PURE__ */ requireNodejsUtils();
+    var GenericWorker = /* @__PURE__ */ requireGenericWorker();
+    var _utf8len = new Array(256);
+    for (var i = 0; i < 256; i++) {
+      _utf8len[i] = i >= 252 ? 6 : i >= 248 ? 5 : i >= 240 ? 4 : i >= 224 ? 3 : i >= 192 ? 2 : 1;
+    }
+    _utf8len[254] = _utf8len[254] = 1;
+    var string2buf = function(str) {
+      var buf, c, c2, m_pos, i2, str_len = str.length, buf_len = 0;
+      for (m_pos = 0; m_pos < str_len; m_pos++) {
+        c = str.charCodeAt(m_pos);
+        if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
+          c2 = str.charCodeAt(m_pos + 1);
+          if ((c2 & 64512) === 56320) {
+            c = 65536 + (c - 55296 << 10) + (c2 - 56320);
+            m_pos++;
+          }
+        }
+        buf_len += c < 128 ? 1 : c < 2048 ? 2 : c < 65536 ? 3 : 4;
+      }
+      if (support2.uint8array) {
+        buf = new Uint8Array(buf_len);
+      } else {
+        buf = new Array(buf_len);
+      }
+      for (i2 = 0, m_pos = 0; i2 < buf_len; m_pos++) {
+        c = str.charCodeAt(m_pos);
+        if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
+          c2 = str.charCodeAt(m_pos + 1);
+          if ((c2 & 64512) === 56320) {
+            c = 65536 + (c - 55296 << 10) + (c2 - 56320);
+            m_pos++;
+          }
+        }
+        if (c < 128) {
+          buf[i2++] = c;
+        } else if (c < 2048) {
+          buf[i2++] = 192 | c >>> 6;
+          buf[i2++] = 128 | c & 63;
+        } else if (c < 65536) {
+          buf[i2++] = 224 | c >>> 12;
+          buf[i2++] = 128 | c >>> 6 & 63;
+          buf[i2++] = 128 | c & 63;
+        } else {
+          buf[i2++] = 240 | c >>> 18;
+          buf[i2++] = 128 | c >>> 12 & 63;
+          buf[i2++] = 128 | c >>> 6 & 63;
+          buf[i2++] = 128 | c & 63;
+        }
+      }
+      return buf;
+    };
+    var utf8border = function(buf, max) {
+      var pos;
+      max = max || buf.length;
+      if (max > buf.length) {
+        max = buf.length;
+      }
+      pos = max - 1;
+      while (pos >= 0 && (buf[pos] & 192) === 128) {
+        pos--;
+      }
+      if (pos < 0) {
+        return max;
+      }
+      if (pos === 0) {
+        return max;
+      }
+      return pos + _utf8len[buf[pos]] > max ? pos : max;
+    };
+    var buf2string = function(buf) {
+      var i2, out, c, c_len;
+      var len = buf.length;
+      var utf16buf = new Array(len * 2);
+      for (out = 0, i2 = 0; i2 < len; ) {
+        c = buf[i2++];
+        if (c < 128) {
+          utf16buf[out++] = c;
+          continue;
+        }
+        c_len = _utf8len[c];
+        if (c_len > 4) {
+          utf16buf[out++] = 65533;
+          i2 += c_len - 1;
+          continue;
+        }
+        c &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7;
+        while (c_len > 1 && i2 < len) {
+          c = c << 6 | buf[i2++] & 63;
+          c_len--;
+        }
+        if (c_len > 1) {
+          utf16buf[out++] = 65533;
+          continue;
+        }
+        if (c < 65536) {
+          utf16buf[out++] = c;
+        } else {
+          c -= 65536;
+          utf16buf[out++] = 55296 | c >> 10 & 1023;
+          utf16buf[out++] = 56320 | c & 1023;
+        }
+      }
+      if (utf16buf.length !== out) {
+        if (utf16buf.subarray) {
+          utf16buf = utf16buf.subarray(0, out);
+        } else {
+          utf16buf.length = out;
+        }
+      }
+      return utils2.applyFromCharCode(utf16buf);
+    };
+    exports$1.utf8encode = function utf8encode(str) {
+      if (support2.nodebuffer) {
+        return nodejsUtils2.newBufferFrom(str, "utf-8");
+      }
+      return string2buf(str);
+    };
+    exports$1.utf8decode = function utf8decode(buf) {
+      if (support2.nodebuffer) {
+        return utils2.transformTo("nodebuffer", buf).toString("utf-8");
+      }
+      buf = utils2.transformTo(support2.uint8array ? "uint8array" : "array", buf);
+      return buf2string(buf);
+    };
+    function Utf8DecodeWorker() {
+      GenericWorker.call(this, "utf-8 decode");
+      this.leftOver = null;
+    }
+    utils2.inherits(Utf8DecodeWorker, GenericWorker);
+    Utf8DecodeWorker.prototype.processChunk = function(chunk) {
+      var data = utils2.transformTo(support2.uint8array ? "uint8array" : "array", chunk.data);
+      if (this.leftOver && this.leftOver.length) {
+        if (support2.uint8array) {
+          var previousData = data;
+          data = new Uint8Array(previousData.length + this.leftOver.length);
+          data.set(this.leftOver, 0);
+          data.set(previousData, this.leftOver.length);
+        } else {
+          data = this.leftOver.concat(data);
+        }
+        this.leftOver = null;
+      }
+      var nextBoundary = utf8border(data);
+      var usableData = data;
+      if (nextBoundary !== data.length) {
+        if (support2.uint8array) {
+          usableData = data.subarray(0, nextBoundary);
+          this.leftOver = data.subarray(nextBoundary, data.length);
+        } else {
+          usableData = data.slice(0, nextBoundary);
+          this.leftOver = data.slice(nextBoundary, data.length);
+        }
+      }
+      this.push({
+        data: exports$1.utf8decode(usableData),
+        meta: chunk.meta
+      });
+    };
+    Utf8DecodeWorker.prototype.flush = function() {
+      if (this.leftOver && this.leftOver.length) {
+        this.push({
+          data: exports$1.utf8decode(this.leftOver),
+          meta: {}
+        });
+        this.leftOver = null;
+      }
+    };
+    exports$1.Utf8DecodeWorker = Utf8DecodeWorker;
+    function Utf8EncodeWorker() {
+      GenericWorker.call(this, "utf-8 encode");
+    }
+    utils2.inherits(Utf8EncodeWorker, GenericWorker);
+    Utf8EncodeWorker.prototype.processChunk = function(chunk) {
+      this.push({
+        data: exports$1.utf8encode(chunk.data),
+        meta: chunk.meta
+      });
+    };
+    exports$1.Utf8EncodeWorker = Utf8EncodeWorker;
+  })(utf8);
+  return utf8;
+}
+var ConvertWorker_1;
+var hasRequiredConvertWorker;
+function requireConvertWorker() {
+  if (hasRequiredConvertWorker) return ConvertWorker_1;
+  hasRequiredConvertWorker = 1;
+  var GenericWorker = /* @__PURE__ */ requireGenericWorker();
+  var utils2 = /* @__PURE__ */ requireUtils();
+  function ConvertWorker(destType) {
+    GenericWorker.call(this, "ConvertWorker to " + destType);
+    this.destType = destType;
+  }
+  utils2.inherits(ConvertWorker, GenericWorker);
+  ConvertWorker.prototype.processChunk = function(chunk) {
+    this.push({
+      data: utils2.transformTo(this.destType, chunk.data),
+      meta: chunk.meta
+    });
+  };
+  ConvertWorker_1 = ConvertWorker;
+  return ConvertWorker_1;
+}
+var NodejsStreamOutputAdapter_1;
+var hasRequiredNodejsStreamOutputAdapter;
+function requireNodejsStreamOutputAdapter() {
+  if (hasRequiredNodejsStreamOutputAdapter) return NodejsStreamOutputAdapter_1;
+  hasRequiredNodejsStreamOutputAdapter = 1;
+  var Readable = requireReadable().Readable;
+  var utils2 = /* @__PURE__ */ requireUtils();
+  utils2.inherits(NodejsStreamOutputAdapter, Readable);
+  function NodejsStreamOutputAdapter(helper, options, updateCb) {
+    Readable.call(this, options);
+    this._helper = helper;
+    var self2 = this;
+    helper.on("data", function(data, meta) {
+      if (!self2.push(data)) {
+        self2._helper.pause();
+      }
+      if (updateCb) {
+        updateCb(meta);
+      }
+    }).on("error", function(e) {
+      self2.emit("error", e);
+    }).on("end", function() {
+      self2.push(null);
+    });
+  }
+  NodejsStreamOutputAdapter.prototype._read = function() {
+    this._helper.resume();
+  };
+  NodejsStreamOutputAdapter_1 = NodejsStreamOutputAdapter;
+  return NodejsStreamOutputAdapter_1;
+}
+var StreamHelper_1;
+var hasRequiredStreamHelper;
+function requireStreamHelper() {
+  if (hasRequiredStreamHelper) return StreamHelper_1;
+  hasRequiredStreamHelper = 1;
+  var utils2 = /* @__PURE__ */ requireUtils();
+  var ConvertWorker = /* @__PURE__ */ requireConvertWorker();
+  var GenericWorker = /* @__PURE__ */ requireGenericWorker();
+  var base642 = /* @__PURE__ */ requireBase64();
+  var support2 = /* @__PURE__ */ requireSupport();
+  var external2 = /* @__PURE__ */ requireExternal();
+  var NodejsStreamOutputAdapter = null;
+  if (support2.nodestream) {
+    try {
+      NodejsStreamOutputAdapter = /* @__PURE__ */ requireNodejsStreamOutputAdapter();
+    } catch (e) {
+    }
+  }
+  function transformZipOutput(type, content, mimeType) {
+    switch (type) {
+      case "blob":
+        return utils2.newBlob(utils2.transformTo("arraybuffer", content), mimeType);
+      case "base64":
+        return base642.encode(content);
+      default:
+        return utils2.transformTo(type, content);
+    }
+  }
+  function concat(type, dataArray) {
+    var i, index = 0, res = null, totalLength = 0;
+    for (i = 0; i < dataArray.length; i++) {
+      totalLength += dataArray[i].length;
+    }
+    switch (type) {
+      case "string":
+        return dataArray.join("");
+      case "array":
+        return Array.prototype.concat.apply([], dataArray);
+      case "uint8array":
+        res = new Uint8Array(totalLength);
+        for (i = 0; i < dataArray.length; i++) {
+          res.set(dataArray[i], index);
+          index += dataArray[i].length;
+        }
+        return res;
+      case "nodebuffer":
+        return Buffer.concat(dataArray);
+      default:
+        throw new Error("concat : unsupported type '" + type + "'");
+    }
+  }
+  function accumulate(helper, updateCallback) {
+    return new external2.Promise(function(resolve, reject) {
+      var dataArray = [];
+      var chunkType = helper._internalType, resultType = helper._outputType, mimeType = helper._mimeType;
+      helper.on("data", function(data, meta) {
+        dataArray.push(data);
+        if (updateCallback) {
+          updateCallback(meta);
+        }
+      }).on("error", function(err) {
+        dataArray = [];
+        reject(err);
+      }).on("end", function() {
+        try {
+          var result = transformZipOutput(resultType, concat(chunkType, dataArray), mimeType);
+          resolve(result);
+        } catch (e) {
+          reject(e);
+        }
+        dataArray = [];
+      }).resume();
+    });
+  }
+  function StreamHelper(worker, outputType, mimeType) {
+    var internalType = outputType;
+    switch (outputType) {
+      case "blob":
+      case "arraybuffer":
+        internalType = "uint8array";
+        break;
+      case "base64":
+        internalType = "string";
+        break;
+    }
+    try {
+      this._internalType = internalType;
+      this._outputType = outputType;
+      this._mimeType = mimeType;
+      utils2.checkSupport(internalType);
+      this._worker = worker.pipe(new ConvertWorker(internalType));
+      worker.lock();
+    } catch (e) {
+      this._worker = new GenericWorker("error");
+      this._worker.error(e);
+    }
+  }
+  StreamHelper.prototype = {
+    /**
+     * Listen a StreamHelper, accumulate its content and concatenate it into a
+     * complete block.
+     * @param {Function} updateCb the update callback.
+     * @return Promise the promise for the accumulation.
+     */
+    accumulate: function(updateCb) {
+      return accumulate(this, updateCb);
+    },
+    /**
+     * Add a listener on an event triggered on a stream.
+     * @param {String} evt the name of the event
+     * @param {Function} fn the listener
+     * @return {StreamHelper} the current helper.
+     */
+    on: function(evt, fn) {
+      var self2 = this;
+      if (evt === "data") {
+        this._worker.on(evt, function(chunk) {
+          fn.call(self2, chunk.data, chunk.meta);
+        });
+      } else {
+        this._worker.on(evt, function() {
+          utils2.delay(fn, arguments, self2);
+        });
+      }
+      return this;
+    },
+    /**
+     * Resume the flow of chunks.
+     * @return {StreamHelper} the current helper.
+     */
+    resume: function() {
+      utils2.delay(this._worker.resume, [], this._worker);
+      return this;
+    },
+    /**
+     * Pause the flow of chunks.
+     * @return {StreamHelper} the current helper.
+     */
+    pause: function() {
+      this._worker.pause();
+      return this;
+    },
+    /**
+     * Return a nodejs stream for this helper.
+     * @param {Function} updateCb the update callback.
+     * @return {NodejsStreamOutputAdapter} the nodejs stream.
+     */
+    toNodejsStream: function(updateCb) {
+      utils2.checkSupport("nodestream");
+      if (this._outputType !== "nodebuffer") {
+        throw new Error(this._outputType + " is not supported by this method");
+      }
+      return new NodejsStreamOutputAdapter(this, {
+        objectMode: this._outputType !== "nodebuffer"
+      }, updateCb);
+    }
+  };
+  StreamHelper_1 = StreamHelper;
+  return StreamHelper_1;
+}
+var defaults = {};
+var hasRequiredDefaults;
+function requireDefaults() {
+  if (hasRequiredDefaults) return defaults;
+  hasRequiredDefaults = 1;
+  defaults.base64 = false;
+  defaults.binary = false;
+  defaults.dir = false;
+  defaults.createFolders = true;
+  defaults.date = null;
+  defaults.compression = null;
+  defaults.compressionOptions = null;
+  defaults.comment = null;
+  defaults.unixPermissions = null;
+  defaults.dosPermissions = null;
+  return defaults;
+}
+var DataWorker_1;
+var hasRequiredDataWorker;
+function requireDataWorker() {
+  if (hasRequiredDataWorker) return DataWorker_1;
+  hasRequiredDataWorker = 1;
+  var utils2 = /* @__PURE__ */ requireUtils();
+  var GenericWorker = /* @__PURE__ */ requireGenericWorker();
+  var DEFAULT_BLOCK_SIZE = 16 * 1024;
+  function DataWorker(dataP) {
+    GenericWorker.call(this, "DataWorker");
+    var self2 = this;
+    this.dataIsReady = false;
+    this.index = 0;
+    this.max = 0;
+    this.data = null;
+    this.type = "";
+    this._tickScheduled = false;
+    dataP.then(function(data) {
+      self2.dataIsReady = true;
+      self2.data = data;
+      self2.max = data && data.length || 0;
+      self2.type = utils2.getTypeOf(data);
+      if (!self2.isPaused) {
+        self2._tickAndRepeat();
+      }
+    }, function(e) {
+      self2.error(e);
+    });
+  }
+  utils2.inherits(DataWorker, GenericWorker);
+  DataWorker.prototype.cleanUp = function() {
+    GenericWorker.prototype.cleanUp.call(this);
+    this.data = null;
+  };
+  DataWorker.prototype.resume = function() {
+    if (!GenericWorker.prototype.resume.call(this)) {
+      return false;
+    }
+    if (!this._tickScheduled && this.dataIsReady) {
+      this._tickScheduled = true;
+      utils2.delay(this._tickAndRepeat, [], this);
+    }
+    return true;
+  };
+  DataWorker.prototype._tickAndRepeat = function() {
+    this._tickScheduled = false;
+    if (this.isPaused || this.isFinished) {
+      return;
+    }
+    this._tick();
+    if (!this.isFinished) {
+      utils2.delay(this._tickAndRepeat, [], this);
+      this._tickScheduled = true;
+    }
+  };
+  DataWorker.prototype._tick = function() {
+    if (this.isPaused || this.isFinished) {
+      return false;
+    }
+    var size = DEFAULT_BLOCK_SIZE;
+    var data = null, nextIndex = Math.min(this.max, this.index + size);
+    if (this.index >= this.max) {
+      return this.end();
+    } else {
+      switch (this.type) {
+        case "string":
+          data = this.data.substring(this.index, nextIndex);
+          break;
+        case "uint8array":
+          data = this.data.subarray(this.index, nextIndex);
+          break;
+        case "array":
+        case "nodebuffer":
+          data = this.data.slice(this.index, nextIndex);
+          break;
+      }
+      this.index = nextIndex;
+      return this.push({
+        data,
+        meta: {
+          percent: this.max ? this.index / this.max * 100 : 0
+        }
+      });
+    }
+  };
+  DataWorker_1 = DataWorker;
+  return DataWorker_1;
+}
+var crc32_1;
+var hasRequiredCrc32;
+function requireCrc32() {
+  if (hasRequiredCrc32) return crc32_1;
+  hasRequiredCrc32 = 1;
+  var utils2 = /* @__PURE__ */ requireUtils();
+  function makeTable() {
+    var c, table = [];
+    for (var n = 0; n < 256; n++) {
+      c = n;
+      for (var k = 0; k < 8; k++) {
+        c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+      }
+      table[n] = c;
+    }
+    return table;
+  }
+  var crcTable = makeTable();
+  function crc32(crc, buf, len, pos) {
+    var t = crcTable, end = pos + len;
+    crc = crc ^ -1;
+    for (var i = pos; i < end; i++) {
+      crc = crc >>> 8 ^ t[(crc ^ buf[i]) & 255];
+    }
+    return crc ^ -1;
+  }
+  function crc32str(crc, str, len, pos) {
+    var t = crcTable, end = pos + len;
+    crc = crc ^ -1;
+    for (var i = pos; i < end; i++) {
+      crc = crc >>> 8 ^ t[(crc ^ str.charCodeAt(i)) & 255];
+    }
+    return crc ^ -1;
+  }
+  crc32_1 = function crc32wrapper(input, crc) {
+    if (typeof input === "undefined" || !input.length) {
+      return 0;
+    }
+    var isArray = utils2.getTypeOf(input) !== "string";
+    if (isArray) {
+      return crc32(crc | 0, input, input.length, 0);
+    } else {
+      return crc32str(crc | 0, input, input.length, 0);
+    }
+  };
+  return crc32_1;
+}
+var Crc32Probe_1;
+var hasRequiredCrc32Probe;
+function requireCrc32Probe() {
+  if (hasRequiredCrc32Probe) return Crc32Probe_1;
+  hasRequiredCrc32Probe = 1;
+  var GenericWorker = /* @__PURE__ */ requireGenericWorker();
+  var crc32 = /* @__PURE__ */ requireCrc32();
+  var utils2 = /* @__PURE__ */ requireUtils();
+  function Crc32Probe() {
+    GenericWorker.call(this, "Crc32Probe");
+    this.withStreamInfo("crc32", 0);
+  }
+  utils2.inherits(Crc32Probe, GenericWorker);
+  Crc32Probe.prototype.processChunk = function(chunk) {
+    this.streamInfo.crc32 = crc32(chunk.data, this.streamInfo.crc32 || 0);
+    this.push(chunk);
+  };
+  Crc32Probe_1 = Crc32Probe;
+  return Crc32Probe_1;
+}
+var DataLengthProbe_1;
+var hasRequiredDataLengthProbe;
+function requireDataLengthProbe() {
+  if (hasRequiredDataLengthProbe) return DataLengthProbe_1;
+  hasRequiredDataLengthProbe = 1;
+  var utils2 = /* @__PURE__ */ requireUtils();
+  var GenericWorker = /* @__PURE__ */ requireGenericWorker();
+  function DataLengthProbe(propName) {
+    GenericWorker.call(this, "DataLengthProbe for " + propName);
+    this.propName = propName;
+    this.withStreamInfo(propName, 0);
+  }
+  utils2.inherits(DataLengthProbe, GenericWorker);
+  DataLengthProbe.prototype.processChunk = function(chunk) {
+    if (chunk) {
+      var length = this.streamInfo[this.propName] || 0;
+      this.streamInfo[this.propName] = length + chunk.data.length;
+    }
+    GenericWorker.prototype.processChunk.call(this, chunk);
+  };
+  DataLengthProbe_1 = DataLengthProbe;
+  return DataLengthProbe_1;
+}
+var compressedObject;
+var hasRequiredCompressedObject;
+function requireCompressedObject() {
+  if (hasRequiredCompressedObject) return compressedObject;
+  hasRequiredCompressedObject = 1;
+  var external2 = /* @__PURE__ */ requireExternal();
+  var DataWorker = /* @__PURE__ */ requireDataWorker();
+  var Crc32Probe = /* @__PURE__ */ requireCrc32Probe();
+  var DataLengthProbe = /* @__PURE__ */ requireDataLengthProbe();
+  function CompressedObject(compressedSize, uncompressedSize, crc32, compression, data) {
+    this.compressedSize = compressedSize;
+    this.uncompressedSize = uncompressedSize;
+    this.crc32 = crc32;
+    this.compression = compression;
+    this.compressedContent = data;
+  }
+  CompressedObject.prototype = {
+    /**
+     * Create a worker to get the uncompressed content.
+     * @return {GenericWorker} the worker.
+     */
+    getContentWorker: function() {
+      var worker = new DataWorker(external2.Promise.resolve(this.compressedContent)).pipe(this.compression.uncompressWorker()).pipe(new DataLengthProbe("data_length"));
+      var that = this;
+      worker.on("end", function() {
+        if (this.streamInfo["data_length"] !== that.uncompressedSize) {
+          throw new Error("Bug : uncompressed data size mismatch");
+        }
+      });
+      return worker;
+    },
+    /**
+     * Create a worker to get the compressed content.
+     * @return {GenericWorker} the worker.
+     */
+    getCompressedWorker: function() {
+      return new DataWorker(external2.Promise.resolve(this.compressedContent)).withStreamInfo("compressedSize", this.compressedSize).withStreamInfo("uncompressedSize", this.uncompressedSize).withStreamInfo("crc32", this.crc32).withStreamInfo("compression", this.compression);
+    }
+  };
+  CompressedObject.createWorkerFrom = function(uncompressedWorker, compression, compressionOptions) {
+    return uncompressedWorker.pipe(new Crc32Probe()).pipe(new DataLengthProbe("uncompressedSize")).pipe(compression.compressWorker(compressionOptions)).pipe(new DataLengthProbe("compressedSize")).withStreamInfo("compression", compression);
+  };
+  compressedObject = CompressedObject;
+  return compressedObject;
+}
+var zipObject;
+var hasRequiredZipObject;
+function requireZipObject() {
+  if (hasRequiredZipObject) return zipObject;
+  hasRequiredZipObject = 1;
+  var StreamHelper = /* @__PURE__ */ requireStreamHelper();
+  var DataWorker = /* @__PURE__ */ requireDataWorker();
+  var utf82 = /* @__PURE__ */ requireUtf8();
+  var CompressedObject = /* @__PURE__ */ requireCompressedObject();
+  var GenericWorker = /* @__PURE__ */ requireGenericWorker();
+  var ZipObject = function(name, data, options) {
+    this.name = name;
+    this.dir = options.dir;
+    this.date = options.date;
+    this.comment = options.comment;
+    this.unixPermissions = options.unixPermissions;
+    this.dosPermissions = options.dosPermissions;
+    this._data = data;
+    this._dataBinary = options.binary;
+    this.options = {
+      compression: options.compression,
+      compressionOptions: options.compressionOptions
+    };
+  };
+  ZipObject.prototype = {
+    /**
+     * Create an internal stream for the content of this object.
+     * @param {String} type the type of each chunk.
+     * @return StreamHelper the stream.
+     */
+    internalStream: function(type) {
+      var result = null, outputType = "string";
+      try {
+        if (!type) {
+          throw new Error("No output type specified.");
+        }
+        outputType = type.toLowerCase();
+        var askUnicodeString = outputType === "string" || outputType === "text";
+        if (outputType === "binarystring" || outputType === "text") {
+          outputType = "string";
+        }
+        result = this._decompressWorker();
+        var isUnicodeString = !this._dataBinary;
+        if (isUnicodeString && !askUnicodeString) {
+          result = result.pipe(new utf82.Utf8EncodeWorker());
+        }
+        if (!isUnicodeString && askUnicodeString) {
+          result = result.pipe(new utf82.Utf8DecodeWorker());
+        }
+      } catch (e) {
+        result = new GenericWorker("error");
+        result.error(e);
+      }
+      return new StreamHelper(result, outputType, "");
+    },
+    /**
+     * Prepare the content in the asked type.
+     * @param {String} type the type of the result.
+     * @param {Function} onUpdate a function to call on each internal update.
+     * @return Promise the promise of the result.
+     */
+    async: function(type, onUpdate) {
+      return this.internalStream(type).accumulate(onUpdate);
+    },
+    /**
+     * Prepare the content as a nodejs stream.
+     * @param {String} type the type of each chunk.
+     * @param {Function} onUpdate a function to call on each internal update.
+     * @return Stream the stream.
+     */
+    nodeStream: function(type, onUpdate) {
+      return this.internalStream(type || "nodebuffer").toNodejsStream(onUpdate);
+    },
+    /**
+     * Return a worker for the compressed content.
+     * @private
+     * @param {Object} compression the compression object to use.
+     * @param {Object} compressionOptions the options to use when compressing.
+     * @return Worker the worker.
+     */
+    _compressWorker: function(compression, compressionOptions) {
+      if (this._data instanceof CompressedObject && this._data.compression.magic === compression.magic) {
+        return this._data.getCompressedWorker();
+      } else {
+        var result = this._decompressWorker();
+        if (!this._dataBinary) {
+          result = result.pipe(new utf82.Utf8EncodeWorker());
+        }
+        return CompressedObject.createWorkerFrom(result, compression, compressionOptions);
+      }
+    },
+    /**
+     * Return a worker for the decompressed content.
+     * @private
+     * @return Worker the worker.
+     */
+    _decompressWorker: function() {
+      if (this._data instanceof CompressedObject) {
+        return this._data.getContentWorker();
+      } else if (this._data instanceof GenericWorker) {
+        return this._data;
+      } else {
+        return new DataWorker(this._data);
+      }
+    }
+  };
+  var removedMethods = ["asText", "asBinary", "asNodeBuffer", "asUint8Array", "asArrayBuffer"];
+  var removedFn = function() {
+    throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.");
+  };
+  for (var i = 0; i < removedMethods.length; i++) {
+    ZipObject.prototype[removedMethods[i]] = removedFn;
+  }
+  zipObject = ZipObject;
+  return zipObject;
+}
+var generate = {};
+var compressions = {};
+var flate = {};
+var hasRequiredFlate;
+function requireFlate() {
+  if (hasRequiredFlate) return flate;
+  hasRequiredFlate = 1;
+  var USE_TYPEDARRAY = typeof Uint8Array !== "undefined" && typeof Uint16Array !== "undefined" && typeof Uint32Array !== "undefined";
+  var pako = /* @__PURE__ */ requirePako();
+  var utils2 = /* @__PURE__ */ requireUtils();
+  var GenericWorker = /* @__PURE__ */ requireGenericWorker();
+  var ARRAY_TYPE = USE_TYPEDARRAY ? "uint8array" : "array";
+  flate.magic = "\b\0";
+  function FlateWorker(action, options) {
+    GenericWorker.call(this, "FlateWorker/" + action);
+    this._pako = null;
+    this._pakoAction = action;
+    this._pakoOptions = options;
+    this.meta = {};
+  }
+  utils2.inherits(FlateWorker, GenericWorker);
+  FlateWorker.prototype.processChunk = function(chunk) {
+    this.meta = chunk.meta;
+    if (this._pako === null) {
+      this._createPako();
+    }
+    this._pako.push(utils2.transformTo(ARRAY_TYPE, chunk.data), false);
+  };
+  FlateWorker.prototype.flush = function() {
+    GenericWorker.prototype.flush.call(this);
+    if (this._pako === null) {
+      this._createPako();
+    }
+    this._pako.push([], true);
+  };
+  FlateWorker.prototype.cleanUp = function() {
+    GenericWorker.prototype.cleanUp.call(this);
+    this._pako = null;
+  };
+  FlateWorker.prototype._createPako = function() {
+    this._pako = new pako[this._pakoAction]({
+      raw: true,
+      level: this._pakoOptions.level || -1
+      // default compression
+    });
+    var self2 = this;
+    this._pako.onData = function(data) {
+      self2.push({
+        data,
+        meta: self2.meta
+      });
+    };
+  };
+  flate.compressWorker = function(compressionOptions) {
+    return new FlateWorker("Deflate", compressionOptions);
+  };
+  flate.uncompressWorker = function() {
+    return new FlateWorker("Inflate", {});
+  };
+  return flate;
+}
+var hasRequiredCompressions;
+function requireCompressions() {
+  if (hasRequiredCompressions) return compressions;
+  hasRequiredCompressions = 1;
+  var GenericWorker = /* @__PURE__ */ requireGenericWorker();
+  compressions.STORE = {
+    magic: "\0\0",
+    compressWorker: function() {
+      return new GenericWorker("STORE compression");
+    },
+    uncompressWorker: function() {
+      return new GenericWorker("STORE decompression");
+    }
+  };
+  compressions.DEFLATE = /* @__PURE__ */ requireFlate();
+  return compressions;
+}
+var signature = {};
+var hasRequiredSignature;
+function requireSignature() {
+  if (hasRequiredSignature) return signature;
+  hasRequiredSignature = 1;
+  signature.LOCAL_FILE_HEADER = "PK";
+  signature.CENTRAL_FILE_HEADER = "PK
";
+  signature.CENTRAL_DIRECTORY_END = "PK";
+  signature.ZIP64_CENTRAL_DIRECTORY_LOCATOR = "PK\x07";
+  signature.ZIP64_CENTRAL_DIRECTORY_END = "PK";
+  signature.DATA_DESCRIPTOR = "PK\x07\b";
+  return signature;
+}
+var ZipFileWorker_1;
+var hasRequiredZipFileWorker;
+function requireZipFileWorker() {
+  if (hasRequiredZipFileWorker) return ZipFileWorker_1;
+  hasRequiredZipFileWorker = 1;
+  var utils2 = /* @__PURE__ */ requireUtils();
+  var GenericWorker = /* @__PURE__ */ requireGenericWorker();
+  var utf82 = /* @__PURE__ */ requireUtf8();
+  var crc32 = /* @__PURE__ */ requireCrc32();
+  var signature2 = /* @__PURE__ */ requireSignature();
+  var decToHex = function(dec, bytes) {
+    var hex = "", i;
+    for (i = 0; i < bytes; i++) {
+      hex += String.fromCharCode(dec & 255);
+      dec = dec >>> 8;
+    }
+    return hex;
+  };
+  var generateUnixExternalFileAttr = function(unixPermissions, isDir) {
+    var result = unixPermissions;
+    if (!unixPermissions) {
+      result = isDir ? 16893 : 33204;
+    }
+    return (result & 65535) << 16;
+  };
+  var generateDosExternalFileAttr = function(dosPermissions) {
+    return (dosPermissions || 0) & 63;
+  };
+  var generateZipParts = function(streamInfo, streamedContent, streamingEnded, offset, platform, encodeFileName) {
+    var file = streamInfo["file"], compression = streamInfo["compression"], useCustomEncoding = encodeFileName !== utf82.utf8encode, encodedFileName = utils2.transformTo("string", encodeFileName(file.name)), utfEncodedFileName = utils2.transformTo("string", utf82.utf8encode(file.name)), comment = file.comment, encodedComment = utils2.transformTo("string", encodeFileName(comment)), utfEncodedComment = utils2.transformTo("string", utf82.utf8encode(comment)), useUTF8ForFileName = utfEncodedFileName.length !== file.name.length, useUTF8ForComment = utfEncodedComment.length !== comment.length, dosTime, dosDate, extraFields = "", unicodePathExtraField = "", unicodeCommentExtraField = "", dir = file.dir, date = file.date;
+    var dataInfo = {
+      crc32: 0,
+      compressedSize: 0,
+      uncompressedSize: 0
+    };
+    if (!streamedContent || streamingEnded) {
+      dataInfo.crc32 = streamInfo["crc32"];
+      dataInfo.compressedSize = streamInfo["compressedSize"];
+      dataInfo.uncompressedSize = streamInfo["uncompressedSize"];
+    }
+    var bitflag = 0;
+    if (streamedContent) {
+      bitflag |= 8;
+    }
+    if (!useCustomEncoding && (useUTF8ForFileName || useUTF8ForComment)) {
+      bitflag |= 2048;
+    }
+    var extFileAttr = 0;
+    var versionMadeBy = 0;
+    if (dir) {
+      extFileAttr |= 16;
+    }
+    if (platform === "UNIX") {
+      versionMadeBy = 798;
+      extFileAttr |= generateUnixExternalFileAttr(file.unixPermissions, dir);
+    } else {
+      versionMadeBy = 20;
+      extFileAttr |= generateDosExternalFileAttr(file.dosPermissions);
+    }
+    dosTime = date.getUTCHours();
+    dosTime = dosTime << 6;
+    dosTime = dosTime | date.getUTCMinutes();
+    dosTime = dosTime << 5;
+    dosTime = dosTime | date.getUTCSeconds() / 2;
+    dosDate = date.getUTCFullYear() - 1980;
+    dosDate = dosDate << 4;
+    dosDate = dosDate | date.getUTCMonth() + 1;
+    dosDate = dosDate << 5;
+    dosDate = dosDate | date.getUTCDate();
+    if (useUTF8ForFileName) {
+      unicodePathExtraField = // Version
+      decToHex(1, 1) + // NameCRC32
+      decToHex(crc32(encodedFileName), 4) + // UnicodeName
+      utfEncodedFileName;
+      extraFields += // Info-ZIP Unicode Path Extra Field
+      "up" + // size
+      decToHex(unicodePathExtraField.length, 2) + // content
+      unicodePathExtraField;
+    }
+    if (useUTF8ForComment) {
+      unicodeCommentExtraField = // Version
+      decToHex(1, 1) + // CommentCRC32
+      decToHex(crc32(encodedComment), 4) + // UnicodeName
+      utfEncodedComment;
+      extraFields += // Info-ZIP Unicode Path Extra Field
+      "uc" + // size
+      decToHex(unicodeCommentExtraField.length, 2) + // content
+      unicodeCommentExtraField;
+    }
+    var header = "";
+    header += "\n\0";
+    header += decToHex(bitflag, 2);
+    header += compression.magic;
+    header += decToHex(dosTime, 2);
+    header += decToHex(dosDate, 2);
+    header += decToHex(dataInfo.crc32, 4);
+    header += decToHex(dataInfo.compressedSize, 4);
+    header += decToHex(dataInfo.uncompressedSize, 4);
+    header += decToHex(encodedFileName.length, 2);
+    header += decToHex(extraFields.length, 2);
+    var fileRecord = signature2.LOCAL_FILE_HEADER + header + encodedFileName + extraFields;
+    var dirRecord = signature2.CENTRAL_FILE_HEADER + // version made by (00: DOS)
+    decToHex(versionMadeBy, 2) + // file header (common to file and central directory)
+    header + // file comment length
+    decToHex(encodedComment.length, 2) + // disk number start
+    "\0\0\0\0" + // external file attributes
+    decToHex(extFileAttr, 4) + // relative offset of local header
+    decToHex(offset, 4) + // file name
+    encodedFileName + // extra field
+    extraFields + // file comment
+    encodedComment;
+    return {
+      fileRecord,
+      dirRecord
+    };
+  };
+  var generateCentralDirectoryEnd = function(entriesCount, centralDirLength, localDirLength, comment, encodeFileName) {
+    var dirEnd = "";
+    var encodedComment = utils2.transformTo("string", encodeFileName(comment));
+    dirEnd = signature2.CENTRAL_DIRECTORY_END + // number of this disk
+    "\0\0\0\0" + // total number of entries in the central directory on this disk
+    decToHex(entriesCount, 2) + // total number of entries in the central directory
+    decToHex(entriesCount, 2) + // size of the central directory   4 bytes
+    decToHex(centralDirLength, 4) + // offset of start of central directory with respect to the starting disk number
+    decToHex(localDirLength, 4) + // .ZIP file comment length
+    decToHex(encodedComment.length, 2) + // .ZIP file comment
+    encodedComment;
+    return dirEnd;
+  };
+  var generateDataDescriptors = function(streamInfo) {
+    var descriptor = "";
+    descriptor = signature2.DATA_DESCRIPTOR + // crc-32                          4 bytes
+    decToHex(streamInfo["crc32"], 4) + // compressed size                 4 bytes
+    decToHex(streamInfo["compressedSize"], 4) + // uncompressed size               4 bytes
+    decToHex(streamInfo["uncompressedSize"], 4);
+    return descriptor;
+  };
+  function ZipFileWorker(streamFiles, comment, platform, encodeFileName) {
+    GenericWorker.call(this, "ZipFileWorker");
+    this.bytesWritten = 0;
+    this.zipComment = comment;
+    this.zipPlatform = platform;
+    this.encodeFileName = encodeFileName;
+    this.streamFiles = streamFiles;
+    this.accumulate = false;
+    this.contentBuffer = [];
+    this.dirRecords = [];
+    this.currentSourceOffset = 0;
+    this.entriesCount = 0;
+    this.currentFile = null;
+    this._sources = [];
+  }
+  utils2.inherits(ZipFileWorker, GenericWorker);
+  ZipFileWorker.prototype.push = function(chunk) {
+    var currentFilePercent = chunk.meta.percent || 0;
+    var entriesCount = this.entriesCount;
+    var remainingFiles = this._sources.length;
+    if (this.accumulate) {
+      this.contentBuffer.push(chunk);
+    } else {
+      this.bytesWritten += chunk.data.length;
+      GenericWorker.prototype.push.call(this, {
+        data: chunk.data,
+        meta: {
+          currentFile: this.currentFile,
+          percent: entriesCount ? (currentFilePercent + 100 * (entriesCount - remainingFiles - 1)) / entriesCount : 100
+        }
+      });
+    }
+  };
+  ZipFileWorker.prototype.openedSource = function(streamInfo) {
+    this.currentSourceOffset = this.bytesWritten;
+    this.currentFile = streamInfo["file"].name;
+    var streamedContent = this.streamFiles && !streamInfo["file"].dir;
+    if (streamedContent) {
+      var record = generateZipParts(streamInfo, streamedContent, false, this.currentSourceOffset, this.zipPlatform, this.encodeFileName);
+      this.push({
+        data: record.fileRecord,
+        meta: { percent: 0 }
+      });
+    } else {
+      this.accumulate = true;
+    }
+  };
+  ZipFileWorker.prototype.closedSource = function(streamInfo) {
+    this.accumulate = false;
+    var streamedContent = this.streamFiles && !streamInfo["file"].dir;
+    var record = generateZipParts(streamInfo, streamedContent, true, this.currentSourceOffset, this.zipPlatform, this.encodeFileName);
+    this.dirRecords.push(record.dirRecord);
+    if (streamedContent) {
+      this.push({
+        data: generateDataDescriptors(streamInfo),
+        meta: { percent: 100 }
+      });
+    } else {
+      this.push({
+        data: record.fileRecord,
+        meta: { percent: 0 }
+      });
+      while (this.contentBuffer.length) {
+        this.push(this.contentBuffer.shift());
+      }
+    }
+    this.currentFile = null;
+  };
+  ZipFileWorker.prototype.flush = function() {
+    var localDirLength = this.bytesWritten;
+    for (var i = 0; i < this.dirRecords.length; i++) {
+      this.push({
+        data: this.dirRecords[i],
+        meta: { percent: 100 }
+      });
+    }
+    var centralDirLength = this.bytesWritten - localDirLength;
+    var dirEnd = generateCentralDirectoryEnd(this.dirRecords.length, centralDirLength, localDirLength, this.zipComment, this.encodeFileName);
+    this.push({
+      data: dirEnd,
+      meta: { percent: 100 }
+    });
+  };
+  ZipFileWorker.prototype.prepareNextSource = function() {
+    this.previous = this._sources.shift();
+    this.openedSource(this.previous.streamInfo);
+    if (this.isPaused) {
+      this.previous.pause();
+    } else {
+      this.previous.resume();
+    }
+  };
+  ZipFileWorker.prototype.registerPrevious = function(previous) {
+    this._sources.push(previous);
+    var self2 = this;
+    previous.on("data", function(chunk) {
+      self2.processChunk(chunk);
+    });
+    previous.on("end", function() {
+      self2.closedSource(self2.previous.streamInfo);
+      if (self2._sources.length) {
+        self2.prepareNextSource();
+      } else {
+        self2.end();
+      }
+    });
+    previous.on("error", function(e) {
+      self2.error(e);
+    });
+    return this;
+  };
+  ZipFileWorker.prototype.resume = function() {
+    if (!GenericWorker.prototype.resume.call(this)) {
+      return false;
+    }
+    if (!this.previous && this._sources.length) {
+      this.prepareNextSource();
+      return true;
+    }
+    if (!this.previous && !this._sources.length && !this.generatedError) {
+      this.end();
+      return true;
+    }
+  };
+  ZipFileWorker.prototype.error = function(e) {
+    var sources = this._sources;
+    if (!GenericWorker.prototype.error.call(this, e)) {
+      return false;
+    }
+    for (var i = 0; i < sources.length; i++) {
+      try {
+        sources[i].error(e);
+      } catch (e2) {
+      }
+    }
+    return true;
+  };
+  ZipFileWorker.prototype.lock = function() {
+    GenericWorker.prototype.lock.call(this);
+    var sources = this._sources;
+    for (var i = 0; i < sources.length; i++) {
+      sources[i].lock();
+    }
+  };
+  ZipFileWorker_1 = ZipFileWorker;
+  return ZipFileWorker_1;
+}
+var hasRequiredGenerate;
+function requireGenerate() {
+  if (hasRequiredGenerate) return generate;
+  hasRequiredGenerate = 1;
+  var compressions2 = /* @__PURE__ */ requireCompressions();
+  var ZipFileWorker = /* @__PURE__ */ requireZipFileWorker();
+  var getCompression = function(fileCompression, zipCompression) {
+    var compressionName = fileCompression || zipCompression;
+    var compression = compressions2[compressionName];
+    if (!compression) {
+      throw new Error(compressionName + " is not a valid compression method !");
+    }
+    return compression;
+  };
+  generate.generateWorker = function(zip, options, comment) {
+    var zipFileWorker = new ZipFileWorker(options.streamFiles, comment, options.platform, options.encodeFileName);
+    var entriesCount = 0;
+    try {
+      zip.forEach(function(relativePath, file) {
+        entriesCount++;
+        var compression = getCompression(file.options.compression, options.compression);
+        var compressionOptions = file.options.compressionOptions || options.compressionOptions || {};
+        var dir = file.dir, date = file.date;
+        file._compressWorker(compression, compressionOptions).withStreamInfo("file", {
+          name: relativePath,
+          dir,
+          date,
+          comment: file.comment || "",
+          unixPermissions: file.unixPermissions,
+          dosPermissions: file.dosPermissions
+        }).pipe(zipFileWorker);
+      });
+      zipFileWorker.entriesCount = entriesCount;
+    } catch (e) {
+      zipFileWorker.error(e);
+    }
+    return zipFileWorker;
+  };
+  return generate;
+}
+var NodejsStreamInputAdapter_1;
+var hasRequiredNodejsStreamInputAdapter;
+function requireNodejsStreamInputAdapter() {
+  if (hasRequiredNodejsStreamInputAdapter) return NodejsStreamInputAdapter_1;
+  hasRequiredNodejsStreamInputAdapter = 1;
+  var utils2 = /* @__PURE__ */ requireUtils();
+  var GenericWorker = /* @__PURE__ */ requireGenericWorker();
+  function NodejsStreamInputAdapter(filename, stream) {
+    GenericWorker.call(this, "Nodejs stream input adapter for " + filename);
+    this._upstreamEnded = false;
+    this._bindStream(stream);
+  }
+  utils2.inherits(NodejsStreamInputAdapter, GenericWorker);
+  NodejsStreamInputAdapter.prototype._bindStream = function(stream) {
+    var self2 = this;
+    this._stream = stream;
+    stream.pause();
+    stream.on("data", function(chunk) {
+      self2.push({
+        data: chunk,
+        meta: {
+          percent: 0
+        }
+      });
+    }).on("error", function(e) {
+      if (self2.isPaused) {
+        this.generatedError = e;
+      } else {
+        self2.error(e);
+      }
+    }).on("end", function() {
+      if (self2.isPaused) {
+        self2._upstreamEnded = true;
+      } else {
+        self2.end();
+      }
+    });
+  };
+  NodejsStreamInputAdapter.prototype.pause = function() {
+    if (!GenericWorker.prototype.pause.call(this)) {
+      return false;
+    }
+    this._stream.pause();
+    return true;
+  };
+  NodejsStreamInputAdapter.prototype.resume = function() {
+    if (!GenericWorker.prototype.resume.call(this)) {
+      return false;
+    }
+    if (this._upstreamEnded) {
+      this.end();
+    } else {
+      this._stream.resume();
+    }
+    return true;
+  };
+  NodejsStreamInputAdapter_1 = NodejsStreamInputAdapter;
+  return NodejsStreamInputAdapter_1;
+}
+var object;
+var hasRequiredObject;
+function requireObject() {
+  if (hasRequiredObject) return object;
+  hasRequiredObject = 1;
+  var utf82 = /* @__PURE__ */ requireUtf8();
+  var utils2 = /* @__PURE__ */ requireUtils();
+  var GenericWorker = /* @__PURE__ */ requireGenericWorker();
+  var StreamHelper = /* @__PURE__ */ requireStreamHelper();
+  var defaults2 = /* @__PURE__ */ requireDefaults();
+  var CompressedObject = /* @__PURE__ */ requireCompressedObject();
+  var ZipObject = /* @__PURE__ */ requireZipObject();
+  var generate2 = /* @__PURE__ */ requireGenerate();
+  var nodejsUtils2 = /* @__PURE__ */ requireNodejsUtils();
+  var NodejsStreamInputAdapter = /* @__PURE__ */ requireNodejsStreamInputAdapter();
+  var fileAdd = function(name, data, originalOptions) {
+    var dataType = utils2.getTypeOf(data), parent;
+    var o = utils2.extend(originalOptions || {}, defaults2);
+    o.date = o.date || /* @__PURE__ */ new Date();
+    if (o.compression !== null) {
+      o.compression = o.compression.toUpperCase();
+    }
+    if (typeof o.unixPermissions === "string") {
+      o.unixPermissions = parseInt(o.unixPermissions, 8);
+    }
+    if (o.unixPermissions && o.unixPermissions & 16384) {
+      o.dir = true;
+    }
+    if (o.dosPermissions && o.dosPermissions & 16) {
+      o.dir = true;
+    }
+    if (o.dir) {
+      name = forceTrailingSlash(name);
+    }
+    if (o.createFolders && (parent = parentFolder(name))) {
+      folderAdd.call(this, parent, true);
+    }
+    var isUnicodeString = dataType === "string" && o.binary === false && o.base64 === false;
+    if (!originalOptions || typeof originalOptions.binary === "undefined") {
+      o.binary = !isUnicodeString;
+    }
+    var isCompressedEmpty = data instanceof CompressedObject && data.uncompressedSize === 0;
+    if (isCompressedEmpty || o.dir || !data || data.length === 0) {
+      o.base64 = false;
+      o.binary = true;
+      data = "";
+      o.compression = "STORE";
+      dataType = "string";
+    }
+    var zipObjectContent = null;
+    if (data instanceof CompressedObject || data instanceof GenericWorker) {
+      zipObjectContent = data;
+    } else if (nodejsUtils2.isNode && nodejsUtils2.isStream(data)) {
+      zipObjectContent = new NodejsStreamInputAdapter(name, data);
+    } else {
+      zipObjectContent = utils2.prepareContent(name, data, o.binary, o.optimizedBinaryString, o.base64);
+    }
+    var object2 = new ZipObject(name, zipObjectContent, o);
+    this.files[name] = object2;
+  };
+  var parentFolder = function(path) {
+    if (path.slice(-1) === "/") {
+      path = path.substring(0, path.length - 1);
+    }
+    var lastSlash = path.lastIndexOf("/");
+    return lastSlash > 0 ? path.substring(0, lastSlash) : "";
+  };
+  var forceTrailingSlash = function(path) {
+    if (path.slice(-1) !== "/") {
+      path += "/";
+    }
+    return path;
+  };
+  var folderAdd = function(name, createFolders) {
+    createFolders = typeof createFolders !== "undefined" ? createFolders : defaults2.createFolders;
+    name = forceTrailingSlash(name);
+    if (!this.files[name]) {
+      fileAdd.call(this, name, null, {
+        dir: true,
+        createFolders
+      });
+    }
+    return this.files[name];
+  };
+  function isRegExp(object2) {
+    return Object.prototype.toString.call(object2) === "[object RegExp]";
+  }
+  var out = {
+    /**
+     * @see loadAsync
+     */
+    load: function() {
+      throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.");
+    },
+    /**
+     * Call a callback function for each entry at this folder level.
+     * @param {Function} cb the callback function:
+     * function (relativePath, file) {...}
+     * It takes 2 arguments : the relative path and the file.
+     */
+    forEach: function(cb) {
+      var filename, relativePath, file;
+      for (filename in this.files) {
+        file = this.files[filename];
+        relativePath = filename.slice(this.root.length, filename.length);
+        if (relativePath && filename.slice(0, this.root.length) === this.root) {
+          cb(relativePath, file);
+        }
+      }
+    },
+    /**
+     * Filter nested files/folders with the specified function.
+     * @param {Function} search the predicate to use :
+     * function (relativePath, file) {...}
+     * It takes 2 arguments : the relative path and the file.
+     * @return {Array} An array of matching elements.
+     */
+    filter: function(search) {
+      var result = [];
+      this.forEach(function(relativePath, entry) {
+        if (search(relativePath, entry)) {
+          result.push(entry);
+        }
+      });
+      return result;
+    },
+    /**
+     * Add a file to the zip file, or search a file.
+     * @param   {string|RegExp} name The name of the file to add (if data is defined),
+     * the name of the file to find (if no data) or a regex to match files.
+     * @param   {String|ArrayBuffer|Uint8Array|Buffer} data  The file data, either raw or base64 encoded
+     * @param   {Object} o     File options
+     * @return  {JSZip|Object|Array} this JSZip object (when adding a file),
+     * a file (when searching by string) or an array of files (when searching by regex).
+     */
+    file: function(name, data, o) {
+      if (arguments.length === 1) {
+        if (isRegExp(name)) {
+          var regexp = name;
+          return this.filter(function(relativePath, file) {
+            return !file.dir && regexp.test(relativePath);
+          });
+        } else {
+          var obj = this.files[this.root + name];
+          if (obj && !obj.dir) {
+            return obj;
+          } else {
+            return null;
+          }
+        }
+      } else {
+        name = this.root + name;
+        fileAdd.call(this, name, data, o);
+      }
+      return this;
+    },
+    /**
+     * Add a directory to the zip file, or search.
+     * @param   {String|RegExp} arg The name of the directory to add, or a regex to search folders.
+     * @return  {JSZip} an object with the new directory as the root, or an array containing matching folders.
+     */
+    folder: function(arg) {
+      if (!arg) {
+        return this;
+      }
+      if (isRegExp(arg)) {
+        return this.filter(function(relativePath, file) {
+          return file.dir && arg.test(relativePath);
+        });
+      }
+      var name = this.root + arg;
+      var newFolder = folderAdd.call(this, name);
+      var ret = this.clone();
+      ret.root = newFolder.name;
+      return ret;
+    },
+    /**
+     * Delete a file, or a directory and all sub-files, from the zip
+     * @param {string} name the name of the file to delete
+     * @return {JSZip} this JSZip object
+     */
+    remove: function(name) {
+      name = this.root + name;
+      var file = this.files[name];
+      if (!file) {
+        if (name.slice(-1) !== "/") {
+          name += "/";
+        }
+        file = this.files[name];
+      }
+      if (file && !file.dir) {
+        delete this.files[name];
+      } else {
+        var kids = this.filter(function(relativePath, file2) {
+          return file2.name.slice(0, name.length) === name;
+        });
+        for (var i = 0; i < kids.length; i++) {
+          delete this.files[kids[i].name];
+        }
+      }
+      return this;
+    },
+    /**
+     * @deprecated This method has been removed in JSZip 3.0, please check the upgrade guide.
+     */
+    generate: function() {
+      throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.");
+    },
+    /**
+     * Generate the complete zip file as an internal stream.
+     * @param {Object} options the options to generate the zip file :
+     * - compression, "STORE" by default.
+     * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob.
+     * @return {StreamHelper} the streamed zip file.
+     */
+    generateInternalStream: function(options) {
+      var worker, opts = {};
+      try {
+        opts = utils2.extend(options || {}, {
+          streamFiles: false,
+          compression: "STORE",
+          compressionOptions: null,
+          type: "",
+          platform: "DOS",
+          comment: null,
+          mimeType: "application/zip",
+          encodeFileName: utf82.utf8encode
+        });
+        opts.type = opts.type.toLowerCase();
+        opts.compression = opts.compression.toUpperCase();
+        if (opts.type === "binarystring") {
+          opts.type = "string";
+        }
+        if (!opts.type) {
+          throw new Error("No output type specified.");
+        }
+        utils2.checkSupport(opts.type);
+        if (opts.platform === "darwin" || opts.platform === "freebsd" || opts.platform === "linux" || opts.platform === "sunos") {
+          opts.platform = "UNIX";
+        }
+        if (opts.platform === "win32") {
+          opts.platform = "DOS";
+        }
+        var comment = opts.comment || this.comment || "";
+        worker = generate2.generateWorker(this, opts, comment);
+      } catch (e) {
+        worker = new GenericWorker("error");
+        worker.error(e);
+      }
+      return new StreamHelper(worker, opts.type || "string", opts.mimeType);
+    },
+    /**
+     * Generate the complete zip file asynchronously.
+     * @see generateInternalStream
+     */
+    generateAsync: function(options, onUpdate) {
+      return this.generateInternalStream(options).accumulate(onUpdate);
+    },
+    /**
+     * Generate the complete zip file asynchronously.
+     * @see generateInternalStream
+     */
+    generateNodeStream: function(options, onUpdate) {
+      options = options || {};
+      if (!options.type) {
+        options.type = "nodebuffer";
+      }
+      return this.generateInternalStream(options).toNodejsStream(onUpdate);
+    }
+  };
+  object = out;
+  return object;
+}
+var DataReader_1;
+var hasRequiredDataReader;
+function requireDataReader() {
+  if (hasRequiredDataReader) return DataReader_1;
+  hasRequiredDataReader = 1;
+  var utils2 = /* @__PURE__ */ requireUtils();
+  function DataReader(data) {
+    this.data = data;
+    this.length = data.length;
+    this.index = 0;
+    this.zero = 0;
+  }
+  DataReader.prototype = {
+    /**
+     * Check that the offset will not go too far.
+     * @param {string} offset the additional offset to check.
+     * @throws {Error} an Error if the offset is out of bounds.
+     */
+    checkOffset: function(offset) {
+      this.checkIndex(this.index + offset);
+    },
+    /**
+     * Check that the specified index will not be too far.
+     * @param {string} newIndex the index to check.
+     * @throws {Error} an Error if the index is out of bounds.
+     */
+    checkIndex: function(newIndex) {
+      if (this.length < this.zero + newIndex || newIndex < 0) {
+        throw new Error("End of data reached (data length = " + this.length + ", asked index = " + newIndex + "). Corrupted zip ?");
+      }
+    },
+    /**
+     * Change the index.
+     * @param {number} newIndex The new index.
+     * @throws {Error} if the new index is out of the data.
+     */
+    setIndex: function(newIndex) {
+      this.checkIndex(newIndex);
+      this.index = newIndex;
+    },
+    /**
+     * Skip the next n bytes.
+     * @param {number} n the number of bytes to skip.
+     * @throws {Error} if the new index is out of the data.
+     */
+    skip: function(n) {
+      this.setIndex(this.index + n);
+    },
+    /**
+     * Get the byte at the specified index.
+     * @param {number} i the index to use.
+     * @return {number} a byte.
+     */
+    byteAt: function() {
+    },
+    /**
+     * Get the next number with a given byte size.
+     * @param {number} size the number of bytes to read.
+     * @return {number} the corresponding number.
+     */
+    readInt: function(size) {
+      var result = 0, i;
+      this.checkOffset(size);
+      for (i = this.index + size - 1; i >= this.index; i--) {
+        result = (result << 8) + this.byteAt(i);
+      }
+      this.index += size;
+      return result;
+    },
+    /**
+     * Get the next string with a given byte size.
+     * @param {number} size the number of bytes to read.
+     * @return {string} the corresponding string.
+     */
+    readString: function(size) {
+      return utils2.transformTo("string", this.readData(size));
+    },
+    /**
+     * Get raw data without conversion, <size> bytes.
+     * @param {number} size the number of bytes to read.
+     * @return {Object} the raw data, implementation specific.
+     */
+    readData: function() {
+    },
+    /**
+     * Find the last occurrence of a zip signature (4 bytes).
+     * @param {string} sig the signature to find.
+     * @return {number} the index of the last occurrence, -1 if not found.
+     */
+    lastIndexOfSignature: function() {
+    },
+    /**
+     * Read the signature (4 bytes) at the current position and compare it with sig.
+     * @param {string} sig the expected signature
+     * @return {boolean} true if the signature matches, false otherwise.
+     */
+    readAndCheckSignature: function() {
+    },
+    /**
+     * Get the next date.
+     * @return {Date} the date.
+     */
+    readDate: function() {
+      var dostime = this.readInt(4);
+      return new Date(Date.UTC(
+        (dostime >> 25 & 127) + 1980,
+        // year
+        (dostime >> 21 & 15) - 1,
+        // month
+        dostime >> 16 & 31,
+        // day
+        dostime >> 11 & 31,
+        // hour
+        dostime >> 5 & 63,
+        // minute
+        (dostime & 31) << 1
+      ));
+    }
+  };
+  DataReader_1 = DataReader;
+  return DataReader_1;
+}
+var ArrayReader_1;
+var hasRequiredArrayReader;
+function requireArrayReader() {
+  if (hasRequiredArrayReader) return ArrayReader_1;
+  hasRequiredArrayReader = 1;
+  var DataReader = /* @__PURE__ */ requireDataReader();
+  var utils2 = /* @__PURE__ */ requireUtils();
+  function ArrayReader(data) {
+    DataReader.call(this, data);
+    for (var i = 0; i < this.data.length; i++) {
+      data[i] = data[i] & 255;
+    }
+  }
+  utils2.inherits(ArrayReader, DataReader);
+  ArrayReader.prototype.byteAt = function(i) {
+    return this.data[this.zero + i];
+  };
+  ArrayReader.prototype.lastIndexOfSignature = function(sig) {
+    var sig0 = sig.charCodeAt(0), sig1 = sig.charCodeAt(1), sig2 = sig.charCodeAt(2), sig3 = sig.charCodeAt(3);
+    for (var i = this.length - 4; i >= 0; --i) {
+      if (this.data[i] === sig0 && this.data[i + 1] === sig1 && this.data[i + 2] === sig2 && this.data[i + 3] === sig3) {
+        return i - this.zero;
+      }
+    }
+    return -1;
+  };
+  ArrayReader.prototype.readAndCheckSignature = function(sig) {
+    var sig0 = sig.charCodeAt(0), sig1 = sig.charCodeAt(1), sig2 = sig.charCodeAt(2), sig3 = sig.charCodeAt(3), data = this.readData(4);
+    return sig0 === data[0] && sig1 === data[1] && sig2 === data[2] && sig3 === data[3];
+  };
+  ArrayReader.prototype.readData = function(size) {
+    this.checkOffset(size);
+    if (size === 0) {
+      return [];
+    }
+    var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
+    this.index += size;
+    return result;
+  };
+  ArrayReader_1 = ArrayReader;
+  return ArrayReader_1;
+}
+var StringReader_1;
+var hasRequiredStringReader;
+function requireStringReader() {
+  if (hasRequiredStringReader) return StringReader_1;
+  hasRequiredStringReader = 1;
+  var DataReader = /* @__PURE__ */ requireDataReader();
+  var utils2 = /* @__PURE__ */ requireUtils();
+  function StringReader(data) {
+    DataReader.call(this, data);
+  }
+  utils2.inherits(StringReader, DataReader);
+  StringReader.prototype.byteAt = function(i) {
+    return this.data.charCodeAt(this.zero + i);
+  };
+  StringReader.prototype.lastIndexOfSignature = function(sig) {
+    return this.data.lastIndexOf(sig) - this.zero;
+  };
+  StringReader.prototype.readAndCheckSignature = function(sig) {
+    var data = this.readData(4);
+    return sig === data;
+  };
+  StringReader.prototype.readData = function(size) {
+    this.checkOffset(size);
+    var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
+    this.index += size;
+    return result;
+  };
+  StringReader_1 = StringReader;
+  return StringReader_1;
+}
+var Uint8ArrayReader_1;
+var hasRequiredUint8ArrayReader;
+function requireUint8ArrayReader() {
+  if (hasRequiredUint8ArrayReader) return Uint8ArrayReader_1;
+  hasRequiredUint8ArrayReader = 1;
+  var ArrayReader = /* @__PURE__ */ requireArrayReader();
+  var utils2 = /* @__PURE__ */ requireUtils();
+  function Uint8ArrayReader(data) {
+    ArrayReader.call(this, data);
+  }
+  utils2.inherits(Uint8ArrayReader, ArrayReader);
+  Uint8ArrayReader.prototype.readData = function(size) {
+    this.checkOffset(size);
+    if (size === 0) {
+      return new Uint8Array(0);
+    }
+    var result = this.data.subarray(this.zero + this.index, this.zero + this.index + size);
+    this.index += size;
+    return result;
+  };
+  Uint8ArrayReader_1 = Uint8ArrayReader;
+  return Uint8ArrayReader_1;
+}
+var NodeBufferReader_1;
+var hasRequiredNodeBufferReader;
+function requireNodeBufferReader() {
+  if (hasRequiredNodeBufferReader) return NodeBufferReader_1;
+  hasRequiredNodeBufferReader = 1;
+  var Uint8ArrayReader = /* @__PURE__ */ requireUint8ArrayReader();
+  var utils2 = /* @__PURE__ */ requireUtils();
+  function NodeBufferReader(data) {
+    Uint8ArrayReader.call(this, data);
+  }
+  utils2.inherits(NodeBufferReader, Uint8ArrayReader);
+  NodeBufferReader.prototype.readData = function(size) {
+    this.checkOffset(size);
+    var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
+    this.index += size;
+    return result;
+  };
+  NodeBufferReader_1 = NodeBufferReader;
+  return NodeBufferReader_1;
+}
+var readerFor;
+var hasRequiredReaderFor;
+function requireReaderFor() {
+  if (hasRequiredReaderFor) return readerFor;
+  hasRequiredReaderFor = 1;
+  var utils2 = /* @__PURE__ */ requireUtils();
+  var support2 = /* @__PURE__ */ requireSupport();
+  var ArrayReader = /* @__PURE__ */ requireArrayReader();
+  var StringReader = /* @__PURE__ */ requireStringReader();
+  var NodeBufferReader = /* @__PURE__ */ requireNodeBufferReader();
+  var Uint8ArrayReader = /* @__PURE__ */ requireUint8ArrayReader();
+  readerFor = function(data) {
+    var type = utils2.getTypeOf(data);
+    utils2.checkSupport(type);
+    if (type === "string" && !support2.uint8array) {
+      return new StringReader(data);
+    }
+    if (type === "nodebuffer") {
+      return new NodeBufferReader(data);
+    }
+    if (support2.uint8array) {
+      return new Uint8ArrayReader(utils2.transformTo("uint8array", data));
+    }
+    return new ArrayReader(utils2.transformTo("array", data));
+  };
+  return readerFor;
+}
+var zipEntry;
+var hasRequiredZipEntry;
+function requireZipEntry() {
+  if (hasRequiredZipEntry) return zipEntry;
+  hasRequiredZipEntry = 1;
+  var readerFor2 = /* @__PURE__ */ requireReaderFor();
+  var utils2 = /* @__PURE__ */ requireUtils();
+  var CompressedObject = /* @__PURE__ */ requireCompressedObject();
+  var crc32fn = /* @__PURE__ */ requireCrc32();
+  var utf82 = /* @__PURE__ */ requireUtf8();
+  var compressions2 = /* @__PURE__ */ requireCompressions();
+  var support2 = /* @__PURE__ */ requireSupport();
+  var MADE_BY_DOS = 0;
+  var MADE_BY_UNIX = 3;
+  var findCompression = function(compressionMethod) {
+    for (var method in compressions2) {
+      if (!Object.prototype.hasOwnProperty.call(compressions2, method)) {
+        continue;
+      }
+      if (compressions2[method].magic === compressionMethod) {
+        return compressions2[method];
+      }
+    }
+    return null;
+  };
+  function ZipEntry(options, loadOptions) {
+    this.options = options;
+    this.loadOptions = loadOptions;
+  }
+  ZipEntry.prototype = {
+    /**
+     * say if the file is encrypted.
+     * @return {boolean} true if the file is encrypted, false otherwise.
+     */
+    isEncrypted: function() {
+      return (this.bitFlag & 1) === 1;
+    },
+    /**
+     * say if the file has utf-8 filename/comment.
+     * @return {boolean} true if the filename/comment is in utf-8, false otherwise.
+     */
+    useUTF8: function() {
+      return (this.bitFlag & 2048) === 2048;
+    },
+    /**
+     * Read the local part of a zip file and add the info in this object.
+     * @param {DataReader} reader the reader to use.
+     */
+    readLocalPart: function(reader) {
+      var compression, localExtraFieldsLength;
+      reader.skip(22);
+      this.fileNameLength = reader.readInt(2);
+      localExtraFieldsLength = reader.readInt(2);
+      this.fileName = reader.readData(this.fileNameLength);
+      reader.skip(localExtraFieldsLength);
+      if (this.compressedSize === -1 || this.uncompressedSize === -1) {
+        throw new Error("Bug or corrupted zip : didn't get enough information from the central directory (compressedSize === -1 || uncompressedSize === -1)");
+      }
+      compression = findCompression(this.compressionMethod);
+      if (compression === null) {
+        throw new Error("Corrupted zip : compression " + utils2.pretty(this.compressionMethod) + " unknown (inner file : " + utils2.transformTo("string", this.fileName) + ")");
+      }
+      this.decompressed = new CompressedObject(this.compressedSize, this.uncompressedSize, this.crc32, compression, reader.readData(this.compressedSize));
+    },
+    /**
+     * Read the central part of a zip file and add the info in this object.
+     * @param {DataReader} reader the reader to use.
+     */
+    readCentralPart: function(reader) {
+      this.versionMadeBy = reader.readInt(2);
+      reader.skip(2);
+      this.bitFlag = reader.readInt(2);
+      this.compressionMethod = reader.readString(2);
+      this.date = reader.readDate();
+      this.crc32 = reader.readInt(4);
+      this.compressedSize = reader.readInt(4);
+      this.uncompressedSize = reader.readInt(4);
+      var fileNameLength = reader.readInt(2);
+      this.extraFieldsLength = reader.readInt(2);
+      this.fileCommentLength = reader.readInt(2);
+      this.diskNumberStart = reader.readInt(2);
+      this.internalFileAttributes = reader.readInt(2);
+      this.externalFileAttributes = reader.readInt(4);
+      this.localHeaderOffset = reader.readInt(4);
+      if (this.isEncrypted()) {
+        throw new Error("Encrypted zip are not supported");
+      }
+      reader.skip(fileNameLength);
+      this.readExtraFields(reader);
+      this.parseZIP64ExtraField(reader);
+      this.fileComment = reader.readData(this.fileCommentLength);
+    },
+    /**
+     * Parse the external file attributes and get the unix/dos permissions.
+     */
+    processAttributes: function() {
+      this.unixPermissions = null;
+      this.dosPermissions = null;
+      var madeBy = this.versionMadeBy >> 8;
+      this.dir = this.externalFileAttributes & 16 ? true : false;
+      if (madeBy === MADE_BY_DOS) {
+        this.dosPermissions = this.externalFileAttributes & 63;
+      }
+      if (madeBy === MADE_BY_UNIX) {
+        this.unixPermissions = this.externalFileAttributes >> 16 & 65535;
+      }
+      if (!this.dir && this.fileNameStr.slice(-1) === "/") {
+        this.dir = true;
+      }
+    },
+    /**
+     * Parse the ZIP64 extra field and merge the info in the current ZipEntry.
+     * @param {DataReader} reader the reader to use.
+     */
+    parseZIP64ExtraField: function() {
+      if (!this.extraFields[1]) {
+        return;
+      }
+      var extraReader = readerFor2(this.extraFields[1].value);
+      if (this.uncompressedSize === utils2.MAX_VALUE_32BITS) {
+        this.uncompressedSize = extraReader.readInt(8);
+      }
+      if (this.compressedSize === utils2.MAX_VALUE_32BITS) {
+        this.compressedSize = extraReader.readInt(8);
+      }
+      if (this.localHeaderOffset === utils2.MAX_VALUE_32BITS) {
+        this.localHeaderOffset = extraReader.readInt(8);
+      }
+      if (this.diskNumberStart === utils2.MAX_VALUE_32BITS) {
+        this.diskNumberStart = extraReader.readInt(4);
+      }
+    },
+    /**
+     * Read the central part of a zip file and add the info in this object.
+     * @param {DataReader} reader the reader to use.
+     */
+    readExtraFields: function(reader) {
+      var end = reader.index + this.extraFieldsLength, extraFieldId, extraFieldLength, extraFieldValue;
+      if (!this.extraFields) {
+        this.extraFields = {};
+      }
+      while (reader.index + 4 < end) {
+        extraFieldId = reader.readInt(2);
+        extraFieldLength = reader.readInt(2);
+        extraFieldValue = reader.readData(extraFieldLength);
+        this.extraFields[extraFieldId] = {
+          id: extraFieldId,
+          length: extraFieldLength,
+          value: extraFieldValue
+        };
+      }
+      reader.setIndex(end);
+    },
+    /**
+     * Apply an UTF8 transformation if needed.
+     */
+    handleUTF8: function() {
+      var decodeParamType = support2.uint8array ? "uint8array" : "array";
+      if (this.useUTF8()) {
+        this.fileNameStr = utf82.utf8decode(this.fileName);
+        this.fileCommentStr = utf82.utf8decode(this.fileComment);
+      } else {
+        var upath = this.findExtraFieldUnicodePath();
+        if (upath !== null) {
+          this.fileNameStr = upath;
+        } else {
+          var fileNameByteArray = utils2.transformTo(decodeParamType, this.fileName);
+          this.fileNameStr = this.loadOptions.decodeFileName(fileNameByteArray);
+        }
+        var ucomment = this.findExtraFieldUnicodeComment();
+        if (ucomment !== null) {
+          this.fileCommentStr = ucomment;
+        } else {
+          var commentByteArray = utils2.transformTo(decodeParamType, this.fileComment);
+          this.fileCommentStr = this.loadOptions.decodeFileName(commentByteArray);
+        }
+      }
+    },
+    /**
+     * Find the unicode path declared in the extra field, if any.
+     * @return {String} the unicode path, null otherwise.
+     */
+    findExtraFieldUnicodePath: function() {
+      var upathField = this.extraFields[28789];
+      if (upathField) {
+        var extraReader = readerFor2(upathField.value);
+        if (extraReader.readInt(1) !== 1) {
+          return null;
+        }
+        if (crc32fn(this.fileName) !== extraReader.readInt(4)) {
+          return null;
+        }
+        return utf82.utf8decode(extraReader.readData(upathField.length - 5));
+      }
+      return null;
+    },
+    /**
+     * Find the unicode comment declared in the extra field, if any.
+     * @return {String} the unicode comment, null otherwise.
+     */
+    findExtraFieldUnicodeComment: function() {
+      var ucommentField = this.extraFields[25461];
+      if (ucommentField) {
+        var extraReader = readerFor2(ucommentField.value);
+        if (extraReader.readInt(1) !== 1) {
+          return null;
+        }
+        if (crc32fn(this.fileComment) !== extraReader.readInt(4)) {
+          return null;
+        }
+        return utf82.utf8decode(extraReader.readData(ucommentField.length - 5));
+      }
+      return null;
+    }
+  };
+  zipEntry = ZipEntry;
+  return zipEntry;
+}
+var zipEntries;
+var hasRequiredZipEntries;
+function requireZipEntries() {
+  if (hasRequiredZipEntries) return zipEntries;
+  hasRequiredZipEntries = 1;
+  var readerFor2 = /* @__PURE__ */ requireReaderFor();
+  var utils2 = /* @__PURE__ */ requireUtils();
+  var sig = /* @__PURE__ */ requireSignature();
+  var ZipEntry = /* @__PURE__ */ requireZipEntry();
+  var support2 = /* @__PURE__ */ requireSupport();
+  function ZipEntries(loadOptions) {
+    this.files = [];
+    this.loadOptions = loadOptions;
+  }
+  ZipEntries.prototype = {
+    /**
+     * Check that the reader is on the specified signature.
+     * @param {string} expectedSignature the expected signature.
+     * @throws {Error} if it is an other signature.
+     */
+    checkSignature: function(expectedSignature) {
+      if (!this.reader.readAndCheckSignature(expectedSignature)) {
+        this.reader.index -= 4;
+        var signature2 = this.reader.readString(4);
+        throw new Error("Corrupted zip or bug: unexpected signature (" + utils2.pretty(signature2) + ", expected " + utils2.pretty(expectedSignature) + ")");
+      }
+    },
+    /**
+     * Check if the given signature is at the given index.
+     * @param {number} askedIndex the index to check.
+     * @param {string} expectedSignature the signature to expect.
+     * @return {boolean} true if the signature is here, false otherwise.
+     */
+    isSignature: function(askedIndex, expectedSignature) {
+      var currentIndex = this.reader.index;
+      this.reader.setIndex(askedIndex);
+      var signature2 = this.reader.readString(4);
+      var result = signature2 === expectedSignature;
+      this.reader.setIndex(currentIndex);
+      return result;
+    },
+    /**
+     * Read the end of the central directory.
+     */
+    readBlockEndOfCentral: function() {
+      this.diskNumber = this.reader.readInt(2);
+      this.diskWithCentralDirStart = this.reader.readInt(2);
+      this.centralDirRecordsOnThisDisk = this.reader.readInt(2);
+      this.centralDirRecords = this.reader.readInt(2);
+      this.centralDirSize = this.reader.readInt(4);
+      this.centralDirOffset = this.reader.readInt(4);
+      this.zipCommentLength = this.reader.readInt(2);
+      var zipComment = this.reader.readData(this.zipCommentLength);
+      var decodeParamType = support2.uint8array ? "uint8array" : "array";
+      var decodeContent = utils2.transformTo(decodeParamType, zipComment);
+      this.zipComment = this.loadOptions.decodeFileName(decodeContent);
+    },
+    /**
+     * Read the end of the Zip 64 central directory.
+     * Not merged with the method readEndOfCentral :
+     * The end of central can coexist with its Zip64 brother,
+     * I don't want to read the wrong number of bytes !
+     */
+    readBlockZip64EndOfCentral: function() {
+      this.zip64EndOfCentralSize = this.reader.readInt(8);
+      this.reader.skip(4);
+      this.diskNumber = this.reader.readInt(4);
+      this.diskWithCentralDirStart = this.reader.readInt(4);
+      this.centralDirRecordsOnThisDisk = this.reader.readInt(8);
+      this.centralDirRecords = this.reader.readInt(8);
+      this.centralDirSize = this.reader.readInt(8);
+      this.centralDirOffset = this.reader.readInt(8);
+      this.zip64ExtensibleData = {};
+      var extraDataSize = this.zip64EndOfCentralSize - 44, index = 0, extraFieldId, extraFieldLength, extraFieldValue;
+      while (index < extraDataSize) {
+        extraFieldId = this.reader.readInt(2);
+        extraFieldLength = this.reader.readInt(4);
+        extraFieldValue = this.reader.readData(extraFieldLength);
+        this.zip64ExtensibleData[extraFieldId] = {
+          id: extraFieldId,
+          length: extraFieldLength,
+          value: extraFieldValue
+        };
+      }
+    },
+    /**
+     * Read the end of the Zip 64 central directory locator.
+     */
+    readBlockZip64EndOfCentralLocator: function() {
+      this.diskWithZip64CentralDirStart = this.reader.readInt(4);
+      this.relativeOffsetEndOfZip64CentralDir = this.reader.readInt(8);
+      this.disksCount = this.reader.readInt(4);
+      if (this.disksCount > 1) {
+        throw new Error("Multi-volumes zip are not supported");
+      }
+    },
+    /**
+     * Read the local files, based on the offset read in the central part.
+     */
+    readLocalFiles: function() {
+      var i, file;
+      for (i = 0; i < this.files.length; i++) {
+        file = this.files[i];
+        this.reader.setIndex(file.localHeaderOffset);
+        this.checkSignature(sig.LOCAL_FILE_HEADER);
+        file.readLocalPart(this.reader);
+        file.handleUTF8();
+        file.processAttributes();
+      }
+    },
+    /**
+     * Read the central directory.
+     */
+    readCentralDir: function() {
+      var file;
+      this.reader.setIndex(this.centralDirOffset);
+      while (this.reader.readAndCheckSignature(sig.CENTRAL_FILE_HEADER)) {
+        file = new ZipEntry({
+          zip64: this.zip64
+        }, this.loadOptions);
+        file.readCentralPart(this.reader);
+        this.files.push(file);
+      }
+      if (this.centralDirRecords !== this.files.length) {
+        if (this.centralDirRecords !== 0 && this.files.length === 0) {
+          throw new Error("Corrupted zip or bug: expected " + this.centralDirRecords + " records in central dir, got " + this.files.length);
+        }
+      }
+    },
+    /**
+     * Read the end of central directory.
+     */
+    readEndOfCentral: function() {
+      var offset = this.reader.lastIndexOfSignature(sig.CENTRAL_DIRECTORY_END);
+      if (offset < 0) {
+        var isGarbage = !this.isSignature(0, sig.LOCAL_FILE_HEADER);
+        if (isGarbage) {
+          throw new Error("Can't find end of central directory : is this a zip file ? If it is, see https://stuk.github.io/jszip/documentation/howto/read_zip.html");
+        } else {
+          throw new Error("Corrupted zip: can't find end of central directory");
+        }
+      }
+      this.reader.setIndex(offset);
+      var endOfCentralDirOffset = offset;
+      this.checkSignature(sig.CENTRAL_DIRECTORY_END);
+      this.readBlockEndOfCentral();
+      if (this.diskNumber === utils2.MAX_VALUE_16BITS || this.diskWithCentralDirStart === utils2.MAX_VALUE_16BITS || this.centralDirRecordsOnThisDisk === utils2.MAX_VALUE_16BITS || this.centralDirRecords === utils2.MAX_VALUE_16BITS || this.centralDirSize === utils2.MAX_VALUE_32BITS || this.centralDirOffset === utils2.MAX_VALUE_32BITS) {
+        this.zip64 = true;
+        offset = this.reader.lastIndexOfSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
+        if (offset < 0) {
+          throw new Error("Corrupted zip: can't find the ZIP64 end of central directory locator");
+        }
+        this.reader.setIndex(offset);
+        this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
+        this.readBlockZip64EndOfCentralLocator();
+        if (!this.isSignature(this.relativeOffsetEndOfZip64CentralDir, sig.ZIP64_CENTRAL_DIRECTORY_END)) {
+          this.relativeOffsetEndOfZip64CentralDir = this.reader.lastIndexOfSignature(sig.ZIP64_CENTRAL_DIRECTORY_END);
+          if (this.relativeOffsetEndOfZip64CentralDir < 0) {
+            throw new Error("Corrupted zip: can't find the ZIP64 end of central directory");
+          }
+        }
+        this.reader.setIndex(this.relativeOffsetEndOfZip64CentralDir);
+        this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_END);
+        this.readBlockZip64EndOfCentral();
+      }
+      var expectedEndOfCentralDirOffset = this.centralDirOffset + this.centralDirSize;
+      if (this.zip64) {
+        expectedEndOfCentralDirOffset += 20;
+        expectedEndOfCentralDirOffset += 12 + this.zip64EndOfCentralSize;
+      }
+      var extraBytes = endOfCentralDirOffset - expectedEndOfCentralDirOffset;
+      if (extraBytes > 0) {
+        if (this.isSignature(endOfCentralDirOffset, sig.CENTRAL_FILE_HEADER)) ;
+        else {
+          this.reader.zero = extraBytes;
+        }
+      } else if (extraBytes < 0) {
+        throw new Error("Corrupted zip: missing " + Math.abs(extraBytes) + " bytes.");
+      }
+    },
+    prepareReader: function(data) {
+      this.reader = readerFor2(data);
+    },
+    /**
+     * Read a zip file and create ZipEntries.
+     * @param {String|ArrayBuffer|Uint8Array|Buffer} data the binary string representing a zip file.
+     */
+    load: function(data) {
+      this.prepareReader(data);
+      this.readEndOfCentral();
+      this.readCentralDir();
+      this.readLocalFiles();
+    }
+  };
+  zipEntries = ZipEntries;
+  return zipEntries;
+}
+var load;
+var hasRequiredLoad;
+function requireLoad() {
+  if (hasRequiredLoad) return load;
+  hasRequiredLoad = 1;
+  var utils2 = /* @__PURE__ */ requireUtils();
+  var external2 = /* @__PURE__ */ requireExternal();
+  var utf82 = /* @__PURE__ */ requireUtf8();
+  var ZipEntries = /* @__PURE__ */ requireZipEntries();
+  var Crc32Probe = /* @__PURE__ */ requireCrc32Probe();
+  var nodejsUtils2 = /* @__PURE__ */ requireNodejsUtils();
+  function checkEntryCRC32(zipEntry2) {
+    return new external2.Promise(function(resolve, reject) {
+      var worker = zipEntry2.decompressed.getContentWorker().pipe(new Crc32Probe());
+      worker.on("error", function(e) {
+        reject(e);
+      }).on("end", function() {
+        if (worker.streamInfo.crc32 !== zipEntry2.decompressed.crc32) {
+          reject(new Error("Corrupted zip : CRC32 mismatch"));
+        } else {
+          resolve();
+        }
+      }).resume();
+    });
+  }
+  load = function(data, options) {
+    var zip = this;
+    options = utils2.extend(options || {}, {
+      base64: false,
+      checkCRC32: false,
+      optimizedBinaryString: false,
+      createFolders: false,
+      decodeFileName: utf82.utf8decode
+    });
+    if (nodejsUtils2.isNode && nodejsUtils2.isStream(data)) {
+      return external2.Promise.reject(new Error("JSZip can't accept a stream when loading a zip file."));
+    }
+    return utils2.prepareContent("the loaded zip file", data, true, options.optimizedBinaryString, options.base64).then(function(data2) {
+      var zipEntries2 = new ZipEntries(options);
+      zipEntries2.load(data2);
+      return zipEntries2;
+    }).then(function checkCRC32(zipEntries2) {
+      var promises = [external2.Promise.resolve(zipEntries2)];
+      var files = zipEntries2.files;
+      if (options.checkCRC32) {
+        for (var i = 0; i < files.length; i++) {
+          promises.push(checkEntryCRC32(files[i]));
+        }
+      }
+      return external2.Promise.all(promises);
+    }).then(function addFiles(results) {
+      var zipEntries2 = results.shift();
+      var files = zipEntries2.files;
+      for (var i = 0; i < files.length; i++) {
+        var input = files[i];
+        var unsafeName = input.fileNameStr;
+        var safeName = utils2.resolve(input.fileNameStr);
+        zip.file(safeName, input.decompressed, {
+          binary: true,
+          optimizedBinaryString: true,
+          date: input.date,
+          dir: input.dir,
+          comment: input.fileCommentStr.length ? input.fileCommentStr : null,
+          unixPermissions: input.unixPermissions,
+          dosPermissions: input.dosPermissions,
+          createFolders: options.createFolders
+        });
+        if (!input.dir) {
+          zip.file(safeName).unsafeOriginalName = unsafeName;
+        }
+      }
+      if (zipEntries2.zipComment.length) {
+        zip.comment = zipEntries2.zipComment;
+      }
+      return zip;
+    });
+  };
+  return load;
+}
+var lib;
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  function JSZip2() {
+    if (!(this instanceof JSZip2)) {
+      return new JSZip2();
+    }
+    if (arguments.length) {
+      throw new Error("The constructor with parameters has been removed in JSZip 3.0, please check the upgrade guide.");
+    }
+    this.files = /* @__PURE__ */ Object.create(null);
+    this.comment = null;
+    this.root = "";
+    this.clone = function() {
+      var newObj = new JSZip2();
+      for (var i in this) {
+        if (typeof this[i] !== "function") {
+          newObj[i] = this[i];
+        }
+      }
+      return newObj;
+    };
+  }
+  JSZip2.prototype = /* @__PURE__ */ requireObject();
+  JSZip2.prototype.loadAsync = /* @__PURE__ */ requireLoad();
+  JSZip2.support = /* @__PURE__ */ requireSupport();
+  JSZip2.defaults = /* @__PURE__ */ requireDefaults();
+  JSZip2.version = "3.10.1";
+  JSZip2.loadAsync = function(content, options) {
+    return new JSZip2().loadAsync(content, options);
+  };
+  JSZip2.external = /* @__PURE__ */ requireExternal();
+  lib = JSZip2;
+  return lib;
+}
+var libExports = /* @__PURE__ */ requireLib();
+const JSZip = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
+export {
+  JSZip as J
+};