@ankhorage/zora 23.4.3 → 24.0.0

package/web-dist/chunks/Accordion-vgkvvdvg.js

@@ -0,0 +1,4295 @@
+'use client';
+// node_modules/@zip.js/zip.js/lib/core/constants.js
+var MAX_32_BITS = 4294967295;
+var MAX_16_BITS = 65535;
+var MAX_8_BITS = 255;
+var COMPRESSION_METHOD_DEFLATE = 8;
+var COMPRESSION_METHOD_DEFLATE_64 = 9;
+var COMPRESSION_METHOD_STORE = 0;
+var COMPRESSION_METHOD_AES = 99;
+var LOCAL_FILE_HEADER_SIGNATURE = 67324752;
+var SPLIT_ZIP_FILE_SIGNATURE = 134695760;
+var TEMPORARY_SPLIT_ZIP_FILE_SIGNATURE = 808471376;
+var DATA_DESCRIPTOR_RECORD_SIGNATURE = SPLIT_ZIP_FILE_SIGNATURE;
+var ARCHIVE_EXTRA_DATA_SIGNATURE = 134630224;
+var DIGITAL_SIGNATURE_RECORD_SIGNATURE = 84233040;
+var CENTRAL_FILE_HEADER_SIGNATURE = 33639248;
+var END_OF_CENTRAL_DIR_SIGNATURE = 101010256;
+var ZIP64_END_OF_CENTRAL_DIR_SIGNATURE = 101075792;
+var ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE = 117853008;
+var CENTRAL_FILE_HEADER_LENGTH = 46;
+var END_OF_CENTRAL_DIR_LENGTH = 22;
+var ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH = 20;
+var ZIP64_END_OF_CENTRAL_DIR_LENGTH = 56;
+var ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH = END_OF_CENTRAL_DIR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LENGTH;
+var DATA_DESCRIPTOR_RECORD_LENGTH = 12;
+var DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH = 20;
+var DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH = 4;
+var SPLIT_ZIP_FILE_SIGNATURE_LENGTH = 4;
+var EXTRAFIELD_TYPE_ZIP64 = 1;
+var EXTRAFIELD_TYPE_AES = 39169;
+var EXTRAFIELD_TYPE_NTFS = 10;
+var EXTRAFIELD_TYPE_NTFS_TAG1 = 1;
+var EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP = 21589;
+var EXTRAFIELD_TYPE_UNICODE_PATH = 28789;
+var EXTRAFIELD_TYPE_UNICODE_COMMENT = 25461;
+var EXTRAFIELD_TYPE_USDZ = 6534;
+var EXTRAFIELD_TYPE_INFOZIP = 30837;
+var EXTRAFIELD_TYPE_UNIX = 30805;
+var EXTRAFIELD_TYPE_UNIX_TYPE1 = 22613;
+var EXTRAFIELD_TYPE_PKWARE_UNIX = 13;
+var BITFLAG_ENCRYPTED = 1;
+var BITFLAG_LEVEL = 6;
+var BITFLAG_DATA_DESCRIPTOR = 8;
+var BITFLAG_COMPRESSED_PATCHED_DATA = 32;
+var BITFLAG_STRONG_ENCRYPTION = 64;
+var BITFLAG_LANG_ENCODING_FLAG = 2048;
+var BITFLAG_MASKED_LOCAL_HEADERS = 8192;
+var FILE_ATTR_MSDOS_DIR_MASK = 16;
+var FILE_ATTR_MSDOS_READONLY_MASK = 1;
+var FILE_ATTR_MSDOS_HIDDEN_MASK = 2;
+var FILE_ATTR_MSDOS_SYSTEM_MASK = 4;
+var FILE_ATTR_MSDOS_ARCHIVE_MASK = 32;
+var FILE_ATTR_UNIX_TYPE_MASK = 61440;
+var FILE_ATTR_UNIX_TYPE_DIR = 16384;
+var FILE_ATTR_UNIX_TYPE_SYMLINK = 40960;
+var FILE_ATTR_UNIX_EXECUTABLE_MASK = 73;
+var FILE_ATTR_UNIX_DEFAULT_MASK = 420;
+var FILE_ATTR_UNIX_SETUID_MASK = 2048;
+var FILE_ATTR_UNIX_SETGID_MASK = 1024;
+var FILE_ATTR_UNIX_STICKY_MASK = 512;
+var DIRECTORY_SIGNATURE = "/";
+var HEADER_SIZE = 30;
+var HEADER_OFFSET_SIGNATURE = 10;
+var HEADER_OFFSET_COMPRESSED_SIZE = 14;
+var HEADER_OFFSET_UNCOMPRESSED_SIZE = 18;
+var MAX_DATE = new Date(2107, 11, 31, 23, 59, 58);
+var MIN_DATE = new Date(1980, 0, 1);
+var UNDEFINED_VALUE = undefined;
+var ERR_LOCAL_FILE_HEADER_NOT_FOUND2 = "Local file header not found";
+var ERR_OVERLAPPING_ENTRY2 = "Overlapping entry found";
+var ERR_EXTRAFIELD_ZIP64_NOT_FOUND2 = "Zip64 extra field not found";
+var UNDEFINED_TYPE = "undefined";
+var FUNCTION_TYPE = "function";
+var STRING_TYPE = "string";
+var NUMBER_TYPE = "number";
+var BOOLEAN_TYPE = "boolean";
+var EMPTY_UINT8_ARRAY = new Uint8Array;
+var SYMBOL_ASYNC_DISPOSE = Symbol.asyncDispose || Symbol();
+
+// node_modules/@zip.js/zip.js/lib/core/options.js
+var OPTION_FILENAME_ENCODING = "filenameEncoding";
+var OPTION_COMMENT_ENCODING = "commentEncoding";
+var OPTION_DECODE_TEXT = "decodeText";
+var OPTION_EXTRACT_PREPENDED_DATA = "extractPrependedData";
+var OPTION_EXTRACT_APPENDED_DATA = "extractAppendedData";
+var OPTION_PASSWORD = "password";
+var OPTION_RAW_PASSWORD = "rawPassword";
+var OPTION_PASS_THROUGH = "passThrough";
+var OPTION_SIGNAL = "signal";
+var OPTION_CHECK_PASSWORD_ONLY = "checkPasswordOnly";
+var OPTION_CHECK_OVERLAPPING_ENTRY_ONLY = "checkOverlappingEntryOnly";
+var OPTION_CHECK_OVERLAPPING_ENTRY = "checkOverlappingEntry";
+var OPTION_CHECK_AMBIGUITY = "checkAmbiguity";
+var OPTION_CHECK_LOCAL_DIRECTORY = "checkLocalDirectory";
+var OPTION_CHECK_LOCAL_FILENAME = "checkLocalFilename";
+var OPTION_CHECK_SIGNATURE = "checkSignature";
+var OPTION_CHECK_CRC32 = "checkCrc32";
+var OPTION_CHECK_AUTHENTICATION_CODE = "checkAuthenticationCode";
+var OPTION_USE_WEB_WORKERS = "useWebWorkers";
+var OPTION_USE_COMPRESSION_STREAM = "useCompressionStream";
+var OPTION_PREVENT_CLOSE = "preventClose";
+var OPTION_STRICTNESS = "strictness";
+var OPTION_FILENAME_VALIDATION = "filenameValidation";
+var OPTION_NORMALIZE_FILENAME = "normalizeFilename";
+var OPTION_MAX_APPENDED_DATA_SIZE = "maxAppendedDataSize";
+var OPTION_DECRYPT_CENTRAL_DIRECTORY = "decryptCentralDirectory";
+var TEXT_TYPE_FILENAME = "filename";
+var TEXT_TYPE_COMMENT = "comment";
+var STRICTNESS_STRICT = "strict";
+var STRICTNESS_BALANCED = "balanced";
+var STRICTNESS_TOLERANT = "tolerant";
+var PASS_THROUGH_COMPRESSED = "compressed";
+var ERR_INVALID_FUNCTION_OPTION = "Invalid option (must be a function)";
+var ERR_INVALID_SIGNAL = "Invalid signal (must be an AbortSignal instance)";
+var ERR_INVALID_PASSWORD_TYPE = "Invalid password (password must be a string, rawPassword must be a Uint8Array)";
+var ERR_INVALID_PASS_THROUGH_VALUE = "Invalid passThrough option (must be a boolean or 'compressed')";
+var ERR_ABORTED = "The operation was aborted";
+var ABORT_ERROR_NAME = "AbortError";
+function checkFunctionOption(value) {
+  if (value && typeof value != FUNCTION_TYPE) {
+    throw new Error(ERR_INVALID_FUNCTION_OPTION);
+  }
+  return value;
+}
+function checkSignalOption(signal) {
+  if (signal && (typeof signal.addEventListener != FUNCTION_TYPE || typeof signal.aborted != BOOLEAN_TYPE)) {
+    throw new Error(ERR_INVALID_SIGNAL);
+  }
+  return signal || UNDEFINED_VALUE;
+}
+function throwIfAborted(signal) {
+  if (signal && signal.aborted) {
+    throw signal.reason === UNDEFINED_VALUE ? new DOMException(ERR_ABORTED, ABORT_ERROR_NAME) : signal.reason;
+  }
+}
+function checkPasswordOption(password, rawPassword) {
+  if (password && typeof password != STRING_TYPE || rawPassword && !(rawPassword instanceof Uint8Array)) {
+    throw new Error(ERR_INVALID_PASSWORD_TYPE);
+  }
+}
+function checkPassThroughOption(passThrough) {
+  if (passThrough !== UNDEFINED_VALUE && typeof passThrough != BOOLEAN_TYPE && passThrough !== PASS_THROUGH_COMPRESSED) {
+    throw new Error(ERR_INVALID_PASS_THROUGH_VALUE);
+  }
+  return passThrough;
+}
+function toNumber(value) {
+  return typeof value == STRING_TYPE && value.trim() ? Number(value) : value;
+}
+
+// node_modules/@zip.js/zip.js/lib/core/configuration.js
+var DEFAULT_CHUNK_SIZE = 256 * 1024;
+var MINIMUM_CHUNK_SIZE = 64;
+var MINIMUM_PROPERTY_VALUE = 1;
+var ERR_INVALID_MAX_WORKERS = "Invalid maxWorkers (must be an integer greater than 0)";
+var ERR_INVALID_BASE_URI = "Invalid baseURI (must be a string)";
+var ERR_INVALID_URI = "Invalid URI (must be a string or a function returning a string)";
+var maxWorkers = 2;
+try {
+  if (typeof navigator != UNDEFINED_TYPE && navigator.hardwareConcurrency) {
+    maxWorkers = navigator.hardwareConcurrency;
+  }
+} catch {}
+var DEFAULT_CONFIGURATION = {
+  workerURI: "./core/web-worker-wasm.js",
+  wasmURI: "./core/streams/zlib-wasm/zlib-streams.wasm",
+  chunkSize: DEFAULT_CHUNK_SIZE,
+  maxWorkers,
+  terminateWorkerTimeout: 5000,
+  workerStarvationTimeout: 5000,
+  workerStartupTimeout: 5000,
+  useWebWorkers: true,
+  useCompressionStream: true,
+  CompressionStream: typeof CompressionStream != UNDEFINED_TYPE && CompressionStream,
+  DecompressionStream: typeof DecompressionStream != UNDEFINED_TYPE && DecompressionStream
+};
+var PROPERTY_NAME_MAX_WORKERS = "maxWorkers";
+var PROPERTY_NAME_BASE_URI = "baseURI";
+var URI_PROPERTY_NAMES = [
+  "wasmURI",
+  "workerURI"
+];
+var BOOLEAN_PROPERTY_NAMES = [
+  "useCompressionStream",
+  "useWebWorkers"
+];
+var NUMBER_PROPERTY_NAMES = [
+  "chunkSize",
+  PROPERTY_NAME_MAX_WORKERS,
+  "terminateWorkerTimeout",
+  "workerStarvationTimeout",
+  "workerStartupTimeout"
+];
+var FUNCTION_PROPERTY_NAMES = [
+  "createWorker",
+  "CompressionStream",
+  "DecompressionStream",
+  "CompressionStreamFallback",
+  "DecompressionStreamFallback"
+];
+var CONFIGURABLE_PROPERTY_NAMES = [
+  PROPERTY_NAME_BASE_URI,
+  ...URI_PROPERTY_NAMES,
+  ...BOOLEAN_PROPERTY_NAMES,
+  ...NUMBER_PROPERTY_NAMES,
+  ...FUNCTION_PROPERTY_NAMES
+];
+var config = { ...DEFAULT_CONFIGURATION };
+function getConfiguration() {
+  return config;
+}
+function getChunkSize(config) {
+  return normalizeChunkSize(config.chunkSize);
+}
+function normalizeChunkSize(chunkSize) {
+  chunkSize = toNumber(chunkSize);
+  return Number.isInteger(chunkSize) && chunkSize >= MINIMUM_PROPERTY_VALUE ? Math.max(chunkSize, MINIMUM_CHUNK_SIZE) : DEFAULT_CHUNK_SIZE;
+}
+function checkConfiguration(configuration) {
+  const checkedConfiguration = {};
+  for (const propertyName of CONFIGURABLE_PROPERTY_NAMES) {
+    const propertyValue = configuration[propertyName];
+    if (propertyValue !== UNDEFINED_VALUE) {
+      checkedConfiguration[propertyName] = checkPropertyValue(propertyName, propertyValue);
+    }
+  }
+  return checkedConfiguration;
+}
+function checkPropertyValue(propertyName, propertyValue) {
+  if (NUMBER_PROPERTY_NAMES.includes(propertyName)) {
+    propertyValue = toNumber(propertyValue);
+    if (propertyName == PROPERTY_NAME_MAX_WORKERS && (!Number.isInteger(propertyValue) || propertyValue < MINIMUM_PROPERTY_VALUE)) {
+      throw new Error(ERR_INVALID_MAX_WORKERS);
+    }
+  } else if (FUNCTION_PROPERTY_NAMES.includes(propertyName)) {
+    checkFunctionOption(propertyValue);
+  } else if (propertyName == PROPERTY_NAME_BASE_URI) {
+    if (propertyValue && typeof propertyValue != STRING_TYPE) {
+      throw new Error(ERR_INVALID_BASE_URI);
+    }
+  } else if (URI_PROPERTY_NAMES.includes(propertyName)) {
+    if (propertyValue && typeof propertyValue != STRING_TYPE && typeof propertyValue != FUNCTION_TYPE) {
+      throw new Error(ERR_INVALID_URI);
+    }
+  }
+  return propertyValue;
+}
+function normalizeConfiguration(configuration) {
+  configuration = configuration || {};
+  const { CompressionStreamZlib, DecompressionStreamZlib } = configuration;
+  if (CompressionStreamZlib === UNDEFINED_VALUE && DecompressionStreamZlib === UNDEFINED_VALUE) {
+    return configuration;
+  }
+  const normalizedConfiguration = Object.assign({}, configuration);
+  if (normalizedConfiguration.CompressionStreamFallback === UNDEFINED_VALUE) {
+    normalizedConfiguration.CompressionStreamFallback = CompressionStreamZlib;
+  }
+  if (normalizedConfiguration.DecompressionStreamFallback === UNDEFINED_VALUE) {
+    normalizedConfiguration.DecompressionStreamFallback = DecompressionStreamZlib;
+  }
+  return normalizedConfiguration;
+}
+function setDefaultConfiguration(configuration) {
+  const checkedConfiguration = checkConfiguration(normalizeConfiguration(configuration));
+  Object.assign(DEFAULT_CONFIGURATION, checkedConfiguration);
+  Object.assign(config, checkedConfiguration);
+}
+
+// node_modules/@zip.js/zip.js/lib/core/codec-registry.js
+var ERR_INVALID_CODEC_MODULE = "Invalid codec module";
+var ERR_UNSUPPORTED_COMPRESSION2 = "Compression method not supported";
+var registeredCodecs = new Map;
+var codecStreams = new Map;
+function getRegisteredCodec(compressionMethod) {
+  return registeredCodecs.get(compressionMethod);
+}
+function getCodecStreams(format) {
+  return codecStreams.get(format);
+}
+function setCodecStreams(format, streams) {
+  const { CompressionStream: CompressionStream2, DecompressionStream: DecompressionStream2 } = streams;
+  if (typeof CompressionStream2 != FUNCTION_TYPE && typeof DecompressionStream2 != FUNCTION_TYPE) {
+    throw new Error(ERR_INVALID_CODEC_MODULE);
+  }
+  codecStreams.set(format, { CompressionStream: CompressionStream2, DecompressionStream: DecompressionStream2 });
+}
+async function ensureCodecStreams(format, codecURI) {
+  if (!codecStreams.has(format) && codecURI) {
+    setCodecStreams(format, await import(codecURI));
+  }
+}
+
+// node_modules/@zip.js/zip.js/lib/core/streams/codecs/crc32.js
+var T = [[], [], [], [], [], [], [], []];
+for (let n = 0;n < 256; n++) {
+  let t = n;
+  for (let j = 0;j < 8; j++) {
+    t = t & 1 ? t >>> 1 ^ 3988292384 : t >>> 1;
+  }
+  T[0][n] = t;
+}
+for (let n = 0;n < 256; n++) {
+  for (let k = 1;k < 8; k++) {
+    const previous = T[k - 1][n];
+    T[k][n] = previous >>> 8 ^ T[0][previous & 255];
+  }
+}
+var [T0, T1, T2, T3, T4, T5, T6, T7] = T;
+
+class Crc32 {
+  constructor(crc) {
+    this.crc = crc || -1;
+  }
+  append(data) {
+    let crc = this.crc | 0;
+    const length = data.length | 0;
+    let offset = 0;
+    if (length >= 8 && data.buffer) {
+      const view = new DataView(data.buffer, data.byteOffset, length);
+      const end = length - 8;
+      for (;offset <= end; offset += 8) {
+        const a = crc ^ view.getInt32(offset, true);
+        const b = view.getInt32(offset + 4, true);
+        crc = T7[a & 255] ^ T6[a >>> 8 & 255] ^ T5[a >>> 16 & 255] ^ T4[a >>> 24 & 255] ^ T3[b & 255] ^ T2[b >>> 8 & 255] ^ T1[b >>> 16 & 255] ^ T0[b >>> 24 & 255];
+      }
+    }
+    for (;offset < length; offset++) {
+      crc = crc >>> 8 ^ T0[(crc ^ data[offset]) & 255];
+    }
+    this.crc = crc;
+  }
+  get() {
+    return ~this.crc;
+  }
+}
+
+// node_modules/@zip.js/zip.js/lib/core/streams/crc32-stream.js
+class Crc32Stream extends TransformStream {
+  constructor() {
+    let stream;
+    const crc32 = new Crc32;
+    super({
+      transform(chunk, controller) {
+        crc32.append(chunk);
+        controller.enqueue(chunk);
+      },
+      flush() {
+        const value = new Uint8Array(4);
+        const dataView = new DataView(value.buffer);
+        dataView.setUint32(0, crc32.get());
+        stream.value = value;
+      }
+    });
+    stream = this;
+  }
+}
+
+// node_modules/@zip.js/zip.js/lib/core/util/encode-text.js
+function encodeText(value) {
+  if (typeof TextEncoder == UNDEFINED_TYPE) {
+    value = unescape(encodeURIComponent(value));
+    const result = new Uint8Array(value.length);
+    for (let i = 0;i < result.length; i++) {
+      result[i] = value.charCodeAt(i);
+    }
+    return result;
+  } else {
+    return new TextEncoder().encode(value);
+  }
+}
+
+// node_modules/@zip.js/zip.js/lib/core/util/array.js
+function concat(first, second) {
+  const result = new Uint8Array(first.length + second.length);
+  result.set(first);
+  result.set(second, first.length);
+  return result;
+}
+function toExactUint8Array(array) {
+  return array.byteOffset || array.byteLength != array.buffer.byteLength ? new Uint8Array(array) : array;
+}
+function getDataView(array) {
+  return new DataView(array.buffer, array.byteOffset, array.byteLength);
+}
+
+// node_modules/@zip.js/zip.js/lib/core/streams/codecs/aes-hmac-sha1.js
+var BLOCK_LENGTH = 16;
+var ROUND_KEYS_LENGTH = 60;
+var SHA1_BLOCK_LENGTH = 64;
+var SHA1_DIGEST_LENGTH = 20;
+var SHA1_SCHEDULE_LENGTH = 16;
+var SHA1_LENGTH_OFFSET = 56;
+var SHA1_PADDING = new Uint8Array([128]);
+var SHA1_ZERO = new Uint8Array(1);
+var SHA1_INITIAL_STATE = new Int32Array([1732584193, 4023233417, 2562383102, 271733878, 3285377520]);
+var HMAC_INNER_PADDING = 54;
+var HMAC_OUTER_PADDING = 92;
+var S_BOX = new Uint8Array(256);
+var T02 = new Int32Array(256);
+var T12 = new Int32Array(256);
+var T22 = new Int32Array(256);
+var T32 = new Int32Array(256);
+var tablesInitialized = false;
+function createEngine(key, authenticationKey) {
+  initTables();
+  const roundKeys = new Int32Array(ROUND_KEYS_LENGTH);
+  const rounds = expandKey(key, roundKeys);
+  const keystream = new Int32Array(BLOCK_LENGTH / 4);
+  const hmac = createHmac(authenticationKey);
+  let counter0 = 0;
+  let counter1 = 0;
+  let counter2 = 0;
+  let counter3 = 0;
+  return {
+    process(data, decrypt) {
+      if (decrypt) {
+        hmac.update(data, 0, data.length);
+      }
+      encrypt(data);
+      if (!decrypt) {
+        hmac.update(data, 0, data.length);
+      }
+    },
+    digest() {
+      return hmac.digest();
+    }
+  };
+  function encrypt(data) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const length = data.length;
+    let offset = 0;
+    for (;offset + BLOCK_LENGTH <= length; offset += BLOCK_LENGTH) {
+      nextKeystream();
+      view.setInt32(offset, view.getInt32(offset) ^ keystream[0]);
+      view.setInt32(offset + 4, view.getInt32(offset + 4) ^ keystream[1]);
+      view.setInt32(offset + 8, view.getInt32(offset + 8) ^ keystream[2]);
+      view.setInt32(offset + 12, view.getInt32(offset + 12) ^ keystream[3]);
+    }
+    if (offset < length) {
+      nextKeystream();
+      for (let indexByte = 0;offset < length; offset++, indexByte++) {
+        data[offset] ^= keystream[indexByte >> 2] >>> 24 - 8 * (indexByte & 3);
+      }
+    }
+  }
+  function nextKeystream() {
+    counter0 = counter0 + 1 | 0;
+    if (!counter0) {
+      counter1 = counter1 + 1 | 0;
+      if (!counter1) {
+        counter2 = counter2 + 1 | 0;
+        if (!counter2) {
+          counter3 = counter3 + 1 | 0;
+        }
+      }
+    }
+    let s0 = swapBytes(counter0) ^ roundKeys[0];
+    let s1 = swapBytes(counter1) ^ roundKeys[1];
+    let s2 = swapBytes(counter2) ^ roundKeys[2];
+    let s3 = swapBytes(counter3) ^ roundKeys[3];
+    let t0 = T02[s0 >>> 24] ^ T12[s1 >>> 16 & 255] ^ T22[s2 >>> 8 & 255] ^ T32[s3 & 255] ^ roundKeys[4];
+    let t1 = T02[s1 >>> 24] ^ T12[s2 >>> 16 & 255] ^ T22[s3 >>> 8 & 255] ^ T32[s0 & 255] ^ roundKeys[5];
+    let t2 = T02[s2 >>> 24] ^ T12[s3 >>> 16 & 255] ^ T22[s0 >>> 8 & 255] ^ T32[s1 & 255] ^ roundKeys[6];
+    let t3 = T02[s3 >>> 24] ^ T12[s0 >>> 16 & 255] ^ T22[s1 >>> 8 & 255] ^ T32[s2 & 255] ^ roundKeys[7];
+    s0 = T02[t0 >>> 24] ^ T12[t1 >>> 16 & 255] ^ T22[t2 >>> 8 & 255] ^ T32[t3 & 255] ^ roundKeys[8];
+    s1 = T02[t1 >>> 24] ^ T12[t2 >>> 16 & 255] ^ T22[t3 >>> 8 & 255] ^ T32[t0 & 255] ^ roundKeys[9];
+    s2 = T02[t2 >>> 24] ^ T12[t3 >>> 16 & 255] ^ T22[t0 >>> 8 & 255] ^ T32[t1 & 255] ^ roundKeys[10];
+    s3 = T02[t3 >>> 24] ^ T12[t0 >>> 16 & 255] ^ T22[t1 >>> 8 & 255] ^ T32[t2 & 255] ^ roundKeys[11];
+    t0 = T02[s0 >>> 24] ^ T12[s1 >>> 16 & 255] ^ T22[s2 >>> 8 & 255] ^ T32[s3 & 255] ^ roundKeys[12];
+    t1 = T02[s1 >>> 24] ^ T12[s2 >>> 16 & 255] ^ T22[s3 >>> 8 & 255] ^ T32[s0 & 255] ^ roundKeys[13];
+    t2 = T02[s2 >>> 24] ^ T12[s3 >>> 16 & 255] ^ T22[s0 >>> 8 & 255] ^ T32[s1 & 255] ^ roundKeys[14];
+    t3 = T02[s3 >>> 24] ^ T12[s0 >>> 16 & 255] ^ T22[s1 >>> 8 & 255] ^ T32[s2 & 255] ^ roundKeys[15];
+    s0 = T02[t0 >>> 24] ^ T12[t1 >>> 16 & 255] ^ T22[t2 >>> 8 & 255] ^ T32[t3 & 255] ^ roundKeys[16];
+    s1 = T02[t1 >>> 24] ^ T12[t2 >>> 16 & 255] ^ T22[t3 >>> 8 & 255] ^ T32[t0 & 255] ^ roundKeys[17];
+    s2 = T02[t2 >>> 24] ^ T12[t3 >>> 16 & 255] ^ T22[t0 >>> 8 & 255] ^ T32[t1 & 255] ^ roundKeys[18];
+    s3 = T02[t3 >>> 24] ^ T12[t0 >>> 16 & 255] ^ T22[t1 >>> 8 & 255] ^ T32[t2 & 255] ^ roundKeys[19];
+    t0 = T02[s0 >>> 24] ^ T12[s1 >>> 16 & 255] ^ T22[s2 >>> 8 & 255] ^ T32[s3 & 255] ^ roundKeys[20];
+    t1 = T02[s1 >>> 24] ^ T12[s2 >>> 16 & 255] ^ T22[s3 >>> 8 & 255] ^ T32[s0 & 255] ^ roundKeys[21];
+    t2 = T02[s2 >>> 24] ^ T12[s3 >>> 16 & 255] ^ T22[s0 >>> 8 & 255] ^ T32[s1 & 255] ^ roundKeys[22];
+    t3 = T02[s3 >>> 24] ^ T12[s0 >>> 16 & 255] ^ T22[s1 >>> 8 & 255] ^ T32[s2 & 255] ^ roundKeys[23];
+    s0 = T02[t0 >>> 24] ^ T12[t1 >>> 16 & 255] ^ T22[t2 >>> 8 & 255] ^ T32[t3 & 255] ^ roundKeys[24];
+    s1 = T02[t1 >>> 24] ^ T12[t2 >>> 16 & 255] ^ T22[t3 >>> 8 & 255] ^ T32[t0 & 255] ^ roundKeys[25];
+    s2 = T02[t2 >>> 24] ^ T12[t3 >>> 16 & 255] ^ T22[t0 >>> 8 & 255] ^ T32[t1 & 255] ^ roundKeys[26];
+    s3 = T02[t3 >>> 24] ^ T12[t0 >>> 16 & 255] ^ T22[t1 >>> 8 & 255] ^ T32[t2 & 255] ^ roundKeys[27];
+    t0 = T02[s0 >>> 24] ^ T12[s1 >>> 16 & 255] ^ T22[s2 >>> 8 & 255] ^ T32[s3 & 255] ^ roundKeys[28];
+    t1 = T02[s1 >>> 24] ^ T12[s2 >>> 16 & 255] ^ T22[s3 >>> 8 & 255] ^ T32[s0 & 255] ^ roundKeys[29];
+    t2 = T02[s2 >>> 24] ^ T12[s3 >>> 16 & 255] ^ T22[s0 >>> 8 & 255] ^ T32[s1 & 255] ^ roundKeys[30];
+    t3 = T02[s3 >>> 24] ^ T12[s0 >>> 16 & 255] ^ T22[s1 >>> 8 & 255] ^ T32[s2 & 255] ^ roundKeys[31];
+    s0 = T02[t0 >>> 24] ^ T12[t1 >>> 16 & 255] ^ T22[t2 >>> 8 & 255] ^ T32[t3 & 255] ^ roundKeys[32];
+    s1 = T02[t1 >>> 24] ^ T12[t2 >>> 16 & 255] ^ T22[t3 >>> 8 & 255] ^ T32[t0 & 255] ^ roundKeys[33];
+    s2 = T02[t2 >>> 24] ^ T12[t3 >>> 16 & 255] ^ T22[t0 >>> 8 & 255] ^ T32[t1 & 255] ^ roundKeys[34];
+    s3 = T02[t3 >>> 24] ^ T12[t0 >>> 16 & 255] ^ T22[t1 >>> 8 & 255] ^ T32[t2 & 255] ^ roundKeys[35];
+    t0 = T02[s0 >>> 24] ^ T12[s1 >>> 16 & 255] ^ T22[s2 >>> 8 & 255] ^ T32[s3 & 255] ^ roundKeys[36];
+    t1 = T02[s1 >>> 24] ^ T12[s2 >>> 16 & 255] ^ T22[s3 >>> 8 & 255] ^ T32[s0 & 255] ^ roundKeys[37];
+    t2 = T02[s2 >>> 24] ^ T12[s3 >>> 16 & 255] ^ T22[s0 >>> 8 & 255] ^ T32[s1 & 255] ^ roundKeys[38];
+    t3 = T02[s3 >>> 24] ^ T12[s0 >>> 16 & 255] ^ T22[s1 >>> 8 & 255] ^ T32[s2 & 255] ^ roundKeys[39];
+    let indexKey = 40;
+    if (rounds > 10) {
+      s0 = T02[t0 >>> 24] ^ T12[t1 >>> 16 & 255] ^ T22[t2 >>> 8 & 255] ^ T32[t3 & 255] ^ roundKeys[40];
+      s1 = T02[t1 >>> 24] ^ T12[t2 >>> 16 & 255] ^ T22[t3 >>> 8 & 255] ^ T32[t0 & 255] ^ roundKeys[41];
+      s2 = T02[t2 >>> 24] ^ T12[t3 >>> 16 & 255] ^ T22[t0 >>> 8 & 255] ^ T32[t1 & 255] ^ roundKeys[42];
+      s3 = T02[t3 >>> 24] ^ T12[t0 >>> 16 & 255] ^ T22[t1 >>> 8 & 255] ^ T32[t2 & 255] ^ roundKeys[43];
+      t0 = T02[s0 >>> 24] ^ T12[s1 >>> 16 & 255] ^ T22[s2 >>> 8 & 255] ^ T32[s3 & 255] ^ roundKeys[44];
+      t1 = T02[s1 >>> 24] ^ T12[s2 >>> 16 & 255] ^ T22[s3 >>> 8 & 255] ^ T32[s0 & 255] ^ roundKeys[45];
+      t2 = T02[s2 >>> 24] ^ T12[s3 >>> 16 & 255] ^ T22[s0 >>> 8 & 255] ^ T32[s1 & 255] ^ roundKeys[46];
+      t3 = T02[s3 >>> 24] ^ T12[s0 >>> 16 & 255] ^ T22[s1 >>> 8 & 255] ^ T32[s2 & 255] ^ roundKeys[47];
+      indexKey = 48;
+    }
+    if (rounds > 12) {
+      s0 = T02[t0 >>> 24] ^ T12[t1 >>> 16 & 255] ^ T22[t2 >>> 8 & 255] ^ T32[t3 & 255] ^ roundKeys[48];
+      s1 = T02[t1 >>> 24] ^ T12[t2 >>> 16 & 255] ^ T22[t3 >>> 8 & 255] ^ T32[t0 & 255] ^ roundKeys[49];
+      s2 = T02[t2 >>> 24] ^ T12[t3 >>> 16 & 255] ^ T22[t0 >>> 8 & 255] ^ T32[t1 & 255] ^ roundKeys[50];
+      s3 = T02[t3 >>> 24] ^ T12[t0 >>> 16 & 255] ^ T22[t1 >>> 8 & 255] ^ T32[t2 & 255] ^ roundKeys[51];
+      t0 = T02[s0 >>> 24] ^ T12[s1 >>> 16 & 255] ^ T22[s2 >>> 8 & 255] ^ T32[s3 & 255] ^ roundKeys[52];
+      t1 = T02[s1 >>> 24] ^ T12[s2 >>> 16 & 255] ^ T22[s3 >>> 8 & 255] ^ T32[s0 & 255] ^ roundKeys[53];
+      t2 = T02[s2 >>> 24] ^ T12[s3 >>> 16 & 255] ^ T22[s0 >>> 8 & 255] ^ T32[s1 & 255] ^ roundKeys[54];
+      t3 = T02[s3 >>> 24] ^ T12[s0 >>> 16 & 255] ^ T22[s1 >>> 8 & 255] ^ T32[s2 & 255] ^ roundKeys[55];
+      indexKey = 56;
+    }
+    keystream[0] = (S_BOX[t0 >>> 24] << 24 | S_BOX[t1 >>> 16 & 255] << 16 | S_BOX[t2 >>> 8 & 255] << 8 | S_BOX[t3 & 255]) ^ roundKeys[indexKey];
+    keystream[1] = (S_BOX[t1 >>> 24] << 24 | S_BOX[t2 >>> 16 & 255] << 16 | S_BOX[t3 >>> 8 & 255] << 8 | S_BOX[t0 & 255]) ^ roundKeys[indexKey + 1];
+    keystream[2] = (S_BOX[t2 >>> 24] << 24 | S_BOX[t3 >>> 16 & 255] << 16 | S_BOX[t0 >>> 8 & 255] << 8 | S_BOX[t1 & 255]) ^ roundKeys[indexKey + 2];
+    keystream[3] = (S_BOX[t3 >>> 24] << 24 | S_BOX[t0 >>> 16 & 255] << 16 | S_BOX[t1 >>> 8 & 255] << 8 | S_BOX[t2 & 255]) ^ roundKeys[indexKey + 3];
+  }
+}
+function pbkdf2(password, salt, iterations, length) {
+  const hmac = createHmac(password);
+  const result = new Uint8Array(length);
+  const block = new Uint8Array(salt.length + 4);
+  const blockView = new DataView(block.buffer);
+  block.set(salt);
+  for (let indexBlock = 1, offset = 0;offset < length; indexBlock++, offset += SHA1_DIGEST_LENGTH) {
+    blockView.setUint32(salt.length, indexBlock);
+    hmac.update(block, 0, block.length);
+    let previous = hmac.digest();
+    const output = previous.slice();
+    for (let iteration = 1;iteration < iterations; iteration++) {
+      hmac.update(previous, 0, SHA1_DIGEST_LENGTH);
+      previous = hmac.digest();
+      for (let indexByte = 0;indexByte < SHA1_DIGEST_LENGTH; indexByte++) {
+        output[indexByte] ^= previous[indexByte];
+      }
+    }
+    result.set(output.subarray(0, Math.min(SHA1_DIGEST_LENGTH, length - offset)), offset);
+  }
+  return result;
+}
+function createHmac(key) {
+  const sha1 = createSha1();
+  const innerKey = new Uint8Array(SHA1_BLOCK_LENGTH);
+  const outerKey = new Uint8Array(SHA1_BLOCK_LENGTH);
+  if (key.length > SHA1_BLOCK_LENGTH) {
+    sha1.update(key, 0, key.length);
+    key = sha1.digest();
+  }
+  for (let indexByte = 0;indexByte < SHA1_BLOCK_LENGTH; indexByte++) {
+    const keyByte = indexByte < key.length ? key[indexByte] : 0;
+    innerKey[indexByte] = keyByte ^ HMAC_INNER_PADDING;
+    outerKey[indexByte] = keyByte ^ HMAC_OUTER_PADDING;
+  }
+  sha1.update(innerKey, 0, SHA1_BLOCK_LENGTH);
+  return {
+    update(data, offset, length) {
+      sha1.update(data, offset, length);
+    },
+    digest() {
+      const innerDigest = sha1.digest();
+      sha1.update(outerKey, 0, SHA1_BLOCK_LENGTH);
+      sha1.update(innerDigest, 0, SHA1_DIGEST_LENGTH);
+      const result = sha1.digest();
+      sha1.update(innerKey, 0, SHA1_BLOCK_LENGTH);
+      return result;
+    }
+  };
+}
+function createSha1() {
+  const state = new Int32Array(SHA1_INITIAL_STATE);
+  const schedule = new Int32Array(SHA1_SCHEDULE_LENGTH);
+  const block = new Uint8Array(SHA1_BLOCK_LENGTH);
+  const blockView = new DataView(block.buffer);
+  const lengthBytes = new Uint8Array(8);
+  let blockLength = 0;
+  let totalLength = 0;
+  return {
+    update,
+    digest
+  };
+  function update(data, offset, length) {
+    const end = offset + length;
+    totalLength += length;
+    if (blockLength) {
+      while (offset < end && blockLength < SHA1_BLOCK_LENGTH) {
+        block[blockLength++] = data[offset++];
+      }
+      if (blockLength == SHA1_BLOCK_LENGTH) {
+        compress(blockView, 0);
+        blockLength = 0;
+      }
+    }
+    if (offset + SHA1_BLOCK_LENGTH <= end) {
+      const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      for (;offset + SHA1_BLOCK_LENGTH <= end; offset += SHA1_BLOCK_LENGTH) {
+        compress(view, offset);
+      }
+    }
+    while (offset < end) {
+      block[blockLength++] = data[offset++];
+    }
+  }
+  function digest() {
+    const bits = totalLength * 8;
+    const high = Math.floor(bits / 4294967296);
+    const low = bits >>> 0;
+    update(SHA1_PADDING, 0, 1);
+    while (blockLength != SHA1_LENGTH_OFFSET) {
+      update(SHA1_ZERO, 0, 1);
+    }
+    lengthBytes[0] = high >>> 24;
+    lengthBytes[1] = high >>> 16;
+    lengthBytes[2] = high >>> 8;
+    lengthBytes[3] = high;
+    lengthBytes[4] = low >>> 24;
+    lengthBytes[5] = low >>> 16;
+    lengthBytes[6] = low >>> 8;
+    lengthBytes[7] = low;
+    update(lengthBytes, 0, 8);
+    const result = new Uint8Array(SHA1_DIGEST_LENGTH);
+    const resultView = new DataView(result.buffer);
+    for (let indexWord = 0;indexWord < state.length; indexWord++) {
+      resultView.setInt32(4 * indexWord, state[indexWord]);
+    }
+    state.set(SHA1_INITIAL_STATE);
+    blockLength = 0;
+    totalLength = 0;
+    return result;
+  }
+  function compress(view, offset) {
+    for (let index = 0;index < 16; index++) {
+      schedule[index] = view.getInt32(offset + 4 * index);
+    }
+    let a = state[0];
+    let b = state[1];
+    let c = state[2];
+    let d = state[3];
+    let e = state[4];
+    let t;
+    for (let index = 0;index < 15; index += 5) {
+      e = (a << 5 | a >>> 27) + ((c ^ d) & b ^ d) + e + 1518500249 + schedule[index] | 0;
+      b = b << 30 | b >>> 2;
+      d = (e << 5 | e >>> 27) + ((b ^ c) & a ^ c) + d + 1518500249 + schedule[index + 1] | 0;
+      a = a << 30 | a >>> 2;
+      c = (d << 5 | d >>> 27) + ((a ^ b) & e ^ b) + c + 1518500249 + schedule[index + 2] | 0;
+      e = e << 30 | e >>> 2;
+      b = (c << 5 | c >>> 27) + ((e ^ a) & d ^ a) + b + 1518500249 + schedule[index + 3] | 0;
+      d = d << 30 | d >>> 2;
+      a = (b << 5 | b >>> 27) + ((d ^ e) & c ^ e) + a + 1518500249 + schedule[index + 4] | 0;
+      c = c << 30 | c >>> 2;
+    }
+    e = (a << 5 | a >>> 27) + ((c ^ d) & b ^ d) + e + 1518500249 + schedule[15] | 0;
+    b = b << 30 | b >>> 2;
+    t = schedule[13] ^ schedule[8] ^ schedule[2] ^ schedule[0];
+    t = t << 1 | t >>> 31;
+    schedule[0] = t;
+    d = (e << 5 | e >>> 27) + ((b ^ c) & a ^ c) + d + 1518500249 + t | 0;
+    a = a << 30 | a >>> 2;
+    t = schedule[14] ^ schedule[9] ^ schedule[3] ^ schedule[1];
+    t = t << 1 | t >>> 31;
+    schedule[1] = t;
+    c = (d << 5 | d >>> 27) + ((a ^ b) & e ^ b) + c + 1518500249 + t | 0;
+    e = e << 30 | e >>> 2;
+    t = schedule[15] ^ schedule[10] ^ schedule[4] ^ schedule[2];
+    t = t << 1 | t >>> 31;
+    schedule[2] = t;
+    b = (c << 5 | c >>> 27) + ((e ^ a) & d ^ a) + b + 1518500249 + t | 0;
+    d = d << 30 | d >>> 2;
+    t = schedule[0] ^ schedule[11] ^ schedule[5] ^ schedule[3];
+    t = t << 1 | t >>> 31;
+    schedule[3] = t;
+    a = (b << 5 | b >>> 27) + ((d ^ e) & c ^ e) + a + 1518500249 + t | 0;
+    c = c << 30 | c >>> 2;
+    for (let index = 20;index < 40; index += 5) {
+      t = schedule[index - 3 & 15] ^ schedule[index - 8 & 15] ^ schedule[index - 14 & 15] ^ schedule[index & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index & 15] = t;
+      e = (a << 5 | a >>> 27) + (b ^ c ^ d) + e + 1859775393 + t | 0;
+      b = b << 30 | b >>> 2;
+      t = schedule[index - 2 & 15] ^ schedule[index - 7 & 15] ^ schedule[index - 13 & 15] ^ schedule[index + 1 & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index + 1 & 15] = t;
+      d = (e << 5 | e >>> 27) + (a ^ b ^ c) + d + 1859775393 + t | 0;
+      a = a << 30 | a >>> 2;
+      t = schedule[index - 1 & 15] ^ schedule[index - 6 & 15] ^ schedule[index - 12 & 15] ^ schedule[index + 2 & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index + 2 & 15] = t;
+      c = (d << 5 | d >>> 27) + (e ^ a ^ b) + c + 1859775393 + t | 0;
+      e = e << 30 | e >>> 2;
+      t = schedule[index & 15] ^ schedule[index - 5 & 15] ^ schedule[index - 11 & 15] ^ schedule[index + 3 & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index + 3 & 15] = t;
+      b = (c << 5 | c >>> 27) + (d ^ e ^ a) + b + 1859775393 + t | 0;
+      d = d << 30 | d >>> 2;
+      t = schedule[index + 1 & 15] ^ schedule[index - 4 & 15] ^ schedule[index - 10 & 15] ^ schedule[index + 4 & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index + 4 & 15] = t;
+      a = (b << 5 | b >>> 27) + (c ^ d ^ e) + a + 1859775393 + t | 0;
+      c = c << 30 | c >>> 2;
+    }
+    for (let index = 40;index < 60; index += 5) {
+      t = schedule[index - 3 & 15] ^ schedule[index - 8 & 15] ^ schedule[index - 14 & 15] ^ schedule[index & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index & 15] = t;
+      e = (a << 5 | a >>> 27) + (b & c | (b | c) & d) + e + 2400959708 + t | 0;
+      b = b << 30 | b >>> 2;
+      t = schedule[index - 2 & 15] ^ schedule[index - 7 & 15] ^ schedule[index - 13 & 15] ^ schedule[index + 1 & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index + 1 & 15] = t;
+      d = (e << 5 | e >>> 27) + (a & b | (a | b) & c) + d + 2400959708 + t | 0;
+      a = a << 30 | a >>> 2;
+      t = schedule[index - 1 & 15] ^ schedule[index - 6 & 15] ^ schedule[index - 12 & 15] ^ schedule[index + 2 & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index + 2 & 15] = t;
+      c = (d << 5 | d >>> 27) + (e & a | (e | a) & b) + c + 2400959708 + t | 0;
+      e = e << 30 | e >>> 2;
+      t = schedule[index & 15] ^ schedule[index - 5 & 15] ^ schedule[index - 11 & 15] ^ schedule[index + 3 & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index + 3 & 15] = t;
+      b = (c << 5 | c >>> 27) + (d & e | (d | e) & a) + b + 2400959708 + t | 0;
+      d = d << 30 | d >>> 2;
+      t = schedule[index + 1 & 15] ^ schedule[index - 4 & 15] ^ schedule[index - 10 & 15] ^ schedule[index + 4 & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index + 4 & 15] = t;
+      a = (b << 5 | b >>> 27) + (c & d | (c | d) & e) + a + 2400959708 + t | 0;
+      c = c << 30 | c >>> 2;
+    }
+    for (let index = 60;index < 80; index += 5) {
+      t = schedule[index - 3 & 15] ^ schedule[index - 8 & 15] ^ schedule[index - 14 & 15] ^ schedule[index & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index & 15] = t;
+      e = (a << 5 | a >>> 27) + (b ^ c ^ d) + e + 3395469782 + t | 0;
+      b = b << 30 | b >>> 2;
+      t = schedule[index - 2 & 15] ^ schedule[index - 7 & 15] ^ schedule[index - 13 & 15] ^ schedule[index + 1 & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index + 1 & 15] = t;
+      d = (e << 5 | e >>> 27) + (a ^ b ^ c) + d + 3395469782 + t | 0;
+      a = a << 30 | a >>> 2;
+      t = schedule[index - 1 & 15] ^ schedule[index - 6 & 15] ^ schedule[index - 12 & 15] ^ schedule[index + 2 & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index + 2 & 15] = t;
+      c = (d << 5 | d >>> 27) + (e ^ a ^ b) + c + 3395469782 + t | 0;
+      e = e << 30 | e >>> 2;
+      t = schedule[index & 15] ^ schedule[index - 5 & 15] ^ schedule[index - 11 & 15] ^ schedule[index + 3 & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index + 3 & 15] = t;
+      b = (c << 5 | c >>> 27) + (d ^ e ^ a) + b + 3395469782 + t | 0;
+      d = d << 30 | d >>> 2;
+      t = schedule[index + 1 & 15] ^ schedule[index - 4 & 15] ^ schedule[index - 10 & 15] ^ schedule[index + 4 & 15];
+      t = t << 1 | t >>> 31;
+      schedule[index + 4 & 15] = t;
+      a = (b << 5 | b >>> 27) + (c ^ d ^ e) + a + 3395469782 + t | 0;
+      c = c << 30 | c >>> 2;
+    }
+    state[0] = state[0] + a | 0;
+    state[1] = state[1] + b | 0;
+    state[2] = state[2] + c | 0;
+    state[3] = state[3] + d | 0;
+    state[4] = state[4] + e | 0;
+  }
+}
+function initTables() {
+  if (!tablesInitialized) {
+    let p = 1;
+    let q = 1;
+    do {
+      p = (p ^ p << 1 ^ (p & 128 ? 27 : 0)) & 255;
+      q = (q ^ q << 1) & 255;
+      q = (q ^ q << 2) & 255;
+      q = (q ^ q << 4) & 255;
+      if (q & 128) {
+        q ^= 9;
+      }
+      S_BOX[p] = (q ^ (q << 1 | q >> 7) ^ (q << 2 | q >> 6) ^ (q << 3 | q >> 5) ^ (q << 4 | q >> 4) ^ 99) & 255;
+    } while (p != 1);
+    S_BOX[0] = 99;
+    for (let index = 0;index < 256; index++) {
+      const s = S_BOX[index];
+      const s2 = multiplyByTwo(s);
+      const t = s2 << 24 | s << 16 | s << 8 | s2 ^ s;
+      T02[index] = t;
+      T12[index] = t >>> 8 | t << 24;
+      T22[index] = t >>> 16 | t << 16;
+      T32[index] = t >>> 24 | t << 8;
+    }
+    tablesInitialized = true;
+  }
+}
+function expandKey(key, roundKeys) {
+  const keyWords = key.length >> 2;
+  const rounds = keyWords + 6;
+  const total = 4 * (rounds + 1);
+  let roundConstant = 1;
+  for (let index = 0;index < keyWords; index++) {
+    roundKeys[index] = key[4 * index] << 24 | key[4 * index + 1] << 16 | key[4 * index + 2] << 8 | key[4 * index + 3];
+  }
+  for (let index = keyWords;index < total; index++) {
+    let word = roundKeys[index - 1];
+    if (index % keyWords == 0) {
+      word = substituteWord(word << 8 | word >>> 24) ^ roundConstant << 24;
+      roundConstant = multiplyByTwo(roundConstant);
+    } else if (keyWords > 6 && index % keyWords == 4) {
+      word = substituteWord(word);
+    }
+    roundKeys[index] = roundKeys[index - keyWords] ^ word;
+  }
+  return rounds;
+}
+function substituteWord(word) {
+  return S_BOX[word >>> 24] << 24 | S_BOX[word >>> 16 & 255] << 16 | S_BOX[word >>> 8 & 255] << 8 | S_BOX[word & 255];
+}
+function swapBytes(value) {
+  return value << 24 | (value & 65280) << 8 | value >>> 8 & 65280 | value >>> 24;
+}
+function multiplyByTwo(value) {
+  return (value << 1 ^ (value >> 7) * 27) & 255;
+}
+
+// node_modules/@zip.js/zip.js/lib/core/streams/common-crypto.js
+var GET_RANDOM_VALUES_SUPPORTED = typeof crypto != UNDEFINED_TYPE && typeof crypto.getRandomValues == FUNCTION_TYPE;
+var ERR_INVALID_PASSWORD2 = "Invalid password";
+var ERR_INVALID_AUTHENTICATION_CODE2 = "Invalid authentication code";
+var ERR_ABORT_CHECK_PASSWORD = "zipjs-abort-check-password";
+var ERR_UNSUPPORTED_CRYPTO_API = "Crypto API not supported";
+function getRandomValues(array) {
+  if (GET_RANDOM_VALUES_SUPPORTED) {
+    return crypto.getRandomValues(array);
+  } else {
+    throw new Error(ERR_UNSUPPORTED_CRYPTO_API);
+  }
+}
+
+// node_modules/@zip.js/zip.js/lib/core/streams/aes-crypto-stream.js
+var BLOCK_LENGTH2 = 16;
+var RAW_FORMAT = "raw";
+var PBKDF2_ALGORITHM = { name: "PBKDF2" };
+var HASH_ALGORITHM = { name: "HMAC" };
+var HASH_FUNCTION = "SHA-1";
+var PBKDF2_ITERATIONS = 1000;
+var BASE_KEY_ALGORITHM = Object.assign({ hash: HASH_ALGORITHM }, PBKDF2_ALGORITHM);
+var DERIVED_BITS_ALGORITHM = Object.assign({ iterations: PBKDF2_ITERATIONS, hash: { name: HASH_FUNCTION } }, PBKDF2_ALGORITHM);
+var DERIVED_BITS_USAGE = ["deriveBits"];
+var SALT_LENGTH = [8, 12, 16];
+var KEY_LENGTH = [16, 24, 32];
+var AUTHENTICATION_CODE_LENGTH = 10;
+var PASSWORD_VERIFICATION_LENGTH = 2;
+var CRYPTO_API_SUPPORTED = typeof crypto != UNDEFINED_TYPE;
+var subtle = CRYPTO_API_SUPPORTED && crypto.subtle;
+var SUBTLE_API_SUPPORTED = CRYPTO_API_SUPPORTED && typeof subtle != UNDEFINED_TYPE;
+var DERIVE_BITS_SUPPORTED = SUBTLE_API_SUPPORTED && typeof subtle.importKey == FUNCTION_TYPE && typeof subtle.deriveBits == FUNCTION_TYPE;
+var createEngine2 = createEngine;
+
+class AESDecryptionStream extends TransformStream {
+  constructor({ password, rawPassword, encryptionStrength, checkPasswordOnly, checkAuthenticationCode = true }) {
+    const aesCrypto = {};
+    super({
+      start() {
+        initAesCrypto(aesCrypto, password, rawPassword, encryptionStrength);
+      },
+      async transform(chunk, controller) {
+        const {
+          password,
+          strength,
+          resolveReady,
+          ready
+        } = aesCrypto;
+        if (password) {
+          await createDecryptionKeys(aesCrypto, strength, password, subarray(chunk, 0, SALT_LENGTH[strength] + PASSWORD_VERIFICATION_LENGTH));
+          chunk = subarray(chunk, SALT_LENGTH[strength] + PASSWORD_VERIFICATION_LENGTH);
+          if (checkPasswordOnly) {
+            disposeEngine(aesCrypto);
+            controller.error(new Error(ERR_ABORT_CHECK_PASSWORD));
+          } else {
+            resolveReady();
+          }
+        } else {
+          await ready;
+        }
+        if (aesCrypto.discarded) {
+          return;
+        }
+        const output = new Uint8Array(chunk.length - AUTHENTICATION_CODE_LENGTH - (chunk.length - AUTHENTICATION_CODE_LENGTH) % BLOCK_LENGTH2);
+        controller.enqueue(append(aesCrypto, chunk, output, 0, AUTHENTICATION_CODE_LENGTH, true));
+      },
+      async flush(controller) {
+        const {
+          engine,
+          pendingInput,
+          ready
+        } = aesCrypto;
+        if (engine) {
+          await ready;
+          if (aesCrypto.discarded) {
+            return;
+          }
+          const originalAuthenticationCode = subarray(pendingInput, pendingInput.length - AUTHENTICATION_CODE_LENGTH);
+          const decryptedChunkArray = new Uint8Array(subarray(pendingInput, 0, pendingInput.length - AUTHENTICATION_CODE_LENGTH));
+          engine.process(decryptedChunkArray, true);
+          const authenticationCode = engine.digest();
+          let invalidAuthenticationCode = pendingInput.length < AUTHENTICATION_CODE_LENGTH ? 1 : 0;
+          for (let indexByte = 0;indexByte < AUTHENTICATION_CODE_LENGTH; indexByte++) {
+            invalidAuthenticationCode |= authenticationCode[indexByte] ^ originalAuthenticationCode[indexByte];
+          }
+          if (invalidAuthenticationCode && checkAuthenticationCode) {
+            controller.error(new Error(ERR_INVALID_AUTHENTICATION_CODE2));
+            return;
+          }
+          controller.enqueue(decryptedChunkArray);
+        }
+      }
+    });
+    setDisposingReadable(this, aesCrypto);
+  }
+}
+
+class AESEncryptionStream extends TransformStream {
+  constructor({ password, rawPassword, encryptionStrength }) {
+    const aesCrypto = {};
+    super({
+      start() {
+        initAesCrypto(aesCrypto, password, rawPassword, encryptionStrength);
+      },
+      async transform(chunk, controller) {
+        const {
+          password,
+          strength,
+          resolveReady,
+          ready
+        } = aesCrypto;
+        let preamble = EMPTY_UINT8_ARRAY;
+        if (password) {
+          preamble = await createEncryptionKeys(aesCrypto, strength, password);
+          resolveReady();
+        } else {
+          await ready;
+        }
+        if (aesCrypto.discarded) {
+          return;
+        }
+        const output = new Uint8Array(preamble.length + chunk.length - chunk.length % BLOCK_LENGTH2);
+        output.set(preamble, 0);
+        controller.enqueue(append(aesCrypto, chunk, output, preamble.length, 0, false));
+      },
+      async flush(controller) {
+        const {
+          engine,
+          pendingInput,
+          ready
+        } = aesCrypto;
+        if (engine) {
+          await ready;
+          if (aesCrypto.discarded) {
+            return;
+          }
+          const encryptedChunkArray = new Uint8Array(pendingInput);
+          engine.process(encryptedChunkArray, false);
+          const authenticationCode = subarray(engine.digest(), 0, AUTHENTICATION_CODE_LENGTH);
+          controller.enqueue(concat(encryptedChunkArray, authenticationCode));
+        }
+      }
+    });
+    setDisposingReadable(this, aesCrypto);
+  }
+}
+function setAESEngine(createEngineFunction) {
+  createEngine2 = createEngineFunction || createEngine;
+}
+function initAesCrypto(aesCrypto, password, rawPassword, encryptionStrength) {
+  Object.assign(aesCrypto, {
+    ready: new Promise((resolve) => aesCrypto.resolveReady = resolve),
+    password: encodePassword(password, rawPassword),
+    strength: encryptionStrength - 1,
+    pendingInput: EMPTY_UINT8_ARRAY,
+    discarded: false
+  });
+}
+function setDisposingReadable(stream, aesCrypto) {
+  const reader = stream.readable.getReader();
+  const readable = new ReadableStream({
+    async pull(controller) {
+      try {
+        const { value, done } = await reader.read();
+        if (done) {
+          controller.close();
+        } else {
+          controller.enqueue(value);
+        }
+      } catch (error) {
+        disposeEngine(aesCrypto);
+        reader.cancel(error).catch(() => {});
+        throw error;
+      }
+    },
+    cancel(reason) {
+      disposeEngine(aesCrypto);
+      return reader.cancel(reason);
+    }
+  });
+  Object.defineProperty(stream, "readable", {
+    get() {
+      return readable;
+    }
+  });
+}
+function append(aesCrypto, input, output, paddingStart, paddingEnd, decrypt) {
+  const {
+    engine,
+    pendingInput
+  } = aesCrypto;
+  if (pendingInput.length) {
+    input = concat(pendingInput, input);
+  }
+  const inputLength = input.length - paddingEnd;
+  const alignedLength = inputLength - inputLength % BLOCK_LENGTH2;
+  output = expand(output, paddingStart + alignedLength);
+  if (alignedLength) {
+    const chunk = subarray(output, paddingStart, paddingStart + alignedLength);
+    chunk.set(subarray(input, 0, alignedLength));
+    engine.process(chunk, decrypt);
+  }
+  aesCrypto.pendingInput = subarray(input, alignedLength);
+  return output;
+}
+async function createDecryptionKeys(decrypt, strength, password, preamble) {
+  const passwordVerificationKey = await createKeys(decrypt, strength, password, subarray(preamble, 0, SALT_LENGTH[strength]));
+  const passwordVerification = subarray(preamble, SALT_LENGTH[strength]);
+  if (passwordVerificationKey[0] != passwordVerification[0] || passwordVerificationKey[1] != passwordVerification[1]) {
+    disposeEngine(decrypt);
+    throw new Error(ERR_INVALID_PASSWORD2);
+  }
+}
+function disposeEngine(aesCrypto) {
+  const { engine } = aesCrypto;
+  aesCrypto.discarded = true;
+  if (engine && engine.dispose) {
+    engine.dispose();
+  }
+}
+async function createEncryptionKeys(encrypt, strength, password) {
+  const salt = getRandomValues(new Uint8Array(SALT_LENGTH[strength]));
+  const passwordVerification = await createKeys(encrypt, strength, password, salt);
+  return concat(salt, passwordVerification);
+}
+async function createKeys(aesCrypto, strength, password, salt) {
+  aesCrypto.password = null;
+  const keyLength = KEY_LENGTH[strength];
+  const compositeKey = await deriveKey(password, salt, keyLength * 2 + PASSWORD_VERIFICATION_LENGTH);
+  aesCrypto.engine = createEngine2(subarray(compositeKey, 0, keyLength), subarray(compositeKey, keyLength, keyLength * 2));
+  if (aesCrypto.discarded) {
+    disposeEngine(aesCrypto);
+  }
+  return subarray(compositeKey, keyLength * 2);
+}
+async function deriveKey(password, salt, length) {
+  if (DERIVE_BITS_SUPPORTED) {
+    try {
+      const baseKey = await subtle.importKey(RAW_FORMAT, password, BASE_KEY_ALGORITHM, false, DERIVED_BITS_USAGE);
+      return new Uint8Array(await subtle.deriveBits(Object.assign({ salt }, DERIVED_BITS_ALGORITHM), baseKey, length * 8));
+    } catch {
+      DERIVE_BITS_SUPPORTED = false;
+    }
+  }
+  return pbkdf2(password, salt, PBKDF2_ITERATIONS, length);
+}
+function encodePassword(password, rawPassword) {
+  if (rawPassword === UNDEFINED_VALUE) {
+    return encodeText(password);
+  } else {
+    return rawPassword;
+  }
+}
+function expand(inputArray, length) {
+  if (length && length > inputArray.length) {
+    const array = inputArray;
+    inputArray = new Uint8Array(length);
+    inputArray.set(array, 0);
+  }
+  return inputArray;
+}
+function subarray(array, begin, end) {
+  return array.subarray(begin, end);
+}
+
+// node_modules/@zip.js/zip.js/lib/core/streams/zip-crypto-stream.js
+var HEADER_LENGTH = 12;
+
+class ZipCryptoDecryptionStream extends TransformStream {
+  constructor({ password, rawPassword, passwordVerification, checkPasswordOnly }) {
+    super({
+      start() {
+        initZipCrypto(this, password, rawPassword, passwordVerification);
+      },
+      transform(chunk, controller) {
+        const zipCrypto = this;
+        if (zipCrypto.password || zipCrypto.rawPassword) {
+          const decryptedHeader = decrypt(zipCrypto, chunk.subarray(0, HEADER_LENGTH));
+          zipCrypto.password = zipCrypto.rawPassword = null;
+          if ((decryptedHeader[HEADER_LENGTH - 1] ^ zipCrypto.passwordVerification) != 0) {
+            throw new Error(ERR_INVALID_PASSWORD2);
+          }
+          chunk = chunk.subarray(HEADER_LENGTH);
+        }
+        if (checkPasswordOnly) {
+          controller.error(new Error(ERR_ABORT_CHECK_PASSWORD));
+        } else {
+          controller.enqueue(decrypt(zipCrypto, chunk));
+        }
+      }
+    });
+  }
+}
+
+class ZipCryptoEncryptionStream extends TransformStream {
+  constructor({ password, rawPassword, passwordVerification }) {
+    super({
+      start() {
+        initZipCrypto(this, password, rawPassword, passwordVerification);
+      },
+      transform(chunk, controller) {
+        const zipCrypto = this;
+        let output;
+        let offset;
+        if (zipCrypto.password || zipCrypto.rawPassword) {
+          zipCrypto.password = zipCrypto.rawPassword = null;
+          const header = getRandomValues(new Uint8Array(HEADER_LENGTH));
+          header[HEADER_LENGTH - 1] = zipCrypto.passwordVerification;
+          output = new Uint8Array(chunk.length + header.length);
+          output.set(encrypt(zipCrypto, header), 0);
+          offset = HEADER_LENGTH;
+        } else {
+          output = new Uint8Array(chunk.length);
+          offset = 0;
+        }
+        output.set(encrypt(zipCrypto, chunk), offset);
+        controller.enqueue(output);
+      }
+    });
+  }
+}
+function initZipCrypto(zipCrypto, password, rawPassword, passwordVerification) {
+  Object.assign(zipCrypto, {
+    password,
+    rawPassword,
+    passwordVerification
+  });
+  createKeys2(zipCrypto, password, rawPassword);
+}
+function decrypt(target, input) {
+  const output = new Uint8Array(input.length);
+  for (let index = 0;index < input.length; index++) {
+    output[index] = getByte(target) ^ input[index];
+    updateKeys(target, output[index]);
+  }
+  return output;
+}
+function encrypt(target, input) {
+  const output = new Uint8Array(input.length);
+  for (let index = 0;index < input.length; index++) {
+    output[index] = getByte(target) ^ input[index];
+    updateKeys(target, input[index]);
+  }
+  return output;
+}
+function createKeys2(target, password, rawPassword) {
+  const cryptoKeys = [305419896, 591751049, 878082192];
+  Object.assign(target, {
+    cryptoKeys,
+    crcKey0: new Crc32(cryptoKeys[0]),
+    crcKey2: new Crc32(cryptoKeys[2])
+  });
+  if (rawPassword) {
+    for (let index = 0;index < rawPassword.length; index++) {
+      updateKeys(target, rawPassword[index]);
+    }
+  } else {
+    for (let index = 0;index < password.length; index++) {
+      updateKeys(target, password.charCodeAt(index));
+    }
+  }
+}
+function updateKeys(target, byte) {
+  let [, key1] = target.cryptoKeys;
+  target.crcKey0.append([byte]);
+  const key0 = ~target.crcKey0.get();
+  key1 = getInt32(Math.imul(getInt32(key1 + getInt8(key0)), 134775813) + 1);
+  target.crcKey2.append([key1 >>> 24]);
+  const key2 = ~target.crcKey2.get();
+  target.cryptoKeys = [key0, key1, key2];
+}
+function getByte(target) {
+  const temp = target.cryptoKeys[2] | 2;
+  return getInt8(Math.imul(temp, temp ^ 1) >>> 8);
+}
+function getInt8(number) {
+  return number & 255;
+}
+function getInt32(number) {
+  return number & 4294967295;
+}
+
+// node_modules/@zip.js/zip.js/lib/core/util/compatible-streams.js
+function toCompatibleReadable(readable) {
+  if (readable instanceof ReadableStream) {
+    return readable;
+  }
+  const reader = readable.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { value, done } = await reader.read();
+        if (done) {
+          controller.close();
+        } else {
+          controller.enqueue(value);
+        }
+      } catch (error) {
+        reader.cancel(error).catch(() => {});
+        throw error;
+      }
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    }
+  });
+}
+function streamToBlob(readable, contentType) {
+  readable = toCompatibleReadable(readable);
+  const blobOptions = contentType ? { type: contentType } : {};
+  if (responseSupportsGlobalReadable()) {
+    return new Response(readable).blob().then((blob) => contentType ? new Blob([blob], blobOptions) : blob);
+  }
+  const chunks = [];
+  return readable.pipeTo(new WritableStream({
+    write(chunk) {
+      chunks.push(chunk);
+    }
+  })).then(() => new Blob(chunks, blobOptions));
+}
+function responseSupportsGlobalReadable() {
+  return typeof Blob.prototype.stream != FUNCTION_TYPE || new Blob([]).stream() instanceof ReadableStream;
+}
+function toCompatibleWritable(writable) {
+  if (writable instanceof WritableStream) {
+    return writable;
+  }
+  const writer = writable.getWriter();
+  return new WritableStream({
+    write(chunk) {
+      return writer.write(chunk);
+    },
+    close() {
+      return writer.close();
+    },
+    abort(reason) {
+      return writer.abort(reason);
+    }
+  });
+}
+
+// node_modules/@zip.js/zip.js/lib/core/util/error.js
+function isErrorObject(error) {
+  return Boolean(error) && typeof error == "object";
+}
+
+// node_modules/@zip.js/zip.js/lib/core/streams/zip-entry-stream.js
+var ERR_INVALID_UNCOMPRESSED_SIZE2 = "Invalid uncompressed size";
+var ERR_INVALID_COMPRESSED_DATA2 = "Invalid compressed data";
+var ERR_CODEC_OUT_OF_MEMORY2 = "Codec out of memory";
+var ERR_INVALID_CRC322 = "Invalid CRC32";
+var Z_MEM_ERROR_CODE = "Z_MEM_ERROR";
+var FORMAT_DEFLATE_RAW = "deflate-raw";
+var FORMAT_DEFLATE64_RAW = "deflate64-raw";
+var FORMAT_GZIP = "gzip";
+var GZIP_HEADER_LENGTH = 10;
+var GZIP_TRAILER_LENGTH = 8;
+var GZIP_HEADER_BYTES = [31, 139, 8];
+
+class DeflateStream extends TransformStream {
+  constructor(options, { chunkSize, CompressionStreamFallback, CompressionStream: CompressionStream2 }) {
+    super({});
+    const { compressed, encrypted, useCompressionStream, zipCrypto, computeCrc32, level, deflate64, format, compressionMethod, inputSize } = options;
+    const stream = this;
+    let crc32Stream, encryptionStream, gzipCrc32Stream;
+    let readable = super.readable;
+    const codecStreams = format && getCodecStreams(format);
+    const GzipCompressionStream = getGzipCodecStream(useCompressionStream, CompressionStream2, CompressionStreamFallback);
+    const useGzipCrc32 = computeCrc32 && compressed && !deflate64 && !codecStreams && (!encrypted || zipCrypto) && Boolean(GzipCompressionStream);
+    if ((!encrypted || zipCrypto) && computeCrc32 && !useGzipCrc32) {
+      crc32Stream = new Crc32Stream;
+      readable = pipeThrough(readable, crc32Stream);
+    }
+    if (compressed) {
+      if (codecStreams) {
+        readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.CompressionStream, format, { level, chunkSize, compressionMethod, uncompressedSize: inputSize }));
+      } else if (useGzipCrc32) {
+        gzipCrc32Stream = new GzipToRawDeflateStream;
+        readable = pipeThroughBackpressured(readable, new GzipCompressionStream(FORMAT_GZIP, { level, chunkSize }));
+        readable = pipeThrough(readable, gzipCrc32Stream);
+      } else {
+        try {
+          readable = pipeThroughCompressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream2, CompressionStreamFallback);
+        } catch (error) {
+          if (!useCompressionStream && CompressionStreamFallback) {
+            throw mapMemoryError(error);
+          }
+          let gzipStream;
+          try {
+            gzipStream = new CompressionStream2(FORMAT_GZIP);
+          } catch {
+            throw mapMemoryError(error);
+          }
+          readable = pipeThroughBackpressured(readable, gzipStream);
+          readable = pipeThrough(readable, new GzipToRawDeflateStream);
+        }
+      }
+    }
+    if (encrypted) {
+      if (zipCrypto) {
+        readable = pipeThrough(readable, new ZipCryptoEncryptionStream(options));
+      } else {
+        encryptionStream = new AESEncryptionStream(options);
+        readable = pipeThrough(readable, encryptionStream);
+      }
+    }
+    setReadable(stream, readable, () => {
+      if ((!encrypted || zipCrypto) && computeCrc32) {
+        stream.crc32 = useGzipCrc32 ? gzipCrc32Stream.crc32 : new DataView(crc32Stream.value.buffer).getUint32(0);
+      }
+    });
+  }
+}
+
+class GzipToRawDeflateStream extends TransformStream {
+  constructor() {
+    let stream;
+    let headerBytesLeft = GZIP_HEADER_LENGTH;
+    let trailerCandidate = new Uint8Array(0);
+    super({
+      transform(chunk, controller) {
+        if (headerBytesLeft) {
+          const droppedLength = Math.min(headerBytesLeft, chunk.length);
+          headerBytesLeft -= droppedLength;
+          chunk = chunk.subarray(droppedLength);
+          if (!chunk.length) {
+            return;
+          }
+        }
+        const availableLength = trailerCandidate.length + chunk.length;
+        if (availableLength <= GZIP_TRAILER_LENGTH) {
+          trailerCandidate = concat(trailerCandidate, chunk);
+          return;
+        }
+        const emitLength = availableLength - GZIP_TRAILER_LENGTH;
+        const emittedFromTrailer = Math.min(emitLength, trailerCandidate.length);
+        controller.enqueue(concat(trailerCandidate.subarray(0, emittedFromTrailer), chunk.subarray(0, emitLength - emittedFromTrailer)));
+        trailerCandidate = concat(trailerCandidate.subarray(emittedFromTrailer), chunk.subarray(emitLength - emittedFromTrailer));
+      },
+      flush() {
+        const dataView = getDataView(trailerCandidate);
+        stream.crc32 = dataView.getUint32(0, true);
+        stream.uncompressedSize = dataView.getUint32(4, true);
+      }
+    });
+    stream = this;
+  }
+}
+function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32, sourceErrors) {
+  const writer = gzipStream.writable.getWriter();
+  const reader = gzipStream.readable.getReader();
+  const outputCrc32 = crc32 === UNDEFINED_VALUE ? new Crc32 : UNDEFINED_VALUE;
+  let outputLength = 0;
+  let trailerWritten = false;
+  let settled = false;
+  let resolvePull, controller;
+  const output = new ReadableStream({
+    start(streamController) {
+      controller = streamController;
+    },
+    pull() {
+      resumePump();
+    },
+    cancel(reason) {
+      settled = true;
+      resumePump();
+      return reader.cancel(reason);
+    }
+  });
+  pump();
+  drain();
+  return output;
+  async function pump() {
+    const inputReader = readable.getReader();
+    try {
+      const header = new Uint8Array(GZIP_HEADER_LENGTH);
+      header.set(GZIP_HEADER_BYTES);
+      await writer.write(header);
+      for (;; ) {
+        await outputCapacity();
+        await writer.ready;
+        const { value, done } = await readSource(inputReader, sourceErrors);
+        if (done) {
+          break;
+        }
+        await writer.write(value);
+      }
+      if (outputCrc32) {
+        await writer.write(new Uint8Array(0));
+      }
+      const trailer = new Uint8Array(GZIP_TRAILER_LENGTH);
+      const dataView = getDataView(trailer);
+      dataView.setUint32(0, outputCrc32 ? outputCrc32.get() : crc32, true);
+      dataView.setUint32(4, outputSize, true);
+      trailerWritten = true;
+      await writer.write(trailer);
+      await writer.close();
+    } catch (error) {
+      await abort(writer, error);
+      await cancel(inputReader, error);
+    }
+  }
+  async function drain() {
+    try {
+      for (;; ) {
+        const { value, done } = await read();
+        if (done) {
+          break;
+        }
+        outputLength += value.length;
+        if (outputLength > outputSize) {
+          throw new Error(ERR_INVALID_UNCOMPRESSED_SIZE2);
+        }
+        if (outputCrc32) {
+          outputCrc32.append(value);
+        }
+        controller.enqueue(value);
+      }
+      if (!settled) {
+        settled = true;
+        controller.close();
+      }
+    } catch (error) {
+      fail(error);
+      await cancel(reader, error);
+    }
+  }
+  function read() {
+    return reader.read().catch((error) => {
+      if (trailerWritten) {
+        if (!outputCrc32) {
+          throw mapError(error, ERR_INVALID_CRC322);
+        }
+        if (outputLength != outputSize) {
+          throw mapError(error, ERR_INVALID_UNCOMPRESSED_SIZE2);
+        }
+        return { done: true };
+      }
+      throw mapCodecError(error, sourceErrors);
+    });
+  }
+  function outputCapacity() {
+    if (!settled && controller.desiredSize <= 0) {
+      return new Promise((resolve) => resolvePull = resolve);
+    }
+  }
+  function resumePump() {
+    if (resolvePull) {
+      const resolve = resolvePull;
+      resolvePull = UNDEFINED_VALUE;
+      resolve();
+    }
+  }
+  function fail(error) {
+    if (!settled) {
+      settled = true;
+      controller.error(error);
+      resumePump();
+    }
+  }
+}
+
+class InflateStream extends TransformStream {
+  constructor(options, { chunkSize, DecompressionStreamFallback, DecompressionStream: DecompressionStream2 }) {
+    super({});
+    const { zipCrypto, encrypted, checkCrc32, crc32, compressed, useCompressionStream, deflate64, format, compressionMethod, rawBitFlag, outputSize } = options;
+    let crc32Stream, decryptionStream, gzipCrc32;
+    let readable = super.readable;
+    if (encrypted) {
+      if (zipCrypto) {
+        readable = pipeThrough(readable, new ZipCryptoDecryptionStream(options));
+      } else {
+        decryptionStream = new AESDecryptionStream(options);
+        readable = pipeThrough(readable, decryptionStream);
+      }
+    }
+    if (compressed) {
+      const sourceErrors = new Set;
+      const codecStreams = format && getCodecStreams(format);
+      let gzipStream;
+      if (codecStreams) {
+        readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.DecompressionStream, format, { chunkSize, compressionMethod, rawBitFlag, uncompressedSize: outputSize }), sourceErrors);
+      } else {
+        const GzipDecompressionStream = getGzipCodecStream(useCompressionStream, DecompressionStream2, DecompressionStreamFallback);
+        if (checkCrc32 && !deflate64 && crc32 !== UNDEFINED_VALUE && outputSize !== UNDEFINED_VALUE && GzipDecompressionStream) {
+          try {
+            gzipStream = new GzipDecompressionStream(FORMAT_GZIP, { chunkSize });
+          } catch {
+            gzipStream = UNDEFINED_VALUE;
+          }
+        }
+        if (!gzipStream) {
+          try {
+            readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream2, DecompressionStreamFallback, sourceErrors);
+          } catch (error) {
+            if (deflate64 || outputSize === UNDEFINED_VALUE || !useCompressionStream && DecompressionStreamFallback) {
+              throw mapMemoryError(error);
+            }
+            try {
+              gzipStream = new DecompressionStream2(FORMAT_GZIP);
+            } catch {
+              throw mapMemoryError(error);
+            }
+          }
+        }
+      }
+      if (gzipStream) {
+        gzipCrc32 = true;
+        readable = pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32, sourceErrors);
+      } else {
+        readable = mapInflateStreamError(readable, sourceErrors);
+      }
+    }
+    if (checkCrc32 && !gzipCrc32) {
+      crc32Stream = new Crc32Stream;
+      readable = pipeThrough(readable, crc32Stream);
+    }
+    setReadable(this, readable, () => {
+      if (crc32Stream) {
+        const computedCrc32 = new DataView(crc32Stream.value.buffer).getUint32(0, false);
+        if (crc32 != computedCrc32) {
+          throw new Error(ERR_INVALID_CRC322);
+        }
+      }
+    });
+  }
+}
+var formatSupportByStream = new Map;
+function supportsFormat(StreamClass, format) {
+  if (!StreamClass) {
+    return false;
+  }
+  let supportByFormat = formatSupportByStream.get(StreamClass);
+  if (!supportByFormat) {
+    supportByFormat = new Map;
+    formatSupportByStream.set(StreamClass, supportByFormat);
+  }
+  let supported = supportByFormat.get(format);
+  if (supported === UNDEFINED_VALUE) {
+    try {
+      new StreamClass(format);
+      supported = true;
+    } catch {
+      supported = false;
+    }
+    supportByFormat.set(format, supported);
+  }
+  return supported;
+}
+function supportsDeflateRaw(StreamClass) {
+  return supportsFormat(StreamClass, FORMAT_DEFLATE_RAW);
+}
+function setReadable(stream, readable, flush) {
+  readable = pipeThrough(readable, new TransformStream({ flush }));
+  Object.defineProperty(stream, "readable", {
+    get() {
+      return readable;
+    }
+  });
+}
+function createCodecStream(CodecStreamClass, format, options) {
+  if (!CodecStreamClass) {
+    throw new Error(ERR_UNSUPPORTED_COMPRESSION2);
+  }
+  return new CodecStreamClass(format, options);
+}
+function getGzipCodecStream(useCompressionStream, CodecStreamNative, CodecStreamFallback) {
+  if (useCompressionStream && CodecStreamNative) {
+    return CodecStreamNative;
+  } else if (CodecStreamFallback && CodecStreamFallback.requiresModule) {
+    return CodecStreamFallback;
+  }
+}
+function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamFallback, sourceErrors) {
+  const Stream = useCompressionStream && CompressionStreamNative ? CompressionStreamNative : CompressionStreamFallback || CompressionStreamNative;
+  const format = options.deflate64 ? FORMAT_DEFLATE64_RAW : FORMAT_DEFLATE_RAW;
+  let codecStream;
+  try {
+    codecStream = new Stream(format, options);
+  } catch (error) {
+    if (useCompressionStream && CompressionStreamFallback && Stream != CompressionStreamFallback) {
+      codecStream = new CompressionStreamFallback(format, options);
+    } else {
+      throw error;
+    }
+  }
+  return pipeThroughBackpressured(readable, codecStream, sourceErrors);
+}
+function pipeThrough(readable, transformStream) {
+  return toCompatibleReadable(readable).pipeThrough(transformStream);
+}
+function pipeThroughBackpressured(readable, transformStream, sourceErrors) {
+  const writer = transformStream.writable.getWriter();
+  const reader = readable.getReader();
+  pump();
+  return transformStream.readable;
+  async function pump() {
+    try {
+      for (;; ) {
+        await writer.ready;
+        const result = await readSource(reader, sourceErrors);
+        if (result.done) {
+          await writer.close();
+          break;
+        }
+        await writer.write(result.value);
+      }
+    } catch (error) {
+      await abort(writer, error);
+      await cancel(reader, error);
+    }
+  }
+}
+async function abort(writer, error) {
+  try {
+    await writer.abort(error);
+  } catch {}
+}
+async function cancel(reader, error) {
+  try {
+    await reader.cancel(error);
+  } catch {}
+}
+function readSource(reader, sourceErrors) {
+  const result = reader.read();
+  return sourceErrors ? result.catch((error) => {
+    sourceErrors.add(error);
+    throw error;
+  }) : result;
+}
+function mapCodecError(error, sourceErrors) {
+  if (sourceErrors.has(error)) {
+    return error;
+  }
+  return mapError(error, isMemoryError(error) ? ERR_CODEC_OUT_OF_MEMORY2 : ERR_INVALID_COMPRESSED_DATA2);
+}
+function mapMemoryError(error) {
+  return isMemoryError(error) ? mapError(error, ERR_CODEC_OUT_OF_MEMORY2) : error;
+}
+function isMemoryError(error) {
+  return isErrorObject(error) && error.code == Z_MEM_ERROR_CODE;
+}
+function mapError(error, message) {
+  const mappedError = new Error(message);
+  mappedError.cause = error;
+  return mappedError;
+}
+function mapInflateStreamError(readable, sourceErrors) {
+  const reader = readable.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { value, done } = await reader.read();
+        if (done) {
+          controller.close();
+        } else {
+          controller.enqueue(value);
+        }
+      } catch (error) {
+        await cancel(reader, error);
+        throw mapCodecError(error, sourceErrors);
+      }
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    }
+  });
+}
+
+// node_modules/@zip.js/zip.js/lib/core/streams/codec-stream.js
+var DEFAULT_CHUNK_SIZE2 = 256 * 1024;
+var MESSAGE_EVENT_TYPE = "message";
+var MESSAGE_START = "start";
+var MESSAGE_PULL = "pull";
+var MESSAGE_DATA = "data";
+var MESSAGE_ACK_DATA = "ack";
+var MESSAGE_CLOSE = "close";
+var CODEC_DEFLATE = "deflate";
+var CODEC_INFLATE = "inflate";
+class CodecStream extends TransformStream {
+  constructor(options, config) {
+    super({});
+    const codec = this;
+    const { codecType } = options;
+    let Stream;
+    if (codecType.startsWith(CODEC_DEFLATE)) {
+      Stream = DeflateStream;
+    } else if (codecType.startsWith(CODEC_INFLATE)) {
+      Stream = InflateStream;
+    }
+    codec.outputSize = 0;
+    let inputSize = 0;
+    const stream = new Stream(options, config);
+    const readable = super.readable;
+    const inputSizeStream = new TransformStream({
+      transform(chunk, controller) {
+        if (chunk && chunk.length) {
+          inputSize += chunk.length;
+          controller.enqueue(chunk);
+        }
+      },
+      flush() {
+        Object.assign(codec, {
+          inputSize
+        });
+      }
+    });
+    const outputSizeStream = new TransformStream({
+      transform(chunk, controller) {
+        if (chunk && chunk.length) {
+          controller.enqueue(chunk);
+          codec.outputSize += chunk.length;
+          if (options.outputSize !== UNDEFINED_VALUE && codec.outputSize > options.outputSize) {
+            throw new Error(ERR_INVALID_UNCOMPRESSED_SIZE2);
+          }
+        }
+      },
+      flush() {
+        const { crc32 } = stream;
+        Object.assign(codec, {
+          crc32,
+          inputSize
+        });
+      }
+    });
+    Object.defineProperty(codec, "readable", {
+      get() {
+        return readable.pipeThrough(inputSizeStream).pipeThrough(stream).pipeThrough(outputSizeStream);
+      }
+    });
+  }
+}
+
+class ChunkStream extends TransformStream {
+  constructor(chunkSize) {
+    const pendingChunks = [];
+    let pendingLength = 0;
+    let outputSize = 0;
+    if (!Number.isFinite(chunkSize) || chunkSize < 1) {
+      chunkSize = DEFAULT_CHUNK_SIZE2;
+    }
+    super({
+      transform(chunk, controller) {
+        pendingChunks.push(chunk);
+        pendingLength += chunk.length;
+        while (pendingLength > chunkSize) {
+          outputSize += chunkSize;
+          controller.enqueue(shiftChunk());
+        }
+      },
+      flush(controller) {
+        if (pendingLength) {
+          outputSize += pendingLength;
+          controller.enqueue(concatChunks(pendingChunks, pendingLength));
+        }
+      }
+    });
+    Object.defineProperty(this, "outputSize", {
+      get: () => outputSize
+    });
+    function shiftChunk() {
+      const result = new Uint8Array(chunkSize);
+      let resultOffset = 0;
+      while (resultOffset < chunkSize) {
+        const firstChunk = pendingChunks[0];
+        const remainingLength = chunkSize - resultOffset;
+        if (firstChunk.length <= remainingLength) {
+          result.set(firstChunk, resultOffset);
+          resultOffset += firstChunk.length;
+          pendingChunks.shift();
+        } else {
+          result.set(firstChunk.subarray(0, remainingLength), resultOffset);
+          pendingChunks[0] = firstChunk.subarray(remainingLength);
+          resultOffset += remainingLength;
+        }
+      }
+      pendingLength -= chunkSize;
+      return result;
+    }
+    function concatChunks(chunks, length) {
+      const result = new Uint8Array(length);
+      let offset = 0;
+      for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return result;
+    }
+  }
+}
+
+// node_modules/@zip.js/zip.js/lib/core/codec-worker.js
+var ERR_WORKER_STARTUP_TIMEOUT2 = "Worker startup timeout";
+var webWorkerSupported;
+var createWorkerFailed;
+var webWorkerBackend;
+var initModule = () => {};
+function configureWorker({ initModule: initModuleFunction }) {
+  initModule = initModuleFunction;
+}
+function setWebWorkerBackend(backend) {
+  webWorkerBackend = backend;
+}
+async function loadModule(config) {
+  if (initModule) {
+    try {
+      await initModule(config);
+      return true;
+    } catch {}
+  }
+  return false;
+}
+function disableWebWorker(workerData) {
+  if (workerData.createWorker) {
+    createWorkerFailed = true;
+  } else {
+    webWorkerSupported = false;
+  }
+}
+
+class CodecWorker {
+  constructor(workerData, { readable, writable }, workerOptions, onTaskFinished) {
+    const { options, config, streamOptions, useWebWorkers, workerURI } = workerOptions;
+    let { createWorker } = workerOptions;
+    const { signal } = streamOptions;
+    if (createWorkerFailed) {
+      createWorker = UNDEFINED_VALUE;
+    }
+    Object.assign(workerData, {
+      busy: true,
+      generation: (workerData.generation || 0) + 1,
+      readable: readable.pipeThrough(new ChunkStream(getChunkSize(config))).pipeThrough(new ProgressWatcherStream(streamOptions), { signal }),
+      writable,
+      options: Object.assign({}, options),
+      workerOptions,
+      workerURI,
+      createWorker,
+      terminate() {
+        return new Promise((resolve) => {
+          const { worker, busy } = workerData;
+          if (busy) {
+            workerData.terminateResolvers = workerData.terminateResolvers || [];
+            workerData.terminateResolvers.push(resolve);
+          } else {
+            if (worker) {
+              worker.terminate();
+              workerData.worker = null;
+            }
+            resolve();
+          }
+          workerData.interface = null;
+        });
+      },
+      onTaskFinished() {
+        if (workerData.busy) {
+          const { terminateResolvers, worker } = workerData;
+          if (terminateResolvers) {
+            workerData.terminateResolvers = null;
+            if (worker) {
+              workerData.terminated = true;
+              worker.terminate();
+            }
+          }
+          workerData.busy = false;
+          const pendingTasks = onTaskFinished(workerData);
+          if (terminateResolvers) {
+            terminateResolvers.forEach((resolve) => resolve(pendingTasks));
+          }
+        }
+      }
+    });
+    if (webWorkerSupported === UNDEFINED_VALUE) {
+      webWorkerSupported = typeof Worker != UNDEFINED_TYPE;
+    }
+    return (useWebWorkers && webWorkerBackend && (webWorkerSupported && workerURI || createWorker) ? webWorkerBackend : createWorkerInterface)(workerData, config);
+  }
+}
+
+class ProgressWatcherStream extends TransformStream {
+  constructor({ onstart, onprogress, size, onend }) {
+    let chunkOffset = 0;
+    super({
+      async start() {
+        if (onstart) {
+          await callHandler(onstart, size);
+        }
+      },
+      async transform(chunk, controller) {
+        chunkOffset += chunk.length;
+        if (onprogress) {
+          await callHandler(onprogress, chunkOffset, size);
+        }
+        controller.enqueue(chunk);
+      },
+      async flush() {
+        if (onend) {
+          await callHandler(onend, chunkOffset);
+        }
+      }
+    });
+  }
+}
+async function callHandler(handler, ...parameters) {
+  try {
+    await handler(...parameters);
+  } catch {}
+}
+function createWorkerInterface(workerData, config) {
+  return {
+    run: () => runWorker(workerData, config)
+  };
+}
+async function runWorker({ options, readable, writable, onTaskFinished, workerOptions }, config) {
+  let codecStream, chunkStream, modulePromise;
+  try {
+    if (options.compressed && !options.format) {
+      const deflate = options.codecType.startsWith(CODEC_DEFLATE);
+      const FallbackStream = deflate ? config.CompressionStreamFallback : config.DecompressionStreamFallback;
+      const NativeStream = deflate ? config.CompressionStream : config.DecompressionStream;
+      if (!options.useCompressionStream) {
+        if (!await moduleLoaded() && (!FallbackStream || FallbackStream.requiresModule)) {
+          options.useCompressionStream = true;
+        }
+      } else if (FallbackStream && FallbackStream.requiresModule && !supportsDeflateRaw(NativeStream)) {
+        await moduleLoaded();
+      }
+    }
+    if (options.encrypted && !options.zipCrypto) {
+      await moduleLoaded();
+    }
+    codecStream = new CodecStream(options, config);
+    chunkStream = new ChunkStream(getChunkSize(config));
+    const { signal } = workerOptions.streamOptions;
+    await readable.pipeThrough(codecStream).pipeThrough(chunkStream).pipeTo(writable, { preventClose: true, preventAbort: true, signal });
+    const {
+      crc32,
+      inputSize,
+      outputSize
+    } = codecStream;
+    return {
+      crc32,
+      inputSize,
+      outputSize
+    };
+  } catch (error) {
+    if (codecStream) {
+      const outputSize = chunkStream ? chunkStream.outputSize : 0;
+      workerOptions.outputSize = outputSize;
+      if (isErrorObject(error)) {
+        try {
+          error.outputSize = outputSize;
+        } catch {}
+      }
+    }
+    throw error;
+  } finally {
+    onTaskFinished();
+  }
+  function moduleLoaded() {
+    if (!modulePromise) {
+      modulePromise = loadModule(config);
+    }
+    return modulePromise;
+  }
+}
+
+// node_modules/@zip.js/zip.js/lib/core/codec-pool.js
+var pool = [];
+var pendingRequests = [];
+var starvationTimeout;
+var starvationDelay;
+var indexWorker = 0;
+async function runWorker2(stream, workerOptions) {
+  const { options, config } = workerOptions;
+  const { useWebWorkers, useCompressionStream, compressed, checkCrc32, computeCrc32, encrypted, format, codecURI } = options;
+  const { workerURI, createWorker, maxWorkers } = config;
+  if (format) {
+    if (codecURI) {
+      options.codecURI = resolveCodecURI(codecURI, config.baseURI);
+    }
+    await ensureCodecStreams(format, options.codecURI);
+  }
+  const streamCopy = !compressed && !checkCrc32 && !computeCrc32 && !encrypted;
+  const workerSupported = format === UNDEFINED_VALUE || Boolean(options.codecURI);
+  workerOptions.useWebWorkers = !streamCopy && workerSupported && (useWebWorkers || useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers);
+  workerOptions.workerURI = workerOptions.useWebWorkers && workerURI ? workerURI : UNDEFINED_VALUE;
+  workerOptions.createWorker = workerOptions.useWebWorkers && createWorker ? createWorker : UNDEFINED_VALUE;
+  options.useCompressionStream = useCompressionStream || useCompressionStream === UNDEFINED_VALUE && config.useCompressionStream;
+  return (await getWorker()).run();
+  async function getWorker() {
+    const workerData = pool.find((workerData) => !workerData.busy);
+    if (workerData) {
+      clearTerminateTimeout(workerData);
+      return new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
+    } else if (pool.length < maxWorkers) {
+      const workerData = { indexWorker };
+      indexWorker++;
+      pool.push(workerData);
+      return new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
+    } else {
+      return new Promise((resolve) => {
+        pendingRequests.push({ resolve, stream, workerOptions });
+        starvationDelay = config.workerStarvationTimeout;
+        armStarvationTimeout();
+      });
+    }
+  }
+  function onTaskFinished(workerData) {
+    clearStarvationTimeout();
+    if (workerData.terminated) {
+      workerData.terminated = false;
+      return runPendingRequestsInline();
+    } else if (pendingRequests.length) {
+      const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
+      resolve(new CodecWorker(workerData, stream, workerOptions, onTaskFinished));
+      armStarvationTimeout();
+    } else if (workerData.worker) {
+      clearTerminateTimeout(workerData);
+      terminateWorker(workerData, workerOptions);
+    } else {
+      pool = pool.filter((data) => data != workerData);
+    }
+  }
+}
+function resolveCodecURI(codecURI, baseURI) {
+  try {
+    return new URL(codecURI, baseURI).toString();
+  } catch {
+    return codecURI;
+  }
+}
+function armStarvationTimeout() {
+  if (!starvationTimeout && pendingRequests.length && Number.isFinite(starvationDelay) && starvationDelay >= 0) {
+    starvationTimeout = setTimeout(onWorkerStarvation, starvationDelay);
+  }
+}
+function clearStarvationTimeout() {
+  if (starvationTimeout) {
+    clearTimeout(starvationTimeout);
+    starvationTimeout = null;
+  }
+}
+function onWorkerStarvation() {
+  starvationTimeout = null;
+  if (pendingRequests.length) {
+    const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
+    resolve(new CodecWorker({}, stream, getInlineWorkerOptions(workerOptions), onInlineTaskFinished));
+    armStarvationTimeout();
+  }
+}
+function runPendingRequestsInline() {
+  const tasks = pendingRequests.splice(0).map(({ resolve, stream, workerOptions }) => new Promise((resolveTask) => {
+    resolve(new CodecWorker({}, stream, getInlineWorkerOptions(workerOptions), () => {
+      onInlineTaskFinished();
+      resolveTask();
+    }));
+  }));
+  clearStarvationTimeout();
+  return Promise.all(tasks);
+}
+function getInlineWorkerOptions(workerOptions) {
+  return Object.assign({}, workerOptions, { useWebWorkers: false, workerURI: UNDEFINED_VALUE, createWorker: UNDEFINED_VALUE });
+}
+function onInlineTaskFinished() {
+  clearStarvationTimeout();
+  armStarvationTimeout();
+}
+function terminateWorker(workerData, workerOptions) {
+  const { config } = workerOptions;
+  const { terminateWorkerTimeout } = config;
+  if (Number.isFinite(terminateWorkerTimeout) && terminateWorkerTimeout >= 0) {
+    workerData.terminateTimeout = setTimeout(async () => {
+      pool = pool.filter((data) => data != workerData);
+      try {
+        await workerData.terminate();
+      } catch {}
+    }, terminateWorkerTimeout);
+  }
+}
+function clearTerminateTimeout(workerData) {
+  const { terminateTimeout } = workerData;
+  if (terminateTimeout) {
+    clearTimeout(terminateTimeout);
+    workerData.terminateTimeout = null;
+  }
+}
+
+// node_modules/@zip.js/zip.js/lib/core/util/decode-cp437.js
+var CP437 = "\x00☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ".split("");
+function decodeCP437(stringValue) {
+  let result = "";
+  for (let indexCharacter = 0;indexCharacter < stringValue.length; indexCharacter++) {
+    result += CP437[stringValue[indexCharacter]];
+  }
+  return result;
+}
+
+// node_modules/@zip.js/zip.js/lib/core/util/decode-text.js
+function decodeText(value, encoding) {
+  return decode(value, encoding, true);
+}
+function isUTF8Text(value) {
+  if (value.some((byte) => byte > 127)) {
+    try {
+      new TextDecoder("utf-8", { fatal: true }).decode(value);
+      return true;
+    } catch {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+function decode(value, encoding, ignoreBOM) {
+  if (encoding && encoding.trim().toLowerCase() == "cp437") {
+    return decodeCP437(value);
+  } else {
+    return new TextDecoder(encoding, { ignoreBOM }).decode(value);
+  }
+}
+
+// node_modules/@zip.js/zip.js/lib/core/io.js
+var ERR_ITERATOR_COMPLETED_TOO_SOON = "Writer iterator completed too soon";
+var ERR_WRITER_NOT_INITIALIZED = "Writer not initialized";
+var ERR_WRITER_SIZE_NOT_WRITABLE = "Invalid writer (size must be writable)";
+var DEFAULT_BUFFER_SIZE = 256 * 1024;
+var DEFAULT_MAXIMUM_RANGE_SIZE = 16 * 1024 * 1024;
+var END_OF_CENTRAL_DIR_SEARCH_LENGTH = END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS;
+var PROPERTY_NAME_WRITABLE = "writable";
+var DISK_BOUNDARY = Symbol();
+
+class Stream {
+  constructor() {
+    this.size = 0;
+  }
+  init() {
+    this.initialized = true;
+  }
+}
+
+class Reader extends Stream {
+  get readable() {
+    return this.createReadable();
+  }
+  createReadable({ offset = 0, size, chunkSize = getChunkSize(getConfiguration()) } = {}) {
+    const reader = this;
+    let chunkOffset = 0;
+    chunkSize = normalizeChunkSize(chunkSize);
+    return new ReadableStream({
+      async pull(controller) {
+        const dataSize = size === UNDEFINED_VALUE ? chunkSize : Math.min(chunkSize, size - chunkOffset);
+        const data = await readUint8Array(reader, offset + chunkOffset, dataSize);
+        if (data.length) {
+          controller.enqueue(data);
+          chunkOffset += data.length;
+        }
+        if (size !== UNDEFINED_VALUE && chunkOffset >= size || !data.length && dataSize) {
+          controller.close();
+        }
+      }
+    });
+  }
+}
+
+class Writer extends Stream {
+  constructor() {
+    super();
+    const writer = this;
+    const writable = new WritableStream({
+      write(chunk) {
+        if (!writer.initialized) {
+          throw new Error(ERR_WRITER_NOT_INITIALIZED);
+        }
+        return writer.writeUint8Array(toExactUint8Array(chunk));
+      }
+    });
+    Object.defineProperty(writer, PROPERTY_NAME_WRITABLE, {
+      get() {
+        return writable;
+      }
+    });
+  }
+  writeUint8Array() {}
+}
+var blobSliceReliable;
+var blobSliceProbe;
+function probeBlobSliceReliability() {
+  blobSliceProbe = (async () => {
+    try {
+      const slicedBlob = new Blob([new Uint8Array(3)]).slice(1, 2);
+      const streamReader = slicedBlob.stream().getReader();
+      let streamedLength = 0;
+      let result = await streamReader.read();
+      while (!result.done) {
+        streamedLength += result.value.length;
+        result = await streamReader.read();
+      }
+      blobSliceReliable = streamedLength == 1;
+    } catch {
+      blobSliceReliable = false;
+    }
+  })();
+}
+
+class BlobReader extends Reader {
+  constructor(blob) {
+    super();
+    Object.assign(this, {
+      sourceBlob: blob,
+      size: blob.size
+    });
+    if (!blobSliceProbe) {
+      probeBlobSliceReliability();
+    }
+  }
+  createReadable(options) {
+    const reader = this;
+    const { sourceBlob, size } = reader;
+    const { offset = 0, size: readSize = size - offset } = options || {};
+    if (typeof sourceBlob.stream == FUNCTION_TYPE) {
+      if (!offset && readSize >= size) {
+        return toCompatibleReadable(sourceBlob.stream());
+      }
+      if (blobSliceReliable) {
+        return toCompatibleReadable(sourceBlob.slice(offset, offset + readSize).stream());
+      }
+    }
+    return super.createReadable(options);
+  }
+  async readUint8Array(offset, length) {
+    const reader = this;
+    const offsetEnd = offset + length;
+    const readsWholeBlob = !offset && offsetEnd >= reader.size;
+    const blob = readsWholeBlob ? reader.sourceBlob : reader.sourceBlob.slice(offset, offsetEnd);
+    let arrayBuffer = await blob.arrayBuffer();
+    const sliceIgnoredByBuggyImplementation = arrayBuffer.byteLength > length;
+    if (sliceIgnoredByBuggyImplementation) {
+      arrayBuffer = arrayBuffer.slice(offset, offsetEnd);
+    }
+    return new Uint8Array(arrayBuffer);
+  }
+}
+class Uint8ArrayReader extends Reader {
+  constructor(array) {
+    super();
+    array = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    Object.assign(this, {
+      array,
+      size: array.length
+    });
+  }
+  readUint8Array(index, length) {
+    return this.array.slice(index, index + length);
+  }
+}
+
+class Uint8ArrayWriter extends Writer {
+  constructor(defaultBufferSize) {
+    super();
+    this.defaultBufferSize = defaultBufferSize || DEFAULT_BUFFER_SIZE;
+  }
+  init(initSize = 0) {
+    Object.assign(this, {
+      offset: 0,
+      array: new Uint8Array(initSize > 0 ? initSize : this.defaultBufferSize)
+    });
+    super.init();
+  }
+  writeUint8Array(array) {
+    const writer = this;
+    const requiredLength = writer.offset + array.length;
+    if (requiredLength > writer.array.length) {
+      let newLength = writer.array.length ? writer.array.length * 2 : writer.defaultBufferSize;
+      while (newLength < requiredLength) {
+        newLength *= 2;
+      }
+      const previousArray = writer.array;
+      writer.array = new Uint8Array(newLength);
+      writer.array.set(previousArray);
+    }
+    writer.array.set(array, writer.offset);
+    writer.offset += array.length;
+  }
+  getData() {
+    if (this.offset === this.array.length) {
+      return this.array;
+    } else {
+      return this.array.slice(0, this.offset);
+    }
+  }
+}
+
+class SplitDataReader extends Reader {
+  constructor(readers) {
+    super();
+    this.readers = readers;
+  }
+  async init() {
+    const reader = this;
+    reader.lastDiskNumber = 0;
+    const readers = reader.readers = await Promise.all(reader.readers.map(initDiskReader));
+    reader.diskOffsets = readers.map((diskReader) => {
+      const diskOffset = reader.size;
+      reader.size += diskReader.size;
+      return diskOffset;
+    });
+    super.init();
+  }
+  getDiskOffset(diskNumber) {
+    const { diskOffsets, size } = this;
+    const diskOffset = diskOffsets[diskNumber];
+    return diskOffset === UNDEFINED_VALUE ? size : diskOffset;
+  }
+  async readUint8Array(offset, length) {
+    const reader = this;
+    const { readers } = this;
+    let result;
+    let currentDiskNumber = 0;
+    let currentReaderOffset = offset;
+    while (readers[currentDiskNumber] && currentReaderOffset >= readers[currentDiskNumber].size) {
+      currentReaderOffset -= readers[currentDiskNumber].size;
+      currentDiskNumber++;
+    }
+    const currentReader = readers[currentDiskNumber];
+    if (currentReader) {
+      const currentReaderSize = currentReader.size;
+      if (currentReaderOffset + length <= currentReaderSize) {
+        result = await readUint8Array(currentReader, currentReaderOffset, length);
+      } else {
+        const chunkLength = currentReaderSize - currentReaderOffset;
+        const firstPart = await readUint8Array(currentReader, currentReaderOffset, chunkLength);
+        const secondPart = await reader.readUint8Array(offset + chunkLength, length - chunkLength);
+        result = concat(firstPart, secondPart);
+      }
+    } else {
+      result = EMPTY_UINT8_ARRAY;
+    }
+    reader.lastDiskNumber = Math.max(currentDiskNumber, reader.lastDiskNumber);
+    return result;
+  }
+}
+
+class SplitDataWriter extends Stream {
+  constructor(writerGenerator, maxSize = 4294967295) {
+    super();
+    const writer = this;
+    Object.assign(writer, {
+      diskNumber: 0,
+      diskOffset: 0,
+      size: 0,
+      maxSize,
+      availableSize: maxSize
+    });
+    let diskSourceWriter, diskWritable, diskWriter;
+    const writable = new WritableStream({
+      async write(chunk) {
+        if (chunk === DISK_BOUNDARY) {
+          if (diskWriter) {
+            await endDisk();
+          }
+          return;
+        }
+        const { availableSize } = writer;
+        if (!diskWriter) {
+          const { value, done } = await writerGenerator.next();
+          if (done && !value) {
+            throw new Error(ERR_ITERATOR_COMPLETED_TOO_SOON);
+          } else {
+            diskSourceWriter = value;
+            diskSourceWriter.size = 0;
+            if (diskSourceWriter.maxSize) {
+              writer.maxSize = diskSourceWriter.maxSize;
+            }
+            writer.availableSize = writer.maxSize;
+            await initStream(diskSourceWriter);
+            diskWritable = value.writable;
+            diskWriter = diskWritable.getWriter();
+          }
+          await this.write(chunk);
+        } else if (chunk.length >= availableSize) {
+          await writeChunk(chunk.subarray(0, availableSize));
+          await endDisk();
+          if (chunk.length > availableSize) {
+            await this.write(chunk.subarray(availableSize));
+          }
+        } else {
+          await writeChunk(chunk);
+        }
+      },
+      async close() {
+        if (diskWriter) {
+          await diskWriter.ready;
+          await closeDiskWriter();
+        }
+      },
+      async abort(reason) {
+        if (diskWriter) {
+          await diskWriter.abort(reason);
+        }
+      }
+    });
+    Object.defineProperty(writer, PROPERTY_NAME_WRITABLE, {
+      get() {
+        return writable;
+      }
+    });
+    async function writeChunk(chunk) {
+      const chunkLength = chunk.length;
+      if (chunkLength) {
+        await diskWriter.ready;
+        await diskWriter.write(chunk);
+        diskSourceWriter.size += chunkLength;
+        writer.availableSize -= chunkLength;
+      }
+    }
+    async function endDisk() {
+      await closeDiskWriter();
+      writer.diskOffset += diskSourceWriter.size;
+      writer.diskNumber++;
+      diskWriter = null;
+      writer.availableSize = writer.maxSize;
+    }
+    async function closeDiskWriter() {
+      await diskWriter.close();
+    }
+  }
+  async closeDisk() {
+    const streamWriter = this.writable.getWriter();
+    try {
+      await streamWriter.ready;
+      await streamWriter.write(DISK_BOUNDARY);
+    } finally {
+      streamWriter.releaseLock();
+    }
+  }
+}
+
+class GenericReader {
+  constructor(reader) {
+    if (Array.isArray(reader)) {
+      reader = new SplitDataReader(reader);
+    }
+    if (reader instanceof ReadableStream || typeof reader.getReader == FUNCTION_TYPE) {
+      reader = {
+        readable: toCompatibleReadable(reader)
+      };
+    }
+    return reader;
+  }
+}
+
+class GenericWriter {
+  constructor(writer) {
+    if (writer.writable === UNDEFINED_VALUE && typeof writer.next == FUNCTION_TYPE) {
+      writer = new SplitDataWriter(writer);
+    }
+    if (writer instanceof WritableStream || typeof writer.getWriter == FUNCTION_TYPE) {
+      writer = {
+        writable: toCompatibleWritable(writer)
+      };
+    }
+    try {
+      writer.size = writer.size === UNDEFINED_VALUE ? 0 : writer.size;
+    } catch {
+      throw new Error(ERR_WRITER_SIZE_NOT_WRITABLE);
+    }
+    return writer;
+  }
+}
+function ownsWritable(writer) {
+  return Boolean(writer && writer.getData);
+}
+async function initStream(stream, initSize) {
+  if (stream.init && !stream.initialized) {
+    await stream.init(initSize);
+  } else {
+    return Promise.resolve();
+  }
+}
+async function initDiskReader(diskReader) {
+  diskReader = new GenericReader(diskReader);
+  await initStream(diskReader);
+  if (diskReader.size === UNDEFINED_VALUE || !diskReader.readUint8Array) {
+    diskReader = new BlobReader(await streamToBlob(diskReader.readable));
+    await initStream(diskReader);
+  }
+  return diskReader;
+}
+function readUint8Array(reader, offset, size) {
+  return reader.readUint8Array(offset, size);
+}
+
+// node_modules/@zip.js/zip.js/lib/core/util/warnings.js
+function addWarning(warnings, reason, filename) {
+  if (!warnings.some((warning) => warning.reason == reason)) {
+    const warning = { reason };
+    if (filename !== UNDEFINED_VALUE) {
+      warning.filename = filename;
+    }
+    warnings.push(warning);
+  }
+}
+
+// node_modules/@zip.js/zip.js/lib/core/zip-entry.js
+var PROPERTY_NAME_FILENAME = "filename";
+var PROPERTY_NAME_RAW_FILENAME = "rawFilename";
+var PROPERTY_NAME_COMMENT = "comment";
+var PROPERTY_NAME_RAW_COMMENT = "rawComment";
+var PROPERTY_NAME_UNCOMPRESSED_SIZE = "uncompressedSize";
+var PROPERTY_NAME_COMPRESSED_SIZE = "compressedSize";
+var PROPERTY_NAME_OFFSET = "offset";
+var PROPERTY_NAME_DISK_NUMBER_START = "diskNumberStart";
+var PROPERTY_NAME_LAST_MODIFICATION_DATE = "lastModDate";
+var PROPERTY_NAME_RAW_LAST_MODIFICATION_DATE = "rawLastModDate";
+var PROPERTY_NAME_LAST_ACCESS_DATE = "lastAccessDate";
+var PROPERTY_NAME_RAW_LAST_ACCESS_DATE = "rawLastAccessDate";
+var PROPERTY_NAME_CREATION_DATE = "creationDate";
+var PROPERTY_NAME_RAW_CREATION_DATE = "rawCreationDate";
+var PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES = "internalFileAttributes";
+var PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES = "externalFileAttributes";
+var PROPERTY_NAME_MSDOS_ATTRIBUTES_RAW = "msdosAttributesRaw";
+var PROPERTY_NAME_MSDOS_ATTRIBUTES = "msdosAttributes";
+var PROPERTY_NAME_MS_DOS_COMPATIBLE = "msDosCompatible";
+var PROPERTY_NAME_ZIP64 = "zip64";
+var PROPERTY_NAME_ENCRYPTED = "encrypted";
+var PROPERTY_NAME_VERSION = "version";
+var PROPERTY_NAME_VERSION_MADE_BY = "versionMadeBy";
+var PROPERTY_NAME_ZIPCRYPTO = "zipCrypto";
+var PROPERTY_NAME_DIRECTORY = "directory";
+var PROPERTY_NAME_EXECUTABLE = "executable";
+var PROPERTY_NAME_SYMLINK = "symlink";
+var PROPERTY_NAME_COMPRESSION_METHOD = "compressionMethod";
+var PROPERTY_NAME_SIGNATURE = "signature";
+var PROPERTY_NAME_CRC32 = "crc32";
+var PROPERTY_NAME_EXTRA_FIELD = "extraField";
+var PROPERTY_NAME_EXTRA_FIELD_INFOZIP = "extraFieldInfoZip";
+var PROPERTY_NAME_EXTRA_FIELD_UNIX = "extraFieldUnix";
+var PROPERTY_NAME_EXTRA_FIELD_UNIX_TYPE1 = "extraFieldUnixType1";
+var PROPERTY_NAME_EXTRA_FIELD_PKWARE_UNIX = "extraFieldPkwareUnix";
+var PROPERTY_NAME_UID = "uid";
+var PROPERTY_NAME_GID = "gid";
+var PROPERTY_NAME_UNIX_MODE = "unixMode";
+var PROPERTY_NAME_SETUID = "setuid";
+var PROPERTY_NAME_SETGID = "setgid";
+var PROPERTY_NAME_STICKY = "sticky";
+var PROPERTY_NAME_BITFLAG = "bitFlag";
+var PROPERTY_NAME_RAW_BITFLAG = "rawBitFlag";
+var PROPERTY_NAME_FILENAME_LENGTH = "filenameLength";
+var PROPERTY_NAME_EXTRA_FIELD_LENGTH = "extraFieldLength";
+var PROPERTY_NAME_UNIX_EXTERNAL_UPPER = "unixExternalUpper";
+var PROPERTY_NAME_FILENAME_UTF8 = "filenameUTF8";
+var PROPERTY_NAME_COMMENT_UTF8 = "commentUTF8";
+var PROPERTY_NAME_RAW_EXTRA_FIELD = "rawExtraField";
+var PROPERTY_NAME_EXTRA_FIELD_ZIP64 = "extraFieldZip64";
+var PROPERTY_NAME_EXTRA_FIELD_UNICODE_PATH = "extraFieldUnicodePath";
+var PROPERTY_NAME_EXTRA_FIELD_UNICODE_COMMENT = "extraFieldUnicodeComment";
+var PROPERTY_NAME_EXTRA_FIELD_AES = "extraFieldAES";
+var PROPERTY_NAME_EXTRA_FIELD_NTFS = "extraFieldNTFS";
+var PROPERTY_NAME_EXTRA_FIELD_EXTENDED_TIMESTAMP = "extraFieldExtendedTimestamp";
+var PROPERTY_NAME_EXTRA_FIELD_USDZ = "extraFieldUSDZ";
+var PROPERTY_NAMES = [
+  PROPERTY_NAME_FILENAME,
+  PROPERTY_NAME_RAW_FILENAME,
+  PROPERTY_NAME_UNCOMPRESSED_SIZE,
+  PROPERTY_NAME_COMPRESSED_SIZE,
+  PROPERTY_NAME_LAST_MODIFICATION_DATE,
+  PROPERTY_NAME_RAW_LAST_MODIFICATION_DATE,
+  PROPERTY_NAME_COMMENT,
+  PROPERTY_NAME_RAW_COMMENT,
+  PROPERTY_NAME_LAST_ACCESS_DATE,
+  PROPERTY_NAME_RAW_LAST_ACCESS_DATE,
+  PROPERTY_NAME_CREATION_DATE,
+  PROPERTY_NAME_RAW_CREATION_DATE,
+  PROPERTY_NAME_OFFSET,
+  PROPERTY_NAME_DISK_NUMBER_START,
+  PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES,
+  PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES,
+  PROPERTY_NAME_MSDOS_ATTRIBUTES_RAW,
+  PROPERTY_NAME_MSDOS_ATTRIBUTES,
+  PROPERTY_NAME_MS_DOS_COMPATIBLE,
+  PROPERTY_NAME_ZIP64,
+  PROPERTY_NAME_ENCRYPTED,
+  PROPERTY_NAME_VERSION,
+  PROPERTY_NAME_VERSION_MADE_BY,
+  PROPERTY_NAME_ZIPCRYPTO,
+  PROPERTY_NAME_DIRECTORY,
+  PROPERTY_NAME_EXECUTABLE,
+  PROPERTY_NAME_SYMLINK,
+  PROPERTY_NAME_COMPRESSION_METHOD,
+  PROPERTY_NAME_SIGNATURE,
+  PROPERTY_NAME_CRC32,
+  PROPERTY_NAME_EXTRA_FIELD,
+  PROPERTY_NAME_EXTRA_FIELD_UNIX,
+  PROPERTY_NAME_EXTRA_FIELD_INFOZIP,
+  PROPERTY_NAME_EXTRA_FIELD_UNIX_TYPE1,
+  PROPERTY_NAME_EXTRA_FIELD_PKWARE_UNIX,
+  PROPERTY_NAME_UID,
+  PROPERTY_NAME_GID,
+  PROPERTY_NAME_UNIX_MODE,
+  PROPERTY_NAME_UNIX_EXTERNAL_UPPER,
+  PROPERTY_NAME_SETUID,
+  PROPERTY_NAME_SETGID,
+  PROPERTY_NAME_STICKY,
+  PROPERTY_NAME_BITFLAG,
+  PROPERTY_NAME_RAW_BITFLAG,
+  PROPERTY_NAME_FILENAME_LENGTH,
+  PROPERTY_NAME_EXTRA_FIELD_LENGTH,
+  PROPERTY_NAME_FILENAME_UTF8,
+  PROPERTY_NAME_COMMENT_UTF8,
+  PROPERTY_NAME_RAW_EXTRA_FIELD,
+  PROPERTY_NAME_EXTRA_FIELD_ZIP64,
+  PROPERTY_NAME_EXTRA_FIELD_UNICODE_PATH,
+  PROPERTY_NAME_EXTRA_FIELD_UNICODE_COMMENT,
+  PROPERTY_NAME_EXTRA_FIELD_AES,
+  PROPERTY_NAME_EXTRA_FIELD_NTFS,
+  PROPERTY_NAME_EXTRA_FIELD_EXTENDED_TIMESTAMP,
+  PROPERTY_NAME_EXTRA_FIELD_USDZ
+];
+
+class Entry {
+  constructor(data) {
+    PROPERTY_NAMES.forEach((name) => this[name] = data[name]);
+  }
+}
+var INTERPRETED_EXTRA_FIELD_TYPES = new Set([
+  EXTRAFIELD_TYPE_ZIP64,
+  EXTRAFIELD_TYPE_AES,
+  EXTRAFIELD_TYPE_NTFS,
+  EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP,
+  EXTRAFIELD_TYPE_UNICODE_PATH,
+  EXTRAFIELD_TYPE_UNICODE_COMMENT,
+  EXTRAFIELD_TYPE_USDZ,
+  EXTRAFIELD_TYPE_INFOZIP,
+  EXTRAFIELD_TYPE_UNIX,
+  EXTRAFIELD_TYPE_UNIX_TYPE1,
+  EXTRAFIELD_TYPE_PKWARE_UNIX
+]);
+function getEncryptionOverhead(encrypted, zipCrypto, encryptionStrength) {
+  return encrypted ? zipCrypto ? 12 : 16 + encryptionStrength * 4 : 0;
+}
+
+// node_modules/@zip.js/zip.js/lib/core/zip-reader.js
+var ERR_BAD_FORMAT2 = "File format is not recognized";
+var ERR_EOCDR_NOT_FOUND2 = "End of central directory not found";
+var ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND2 = "End of Zip64 central directory locator not found";
+var ERR_CENTRAL_DIRECTORY_NOT_FOUND2 = "Central directory header not found";
+var ERR_ENCRYPTED2 = "File contains encrypted entry";
+var ERR_UNSUPPORTED_ENCRYPTION2 = "Encryption method not supported";
+var ERR_SPLIT_ZIP_FILE2 = "Split zip file";
+var ERR_ENTRY_DATA_OUT_OF_BOUNDS2 = "Entry data out of bounds";
+var ERR_AMBIGUOUS_ARCHIVE2 = "Ambiguous archive";
+var ERR_ENCRYPTED_CENTRAL_DIRECTORY2 = "Encrypted central directory is not supported";
+var ERR_UNSAFE_FILENAME2 = "Unsafe filename";
+var ERR_INVALID_STRICTNESS2 = "Invalid strictness (must be 'strict', 'balanced' or 'tolerant')";
+var ERR_INVALID_FILENAME_VALIDATION2 = "Invalid filenameValidation (must be 'strict', 'balanced' or 'tolerant')";
+var ERR_INVALID_MAX_APPENDED_DATA_SIZE2 = "Invalid maxAppendedDataSize (must be a number greater than or equal to 0)";
+var ERR_UNSUPPORTED_UINT642 = "64-bit value exceeds Number.MAX_SAFE_INTEGER";
+var WARNING_UNSORTED_CENTRAL_DIRECTORY2 = "unsorted central directory";
+var WARNING_UNKNOWN_VERSION2 = "unknown version needed to extract";
+var WARNING_COMPRESSED_PATCHED_DATA2 = "compressed patched data";
+var WARNING_MALFORMED_EXTRA_FIELD2 = "malformed extra field";
+var WARNING_UNKNOWN_ZIP64_EXTENSIBLE_DATA2 = "unknown zip64 extensible data";
+var WARNING_WRAPPED_ENTRIES_COUNT2 = "wrapped entries count";
+var WARNING_APPENDED_DATA2 = "appended data";
+var WARNING_PREPENDED_DATA2 = "prepended data";
+var WARNING_PREPENDED_CENTRAL_DIRECTORY2 = "prepended central directory";
+var WARNING_TRAILING_CENTRAL_DIRECTORY_DATA2 = "trailing central directory data";
+var WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET2 = "mismatched central directory offset";
+var WARNING_MISSING_ZIP64_EXTRA_FIELD2 = "missing zip64 extra field";
+var WARNING_DUPLICATE_FILENAME2 = "duplicate filename";
+var WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY2 = "mismatched zip64 end of central directory record";
+var WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY2 = "multiple end of central directory records";
+var WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME2 = "mismatched local file header (filename)";
+var WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG2 = "mismatched local file header (general purpose bit flag)";
+var WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD2 = "mismatched local file header (compression method)";
+var WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES2 = "mismatched local file header (crc32 or sizes)";
+var MAX_KNOWN_VERSION = 63;
+var DRIVE_LETTER_REGEXP = /^[a-zA-Z]:/;
+var PARENT_DIRECTORY_REGEXP = /(^|[\\/])\.\.([\\/]|$)/;
+var CHARSET_UTF8 = "utf-8";
+var PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
+var CHARSET_CP437 = "cp437";
+var BITFLAG_AMBIGUITY_MASK = BITFLAG_ENCRYPTED | BITFLAG_DATA_DESCRIPTOR | BITFLAG_STRONG_ENCRYPTION | BITFLAG_LANG_ENCODING_FLAG;
+var VENDOR_VERSION_AE_1 = 1;
+var ZIP64_PROPERTIES = [
+  [PROPERTY_NAME_UNCOMPRESSED_SIZE, MAX_32_BITS],
+  [PROPERTY_NAME_COMPRESSED_SIZE, MAX_32_BITS],
+  [PROPERTY_NAME_OFFSET, MAX_32_BITS],
+  [PROPERTY_NAME_DISK_NUMBER_START, MAX_16_BITS]
+];
+var ZIP64_EXTRACTION = {
+  [MAX_16_BITS]: {
+    getValue: getUint32,
+    bytes: 4
+  },
+  [MAX_32_BITS]: {
+    getValue: getBigUint64,
+    bytes: 8
+  }
+};
+var MAX_SAFE_UINT64 = BigInt(Number.MAX_SAFE_INTEGER);
+var MAX_END_OF_CENTRAL_DIR_PROBES = 64;
+var MAX_DEFLATE_EXPANSION_RATIO = 1032;
+var CENTRAL_DIRECTORY_UNREACHABLE = 0;
+var CENTRAL_DIRECTORY_PLAUSIBLE = 1;
+var CENTRAL_DIRECTORY_REACHABLE = 2;
+
+class ZipReader2 {
+  constructor(reader, options = {}) {
+    Object.assign(this, {
+      reader: new GenericReader(reader),
+      options: options || {},
+      readRanges: { indexes: new Set, sortedRanges: [], pendingRanges: [] },
+      entriesMissingZip64ExtraField: new WeakSet
+    });
+  }
+  async* getEntriesGenerator(options = {}) {
+    const zipReader = this;
+    let { reader } = zipReader;
+    await initStream(reader);
+    if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
+      reader = new BlobReader(await streamToBlob(reader.readable));
+      await initStream(reader);
+    }
+    if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
+      throw new Error(ERR_BAD_FORMAT2);
+    }
+    const warnings = zipReader.warnings = [];
+    const strictness = getStrictness(options, zipReader.options);
+    const checkAmbiguity = strictness == STRICTNESS_STRICT;
+    const rejectAmbiguousEndOfDirectory = strictness != STRICTNESS_TOLERANT;
+    const maxAppendedDataSize = getMaxAppendedDataSize(getOptionValue(zipReader, options, OPTION_MAX_APPENDED_DATA_SIZE), strictness);
+    const filenameValidation = getFilenameValidation(getOptionValue(zipReader, options, OPTION_FILENAME_VALIDATION), strictness);
+    const normalizeFilename = getOptionValue(zipReader, options, OPTION_NORMALIZE_FILENAME);
+    const { endOfDirectoryInfo, endOfDirectoryReachingEndCount } = await findEndOfCentralDirectory(reader, rejectAmbiguousEndOfDirectory, maxAppendedDataSize);
+    if (!endOfDirectoryInfo) {
+      if (await startsWithSplitZipSignature(reader)) {
+        throw new Error(ERR_SPLIT_ZIP_FILE2);
+      } else {
+        throw new Error(ERR_EOCDR_NOT_FOUND2);
+      }
+    }
+    if (rejectAmbiguousEndOfDirectory && endOfDirectoryReachingEndCount > 1) {
+      throwAmbiguousArchive(WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY2);
+    }
+    const endOfDirectoryView = getDataView(endOfDirectoryInfo);
+    let directoryDataLength = getUint32(endOfDirectoryView, 12);
+    let directoryDataOffset = getUint32(endOfDirectoryView, 16);
+    const commentOffset = endOfDirectoryInfo.offset;
+    const commentLength = getUint16(endOfDirectoryView, 20);
+    const appendedDataOffset = commentOffset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
+    const appendedDataLength = reader.size - appendedDataOffset;
+    if (appendedDataLength > maxAppendedDataSize) {
+      throwAmbiguousArchive(WARNING_APPENDED_DATA2);
+    }
+    if (appendedDataLength > 0) {
+      addWarning(warnings, WARNING_APPENDED_DATA2);
+    }
+    let lastDiskNumber = getUint16(endOfDirectoryView, 4);
+    const expectedLastDiskNumber = reader.lastDiskNumber || 0;
+    let diskNumber = getUint16(endOfDirectoryView, 6);
+    let filesLength = getUint16(endOfDirectoryView, 10);
+    let prependedDataLength = 0;
+    let prependedCentralDirectory;
+    let startOffset;
+    let zip64EndOfDirectory;
+    let zip64EndOfDirectoryVersion2;
+    let zip64EndOfDirectoryLength = ZIP64_END_OF_CENTRAL_DIR_LENGTH;
+    let directoryEncryptionInfo;
+    const requiresZip64 = directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS || diskNumber == MAX_16_BITS;
+    if (directoryDataOffset != MAX_32_BITS && diskNumber != MAX_16_BITS) {
+      directoryDataOffset += getDiskOffset(reader, diskNumber);
+    }
+    if (requiresZip64) {
+      const endOfDirectoryLocatorArray = endOfDirectoryInfo.offset >= ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH ? await readUint8Array(reader, endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH) : EMPTY_UINT8_ARRAY;
+      const endOfDirectoryLocatorView = getDataView(endOfDirectoryLocatorArray);
+      if (endOfDirectoryLocatorArray.length == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH && getUint32(endOfDirectoryLocatorView, 0) == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE) {
+        directoryDataOffset = getDiskOffset(reader, getUint32(endOfDirectoryLocatorView, 4)) + getBigUint64(endOfDirectoryLocatorView, 8);
+        let endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
+        let endOfDirectoryView = getDataView(endOfDirectoryArray);
+        if (endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
+          const locatorOffset = endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH;
+          let expectedDirectoryDataOffset = locatorOffset - ZIP64_END_OF_CENTRAL_DIR_LENGTH;
+          if (!await startsWithSignature(reader, expectedDirectoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_SIGNATURE)) {
+            expectedDirectoryDataOffset = await findZip64EndOfDirectoryOffset(reader, locatorOffset);
+          }
+          if (expectedDirectoryDataOffset !== UNDEFINED_VALUE && expectedDirectoryDataOffset >= 0 && directoryDataOffset != expectedDirectoryDataOffset) {
+            const originalDirectoryDataOffset = directoryDataOffset;
+            directoryDataOffset = expectedDirectoryDataOffset;
+            if (directoryDataOffset > originalDirectoryDataOffset) {
+              prependedDataLength = directoryDataOffset - originalDirectoryDataOffset;
+            }
+            endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
+            endOfDirectoryView = getDataView(endOfDirectoryArray);
+          }
+        }
+        if (endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
+          throw new Error(ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND2);
+        }
+        zip64EndOfDirectory = true;
+        zip64EndOfDirectoryVersion2 = getBigUint64(endOfDirectoryView, 4) > ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12;
+        if (zip64EndOfDirectoryVersion2) {
+          const extensibleDataLength = Math.min(getBigUint64(endOfDirectoryView, 4) - (ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12), reader.size - directoryDataOffset - ZIP64_END_OF_CENTRAL_DIR_LENGTH);
+          if (extensibleDataLength > 0) {
+            zip64EndOfDirectoryLength += extensibleDataLength;
+            const rawExtensibleData = await readUint8Array(reader, directoryDataOffset + ZIP64_END_OF_CENTRAL_DIR_LENGTH, extensibleDataLength);
+            directoryEncryptionInfo = getDirectoryEncryptionInfo(rawExtensibleData);
+          }
+        }
+        if (lastDiskNumber == MAX_16_BITS) {
+          lastDiskNumber = getUint32(endOfDirectoryView, 16);
+        } else if (lastDiskNumber != getUint32(endOfDirectoryView, 16)) {
+          reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY2);
+        }
+        if (diskNumber == MAX_16_BITS) {
+          diskNumber = getUint32(endOfDirectoryView, 20);
+        } else if (diskNumber != getUint32(endOfDirectoryView, 20)) {
+          reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY2);
+        }
+        if (filesLength == MAX_16_BITS) {
+          filesLength = getBigUint64(endOfDirectoryView, 32);
+        } else if (filesLength != getBigUint64(endOfDirectoryView, 32)) {
+          reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY2);
+        }
+        if (directoryDataLength == MAX_32_BITS) {
+          directoryDataLength = getBigUint64(endOfDirectoryView, 40);
+        } else if (directoryDataLength != getBigUint64(endOfDirectoryView, 40)) {
+          reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY2);
+        }
+        directoryDataOffset = getDiskOffset(reader, diskNumber) + getBigUint64(endOfDirectoryView, 48) + prependedDataLength;
+      } else if (directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || diskNumber == MAX_16_BITS) {
+        throw new Error(ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND2);
+      }
+    }
+    let declaredDirectoryDataLength = directoryDataLength;
+    const centralDirectoryEndOffset = endOfDirectoryInfo.offset - (zip64EndOfDirectory ? zip64EndOfDirectoryLength + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH : 0);
+    if (expectedLastDiskNumber != lastDiskNumber) {
+      throw new Error(ERR_SPLIT_ZIP_FILE2);
+    }
+    if (directoryDataOffset < 0) {
+      throw new Error(ERR_BAD_FORMAT2);
+    }
+    let offset = 0;
+    let directoryArray = directoryDataOffset < reader.size ? await readUint8Array(reader, directoryDataOffset, directoryDataLength) : EMPTY_UINT8_ARRAY;
+    let directoryView = getDataView(directoryArray);
+    if (directoryDataLength) {
+      let expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength;
+      if (directoryDataOffset != expectedDirectoryDataOffset && diskNumber == lastDiskNumber) {
+        const storedPointsAtDirectory = directoryArray.length >= 4 && (getUint32(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE || Boolean(directoryEncryptionInfo && directoryEncryptionInfo.compressedSize) || detectEncryptedCentralDirectory(directoryView));
+        if (!storedPointsAtDirectory && expectedDirectoryDataOffset < 0) {
+          throw new Error(ERR_BAD_FORMAT2);
+        }
+        let reconcile = !storedPointsAtDirectory;
+        if (expectedDirectoryDataOffset >= 0 && expectedDirectoryDataOffset + 4 <= reader.size) {
+          let expectedPointsAtDirectory = await pointsAtDirectory(reader, expectedDirectoryDataOffset);
+          if (!expectedPointsAtDirectory) {
+            const signatureRecordOffset = await findDigitalSignatureRecordOffset(reader, centralDirectoryEndOffset);
+            const signedDirectoryDataOffset = signatureRecordOffset - directoryDataLength;
+            if (signatureRecordOffset !== UNDEFINED_VALUE && signedDirectoryDataOffset >= 0 && await pointsAtDirectory(reader, signedDirectoryDataOffset)) {
+              expectedDirectoryDataOffset = signedDirectoryDataOffset;
+              expectedPointsAtDirectory = true;
+            }
+          }
+          if (storedPointsAtDirectory) {
+            reconcile = expectedPointsAtDirectory;
+          }
+        }
+        if (reconcile && expectedDirectoryDataOffset != directoryDataOffset) {
+          const originalDirectoryDataOffset = directoryDataOffset;
+          directoryDataOffset = expectedDirectoryDataOffset;
+          directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
+          directoryView = getDataView(directoryArray);
+          const offsetDelta = directoryDataOffset - originalDirectoryDataOffset;
+          const { localHeaderFound, shiftedLocalHeaderFound } = await probeLocalHeaders(reader, directoryArray, directoryView, offsetDelta);
+          if (offsetDelta > 0 && !(localHeaderFound && !shiftedLocalHeaderFound)) {
+            prependedDataLength += offsetDelta;
+            prependedCentralDirectory = storedPointsAtDirectory;
+          } else {
+            reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET2);
+            if (offsetDelta < 0 && !localHeaderFound && shiftedLocalHeaderFound) {
+              prependedDataLength += offsetDelta;
+            }
+          }
+        }
+      }
+      if (directoryArray.length < 4) {
+        throw new Error(ERR_BAD_FORMAT2);
+      }
+    } else if (!filesLength && directoryDataOffset < centralDirectoryEndOffset && diskNumber == lastDiskNumber) {
+      prependedDataLength += centralDirectoryEndOffset - directoryDataOffset;
+      directoryDataOffset = centralDirectoryEndOffset;
+    }
+    const expectedDirectoryDataLength = centralDirectoryEndOffset - directoryDataOffset;
+    if (directoryDataLength != expectedDirectoryDataLength && expectedDirectoryDataLength >= 0 && diskNumber == lastDiskNumber) {
+      directoryDataLength = expectedDirectoryDataLength;
+      directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
+      directoryView = getDataView(directoryArray);
+    }
+    if (directoryDataOffset < 0 || directoryDataOffset >= reader.size) {
+      throw new Error(ERR_BAD_FORMAT2);
+    }
+    zipReader.directoryOffset = directoryDataOffset;
+    zipReader.directoryLength = declaredDirectoryDataLength;
+    const decryptCentralDirectory = getFunctionOptionValue(zipReader, options, OPTION_DECRYPT_CENTRAL_DIRECTORY);
+    let decryptedDirectory, dataAfterEncryptedDirectory;
+    if (decryptCentralDirectory && filesLength && directoryArray.length >= 4 && getUint32(directoryView, 0) != CENTRAL_FILE_HEADER_SIGNATURE && (zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
+      const encryptedDirectoryDataLength = getEncryptedDirectoryDataLength(directoryEncryptionInfo, declaredDirectoryDataLength, directoryArray.length);
+      dataAfterEncryptedDirectory = directoryArray.subarray(encryptedDirectoryDataLength);
+      directoryArray = await decryptCentralDirectory(directoryArray.subarray(0, encryptedDirectoryDataLength), directoryEncryptionInfo);
+      directoryView = getDataView(directoryArray);
+      declaredDirectoryDataLength = directoryArray.length;
+      decryptedDirectory = true;
+    }
+    if (directoryEncryptionInfo && !decryptedDirectory && (directoryArray.length < 4 || getUint32(directoryView, 0) == CENTRAL_FILE_HEADER_SIGNATURE)) {
+      addWarning(warnings, WARNING_UNKNOWN_ZIP64_EXTENSIBLE_DATA2);
+    }
+    startOffset = directoryDataOffset;
+    const filenameEncoding = getOptionValue(zipReader, options, OPTION_FILENAME_ENCODING);
+    const commentEncoding = getOptionValue(zipReader, options, OPTION_COMMENT_ENCODING);
+    const filenames = new Set;
+    let duplicateFilename;
+    let previousEntryPosition = -Infinity;
+    const recoverWrappedFilesLength = !checkAmbiguity && !zip64EndOfDirectory;
+    if (!filesLength && recoverWrappedFilesLength) {
+      filesLength = getWrappedFilesLength(directoryView, directoryArray, offset);
+      if (filesLength) {
+        addWarning(warnings, WARNING_WRAPPED_ENTRIES_COUNT2);
+      }
+    }
+    const entryOptions = Object.assign({}, zipReader.options, options, { [OPTION_STRICTNESS]: strictness });
+    delete entryOptions[OPTION_CHECK_AMBIGUITY];
+    for (let indexFile = 0;indexFile < filesLength; indexFile++) {
+      const fileEntry = new ZipEntry(reader, entryOptions);
+      if (offset + CENTRAL_FILE_HEADER_LENGTH > directoryArray.length || getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
+        if (indexFile == 0 && !decryptedDirectory && (zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
+          throw new Error(ERR_ENCRYPTED_CENTRAL_DIRECTORY2);
+        }
+        throw new Error(ERR_CENTRAL_DIRECTORY_NOT_FOUND2);
+      }
+      readCommonHeader(fileEntry, directoryView, offset + 6);
+      const languageEncodingFlag = Boolean(fileEntry.bitFlag.languageEncodingFlag);
+      const filenameOffset = offset + CENTRAL_FILE_HEADER_LENGTH;
+      const extraFieldOffset = filenameOffset + fileEntry.filenameLength;
+      const commentOffset = extraFieldOffset + fileEntry.extraFieldLength;
+      const versionMadeBy = getUint16(directoryView, offset + 4);
+      const msDosCompatible = versionMadeBy >> 8 == 0;
+      const unixCompatible = versionMadeBy >> 8 == 3;
+      const commentLength = getUint16(directoryView, offset + 32);
+      const endOffset = commentOffset + commentLength;
+      const rawEntryData = new Uint8Array(directoryArray.subarray(filenameOffset, endOffset));
+      const rawFilename = rawEntryData.subarray(0, fileEntry.filenameLength);
+      const rawComment = rawEntryData.subarray(fileEntry.filenameLength + fileEntry.extraFieldLength);
+      const filenameUTF8 = languageEncodingFlag || !filenameEncoding && isUTF8Text(rawFilename);
+      const commentUTF8 = languageEncodingFlag || !commentEncoding && isUTF8Text(rawComment);
+      const externalFileAttributes = getUint32(directoryView, offset + 38);
+      const msdosAttributesRaw = externalFileAttributes & MAX_8_BITS;
+      const msdosAttributes = {
+        readOnly: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_READONLY_MASK),
+        hidden: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_HIDDEN_MASK),
+        system: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_SYSTEM_MASK),
+        directory: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_DIR_MASK),
+        archive: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_ARCHIVE_MASK)
+      };
+      const offsetFileEntry = getUint32(directoryView, offset + 42);
+      const decode = getFunctionOptionValue(zipReader, options, OPTION_DECODE_TEXT) || decodeText;
+      const rawFilenameEncoding = filenameUTF8 ? CHARSET_UTF8 : filenameEncoding || CHARSET_CP437;
+      const rawCommentEncoding = commentUTF8 ? CHARSET_UTF8 : commentEncoding || CHARSET_CP437;
+      let filename = decode(rawFilename, rawFilenameEncoding, TEXT_TYPE_FILENAME);
+      if (filename === UNDEFINED_VALUE) {
+        filename = decodeText(rawFilename, rawFilenameEncoding);
+      }
+      let comment = decode(rawComment, rawCommentEncoding, TEXT_TYPE_COMMENT);
+      if (comment === UNDEFINED_VALUE) {
+        comment = decodeText(rawComment, rawCommentEncoding);
+      }
+      Object.assign(fileEntry, {
+        index: indexFile,
+        decryptedDirectory,
+        versionMadeBy,
+        msDosCompatible,
+        zip64: false,
+        compressedSize: 0,
+        uncompressedSize: 0,
+        commentLength,
+        offset: offsetFileEntry,
+        diskNumberStart: getUint16(directoryView, offset + 34),
+        internalFileAttributes: getUint16(directoryView, offset + 36),
+        externalFileAttributes,
+        msdosAttributesRaw,
+        msdosAttributes,
+        rawFilename,
+        filenameUTF8,
+        commentUTF8,
+        rawExtraField: rawEntryData.subarray(fileEntry.filenameLength, fileEntry.filenameLength + fileEntry.extraFieldLength),
+        rawComment,
+        filename,
+        comment
+      });
+      let malformedExtraField;
+      try {
+        malformedExtraField = readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6);
+      } catch (error) {
+        if (checkAmbiguity || error.message != ERR_EXTRAFIELD_ZIP64_NOT_FOUND2) {
+          throw error;
+        }
+        fileEntry.zip64ExtraFieldMissing = true;
+        addWarning(warnings, WARNING_MISSING_ZIP64_EXTRA_FIELD2, fileEntry.filename);
+      }
+      filename = fileEntry.filename;
+      if (normalizeFilename) {
+        const normalizedFilename = normalizeFilename(filename);
+        if (normalizedFilename !== UNDEFINED_VALUE) {
+          filename = fileEntry.filename = normalizedFilename;
+        }
+      }
+      if (isUnsafeFilename(filename, filenameValidation)) {
+        const error = new Error(ERR_UNSAFE_FILENAME2);
+        error.filename = filename;
+        throw error;
+      }
+      if (malformedExtraField) {
+        addWarning(warnings, WARNING_MALFORMED_EXTRA_FIELD2, filename);
+      }
+      if (fileEntry.zip64ExtraFieldMissing && fileEntry.offset == MAX_32_BITS) {
+        startOffset = 0;
+      } else {
+        fileEntry.offset += prependedDataLength;
+        const entryPosition = getDiskOffset(reader, fileEntry.diskNumberStart) + fileEntry.offset;
+        startOffset = Math.min(entryPosition, startOffset);
+        if (entryPosition < previousEntryPosition) {
+          addWarning(warnings, WARNING_UNSORTED_CENTRAL_DIRECTORY2, filename);
+        }
+        previousEntryPosition = entryPosition;
+      }
+      if ((fileEntry.version & MAX_8_BITS) > MAX_KNOWN_VERSION) {
+        addWarning(warnings, WARNING_UNKNOWN_VERSION2, filename);
+      }
+      if ((fileEntry.rawBitFlag & BITFLAG_COMPRESSED_PATCHED_DATA) == BITFLAG_COMPRESSED_PATCHED_DATA) {
+        addWarning(warnings, WARNING_COMPRESSED_PATCHED_DATA2, filename);
+      }
+      if (filenames.has(fileEntry.filename)) {
+        duplicateFilename = true;
+      }
+      filenames.add(fileEntry.filename);
+      const unixExternalUpper = fileEntry.externalFileAttributes >> 16 & MAX_16_BITS;
+      if (fileEntry.unixMode === UNDEFINED_VALUE && (unixExternalUpper & (FILE_ATTR_UNIX_DEFAULT_MASK | FILE_ATTR_UNIX_EXECUTABLE_MASK | FILE_ATTR_UNIX_TYPE_DIR)) != 0) {
+        fileEntry.unixMode = unixExternalUpper;
+      }
+      const setuid = Boolean(fileEntry.unixMode & FILE_ATTR_UNIX_SETUID_MASK);
+      const setgid = Boolean(fileEntry.unixMode & FILE_ATTR_UNIX_SETGID_MASK);
+      const sticky = Boolean(fileEntry.unixMode & FILE_ATTR_UNIX_STICKY_MASK);
+      const unixType = fileEntry.unixMode === UNDEFINED_VALUE ? unixExternalUpper : fileEntry.unixMode;
+      const symlink = (unixType & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_SYMLINK;
+      const modeIsDir = fileEntry.unixMode !== UNDEFINED_VALUE && (fileEntry.unixMode & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_DIR;
+      const upperIsDir = (unixExternalUpper & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_DIR;
+      const directory = modeIsDir || upperIsDir || msDosCompatible && msdosAttributes.directory || fileEntry.filename.endsWith(DIRECTORY_SIGNATURE);
+      const executable = !symlink && !directory && (fileEntry.unixMode !== UNDEFINED_VALUE ? (fileEntry.unixMode & FILE_ATTR_UNIX_EXECUTABLE_MASK) != 0 : unixCompatible && (unixExternalUpper & FILE_ATTR_UNIX_EXECUTABLE_MASK) != 0);
+      Object.assign(fileEntry, {
+        setuid,
+        setgid,
+        sticky,
+        symlink,
+        unixExternalUpper,
+        executable,
+        directory,
+        zipCrypto: fileEntry.encrypted && !fileEntry.extraFieldAES
+      });
+      const entry = new Entry(fileEntry);
+      if (fileEntry.zip64ExtraFieldMissing) {
+        zipReader.entriesMissingZip64ExtraField.add(entry);
+      }
+      entry.getData = (writer, options) => fileEntry.getData(writer, entry, zipReader, options);
+      entry.arrayBuffer = async (options) => {
+        const writer = new TransformStream;
+        const arrayBufferPromise = streamToBlob(writer.readable).then((blob) => blob.arrayBuffer());
+        arrayBufferPromise.catch(() => {});
+        await fileEntry.getData(writer, entry, zipReader, Object.assign({}, options, { preventClose: false }));
+        return arrayBufferPromise;
+      };
+      offset = endOffset;
+      if (indexFile == filesLength - 1 && recoverWrappedFilesLength) {
+        const wrappedFilesLength = getWrappedFilesLength(directoryView, directoryArray, offset);
+        if (wrappedFilesLength) {
+          filesLength += wrappedFilesLength;
+          addWarning(warnings, WARNING_WRAPPED_ENTRIES_COUNT2);
+        }
+      }
+      const { onprogress } = options;
+      if (onprogress) {
+        try {
+          await onprogress(indexFile + 1, filesLength, new Entry(fileEntry));
+        } catch {}
+      }
+      yield entry;
+    }
+    let offsetAfterSignature = offset;
+    let digitalSignature = readDigitalSignature(directoryArray.subarray(offset)) || (decryptedDirectory ? readDigitalSignature(dataAfterEncryptedDirectory) : UNDEFINED_VALUE);
+    if (!digitalSignature && !decryptedDirectory) {
+      const signatureRecordOffset = directoryDataOffset + offset;
+      const signatureRecordLength = Math.min(centralDirectoryEndOffset - signatureRecordOffset, 6 + MAX_16_BITS);
+      if (signatureRecordLength >= 6) {
+        digitalSignature = readDigitalSignature(await readUint8Array(reader, signatureRecordOffset, signatureRecordLength));
+      }
+    }
+    if (digitalSignature) {
+      zipReader.digitalSignature = digitalSignature;
+      offsetAfterSignature = offset + 6 + digitalSignature.length;
+    }
+    if (offset != declaredDirectoryDataLength && offsetAfterSignature != declaredDirectoryDataLength || !decryptedDirectory && offset != directoryDataLength && offsetAfterSignature != directoryDataLength) {
+      reportAmbiguity(checkAmbiguity, warnings, WARNING_TRAILING_CENTRAL_DIRECTORY_DATA2);
+    }
+    if (duplicateFilename) {
+      reportAmbiguity(checkAmbiguity, warnings, WARNING_DUPLICATE_FILENAME2);
+    }
+    const extractPrependedData = getOptionValue(zipReader, options, OPTION_EXTRACT_PREPENDED_DATA);
+    const extractAppendedData = getOptionValue(zipReader, options, OPTION_EXTRACT_APPENDED_DATA);
+    const splitZipSignatureLength = (checkAmbiguity || extractPrependedData) && filesLength && startOffset == SPLIT_ZIP_FILE_SIGNATURE_LENGTH && await startsWithSplitZipMarker(reader) ? SPLIT_ZIP_FILE_SIGNATURE_LENGTH : 0;
+    if (checkAmbiguity && (prependedDataLength > 0 || filesLength && startOffset > splitZipSignatureLength)) {
+      throwAmbiguousArchive(WARNING_PREPENDED_DATA2);
+    }
+    if (prependedDataLength > 0 || filesLength && startOffset > SPLIT_ZIP_FILE_SIGNATURE_LENGTH) {
+      addWarning(warnings, WARNING_PREPENDED_DATA2);
+    }
+    if (prependedCentralDirectory) {
+      addWarning(warnings, WARNING_PREPENDED_CENTRAL_DIRECTORY2);
+    }
+    if (extractPrependedData) {
+      zipReader.prependedData = startOffset > splitZipSignatureLength ? await readUint8Array(reader, splitZipSignatureLength, startOffset - splitZipSignatureLength) : EMPTY_UINT8_ARRAY;
+    }
+    zipReader.comment = commentLength ? await readUint8Array(reader, commentOffset + END_OF_CENTRAL_DIR_LENGTH, commentLength) : EMPTY_UINT8_ARRAY;
+    if (extractAppendedData) {
+      zipReader.appendedData = appendedDataOffset < reader.size ? await readUint8Array(reader, appendedDataOffset, reader.size - appendedDataOffset) : EMPTY_UINT8_ARRAY;
+    }
+    return true;
+  }
+  async getEntries(options = {}) {
+    const entries = [];
+    for await (const entry of this.getEntriesGenerator(options)) {
+      entries.push(entry);
+    }
+    return entries;
+  }
+  async close() {
+    const { reader } = this;
+    if (!reader.readUint8Array && reader.readable && !reader.readable.locked) {
+      await reader.readable.cancel();
+    }
+  }
+  [SYMBOL_ASYNC_DISPOSE]() {
+    return this.close();
+  }
+}
+
+class ZipReaderStream2 {
+  constructor(options = {}) {
+    let sourceController;
+    const { readable, writable } = new TransformStream({
+      start(controller) {
+        sourceController = controller;
+      }
+    });
+    const zipReader = new ZipReader2(readable, options);
+    const gen = zipReader.getEntriesGenerator();
+    const pendingEntries = new Set;
+    this.readable = new ReadableStream({
+      async pull(controller) {
+        const { done, value } = await gen.next();
+        if (done)
+          return controller.close();
+        const entryStream = createEntryStream(value, pendingEntries);
+        const chunk = {
+          ...value,
+          readable: entryStream.readable
+        };
+        delete chunk.getData;
+        Object.defineProperties(chunk, {
+          localDirectory: {
+            get: () => value.localDirectory,
+            enumerable: true
+          },
+          warnings: {
+            get: () => value.warnings,
+            enumerable: true
+          }
+        });
+        controller.enqueue(chunk);
+      },
+      async cancel(reason) {
+        const entryStreams = Array.from(pendingEntries);
+        pendingEntries.clear();
+        sourceController.error(reason);
+        await Promise.allSettled(entryStreams.map((entryStream) => entryStream.cancel(reason)));
+        await Promise.allSettled([gen.return(), zipReader.close()]);
+      }
+    });
+    this.writable = writable;
+  }
+}
+function createEntryStream(entry, pendingEntries) {
+  const { readable, writable } = new TransformStream;
+  let dataReader;
+  const entryStream = {
+    cancel: async (reason) => {
+      pendingEntries.delete(entryStream);
+      await (dataReader ? dataReader.cancel(reason) : readable.cancel(reason));
+    }
+  };
+  entryStream.readable = new ReadableStream({
+    async pull(controller) {
+      if (!dataReader) {
+        dataReader = readable.getReader();
+        pendingEntries.add(entryStream);
+        getData();
+      }
+      const { done, value } = await dataReader.read();
+      if (done) {
+        controller.close();
+      } else {
+        controller.enqueue(value);
+      }
+    },
+    cancel: (reason) => entryStream.cancel(reason)
+  }, { highWaterMark: 0 });
+  return entryStream;
+  async function getData() {
+    try {
+      await entry.getData(writable, { preventClose: false });
+    } catch (error) {
+      try {
+        await writable.abort(error);
+      } catch {}
+    } finally {
+      pendingEntries.delete(entryStream);
+    }
+  }
+}
+async function isZipFile2(reader, options = {}) {
+  reader = new GenericReader(reader);
+  await initStream(reader);
+  if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
+    reader = new BlobReader(await streamToBlob(reader.readable));
+    await initStream(reader);
+  }
+  if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
+    return false;
+  }
+  const strictness = getStrictness(options, {});
+  const rejectAmbiguousEndOfDirectory = strictness != STRICTNESS_TOLERANT;
+  const maxAppendedDataSize = getMaxAppendedDataSize(options[OPTION_MAX_APPENDED_DATA_SIZE], strictness);
+  const { endOfDirectoryInfo, endOfDirectoryReachingEndCount } = await findEndOfCentralDirectory(reader, rejectAmbiguousEndOfDirectory, maxAppendedDataSize);
+  if (!endOfDirectoryInfo || strictness == STRICTNESS_STRICT && endOfDirectoryReachingEndCount > 1) {
+    return false;
+  }
+  const commentLength = getUint16(getDataView(endOfDirectoryInfo), 20);
+  const appendedDataOffset = endOfDirectoryInfo.offset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
+  return reader.size - appendedDataOffset <= maxAppendedDataSize;
+}
+class ZipEntry {
+  constructor(reader, options) {
+    Object.assign(this, {
+      reader,
+      options
+    });
+  }
+  async getData(writer, fileEntry, zipReader, options = {}) {
+    const zipEntry = this;
+    const { readRanges, directoryOffset } = zipReader;
+    if (zipEntry.zip64ExtraFieldMissing) {
+      throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND2);
+    }
+    const config = getConfiguration();
+    const {
+      reader,
+      index,
+      offset,
+      diskNumberStart,
+      extraFieldAES,
+      extraFieldZip64,
+      compressionMethod,
+      bitFlag,
+      rawBitFlag,
+      crc32,
+      rawLastModDate,
+      uncompressedSize,
+      compressedSize
+    } = zipEntry;
+    const {
+      dataDescriptor
+    } = bitFlag;
+    const localDirectory = fileEntry.localDirectory = {};
+    const warnings = fileEntry.warnings = [];
+    const localHeaderOffset = getDiskOffset(reader, diskNumberStart) + offset;
+    const dataArray = await readUint8Array(reader, localHeaderOffset, HEADER_SIZE);
+    const dataView = getDataView(dataArray);
+    let password = getOptionValue(zipEntry, options, OPTION_PASSWORD);
+    let rawPassword = getOptionValue(zipEntry, options, OPTION_RAW_PASSWORD);
+    const passThrough = checkPassThroughOption(getOptionValue(zipEntry, options, OPTION_PASS_THROUGH));
+    const passThroughCompression = Boolean(passThrough);
+    const passThroughEncryption = passThrough === true;
+    checkPasswordOption(password, rawPassword);
+    password = password && password.length ? password : UNDEFINED_VALUE;
+    rawPassword = rawPassword && rawPassword.length ? rawPassword : UNDEFINED_VALUE;
+    if (extraFieldAES) {
+      if (extraFieldAES.originalCompressionMethod != COMPRESSION_METHOD_AES) {
+        throw new Error(ERR_UNSUPPORTED_COMPRESSION2);
+      }
+    }
+    if (dataArray.length < HEADER_SIZE || getUint32(dataView, 0) != LOCAL_FILE_HEADER_SIGNATURE) {
+      throw new Error(ERR_LOCAL_FILE_HEADER_NOT_FOUND2);
+    }
+    readCommonHeader(localDirectory, dataView, 4);
+    const {
+      extraFieldLength,
+      filenameLength
+    } = localDirectory;
+    const dataOffset = localDirectory.dataOffset = localHeaderOffset + HEADER_SIZE + filenameLength + extraFieldLength;
+    const checkLocalDirectoryOption = getOptionValue(zipEntry, options, OPTION_CHECK_LOCAL_DIRECTORY);
+    const entryStrictness = getStrictness(options, zipEntry.options);
+    const checkLocalDirectory = getCheckLocalDirectory(checkLocalDirectoryOption, entryStrictness);
+    const checkLocalFilenameOption = getOptionValue(zipEntry, options, OPTION_CHECK_LOCAL_FILENAME);
+    const checkLocalFilename = getCheckLocalFilename(checkLocalFilenameOption === UNDEFINED_VALUE ? checkLocalDirectoryOption : checkLocalFilenameOption, entryStrictness);
+    let rawLocalFilename = EMPTY_UINT8_ARRAY;
+    if (checkLocalFilename && (filenameLength || extraFieldLength)) {
+      const trailingDataArray = await readUint8Array(reader, localHeaderOffset + HEADER_SIZE, filenameLength + extraFieldLength);
+      rawLocalFilename = trailingDataArray.subarray(0, filenameLength);
+      localDirectory.rawExtraField = trailingDataArray.subarray(filenameLength);
+    } else {
+      localDirectory.rawExtraField = extraFieldLength ? await readUint8Array(reader, localHeaderOffset + HEADER_SIZE + filenameLength, extraFieldLength) : EMPTY_UINT8_ARRAY;
+    }
+    if (checkLocalFilename) {
+      localDirectory.rawFilename = rawLocalFilename;
+    }
+    if (readCommonFooter(zipEntry, localDirectory, dataView, 4, true)) {
+      addWarning(warnings, WARNING_MALFORMED_EXTRA_FIELD2);
+    }
+    validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename, checkLocalDirectory ? UNDEFINED_VALUE : warnings);
+    const { lastAccessDate, creationDate, uid, gid } = localDirectory;
+    if (lastAccessDate && fileEntry.lastAccessDate === UNDEFINED_VALUE) {
+      fileEntry.lastAccessDate = lastAccessDate;
+    }
+    if (creationDate && fileEntry.creationDate === UNDEFINED_VALUE) {
+      fileEntry.creationDate = creationDate;
+    }
+    if (uid !== UNDEFINED_VALUE && fileEntry.uid === UNDEFINED_VALUE) {
+      fileEntry.uid = uid;
+    }
+    if (gid !== UNDEFINED_VALUE && fileEntry.gid === UNDEFINED_VALUE) {
+      fileEntry.gid = gid;
+    }
+    const checkPasswordOnly = getOptionValue(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
+    const encrypted = zipEntry.encrypted && (!passThroughEncryption || checkPasswordOnly);
+    const zipCrypto = encrypted && !extraFieldAES;
+    if (!passThroughEncryption) {
+      fileEntry.zipCrypto = zipCrypto;
+    }
+    if (encrypted && (zipEntry.rawBitFlag & BITFLAG_STRONG_ENCRYPTION) == BITFLAG_STRONG_ENCRYPTION) {
+      throw new Error(ERR_UNSUPPORTED_ENCRYPTION2);
+    }
+    const registeredCodec = passThroughCompression ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
+    if (compressionMethod != COMPRESSION_METHOD_STORE && compressionMethod != COMPRESSION_METHOD_DEFLATE && compressionMethod != COMPRESSION_METHOD_DEFLATE_64 && !registeredCodec && !passThroughCompression) {
+      throw new Error(ERR_UNSUPPORTED_COMPRESSION2);
+    }
+    if (encrypted) {
+      if (!zipCrypto && (extraFieldAES.strength < 1 || extraFieldAES.strength > 3)) {
+        throw new Error(ERR_UNSUPPORTED_ENCRYPTION2);
+      } else if (!password && !rawPassword) {
+        throw new Error(ERR_ENCRYPTED2);
+      }
+    }
+    if (dataOffset + compressedSize > Math.min(reader.size, directoryOffset)) {
+      throw new Error(ERR_ENTRY_DATA_OUT_OF_BOUNDS2);
+    }
+    const size = compressedSize;
+    const signal = checkSignalOption(getOptionValue(zipEntry, options, OPTION_SIGNAL));
+    throwIfAborted(signal);
+    let checkOverlappingEntry = getOptionValue(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY);
+    const checkOverlappingEntryOnly = getOptionValue(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY_ONLY);
+    if (checkOverlappingEntryOnly) {
+      checkOverlappingEntry = true;
+    }
+    const { onstart, onprogress, onend } = options;
+    const compressed = compressionMethod != COMPRESSION_METHOD_STORE && !passThroughCompression;
+    const outputSize = passThroughCompression ? compressedSize - getEncryptionOverhead(encrypted, zipCrypto, extraFieldAES && extraFieldAES.strength) : uncompressedSize;
+    const deflate64 = compressionMethod == COMPRESSION_METHOD_DEFLATE_64;
+    let useCompressionStream = getOptionValue(zipEntry, options, OPTION_USE_COMPRESSION_STREAM);
+    if (deflate64) {
+      useCompressionStream = false;
+    }
+    const checkCrc32Option = getOptionValue(zipEntry, options, OPTION_CHECK_CRC32);
+    const checkCrc32 = (checkCrc32Option === UNDEFINED_VALUE ? getOptionValue(zipEntry, options, OPTION_CHECK_SIGNATURE) : checkCrc32Option) && !passThroughCompression && (!encrypted || zipCrypto || extraFieldAES && extraFieldAES.vendorVersion == VENDOR_VERSION_AE_1);
+    const workerOptions = {
+      options: {
+        codecType: CODEC_INFLATE,
+        password,
+        rawPassword,
+        zipCrypto,
+        encryptionStrength: extraFieldAES && extraFieldAES.strength,
+        checkCrc32,
+        checkAuthenticationCode: getOptionValue(zipEntry, options, OPTION_CHECK_AUTHENTICATION_CODE),
+        passwordVerification: zipCrypto && (dataDescriptor ? rawLastModDate >>> 8 & MAX_8_BITS : crc32 >>> 24 & MAX_8_BITS),
+        outputSize,
+        crc32,
+        compressed,
+        encrypted,
+        useWebWorkers: getOptionValue(zipEntry, options, OPTION_USE_WEB_WORKERS),
+        useCompressionStream,
+        deflate64,
+        format: registeredCodec ? registeredCodec.format : UNDEFINED_VALUE,
+        codecURI: registeredCodec ? registeredCodec.codecURI : UNDEFINED_VALUE,
+        compressionMethod,
+        rawBitFlag,
+        checkPasswordOnly
+      },
+      config,
+      streamOptions: { signal, size, onstart, onprogress, onend }
+    };
+    if (checkOverlappingEntry) {
+      await detectOverlappingEntry({
+        reader,
+        fileEntry,
+        index,
+        offset: localHeaderOffset,
+        crc32,
+        compressedSize,
+        uncompressedSize,
+        dataOffset,
+        dataDescriptor: dataDescriptor || localDirectory.bitFlag.dataDescriptor,
+        extraFieldZip64: extraFieldZip64 || localDirectory.extraFieldZip64,
+        readRanges
+      });
+      validateDataDescriptor(zipEntry, localDirectory, checkLocalDirectory ? UNDEFINED_VALUE : warnings);
+    }
+    let writable, abortError, aborted;
+    try {
+      if (!checkOverlappingEntryOnly) {
+        if (checkPasswordOnly) {
+          writer = new WritableStream;
+        }
+        writer = new GenericWriter(writer);
+        await initStream(writer, getDecodableOutputSize(outputSize, compressedSize, compressed));
+        ({ writable } = writer);
+        const readable = toCompatibleReadable(reader.createReadable({ offset: dataOffset, size }));
+        const { outputSize: writtenSize } = await runWorker2({ readable, writable }, workerOptions);
+        throwIfAborted(signal);
+        if (writtenSize != outputSize) {
+          throw Object.assign(new Error(ERR_INVALID_UNCOMPRESSED_SIZE2), { outputSize: writtenSize });
+        }
+        writer.size += writtenSize;
+      }
+    } catch (error) {
+      if (isErrorObject(error) && error.outputSize !== UNDEFINED_VALUE) {
+        writer.size += error.outputSize;
+      }
+      if (!checkPasswordOnly || !isErrorObject(error) || error.message != ERR_ABORT_CHECK_PASSWORD) {
+        abortError = error;
+        aborted = true;
+        throw error;
+      }
+    } finally {
+      const preventClose = !ownsWritable(writer) && getOptionValue(zipEntry, options, OPTION_PREVENT_CLOSE);
+      if (!preventClose && writable && !writable.locked) {
+        const writableWriter = writable.getWriter();
+        if (aborted) {
+          try {
+            await writableWriter.abort(abortError);
+          } catch {}
+        } else {
+          await writableWriter.close();
+        }
+      }
+    }
+    return checkPasswordOnly || checkOverlappingEntryOnly ? UNDEFINED_VALUE : writer.getData ? writer.getData() : writable;
+  }
+}
+function detectEncryptedCentralDirectory(directoryView) {
+  return directoryView.byteLength >= 4 && getUint32(directoryView, 0) == ARCHIVE_EXTRA_DATA_SIGNATURE;
+}
+function getWrappedFilesLength(directoryView, directoryArray, offset) {
+  let wrappedFilesLength = 0;
+  while (offset + CENTRAL_FILE_HEADER_LENGTH <= directoryArray.length && getUint32(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE) {
+    offset += CENTRAL_FILE_HEADER_LENGTH + getUint16(directoryView, offset + 28) + getUint16(directoryView, offset + 30) + getUint16(directoryView, offset + 32);
+    wrappedFilesLength++;
+  }
+  return wrappedFilesLength % (MAX_16_BITS + 1) ? 0 : wrappedFilesLength;
+}
+function pointsAtDirectory(reader, offset) {
+  return startsWithSignature(reader, offset, CENTRAL_FILE_HEADER_SIGNATURE);
+}
+async function startsWithSignature(reader, offset, signature) {
+  if (offset < 0 || offset + 4 > reader.size) {
+    return false;
+  }
+  const signatureArray = await readUint8Array(reader, offset, 4);
+  return getUint32(getDataView(signatureArray), 0) == signature;
+}
+async function findDigitalSignatureRecordOffset(reader, endOffset) {
+  const startOffset = Math.max(0, endOffset - (6 + MAX_16_BITS));
+  const tailArray = await readUint8Array(reader, startOffset, endOffset - startOffset);
+  const tailView = getDataView(tailArray);
+  for (let indexByte = tailArray.length - 6;indexByte >= 0; indexByte--) {
+    if (getUint32(tailView, indexByte) == DIGITAL_SIGNATURE_RECORD_SIGNATURE && indexByte + 6 + getUint16(tailView, indexByte + 4) == tailArray.length) {
+      return startOffset + indexByte;
+    }
+  }
+}
+async function findZip64EndOfDirectoryOffset(reader, endOffset) {
+  const startOffset = Math.max(0, endOffset - (ZIP64_END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS));
+  const tailArray = await readUint8Array(reader, startOffset, endOffset - startOffset);
+  const tailView = getDataView(tailArray);
+  for (let indexByte = tailArray.length - ZIP64_END_OF_CENTRAL_DIR_LENGTH;indexByte >= 0; indexByte--) {
+    if (getUint32(tailView, indexByte) == ZIP64_END_OF_CENTRAL_DIR_SIGNATURE && indexByte + 12 + Number(tailView.getBigUint64(indexByte + 4, true)) == tailArray.length) {
+      return startOffset + indexByte;
+    }
+  }
+}
+async function probeLocalHeaders(reader, directoryArray, directoryView, offsetDelta) {
+  let result = { localHeaderFound: false, shiftedLocalHeaderFound: false };
+  let recordOffset = 0;
+  while (recordOffset + CENTRAL_FILE_HEADER_LENGTH <= directoryArray.length && getUint32(directoryView, recordOffset) == CENTRAL_FILE_HEADER_SIGNATURE) {
+    const localHeaderOffset = getLocalHeaderOffset(directoryArray, directoryView, recordOffset);
+    if (localHeaderOffset !== UNDEFINED_VALUE) {
+      const localHeaderFound = await startsWithSignature(reader, localHeaderOffset, LOCAL_FILE_HEADER_SIGNATURE);
+      const shiftedLocalHeaderFound = await startsWithSignature(reader, localHeaderOffset + offsetDelta, LOCAL_FILE_HEADER_SIGNATURE);
+      if (!recordOffset) {
+        result = { localHeaderFound, shiftedLocalHeaderFound };
+      }
+      if (localHeaderFound != shiftedLocalHeaderFound) {
+        return { localHeaderFound, shiftedLocalHeaderFound };
+      }
+    }
+    recordOffset += CENTRAL_FILE_HEADER_LENGTH + getUint16(directoryView, recordOffset + 28) + getUint16(directoryView, recordOffset + 30) + getUint16(directoryView, recordOffset + 32);
+  }
+  return result;
+}
+function getLocalHeaderOffset(directoryArray, directoryView, recordOffset) {
+  const localHeaderOffset = getUint32(directoryView, recordOffset + 42);
+  if (localHeaderOffset != MAX_32_BITS) {
+    return localHeaderOffset;
+  }
+  let offsetExtraField = recordOffset + CENTRAL_FILE_HEADER_LENGTH + getUint16(directoryView, recordOffset + 28);
+  const endExtraField = Math.min(offsetExtraField + getUint16(directoryView, recordOffset + 30), directoryArray.length);
+  while (offsetExtraField + 4 <= endExtraField) {
+    const type = getUint16(directoryView, offsetExtraField);
+    const size = getUint16(directoryView, offsetExtraField + 2);
+    if (type == EXTRAFIELD_TYPE_ZIP64) {
+      let offsetValue = offsetExtraField + 4;
+      if (getUint32(directoryView, recordOffset + 24) == MAX_32_BITS) {
+        offsetValue += 8;
+      }
+      if (getUint32(directoryView, recordOffset + 20) == MAX_32_BITS) {
+        offsetValue += 8;
+      }
+      return offsetValue + 8 <= endExtraField ? getBigUint64(directoryView, offsetValue) : UNDEFINED_VALUE;
+    }
+    offsetExtraField += 4 + size;
+  }
+  return UNDEFINED_VALUE;
+}
+function readDigitalSignature(signatureRecordArray) {
+  if (signatureRecordArray.length >= 6) {
+    const signatureRecordView = getDataView(signatureRecordArray);
+    if (getUint32(signatureRecordView, 0) == DIGITAL_SIGNATURE_RECORD_SIGNATURE) {
+      const signatureDataLength = getUint16(signatureRecordView, 4);
+      if (6 + signatureDataLength <= signatureRecordArray.length) {
+        return new Uint8Array(signatureRecordArray.subarray(6, 6 + signatureDataLength));
+      }
+    }
+  }
+}
+function getEncryptedDirectoryDataLength(directoryEncryptionInfo, declaredDirectoryDataLength, directoryDataLength) {
+  const encryptedDirectoryDataLength = directoryEncryptionInfo && directoryEncryptionInfo.compressedSize ? directoryEncryptionInfo.compressedSize : declaredDirectoryDataLength;
+  return encryptedDirectoryDataLength > 0 && encryptedDirectoryDataLength <= directoryDataLength ? encryptedDirectoryDataLength : directoryDataLength;
+}
+function getDirectoryEncryptionInfo(rawExtensibleData) {
+  const directoryEncryptionInfo = { rawExtensibleData };
+  if (rawExtensibleData.length >= 28) {
+    const extensibleDataView = getDataView(rawExtensibleData);
+    const hashDataLength = getUint16(extensibleDataView, 26);
+    Object.assign(directoryEncryptionInfo, {
+      compressionMethod: getUint16(extensibleDataView, 0),
+      compressedSize: getBigUint64(extensibleDataView, 2),
+      uncompressedSize: getBigUint64(extensibleDataView, 10),
+      encryptionAlgorithm: getUint16(extensibleDataView, 18),
+      bitLength: getUint16(extensibleDataView, 20),
+      flags: getUint16(extensibleDataView, 22),
+      hashAlgorithm: getUint16(extensibleDataView, 24),
+      hashData: rawExtensibleData.subarray(28, 28 + hashDataLength)
+    });
+  }
+  return directoryEncryptionInfo;
+}
+function readCommonHeader(directory, dataView, offset) {
+  const rawBitFlag = directory.rawBitFlag = getUint16(dataView, offset + 2);
+  const encrypted = (rawBitFlag & BITFLAG_ENCRYPTED) == BITFLAG_ENCRYPTED;
+  const rawLastModDate = getUint32(dataView, offset + 6);
+  Object.assign(directory, {
+    encrypted,
+    version: getUint16(dataView, offset),
+    bitFlag: {
+      level: (rawBitFlag & BITFLAG_LEVEL) >> 1,
+      dataDescriptor: (rawBitFlag & BITFLAG_DATA_DESCRIPTOR) == BITFLAG_DATA_DESCRIPTOR,
+      languageEncodingFlag: (rawBitFlag & BITFLAG_LANG_ENCODING_FLAG) == BITFLAG_LANG_ENCODING_FLAG
+    },
+    rawLastModDate,
+    lastModDate: getDate(rawLastModDate),
+    filenameLength: getUint16(dataView, offset + 22),
+    extraFieldLength: getUint16(dataView, offset + 24)
+  });
+}
+function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory) {
+  const { rawExtraField } = directory;
+  const extraField = directory.extraField = new Map;
+  const rawExtraFieldView = getDataView(rawExtraField);
+  let offsetExtraField = 0;
+  let malformedExtraField = false;
+  try {
+    while (offsetExtraField < rawExtraField.length) {
+      const type = getUint16(rawExtraFieldView, offsetExtraField);
+      const size = getUint16(rawExtraFieldView, offsetExtraField + 2);
+      extraField.set(type, {
+        type,
+        data: rawExtraField.slice(offsetExtraField + 4, offsetExtraField + 4 + size)
+      });
+      offsetExtraField += 4 + size;
+    }
+  } catch {
+    malformedExtraField = true;
+  }
+  if (offsetExtraField > rawExtraField.length) {
+    malformedExtraField = true;
+  }
+  const compressionMethod = getUint16(dataView, offset + 4);
+  Object.assign(directory, {
+    signature: getUint32(dataView, offset + HEADER_OFFSET_SIGNATURE),
+    crc32: getUint32(dataView, offset + HEADER_OFFSET_SIGNATURE),
+    compressedSize: getUint32(dataView, offset + HEADER_OFFSET_COMPRESSED_SIZE),
+    uncompressedSize: getUint32(dataView, offset + HEADER_OFFSET_UNCOMPRESSED_SIZE)
+  });
+  const extraFieldZip64 = extraField.get(EXTRAFIELD_TYPE_ZIP64);
+  let extraFieldZip64Missing;
+  if (extraFieldZip64) {
+    if (!readExtraFieldZip64(extraFieldZip64, directory, localDirectory)) {
+      malformedExtraField = true;
+    }
+    directory.extraFieldZip64 = extraFieldZip64;
+  } else if (ZIP64_PROPERTIES.some(([propertyName, max]) => directory[propertyName] == max)) {
+    if (localDirectory) {
+      malformedExtraField = true;
+    } else {
+      extraFieldZip64Missing = true;
+    }
+  }
+  const extraFieldUnicodePath = extraField.get(EXTRAFIELD_TYPE_UNICODE_PATH);
+  if (extraFieldUnicodePath) {
+    readExtraFieldUnicode(extraFieldUnicodePath, PROPERTY_NAME_FILENAME, PROPERTY_NAME_RAW_FILENAME, directory, fileEntry);
+    directory.extraFieldUnicodePath = extraFieldUnicodePath;
+  }
+  const extraFieldUnicodeComment = extraField.get(EXTRAFIELD_TYPE_UNICODE_COMMENT);
+  if (extraFieldUnicodeComment) {
+    readExtraFieldUnicode(extraFieldUnicodeComment, PROPERTY_NAME_COMMENT, PROPERTY_NAME_RAW_COMMENT, directory, fileEntry);
+    directory.extraFieldUnicodeComment = extraFieldUnicodeComment;
+  }
+  const extraFieldAES = extraField.get(EXTRAFIELD_TYPE_AES);
+  if (extraFieldAES && (compressionMethod == COMPRESSION_METHOD_AES || directory.encrypted) && extraFieldAES.data.length >= 7) {
+    readExtraFieldAES(extraFieldAES, directory, compressionMethod);
+    directory.extraFieldAES = extraFieldAES;
+  } else {
+    if (extraFieldAES) {
+      malformedExtraField = true;
+    }
+    directory.compressionMethod = compressionMethod;
+  }
+  const extraFieldPkwareUnix = extraField.get(EXTRAFIELD_TYPE_PKWARE_UNIX);
+  if (extraFieldPkwareUnix) {
+    readExtraFieldUnixDates(extraFieldPkwareUnix, directory);
+    directory.extraFieldPkwareUnix = extraFieldPkwareUnix;
+  }
+  const extraFieldUnixType1 = extraField.get(EXTRAFIELD_TYPE_UNIX_TYPE1);
+  if (extraFieldUnixType1) {
+    readExtraFieldUnixDates(extraFieldUnixType1, directory);
+    directory.extraFieldUnixType1 = extraFieldUnixType1;
+  }
+  const extraFieldExtendedTimestamp = extraField.get(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
+  if (extraFieldExtendedTimestamp) {
+    readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory, localDirectory);
+    directory.extraFieldExtendedTimestamp = extraFieldExtendedTimestamp;
+  }
+  const extraFieldNTFS = extraField.get(EXTRAFIELD_TYPE_NTFS);
+  if (extraFieldNTFS) {
+    readExtraFieldNTFS(extraFieldNTFS, directory);
+    directory.extraFieldNTFS = extraFieldNTFS;
+  }
+  const extraFieldInfoZip = extraField.get(EXTRAFIELD_TYPE_INFOZIP);
+  let unixIdsRead;
+  if (extraFieldInfoZip) {
+    unixIdsRead = readExtraFieldUnix(extraFieldInfoZip, directory, true);
+    directory.extraFieldInfoZip = extraFieldInfoZip;
+  }
+  const extraFieldUnix = extraField.get(EXTRAFIELD_TYPE_UNIX);
+  if (extraFieldUnix) {
+    readExtraFieldUnix(extraFieldUnix, unixIdsRead ? {} : directory, false);
+    directory.extraFieldUnix = extraFieldUnix;
+  }
+  const extraFieldUSDZ = extraField.get(EXTRAFIELD_TYPE_USDZ);
+  if (extraFieldUSDZ) {
+    directory.extraFieldUSDZ = extraFieldUSDZ;
+  }
+  if (extraFieldZip64Missing) {
+    throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND2);
+  }
+  return malformedExtraField;
+}
+function readExtraFieldZip64(extraFieldZip64, directory, localDirectory) {
+  directory.zip64 = true;
+  const extraFieldView = getDataView(extraFieldZip64.data);
+  const missingProperties = ZIP64_PROPERTIES.filter(([propertyName, max]) => directory[propertyName] == max);
+  const requiredLength = missingProperties.reduce((length, [, max]) => length + ZIP64_EXTRACTION[max].bytes, 0);
+  if (extraFieldZip64.data.length < requiredLength) {
+    if (localDirectory) {
+      return false;
+    }
+    throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND2);
+  }
+  const values = [];
+  try {
+    for (let indexMissingProperty = 0, offset = 0;indexMissingProperty < missingProperties.length; indexMissingProperty++) {
+      const [, max] = missingProperties[indexMissingProperty];
+      const extraction = ZIP64_EXTRACTION[max];
+      values.push(extraction.getValue(extraFieldView, offset));
+      offset += extraction.bytes;
+    }
+  } catch (error) {
+    if (localDirectory) {
+      return false;
+    }
+    throw error;
+  }
+  missingProperties.forEach(([propertyName], indexMissingProperty) => {
+    directory[propertyName] = extraFieldZip64[propertyName] = values[indexMissingProperty];
+  });
+  return true;
+}
+function readExtraFieldUnicode(extraFieldUnicode, propertyName, rawPropertyName, directory, fileEntry) {
+  if (extraFieldUnicode.data.length < 5) {
+    extraFieldUnicode.valid = false;
+    return;
+  }
+  const extraFieldView = getDataView(extraFieldUnicode.data);
+  const computedCrc32 = new Crc32;
+  computedCrc32.append(fileEntry[rawPropertyName]);
+  const computedCrc32View = getDataView(new Uint8Array(4));
+  computedCrc32View.setUint32(0, computedCrc32.get(), true);
+  const nameCrc32 = getUint32(extraFieldView, 1);
+  const version = getUint8(extraFieldView, 0);
+  Object.assign(extraFieldUnicode, {
+    version,
+    [propertyName]: decodeText(extraFieldUnicode.data.subarray(5)),
+    valid: version == 1 && !fileEntry.bitFlag.languageEncodingFlag && nameCrc32 == getUint32(computedCrc32View, 0)
+  });
+  if (extraFieldUnicode.valid) {
+    directory[propertyName] = extraFieldUnicode[propertyName];
+    directory[propertyName + PROPERTY_NAME_UTF8_SUFFIX] = true;
+  }
+}
+function readExtraFieldAES(extraFieldAES, directory, compressionMethod) {
+  const extraFieldView = getDataView(extraFieldAES.data);
+  const strength = getUint8(extraFieldView, 4);
+  Object.assign(extraFieldAES, {
+    vendorVersion: getUint8(extraFieldView, 0),
+    vendorId: getUint8(extraFieldView, 2),
+    strength,
+    originalCompressionMethod: compressionMethod,
+    compressionMethod: getUint16(extraFieldView, 5)
+  });
+  directory.compressionMethod = extraFieldAES.compressionMethod;
+  if (extraFieldAES.vendorVersion != VENDOR_VERSION_AE_1) {
+    directory.crc32 = UNDEFINED_VALUE;
+  }
+}
+function readExtraFieldNTFS(extraFieldNTFS, directory) {
+  const extraFieldView = getDataView(extraFieldNTFS.data);
+  let offsetExtraField = 4;
+  let tag1Data;
+  try {
+    while (offsetExtraField < extraFieldNTFS.data.length && !tag1Data) {
+      const tagValue = getUint16(extraFieldView, offsetExtraField);
+      const attributeSize = getUint16(extraFieldView, offsetExtraField + 2);
+      if (tagValue == EXTRAFIELD_TYPE_NTFS_TAG1) {
+        tag1Data = extraFieldNTFS.data.slice(offsetExtraField + 4, offsetExtraField + 4 + attributeSize);
+      }
+      offsetExtraField += 4 + attributeSize;
+    }
+  } catch {}
+  if (tag1Data && tag1Data.length == 24) {
+    const tag1View = getDataView(tag1Data);
+    const rawLastModDate = tag1View.getBigUint64(0, true);
+    const rawLastAccessDate = tag1View.getBigUint64(8, true);
+    const rawCreationDate = tag1View.getBigUint64(16, true);
+    Object.assign(extraFieldNTFS, {
+      rawLastModDate,
+      rawLastAccessDate,
+      rawCreationDate
+    });
+    const lastModDate = getDateNTFS(rawLastModDate);
+    const lastAccessDate = getDateNTFS(rawLastAccessDate);
+    const creationDate = getDateNTFS(rawCreationDate);
+    const extraFieldData = { lastModDate, lastAccessDate, creationDate };
+    Object.assign(extraFieldNTFS, extraFieldData);
+    Object.assign(directory, extraFieldData, { rawLastAccessDate, rawCreationDate });
+  }
+}
+function readExtraFieldUnixDates(extraField, directory) {
+  if (extraField.data.length < 8) {
+    return;
+  }
+  const extraFieldView = getDataView(extraField.data);
+  const lastAccessDate = new Date((getUint32(extraFieldView, 0) | 0) * 1000);
+  const lastModDate = new Date((getUint32(extraFieldView, 4) | 0) * 1000);
+  const extraFieldData = { lastAccessDate, lastModDate };
+  if (extraField.data.length >= 12) {
+    extraFieldData.uid = getUint16(extraFieldView, 8);
+    extraFieldData.gid = getUint16(extraFieldView, 10);
+  }
+  Object.assign(extraField, extraFieldData);
+  Object.assign(directory, extraFieldData);
+}
+function readExtraFieldUnix(extraField, directory, isInfoZip) {
+  try {
+    const view = getDataView(extraField.data);
+    let uid, gid;
+    if (isInfoZip) {
+      let offset = 0;
+      const version = getUint8(view, offset++);
+      const uidSize = getUint8(view, offset++);
+      uid = unpackUnixId(extraField.data.subarray(offset, offset + uidSize));
+      offset += uidSize;
+      const gidSize = getUint8(view, offset++);
+      gid = unpackUnixId(extraField.data.subarray(offset, offset + gidSize));
+      Object.assign(extraField, { version, uid, gid });
+    } else if (extraField.data.length >= 4) {
+      uid = getUint16(view, 0);
+      gid = getUint16(view, 2);
+      Object.assign(extraField, { uid, gid });
+    }
+    if (uid !== UNDEFINED_VALUE) {
+      directory.uid = uid;
+    }
+    if (gid !== UNDEFINED_VALUE) {
+      directory.gid = gid;
+    }
+    return uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE;
+  } catch {}
+}
+function unpackUnixId(bytes) {
+  const buffer = new Uint8Array(4);
+  buffer.set(bytes, 0);
+  const view = new DataView(buffer.buffer, buffer.byteOffset, 4);
+  return view.getUint32(0, true);
+}
+function readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory, localDirectory) {
+  if (!extraFieldExtendedTimestamp.data.length) {
+    return;
+  }
+  const extraFieldView = getDataView(extraFieldExtendedTimestamp.data);
+  const flags = getUint8(extraFieldView, 0);
+  const timeProperties = [];
+  const timeRawProperties = [];
+  if (localDirectory) {
+    if ((flags & 1) == 1) {
+      timeProperties.push(PROPERTY_NAME_LAST_MODIFICATION_DATE);
+      timeRawProperties.push(PROPERTY_NAME_RAW_LAST_MODIFICATION_DATE);
+    }
+    if ((flags & 2) == 2) {
+      timeProperties.push(PROPERTY_NAME_LAST_ACCESS_DATE);
+      timeRawProperties.push(PROPERTY_NAME_RAW_LAST_ACCESS_DATE);
+    }
+    if ((flags & 4) == 4) {
+      timeProperties.push(PROPERTY_NAME_CREATION_DATE);
+      timeRawProperties.push(PROPERTY_NAME_RAW_CREATION_DATE);
+    }
+  } else if (extraFieldExtendedTimestamp.data.length >= 5) {
+    timeProperties.push(PROPERTY_NAME_LAST_MODIFICATION_DATE);
+    timeRawProperties.push(PROPERTY_NAME_RAW_LAST_MODIFICATION_DATE);
+  }
+  let offset = 1;
+  timeProperties.forEach((propertyName, indexProperty) => {
+    if (extraFieldExtendedTimestamp.data.length >= offset + 4) {
+      const time = getUint32(extraFieldView, offset);
+      directory[propertyName] = extraFieldExtendedTimestamp[propertyName] = new Date((time | 0) * 1000);
+      const rawPropertyName = timeRawProperties[indexProperty];
+      extraFieldExtendedTimestamp[rawPropertyName] = time;
+    }
+    offset += 4;
+  });
+}
+async function detectOverlappingEntry({
+  reader,
+  fileEntry,
+  index,
+  offset,
+  crc32,
+  compressedSize,
+  uncompressedSize,
+  dataOffset,
+  dataDescriptor,
+  extraFieldZip64,
+  readRanges
+}) {
+  let dataDescriptorLength = 0;
+  if (dataDescriptor) {
+    const zip64 = Boolean(extraFieldZip64);
+    const localDataDescriptor = await readLocalDataDescriptor(reader, dataOffset + compressedSize, { crc32, compressedSize, uncompressedSize, zip64 });
+    if (localDataDescriptor) {
+      fileEntry.localDirectory.dataDescriptor = localDataDescriptor;
+      dataDescriptorLength = getDataDescriptorLength(localDataDescriptor.zip64, localDataDescriptor.signature);
+    } else {
+      dataDescriptorLength = getDataDescriptorLength(zip64, false);
+    }
+  }
+  const range = {
+    start: offset,
+    end: dataOffset + compressedSize + dataDescriptorLength,
+    fileEntry
+  };
+  const { indexes, sortedRanges, pendingRanges } = readRanges;
+  if (!indexes.has(index)) {
+    const overlappingRange = findOverlappingRange(sortedRanges, range) || pendingRanges.find((otherRange) => rangesOverlap(range, otherRange));
+    if (overlappingRange) {
+      const error = new Error(ERR_OVERLAPPING_ENTRY2);
+      error.overlappingEntry = overlappingRange.fileEntry;
+      throw error;
+    }
+    indexes.add(index);
+    pendingRanges.push(range);
+    if (pendingRanges.length * pendingRanges.length > sortedRanges.length) {
+      pendingRanges.sort((range, otherRange) => range.start - otherRange.start);
+      readRanges.sortedRanges = mergeRanges(sortedRanges, pendingRanges);
+      pendingRanges.length = 0;
+    }
+  }
+}
+function findOverlappingRange(sortedRanges, range) {
+  let low = 0;
+  let high = sortedRanges.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (sortedRanges[middle].start < range.start) {
+      low = middle + 1;
+    } else {
+      high = middle;
+    }
+  }
+  const previousRange = sortedRanges[low - 1];
+  const nextRange = sortedRanges[low];
+  if (previousRange && rangesOverlap(range, previousRange)) {
+    return previousRange;
+  }
+  if (nextRange && rangesOverlap(range, nextRange)) {
+    return nextRange;
+  }
+}
+function rangesOverlap(range, otherRange) {
+  return range.start < otherRange.end && otherRange.start < range.end;
+}
+function mergeRanges(sortedRanges, pendingRanges) {
+  const mergedRanges = [];
+  let indexSorted = 0;
+  let indexPending = 0;
+  while (indexSorted < sortedRanges.length || indexPending < pendingRanges.length) {
+    if (indexPending == pendingRanges.length || indexSorted < sortedRanges.length && sortedRanges[indexSorted].start < pendingRanges[indexPending].start) {
+      mergedRanges.push(sortedRanges[indexSorted++]);
+    } else {
+      mergedRanges.push(pendingRanges[indexPending++]);
+    }
+  }
+  return mergedRanges;
+}
+async function readLocalDataDescriptor(reader, offset, { crc32, compressedSize, uncompressedSize, zip64 }) {
+  const maxLength = DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH;
+  const length = Math.min(maxLength, Math.max(0, reader.size - offset));
+  const dataDescriptorArray = length ? await readUint8Array(reader, offset, length) : EMPTY_UINT8_ARRAY;
+  const dataDescriptorView = getDataView(dataDescriptorArray);
+  const candidates = [[zip64, true], [zip64, false], [!zip64, true], [!zip64, false]].map(([zip64Layout, signature]) => readDataDescriptor(dataDescriptorView, zip64Layout, signature)).filter((candidate) => candidate && candidate.compressedSize == compressedSize && candidate.uncompressedSize == uncompressedSize);
+  return candidates.find((candidate) => candidate.crc32 == crc32) || candidates[0] || readDataDescriptor(dataDescriptorView, zip64, true) || readDataDescriptor(dataDescriptorView, zip64, false);
+}
+async function getEntryDataDescriptorLength2(reader, offset, { crc32, compressedSize, uncompressedSize, extraFieldZip64 }) {
+  const dataDescriptor = await readLocalDataDescriptor(reader, offset, { crc32, compressedSize, uncompressedSize, zip64: Boolean(extraFieldZip64) });
+  if (dataDescriptor && dataDescriptor.compressedSize == compressedSize && dataDescriptor.uncompressedSize == uncompressedSize) {
+    return getDataDescriptorLength(dataDescriptor.zip64, dataDescriptor.signature);
+  }
+}
+function readDataDescriptor(dataDescriptorView, zip64, signature) {
+  const offset = signature ? DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH : 0;
+  if (dataDescriptorView.byteLength < getDataDescriptorLength(zip64, signature) || signature && getUint32(dataDescriptorView, 0) != DATA_DESCRIPTOR_RECORD_SIGNATURE) {
+    return UNDEFINED_VALUE;
+  }
+  const crc32 = getUint32(dataDescriptorView, offset);
+  let compressedSize;
+  let uncompressedSize;
+  try {
+    if (zip64) {
+      compressedSize = getBigUint64(dataDescriptorView, offset + 4);
+      uncompressedSize = getBigUint64(dataDescriptorView, offset + 12);
+    } else {
+      compressedSize = getUint32(dataDescriptorView, offset + 4);
+      uncompressedSize = getUint32(dataDescriptorView, offset + 8);
+    }
+  } catch {
+    return UNDEFINED_VALUE;
+  }
+  return { signature, zip64, crc32, compressedSize, uncompressedSize };
+}
+function getDataDescriptorLength(zip64, signature) {
+  return (zip64 ? DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH : DATA_DESCRIPTOR_RECORD_LENGTH) + (signature ? DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH : 0);
+}
+function getDiskOffset(reader, diskNumber) {
+  return reader.getDiskOffset ? reader.getDiskOffset(diskNumber) : 0;
+}
+async function startsWithSplitZipSignature(reader) {
+  return await getFirstSignature(reader) == SPLIT_ZIP_FILE_SIGNATURE;
+}
+async function startsWithSplitZipMarker(reader) {
+  const signature = await getFirstSignature(reader);
+  return signature == SPLIT_ZIP_FILE_SIGNATURE || signature == TEMPORARY_SPLIT_ZIP_FILE_SIGNATURE;
+}
+async function getFirstSignature(reader) {
+  const signatureArray = await readUint8Array(reader, 0, SPLIT_ZIP_FILE_SIGNATURE_LENGTH);
+  return getUint32(getDataView(signatureArray));
+}
+function isStrictnessValue(value) {
+  return value === STRICTNESS_STRICT || value === STRICTNESS_BALANCED || value === STRICTNESS_TOLERANT;
+}
+function getDecodableOutputSize(outputSize, compressedSize, compressed) {
+  return Math.min(outputSize, compressed ? compressedSize * MAX_DEFLATE_EXPANSION_RATIO : compressedSize);
+}
+function getStrictness(options, inheritedOptions) {
+  return resolveStrictness(options, resolveStrictness(inheritedOptions, STRICTNESS_BALANCED));
+}
+function resolveStrictness(options, inheritedStrictness) {
+  const strictness = options[OPTION_STRICTNESS];
+  if (strictness !== UNDEFINED_VALUE) {
+    if (!isStrictnessValue(strictness)) {
+      throw new Error(ERR_INVALID_STRICTNESS2);
+    }
+    return strictness;
+  }
+  const checkAmbiguity = options[OPTION_CHECK_AMBIGUITY];
+  if (checkAmbiguity === UNDEFINED_VALUE) {
+    return inheritedStrictness;
+  }
+  if (checkAmbiguity) {
+    return STRICTNESS_STRICT;
+  }
+  return inheritedStrictness == STRICTNESS_TOLERANT ? STRICTNESS_TOLERANT : STRICTNESS_BALANCED;
+}
+function getCheckLocalDirectory(checkLocalDirectory, strictness) {
+  if (checkLocalDirectory === UNDEFINED_VALUE) {
+    return strictness != STRICTNESS_TOLERANT;
+  }
+  return Boolean(checkLocalDirectory);
+}
+function getCheckLocalFilename(checkLocalFilename, strictness) {
+  if (checkLocalFilename === UNDEFINED_VALUE) {
+    return strictness == STRICTNESS_STRICT;
+  }
+  return Boolean(checkLocalFilename);
+}
+function getFilenameValidation(filenameValidation, strictness) {
+  if (filenameValidation === UNDEFINED_VALUE) {
+    return strictness;
+  }
+  if (!isStrictnessValue(filenameValidation)) {
+    throw new Error(ERR_INVALID_FILENAME_VALIDATION2);
+  }
+  return filenameValidation;
+}
+function isUnsafeFilename(filename, filenameValidation) {
+  if (filenameValidation == STRICTNESS_TOLERANT) {
+    return false;
+  }
+  const pathParts = filename.split("/");
+  if (pathParts.length > 1 && pathParts[pathParts.length - 1] === "") {
+    pathParts.pop();
+  }
+  if (PARENT_DIRECTORY_REGEXP.test(filename) || filename.startsWith("/") || filename.startsWith("\\") || DRIVE_LETTER_REGEXP.test(filename)) {
+    return true;
+  }
+  return filenameValidation == STRICTNESS_STRICT && (pathParts.includes(".") || pathParts.includes("") || filename.includes("\x00"));
+}
+function getMaxAppendedDataSize(maxAppendedDataSize, strictness) {
+  if (maxAppendedDataSize !== UNDEFINED_VALUE) {
+    const size = toNumber(maxAppendedDataSize);
+    if (typeof size != NUMBER_TYPE || Number.isNaN(size) || size < 0) {
+      throw new Error(ERR_INVALID_MAX_APPENDED_DATA_SIZE2);
+    }
+    return size;
+  }
+  if (strictness == STRICTNESS_STRICT) {
+    return 0;
+  }
+  if (strictness == STRICTNESS_TOLERANT) {
+    return Infinity;
+  }
+  return MAX_16_BITS;
+}
+async function findEndOfCentralDirectory(reader, rejectAmbiguous, maxAppendedDataSize) {
+  const { size } = reader;
+  const anchoredLength = Math.min(size, END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS);
+  const remoteProbeBudget = { remaining: MAX_END_OF_CENTRAL_DIR_PROBES };
+  let endOfDirectoryInfo;
+  let plausibleEndOfDirectoryInfo;
+  let endOfDirectoryReachingEndCount = 0;
+  for await (const [anchoredView, anchoredOffset, anchoredArray, indexByte, offset] of scanEndOfCentralDirectory(reader, anchoredLength)) {
+    const commentLength = getUint16(anchoredView, indexByte + 20);
+    if (offset + END_OF_CENTRAL_DIR_LENGTH + commentLength == size) {
+      const reachability = await getCentralDirectoryReachability(reader, anchoredView, anchoredOffset, indexByte, offset, size, remoteProbeBudget);
+      if (reachability == CENTRAL_DIRECTORY_REACHABLE) {
+        if (!endOfDirectoryInfo) {
+          endOfDirectoryInfo = getEndOfCentralDirectoryInfo(anchoredArray, indexByte, offset);
+        }
+        endOfDirectoryReachingEndCount++;
+        if (!rejectAmbiguous || endOfDirectoryReachingEndCount > 1) {
+          break;
+        }
+      } else if (reachability == CENTRAL_DIRECTORY_PLAUSIBLE && !plausibleEndOfDirectoryInfo) {
+        plausibleEndOfDirectoryInfo = getEndOfCentralDirectoryInfo(anchoredArray, indexByte, offset);
+      }
+    }
+  }
+  if (!endOfDirectoryInfo) {
+    endOfDirectoryInfo = plausibleEndOfDirectoryInfo;
+  }
+  if (!endOfDirectoryInfo) {
+    endOfDirectoryInfo = await seekEndOfCentralDirectory(reader, maxAppendedDataSize, remoteProbeBudget);
+  }
+  return { endOfDirectoryInfo, endOfDirectoryReachingEndCount };
+}
+async function seekEndOfCentralDirectory(reader, maxAppendedDataSize, remoteProbeBudget) {
+  const { size } = reader;
+  const searchLength = Math.min(size, maxAppendedDataSize == Infinity ? size : END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS + maxAppendedDataSize);
+  let firstSignatureInfo, plausibleInfo;
+  for await (const [searchView, searchOffset, searchArray, indexByte, offset] of scanEndOfCentralDirectory(reader, searchLength)) {
+    const record = getEndOfCentralDirectoryInfo(searchArray, indexByte, offset);
+    if (!firstSignatureInfo) {
+      firstSignatureInfo = record;
+    }
+    const reachability = await getCentralDirectoryReachability(reader, searchView, searchOffset, indexByte, offset, size, remoteProbeBudget);
+    if (reachability == CENTRAL_DIRECTORY_REACHABLE) {
+      return record;
+    }
+    if (reachability == CENTRAL_DIRECTORY_PLAUSIBLE && !plausibleInfo) {
+      plausibleInfo = record;
+    }
+  }
+  return plausibleInfo || firstSignatureInfo;
+}
+async function* scanEndOfCentralDirectory(reader, scanLength) {
+  const scanOffset = reader.size - scanLength;
+  const scanArray = await readUint8Array(reader, scanOffset, scanLength);
+  const scanView = getDataView(scanArray);
+  for (let indexByte = scanArray.length - END_OF_CENTRAL_DIR_LENGTH;indexByte >= 0; indexByte--) {
+    if (getUint32(scanView, indexByte) == END_OF_CENTRAL_DIR_SIGNATURE) {
+      yield [scanView, scanOffset, scanArray, indexByte, scanOffset + indexByte];
+    }
+  }
+}
+function getEndOfCentralDirectoryInfo(scanArray, indexByte, offset) {
+  return { offset, buffer: new Uint8Array(scanArray.subarray(indexByte, indexByte + END_OF_CENTRAL_DIR_LENGTH)).buffer };
+}
+async function getCentralDirectoryReachability(reader, view, anchoredOffset, indexByte, offset, size, remoteProbeBudget) {
+  const filesLength = getUint16(view, indexByte + 10);
+  const directoryDataLength = getUint32(view, indexByte + 12);
+  const directoryDataOffset = getUint32(view, indexByte + 16);
+  if (filesLength == MAX_16_BITS || directoryDataLength == MAX_32_BITS || directoryDataOffset == MAX_32_BITS) {
+    const locatorSignature = await readSignature(reader, view, anchoredOffset, offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH, size, remoteProbeBudget);
+    return locatorSignature == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE ? CENTRAL_DIRECTORY_REACHABLE : CENTRAL_DIRECTORY_UNREACHABLE;
+  }
+  if (!filesLength && !directoryDataLength) {
+    return CENTRAL_DIRECTORY_PLAUSIBLE;
+  }
+  const directoryDiskNumber = getUint16(view, indexByte + 6);
+  for (const centralDirectoryOffset of [offset - directoryDataLength, getDiskOffset(reader, directoryDiskNumber) + directoryDataOffset]) {
+    if (await readSignature(reader, view, anchoredOffset, centralDirectoryOffset, size, remoteProbeBudget) == CENTRAL_FILE_HEADER_SIGNATURE) {
+      return CENTRAL_DIRECTORY_REACHABLE;
+    }
+  }
+  return CENTRAL_DIRECTORY_UNREACHABLE;
+}
+async function readSignature(reader, view, anchoredOffset, signatureOffset, size, remoteProbeBudget) {
+  if (signatureOffset < 0 || signatureOffset + 4 > size) {
+    return UNDEFINED_VALUE;
+  }
+  if (signatureOffset >= anchoredOffset) {
+    return getUint32(view, signatureOffset - anchoredOffset);
+  }
+  if (remoteProbeBudget.remaining > 0) {
+    remoteProbeBudget.remaining--;
+    const signatureArray = await readUint8Array(reader, signatureOffset, 4);
+    return getUint32(getDataView(signatureArray), 0);
+  }
+  return UNDEFINED_VALUE;
+}
+function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename, warnings) {
+  const { rawFilename } = zipEntry;
+  const reject = !warnings;
+  const maskedLocalDirectory = zipEntry.decryptedDirectory && (localDirectory.rawBitFlag & BITFLAG_MASKED_LOCAL_HEADERS) == BITFLAG_MASKED_LOCAL_HEADERS;
+  if (checkLocalFilename && !maskedLocalDirectory && (rawLocalFilename.length != rawFilename.length || rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte]))) {
+    reportAmbiguity(reject, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME2);
+  }
+  if ((localDirectory.rawBitFlag & BITFLAG_AMBIGUITY_MASK) != (zipEntry.rawBitFlag & BITFLAG_AMBIGUITY_MASK)) {
+    reportAmbiguity(reject, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG2);
+  }
+  if (localDirectory.compressionMethod != zipEntry.compressionMethod) {
+    reportAmbiguity(reject, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD2);
+  }
+  if (!localDirectory.bitFlag.dataDescriptor && !maskedLocalDirectory && (localDirectory.crc32 || localDirectory.compressedSize || localDirectory.uncompressedSize) && (localDirectory.crc32 != zipEntry.crc32 || localDirectory.compressedSize != zipEntry.compressedSize || localDirectory.uncompressedSize != zipEntry.uncompressedSize)) {
+    reportAmbiguity(reject, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES2);
+  }
+}
+function validateDataDescriptor(zipEntry, localDirectory, warnings) {
+  const { dataDescriptor } = localDirectory;
+  const maskedLocalDirectory = zipEntry.decryptedDirectory && (localDirectory.rawBitFlag & BITFLAG_MASKED_LOCAL_HEADERS) == BITFLAG_MASKED_LOCAL_HEADERS;
+  if (dataDescriptor && !maskedLocalDirectory && (zipEntry.crc32 !== UNDEFINED_VALUE && dataDescriptor.crc32 != zipEntry.crc32 || dataDescriptor.compressedSize != zipEntry.compressedSize || dataDescriptor.uncompressedSize != zipEntry.uncompressedSize)) {
+    reportAmbiguity(!warnings, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES2);
+  }
+}
+function reportAmbiguity(reject, warnings, reason) {
+  if (reject) {
+    throwAmbiguousArchive(reason);
+  } else {
+    addWarning(warnings, reason);
+  }
+}
+function throwAmbiguousArchive(reason) {
+  const error = new Error(ERR_AMBIGUOUS_ARCHIVE2);
+  error.reason = reason;
+  throw error;
+}
+function getOptionValue(zipReader, options, name) {
+  return options[name] === UNDEFINED_VALUE ? zipReader.options[name] : options[name];
+}
+function getFunctionOptionValue(zipReader, options, name) {
+  return checkFunctionOption(getOptionValue(zipReader, options, name));
+}
+function getDate(timeRaw) {
+  const date = (timeRaw & 4294901760) >> 16, time = timeRaw & MAX_16_BITS;
+  const result = new Date(1980 + ((date & 65024) >> 9), ((date & 480) >> 5) - 1, date & 31, (time & 63488) >> 11, (time & 2016) >> 5, (time & 31) * 2, 0);
+  return result < MIN_DATE ? MIN_DATE : result;
+}
+function getDateNTFS(timeRaw) {
+  return new Date(Number(timeRaw / BigInt(1e4) - BigInt(11644473600000)));
+}
+function getUint8(view, offset) {
+  return view.getUint8(offset);
+}
+function getUint16(view, offset) {
+  return view.getUint16(offset, true);
+}
+function getUint32(view, offset) {
+  return view.getUint32(offset, true);
+}
+function getBigUint64(view, offset) {
+  const value = view.getBigUint64(offset, true);
+  if (value > MAX_SAFE_UINT64) {
+    throw new Error(ERR_UNSUPPORTED_UINT642);
+  }
+  return Number(value);
+}
+
+export { UNDEFINED_VALUE, ERR_LOCAL_FILE_HEADER_NOT_FOUND2, ERR_OVERLAPPING_ENTRY2, ERR_EXTRAFIELD_ZIP64_NOT_FOUND2, FUNCTION_TYPE, setDefaultConfiguration, toExactUint8Array, isErrorObject, createEngine, ERR_INVALID_PASSWORD2, ERR_INVALID_AUTHENTICATION_CODE2, setAESEngine, ERR_UNSUPPORTED_COMPRESSION2, ERR_INVALID_UNCOMPRESSED_SIZE2, ERR_INVALID_COMPRESSED_DATA2, ERR_CODEC_OUT_OF_MEMORY2, ERR_INVALID_CRC322, MESSAGE_EVENT_TYPE, MESSAGE_START, MESSAGE_PULL, MESSAGE_DATA, MESSAGE_ACK_DATA, MESSAGE_CLOSE, ERR_WORKER_STARTUP_TIMEOUT2, configureWorker, setWebWorkerBackend, disableWebWorker, createWorkerInterface, runWorker, Uint8ArrayReader, Uint8ArrayWriter, ERR_BAD_FORMAT2, ERR_EOCDR_NOT_FOUND2, ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND2, ERR_CENTRAL_DIRECTORY_NOT_FOUND2, ERR_ENCRYPTED2, ERR_UNSUPPORTED_ENCRYPTION2, ERR_SPLIT_ZIP_FILE2, ERR_ENTRY_DATA_OUT_OF_BOUNDS2, ERR_AMBIGUOUS_ARCHIVE2, ERR_ENCRYPTED_CENTRAL_DIRECTORY2, ERR_UNSAFE_FILENAME2, ERR_INVALID_STRICTNESS2, ERR_INVALID_FILENAME_VALIDATION2, ERR_INVALID_MAX_APPENDED_DATA_SIZE2, ERR_UNSUPPORTED_UINT642, WARNING_UNSORTED_CENTRAL_DIRECTORY2, WARNING_UNKNOWN_VERSION2, WARNING_COMPRESSED_PATCHED_DATA2, WARNING_MALFORMED_EXTRA_FIELD2, WARNING_UNKNOWN_ZIP64_EXTENSIBLE_DATA2, WARNING_WRAPPED_ENTRIES_COUNT2, WARNING_APPENDED_DATA2, WARNING_PREPENDED_DATA2, WARNING_PREPENDED_CENTRAL_DIRECTORY2, WARNING_TRAILING_CENTRAL_DIRECTORY_DATA2, WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET2, WARNING_MISSING_ZIP64_EXTRA_FIELD2, WARNING_DUPLICATE_FILENAME2, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY2, WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY2, WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME2, WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG2, WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD2, WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES2, ZipReader2, ZipReaderStream2, isZipFile2, getEntryDataDescriptorLength2 };