(function () {
  "use strict";
  const {
      Array: te,
      Object: m,
      Number: ne,
      Math: A,
      Error: v,
      Uint8Array: w,
      Uint16Array: nt,
      Uint32Array: se,
      Int32Array: st,
      Map: re,
      DataView: W,
      Promise: M,
      TextEncoder: ae,
      crypto: B,
      postMessage: K,
      TransformStream: b,
      ReadableStream: Ve,
      WritableStream: xe,
      CompressionStream: rt,
      DecompressionStream: at,
    } = self,
    j = void 0,
    N = "undefined",
    O = "function";
  class oe {
    constructor(e) {
      return class extends b {
        constructor(n, s) {
          const r = new e(s);
          super({
            transform(a, o) {
              o.enqueue(r.append(a));
            },
            flush(a) {
              const o = r.flush();
              o && a.enqueue(o);
            },
          });
        }
      };
    }
  }
  const ie = [];
  for (let t = 0; 256 > t; t++) {
    let e = t;
    for (let n = 0; 8 > n; n++)
      1 & e ? (e = (e >>> 1) ^ 3988292384) : (e >>>= 1);
    ie[t] = e;
  }
  class G {
    constructor(e) {
      this.crc = e || -1;
    }
    append(e) {
      let n = 0 | this.crc;
      for (let s = 0, r = 0 | e.length; r > s; s++)
        n = (n >>> 8) ^ ie[255 & (n ^ e[s])];
      this.crc = n;
    }
    get() {
      return ~this.crc;
    }
  }
  class ce extends b {
    constructor() {
      let e;
      const n = new G();
      (super({
        transform(s, r) {
          (n.append(s), r.enqueue(s));
        },
        flush() {
          const s = new w(4);
          (new W(s.buffer).setUint32(0, n.get()), (e.value = s));
        },
      }),
        (e = this));
    }
  }
  const _ = {
      concat(t, e) {
        if (t.length === 0 || e.length === 0) return t.concat(e);
        const n = t[t.length - 1],
          s = _.getPartial(n);
        return s === 32
          ? t.concat(e)
          : _._shiftRight(e, s, 0 | n, t.slice(0, t.length - 1));
      },
      bitLength(t) {
        const e = t.length;
        if (e === 0) return 0;
        const n = t[e - 1];
        return 32 * (e - 1) + _.getPartial(n);
      },
      clamp(t, e) {
        if (32 * t.length < e) return t;
        const n = (t = t.slice(0, A.ceil(e / 32))).length;
        return (
          (e &= 31),
          n > 0 &&
            e &&
            (t[n - 1] = _.partial(e, t[n - 1] & (2147483648 >> (e - 1)), 1)),
          t
        );
      },
      partial: (t, e, n) =>
        t === 32 ? e : (n ? 0 | e : e << (32 - t)) + 1099511627776 * t,
      getPartial: (t) => A.round(t / 1099511627776) || 32,
      _shiftRight(t, e, n, s) {
        for (s === void 0 && (s = []); e >= 32; e -= 32) (s.push(n), (n = 0));
        if (e === 0) return s.concat(t);
        for (let o = 0; o < t.length; o++)
          (s.push(n | (t[o] >>> e)), (n = t[o] << (32 - e)));
        const r = t.length ? t[t.length - 1] : 0,
          a = _.getPartial(r);
        return (
          s.push(_.partial((e + a) & 31, e + a > 32 ? n : s.pop(), 1)),
          s
        );
      },
    },
    L = {
      bytes: {
        fromBits(t) {
          const e = _.bitLength(t) / 8,
            n = new w(e);
          let s;
          for (let r = 0; e > r; r++)
            (3 & r || (s = t[r / 4]), (n[r] = s >>> 24), (s <<= 8));
          return n;
        },
        toBits(t) {
          const e = [];
          let n,
            s = 0;
          for (n = 0; n < t.length; n++)
            ((s = (s << 8) | t[n]), 3 & ~n || (e.push(s), (s = 0)));
          return (3 & n && e.push(_.partial(8 * (3 & n), s)), e);
        },
      },
    },
    Ee = class {
      constructor(t) {
        const e = this;
        ((e.blockSize = 512),
          (e._init = [
            1732584193, 4023233417, 2562383102, 271733878, 3285377520,
          ]),
          (e._key = [1518500249, 1859775393, 2400959708, 3395469782]),
          t
            ? ((e._h = t._h.slice(0)),
              (e._buffer = t._buffer.slice(0)),
              (e._length = t._length))
            : e.reset());
      }
      reset() {
        const t = this;
        return (
          (t._h = t._init.slice(0)),
          (t._buffer = []),
          (t._length = 0),
          t
        );
      }
      update(t) {
        const e = this;
        typeof t == "string" && (t = L.utf8String.toBits(t));
        const n = (e._buffer = _.concat(e._buffer, t)),
          s = e._length,
          r = (e._length = s + _.bitLength(t));
        if (r > 9007199254740991)
          throw new v("Cannot hash more than 2^53 - 1 bits");
        const a = new se(n);
        let o = 0;
        for (
          let l = e.blockSize + s - ((e.blockSize + s) & (e.blockSize - 1));
          r >= l;
          l += e.blockSize
        )
          (e._block(a.subarray(16 * o, 16 * (o + 1))), (o += 1));
        return (n.splice(0, 16 * o), e);
      }
      finalize() {
        const t = this;
        let e = t._buffer;
        const n = t._h;
        e = _.concat(e, [_.partial(1, 1)]);
        for (let s = e.length + 2; 15 & s; s++) e.push(0);
        for (
          e.push(A.floor(t._length / 4294967296)), e.push(0 | t._length);
          e.length;
        )
          t._block(e.splice(0, 16));
        return (t.reset(), n);
      }
      _f(t, e, n, s) {
        return t > 19
          ? t > 39
            ? t > 59
              ? t > 79
                ? void 0
                : e ^ n ^ s
              : (e & n) | (e & s) | (n & s)
            : e ^ n ^ s
          : (e & n) | (~e & s);
      }
      _S(t, e) {
        return (e << t) | (e >>> (32 - t));
      }
      _block(t) {
        const e = this,
          n = e._h,
          s = te(80);
        for (let c = 0; 16 > c; c++) s[c] = t[c];
        let r = n[0],
          a = n[1],
          o = n[2],
          l = n[3],
          u = n[4];
        for (let c = 0; 79 >= c; c++) {
          16 > c ||
            (s[c] = e._S(1, s[c - 3] ^ s[c - 8] ^ s[c - 14] ^ s[c - 16]));
          const i =
            (e._S(5, r) +
              e._f(c, a, o, l) +
              u +
              s[c] +
              e._key[A.floor(c / 20)]) |
            0;
          ((u = l), (l = o), (o = e._S(30, a)), (a = r), (r = i));
        }
        ((n[0] = (n[0] + r) | 0),
          (n[1] = (n[1] + a) | 0),
          (n[2] = (n[2] + o) | 0),
          (n[3] = (n[3] + l) | 0),
          (n[4] = (n[4] + u) | 0));
      }
    },
    Ue = {
      getRandomValues(t) {
        const e = new se(t.buffer),
          n = (s) => {
            let r = 987654321;
            const a = 4294967295;
            return () => (
              (r = (36969 * (65535 & r) + (r >> 16)) & a),
              ((((r << 16) + (s = (18e3 * (65535 & s) + (s >> 16)) & a)) & a) /
                4294967296 +
                0.5) *
                (A.random() > 0.5 ? 1 : -1)
            );
          };
        for (let s, r = 0; r < t.length; r += 4) {
          const a = n(4294967296 * (s || A.random()));
          ((s = 987654071 * a()), (e[r / 4] = (4294967296 * a()) | 0));
        }
        return t;
      },
    },
    H = {
      importKey: (t) => new H.hmacSha1(L.bytes.toBits(t)),
      pbkdf2(t, e, n, s) {
        if (((n = n || 1e4), 0 > s || 0 > n))
          throw new v("invalid params to pbkdf2");
        const r = (1 + (s >> 5)) << 2;
        let a, o, l, u, c;
        const i = new ArrayBuffer(r),
          f = new W(i);
        let h = 0;
        const p = _;
        for (e = L.bytes.toBits(e), c = 1; (r || 1) > h; c++) {
          for (a = o = t.encrypt(p.concat(e, [c])), l = 1; n > l; l++)
            for (o = t.encrypt(o), u = 0; u < o.length; u++) a[u] ^= o[u];
          for (l = 0; (r || 1) > h && l < a.length; l++)
            (f.setInt32(h, a[l]), (h += 4));
        }
        return i.slice(0, s / 8);
      },
      hmacSha1: class {
        constructor(t) {
          const e = this,
            n = (e._hash = Ee),
            s = [[], []];
          e._baseHash = [new n(), new n()];
          const r = e._baseHash[0].blockSize / 32;
          t.length > r && (t = new n().update(t).finalize());
          for (let a = 0; r > a; a++)
            ((s[0][a] = 909522486 ^ t[a]), (s[1][a] = 1549556828 ^ t[a]));
          (e._baseHash[0].update(s[0]),
            e._baseHash[1].update(s[1]),
            (e._resultHash = new n(e._baseHash[0])));
        }
        reset() {
          const t = this;
          ((t._resultHash = new t._hash(t._baseHash[0])), (t._updated = !1));
        }
        update(t) {
          ((this._updated = !0), this._resultHash.update(t));
        }
        digest() {
          const t = this,
            e = t._resultHash.finalize(),
            n = new t._hash(t._baseHash[1]).update(e).finalize();
          return (t.reset(), n);
        }
        encrypt(t) {
          if (this._updated)
            throw new v("encrypt on already updated hmac called!");
          return (this.update(t), this.digest(t));
        }
      },
    },
    We = typeof B != N && typeof B.getRandomValues == O,
    le = "Invalid password",
    ue = "Invalid signature",
    he = "zipjs-abort-check-password";
  function fe(t) {
    return We ? B.getRandomValues(t) : Ue.getRandomValues(t);
  }
  const P = 16,
    pe = { name: "PBKDF2" },
    Me = m.assign({ hash: { name: "HMAC" } }, pe),
    X = m.assign({ iterations: 1e3, hash: { name: "SHA-1" } }, pe),
    Ne = ["deriveBits"],
    T = [8, 12, 16],
    V = [16, 24, 32],
    q = 10,
    Oe = [0, 0, 0, 0],
    F = typeof B != N,
    x = F && B.subtle,
    de = F && typeof x != N,
    z = L.bytes,
    Le = class {
      constructor(t) {
        const e = this;
        ((e._tables = [
          [[], [], [], [], []],
          [[], [], [], [], []],
        ]),
          e._tables[0][0][0] || e._precompute());
        const n = e._tables[0][4],
          s = e._tables[1],
          r = t.length;
        let a,
          o,
          l,
          u = 1;
        if (r !== 4 && r !== 6 && r !== 8) throw new v("invalid aes key size");
        for (
          e._key = [(o = t.slice(0)), (l = [])], a = r;
          4 * r + 28 > a;
          a++
        ) {
          let c = o[a - 1];
          ((a % r == 0 || (r === 8 && a % r == 4)) &&
            ((c =
              (n[c >>> 24] << 24) ^
              (n[(c >> 16) & 255] << 16) ^
              (n[(c >> 8) & 255] << 8) ^
              n[255 & c]),
            a % r == 0 &&
              ((c = (c << 8) ^ (c >>> 24) ^ (u << 24)),
              (u = (u << 1) ^ (283 * (u >> 7))))),
            (o[a] = o[a - r] ^ c));
        }
        for (let c = 0; a; c++, a--) {
          const i = o[3 & c ? a : a - 4];
          l[c] =
            4 >= a || 4 > c
              ? i
              : s[0][n[i >>> 24]] ^
                s[1][n[(i >> 16) & 255]] ^
                s[2][n[(i >> 8) & 255]] ^
                s[3][n[255 & i]];
        }
      }
      encrypt(t) {
        return this._crypt(t, 0);
      }
      decrypt(t) {
        return this._crypt(t, 1);
      }
      _precompute() {
        const t = this._tables[0],
          e = this._tables[1],
          n = t[4],
          s = e[4],
          r = [],
          a = [];
        let o, l, u, c;
        for (let i = 0; 256 > i; i++)
          a[(r[i] = (i << 1) ^ (283 * (i >> 7))) ^ i] = i;
        for (let i = (o = 0); !n[i]; i ^= l || 1, o = a[o] || 1) {
          let f = o ^ (o << 1) ^ (o << 2) ^ (o << 3) ^ (o << 4);
          ((f = (f >> 8) ^ (255 & f) ^ 99),
            (n[i] = f),
            (s[f] = i),
            (c = r[(u = r[(l = r[i])])]));
          let h = (16843009 * c) ^ (65537 * u) ^ (257 * l) ^ (16843008 * i),
            p = (257 * r[f]) ^ (16843008 * f);
          for (let d = 0; 4 > d; d++)
            ((t[d][i] = p = (p << 24) ^ (p >>> 8)),
              (e[d][f] = h = (h << 24) ^ (h >>> 8)));
        }
        for (let i = 0; 5 > i; i++)
          ((t[i] = t[i].slice(0)), (e[i] = e[i].slice(0)));
      }
      _crypt(t, e) {
        if (t.length !== 4) throw new v("invalid aes block size");
        const n = this._key[e],
          s = n.length / 4 - 2,
          r = [0, 0, 0, 0],
          a = this._tables[e],
          o = a[0],
          l = a[1],
          u = a[2],
          c = a[3],
          i = a[4];
        let f,
          h,
          p,
          d = t[0] ^ n[0],
          g = t[e ? 3 : 1] ^ n[1],
          y = t[2] ^ n[2],
          S = t[e ? 1 : 3] ^ n[3],
          I = 4;
        for (let C = 0; s > C; C++)
          ((f =
            o[d >>> 24] ^
            l[(g >> 16) & 255] ^
            u[(y >> 8) & 255] ^
            c[255 & S] ^
            n[I]),
            (h =
              o[g >>> 24] ^
              l[(y >> 16) & 255] ^
              u[(S >> 8) & 255] ^
              c[255 & d] ^
              n[I + 1]),
            (p =
              o[y >>> 24] ^
              l[(S >> 16) & 255] ^
              u[(d >> 8) & 255] ^
              c[255 & g] ^
              n[I + 2]),
            (S =
              o[S >>> 24] ^
              l[(d >> 16) & 255] ^
              u[(g >> 8) & 255] ^
              c[255 & y] ^
              n[I + 3]),
            (I += 4),
            (d = f),
            (g = h),
            (y = p));
        for (let C = 0; 4 > C; C++)
          ((r[e ? 3 & -C : C] =
            (i[d >>> 24] << 24) ^
            (i[(g >> 16) & 255] << 16) ^
            (i[(y >> 8) & 255] << 8) ^
            i[255 & S] ^
            n[I++]),
            (f = d),
            (d = g),
            (g = y),
            (y = S),
            (S = f));
        return r;
      }
    },
    Fe = class {
      constructor(t, e) {
        ((this._prf = t), (this._initIv = e), (this._iv = e));
      }
      reset() {
        this._iv = this._initIv;
      }
      update(t) {
        return this.calculate(this._prf, t, this._iv);
      }
      incWord(t) {
        if (255 & ~(t >> 24)) t += 1 << 24;
        else {
          let e = (t >> 16) & 255,
            n = (t >> 8) & 255,
            s = 255 & t;
          (e === 255
            ? ((e = 0), n === 255 ? ((n = 0), s === 255 ? (s = 0) : ++s) : ++n)
            : ++e,
            (t = 0),
            (t += e << 16),
            (t += n << 8),
            (t += s));
        }
        return t;
      }
      incCounter(t) {
        (t[0] = this.incWord(t[0])) === 0 && (t[1] = this.incWord(t[1]));
      }
      calculate(t, e, n) {
        let s;
        if (!(s = e.length)) return [];
        const r = _.bitLength(e);
        for (let a = 0; s > a; a += 4) {
          this.incCounter(n);
          const o = t.encrypt(n);
          ((e[a] ^= o[0]),
            (e[a + 1] ^= o[1]),
            (e[a + 2] ^= o[2]),
            (e[a + 3] ^= o[3]));
        }
        return _.clamp(e, r);
      }
    },
    je = H.hmacSha1;
  let ge = F && de && typeof x.importKey == O,
    we = F && de && typeof x.deriveBits == O;
  class Ge extends b {
    constructor({
      password: e,
      rawPassword: n,
      signed: s,
      encryptionStrength: r,
      checkPasswordOnly: a,
    }) {
      super({
        start() {
          m.assign(this, {
            ready: new M((o) => (this.resolveReady = o)),
            password: _e(e, n),
            signed: s,
            strength: r - 1,
            pending: new w(),
          });
        },
        async transform(o, l) {
          const u = this,
            { password: c, strength: i, resolveReady: f, ready: h } = u;
          c
            ? (await (async (d, g, y, S) => {
                const I = await me(d, g, y, k(S, 0, T[g])),
                  C = k(S, T[g]);
                if (I[0] != C[0] || I[1] != C[1]) throw new v(le);
              })(u, i, c, k(o, 0, T[i] + 2)),
              (o = k(o, T[i] + 2)),
              a ? l.error(new v(he)) : f())
            : await h;
          const p = new w(o.length - q - ((o.length - q) % P));
          l.enqueue(ye(u, o, p, 0, q, !0));
        },
        async flush(o) {
          const { signed: l, ctr: u, hmac: c, pending: i, ready: f } = this;
          if (c && u) {
            await f;
            const h = k(i, 0, i.length - q),
              p = k(i, i.length - q);
            let d = new w();
            if (h.length) {
              const g = U(z, h);
              c.update(g);
              const y = u.update(g);
              d = E(z, y);
            }
            if (l) {
              const g = k(E(z, c.digest()), 0, q);
              for (let y = 0; q > y; y++) if (g[y] != p[y]) throw new v(ue);
            }
            o.enqueue(d);
          }
        },
      });
    }
  }
  class Xe extends b {
    constructor({ password: e, rawPassword: n, encryptionStrength: s }) {
      let r;
      (super({
        start() {
          m.assign(this, {
            ready: new M((a) => (this.resolveReady = a)),
            password: _e(e, n),
            strength: s - 1,
            pending: new w(),
          });
        },
        async transform(a, o) {
          const l = this,
            { password: u, strength: c, resolveReady: i, ready: f } = l;
          let h = new w();
          u
            ? ((h = await (async (d, g, y) => {
                const S = fe(new w(T[g]));
                return J(S, await me(d, g, y, S));
              })(l, c, u)),
              i())
            : await f;
          const p = new w(h.length + a.length - (a.length % P));
          (p.set(h, 0), o.enqueue(ye(l, a, p, h.length, 0)));
        },
        async flush(a) {
          const { ctr: o, hmac: l, pending: u, ready: c } = this;
          if (l && o) {
            await c;
            let i = new w();
            if (u.length) {
              const f = o.update(U(z, u));
              (l.update(f), (i = E(z, f)));
            }
            ((r.signature = E(z, l.digest()).slice(0, q)),
              a.enqueue(J(i, r.signature)));
          }
        },
      }),
        (r = this));
    }
  }
  function ye(t, e, n, s, r, a) {
    const { ctr: o, hmac: l, pending: u } = t,
      c = e.length - r;
    let i;
    for (
      u.length &&
        ((e = J(u, e)),
        (n = ((f, h) => {
          if (h && h > f.length) {
            const p = f;
            (f = new w(h)).set(p, 0);
          }
          return f;
        })(n, c - (c % P)))),
        i = 0;
      c - P >= i;
      i += P
    ) {
      const f = U(z, k(e, i, i + P));
      a && l.update(f);
      const h = o.update(f);
      (a || l.update(h), n.set(E(z, h), i + s));
    }
    return ((t.pending = k(e, i)), n);
  }
  async function me(t, e, n, s) {
    t.password = null;
    const r = await (async (i, f, h, p, d) => {
        if (!ge) return H.importKey(f);
        try {
          return await x.importKey("raw", f, h, !1, d);
        } catch {
          return ((ge = !1), H.importKey(f));
        }
      })(0, n, Me, 0, Ne),
      a = await (async (i, f, h) => {
        if (!we) return H.pbkdf2(f, i.salt, X.iterations, h);
        try {
          return await x.deriveBits(i, f, h);
        } catch {
          return ((we = !1), H.pbkdf2(f, i.salt, X.iterations, h));
        }
      })(m.assign({ salt: s }, X), r, 8 * (2 * V[e] + 2)),
      o = new w(a),
      l = U(z, k(o, 0, V[e])),
      u = U(z, k(o, V[e], 2 * V[e])),
      c = k(o, 2 * V[e]);
    return (
      m.assign(t, {
        keys: { key: l, authentication: u, passwordVerification: c },
        ctr: new Fe(new Le(l), te.from(Oe)),
        hmac: new je(u),
      }),
      c
    );
  }
  function _e(t, e) {
    return e === j
      ? ((n) => {
          if (typeof ae == N) {
            const s = new w((n = unescape(encodeURIComponent(n))).length);
            for (let r = 0; r < s.length; r++) s[r] = n.charCodeAt(r);
            return s;
          }
          return new ae().encode(n);
        })(t)
      : e;
  }
  function J(t, e) {
    let n = t;
    return (
      t.length + e.length &&
        ((n = new w(t.length + e.length)), n.set(t, 0), n.set(e, t.length)),
      n
    );
  }
  function k(t, e, n) {
    return t.subarray(e, n);
  }
  function E(t, e) {
    return t.fromBits(e);
  }
  function U(t, e) {
    return t.toBits(e);
  }
  class Je extends b {
    constructor({
      password: e,
      passwordVerification: n,
      checkPasswordOnly: s,
    }) {
      super({
        start() {
          (m.assign(this, { password: e, passwordVerification: n }),
            ve(this, e));
        },
        transform(r, a) {
          const o = this;
          if (o.password) {
            const l = be(o, r.subarray(0, 12));
            if (((o.password = null), l[11] != o.passwordVerification))
              throw new v(le);
            r = r.subarray(12);
          }
          s ? a.error(new v(he)) : a.enqueue(be(o, r));
        },
      });
    }
  }
  class Qe extends b {
    constructor({ password: e, passwordVerification: n }) {
      super({
        start() {
          (m.assign(this, { password: e, passwordVerification: n }),
            ve(this, e));
        },
        transform(s, r) {
          const a = this;
          let o, l;
          if (a.password) {
            a.password = null;
            const u = fe(new w(12));
            ((u[11] = a.passwordVerification),
              (o = new w(s.length + u.length)),
              o.set(Se(a, u), 0),
              (l = 12));
          } else ((o = new w(s.length)), (l = 0));
          (o.set(Se(a, s), l), r.enqueue(o));
        },
      });
    }
  }
  function be(t, e) {
    const n = new w(e.length);
    for (let s = 0; s < e.length; s++) ((n[s] = ke(t) ^ e[s]), Q(t, n[s]));
    return n;
  }
  function Se(t, e) {
    const n = new w(e.length);
    for (let s = 0; s < e.length; s++) ((n[s] = ke(t) ^ e[s]), Q(t, e[s]));
    return n;
  }
  function ve(t, e) {
    const n = [305419896, 591751049, 878082192];
    m.assign(t, { keys: n, crcKey0: new G(n[0]), crcKey2: new G(n[2]) });
    for (let s = 0; s < e.length; s++) Q(t, e.charCodeAt(s));
  }
  function Q(t, e) {
    let [n, s, r] = t.keys;
    (t.crcKey0.append([e]),
      (n = ~t.crcKey0.get()),
      (s = De(A.imul(De(s + ze(n)), 134775813) + 1)),
      t.crcKey2.append([s >>> 24]),
      (r = ~t.crcKey2.get()),
      (t.keys = [n, s, r]));
  }
  function ke(t) {
    const e = 2 | t.keys[2];
    return ze(A.imul(e, 1 ^ e) >>> 8);
  }
  function ze(t) {
    return 255 & t;
  }
  function De(t) {
    return 4294967295 & t;
  }
  const Ce = "deflate-raw";
  class Ye extends b {
    constructor(
      e,
      { chunkSize: n, CompressionStream: s, CompressionStreamNative: r },
    ) {
      super({});
      const {
          compressed: a,
          encrypted: o,
          useCompressionStream: l,
          zipCrypto: u,
          signed: c,
          level: i,
        } = e,
        f = this;
      let h,
        p,
        d = Ie(super.readable);
      ((o && !u) || !c || ((h = new ce()), (d = D(d, h))),
        a && (d = qe(d, l, { level: i, chunkSize: n }, r, s)),
        o && (u ? (d = D(d, new Qe(e))) : ((p = new Xe(e)), (d = D(d, p)))),
        Ae(f, d, () => {
          let g;
          (o && !u && (g = p.signature),
            (o && !u) || !c || (g = new W(h.value.buffer).getUint32(0)),
            (f.signature = g));
        }));
    }
  }
  class Ze extends b {
    constructor(
      e,
      { chunkSize: n, DecompressionStream: s, DecompressionStreamNative: r },
    ) {
      super({});
      const {
        zipCrypto: a,
        encrypted: o,
        signed: l,
        signature: u,
        compressed: c,
        useCompressionStream: i,
      } = e;
      let f,
        h,
        p = Ie(super.readable);
      (o && (a ? (p = D(p, new Je(e))) : ((h = new Ge(e)), (p = D(p, h)))),
        c && (p = qe(p, i, { chunkSize: n }, r, s)),
        (o && !a) || !l || ((f = new ce()), (p = D(p, f))),
        Ae(this, p, () => {
          if ((!o || a) && l) {
            const d = new W(f.value.buffer);
            if (u != d.getUint32(0, !1)) throw new v(ue);
          }
        }));
    }
  }
  function Ie(t) {
    return D(
      t,
      new b({
        transform(e, n) {
          e && e.length && n.enqueue(e);
        },
      }),
    );
  }
  function Ae(t, e, n) {
    ((e = D(e, new b({ flush: n }))),
      m.defineProperty(t, "readable", { get: () => e }));
  }
  function qe(t, e, n, s, r) {
    try {
      t = D(t, new (e && s ? s : r)(Ce, n));
    } catch {
      if (!e) return t;
      try {
        t = D(t, new r(Ce, n));
      } catch {
        return t;
      }
    }
    return t;
  }
  function D(t, e) {
    return t.pipeThrough(e);
  }
  const Re = "data",
    He = "close";
  class $e extends b {
    constructor(e, n) {
      super({});
      const s = this,
        { codecType: r } = e;
      let a;
      r.startsWith("deflate") ? (a = Ye) : r.startsWith("inflate") && (a = Ze);
      let o = 0,
        l = 0;
      const u = new a(e, n),
        c = super.readable,
        i = new b({
          transform(h, p) {
            h && h.length && ((l += h.length), p.enqueue(h));
          },
          flush() {
            m.assign(s, { inputSize: l });
          },
        }),
        f = new b({
          transform(h, p) {
            h && h.length && ((o += h.length), p.enqueue(h));
          },
          flush() {
            const { signature: h } = u;
            m.assign(s, { signature: h, outputSize: o, inputSize: l });
          },
        });
      m.defineProperty(s, "readable", {
        get: () => c.pipeThrough(i).pipeThrough(u).pipeThrough(f),
      });
    }
  }
  class et extends b {
    constructor(e) {
      let n;
      super({
        transform: function s(r, a) {
          if (n) {
            const o = new w(n.length + r.length);
            (o.set(n), o.set(r, n.length), (r = o), (n = null));
          }
          r.length > e ? (a.enqueue(r.slice(0, e)), s(r.slice(e), a)) : (n = r);
        },
        flush(s) {
          n && n.length && s.enqueue(n);
        },
      });
    }
  }
  const Y = new re(),
    Z = new re();
  let $,
    R = 0,
    Pe = !0;
  async function tt(t) {
    try {
      const { options: e, scripts: n, config: s } = t;
      if (n && n.length)
        try {
          Pe ? importScripts.apply(j, n) : await Be(n);
        } catch {
          ((Pe = !1), await Be(n));
        }
      (self.initCodec && self.initCodec(),
        (s.CompressionStreamNative = self.CompressionStream),
        (s.DecompressionStreamNative = self.DecompressionStream),
        self.Deflate && (s.CompressionStream = new oe(self.Deflate)),
        self.Inflate && (s.DecompressionStream = new oe(self.Inflate)));
      const r = { highWaterMark: 1 },
        a =
          t.readable ||
          new Ve(
            {
              async pull(h) {
                const p = new M((y) => Y.set(R, y));
                (ee({ type: "pull", messageId: R }),
                  (R = (R + 1) % ne.MAX_SAFE_INTEGER));
                const { value: d, done: g } = await p;
                (h.enqueue(d), g && h.close());
              },
            },
            r,
          ),
        o =
          t.writable ||
          new xe(
            {
              async write(h) {
                let p;
                const d = new M((g) => (p = g));
                (Z.set(R, p),
                  ee({ type: Re, value: h, messageId: R }),
                  (R = (R + 1) % ne.MAX_SAFE_INTEGER),
                  await d);
              },
            },
            r,
          ),
        l = new $e(e, s);
      $ = new AbortController();
      const { signal: u } = $;
      (await a
        .pipeThrough(l)
        .pipeThrough(new et(s.chunkSize))
        .pipeTo(o, { signal: u, preventClose: !0, preventAbort: !0 }),
        await o.getWriter().close());
      const { signature: c, inputSize: i, outputSize: f } = l;
      ee({ type: He, result: { signature: c, inputSize: i, outputSize: f } });
    } catch (e) {
      Ke(e);
    }
  }
  async function Be(t) {
    for (const e of t) await import(e);
  }
  function ee(t) {
    let { value: e } = t;
    if (e)
      if (e.length)
        try {
          ((e = new w(e)), (t.value = e.buffer), K(t, [t.value]));
        } catch {
          K(t);
        }
      else K(t);
    else K(t);
  }
  function Ke(t = new v("Unknown error")) {
    const { message: e, stack: n, code: s, name: r } = t;
    K({ error: { message: e, stack: n, code: s, name: r } });
  }
  function Te(t, e, n) {
    return class {
      constructor(r) {
        const a = this;
        var o, l;
        ((o = r),
          (l = "level"),
          (typeof m.hasOwn === O ? m.hasOwn(o, l) : o.hasOwnProperty(l)) &&
            r.level === j &&
            delete r.level,
          (a.codec = new t(m.assign({}, e, r))),
          n(a.codec, (u) => {
            if (a.pendingData) {
              const c = a.pendingData;
              a.pendingData = new w(c.length + u.length);
              const { pendingData: i } = a;
              (i.set(c, 0), i.set(u, c.length));
            } else a.pendingData = new w(u);
          }));
      }
      append(r) {
        return (this.codec.push(r), s(this));
      }
      flush() {
        return (this.codec.push(new w(), !0), s(this));
      }
    };
    function s(r) {
      if (r.pendingData) {
        const a = r.pendingData;
        return ((r.pendingData = null), a);
      }
      return new w();
    }
  }
  (addEventListener("message", ({ data: t }) => {
    const { type: e, messageId: n, value: s, done: r } = t;
    try {
      if ((e == "start" && tt(t), e == Re)) {
        const a = Y.get(n);
        (Y.delete(n), a({ value: new w(s), done: r }));
      }
      if (e == "ack") {
        const a = Z.get(n);
        (Z.delete(n), a());
      }
      e == He && $.abort();
    } catch (a) {
      Ke(a);
    }
  }),
    (self.initCodec = () => {
      const { Deflate: t, Inflate: e } = ((n, s = {}, r) => ({
        Deflate: Te(n.Deflate, s.deflate, r),
        Inflate: Te(n.Inflate, s.inflate, r),
      }))(
        pako,
        { deflate: { raw: !0 }, inflate: { raw: !0 } },
        (n, s) => (n.onData = s),
      );
      ((self.Deflate = t), (self.Inflate = e));
    }));
})();
