@cesium/engine 26.2.0 → 26.3.1-wasm.0

package/Build/ThirdParty/Workers/zip-web-worker.js

@@ -1,746 +1,853 @@
 !(function() {
   "use strict";
-  const { Array: t, Object: e, Number: n, Math: s, Error: r, Uint8Array: o, Uint16Array: i, Uint32Array: a, Int32Array: c, Map: l, DataView: f, Promise: w, TextEncoder: u, crypto: h, postMessage: p, TransformStream: d, ReadableStream: y, WritableStream: m, CompressionStream: g, DecompressionStream: S } = self, b = void 0, k = "undefined", v = "function", z = new o(), C = [[], [], [], [], [], [], [], []];
-  for (let t2 = 0; 256 > t2; t2++) {
-    let e2 = t2;
-    for (let t3 = 0; 8 > t3; t3++) e2 = 1 & e2 ? e2 >>> 1 ^ 3988292384 : e2 >>> 1;
-    C[0][t2] = e2;
-  }
-  for (let t2 = 0; 256 > t2; t2++) for (let e2 = 1; 8 > e2; e2++) {
-    const n2 = C[e2 - 1][t2];
-    C[e2][t2] = n2 >>> 8 ^ C[0][255 & n2];
-  }
-  const [I, A, x, P, R, U, W, D] = C;
-  class M {
+  const { Array: t, Object: n, Number: e, Math: o, Error: r, Uint8Array: s, Uint16Array: c, Uint32Array: i, Int32Array: a, Map: f, DataView: u, Promise: w, TextEncoder: l, crypto: h, postMessage: p, TransformStream: d, ReadableStream: y, WritableStream: m, CompressionStream: S, DecompressionStream: g } = self, v = void 0, z = "undefined", b = "function", k = new s(), C = [[], [], [], [], [], [], [], []];
+  for (let t2 = 0; t2 < 256; t2++) {
+    let n2 = t2;
+    for (let t3 = 0; t3 < 8; t3++) n2 = 1 & n2 ? n2 >>> 1 ^ 3988292384 : n2 >>> 1;
+    C[0][t2] = n2;
+  }
+  for (let t2 = 0; t2 < 256; t2++) for (let n2 = 1; n2 < 8; n2++) {
+    const e2 = C[n2 - 1][t2];
+    C[n2][t2] = e2 >>> 8 ^ C[0][255 & e2];
+  }
+  const [I, A, x, M, P, D, F, E] = C;
+  class R {
     constructor(t2) {
-      this.t = t2 || -1;
+      this.o = t2 || -1;
     }
     append(t2) {
-      let e2 = 0 | this.t;
-      const n2 = 0 | t2.length;
-      let s2 = 0;
-      if (n2 >= 8 && t2.buffer) {
-        const r2 = new f(t2.buffer, t2.byteOffset, n2), o2 = n2 - 8;
-        for (; o2 >= s2; s2 += 8) {
-          const t3 = e2 ^ r2.getInt32(s2, true), n3 = r2.getInt32(s2 + 4, true);
-          e2 = D[255 & t3] ^ W[t3 >>> 8 & 255] ^ U[t3 >>> 16 & 255] ^ R[t3 >>> 24 & 255] ^ P[255 & n3] ^ x[n3 >>> 8 & 255] ^ A[n3 >>> 16 & 255] ^ I[n3 >>> 24 & 255];
+      let n2 = 0 | this.o;
+      const e2 = 0 | t2.length;
+      let o2 = 0;
+      if (e2 >= 8 && t2.buffer) {
+        const r2 = new u(t2.buffer, t2.byteOffset, e2), s2 = e2 - 8;
+        for (; o2 <= s2; o2 += 8) {
+          const t3 = n2 ^ r2.getInt32(o2, true), e3 = r2.getInt32(o2 + 4, true);
+          n2 = E[255 & t3] ^ F[t3 >>> 8 & 255] ^ D[t3 >>> 16 & 255] ^ P[t3 >>> 24 & 255] ^ M[255 & e3] ^ x[e3 >>> 8 & 255] ^ A[e3 >>> 16 & 255] ^ I[e3 >>> 24 & 255];
         }
       }
-      for (; n2 > s2; s2++) e2 = e2 >>> 8 ^ I[255 & (e2 ^ t2[s2])];
-      this.t = e2;
+      for (; o2 < e2; o2++) n2 = n2 >>> 8 ^ I[255 & (n2 ^ t2[o2])];
+      this.o = n2;
     }
     get() {
-      return ~this.t;
+      return ~this.o;
     }
   }
-  class _ extends d {
+  class U extends d {
     constructor() {
       let t2;
-      const e2 = new M();
-      super({ transform(t3, n2) {
-        e2.append(t3), n2.enqueue(t3);
+      const n2 = new R();
+      super({ transform(t3, e2) {
+        n2.append(t3), e2.enqueue(t3);
       }, flush() {
-        const n2 = new o(4);
-        new f(n2.buffer).setUint32(0, e2.get()), t2.value = n2;
+        const e2 = new s(4);
+        new u(e2.buffer).setUint32(0, n2.get()), t2.value = e2;
       } }), t2 = this;
     }
   }
-  const B = { concat(t2, e2) {
-    if (0 === t2.length || 0 === e2.length) return t2.concat(e2);
-    const n2 = t2[t2.length - 1], s2 = B.o(n2);
-    return 32 === s2 ? t2.concat(e2) : B.i(e2, s2, 0 | n2, t2.slice(0, t2.length - 1));
-  }, l(t2) {
-    const e2 = t2.length;
-    if (0 === e2) return 0;
-    const n2 = t2[e2 - 1];
-    return 32 * (e2 - 1) + B.o(n2);
-  }, u(t2, e2) {
-    if (32 * t2.length < e2) return t2;
-    const n2 = (t2 = t2.slice(0, s.ceil(e2 / 32))).length;
-    return e2 &= 31, n2 > 0 && e2 && (t2[n2 - 1] = B.h(e2, t2[n2 - 1] & 2147483648 >> e2 - 1, 1)), t2;
-  }, h: (t2, e2, n2) => 32 === t2 ? e2 : (n2 ? 0 | e2 : e2 << 32 - t2) + 1099511627776 * t2, o: (t2) => s.round(t2 / 1099511627776) || 32, i(t2, e2, n2, s2) {
-    for (void 0 === s2 && (s2 = []); e2 >= 32; e2 -= 32) s2.push(n2), n2 = 0;
-    if (0 === e2) return s2.concat(t2);
-    for (let r3 = 0; r3 < t2.length; r3++) s2.push(n2 | t2[r3] >>> e2), n2 = t2[r3] << 32 - e2;
-    const r2 = t2.length ? t2[t2.length - 1] : 0, o2 = B.o(r2);
-    return s2.push(B.h(e2 + o2 & 31, e2 + o2 > 32 ? n2 : s2.pop(), 1)), s2;
-  } }, T = { bytes: { p(t2) {
-    const e2 = B.l(t2) / 8, n2 = new o(e2);
-    let s2;
-    for (let r2 = 0; e2 > r2; r2++) 3 & r2 || (s2 = t2[r2 / 4]), n2[r2] = s2 >>> 24, s2 <<= 8;
-    return n2;
-  }, m(t2) {
-    const e2 = [];
-    let n2, s2 = 0;
-    for (n2 = 0; n2 < t2.length; n2++) s2 = s2 << 8 | t2[n2], 3 & ~n2 || (e2.push(s2), s2 = 0);
-    return 3 & n2 && e2.push(B.h(8 * (3 & n2), s2)), e2;
-  } } }, V = class {
-    constructor(t2) {
-      const e2 = this;
-      e2.blockSize = 512, e2.S = [1732584193, 4023233417, 2562383102, 271733878, 3285377520], e2.k = [1518500249, 1859775393, 2400959708, 3395469782], t2 ? (e2.v = t2.v.slice(0), e2.C = t2.C.slice(0), e2.I = t2.I) : e2.reset();
-    }
-    reset() {
-      const t2 = this;
-      return t2.v = t2.S.slice(0), t2.C = [], t2.I = 0, t2;
-    }
-    update(t2) {
-      const e2 = this;
-      "string" == typeof t2 && (t2 = T.A.m(t2));
-      const n2 = e2.C = B.concat(e2.C, t2), s2 = e2.I, o2 = e2.I = s2 + B.l(t2);
-      if (o2 > 9007199254740991) throw new r("Cannot hash more than 2^53 - 1 bits");
-      const i2 = new a(n2);
-      let c2 = 0;
-      for (let t3 = e2.blockSize + s2 - (e2.blockSize + s2 & e2.blockSize - 1); o2 >= t3; t3 += e2.blockSize) e2.P(i2.subarray(16 * c2, 16 * (c2 + 1))), c2 += 1;
-      return n2.splice(0, 16 * c2), e2;
-    }
-    R() {
-      const t2 = this;
-      let e2 = t2.C;
-      const n2 = t2.v;
-      e2 = B.concat(e2, [B.h(1, 1)]);
-      for (let t3 = e2.length + 2; 15 & t3; t3++) e2.push(0);
-      for (e2.push(s.floor(t2.I / 4294967296)), e2.push(0 | t2.I); e2.length; ) t2.P(e2.splice(0, 16));
-      return t2.reset(), n2;
-    }
-    U(t2, e2, n2, s2) {
-      return t2 > 19 ? t2 > 39 ? t2 > 59 ? t2 > 79 ? void 0 : e2 ^ n2 ^ s2 : e2 & n2 | e2 & s2 | n2 & s2 : e2 ^ n2 ^ s2 : e2 & n2 | ~e2 & s2;
-    }
-    W(t2, e2) {
-      return e2 << t2 | e2 >>> 32 - t2;
-    }
-    P(e2) {
-      const n2 = this, r2 = n2.v, o2 = t(80);
-      for (let t2 = 0; 16 > t2; t2++) o2[t2] = e2[t2];
-      let i2 = r2[0], a2 = r2[1], c2 = r2[2], l2 = r2[3], f2 = r2[4];
-      for (let t2 = 0; 79 >= t2; t2++) {
-        16 > t2 || (o2[t2] = n2.W(1, o2[t2 - 3] ^ o2[t2 - 8] ^ o2[t2 - 14] ^ o2[t2 - 16]));
-        const e3 = n2.W(5, i2) + n2.U(t2, a2, c2, l2) + f2 + o2[t2] + n2.k[s.floor(t2 / 20)] | 0;
-        f2 = l2, l2 = c2, c2 = n2.W(30, a2), a2 = i2, i2 = e3;
-      }
-      r2[0] = r2[0] + i2 | 0, r2[1] = r2[1] + a2 | 0, r2[2] = r2[2] + c2 | 0, r2[3] = r2[3] + l2 | 0, r2[4] = r2[4] + f2 | 0;
-    }
-  }, K = { importKey: (t2) => new K.D(T.bytes.m(t2)), M(t2, e2, n2, s2) {
-    if (n2 = n2 || 1e4, 0 > s2 || 0 > n2) throw new r("invalid params to pbkdf2");
-    const o2 = 1 + (s2 >> 5) << 2;
-    let i2, a2, c2, l2, w2;
-    const u2 = new ArrayBuffer(o2), h2 = new f(u2);
-    let p2 = 0;
-    const d2 = B;
-    for (e2 = T.bytes.m(e2), w2 = 1; (o2 || 1) > p2; w2++) {
-      for (i2 = a2 = t2.encrypt(d2.concat(e2, [w2])), c2 = 1; n2 > c2; c2++) for (a2 = t2.encrypt(a2), l2 = 0; l2 < a2.length; l2++) i2[l2] ^= a2[l2];
-      for (c2 = 0; (o2 || 1) > p2 && c2 < i2.length; c2++) h2.setInt32(p2, i2[c2]), p2 += 4;
-    }
-    return u2.slice(0, s2 / 8);
-  }, D: class {
-    constructor(t2) {
-      const e2 = this, n2 = e2._ = V, s2 = [[], []];
-      e2.B = [new n2(), new n2()];
-      const r2 = e2.B[0].blockSize / 32;
-      t2.length > r2 && (t2 = new n2().update(t2).R());
-      for (let e3 = 0; r2 > e3; e3++) s2[0][e3] = 909522486 ^ t2[e3], s2[1][e3] = 1549556828 ^ t2[e3];
-      e2.B[0].update(s2[0]), e2.B[1].update(s2[1]), e2.T = new n2(e2.B[0]);
-    }
-    reset() {
-      const t2 = this;
-      t2.T = new t2._(t2.B[0]), t2.V = false;
-    }
-    update(t2) {
-      this.V = true, this.T.update(t2);
-    }
-    digest() {
-      const t2 = this, e2 = t2.T.R(), n2 = new t2._(t2.B[1]).update(e2).R();
-      return t2.reset(), n2;
-    }
-    encrypt(t2) {
-      if (this.V) throw new r("encrypt on already updated hmac called!");
-      return this.update(t2), this.digest(t2);
-    }
-  } }, j = typeof h != k && typeof h.getRandomValues == v, E = "Invalid password", L = "Invalid signature", O = "zipjs-abort-check-password";
-  function H(t2) {
-    if (j) return h.getRandomValues(t2);
-    throw new r("Crypto API not supported");
-  }
-  const Z = 16, F = { name: "PBKDF2" }, N = e.assign({ hash: { name: "HMAC" } }, F), q = e.assign({ iterations: 1e3, hash: { name: "SHA-1" } }, F), G = ["deriveBits"], J = [8, 12, 16], Q = [16, 24, 32], X = 10, Y = [0, 0, 0, 0], $ = typeof h != k, tt = $ && h.subtle, et = $ && typeof tt != k, nt = T.bytes, st = class {
-    constructor(t2) {
-      const e2 = this;
-      e2.K = [[[], [], [], [], []], [[], [], [], [], []]], e2.K[0][0][0] || e2.j();
-      const n2 = e2.K[0][4], s2 = e2.K[1], o2 = t2.length;
-      let i2, a2, c2, l2 = 1;
-      if (4 !== o2 && 6 !== o2 && 8 !== o2) throw new r("invalid aes key size");
-      for (e2.k = [a2 = t2.slice(0), c2 = []], i2 = o2; 4 * o2 + 28 > i2; i2++) {
-        let t3 = a2[i2 - 1];
-        (i2 % o2 === 0 || 8 === o2 && i2 % o2 === 4) && (t3 = n2[t3 >>> 24] << 24 ^ n2[t3 >> 16 & 255] << 16 ^ n2[t3 >> 8 & 255] << 8 ^ n2[255 & t3], i2 % o2 === 0 && (t3 = t3 << 8 ^ t3 >>> 24 ^ l2 << 24, l2 = l2 << 1 ^ 283 * (l2 >> 7))), a2[i2] = a2[i2 - o2] ^ t3;
-      }
-      for (let t3 = 0; i2; t3++, i2--) {
-        const e3 = a2[3 & t3 ? i2 : i2 - 4];
-        c2[t3] = 4 >= i2 || 4 > t3 ? e3 : s2[0][n2[e3 >>> 24]] ^ s2[1][n2[e3 >> 16 & 255]] ^ s2[2][n2[e3 >> 8 & 255]] ^ s2[3][n2[255 & e3]];
+  function B(t2, n2) {
+    const e2 = new s(t2.length + n2.length);
+    return e2.set(t2), e2.set(n2, t2.length), e2;
+  }
+  function T(t2) {
+    return new u(t2.buffer, t2.byteOffset, t2.byteLength);
+  }
+  const V = 64, W = 20, j = new s([128]), K = new s(1), O = new a([1732584193, 4023233417, 2562383102, 271733878, 3285377520]), H = new s(256), L = new a(256), N = new a(256), q = new a(256), G = new a(256);
+  let J = false;
+  function Q(t2, n2) {
+    !(function() {
+      if (!J) {
+        let t3 = 1, n3 = 1;
+        do {
+          t3 = 255 & (t3 ^ t3 << 1 ^ (128 & t3 ? 27 : 0)), n3 = 255 & (n3 ^ n3 << 1), n3 = 255 & (n3 ^ n3 << 2), n3 = 255 & (n3 ^ n3 << 4), 128 & n3 && (n3 ^= 9), H[t3] = 255 & (n3 ^ (n3 << 1 | n3 >> 7) ^ (n3 << 2 | n3 >> 6) ^ (n3 << 3 | n3 >> 5) ^ (n3 << 4 | n3 >> 4) ^ 99);
+        } while (1 != t3);
+        H[0] = 99;
+        for (let t4 = 0; t4 < 256; t4++) {
+          const n4 = H[t4], e3 = $(n4), o3 = e3 << 24 | n4 << 16 | n4 << 8 | e3 ^ n4;
+          L[t4] = o3, N[t4] = o3 >>> 8 | o3 << 24, q[t4] = o3 >>> 16 | o3 << 16, G[t4] = o3 >>> 24 | o3 << 8;
+        }
+        J = true;
       }
-    }
-    encrypt(t2) {
-      return this.L(t2, 0);
-    }
-    decrypt(t2) {
-      return this.L(t2, 1);
-    }
-    j() {
-      const t2 = this.K[0], e2 = this.K[1], n2 = t2[4], s2 = e2[4], r2 = [], o2 = [];
-      let i2, a2, c2, l2;
-      for (let t3 = 0; 256 > t3; t3++) o2[(r2[t3] = t3 << 1 ^ 283 * (t3 >> 7)) ^ t3] = t3;
-      for (let f2 = i2 = 0; !n2[f2]; f2 ^= a2 || 1, i2 = o2[i2] || 1) {
-        let o3 = i2 ^ i2 << 1 ^ i2 << 2 ^ i2 << 3 ^ i2 << 4;
-        o3 = o3 >> 8 ^ 255 & o3 ^ 99, n2[f2] = o3, s2[o3] = f2, l2 = r2[c2 = r2[a2 = r2[f2]]];
-        let w2 = 16843009 * l2 ^ 65537 * c2 ^ 257 * a2 ^ 16843008 * f2, u2 = 257 * r2[o3] ^ 16843008 * o3;
-        for (let n3 = 0; 4 > n3; n3++) t2[n3][f2] = u2 = u2 << 24 ^ u2 >>> 8, e2[n3][o3] = w2 = w2 << 24 ^ w2 >>> 8;
+    })();
+    const e2 = new a(60), o2 = (function(t3, n3) {
+      const e3 = t3.length >> 2, o3 = e3 + 6, r3 = 4 * (o3 + 1);
+      let s3 = 1;
+      for (let o4 = 0; o4 < e3; o4++) n3[o4] = t3[4 * o4] << 24 | t3[4 * o4 + 1] << 16 | t3[4 * o4 + 2] << 8 | t3[4 * o4 + 3];
+      for (let t4 = e3; t4 < r3; t4++) {
+        let o4 = n3[t4 - 1];
+        t4 % e3 == 0 ? (o4 = Y(o4 << 8 | o4 >>> 24) ^ s3 << 24, s3 = $(s3)) : e3 > 6 && t4 % e3 == 4 && (o4 = Y(o4)), n3[t4] = n3[t4 - e3] ^ o4;
       }
-      for (let n3 = 0; 5 > n3; n3++) t2[n3] = t2[n3].slice(0), e2[n3] = e2[n3].slice(0);
-    }
-    L(t2, e2) {
-      if (4 !== t2.length) throw new r("invalid aes block size");
-      const n2 = this.k[e2], s2 = n2.length / 4 - 2, o2 = [0, 0, 0, 0], i2 = this.K[e2], a2 = i2[0], c2 = i2[1], l2 = i2[2], f2 = i2[3], w2 = i2[4];
-      let u2, h2, p2, d2 = t2[0] ^ n2[0], y2 = t2[e2 ? 3 : 1] ^ n2[1], m2 = t2[2] ^ n2[2], g2 = t2[e2 ? 1 : 3] ^ n2[3], S2 = 4;
-      for (let t3 = 0; s2 > t3; t3++) u2 = a2[d2 >>> 24] ^ c2[y2 >> 16 & 255] ^ l2[m2 >> 8 & 255] ^ f2[255 & g2] ^ n2[S2], h2 = a2[y2 >>> 24] ^ c2[m2 >> 16 & 255] ^ l2[g2 >> 8 & 255] ^ f2[255 & d2] ^ n2[S2 + 1], p2 = a2[m2 >>> 24] ^ c2[g2 >> 16 & 255] ^ l2[d2 >> 8 & 255] ^ f2[255 & y2] ^ n2[S2 + 2], g2 = a2[g2 >>> 24] ^ c2[d2 >> 16 & 255] ^ l2[y2 >> 8 & 255] ^ f2[255 & m2] ^ n2[S2 + 3], S2 += 4, d2 = u2, y2 = h2, m2 = p2;
-      for (let t3 = 0; 4 > t3; t3++) o2[e2 ? 3 & -t3 : t3] = w2[d2 >>> 24] << 24 ^ w2[y2 >> 16 & 255] << 16 ^ w2[m2 >> 8 & 255] << 8 ^ w2[255 & g2] ^ n2[S2++], u2 = d2, d2 = y2, y2 = m2, m2 = g2, g2 = u2;
-      return o2;
-    }
-  }, rt = class {
-    constructor(t2, e2) {
-      this.O = t2, this.H = e2, this.Z = e2;
-    }
-    reset() {
-      this.Z = this.H;
-    }
-    update(t2) {
-      return this.F(this.O, t2, this.Z);
-    }
-    N(t2) {
-      if (255 & ~(t2 >> 24)) t2 += 1 << 24;
-      else {
-        let e2 = t2 >> 16 & 255, n2 = t2 >> 8 & 255, s2 = 255 & t2;
-        255 === e2 ? (e2 = 0, 255 === n2 ? (n2 = 0, 255 === s2 ? s2 = 0 : ++s2) : ++n2) : ++e2, t2 = 0, t2 += e2 << 16, t2 += n2 << 8, t2 += s2;
+      return o3;
+    })(t2, e2), r2 = new a(4), s2 = X(n2);
+    let c2 = 0, i2 = 0, f2 = 0, w2 = 0;
+    return { process(t3, n3) {
+      n3 && s2.update(t3, 0, t3.length), (function(t4) {
+        const n4 = new u(t4.buffer, t4.byteOffset, t4.byteLength), e3 = t4.length;
+        let o3 = 0;
+        for (; o3 + 16 <= e3; o3 += 16) l2(), n4.setInt32(o3, n4.getInt32(o3) ^ r2[0]), n4.setInt32(o3 + 4, n4.getInt32(o3 + 4) ^ r2[1]), n4.setInt32(o3 + 8, n4.getInt32(o3 + 8) ^ r2[2]), n4.setInt32(o3 + 12, n4.getInt32(o3 + 12) ^ r2[3]);
+        if (o3 < e3) {
+          l2();
+          for (let n5 = 0; o3 < e3; o3++, n5++) t4[o3] ^= r2[n5 >> 2] >>> 24 - 8 * (3 & n5);
+        }
+      })(t3), n3 || s2.update(t3, 0, t3.length);
+    }, digest: () => s2.digest() };
+    function l2() {
+      c2 = c2 + 1 | 0, c2 || (i2 = i2 + 1 | 0, i2 || (f2 = f2 + 1 | 0, f2 || (w2 = w2 + 1 | 0)));
+      let t3 = Z(c2) ^ e2[0], n3 = Z(i2) ^ e2[1], s3 = Z(f2) ^ e2[2], a2 = Z(w2) ^ e2[3], u2 = L[t3 >>> 24] ^ N[n3 >>> 16 & 255] ^ q[s3 >>> 8 & 255] ^ G[255 & a2] ^ e2[4], l3 = L[n3 >>> 24] ^ N[s3 >>> 16 & 255] ^ q[a2 >>> 8 & 255] ^ G[255 & t3] ^ e2[5], h2 = L[s3 >>> 24] ^ N[a2 >>> 16 & 255] ^ q[t3 >>> 8 & 255] ^ G[255 & n3] ^ e2[6], p2 = L[a2 >>> 24] ^ N[t3 >>> 16 & 255] ^ q[n3 >>> 8 & 255] ^ G[255 & s3] ^ e2[7];
+      t3 = L[u2 >>> 24] ^ N[l3 >>> 16 & 255] ^ q[h2 >>> 8 & 255] ^ G[255 & p2] ^ e2[8], n3 = L[l3 >>> 24] ^ N[h2 >>> 16 & 255] ^ q[p2 >>> 8 & 255] ^ G[255 & u2] ^ e2[9], s3 = L[h2 >>> 24] ^ N[p2 >>> 16 & 255] ^ q[u2 >>> 8 & 255] ^ G[255 & l3] ^ e2[10], a2 = L[p2 >>> 24] ^ N[u2 >>> 16 & 255] ^ q[l3 >>> 8 & 255] ^ G[255 & h2] ^ e2[11], u2 = L[t3 >>> 24] ^ N[n3 >>> 16 & 255] ^ q[s3 >>> 8 & 255] ^ G[255 & a2] ^ e2[12], l3 = L[n3 >>> 24] ^ N[s3 >>> 16 & 255] ^ q[a2 >>> 8 & 255] ^ G[255 & t3] ^ e2[13], h2 = L[s3 >>> 24] ^ N[a2 >>> 16 & 255] ^ q[t3 >>> 8 & 255] ^ G[255 & n3] ^ e2[14], p2 = L[a2 >>> 24] ^ N[t3 >>> 16 & 255] ^ q[n3 >>> 8 & 255] ^ G[255 & s3] ^ e2[15], t3 = L[u2 >>> 24] ^ N[l3 >>> 16 & 255] ^ q[h2 >>> 8 & 255] ^ G[255 & p2] ^ e2[16], n3 = L[l3 >>> 24] ^ N[h2 >>> 16 & 255] ^ q[p2 >>> 8 & 255] ^ G[255 & u2] ^ e2[17], s3 = L[h2 >>> 24] ^ N[p2 >>> 16 & 255] ^ q[u2 >>> 8 & 255] ^ G[255 & l3] ^ e2[18], a2 = L[p2 >>> 24] ^ N[u2 >>> 16 & 255] ^ q[l3 >>> 8 & 255] ^ G[255 & h2] ^ e2[19], u2 = L[t3 >>> 24] ^ N[n3 >>> 16 & 255] ^ q[s3 >>> 8 & 255] ^ G[255 & a2] ^ e2[20], l3 = L[n3 >>> 24] ^ N[s3 >>> 16 & 255] ^ q[a2 >>> 8 & 255] ^ G[255 & t3] ^ e2[21], h2 = L[s3 >>> 24] ^ N[a2 >>> 16 & 255] ^ q[t3 >>> 8 & 255] ^ G[255 & n3] ^ e2[22], p2 = L[a2 >>> 24] ^ N[t3 >>> 16 & 255] ^ q[n3 >>> 8 & 255] ^ G[255 & s3] ^ e2[23], t3 = L[u2 >>> 24] ^ N[l3 >>> 16 & 255] ^ q[h2 >>> 8 & 255] ^ G[255 & p2] ^ e2[24], n3 = L[l3 >>> 24] ^ N[h2 >>> 16 & 255] ^ q[p2 >>> 8 & 255] ^ G[255 & u2] ^ e2[25], s3 = L[h2 >>> 24] ^ N[p2 >>> 16 & 255] ^ q[u2 >>> 8 & 255] ^ G[255 & l3] ^ e2[26], a2 = L[p2 >>> 24] ^ N[u2 >>> 16 & 255] ^ q[l3 >>> 8 & 255] ^ G[255 & h2] ^ e2[27], u2 = L[t3 >>> 24] ^ N[n3 >>> 16 & 255] ^ q[s3 >>> 8 & 255] ^ G[255 & a2] ^ e2[28], l3 = L[n3 >>> 24] ^ N[s3 >>> 16 & 255] ^ q[a2 >>> 8 & 255] ^ G[255 & t3] ^ e2[29], h2 = L[s3 >>> 24] ^ N[a2 >>> 16 & 255] ^ q[t3 >>> 8 & 255] ^ G[255 & n3] ^ e2[30], p2 = L[a2 >>> 24] ^ N[t3 >>> 16 & 255] ^ q[n3 >>> 8 & 255] ^ G[255 & s3] ^ e2[31], t3 = L[u2 >>> 24] ^ N[l3 >>> 16 & 255] ^ q[h2 >>> 8 & 255] ^ G[255 & p2] ^ e2[32], n3 = L[l3 >>> 24] ^ N[h2 >>> 16 & 255] ^ q[p2 >>> 8 & 255] ^ G[255 & u2] ^ e2[33], s3 = L[h2 >>> 24] ^ N[p2 >>> 16 & 255] ^ q[u2 >>> 8 & 255] ^ G[255 & l3] ^ e2[34], a2 = L[p2 >>> 24] ^ N[u2 >>> 16 & 255] ^ q[l3 >>> 8 & 255] ^ G[255 & h2] ^ e2[35], u2 = L[t3 >>> 24] ^ N[n3 >>> 16 & 255] ^ q[s3 >>> 8 & 255] ^ G[255 & a2] ^ e2[36], l3 = L[n3 >>> 24] ^ N[s3 >>> 16 & 255] ^ q[a2 >>> 8 & 255] ^ G[255 & t3] ^ e2[37], h2 = L[s3 >>> 24] ^ N[a2 >>> 16 & 255] ^ q[t3 >>> 8 & 255] ^ G[255 & n3] ^ e2[38], p2 = L[a2 >>> 24] ^ N[t3 >>> 16 & 255] ^ q[n3 >>> 8 & 255] ^ G[255 & s3] ^ e2[39];
+      let d2 = 40;
+      o2 > 10 && (t3 = L[u2 >>> 24] ^ N[l3 >>> 16 & 255] ^ q[h2 >>> 8 & 255] ^ G[255 & p2] ^ e2[40], n3 = L[l3 >>> 24] ^ N[h2 >>> 16 & 255] ^ q[p2 >>> 8 & 255] ^ G[255 & u2] ^ e2[41], s3 = L[h2 >>> 24] ^ N[p2 >>> 16 & 255] ^ q[u2 >>> 8 & 255] ^ G[255 & l3] ^ e2[42], a2 = L[p2 >>> 24] ^ N[u2 >>> 16 & 255] ^ q[l3 >>> 8 & 255] ^ G[255 & h2] ^ e2[43], u2 = L[t3 >>> 24] ^ N[n3 >>> 16 & 255] ^ q[s3 >>> 8 & 255] ^ G[255 & a2] ^ e2[44], l3 = L[n3 >>> 24] ^ N[s3 >>> 16 & 255] ^ q[a2 >>> 8 & 255] ^ G[255 & t3] ^ e2[45], h2 = L[s3 >>> 24] ^ N[a2 >>> 16 & 255] ^ q[t3 >>> 8 & 255] ^ G[255 & n3] ^ e2[46], p2 = L[a2 >>> 24] ^ N[t3 >>> 16 & 255] ^ q[n3 >>> 8 & 255] ^ G[255 & s3] ^ e2[47], d2 = 48), o2 > 12 && (t3 = L[u2 >>> 24] ^ N[l3 >>> 16 & 255] ^ q[h2 >>> 8 & 255] ^ G[255 & p2] ^ e2[48], n3 = L[l3 >>> 24] ^ N[h2 >>> 16 & 255] ^ q[p2 >>> 8 & 255] ^ G[255 & u2] ^ e2[49], s3 = L[h2 >>> 24] ^ N[p2 >>> 16 & 255] ^ q[u2 >>> 8 & 255] ^ G[255 & l3] ^ e2[50], a2 = L[p2 >>> 24] ^ N[u2 >>> 16 & 255] ^ q[l3 >>> 8 & 255] ^ G[255 & h2] ^ e2[51], u2 = L[t3 >>> 24] ^ N[n3 >>> 16 & 255] ^ q[s3 >>> 8 & 255] ^ G[255 & a2] ^ e2[52], l3 = L[n3 >>> 24] ^ N[s3 >>> 16 & 255] ^ q[a2 >>> 8 & 255] ^ G[255 & t3] ^ e2[53], h2 = L[s3 >>> 24] ^ N[a2 >>> 16 & 255] ^ q[t3 >>> 8 & 255] ^ G[255 & n3] ^ e2[54], p2 = L[a2 >>> 24] ^ N[t3 >>> 16 & 255] ^ q[n3 >>> 8 & 255] ^ G[255 & s3] ^ e2[55], d2 = 56), r2[0] = (H[u2 >>> 24] << 24 | H[l3 >>> 16 & 255] << 16 | H[h2 >>> 8 & 255] << 8 | H[255 & p2]) ^ e2[d2], r2[1] = (H[l3 >>> 24] << 24 | H[h2 >>> 16 & 255] << 16 | H[p2 >>> 8 & 255] << 8 | H[255 & u2]) ^ e2[d2 + 1], r2[2] = (H[h2 >>> 24] << 24 | H[p2 >>> 16 & 255] << 16 | H[u2 >>> 8 & 255] << 8 | H[255 & l3]) ^ e2[d2 + 2], r2[3] = (H[p2 >>> 24] << 24 | H[u2 >>> 16 & 255] << 16 | H[l3 >>> 8 & 255] << 8 | H[255 & h2]) ^ e2[d2 + 3];
+    }
+  }
+  function X(t2) {
+    const n2 = (function() {
+      const t3 = new a(O), n3 = new a(16), e3 = new s(V), r3 = new u(e3.buffer), c2 = new s(8);
+      let i2 = 0, f2 = 0;
+      return { update: w2, digest: function() {
+        const n4 = 8 * f2, e4 = o.floor(n4 / 4294967296), r4 = n4 >>> 0;
+        for (w2(j, 0, 1); 56 != i2; ) w2(K, 0, 1);
+        c2[0] = e4 >>> 24, c2[1] = e4 >>> 16, c2[2] = e4 >>> 8, c2[3] = e4, c2[4] = r4 >>> 24, c2[5] = r4 >>> 16, c2[6] = r4 >>> 8, c2[7] = r4, w2(c2, 0, 8);
+        const a2 = new s(W), l3 = new u(a2.buffer);
+        for (let n5 = 0; n5 < t3.length; n5++) l3.setInt32(4 * n5, t3[n5]);
+        return t3.set(O), i2 = 0, f2 = 0, a2;
+      } };
+      function w2(t4, n4, o2) {
+        const s2 = n4 + o2;
+        if (f2 += o2, i2) {
+          for (; n4 < s2 && i2 < V; ) e3[i2++] = t4[n4++];
+          i2 == V && (l2(r3, 0), i2 = 0);
+        }
+        if (n4 + V <= s2) {
+          const e4 = new u(t4.buffer, t4.byteOffset, t4.byteLength);
+          for (; n4 + V <= s2; n4 += V) l2(e4, n4);
+        }
+        for (; n4 < s2; ) e3[i2++] = t4[n4++];
       }
-      return t2;
-    }
-    q(t2) {
-      0 === (t2[0] = this.N(t2[0])) && (t2[1] = this.N(t2[1]));
-    }
-    F(t2, e2, n2) {
-      let s2;
-      if (!(s2 = e2.length)) return [];
-      const r2 = B.l(e2);
-      for (let r3 = 0; s2 > r3; r3 += 4) {
-        this.q(n2);
-        const s3 = t2.encrypt(n2);
-        e2[r3] ^= s3[0], e2[r3 + 1] ^= s3[1], e2[r3 + 2] ^= s3[2], e2[r3 + 3] ^= s3[3];
+      function l2(e4, o2) {
+        for (let t4 = 0; t4 < 16; t4++) n3[t4] = e4.getInt32(o2 + 4 * t4);
+        let r4, s2 = t3[0], c3 = t3[1], i3 = t3[2], a2 = t3[3], f3 = t3[4];
+        for (let t4 = 0; t4 < 15; t4 += 5) f3 = (s2 << 5 | s2 >>> 27) + ((i3 ^ a2) & c3 ^ a2) + f3 + 1518500249 + n3[t4] | 0, c3 = c3 << 30 | c3 >>> 2, a2 = (f3 << 5 | f3 >>> 27) + ((c3 ^ i3) & s2 ^ i3) + a2 + 1518500249 + n3[t4 + 1] | 0, s2 = s2 << 30 | s2 >>> 2, i3 = (a2 << 5 | a2 >>> 27) + ((s2 ^ c3) & f3 ^ c3) + i3 + 1518500249 + n3[t4 + 2] | 0, f3 = f3 << 30 | f3 >>> 2, c3 = (i3 << 5 | i3 >>> 27) + ((f3 ^ s2) & a2 ^ s2) + c3 + 1518500249 + n3[t4 + 3] | 0, a2 = a2 << 30 | a2 >>> 2, s2 = (c3 << 5 | c3 >>> 27) + ((a2 ^ f3) & i3 ^ f3) + s2 + 1518500249 + n3[t4 + 4] | 0, i3 = i3 << 30 | i3 >>> 2;
+        f3 = (s2 << 5 | s2 >>> 27) + ((i3 ^ a2) & c3 ^ a2) + f3 + 1518500249 + n3[15] | 0, c3 = c3 << 30 | c3 >>> 2, r4 = n3[13] ^ n3[8] ^ n3[2] ^ n3[0], r4 = r4 << 1 | r4 >>> 31, n3[0] = r4, a2 = (f3 << 5 | f3 >>> 27) + ((c3 ^ i3) & s2 ^ i3) + a2 + 1518500249 + r4 | 0, s2 = s2 << 30 | s2 >>> 2, r4 = n3[14] ^ n3[9] ^ n3[3] ^ n3[1], r4 = r4 << 1 | r4 >>> 31, n3[1] = r4, i3 = (a2 << 5 | a2 >>> 27) + ((s2 ^ c3) & f3 ^ c3) + i3 + 1518500249 + r4 | 0, f3 = f3 << 30 | f3 >>> 2, r4 = n3[15] ^ n3[10] ^ n3[4] ^ n3[2], r4 = r4 << 1 | r4 >>> 31, n3[2] = r4, c3 = (i3 << 5 | i3 >>> 27) + ((f3 ^ s2) & a2 ^ s2) + c3 + 1518500249 + r4 | 0, a2 = a2 << 30 | a2 >>> 2, r4 = n3[0] ^ n3[11] ^ n3[5] ^ n3[3], r4 = r4 << 1 | r4 >>> 31, n3[3] = r4, s2 = (c3 << 5 | c3 >>> 27) + ((a2 ^ f3) & i3 ^ f3) + s2 + 1518500249 + r4 | 0, i3 = i3 << 30 | i3 >>> 2;
+        for (let t4 = 20; t4 < 40; t4 += 5) r4 = n3[t4 - 3 & 15] ^ n3[t4 - 8 & 15] ^ n3[t4 - 14 & 15] ^ n3[15 & t4], r4 = r4 << 1 | r4 >>> 31, n3[15 & t4] = r4, f3 = (s2 << 5 | s2 >>> 27) + (c3 ^ i3 ^ a2) + f3 + 1859775393 + r4 | 0, c3 = c3 << 30 | c3 >>> 2, r4 = n3[t4 - 2 & 15] ^ n3[t4 - 7 & 15] ^ n3[t4 - 13 & 15] ^ n3[t4 + 1 & 15], r4 = r4 << 1 | r4 >>> 31, n3[t4 + 1 & 15] = r4, a2 = (f3 << 5 | f3 >>> 27) + (s2 ^ c3 ^ i3) + a2 + 1859775393 + r4 | 0, s2 = s2 << 30 | s2 >>> 2, r4 = n3[t4 - 1 & 15] ^ n3[t4 - 6 & 15] ^ n3[t4 - 12 & 15] ^ n3[t4 + 2 & 15], r4 = r4 << 1 | r4 >>> 31, n3[t4 + 2 & 15] = r4, i3 = (a2 << 5 | a2 >>> 27) + (f3 ^ s2 ^ c3) + i3 + 1859775393 + r4 | 0, f3 = f3 << 30 | f3 >>> 2, r4 = n3[15 & t4] ^ n3[t4 - 5 & 15] ^ n3[t4 - 11 & 15] ^ n3[t4 + 3 & 15], r4 = r4 << 1 | r4 >>> 31, n3[t4 + 3 & 15] = r4, c3 = (i3 << 5 | i3 >>> 27) + (a2 ^ f3 ^ s2) + c3 + 1859775393 + r4 | 0, a2 = a2 << 30 | a2 >>> 2, r4 = n3[t4 + 1 & 15] ^ n3[t4 - 4 & 15] ^ n3[t4 - 10 & 15] ^ n3[t4 + 4 & 15], r4 = r4 << 1 | r4 >>> 31, n3[t4 + 4 & 15] = r4, s2 = (c3 << 5 | c3 >>> 27) + (i3 ^ a2 ^ f3) + s2 + 1859775393 + r4 | 0, i3 = i3 << 30 | i3 >>> 2;
+        for (let t4 = 40; t4 < 60; t4 += 5) r4 = n3[t4 - 3 & 15] ^ n3[t4 - 8 & 15] ^ n3[t4 - 14 & 15] ^ n3[15 & t4], r4 = r4 << 1 | r4 >>> 31, n3[15 & t4] = r4, f3 = (s2 << 5 | s2 >>> 27) + (c3 & i3 | (c3 | i3) & a2) + f3 + 2400959708 + r4 | 0, c3 = c3 << 30 | c3 >>> 2, r4 = n3[t4 - 2 & 15] ^ n3[t4 - 7 & 15] ^ n3[t4 - 13 & 15] ^ n3[t4 + 1 & 15], r4 = r4 << 1 | r4 >>> 31, n3[t4 + 1 & 15] = r4, a2 = (f3 << 5 | f3 >>> 27) + (s2 & c3 | (s2 | c3) & i3) + a2 + 2400959708 + r4 | 0, s2 = s2 << 30 | s2 >>> 2, r4 = n3[t4 - 1 & 15] ^ n3[t4 - 6 & 15] ^ n3[t4 - 12 & 15] ^ n3[t4 + 2 & 15], r4 = r4 << 1 | r4 >>> 31, n3[t4 + 2 & 15] = r4, i3 = (a2 << 5 | a2 >>> 27) + (f3 & s2 | (f3 | s2) & c3) + i3 + 2400959708 + r4 | 0, f3 = f3 << 30 | f3 >>> 2, r4 = n3[15 & t4] ^ n3[t4 - 5 & 15] ^ n3[t4 - 11 & 15] ^ n3[t4 + 3 & 15], r4 = r4 << 1 | r4 >>> 31, n3[t4 + 3 & 15] = r4, c3 = (i3 << 5 | i3 >>> 27) + (a2 & f3 | (a2 | f3) & s2) + c3 + 2400959708 + r4 | 0, a2 = a2 << 30 | a2 >>> 2, r4 = n3[t4 + 1 & 15] ^ n3[t4 - 4 & 15] ^ n3[t4 - 10 & 15] ^ n3[t4 + 4 & 15], r4 = r4 << 1 | r4 >>> 31, n3[t4 + 4 & 15] = r4, s2 = (c3 << 5 | c3 >>> 27) + (i3 & a2 | (i3 | a2) & f3) + s2 + 2400959708 + r4 | 0, i3 = i3 << 30 | i3 >>> 2;
+        for (let t4 = 60; t4 < 80; t4 += 5) r4 = n3[t4 - 3 & 15] ^ n3[t4 - 8 & 15] ^ n3[t4 - 14 & 15] ^ n3[15 & t4], r4 = r4 << 1 | r4 >>> 31, n3[15 & t4] = r4, f3 = (s2 << 5 | s2 >>> 27) + (c3 ^ i3 ^ a2) + f3 + 3395469782 + r4 | 0, c3 = c3 << 30 | c3 >>> 2, r4 = n3[t4 - 2 & 15] ^ n3[t4 - 7 & 15] ^ n3[t4 - 13 & 15] ^ n3[t4 + 1 & 15], r4 = r4 << 1 | r4 >>> 31, n3[t4 + 1 & 15] = r4, a2 = (f3 << 5 | f3 >>> 27) + (s2 ^ c3 ^ i3) + a2 + 3395469782 + r4 | 0, s2 = s2 << 30 | s2 >>> 2, r4 = n3[t4 - 1 & 15] ^ n3[t4 - 6 & 15] ^ n3[t4 - 12 & 15] ^ n3[t4 + 2 & 15], r4 = r4 << 1 | r4 >>> 31, n3[t4 + 2 & 15] = r4, i3 = (a2 << 5 | a2 >>> 27) + (f3 ^ s2 ^ c3) + i3 + 3395469782 + r4 | 0, f3 = f3 << 30 | f3 >>> 2, r4 = n3[15 & t4] ^ n3[t4 - 5 & 15] ^ n3[t4 - 11 & 15] ^ n3[t4 + 3 & 15], r4 = r4 << 1 | r4 >>> 31, n3[t4 + 3 & 15] = r4, c3 = (i3 << 5 | i3 >>> 27) + (a2 ^ f3 ^ s2) + c3 + 3395469782 + r4 | 0, a2 = a2 << 30 | a2 >>> 2, r4 = n3[t4 + 1 & 15] ^ n3[t4 - 4 & 15] ^ n3[t4 - 10 & 15] ^ n3[t4 + 4 & 15], r4 = r4 << 1 | r4 >>> 31, n3[t4 + 4 & 15] = r4, s2 = (c3 << 5 | c3 >>> 27) + (i3 ^ a2 ^ f3) + s2 + 3395469782 + r4 | 0, i3 = i3 << 30 | i3 >>> 2;
+        t3[0] = t3[0] + s2 | 0, t3[1] = t3[1] + c3 | 0, t3[2] = t3[2] + i3 | 0, t3[3] = t3[3] + a2 | 0, t3[4] = t3[4] + f3 | 0;
       }
-      return B.u(e2, r2);
-    }
-  }, ot = K.D;
-  let it = $ && et && typeof tt.importKey == v, at = $ && et && typeof tt.deriveBits == v;
-  class ct extends d {
-    constructor({ password: t2, rawPassword: e2, encryptionStrength: n2, checkPasswordOnly: s2 }) {
+    })(), e2 = new s(V), r2 = new s(V);
+    t2.length > V && (n2.update(t2, 0, t2.length), t2 = n2.digest());
+    for (let n3 = 0; n3 < V; n3++) {
+      const o2 = n3 < t2.length ? t2[n3] : 0;
+      e2[n3] = 54 ^ o2, r2[n3] = 92 ^ o2;
+    }
+    return n2.update(e2, 0, V), { update(t3, e3, o2) {
+      n2.update(t3, e3, o2);
+    }, digest() {
+      const t3 = n2.digest();
+      n2.update(r2, 0, V), n2.update(t3, 0, W);
+      const o2 = n2.digest();
+      return n2.update(e2, 0, V), o2;
+    } };
+  }
+  function Y(t2) {
+    return H[t2 >>> 24] << 24 | H[t2 >>> 16 & 255] << 16 | H[t2 >>> 8 & 255] << 8 | H[255 & t2];
+  }
+  function Z(t2) {
+    return t2 << 24 | (65280 & t2) << 8 | t2 >>> 8 & 65280 | t2 >>> 24;
+  }
+  function $(t2) {
+    return 255 & (t2 << 1 ^ 27 * (t2 >> 7));
+  }
+  const _ = typeof h != z && typeof h.getRandomValues == b, tt = "Invalid password", nt = "zipjs-abort-check-password";
+  function et(t2) {
+    if (_) return h.getRandomValues(t2);
+    throw new r("Crypto API not supported");
+  }
+  const ot = { name: "PBKDF2" }, rt = n.assign({ hash: { name: "HMAC" } }, ot), st = n.assign({ iterations: 1e3, hash: { name: "SHA-1" } }, ot), ct = ["deriveBits"], it = [8, 12, 16], at = [16, 24, 32], ft = 10, ut = typeof h != z, wt = ut && h.subtle;
+  let lt = ut && typeof wt != z && typeof wt.importKey == b && typeof wt.deriveBits == b, ht = Q;
+  class pt extends d {
+    constructor({ password: t2, rawPassword: n2, encryptionStrength: e2, checkPasswordOnly: o2, checkAuthenticationCode: c2 = true }) {
       super({ start() {
-        ft(this, t2, e2, n2);
-      }, async transform(t3, e3) {
-        const n3 = this, { password: i2, strength: a2, G: c2, ready: l2 } = n3;
-        i2 ? (await (async (t4, e4, n4, s3) => {
-          const o2 = await ut(t4, e4, n4, dt(s3, 0, J[e4])), i3 = dt(s3, J[e4]);
-          if (o2[0] != i3[0] || o2[1] != i3[1]) throw new r(E);
-        })(n3, a2, i2, dt(t3, 0, J[a2] + 2)), t3 = dt(t3, J[a2] + 2), s2 ? e3.error(new r(O)) : c2()) : await l2;
-        const f2 = new o(t3.length - X - (t3.length - X) % Z);
-        e3.enqueue(wt(n3, t3, f2, 0, X, true));
+        yt(this, t2, n2, e2);
+      }, async transform(t3, n3) {
+        const e3 = this, { password: c3, strength: i2, l: a2, ready: f2 } = e3;
+        c3 ? (await (async function(t4, n4, e4, o3) {
+          const s2 = await gt(t4, n4, e4, zt(o3, 0, it[n4])), c4 = zt(o3, it[n4]);
+          if (s2[0] != c4[0] || s2[1] != c4[1]) throw St(t4), new r(tt);
+        })(e3, i2, c3, zt(t3, 0, it[i2] + 2)), t3 = zt(t3, it[i2] + 2), o2 ? (St(e3), n3.error(new r(nt))) : a2()) : await f2;
+        const u2 = new s(t3.length - ft - (t3.length - ft) % 16);
+        n3.enqueue(mt(e3, t3, u2, 0, ft, true));
       }, async flush(t3) {
-        const { J: e3, X: n3, pending: s3, ready: o2 } = this;
-        if (n3 && e3) {
-          await o2;
-          const i2 = dt(s3, 0, s3.length - X), a2 = dt(s3, s3.length - X);
-          let c2 = z;
-          if (i2.length) {
-            const t4 = mt(nt, i2);
-            n3.update(t4);
-            const s4 = e3.update(t4);
-            c2 = yt(nt, s4);
-          }
-          const l2 = dt(yt(nt, n3.digest()), 0, X);
-          let f2 = s3.length < X ? 1 : 0;
-          for (let t4 = 0; X > t4; t4++) f2 |= l2[t4] ^ a2[t4];
-          if (f2) throw new r(L);
-          t3.enqueue(c2);
+        const { h: n3, m: e3, ready: o3 } = this;
+        if (n3) {
+          await o3;
+          const i2 = zt(e3, e3.length - ft), a2 = new s(zt(e3, 0, e3.length - ft));
+          n3.process(a2, true);
+          const f2 = n3.digest();
+          let u2 = e3.length < ft ? 1 : 0;
+          for (let t4 = 0; t4 < ft; t4++) u2 |= f2[t4] ^ i2[t4];
+          if (u2 && c2) throw new r("Invalid authentication code");
+          t3.enqueue(a2);
         }
+      }, cancel() {
+        St(this);
       } });
     }
   }
-  class lt extends d {
-    constructor({ password: t2, rawPassword: e2, encryptionStrength: n2 }) {
-      let s2;
+  class dt extends d {
+    constructor({ password: t2, rawPassword: n2, encryptionStrength: e2 }) {
       super({ start() {
-        ft(this, t2, e2, n2);
-      }, async transform(t3, e3) {
-        const n3 = this, { password: s3, strength: r2, G: i2, ready: a2 } = n3;
-        let c2 = z;
-        s3 ? (c2 = await (async (t4, e4, n4) => {
-          const s4 = H(new o(J[e4]));
-          return pt(s4, await ut(t4, e4, n4, s4));
-        })(n3, r2, s3), i2()) : await a2;
-        const l2 = new o(c2.length + t3.length - t3.length % Z);
-        l2.set(c2, 0), e3.enqueue(wt(n3, t3, l2, c2.length, 0));
+        yt(this, t2, n2, e2);
+      }, async transform(t3, n3) {
+        const e3 = this, { password: o2, strength: r2, l: c2, ready: i2 } = e3;
+        let a2 = k;
+        o2 ? (a2 = await (async function(t4, n4, e4) {
+          const o3 = et(new s(it[n4]));
+          return B(o3, await gt(t4, n4, e4, o3));
+        })(e3, r2, o2), c2()) : await i2;
+        const f2 = new s(a2.length + t3.length - t3.length % 16);
+        f2.set(a2, 0), n3.enqueue(mt(e3, t3, f2, a2.length, 0, false));
       }, async flush(t3) {
-        const { J: e3, X: n3, pending: r2, ready: o2 } = this;
-        if (n3 && e3) {
+        const { h: n3, m: e3, ready: o2 } = this;
+        if (n3) {
           await o2;
-          let i2 = z;
-          if (r2.length) {
-            const t4 = e3.update(mt(nt, r2));
-            n3.update(t4), i2 = yt(nt, t4);
-          }
-          s2.signature = yt(nt, n3.digest()).slice(0, X), t3.enqueue(pt(i2, s2.signature));
+          const r2 = new s(e3);
+          n3.process(r2, false);
+          const c2 = zt(n3.digest(), 0, ft);
+          t3.enqueue(B(r2, c2));
         }
-      } }), s2 = this;
+      }, cancel() {
+        St(this);
+      } });
     }
   }
-  function ft(t2, n2, s2, r2) {
-    e.assign(t2, { ready: new w((e2) => t2.G = e2), password: ht(n2, s2), strength: r2 - 1, pending: z });
-  }
-  function wt(t2, e2, n2, s2, r2, i2) {
-    const { J: a2, X: c2, pending: l2 } = t2;
-    l2.length && (e2 = pt(l2, e2));
-    const f2 = e2.length - r2;
-    let w2;
-    for (n2 = ((t3, e3) => {
-      if (e3 && e3 > t3.length) {
-        const n3 = t3;
-        (t3 = new o(e3)).set(n3, 0);
+  function yt(t2, e2, o2, r2) {
+    n.assign(t2, { ready: new w((n2) => t2.l = n2), password: vt(e2, o2), strength: r2 - 1, m: k });
+  }
+  function mt(t2, n2, e2, o2, r2, c2) {
+    const { h: i2, m: a2 } = t2;
+    a2.length && (n2 = B(a2, n2));
+    const f2 = n2.length - r2, u2 = f2 - f2 % 16;
+    if (e2 = (function(t3, n3) {
+      if (n3 && n3 > t3.length) {
+        const e3 = t3;
+        (t3 = new s(n3)).set(e3, 0);
       }
       return t3;
-    })(n2, s2 + (f2 - f2 % Z)), w2 = 0; f2 - Z >= w2; w2 += Z) {
-      const t3 = mt(nt, dt(e2, w2, w2 + Z));
-      i2 && c2.update(t3);
-      const r3 = a2.update(t3);
-      i2 || c2.update(r3), n2.set(yt(nt, r3), w2 + s2);
+    })(e2, o2 + u2), u2) {
+      const t3 = zt(e2, o2, o2 + u2);
+      t3.set(zt(n2, 0, u2)), i2.process(t3, c2);
     }
-    return t2.pending = dt(e2, w2), n2;
+    return t2.m = zt(n2, u2), e2;
   }
-  async function ut(n2, s2, r2, i2) {
-    n2.password = null;
-    const a2 = await (async (t2, e2, n3, s3, r3) => {
-      if (!it) return K.importKey(e2);
-      try {
-        return await tt.importKey("raw", e2, n3, false, r3);
-      } catch {
-        return it = false, K.importKey(e2);
-      }
-    })(0, r2, N, 0, G), c2 = await (async (t2, e2, n3) => {
-      if (!at) return K.M(e2, t2.salt, q.iterations, n3);
-      try {
-        return await tt.deriveBits(t2, e2, n3);
+  function St({ h: t2 }) {
+    t2 && t2.dispose && t2.dispose();
+  }
+  async function gt(t2, e2, r2, c2) {
+    t2.password = null;
+    const i2 = at[e2], a2 = await (async function(t3, e3, r3) {
+      if (lt) try {
+        const o2 = await wt.importKey("raw", t3, rt, false, ct);
+        return new s(await wt.deriveBits(n.assign({ salt: e3 }, st), o2, 8 * r3));
       } catch {
-        return at = false, K.M(e2, t2.salt, q.iterations, n3);
+        lt = false;
       }
-    })(e.assign({ salt: i2 }, q), a2, 8 * (2 * Q[s2] + 2)), l2 = new o(c2), f2 = mt(nt, dt(l2, 0, Q[s2])), w2 = mt(nt, dt(l2, Q[s2], 2 * Q[s2])), u2 = dt(l2, 2 * Q[s2]);
-    return e.assign(n2, { keys: { key: f2, Y: w2, passwordVerification: u2 }, J: new rt(new st(f2), t.from(Y)), X: new ot(w2) }), u2;
-  }
-  function ht(t2, e2) {
-    return e2 === b ? ((t3) => {
-      if (typeof u == k) {
-        const e3 = new o((t3 = unescape(encodeURIComponent(t3))).length);
-        for (let n2 = 0; n2 < e3.length; n2++) e3[n2] = t3.charCodeAt(n2);
-        return e3;
+      return (function(t4, n2, e4, r4) {
+        const c3 = X(t4), i3 = new s(r4), a3 = new s(n2.length + 4), f2 = new u(a3.buffer);
+        a3.set(n2);
+        for (let t5 = 1, e5 = 0; e5 < r4; t5++, e5 += W) {
+          f2.setUint32(n2.length, t5), c3.update(a3, 0, a3.length);
+          let s2 = c3.digest();
+          const u2 = s2.slice();
+          for (let t6 = 1; t6 < 1e3; t6++) {
+            c3.update(s2, 0, W), s2 = c3.digest();
+            for (let t7 = 0; t7 < W; t7++) u2[t7] ^= s2[t7];
+          }
+          i3.set(u2.subarray(0, o.min(W, r4 - e5)), e5);
+        }
+        return i3;
+      })(t3, e3, 0, r3);
+    })(r2, c2, 2 * i2 + 2);
+    return t2.h = ht(zt(a2, 0, i2), zt(a2, i2, 2 * i2)), zt(a2, 2 * i2);
+  }
+  function vt(t2, n2) {
+    return n2 === v ? (function(t3) {
+      if (typeof l == z) {
+        t3 = unescape(encodeURIComponent(t3));
+        const n3 = new s(t3.length);
+        for (let e2 = 0; e2 < n3.length; e2++) n3[e2] = t3.charCodeAt(e2);
+        return n3;
       }
-      return new u().encode(t3);
-    })(t2) : e2;
-  }
-  function pt(t2, e2) {
-    let n2 = t2;
-    return t2.length + e2.length && (n2 = new o(t2.length + e2.length), n2.set(t2, 0), n2.set(e2, t2.length)), n2;
-  }
-  function dt(t2, e2, n2) {
-    return t2.subarray(e2, n2);
+      return new l().encode(t3);
+    })(t2) : n2;
   }
-  function yt(t2, e2) {
-    return t2.p(e2);
+  function zt(t2, n2, e2) {
+    return t2.subarray(n2, e2);
   }
-  function mt(t2, e2) {
-    return t2.m(e2);
-  }
-  class gt extends d {
-    constructor({ password: t2, rawPassword: e2, passwordVerification: n2, checkPasswordOnly: s2 }) {
+  class bt extends d {
+    constructor({ password: t2, rawPassword: n2, passwordVerification: e2, checkPasswordOnly: o2 }) {
       super({ start() {
-        bt(this, t2, e2, n2);
-      }, transform(t3, e3) {
-        const n3 = this;
-        if (n3.password || n3.rawPassword) {
-          const e4 = kt(n3, t3.subarray(0, 12));
-          if (n3.password = n3.rawPassword = null, 0 != (e4.at(-1) ^ n3.passwordVerification)) throw new r(E);
+        Ct(this, t2, n2, e2);
+      }, transform(t3, n3) {
+        const e3 = this;
+        if (e3.password || e3.rawPassword) {
+          const n4 = It(e3, t3.subarray(0, 12));
+          if (e3.password = e3.rawPassword = null, 0 != (n4[11] ^ e3.passwordVerification)) throw new r(tt);
           t3 = t3.subarray(12);
         }
-        s2 ? e3.error(new r(O)) : e3.enqueue(kt(n3, t3));
+        o2 ? n3.error(new r(nt)) : n3.enqueue(It(e3, t3));
       } });
     }
   }
-  class St extends d {
-    constructor({ password: t2, rawPassword: e2, passwordVerification: n2 }) {
+  class kt extends d {
+    constructor({ password: t2, rawPassword: n2, passwordVerification: e2 }) {
       super({ start() {
-        bt(this, t2, e2, n2);
-      }, transform(t3, e3) {
-        const n3 = this;
-        let s2, r2;
-        if (n3.password || n3.rawPassword) {
-          n3.password = n3.rawPassword = null;
-          const e4 = H(new o(12));
-          e4[11] = n3.passwordVerification, s2 = new o(t3.length + e4.length), s2.set(vt(n3, e4), 0), r2 = 12;
-        } else s2 = new o(t3.length), r2 = 0;
-        s2.set(vt(n3, t3), r2), e3.enqueue(s2);
+        Ct(this, t2, n2, e2);
+      }, transform(t3, n3) {
+        const e3 = this;
+        let o2, r2;
+        if (e3.password || e3.rawPassword) {
+          e3.password = e3.rawPassword = null;
+          const n4 = et(new s(12));
+          n4[11] = e3.passwordVerification, o2 = new s(t3.length + n4.length), o2.set(At(e3, n4), 0), r2 = 12;
+        } else o2 = new s(t3.length), r2 = 0;
+        o2.set(At(e3, t3), r2), n3.enqueue(o2);
       } });
     }
   }
-  function bt(t2, n2, s2, r2) {
-    e.assign(t2, { password: n2, rawPassword: s2, passwordVerification: r2 }), ((t3, n3, s3) => {
+  function Ct(t2, e2, o2, r2) {
+    n.assign(t2, { password: e2, rawPassword: o2, passwordVerification: r2 }), (function(t3, e3, o3) {
       const r3 = [305419896, 591751049, 878082192];
-      if (e.assign(t3, { keys: r3, $: new M(r3[0]), tt: new M(r3[2]) }), s3) for (let e2 = 0; e2 < s3.length; e2++) zt(t3, s3[e2]);
-      else for (let e2 = 0; e2 < n3.length; e2++) zt(t3, n3.charCodeAt(e2));
-    })(t2, n2, s2);
-  }
-  function kt(t2, e2) {
-    const n2 = new o(e2.length);
-    for (let s2 = 0; s2 < e2.length; s2++) n2[s2] = Ct(t2) ^ e2[s2], zt(t2, n2[s2]);
-    return n2;
-  }
-  function vt(t2, e2) {
-    const n2 = new o(e2.length);
-    for (let s2 = 0; s2 < e2.length; s2++) n2[s2] = Ct(t2) ^ e2[s2], zt(t2, e2[s2]);
-    return n2;
-  }
-  function zt(t2, e2) {
-    let [, n2] = t2.keys;
-    t2.$.append([e2]);
-    const r2 = ~t2.$.get();
-    n2 = At(s.imul(At(n2 + It(r2)), 134775813) + 1), t2.tt.append([n2 >>> 24]);
-    const o2 = ~t2.tt.get();
-    t2.keys = [r2, n2, o2];
-  }
-  function Ct(t2) {
-    const e2 = 2 | t2.keys[2];
-    return It(s.imul(e2, 1 ^ e2) >>> 8);
-  }
-  function It(t2) {
+      if (n.assign(t3, { keys: r3, S: new R(r3[0]), v: new R(r3[2]) }), o3) for (let n2 = 0; n2 < o3.length; n2++) xt(t3, o3[n2]);
+      else for (let n2 = 0; n2 < e3.length; n2++) xt(t3, e3.charCodeAt(n2));
+    })(t2, e2, o2);
+  }
+  function It(t2, n2) {
+    const e2 = new s(n2.length);
+    for (let o2 = 0; o2 < n2.length; o2++) e2[o2] = Mt(t2) ^ n2[o2], xt(t2, e2[o2]);
+    return e2;
+  }
+  function At(t2, n2) {
+    const e2 = new s(n2.length);
+    for (let o2 = 0; o2 < n2.length; o2++) e2[o2] = Mt(t2) ^ n2[o2], xt(t2, n2[o2]);
+    return e2;
+  }
+  function xt(t2, n2) {
+    let [, e2] = t2.keys;
+    t2.S.append([n2]);
+    const r2 = ~t2.S.get();
+    e2 = Dt(o.imul(Dt(e2 + Pt(r2)), 134775813) + 1), t2.v.append([e2 >>> 24]);
+    const s2 = ~t2.v.get();
+    t2.keys = [r2, e2, s2];
+  }
+  function Mt(t2) {
+    const n2 = 2 | t2.keys[2];
+    return Pt(o.imul(n2, 1 ^ n2) >>> 8);
+  }
+  function Pt(t2) {
     return 255 & t2;
   }
-  function At(t2) {
+  function Dt(t2) {
     return 4294967295 & t2;
   }
-  class xt extends d {
-    constructor(t2, { chunkSize: e2, CompressionStreamZlib: n2, CompressionStream: s2 }) {
+  function Ft(t2) {
+    if (t2 instanceof y) return t2;
+    const n2 = t2.getReader();
+    return new y({ async pull(t3) {
+      const { value: e2, done: o2 } = await n2.read();
+      o2 ? t3.close() : t3.enqueue(e2);
+    }, cancel: (t3) => n2.cancel(t3) });
+  }
+  const Et = new f();
+  function Rt(t2) {
+    return Et.get(t2);
+  }
+  const Ut = "Invalid uncompressed size", Bt = "deflate-raw", Tt = "gzip", Vt = [31, 139, 8];
+  class Wt extends d {
+    constructor(t2, { chunkSize: n2, CompressionStreamFallback: e2, CompressionStream: o2 }) {
       super({});
-      const { compressed: r2, encrypted: o2, useCompressionStream: i2, zipCrypto: a2, signed: c2, level: l2, deflate64: w2 } = t2, u2 = this;
-      let h2, p2, d2, y2 = super.readable;
-      const m2 = c2 && r2 && !w2 && (!o2 || a2) && !(!i2 || !s2);
-      o2 && !a2 || !c2 || m2 || (h2 = new _(), y2 = Dt(y2, h2)), r2 && (m2 ? (d2 = new Pt(), y2 = Mt(y2, new s2("gzip")), y2 = Dt(y2, d2)) : y2 = Wt(y2, i2, { level: l2, chunkSize: e2 }, s2, n2, s2)), o2 && (a2 ? y2 = Dt(y2, new St(t2)) : (p2 = new lt(t2), y2 = Dt(y2, p2))), Ut(u2, y2, () => {
-        let t3;
-        o2 && !a2 && (t3 = p2.signature), o2 && !a2 || !c2 || (t3 = m2 ? d2.signature : new f(h2.value.buffer).getUint32(0)), u2.signature = t3;
+      const { compressed: r2, encrypted: s2, useCompressionStream: c2, zipCrypto: i2, computeCrc32: a2, level: f2, deflate64: w2, format: l2, compressionMethod: h2, inputSize: p2 } = t2, d2 = this;
+      let y2, m2, S2, g2 = super.readable;
+      const v2 = l2 && Rt(l2), z2 = (function(t3, n3, e3) {
+        return t3 && n3 ? n3 : e3 && e3.C ? e3 : void 0;
+      })(c2, o2, e2), b2 = a2 && r2 && !w2 && !v2 && (!s2 || i2) && Boolean(z2);
+      if (s2 && !i2 || !a2 || b2 || (y2 = new U(), g2 = qt(g2, y2)), r2) if (v2) g2 = Gt(g2, Lt(v2.CompressionStream, l2, { level: f2, chunkSize: n2, compressionMethod: h2, uncompressedSize: p2 }));
+      else if (b2) S2 = new jt(), g2 = Gt(g2, new z2(Tt, { level: f2, chunkSize: n2 })), g2 = qt(g2, S2);
+      else try {
+        g2 = Nt(g2, c2, { level: f2, chunkSize: n2 }, o2, e2);
+      } catch (t3) {
+        let n3;
+        try {
+          n3 = new o2(Tt);
+        } catch {
+          throw t3;
+        }
+        g2 = Gt(g2, n3), g2 = qt(g2, new jt());
+      }
+      s2 && (i2 ? g2 = qt(g2, new kt(t2)) : (m2 = new dt(t2), g2 = qt(g2, m2))), Ht(d2, g2, () => {
+        s2 && !i2 || !a2 || (d2.crc32 = b2 ? S2.crc32 : new u(y2.value.buffer).getUint32(0));
       });
     }
   }
-  class Pt extends d {
+  class jt extends d {
     constructor() {
-      let t2, e2 = 10, n2 = new o(0);
+      let t2, n2 = 10, e2 = new s(0);
       super({ transform(t3, r2) {
-        if (e2) {
-          const n3 = s.min(e2, t3.length);
-          if (e2 -= n3, !(t3 = t3.subarray(n3)).length) return;
-        }
-        const i2 = n2.length + t3.length;
-        if (8 >= i2) {
-          const e3 = new o(i2);
-          return e3.set(n2), e3.set(t3, n2.length), void (n2 = e3);
+        if (n2) {
+          const e3 = o.min(n2, t3.length);
+          if (n2 -= e3, !(t3 = t3.subarray(e3)).length) return;
         }
-        const a2 = i2 - 8, c2 = new o(a2), l2 = s.min(a2, n2.length);
-        c2.set(n2.subarray(0, l2), 0), a2 > l2 && c2.set(t3.subarray(0, a2 - l2), l2), r2.enqueue(c2);
-        const f2 = new o(8), w2 = n2.length - l2;
-        w2 && f2.set(n2.subarray(l2), 0), f2.set(t3.subarray(a2 - l2), w2), n2 = f2;
+        const s2 = e2.length + t3.length;
+        if (s2 <= 8) return void (e2 = B(e2, t3));
+        const c2 = s2 - 8, i2 = o.min(c2, e2.length);
+        r2.enqueue(B(e2.subarray(0, i2), t3.subarray(0, c2 - i2))), e2 = B(e2.subarray(i2), t3.subarray(c2 - i2));
       }, flush() {
-        const e3 = new f(n2.buffer, n2.byteOffset, n2.byteLength);
-        t2.signature = e3.getUint32(0, true), t2.uncompressedSize = e3.getUint32(4, true);
+        const n3 = T(e2);
+        t2.crc32 = n3.getUint32(0, true), t2.uncompressedSize = n3.getUint32(4, true);
       } }), t2 = this;
     }
   }
-  class Rt extends d {
-    constructor(t2, { chunkSize: e2, DecompressionStreamZlib: n2, DecompressionStream: s2 }) {
+  class Kt extends d {
+    constructor(t2, { chunkSize: n2, DecompressionStreamFallback: e2, DecompressionStream: o2 }) {
       super({});
-      const { zipCrypto: o2, encrypted: i2, signed: a2, signature: c2, compressed: l2, useCompressionStream: w2, deflate64: u2 } = t2;
-      let h2, p2, d2 = super.readable;
-      i2 && (o2 ? d2 = Dt(d2, new gt(t2)) : (p2 = new ct(t2), d2 = Dt(d2, p2))), l2 && (d2 = Wt(d2, w2, { chunkSize: e2, deflate64: u2 }, s2, n2, s2), d2 = ((t3) => {
-        const e3 = t3.getReader();
-        return new y({ async pull(t4) {
+      const { zipCrypto: c2, encrypted: i2, checkCrc32: a2, crc32: f2, compressed: l2, useCompressionStream: h2, deflate64: p2, format: m2, compressionMethod: S2, rawBitFlag: g2, outputSize: z2 } = t2;
+      let b2, k2, C2, I2 = super.readable;
+      if (i2 && (c2 ? I2 = qt(I2, new bt(t2)) : (k2 = new pt(t2), I2 = qt(I2, k2))), l2) {
+        const t3 = m2 && Rt(m2);
+        if (t3) I2 = Gt(I2, Lt(t3.DecompressionStream, m2, { chunkSize: n2, compressionMethod: S2, rawBitFlag: g2, uncompressedSize: z2 }));
+        else try {
+          I2 = Nt(I2, h2, { chunkSize: n2, deflate64: p2 }, o2, e2);
+        } catch (t4) {
+          if (p2 || z2 === v) throw t4;
           let n3;
           try {
-            n3 = await e3.read();
-          } catch (t5) {
-            if (t5 && t5.message) throw t5;
-            const e4 = new r("Invalid compressed data");
-            throw e4.cause = t5, e4;
+            n3 = new o2(Tt);
+          } catch {
+            throw t4;
           }
-          const { value: s3, done: o3 } = n3;
-          o3 ? t4.close() : t4.enqueue(s3);
-        }, cancel: (t4) => e3.cancel(t4) });
-      })(d2)), i2 && !o2 || !a2 || (h2 = new _(), d2 = Dt(d2, h2)), Ut(this, d2, () => {
-        if ((!i2 || o2) && a2) {
-          const t3 = new f(h2.value.buffer);
-          if (c2 != t3.getUint32(0, false)) throw new r(L);
+          C2 = new R(), I2 = (function(t5, n4, e3, o3) {
+            let c3, i3, a3, f3 = 0, u2 = false;
+            const l3 = new w((t6, n5) => {
+              i3 = t6, a3 = n5;
+            });
+            l3.catch(() => {
+            }), e3 || i3();
+            const h3 = new d({ start(t6) {
+              const n5 = new s(10);
+              n5.set(Vt), t6.enqueue(n5);
+            }, transform(t6, n5) {
+              n5.enqueue(t6);
+            }, async flush(t6) {
+              u2 = true, y2();
+              try {
+                await l3;
+              } finally {
+                m3();
+              }
+              const n5 = new s(8), r2 = T(n5);
+              r2.setUint32(0, o3.get(), true), r2.setUint32(4, e3, true), t6.enqueue(n5);
+            }, cancel(t6) {
+              a3(t6);
+            } }), p3 = new d({ transform(t6, n5) {
+              o3.append(t6), f3 += t6.length, f3 >= e3 ? i3() : u2 && y2(), n5.enqueue(t6);
+            }, cancel(t6) {
+              a3(t6);
+            } });
+            return t5 = qt(t5, h3), qt(t5 = Gt(t5, n4), p3);
+            function y2() {
+              m3(), c3 = setTimeout(() => a3(new r(Ut)), 5e3);
+            }
+            function m3() {
+              clearTimeout(c3);
+            }
+          })(I2, n3, z2, C2);
+        }
+        I2 = (function(t4) {
+          const n3 = t4.getReader();
+          return new y({ async pull(t5) {
+            let e3;
+            try {
+              e3 = await n3.read();
+            } catch (t6) {
+              if (t6 && t6.message) throw t6;
+              const n4 = new r("Invalid compressed data");
+              throw n4.cause = t6, n4;
+            }
+            const { value: o3, done: s2 } = e3;
+            s2 ? t5.close() : t5.enqueue(o3);
+          }, cancel: (t5) => n3.cancel(t5) });
+        })(I2);
+      }
+      a2 && !C2 && (b2 = new U(), I2 = qt(I2, b2)), Ht(this, I2, () => {
+        if (a2) {
+          const t3 = C2 ? C2.get() >>> 0 : new u(b2.value.buffer).getUint32(0, false);
+          if (f2 != t3) throw new r("Invalid CRC32");
         }
       });
     }
   }
-  function Ut(t2, n2, s2) {
-    n2 = Dt(n2, new d({ flush: s2 })), e.defineProperty(t2, "readable", { get: () => n2 });
+  const Ot = new f();
+  function Ht(t2, e2, o2) {
+    e2 = qt(e2, new d({ flush: o2 })), n.defineProperty(t2, "readable", { get: () => e2 });
   }
-  function Wt(t2, e2, n2, s2, r2, o2) {
-    const i2 = e2 && s2 ? s2 : r2 || o2, a2 = n2.deflate64 ? "deflate64-raw" : "deflate-raw";
-    let c2;
+  function Lt(t2, n2, e2) {
+    if (!t2) throw new r("Compression method not supported");
+    return new t2(n2, e2);
+  }
+  function Nt(t2, n2, e2, o2, r2) {
+    const s2 = n2 && o2 ? o2 : r2 || o2, c2 = e2.deflate64 ? "deflate64-raw" : Bt;
+    let i2;
     try {
-      c2 = new i2(a2, n2);
+      i2 = new s2(c2, e2);
     } catch (t3) {
-      if (!e2) throw t3;
-      if (r2) c2 = new r2(a2, n2);
-      else {
-        if (!o2) throw t3;
-        c2 = new o2(a2, n2);
-      }
+      if (!n2 || !r2 || s2 == r2) throw t3;
+      i2 = new r2(c2, e2);
     }
-    return Mt(t2, c2);
+    return Gt(t2, i2);
   }
-  function Dt(t2, e2) {
-    return t2.pipeThrough(e2);
+  function qt(t2, n2) {
+    return Ft(t2).pipeThrough(n2);
   }
-  function Mt(t2, e2) {
-    const n2 = e2.writable.getWriter(), s2 = t2.getReader();
-    return (async () => {
+  function Gt(t2, n2) {
+    const e2 = n2.writable.getWriter(), o2 = t2.getReader();
+    return (async function() {
       try {
         for (; ; ) {
-          await n2.ready;
-          const t3 = await s2.read();
+          await e2.ready;
+          const t3 = await o2.read();
           if (t3.done) {
-            await n2.close();
+            await e2.close();
             break;
           }
-          await n2.write(t3.value);
+          await e2.write(t3.value);
         }
       } catch (t3) {
-        await (async (t4, e3) => {
+        await (async function(t4, n3) {
           try {
-            await t4.abort(e3);
+            await t4.abort(n3);
           } catch {
           }
-        })(n2, t3), await (async (t4, e3) => {
+        })(e2, t3), await (async function(t4, n3) {
           try {
-            await t4.cancel(e3);
+            await t4.cancel(n3);
           } catch {
           }
-        })(s2, t3);
+        })(o2, t3);
       }
-    })(), e2.readable;
+    })(), n2.readable;
   }
-  const _t = "data", Bt = "close";
-  class Tt extends d {
-    constructor(t2, n2) {
+  const Jt = "data", Qt = "deflate";
+  class Xt extends d {
+    constructor(t2, e2) {
       super({});
-      const s2 = this, { codecType: o2 } = t2;
-      let i2;
-      o2.startsWith("deflate") ? i2 = xt : o2.startsWith("inflate") && (i2 = Rt), s2.outputSize = 0;
-      let a2 = 0;
-      const c2 = new i2(t2, n2), l2 = super.readable, f2 = new d({ transform(t3, e2) {
-        t3 && t3.length && (a2 += t3.length, e2.enqueue(t3));
+      const o2 = this, { codecType: s2 } = t2;
+      let c2;
+      s2.startsWith(Qt) ? c2 = Wt : s2.startsWith("inflate") && (c2 = Kt), o2.outputSize = 0;
+      let i2 = 0;
+      const a2 = new c2(t2, e2), f2 = super.readable, u2 = new d({ transform(t3, n2) {
+        t3 && t3.length && (i2 += t3.length, n2.enqueue(t3));
       }, flush() {
-        e.assign(s2, { inputSize: a2 });
-      } }), w2 = new d({ transform(e2, n3) {
-        if (e2 && e2.length && (n3.enqueue(e2), s2.outputSize += e2.length, t2.outputSize !== b && s2.outputSize > t2.outputSize)) throw new r("Invalid uncompressed size");
+        n.assign(o2, { inputSize: i2 });
+      } }), w2 = new d({ transform(n2, e3) {
+        if (n2 && n2.length && (e3.enqueue(n2), o2.outputSize += n2.length, t2.outputSize !== v && o2.outputSize > t2.outputSize)) throw new r(Ut);
       }, flush() {
-        const { signature: t3 } = c2;
-        e.assign(s2, { signature: t3, inputSize: a2 });
+        const { crc32: t3 } = a2;
+        n.assign(o2, { crc32: t3, inputSize: i2 });
       } });
-      e.defineProperty(s2, "readable", { get: () => l2.pipeThrough(f2).pipeThrough(c2).pipeThrough(w2) });
+      n.defineProperty(o2, "readable", { get: () => f2.pipeThrough(u2).pipeThrough(a2).pipeThrough(w2) });
     }
   }
-  class Vt extends d {
+  class Yt extends d {
     constructor(t2) {
-      let e2;
-      1 > t2 && (t2 = 65536), super({ transform: (n2, s2) => {
-        if (e2) {
-          const t3 = new o(e2.length + n2.length);
-          t3.set(e2), t3.set(n2, e2.length), n2 = t3, e2 = null;
+      const o2 = [];
+      let r2 = 0, c2 = 0;
+      function i2() {
+        const n2 = new s(t2);
+        let e2 = 0;
+        for (; e2 < t2; ) {
+          const r3 = o2[0], s2 = t2 - e2;
+          r3.length <= s2 ? (n2.set(r3, e2), e2 += r3.length, o2.shift()) : (n2.set(r3.subarray(0, s2), e2), o2[0] = r3.subarray(s2), e2 += s2);
         }
-        let r2 = 0;
-        for (; n2.length - r2 > t2; ) s2.enqueue(n2.slice(r2, r2 + t2)), r2 += t2;
-        e2 = r2 ? n2.slice(r2) : n2;
+        return r2 -= t2, n2;
+      }
+      (!e.isFinite(t2) || t2 < 1) && (t2 = 65536), super({ transform(n2, e2) {
+        for (o2.push(n2), r2 += n2.length; r2 > t2; ) c2 += t2, e2.enqueue(i2());
       }, flush(t3) {
-        e2 && e2.length && t3.enqueue(e2);
-      } });
+        r2 && (c2 += r2, t3.enqueue((function(t4, n2) {
+          const e2 = new s(n2);
+          let o3 = 0;
+          for (const n3 of t4) e2.set(n3, o3), o3 += n3.length;
+          return e2;
+        })(o2, r2)));
+      } }), n.defineProperty(this, "outputSize", { get: () => c2 });
     }
   }
-  let Kt = 2;
+  let Zt = 2;
   try {
-    typeof navigator != k && navigator.hardwareConcurrency && (Kt = navigator.hardwareConcurrency);
+    typeof navigator != z && navigator.hardwareConcurrency && (Zt = navigator.hardwareConcurrency);
   } catch {
   }
-  const jt = { workerURI: "./core/web-worker-wasm.js", wasmURI: "./core/streams/zlib-wasm/zlib-streams.wasm", chunkSize: 65536, maxWorkers: Kt, terminateWorkerTimeout: 5e3, workerStarvationTimeout: 5e3, useWebWorkers: true, useCompressionStream: true, CompressionStream: typeof g != k && g, DecompressionStream: typeof S != k && S };
-  e.assign({}, jt);
-  const Et = new l(), Lt = new l();
-  let Ot, Ht, Zt, Ft, Nt, qt = 0;
-  async function Gt(t2) {
-    let e2, r2;
+  function $t(t2) {
+    return Boolean(t2) && "object" == typeof t2;
+  }
+  const _t = new f(), tn = new f(), nn = (function() {
     try {
-      const { options: o2, config: i2 } = t2;
-      if (!o2.useCompressionStream) try {
+      return structuredClone(new r()) instanceof r;
+    } catch {
+      return false;
+    }
+  })();
+  let en = 0;
+  async function on(t2) {
+    let n2, s2, c2;
+    try {
+      const { options: i2, config: a2 } = t2;
+      if (i2.format) try {
+        await (async function(t3, n3) {
+          !Et.has(t3) && n3 && (function(t4, n4) {
+            const { CompressionStream: e2, DecompressionStream: o2 } = n4;
+            if (typeof e2 != b && typeof o2 != b) throw new r("Invalid codec module");
+            Et.set(t4, { CompressionStream: e2, DecompressionStream: o2 });
+          })(t3, await import(
+            /* webpackIgnore: true */
+            /* @vite-ignore */
+            n3
+          ));
+        })(i2.format, i2.codecURI);
+      } catch (t3) {
+        if ($t(t3)) try {
+          t3.codecImportFailed = true;
+        } catch {
+        }
+        throw t3;
+      }
+      if (a2.CompressionStream = self.CompressionStream, a2.DecompressionStream = self.DecompressionStream, i2.compressed && !i2.format) if (i2.useCompressionStream) {
+        if (!(function(t3, n3) {
+          if (!t3) return false;
+          let e2 = Ot.get(t3);
+          e2 || (e2 = new f(), Ot.set(t3, e2));
+          let o2 = e2.get(n3);
+          if (o2 === v) {
+            try {
+              new t3(n3), o2 = true;
+            } catch {
+              o2 = false;
+            }
+            e2.set(n3, o2);
+          }
+          return o2;
+        })(i2.codecType.startsWith(Qt) ? a2.CompressionStream : a2.DecompressionStream, Bt)) try {
+          await self.initModule(t2.config);
+        } catch {
+        }
+      } else try {
         await self.initModule(t2.config);
       } catch {
-        o2.useCompressionStream = true;
+        i2.useCompressionStream = true;
       }
-      i2.CompressionStream = self.CompressionStream, i2.DecompressionStream = self.DecompressionStream;
-      const a2 = { highWaterMark: 1 }, c2 = t2.readable || new y({ async pull(t3) {
-        const e3 = new w((t4) => Et.set(qt, t4));
-        Jt({ type: "pull", messageId: qt }), qt = (qt + 1) % n.MAX_SAFE_INTEGER;
-        const { value: s2, done: r3 } = await e3;
-        t3.enqueue(s2), r3 && t3.close();
-      } }, a2);
-      r2 = t2.writable || new m({ async write(t3) {
-        let e3;
-        const s2 = new w((t4) => e3 = t4);
-        Lt.set(qt, e3), Jt({ type: _t, value: t3, messageId: qt }), qt = (qt + 1) % n.MAX_SAFE_INTEGER, await s2;
-      } }, a2), e2 = new Tt(o2, i2), Ot = new AbortController();
-      const { signal: l2 } = Ot;
-      await c2.pipeThrough(e2).pipeThrough(new Vt(((t3) => s.max(t3.chunkSize, 64))(i2))).pipeTo(r2, { signal: l2, preventClose: true, preventAbort: true }), await r2.getWriter().close();
-      const { signature: f2, inputSize: u2, outputSize: h2 } = e2;
-      Jt({ type: Bt, result: { signature: f2, inputSize: u2, outputSize: h2 } });
+      if (i2.encrypted && !i2.zipCrypto) try {
+        await self.initModule(t2.config);
+      } catch {
+      }
+      !a2.CompressionStreamFallback && a2.CompressionStreamZlib && (a2.CompressionStreamFallback = a2.CompressionStreamZlib), !a2.DecompressionStreamFallback && a2.DecompressionStreamZlib && (a2.DecompressionStreamFallback = a2.DecompressionStreamZlib);
+      const u2 = { highWaterMark: 1 }, l2 = t2.readable ? Ft(t2.readable) : new y({ async pull(t3) {
+        const n3 = new w((t4) => _t.set(en, t4));
+        rn({ type: "pull", messageId: en }), en = (en + 1) % e.MAX_SAFE_INTEGER;
+        const { value: o2, done: r2 } = await n3;
+        t3.enqueue(o2), r2 && t3.close();
+      } }, u2);
+      c2 = t2.writable ? (function(t3) {
+        if (t3 instanceof m) return t3;
+        const n3 = t3.getWriter();
+        return new m({ write: (t4) => n3.write(t4), close: () => n3.close(), abort: (t4) => n3.abort(t4) });
+      })(t2.writable) : new m({ async write(t3) {
+        let n3;
+        const o2 = new w((t4) => n3 = t4);
+        tn.set(en, n3), rn({ type: Jt, value: t3, messageId: en }), en = (en + 1) % e.MAX_SAFE_INTEGER, await o2;
+      } }, u2), n2 = new Xt(i2, a2), s2 = new Yt((function(t3) {
+        return r2 = "string" == typeof (n3 = r2 = t3.chunkSize) && n3.trim() ? e(n3) : n3, e.isInteger(r2) && r2 >= 1 ? o.max(r2, 64) : 65536;
+        var n3, r2;
+      })(a2)), await l2.pipeThrough(n2).pipeThrough(s2).pipeTo(c2, { preventClose: true, preventAbort: true }), await c2.getWriter().close();
+      const { crc32: h2, inputSize: p2, outputSize: d2 } = n2;
+      rn({ type: "close", result: { crc32: h2, inputSize: p2, outputSize: d2 } });
     } catch (t3) {
-      if (t3.outputSize = e2 ? e2.outputSize : 0, r2 && !r2.locked) try {
-        await r2.getWriter().close();
+      const n3 = s2 ? s2.outputSize : 0;
+      if ($t(t3)) try {
+        t3.outputSize = n3;
       } catch {
       }
-      Qt(t3);
+      if (c2 && !c2.locked) try {
+        await c2.getWriter().close();
+      } catch {
+      }
+      sn(t3, n3);
     }
   }
-  function Jt(t2) {
-    let { value: e2 } = t2;
-    if (e2) if (e2.length) try {
-      e2 = new o(e2), t2.value = e2.buffer, p(t2, [t2.value]);
+  function rn(t2) {
+    const { value: n2 } = t2;
+    if (n2) if (n2.length) try {
+      t2.value = (e2 = n2, e2.byteOffset || e2.byteLength != e2.buffer.byteLength ? new s(e2) : e2).buffer, p(t2, [t2.value]);
     } catch {
       p(t2);
     }
     else p(t2);
     else p(t2);
+    var e2;
+  }
+  function sn(t2, n2) {
+    const { message: e2, stack: o2, code: s2, name: c2, outputSize: i2, cause: a2, codecImportFailed: f2 } = (function(t3 = new r("Unknown error")) {
+      return $t(t3) ? t3 : new r(String(t3));
+    })(t2), u2 = { message: e2, stack: o2, code: s2, name: c2, outputSize: i2 === v ? n2 : i2 };
+    if (a2 && (u2.cause = { name: a2.name, message: a2.message }), f2 && (u2.codecImportFailed = true), nn) try {
+      return void p({ error: u2, errorValue: { value: t2 } });
+    } catch {
+    }
+    p({ error: u2 });
   }
-  function Qt(t2 = new r("Unknown error")) {
-    const { message: e2, stack: n2, code: s2, name: o2, outputSize: i2 } = t2;
-    p({ error: { message: e2, stack: n2, code: s2, name: o2, outputSize: i2 } });
-  }
-  function Xt(t2, e2, n2 = {}) {
-    const i2 = "number" == typeof n2.level ? n2.level : -1, a2 = "number" == typeof n2.outBuffer ? n2.outBuffer : 65536, c2 = "number" == typeof n2.inBufferSize ? n2.inBufferSize : 65536;
+  addEventListener("message", ({ data: t2 }) => {
+    const { type: n2, messageId: e2, value: o2, done: r2 } = t2;
+    try {
+      if ("start" == n2 && on(t2), n2 == Jt) {
+        const t3 = _t.get(e2);
+        _t.delete(e2), t3({ value: o2 || new s(), done: r2 });
+      }
+      if ("ack" == n2) {
+        const t3 = tn.get(e2);
+        tn.delete(e2), t3();
+      }
+    } catch (t3) {
+      sn(t3);
+    }
+  }), p({ type: "ready" });
+  const cn = "deflate", an = "deflate-raw", fn = "deflate64-raw", un = "gzip";
+  let wn, ln, hn, pn, dn;
+  function yn(t2, n2, e2 = {}) {
+    if (!wn) {
+      const t3 = new r("WASM module not loaded");
+      throw t3.cause = dn, t3;
+    }
+    const c2 = "number" == typeof e2.level ? e2.level : -1, i2 = "number" == typeof e2.outBuffer ? e2.outBuffer : 65536, a2 = "number" == typeof e2.inBufferSize ? e2.inBufferSize : 65536;
     return new d({ start() {
       try {
-        let n3;
-        if (this.et = Zt(a2), this.in = Zt(c2), this.inBufferSize = c2, !this.et || !this.in) throw new r("allocation failed");
-        if (this.nt = new o(a2), t2 ? (this.st = Ht.deflate_process, this.rt = Ht.deflate_last_consumed, this.ot = Ht.deflate_end, this.it = Ht.deflate_new(), n3 = "gzip" === e2 ? Ht.deflate_init_gzip(this.it, i2) : "deflate-raw" === e2 ? Ht.deflate_init_raw(this.it, i2) : Ht.deflate_init(this.it, i2)) : "deflate64-raw" === e2 ? (this.st = Ht.inflate9_process, this.rt = Ht.inflate9_last_consumed, this.ot = Ht.inflate9_end, this.it = Ht.inflate9_new(), n3 = Ht.inflate9_init_raw(this.it)) : (this.st = Ht.inflate_process, this.rt = Ht.inflate_last_consumed, this.ot = Ht.inflate_end, this.it = Ht.inflate_new(), n3 = "deflate-raw" === e2 ? Ht.inflate_init_raw(this.it) : "gzip" === e2 ? Ht.inflate_init_gzip(this.it) : Ht.inflate_init(this.it)), 0 !== n3) throw new r("init failed:" + n3);
+        let e3;
+        if (this.I = ln(i2), this.in = ln(a2), this.inBufferSize = a2, !this.I || !this.in) throw new r("allocation failed");
+        if (t2 ? (this.A = wn.deflate_process, this.M = wn.deflate_last_consumed, this.P = wn.deflate_end, this.D = wn.deflate_new(), e3 = n2 === un ? wn.deflate_init_gzip(this.D, c2) : n2 === an ? wn.deflate_init_raw(this.D, c2) : wn.deflate_init(this.D, c2)) : n2 === fn ? (this.A = wn.inflate9_process, this.M = wn.inflate9_last_consumed, this.P = wn.inflate9_end, this.D = wn.inflate9_new(), e3 = wn.inflate9_init_raw(this.D)) : (this.A = wn.inflate_process, this.M = wn.inflate_last_consumed, this.P = wn.inflate_end, this.D = wn.inflate_new(), e3 = n2 === an ? wn.inflate_init_raw(this.D) : n2 === un ? wn.inflate_init_gzip(this.D) : wn.inflate_init(this.D)), 0 !== e3) throw new r("init failed:" + e3);
       } catch (t3) {
-        throw l2(this), t3;
+        throw f2(this), t3;
       }
-    }, transform(e3, n3) {
+    }, transform(t3, n3) {
       try {
-        const i3 = e3, c3 = new o(Nt.buffer), l3 = this.st, f2 = this.rt, w2 = this.et, u2 = this.nt;
-        let h2 = 0;
-        for (; h2 < i3.length; ) {
-          const e4 = s.min(i3.length - h2, 32768);
-          if ((!this.in || this.inBufferSize < e4) && (this.in && Ft && (Ft(this.in), this.in = 0), this.in = Zt(e4), this.inBufferSize = e4, !this.in)) throw new r("allocation failed");
-          c3.set(i3.subarray(h2, h2 + e4), this.in);
-          const o2 = l3(this.it, this.in, e4, w2, a2, 0), p2 = 16777215 & o2;
-          if (p2 && (u2.set(c3.subarray(w2, w2 + p2), 0), n3.enqueue(u2.slice(0, p2))), !t2) {
-            const t3 = o2 >> 24 & 255, e5 = 128 & t3 ? t3 - 256 : t3;
-            if (0 > e5) throw new r("process error:" + e5);
-          }
-          const d2 = f2(this.it);
-          if (0 === d2) break;
-          h2 += d2;
+        const e3 = t3, c3 = new s(pn.buffer), a3 = this.A, f3 = this.M, u2 = this.I;
+        let w2 = 0;
+        for (; w2 < e3.length; ) {
+          const t4 = o.min(e3.length - w2, 32768);
+          if ((!this.in || this.inBufferSize < t4) && (this.in && hn && (hn(this.in), this.in = 0), this.in = ln(t4), this.inBufferSize = t4, !this.in)) throw new r("allocation failed");
+          c3.set(e3.subarray(w2, w2 + t4), this.in);
+          const s2 = a3(this.D, this.in, t4, u2, i2, 0), l2 = s2 >> 24 & 255, h2 = 128 & l2 ? l2 - 256 : l2;
+          if (h2 < 0) throw new r("process error:" + h2);
+          const p2 = 16777215 & s2;
+          p2 && n3.enqueue(c3.slice(u2, u2 + p2));
+          const d2 = f3(this.D);
+          if (0 === d2 && 0 === p2) break;
+          w2 += d2;
         }
-      } catch (t3) {
-        l2(this), n3.error(t3);
+      } catch (t4) {
+        f2(this), n3.error(t4);
       }
-    }, flush(e3) {
+    }, flush(t3) {
       try {
-        const n3 = new o(Nt.buffer), s2 = this.st, i3 = this.et, c3 = this.nt;
+        const n3 = new s(pn.buffer), e3 = this.A, o2 = this.I;
         for (; ; ) {
-          const o2 = s2(this.it, 0, 0, i3, a2, 4), l3 = 16777215 & o2, f2 = o2 >> 24 & 255;
-          if (!t2) {
-            const t3 = 128 & f2 ? f2 - 256 : f2;
-            if (0 > t3) throw new r("process error:" + t3);
-          }
-          if (l3 && (c3.set(n3.subarray(i3, i3 + l3), 0), e3.enqueue(c3.slice(0, l3))), 1 === f2 || 0 === l3) break;
+          const s2 = e3(this.D, 0, 0, o2, i2, 4), c3 = s2 >> 24 & 255, a3 = 128 & c3 ? c3 - 256 : c3;
+          if (a3 < 0) throw new r("process error:" + a3);
+          const f3 = 16777215 & s2;
+          if (f3 && t3.enqueue(n3.slice(o2, o2 + f3)), 1 === c3 || 0 === f3) break;
         }
-      } catch (t3) {
-        e3.error(t3);
+      } catch (n3) {
+        t3.error(n3);
       } finally {
-        const t3 = l2(this);
-        0 !== t3 && e3.error(new r("end error:" + t3));
+        const n3 = f2(this);
+        0 !== n3 && t3.error(new r("end error:" + n3));
       }
     }, cancel() {
-      l2(this);
+      f2(this);
     } });
-    function l2(t3) {
-      let e3 = 0;
-      return t3.it && t3.ot && (e3 = t3.ot(t3.it)), t3.it = 0, t3.in && Ft && Ft(t3.in), t3.in = 0, t3.et && Ft && Ft(t3.et), t3.et = 0, e3;
-    }
-  }
-  addEventListener("message", ({ data: t2 }) => {
-    const { type: e2, messageId: n2, value: s2, done: r2 } = t2;
-    try {
-      if ("start" == e2 && Gt(t2), e2 == _t) {
-        const t3 = Et.get(n2);
-        Et.delete(n2), t3({ value: new o(s2), done: r2 });
+    function f2(t3) {
+      let n3 = 0;
+      return t3.D && t3.P && (n3 = t3.P(t3.D)), t3.D = 0, t3.in && hn && hn(t3.in), t3.in = 0, t3.I && hn && hn(t3.I), t3.I = 0, n3;
+    }
+  }
+  class mn {
+    constructor(t2 = cn, n2) {
+      return yn(true, t2, n2);
+    }
+  }
+  class Sn {
+    constructor(t2 = cn, n2) {
+      return yn(false, t2, n2);
+    }
+  }
+  mn.C = true, Sn.C = true, mn.F = [cn, an, un], Sn.F = [cn, an, un, fn];
+  const gn = 65536;
+  let vn, zn;
+  function bn(t2) {
+    return new s(t2.memory.buffer);
+  }
+  let kn = false;
+  !(function(t2 = {}) {
+    const { init: n2, R: e2 } = t2, o2 = t2.CompressionStreamFallback || t2.CompressionStreamZlib, r2 = t2.DecompressionStreamFallback || t2.DecompressionStreamZlib;
+    e2 && (ht = e2 || Q), self.initModule = async (t3) => {
+      n2 && await n2(t3), o2 && (t3.CompressionStreamFallback = o2), r2 && (t3.DecompressionStreamFallback = r2);
+    };
+  })({ CompressionStreamFallback: mn, DecompressionStreamFallback: Sn, R: function(t2, n2) {
+    const e2 = vn;
+    let o2 = e2 ? (function(t3, n3, e3) {
+      zn || (zn = t3.malloc(gn));
+      const o3 = zn ? t3.aes_hmac_new() : 0;
+      if (o3) {
+        const r3 = bn(t3);
+        if (r3.set(n3, zn), r3.set(e3, zn + n3.length), t3.aes_hmac_init(o3, zn, n3.length, zn + n3.length, e3.length)) return t3.aes_hmac_end(o3, 0), 0;
       }
-      if ("ack" == e2) {
-        const t3 = Lt.get(n2);
-        Lt.delete(n2), t3();
+      return o3;
+    })(e2, t2, n2) : 0;
+    if (!o2) return Q(t2, n2);
+    const r2 = zn;
+    return { process(t3, n3) {
+      for (let s2 = 0; s2 < t3.length; s2 += gn) {
+        const c2 = t3.subarray(s2, s2 + gn), i2 = bn(e2);
+        i2.set(c2, r2), e2.aes_hmac_process(o2, r2, c2.length, n3 ? 1 : 0), c2.set(i2.subarray(r2, r2 + c2.length));
       }
-      e2 == Bt && Ot.abort();
-    } catch (t3) {
-      Qt(t3);
-    }
-  });
-  class Yt {
-    constructor(t2 = "deflate", e2) {
-      return Xt(true, t2, e2);
-    }
-  }
-  class $t {
-    constructor(t2 = "deflate", e2) {
-      return Xt(false, t2, e2);
-    }
-  }
-  Yt.ct = true, $t.ct = true;
-  let te = false;
-  self.initModule = async (t2) => {
-    try {
-      const e2 = await (async (t3, { baseURI: e3 }) => {
-        if (!te) {
-          let n2, s2;
+    }, digest: () => (e2.aes_hmac_end(o2, r2), o2 = 0, bn(e2).slice(r2, r2 + 20)), dispose() {
+      o2 && (e2.aes_hmac_end(o2, 0), o2 = 0);
+    } };
+  }, init: (t2) => (async function(t3, { baseURI: n2 }) {
+    if (!kn) try {
+      await (async function(t4, n3) {
+        let e2, o2;
+        try {
           try {
-            try {
-              s2 = new URL(t3, e3);
-            } catch {
-            }
-            const r2 = await fetch(s2);
-            n2 = await r2.arrayBuffer();
-          } catch (e4) {
-            if (!t3.startsWith("data:application/wasm;base64,")) throw e4;
-            n2 = ((t4) => {
-              const e5 = t4.split(",")[1], n3 = atob(e5), s3 = n3.length, r2 = new o(s3);
-              for (let t5 = 0; s3 > t5; ++t5) r2[t5] = n3.charCodeAt(t5);
-              return r2.buffer;
-            })(t3);
+            o2 = new URL(t4, n3);
+          } catch {
           }
-          ((t4) => {
-            if (Ht = t4, { malloc: Zt, free: Ft, memory: Nt } = Ht, "function" != typeof Zt || "function" != typeof Ft || !Nt) throw Ht = Zt = Ft = Nt = null, new r("Invalid WASM module");
-          })((await WebAssembly.instantiate(n2)).instance.exports), te = true;
+          const r2 = await fetch(o2);
+          e2 = await r2.arrayBuffer();
+        } catch (n4) {
+          if (!t4.startsWith("data:application/wasm;base64,")) throw n4;
+          e2 = (function(t5) {
+            const n5 = t5.split(",")[1], e3 = atob(n5), o3 = e3.length, r2 = new s(o3);
+            for (let t6 = 0; t6 < o3; ++t6) r2[t6] = e3.charCodeAt(t6);
+            return r2.buffer;
+          })(t4);
         }
-      })(t2.wasmURI, t2);
-      return t2.CompressionStreamZlib = Yt, t2.DecompressionStreamZlib = $t, e2;
-    } catch {
-    }
-  };
+        const c2 = await WebAssembly.instantiate(e2);
+        var i2;
+        (function(t5) {
+          if (wn = t5, { malloc: ln, free: hn, memory: pn } = wn, "function" != typeof ln || "function" != typeof hn || !pn) throw wn = ln = hn = pn = null, new r("Invalid WASM module");
+        })(c2.instance.exports), typeof (i2 = c2.instance.exports).aes_hmac_new == b && (vn = i2, zn = 0);
+      })(t3, n2), kn = true;
+    } catch (t4) {
+      throw (function(t5) {
+        dn = t5;
+      })(t4), t4;
+    }
+  })(t2.wasmURI, t2) });
 })();