precision-dashwidgets 0.5.0 → 0.5.2

package/dist/pako.esm-Bx5X36Wo-CzWah3nf.mjs

@@ -0,0 +1,1053 @@
+function M(t) {
+  let n = t.length;
+  for (; --n >= 0; )
+    t[n] = 0;
+}
+const tt = 3, nt = 258, Ne = 29, at = 256, it = at + 1 + Ne, Fe = 30, rt = 512, st = new Array((it + 2) * 2);
+M(st);
+const ot = new Array(Fe * 2);
+M(ot);
+const lt = new Array(rt);
+M(lt);
+const dt = new Array(nt - tt + 1);
+M(dt);
+const ft = new Array(Ne);
+M(ft);
+const ct = new Array(Fe);
+M(ct);
+const ht = (t, n, e, s) => {
+  let o = t & 65535 | 0, r = t >>> 16 & 65535 | 0, c = 0;
+  for (; e !== 0; ) {
+    c = e > 2e3 ? 2e3 : e, e -= c;
+    do
+      o = o + n[s++] | 0, r = r + o | 0;
+    while (--c);
+    o %= 65521, r %= 65521;
+  }
+  return o | r << 16 | 0;
+};
+var ie = ht;
+const ut = () => {
+  let t, n = [];
+  for (var e = 0; e < 256; e++) {
+    t = e;
+    for (var s = 0; s < 8; s++)
+      t = t & 1 ? 3988292384 ^ t >>> 1 : t >>> 1;
+    n[e] = t;
+  }
+  return n;
+}, wt = new Uint32Array(ut()), bt = (t, n, e, s) => {
+  const o = wt, r = s + e;
+  t ^= -1;
+  for (let c = s; c < r; c++)
+    t = t >>> 8 ^ o[(t ^ n[c]) & 255];
+  return t ^ -1;
+};
+var T = bt, re = {
+  2: "need dictionary",
+  /* Z_NEED_DICT       2  */
+  1: "stream end",
+  /* Z_STREAM_END      1  */
+  0: "",
+  /* Z_OK              0  */
+  "-1": "file error",
+  /* Z_ERRNO         (-1) */
+  "-2": "stream error",
+  /* Z_STREAM_ERROR  (-2) */
+  "-3": "data error",
+  /* Z_DATA_ERROR    (-3) */
+  "-4": "insufficient memory",
+  /* Z_MEM_ERROR     (-4) */
+  "-5": "buffer error",
+  /* Z_BUF_ERROR     (-5) */
+  "-6": "incompatible version"
+  /* Z_VERSION_ERROR (-6) */
+}, je = {
+  /* Allowed flush values; see deflate() and inflate() below for details */
+  Z_NO_FLUSH: 0,
+  Z_FINISH: 4,
+  Z_BLOCK: 5,
+  Z_TREES: 6,
+  /* Return codes for the compression/decompression functions. Negative values
+  * are errors, positive values are used for special but normal events.
+  */
+  Z_OK: 0,
+  Z_STREAM_END: 1,
+  Z_NEED_DICT: 2,
+  Z_STREAM_ERROR: -2,
+  Z_DATA_ERROR: -3,
+  Z_MEM_ERROR: -4,
+  Z_BUF_ERROR: -5,
+  /* The deflate compression method */
+  Z_DEFLATED: 8
+  //Z_NULL:                 null // Use -1 or null inline, depending on var type
+};
+const mt = (t, n) => Object.prototype.hasOwnProperty.call(t, n);
+var kt = function(t) {
+  const n = Array.prototype.slice.call(arguments, 1);
+  for (; n.length; ) {
+    const e = n.shift();
+    if (e) {
+      if (typeof e != "object")
+        throw new TypeError(e + "must be non-object");
+      for (const s in e)
+        mt(e, s) && (t[s] = e[s]);
+    }
+  }
+  return t;
+}, _t = (t) => {
+  let n = 0;
+  for (let s = 0, o = t.length; s < o; s++)
+    n += t[s].length;
+  const e = new Uint8Array(n);
+  for (let s = 0, o = 0, r = t.length; s < r; s++) {
+    let c = t[s];
+    e.set(c, o), o += c.length;
+  }
+  return e;
+}, He = {
+  assign: kt,
+  flattenChunks: _t
+};
+let Ke = !0;
+try {
+  String.fromCharCode.apply(null, new Uint8Array(1));
+} catch {
+  Ke = !1;
+}
+const F = new Uint8Array(256);
+for (let t = 0; t < 256; t++)
+  F[t] = t >= 252 ? 6 : t >= 248 ? 5 : t >= 240 ? 4 : t >= 224 ? 3 : t >= 192 ? 2 : 1;
+F[254] = F[254] = 1;
+var gt = (t) => {
+  if (typeof TextEncoder == "function" && TextEncoder.prototype.encode)
+    return new TextEncoder().encode(t);
+  let n, e, s, o, r, c = t.length, d = 0;
+  for (o = 0; o < c; o++)
+    e = t.charCodeAt(o), (e & 64512) === 55296 && o + 1 < c && (s = t.charCodeAt(o + 1), (s & 64512) === 56320 && (e = 65536 + (e - 55296 << 10) + (s - 56320), o++)), d += e < 128 ? 1 : e < 2048 ? 2 : e < 65536 ? 3 : 4;
+  for (n = new Uint8Array(d), r = 0, o = 0; r < d; o++)
+    e = t.charCodeAt(o), (e & 64512) === 55296 && o + 1 < c && (s = t.charCodeAt(o + 1), (s & 64512) === 56320 && (e = 65536 + (e - 55296 << 10) + (s - 56320), o++)), e < 128 ? n[r++] = e : e < 2048 ? (n[r++] = 192 | e >>> 6, n[r++] = 128 | e & 63) : e < 65536 ? (n[r++] = 224 | e >>> 12, n[r++] = 128 | e >>> 6 & 63, n[r++] = 128 | e & 63) : (n[r++] = 240 | e >>> 18, n[r++] = 128 | e >>> 12 & 63, n[r++] = 128 | e >>> 6 & 63, n[r++] = 128 | e & 63);
+  return n;
+};
+const pt = (t, n) => {
+  if (n < 65534 && t.subarray && Ke)
+    return String.fromCharCode.apply(null, t.length === n ? t : t.subarray(0, n));
+  let e = "";
+  for (let s = 0; s < n; s++)
+    e += String.fromCharCode(t[s]);
+  return e;
+};
+var vt = (t, n) => {
+  const e = n || t.length;
+  if (typeof TextDecoder == "function" && TextDecoder.prototype.decode)
+    return new TextDecoder().decode(t.subarray(0, n));
+  let s, o;
+  const r = new Array(e * 2);
+  for (o = 0, s = 0; s < e; ) {
+    let c = t[s++];
+    if (c < 128) {
+      r[o++] = c;
+      continue;
+    }
+    let d = F[c];
+    if (d > 4) {
+      r[o++] = 65533, s += d - 1;
+      continue;
+    }
+    for (c &= d === 2 ? 31 : d === 3 ? 15 : 7; d > 1 && s < e; )
+      c = c << 6 | t[s++] & 63, d--;
+    if (d > 1) {
+      r[o++] = 65533;
+      continue;
+    }
+    c < 65536 ? r[o++] = c : (c -= 65536, r[o++] = 55296 | c >> 10 & 1023, r[o++] = 56320 | c & 1023);
+  }
+  return pt(r, o);
+}, yt = (t, n) => {
+  n = n || t.length, n > t.length && (n = t.length);
+  let e = n - 1;
+  for (; e >= 0 && (t[e] & 192) === 128; )
+    e--;
+  return e < 0 || e === 0 ? n : e + F[t[e]] > n ? e : n;
+}, se = {
+  string2buf: gt,
+  buf2string: vt,
+  utf8border: yt
+};
+function xt() {
+  this.input = null, this.next_in = 0, this.avail_in = 0, this.total_in = 0, this.output = null, this.next_out = 0, this.avail_out = 0, this.total_out = 0, this.msg = "", this.state = null, this.data_type = 2, this.adler = 0;
+}
+var At = xt;
+const L = 16209, Et = 16191;
+var Rt = function(t, n) {
+  let e, s, o, r, c, d, v, a, i, A, h, l, R, Z, g, m, b, f, w, E, p, _, y, u;
+  const k = t.state;
+  e = t.next_in, y = t.input, s = e + (t.avail_in - 5), o = t.next_out, u = t.output, r = o - (n - t.avail_out), c = o + (t.avail_out - 257), d = k.dmax, v = k.wsize, a = k.whave, i = k.wnext, A = k.window, h = k.hold, l = k.bits, R = k.lencode, Z = k.distcode, g = (1 << k.lenbits) - 1, m = (1 << k.distbits) - 1;
+  e:
+    do {
+      l < 15 && (h += y[e++] << l, l += 8, h += y[e++] << l, l += 8), b = R[h & g];
+      t:
+        for (; ; ) {
+          if (f = b >>> 24, h >>>= f, l -= f, f = b >>> 16 & 255, f === 0)
+            u[o++] = b & 65535;
+          else if (f & 16) {
+            w = b & 65535, f &= 15, f && (l < f && (h += y[e++] << l, l += 8), w += h & (1 << f) - 1, h >>>= f, l -= f), l < 15 && (h += y[e++] << l, l += 8, h += y[e++] << l, l += 8), b = Z[h & m];
+            n:
+              for (; ; ) {
+                if (f = b >>> 24, h >>>= f, l -= f, f = b >>> 16 & 255, f & 16) {
+                  if (E = b & 65535, f &= 15, l < f && (h += y[e++] << l, l += 8, l < f && (h += y[e++] << l, l += 8)), E += h & (1 << f) - 1, E > d) {
+                    t.msg = "invalid distance too far back", k.mode = L;
+                    break e;
+                  }
+                  if (h >>>= f, l -= f, f = o - r, E > f) {
+                    if (f = E - f, f > a && k.sane) {
+                      t.msg = "invalid distance too far back", k.mode = L;
+                      break e;
+                    }
+                    if (p = 0, _ = A, i === 0) {
+                      if (p += v - f, f < w) {
+                        w -= f;
+                        do
+                          u[o++] = A[p++];
+                        while (--f);
+                        p = o - E, _ = u;
+                      }
+                    } else if (i < f) {
+                      if (p += v + i - f, f -= i, f < w) {
+                        w -= f;
+                        do
+                          u[o++] = A[p++];
+                        while (--f);
+                        if (p = 0, i < w) {
+                          f = i, w -= f;
+                          do
+                            u[o++] = A[p++];
+                          while (--f);
+                          p = o - E, _ = u;
+                        }
+                      }
+                    } else if (p += i - f, f < w) {
+                      w -= f;
+                      do
+                        u[o++] = A[p++];
+                      while (--f);
+                      p = o - E, _ = u;
+                    }
+                    for (; w > 2; )
+                      u[o++] = _[p++], u[o++] = _[p++], u[o++] = _[p++], w -= 3;
+                    w && (u[o++] = _[p++], w > 1 && (u[o++] = _[p++]));
+                  } else {
+                    p = o - E;
+                    do
+                      u[o++] = u[p++], u[o++] = u[p++], u[o++] = u[p++], w -= 3;
+                    while (w > 2);
+                    w && (u[o++] = u[p++], w > 1 && (u[o++] = u[p++]));
+                  }
+                } else if (f & 64) {
+                  t.msg = "invalid distance code", k.mode = L;
+                  break e;
+                } else {
+                  b = Z[(b & 65535) + (h & (1 << f) - 1)];
+                  continue n;
+                }
+                break;
+              }
+          } else if (f & 64)
+            if (f & 32) {
+              k.mode = Et;
+              break e;
+            } else {
+              t.msg = "invalid literal/length code", k.mode = L;
+              break e;
+            }
+          else {
+            b = R[(b & 65535) + (h & (1 << f) - 1)];
+            continue t;
+          }
+          break;
+        }
+    } while (e < s && o < c);
+  w = l >> 3, e -= w, l -= w << 3, h &= (1 << l) - 1, t.next_in = e, t.next_out = o, t.avail_in = e < s ? 5 + (s - e) : 5 - (e - s), t.avail_out = o < c ? 257 + (c - o) : 257 - (o - c), k.hold = h, k.bits = l;
+};
+const I = 15, le = 852, de = 592, fe = 0, W = 1, ce = 2, Zt = new Uint16Array([
+  /* Length codes 257..285 base */
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  13,
+  15,
+  17,
+  19,
+  23,
+  27,
+  31,
+  35,
+  43,
+  51,
+  59,
+  67,
+  83,
+  99,
+  115,
+  131,
+  163,
+  195,
+  227,
+  258,
+  0,
+  0
+]), St = new Uint8Array([
+  /* Length codes 257..285 extra */
+  16,
+  16,
+  16,
+  16,
+  16,
+  16,
+  16,
+  16,
+  17,
+  17,
+  17,
+  17,
+  18,
+  18,
+  18,
+  18,
+  19,
+  19,
+  19,
+  19,
+  20,
+  20,
+  20,
+  20,
+  21,
+  21,
+  21,
+  21,
+  16,
+  72,
+  78
+]), Dt = new Uint16Array([
+  /* Distance codes 0..29 base */
+  1,
+  2,
+  3,
+  4,
+  5,
+  7,
+  9,
+  13,
+  17,
+  25,
+  33,
+  49,
+  65,
+  97,
+  129,
+  193,
+  257,
+  385,
+  513,
+  769,
+  1025,
+  1537,
+  2049,
+  3073,
+  4097,
+  6145,
+  8193,
+  12289,
+  16385,
+  24577,
+  0,
+  0
+]), Tt = new Uint8Array([
+  /* Distance codes 0..29 extra */
+  16,
+  16,
+  16,
+  16,
+  17,
+  17,
+  18,
+  18,
+  19,
+  19,
+  20,
+  20,
+  21,
+  21,
+  22,
+  22,
+  23,
+  23,
+  24,
+  24,
+  25,
+  25,
+  26,
+  26,
+  27,
+  27,
+  28,
+  28,
+  29,
+  29,
+  64,
+  64
+]), Ut = (t, n, e, s, o, r, c, d) => {
+  const v = d.bits;
+  let a = 0, i = 0, A = 0, h = 0, l = 0, R = 0, Z = 0, g = 0, m = 0, b = 0, f, w, E, p, _, y = null, u;
+  const k = new Uint16Array(I + 1), S = new Uint16Array(I + 1);
+  let C = null, oe, H, K;
+  for (a = 0; a <= I; a++)
+    k[a] = 0;
+  for (i = 0; i < s; i++)
+    k[n[e + i]]++;
+  for (l = v, h = I; h >= 1 && k[h] === 0; h--)
+    ;
+  if (l > h && (l = h), h === 0)
+    return o[r++] = 1 << 24 | 64 << 16 | 0, o[r++] = 1 << 24 | 64 << 16 | 0, d.bits = 1, 0;
+  for (A = 1; A < h && k[A] === 0; A++)
+    ;
+  for (l < A && (l = A), g = 1, a = 1; a <= I; a++)
+    if (g <<= 1, g -= k[a], g < 0)
+      return -1;
+  if (g > 0 && (t === fe || h !== 1))
+    return -1;
+  for (S[1] = 0, a = 1; a < I; a++)
+    S[a + 1] = S[a] + k[a];
+  for (i = 0; i < s; i++)
+    n[e + i] !== 0 && (c[S[n[e + i]]++] = i);
+  if (t === fe ? (y = C = c, u = 20) : t === W ? (y = Zt, C = St, u = 257) : (y = Dt, C = Tt, u = 0), b = 0, i = 0, a = A, _ = r, R = l, Z = 0, E = -1, m = 1 << l, p = m - 1, t === W && m > le || t === ce && m > de)
+    return 1;
+  for (; ; ) {
+    oe = a - Z, c[i] + 1 < u ? (H = 0, K = c[i]) : c[i] >= u ? (H = C[c[i] - u], K = y[c[i] - u]) : (H = 96, K = 0), f = 1 << a - Z, w = 1 << R, A = w;
+    do
+      w -= f, o[_ + (b >> Z) + w] = oe << 24 | H << 16 | K | 0;
+    while (w !== 0);
+    for (f = 1 << a - 1; b & f; )
+      f >>= 1;
+    if (f !== 0 ? (b &= f - 1, b += f) : b = 0, i++, --k[a] === 0) {
+      if (a === h)
+        break;
+      a = n[e + c[i]];
+    }
+    if (a > l && (b & p) !== E) {
+      for (Z === 0 && (Z = l), _ += A, R = a - Z, g = 1 << R; R + Z < h && (g -= k[R + Z], !(g <= 0)); )
+        R++, g <<= 1;
+      if (m += 1 << R, t === W && m > le || t === ce && m > de)
+        return 1;
+      E = b & p, o[E] = l << 24 | R << 16 | _ - r | 0;
+    }
+  }
+  return b !== 0 && (o[_ + b] = a - Z << 24 | 64 << 16 | 0), d.bits = l, 0;
+};
+var N = Ut;
+const Bt = 0, Le = 1, Ge = 2, {
+  Z_FINISH: he,
+  Z_BLOCK: Ct,
+  Z_TREES: G,
+  Z_OK: O,
+  Z_STREAM_END: Ot,
+  Z_NEED_DICT: zt,
+  Z_STREAM_ERROR: D,
+  Z_DATA_ERROR: Pe,
+  Z_MEM_ERROR: qe,
+  Z_BUF_ERROR: It,
+  Z_DEFLATED: ue
+} = je, Q = 16180, we = 16181, be = 16182, me = 16183, ke = 16184, _e = 16185, ge = 16186, pe = 16187, ve = 16188, ye = 16189, J = 16190, U = 16191, X = 16192, xe = 16193, Y = 16194, Ae = 16195, Ee = 16196, Re = 16197, Ze = 16198, P = 16199, q = 16200, Se = 16201, De = 16202, Te = 16203, Ue = 16204, Be = 16205, $ = 16206, Ce = 16207, Oe = 16208, x = 16209, Je = 16210, Qe = 16211, Mt = 852, Nt = 592, Ft = 15, jt = Ft, ze = (t) => (t >>> 24 & 255) + (t >>> 8 & 65280) + ((t & 65280) << 8) + ((t & 255) << 24);
+function Ht() {
+  this.strm = null, this.mode = 0, this.last = !1, this.wrap = 0, this.havedict = !1, this.flags = 0, this.dmax = 0, this.check = 0, this.total = 0, this.head = null, this.wbits = 0, this.wsize = 0, this.whave = 0, this.wnext = 0, this.window = null, this.hold = 0, this.bits = 0, this.length = 0, this.offset = 0, this.extra = 0, this.lencode = null, this.distcode = null, this.lenbits = 0, this.distbits = 0, this.ncode = 0, this.nlen = 0, this.ndist = 0, this.have = 0, this.next = null, this.lens = new Uint16Array(320), this.work = new Uint16Array(288), this.lendyn = null, this.distdyn = null, this.sane = 0, this.back = 0, this.was = 0;
+}
+const z = (t) => {
+  if (!t)
+    return 1;
+  const n = t.state;
+  return !n || n.strm !== t || n.mode < Q || n.mode > Qe ? 1 : 0;
+}, Ve = (t) => {
+  if (z(t))
+    return D;
+  const n = t.state;
+  return t.total_in = t.total_out = n.total = 0, t.msg = "", n.wrap && (t.adler = n.wrap & 1), n.mode = Q, n.last = 0, n.havedict = 0, n.flags = -1, n.dmax = 32768, n.head = null, n.hold = 0, n.bits = 0, n.lencode = n.lendyn = new Int32Array(Mt), n.distcode = n.distdyn = new Int32Array(Nt), n.sane = 1, n.back = -1, O;
+}, We = (t) => {
+  if (z(t))
+    return D;
+  const n = t.state;
+  return n.wsize = 0, n.whave = 0, n.wnext = 0, Ve(t);
+}, Xe = (t, n) => {
+  let e;
+  if (z(t))
+    return D;
+  const s = t.state;
+  return n < 0 ? (e = 0, n = -n) : (e = (n >> 4) + 5, n < 48 && (n &= 15)), n && (n < 8 || n > 15) ? D : (s.window !== null && s.wbits !== n && (s.window = null), s.wrap = e, s.wbits = n, We(t));
+}, Ye = (t, n) => {
+  if (!t)
+    return D;
+  const e = new Ht();
+  t.state = e, e.strm = t, e.window = null, e.mode = Q;
+  const s = Xe(t, n);
+  return s !== O && (t.state = null), s;
+}, Kt = (t) => Ye(t, jt);
+let Ie = !0, ee, te;
+const Lt = (t) => {
+  if (Ie) {
+    ee = new Int32Array(512), te = new Int32Array(32);
+    let n = 0;
+    for (; n < 144; )
+      t.lens[n++] = 8;
+    for (; n < 256; )
+      t.lens[n++] = 9;
+    for (; n < 280; )
+      t.lens[n++] = 7;
+    for (; n < 288; )
+      t.lens[n++] = 8;
+    for (N(Le, t.lens, 0, 288, ee, 0, t.work, { bits: 9 }), n = 0; n < 32; )
+      t.lens[n++] = 5;
+    N(Ge, t.lens, 0, 32, te, 0, t.work, { bits: 5 }), Ie = !1;
+  }
+  t.lencode = ee, t.lenbits = 9, t.distcode = te, t.distbits = 5;
+}, $e = (t, n, e, s) => {
+  let o;
+  const r = t.state;
+  return r.window === null && (r.wsize = 1 << r.wbits, r.wnext = 0, r.whave = 0, r.window = new Uint8Array(r.wsize)), s >= r.wsize ? (r.window.set(n.subarray(e - r.wsize, e), 0), r.wnext = 0, r.whave = r.wsize) : (o = r.wsize - r.wnext, o > s && (o = s), r.window.set(n.subarray(e - s, e - s + o), r.wnext), s -= o, s ? (r.window.set(n.subarray(e - s, e), 0), r.wnext = s, r.whave = r.wsize) : (r.wnext += o, r.wnext === r.wsize && (r.wnext = 0), r.whave < r.wsize && (r.whave += o))), 0;
+}, Gt = (t, n) => {
+  let e, s, o, r, c, d, v, a, i, A, h, l, R, Z, g = 0, m, b, f, w, E, p, _, y;
+  const u = new Uint8Array(4);
+  let k, S;
+  const C = (
+    /* permutation of code lengths */
+    new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15])
+  );
+  if (z(t) || !t.output || !t.input && t.avail_in !== 0)
+    return D;
+  e = t.state, e.mode === U && (e.mode = X), c = t.next_out, o = t.output, v = t.avail_out, r = t.next_in, s = t.input, d = t.avail_in, a = e.hold, i = e.bits, A = d, h = v, y = O;
+  e:
+    for (; ; )
+      switch (e.mode) {
+        case Q:
+          if (e.wrap === 0) {
+            e.mode = X;
+            break;
+          }
+          for (; i < 16; ) {
+            if (d === 0)
+              break e;
+            d--, a += s[r++] << i, i += 8;
+          }
+          if (e.wrap & 2 && a === 35615) {
+            e.wbits === 0 && (e.wbits = 15), e.check = 0, u[0] = a & 255, u[1] = a >>> 8 & 255, e.check = T(e.check, u, 2, 0), a = 0, i = 0, e.mode = we;
+            break;
+          }
+          if (e.head && (e.head.done = !1), !(e.wrap & 1) || /* check if zlib header allowed */
+          (((a & 255) << 8) + (a >> 8)) % 31) {
+            t.msg = "incorrect header check", e.mode = x;
+            break;
+          }
+          if ((a & 15) !== ue) {
+            t.msg = "unknown compression method", e.mode = x;
+            break;
+          }
+          if (a >>>= 4, i -= 4, _ = (a & 15) + 8, e.wbits === 0 && (e.wbits = _), _ > 15 || _ > e.wbits) {
+            t.msg = "invalid window size", e.mode = x;
+            break;
+          }
+          e.dmax = 1 << e.wbits, e.flags = 0, t.adler = e.check = 1, e.mode = a & 512 ? ye : U, a = 0, i = 0;
+          break;
+        case we:
+          for (; i < 16; ) {
+            if (d === 0)
+              break e;
+            d--, a += s[r++] << i, i += 8;
+          }
+          if (e.flags = a, (e.flags & 255) !== ue) {
+            t.msg = "unknown compression method", e.mode = x;
+            break;
+          }
+          if (e.flags & 57344) {
+            t.msg = "unknown header flags set", e.mode = x;
+            break;
+          }
+          e.head && (e.head.text = a >> 8 & 1), e.flags & 512 && e.wrap & 4 && (u[0] = a & 255, u[1] = a >>> 8 & 255, e.check = T(e.check, u, 2, 0)), a = 0, i = 0, e.mode = be;
+        case be:
+          for (; i < 32; ) {
+            if (d === 0)
+              break e;
+            d--, a += s[r++] << i, i += 8;
+          }
+          e.head && (e.head.time = a), e.flags & 512 && e.wrap & 4 && (u[0] = a & 255, u[1] = a >>> 8 & 255, u[2] = a >>> 16 & 255, u[3] = a >>> 24 & 255, e.check = T(e.check, u, 4, 0)), a = 0, i = 0, e.mode = me;
+        case me:
+          for (; i < 16; ) {
+            if (d === 0)
+              break e;
+            d--, a += s[r++] << i, i += 8;
+          }
+          e.head && (e.head.xflags = a & 255, e.head.os = a >> 8), e.flags & 512 && e.wrap & 4 && (u[0] = a & 255, u[1] = a >>> 8 & 255, e.check = T(e.check, u, 2, 0)), a = 0, i = 0, e.mode = ke;
+        case ke:
+          if (e.flags & 1024) {
+            for (; i < 16; ) {
+              if (d === 0)
+                break e;
+              d--, a += s[r++] << i, i += 8;
+            }
+            e.length = a, e.head && (e.head.extra_len = a), e.flags & 512 && e.wrap & 4 && (u[0] = a & 255, u[1] = a >>> 8 & 255, e.check = T(e.check, u, 2, 0)), a = 0, i = 0;
+          } else e.head && (e.head.extra = null);
+          e.mode = _e;
+        case _e:
+          if (e.flags & 1024 && (l = e.length, l > d && (l = d), l && (e.head && (_ = e.head.extra_len - e.length, e.head.extra || (e.head.extra = new Uint8Array(e.head.extra_len)), e.head.extra.set(
+            s.subarray(
+              r,
+              // extra field is limited to 65536 bytes
+              // - no need for additional size check
+              r + l
+            ),
+            /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
+            _
+          )), e.flags & 512 && e.wrap & 4 && (e.check = T(e.check, s, l, r)), d -= l, r += l, e.length -= l), e.length))
+            break e;
+          e.length = 0, e.mode = ge;
+        case ge:
+          if (e.flags & 2048) {
+            if (d === 0)
+              break e;
+            l = 0;
+            do
+              _ = s[r + l++], e.head && _ && e.length < 65536 && (e.head.name += String.fromCharCode(_));
+            while (_ && l < d);
+            if (e.flags & 512 && e.wrap & 4 && (e.check = T(e.check, s, l, r)), d -= l, r += l, _)
+              break e;
+          } else e.head && (e.head.name = null);
+          e.length = 0, e.mode = pe;
+        case pe:
+          if (e.flags & 4096) {
+            if (d === 0)
+              break e;
+            l = 0;
+            do
+              _ = s[r + l++], e.head && _ && e.length < 65536 && (e.head.comment += String.fromCharCode(_));
+            while (_ && l < d);
+            if (e.flags & 512 && e.wrap & 4 && (e.check = T(e.check, s, l, r)), d -= l, r += l, _)
+              break e;
+          } else e.head && (e.head.comment = null);
+          e.mode = ve;
+        case ve:
+          if (e.flags & 512) {
+            for (; i < 16; ) {
+              if (d === 0)
+                break e;
+              d--, a += s[r++] << i, i += 8;
+            }
+            if (e.wrap & 4 && a !== (e.check & 65535)) {
+              t.msg = "header crc mismatch", e.mode = x;
+              break;
+            }
+            a = 0, i = 0;
+          }
+          e.head && (e.head.hcrc = e.flags >> 9 & 1, e.head.done = !0), t.adler = e.check = 0, e.mode = U;
+          break;
+        case ye:
+          for (; i < 32; ) {
+            if (d === 0)
+              break e;
+            d--, a += s[r++] << i, i += 8;
+          }
+          t.adler = e.check = ze(a), a = 0, i = 0, e.mode = J;
+        case J:
+          if (e.havedict === 0)
+            return t.next_out = c, t.avail_out = v, t.next_in = r, t.avail_in = d, e.hold = a, e.bits = i, zt;
+          t.adler = e.check = 1, e.mode = U;
+        case U:
+          if (n === Ct || n === G)
+            break e;
+        case X:
+          if (e.last) {
+            a >>>= i & 7, i -= i & 7, e.mode = $;
+            break;
+          }
+          for (; i < 3; ) {
+            if (d === 0)
+              break e;
+            d--, a += s[r++] << i, i += 8;
+          }
+          switch (e.last = a & 1, a >>>= 1, i -= 1, a & 3) {
+            case 0:
+              e.mode = xe;
+              break;
+            case 1:
+              if (Lt(e), e.mode = P, n === G) {
+                a >>>= 2, i -= 2;
+                break e;
+              }
+              break;
+            case 2:
+              e.mode = Ee;
+              break;
+            case 3:
+              t.msg = "invalid block type", e.mode = x;
+          }
+          a >>>= 2, i -= 2;
+          break;
+        case xe:
+          for (a >>>= i & 7, i -= i & 7; i < 32; ) {
+            if (d === 0)
+              break e;
+            d--, a += s[r++] << i, i += 8;
+          }
+          if ((a & 65535) !== (a >>> 16 ^ 65535)) {
+            t.msg = "invalid stored block lengths", e.mode = x;
+            break;
+          }
+          if (e.length = a & 65535, a = 0, i = 0, e.mode = Y, n === G)
+            break e;
+        case Y:
+          e.mode = Ae;
+        case Ae:
+          if (l = e.length, l) {
+            if (l > d && (l = d), l > v && (l = v), l === 0)
+              break e;
+            o.set(s.subarray(r, r + l), c), d -= l, r += l, v -= l, c += l, e.length -= l;
+            break;
+          }
+          e.mode = U;
+          break;
+        case Ee:
+          for (; i < 14; ) {
+            if (d === 0)
+              break e;
+            d--, a += s[r++] << i, i += 8;
+          }
+          if (e.nlen = (a & 31) + 257, a >>>= 5, i -= 5, e.ndist = (a & 31) + 1, a >>>= 5, i -= 5, e.ncode = (a & 15) + 4, a >>>= 4, i -= 4, e.nlen > 286 || e.ndist > 30) {
+            t.msg = "too many length or distance symbols", e.mode = x;
+            break;
+          }
+          e.have = 0, e.mode = Re;
+        case Re:
+          for (; e.have < e.ncode; ) {
+            for (; i < 3; ) {
+              if (d === 0)
+                break e;
+              d--, a += s[r++] << i, i += 8;
+            }
+            e.lens[C[e.have++]] = a & 7, a >>>= 3, i -= 3;
+          }
+          for (; e.have < 19; )
+            e.lens[C[e.have++]] = 0;
+          if (e.lencode = e.lendyn, e.lenbits = 7, k = { bits: e.lenbits }, y = N(Bt, e.lens, 0, 19, e.lencode, 0, e.work, k), e.lenbits = k.bits, y) {
+            t.msg = "invalid code lengths set", e.mode = x;
+            break;
+          }
+          e.have = 0, e.mode = Ze;
+        case Ze:
+          for (; e.have < e.nlen + e.ndist; ) {
+            for (; g = e.lencode[a & (1 << e.lenbits) - 1], m = g >>> 24, b = g >>> 16 & 255, f = g & 65535, !(m <= i); ) {
+              if (d === 0)
+                break e;
+              d--, a += s[r++] << i, i += 8;
+            }
+            if (f < 16)
+              a >>>= m, i -= m, e.lens[e.have++] = f;
+            else {
+              if (f === 16) {
+                for (S = m + 2; i < S; ) {
+                  if (d === 0)
+                    break e;
+                  d--, a += s[r++] << i, i += 8;
+                }
+                if (a >>>= m, i -= m, e.have === 0) {
+                  t.msg = "invalid bit length repeat", e.mode = x;
+                  break;
+                }
+                _ = e.lens[e.have - 1], l = 3 + (a & 3), a >>>= 2, i -= 2;
+              } else if (f === 17) {
+                for (S = m + 3; i < S; ) {
+                  if (d === 0)
+                    break e;
+                  d--, a += s[r++] << i, i += 8;
+                }
+                a >>>= m, i -= m, _ = 0, l = 3 + (a & 7), a >>>= 3, i -= 3;
+              } else {
+                for (S = m + 7; i < S; ) {
+                  if (d === 0)
+                    break e;
+                  d--, a += s[r++] << i, i += 8;
+                }
+                a >>>= m, i -= m, _ = 0, l = 11 + (a & 127), a >>>= 7, i -= 7;
+              }
+              if (e.have + l > e.nlen + e.ndist) {
+                t.msg = "invalid bit length repeat", e.mode = x;
+                break;
+              }
+              for (; l--; )
+                e.lens[e.have++] = _;
+            }
+          }
+          if (e.mode === x)
+            break;
+          if (e.lens[256] === 0) {
+            t.msg = "invalid code -- missing end-of-block", e.mode = x;
+            break;
+          }
+          if (e.lenbits = 9, k = { bits: e.lenbits }, y = N(Le, e.lens, 0, e.nlen, e.lencode, 0, e.work, k), e.lenbits = k.bits, y) {
+            t.msg = "invalid literal/lengths set", e.mode = x;
+            break;
+          }
+          if (e.distbits = 6, e.distcode = e.distdyn, k = { bits: e.distbits }, y = N(Ge, e.lens, e.nlen, e.ndist, e.distcode, 0, e.work, k), e.distbits = k.bits, y) {
+            t.msg = "invalid distances set", e.mode = x;
+            break;
+          }
+          if (e.mode = P, n === G)
+            break e;
+        case P:
+          e.mode = q;
+        case q:
+          if (d >= 6 && v >= 258) {
+            t.next_out = c, t.avail_out = v, t.next_in = r, t.avail_in = d, e.hold = a, e.bits = i, Rt(t, h), c = t.next_out, o = t.output, v = t.avail_out, r = t.next_in, s = t.input, d = t.avail_in, a = e.hold, i = e.bits, e.mode === U && (e.back = -1);
+            break;
+          }
+          for (e.back = 0; g = e.lencode[a & (1 << e.lenbits) - 1], m = g >>> 24, b = g >>> 16 & 255, f = g & 65535, !(m <= i); ) {
+            if (d === 0)
+              break e;
+            d--, a += s[r++] << i, i += 8;
+          }
+          if (b && !(b & 240)) {
+            for (w = m, E = b, p = f; g = e.lencode[p + ((a & (1 << w + E) - 1) >> w)], m = g >>> 24, b = g >>> 16 & 255, f = g & 65535, !(w + m <= i); ) {
+              if (d === 0)
+                break e;
+              d--, a += s[r++] << i, i += 8;
+            }
+            a >>>= w, i -= w, e.back += w;
+          }
+          if (a >>>= m, i -= m, e.back += m, e.length = f, b === 0) {
+            e.mode = Be;
+            break;
+          }
+          if (b & 32) {
+            e.back = -1, e.mode = U;
+            break;
+          }
+          if (b & 64) {
+            t.msg = "invalid literal/length code", e.mode = x;
+            break;
+          }
+          e.extra = b & 15, e.mode = Se;
+        case Se:
+          if (e.extra) {
+            for (S = e.extra; i < S; ) {
+              if (d === 0)
+                break e;
+              d--, a += s[r++] << i, i += 8;
+            }
+            e.length += a & (1 << e.extra) - 1, a >>>= e.extra, i -= e.extra, e.back += e.extra;
+          }
+          e.was = e.length, e.mode = De;
+        case De:
+          for (; g = e.distcode[a & (1 << e.distbits) - 1], m = g >>> 24, b = g >>> 16 & 255, f = g & 65535, !(m <= i); ) {
+            if (d === 0)
+              break e;
+            d--, a += s[r++] << i, i += 8;
+          }
+          if (!(b & 240)) {
+            for (w = m, E = b, p = f; g = e.distcode[p + ((a & (1 << w + E) - 1) >> w)], m = g >>> 24, b = g >>> 16 & 255, f = g & 65535, !(w + m <= i); ) {
+              if (d === 0)
+                break e;
+              d--, a += s[r++] << i, i += 8;
+            }
+            a >>>= w, i -= w, e.back += w;
+          }
+          if (a >>>= m, i -= m, e.back += m, b & 64) {
+            t.msg = "invalid distance code", e.mode = x;
+            break;
+          }
+          e.offset = f, e.extra = b & 15, e.mode = Te;
+        case Te:
+          if (e.extra) {
+            for (S = e.extra; i < S; ) {
+              if (d === 0)
+                break e;
+              d--, a += s[r++] << i, i += 8;
+            }
+            e.offset += a & (1 << e.extra) - 1, a >>>= e.extra, i -= e.extra, e.back += e.extra;
+          }
+          if (e.offset > e.dmax) {
+            t.msg = "invalid distance too far back", e.mode = x;
+            break;
+          }
+          e.mode = Ue;
+        case Ue:
+          if (v === 0)
+            break e;
+          if (l = h - v, e.offset > l) {
+            if (l = e.offset - l, l > e.whave && e.sane) {
+              t.msg = "invalid distance too far back", e.mode = x;
+              break;
+            }
+            l > e.wnext ? (l -= e.wnext, R = e.wsize - l) : R = e.wnext - l, l > e.length && (l = e.length), Z = e.window;
+          } else
+            Z = o, R = c - e.offset, l = e.length;
+          l > v && (l = v), v -= l, e.length -= l;
+          do
+            o[c++] = Z[R++];
+          while (--l);
+          e.length === 0 && (e.mode = q);
+          break;
+        case Be:
+          if (v === 0)
+            break e;
+          o[c++] = e.length, v--, e.mode = q;
+          break;
+        case $:
+          if (e.wrap) {
+            for (; i < 32; ) {
+              if (d === 0)
+                break e;
+              d--, a |= s[r++] << i, i += 8;
+            }
+            if (h -= v, t.total_out += h, e.total += h, e.wrap & 4 && h && (t.adler = e.check = /*UPDATE_CHECK(state.check, put - _out, _out);*/
+            e.flags ? T(e.check, o, h, c - h) : ie(e.check, o, h, c - h)), h = v, e.wrap & 4 && (e.flags ? a : ze(a)) !== e.check) {
+              t.msg = "incorrect data check", e.mode = x;
+              break;
+            }
+            a = 0, i = 0;
+          }
+          e.mode = Ce;
+        case Ce:
+          if (e.wrap && e.flags) {
+            for (; i < 32; ) {
+              if (d === 0)
+                break e;
+              d--, a += s[r++] << i, i += 8;
+            }
+            if (e.wrap & 4 && a !== (e.total & 4294967295)) {
+              t.msg = "incorrect length check", e.mode = x;
+              break;
+            }
+            a = 0, i = 0;
+          }
+          e.mode = Oe;
+        case Oe:
+          y = Ot;
+          break e;
+        case x:
+          y = Pe;
+          break e;
+        case Je:
+          return qe;
+        case Qe:
+        default:
+          return D;
+      }
+  return t.next_out = c, t.avail_out = v, t.next_in = r, t.avail_in = d, e.hold = a, e.bits = i, (e.wsize || h !== t.avail_out && e.mode < x && (e.mode < $ || n !== he)) && $e(t, t.output, t.next_out, h - t.avail_out), A -= t.avail_in, h -= t.avail_out, t.total_in += A, t.total_out += h, e.total += h, e.wrap & 4 && h && (t.adler = e.check = /*UPDATE_CHECK(state.check, strm.next_out - _out, _out);*/
+  e.flags ? T(e.check, o, h, t.next_out - h) : ie(e.check, o, h, t.next_out - h)), t.data_type = e.bits + (e.last ? 64 : 0) + (e.mode === U ? 128 : 0) + (e.mode === P || e.mode === Y ? 256 : 0), (A === 0 && h === 0 || n === he) && y === O && (y = It), y;
+}, Pt = (t) => {
+  if (z(t))
+    return D;
+  let n = t.state;
+  return n.window && (n.window = null), t.state = null, O;
+}, qt = (t, n) => {
+  if (z(t))
+    return D;
+  const e = t.state;
+  return e.wrap & 2 ? (e.head = n, n.done = !1, O) : D;
+}, Jt = (t, n) => {
+  const e = n.length;
+  let s, o, r;
+  return z(t) || (s = t.state, s.wrap !== 0 && s.mode !== J) ? D : s.mode === J && (o = 1, o = ie(o, n, e, 0), o !== s.check) ? Pe : (r = $e(t, n, e, e), r ? (s.mode = Je, qe) : (s.havedict = 1, O));
+};
+var Qt = We, Vt = Xe, Wt = Ve, Xt = Kt, Yt = Ye, $t = Gt, en = Pt, tn = qt, nn = Jt, an = "pako inflate (from Nodeca project)", B = {
+  inflateReset: Qt,
+  inflateReset2: Vt,
+  inflateResetKeep: Wt,
+  inflateInit: Xt,
+  inflateInit2: Yt,
+  inflate: $t,
+  inflateEnd: en,
+  inflateGetHeader: tn,
+  inflateSetDictionary: nn,
+  inflateInfo: an
+};
+function rn() {
+  this.text = 0, this.time = 0, this.xflags = 0, this.os = 0, this.extra = null, this.extra_len = 0, this.name = "", this.comment = "", this.hcrc = 0, this.done = !1;
+}
+var sn = rn;
+const et = Object.prototype.toString, {
+  Z_NO_FLUSH: on,
+  Z_FINISH: ln,
+  Z_OK: j,
+  Z_STREAM_END: ne,
+  Z_NEED_DICT: ae,
+  Z_STREAM_ERROR: dn,
+  Z_DATA_ERROR: Me,
+  Z_MEM_ERROR: fn
+} = je;
+function V(t) {
+  this.options = He.assign({
+    chunkSize: 1024 * 64,
+    windowBits: 15,
+    to: ""
+  }, t || {});
+  const n = this.options;
+  n.raw && n.windowBits >= 0 && n.windowBits < 16 && (n.windowBits = -n.windowBits, n.windowBits === 0 && (n.windowBits = -15)), n.windowBits >= 0 && n.windowBits < 16 && !(t && t.windowBits) && (n.windowBits += 32), n.windowBits > 15 && n.windowBits < 48 && !(n.windowBits & 15) && (n.windowBits |= 15), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new At(), this.strm.avail_out = 0;
+  let e = B.inflateInit2(
+    this.strm,
+    n.windowBits
+  );
+  if (e !== j)
+    throw new Error(re[e]);
+  if (this.header = new sn(), B.inflateGetHeader(this.strm, this.header), n.dictionary && (typeof n.dictionary == "string" ? n.dictionary = se.string2buf(n.dictionary) : et.call(n.dictionary) === "[object ArrayBuffer]" && (n.dictionary = new Uint8Array(n.dictionary)), n.raw && (e = B.inflateSetDictionary(this.strm, n.dictionary), e !== j)))
+    throw new Error(re[e]);
+}
+V.prototype.push = function(t, n) {
+  const e = this.strm, s = this.options.chunkSize, o = this.options.dictionary;
+  let r, c, d;
+  if (this.ended) return !1;
+  for (n === ~~n ? c = n : c = n === !0 ? ln : on, et.call(t) === "[object ArrayBuffer]" ? e.input = new Uint8Array(t) : e.input = t, e.next_in = 0, e.avail_in = e.input.length; ; ) {
+    for (e.avail_out === 0 && (e.output = new Uint8Array(s), e.next_out = 0, e.avail_out = s), r = B.inflate(e, c), r === ae && o && (r = B.inflateSetDictionary(e, o), r === j ? r = B.inflate(e, c) : r === Me && (r = ae)); e.avail_in > 0 && r === ne && e.state.wrap > 0 && t[e.next_in] !== 0; )
+      B.inflateReset(e), r = B.inflate(e, c);
+    switch (r) {
+      case dn:
+      case Me:
+      case ae:
+      case fn:
+        return this.onEnd(r), this.ended = !0, !1;
+    }
+    if (d = e.avail_out, e.next_out && (e.avail_out === 0 || r === ne))
+      if (this.options.to === "string") {
+        let v = se.utf8border(e.output, e.next_out), a = e.next_out - v, i = se.buf2string(e.output, v);
+        e.next_out = a, e.avail_out = s - a, a && e.output.set(e.output.subarray(v, v + a), 0), this.onData(i);
+      } else
+        this.onData(e.output.length === e.next_out ? e.output : e.output.subarray(0, e.next_out));
+    if (!(r === j && d === 0)) {
+      if (r === ne)
+        return r = B.inflateEnd(this.strm), this.onEnd(r), this.ended = !0, !0;
+      if (e.avail_in === 0) break;
+    }
+  }
+  return !0;
+};
+V.prototype.onData = function(t) {
+  this.chunks.push(t);
+};
+V.prototype.onEnd = function(t) {
+  t === j && (this.options.to === "string" ? this.result = this.chunks.join("") : this.result = He.flattenChunks(this.chunks)), this.chunks = [], this.err = t, this.msg = this.strm.msg;
+};
+function cn(t, n) {
+  const e = new V(n);
+  if (e.push(t), e.err) throw e.msg || re[e.err];
+  return e.result;
+}
+var hn = cn, un = {
+  inflate: hn
+};
+const { inflate: wn } = un;
+var bn = wn;
+export {
+  bn as w
+};