create-swdg-frontend 0.1.0

package/template/public/Cesium1.119/Workers/decodeGoogleEarthEnterprisePacket.js

@@ -0,0 +1,1836 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.119
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import { a as Se } from "./chunk-PXCJYT2S.js";
+import { a as D } from "./chunk-II4VNKYR.js";
+import { b as ae } from "./chunk-UH2WFNTA.js";
+import { c as R, d as Ot, e as me } from "./chunk-PEYJTJPE.js";
+var Ie = R((Li, Ae) => {
+  "use strict";
+  var zt = (t, i, e, r) => {
+    let s = (t & 65535) | 0,
+      n = ((t >>> 16) & 65535) | 0,
+      c = 0;
+    for (; e !== 0; ) {
+      ((c = e > 2e3 ? 2e3 : e), (e -= c));
+      do ((s = (s + i[r++]) | 0), (n = (n + s) | 0));
+      while (--c);
+      ((s %= 65521), (n %= 65521));
+    }
+    return s | (n << 16) | 0;
+  };
+  Ae.exports = zt;
+});
+var De = R((Pi, Re) => {
+  "use strict";
+  var Ht = () => {
+      let t,
+        i = [];
+      for (var e = 0; e < 256; e++) {
+        t = e;
+        for (var r = 0; r < 8; r++)
+          t = t & 1 ? 3988292384 ^ (t >>> 1) : t >>> 1;
+        i[e] = t;
+      }
+      return i;
+    },
+    Ft = new Uint32Array(Ht()),
+    Vt = (t, i, e, r) => {
+      let s = Ft,
+        n = r + e;
+      t ^= -1;
+      for (let c = r; c < n; c++) t = (t >>> 8) ^ s[(t ^ i[c]) & 255];
+      return t ^ -1;
+    };
+  Re.exports = Vt;
+});
+var Oe = R((zi, Ue) => {
+  "use strict";
+  Ue.exports = function (i, e) {
+    let r,
+      s,
+      n,
+      c,
+      f,
+      _,
+      a,
+      o,
+      v,
+      w,
+      l,
+      u,
+      I,
+      p,
+      x,
+      T,
+      g,
+      d,
+      E,
+      A,
+      h,
+      S,
+      k,
+      b,
+      m = i.state;
+    ((r = i.next_in),
+      (k = i.input),
+      (s = r + (i.avail_in - 5)),
+      (n = i.next_out),
+      (b = i.output),
+      (c = n - (e - i.avail_out)),
+      (f = n + (i.avail_out - 257)),
+      (_ = m.dmax),
+      (a = m.wsize),
+      (o = m.whave),
+      (v = m.wnext),
+      (w = m.window),
+      (l = m.hold),
+      (u = m.bits),
+      (I = m.lencode),
+      (p = m.distcode),
+      (x = (1 << m.lenbits) - 1),
+      (T = (1 << m.distbits) - 1));
+    e: do {
+      (u < 15 && ((l += k[r++] << u), (u += 8), (l += k[r++] << u), (u += 8)),
+        (g = I[l & x]));
+      t: for (;;) {
+        if (
+          ((d = g >>> 24),
+          (l >>>= d),
+          (u -= d),
+          (d = (g >>> 16) & 255),
+          d === 0)
+        )
+          b[n++] = g & 65535;
+        else if (d & 16) {
+          ((E = g & 65535),
+            (d &= 15),
+            d &&
+              (u < d && ((l += k[r++] << u), (u += 8)),
+              (E += l & ((1 << d) - 1)),
+              (l >>>= d),
+              (u -= d)),
+            u < 15 &&
+              ((l += k[r++] << u), (u += 8), (l += k[r++] << u), (u += 8)),
+            (g = p[l & T]));
+          i: for (;;) {
+            if (
+              ((d = g >>> 24),
+              (l >>>= d),
+              (u -= d),
+              (d = (g >>> 16) & 255),
+              d & 16)
+            ) {
+              if (
+                ((A = g & 65535),
+                (d &= 15),
+                u < d &&
+                  ((l += k[r++] << u),
+                  (u += 8),
+                  u < d && ((l += k[r++] << u), (u += 8))),
+                (A += l & ((1 << d) - 1)),
+                A > _)
+              ) {
+                ((i.msg = "invalid distance too far back"), (m.mode = 16209));
+                break e;
+              }
+              if (((l >>>= d), (u -= d), (d = n - c), A > d)) {
+                if (((d = A - d), d > o && m.sane)) {
+                  ((i.msg = "invalid distance too far back"), (m.mode = 16209));
+                  break e;
+                }
+                if (((h = 0), (S = w), v === 0)) {
+                  if (((h += a - d), d < E)) {
+                    E -= d;
+                    do b[n++] = w[h++];
+                    while (--d);
+                    ((h = n - A), (S = b));
+                  }
+                } else if (v < d) {
+                  if (((h += a + v - d), (d -= v), d < E)) {
+                    E -= d;
+                    do b[n++] = w[h++];
+                    while (--d);
+                    if (((h = 0), v < E)) {
+                      ((d = v), (E -= d));
+                      do b[n++] = w[h++];
+                      while (--d);
+                      ((h = n - A), (S = b));
+                    }
+                  }
+                } else if (((h += v - d), d < E)) {
+                  E -= d;
+                  do b[n++] = w[h++];
+                  while (--d);
+                  ((h = n - A), (S = b));
+                }
+                for (; E > 2; )
+                  ((b[n++] = S[h++]),
+                    (b[n++] = S[h++]),
+                    (b[n++] = S[h++]),
+                    (E -= 3));
+                E && ((b[n++] = S[h++]), E > 1 && (b[n++] = S[h++]));
+              } else {
+                h = n - A;
+                do
+                  ((b[n++] = b[h++]),
+                    (b[n++] = b[h++]),
+                    (b[n++] = b[h++]),
+                    (E -= 3));
+                while (E > 2);
+                E && ((b[n++] = b[h++]), E > 1 && (b[n++] = b[h++]));
+              }
+            } else if (d & 64) {
+              ((i.msg = "invalid distance code"), (m.mode = 16209));
+              break e;
+            } else {
+              g = p[(g & 65535) + (l & ((1 << d) - 1))];
+              continue i;
+            }
+            break;
+          }
+        } else if (d & 64)
+          if (d & 32) {
+            m.mode = 16191;
+            break e;
+          } else {
+            ((i.msg = "invalid literal/length code"), (m.mode = 16209));
+            break e;
+          }
+        else {
+          g = I[(g & 65535) + (l & ((1 << d) - 1))];
+          continue t;
+        }
+        break;
+      }
+    } while (r < s && n < f);
+    ((E = u >> 3),
+      (r -= E),
+      (u -= E << 3),
+      (l &= (1 << u) - 1),
+      (i.next_in = r),
+      (i.next_out = n),
+      (i.avail_in = r < s ? 5 + (s - r) : 5 - (r - s)),
+      (i.avail_out = n < f ? 257 + (f - n) : 257 - (n - f)),
+      (m.hold = l),
+      (m.bits = u));
+  };
+});
+var Me = R((Hi, Ne) => {
+  "use strict";
+  var Gt = new Uint16Array([
+      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,
+    ]),
+    Yt = new Uint8Array([
+      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,
+    ]),
+    Xt = new Uint16Array([
+      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,
+    ]),
+    qt = new Uint8Array([
+      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,
+    ]),
+    Kt = (t, i, e, r, s, n, c, f) => {
+      let _ = f.bits,
+        a = 0,
+        o = 0,
+        v = 0,
+        w = 0,
+        l = 0,
+        u = 0,
+        I = 0,
+        p = 0,
+        x = 0,
+        T = 0,
+        g,
+        d,
+        E,
+        A,
+        h,
+        S = null,
+        k,
+        b = new Uint16Array(16),
+        m = new Uint16Array(16),
+        L = null,
+        Ee,
+        W,
+        Q;
+      for (a = 0; a <= 15; a++) b[a] = 0;
+      for (o = 0; o < r; o++) b[i[e + o]]++;
+      for (l = _, w = 15; w >= 1 && b[w] === 0; w--);
+      if ((l > w && (l = w), w === 0))
+        return (
+          (s[n++] = (1 << 24) | (64 << 16) | 0),
+          (s[n++] = (1 << 24) | (64 << 16) | 0),
+          (f.bits = 1),
+          0
+        );
+      for (v = 1; v < w && b[v] === 0; v++);
+      for (l < v && (l = v), p = 1, a = 1; a <= 15; a++)
+        if (((p <<= 1), (p -= b[a]), p < 0)) return -1;
+      if (p > 0 && (t === 0 || w !== 1)) return -1;
+      for (m[1] = 0, a = 1; a < 15; a++) m[a + 1] = m[a] + b[a];
+      for (o = 0; o < r; o++) i[e + o] !== 0 && (c[m[i[e + o]]++] = o);
+      if (
+        (t === 0
+          ? ((S = L = c), (k = 20))
+          : t === 1
+            ? ((S = Gt), (L = Yt), (k = 257))
+            : ((S = Xt), (L = qt), (k = 0)),
+        (T = 0),
+        (o = 0),
+        (a = v),
+        (h = n),
+        (u = l),
+        (I = 0),
+        (E = -1),
+        (x = 1 << l),
+        (A = x - 1),
+        (t === 1 && x > 852) || (t === 2 && x > 592))
+      )
+        return 1;
+      for (;;) {
+        ((Ee = a - I),
+          c[o] + 1 < k
+            ? ((W = 0), (Q = c[o]))
+            : c[o] >= k
+              ? ((W = L[c[o] - k]), (Q = S[c[o] - k]))
+              : ((W = 96), (Q = 0)),
+          (g = 1 << (a - I)),
+          (d = 1 << u),
+          (v = d));
+        do ((d -= g), (s[h + (T >> I) + d] = (Ee << 24) | (W << 16) | Q | 0));
+        while (d !== 0);
+        for (g = 1 << (a - 1); T & g; ) g >>= 1;
+        if ((g !== 0 ? ((T &= g - 1), (T += g)) : (T = 0), o++, --b[a] === 0)) {
+          if (a === w) break;
+          a = i[e + c[o]];
+        }
+        if (a > l && (T & A) !== E) {
+          for (
+            I === 0 && (I = l), h += v, u = a - I, p = 1 << u;
+            u + I < w && ((p -= b[u + I]), !(p <= 0));
+          )
+            (u++, (p <<= 1));
+          if (((x += 1 << u), (t === 1 && x > 852) || (t === 2 && x > 592)))
+            return 1;
+          ((E = T & A), (s[E] = (l << 24) | (u << 16) | (h - n) | 0));
+        }
+      }
+      return (
+        T !== 0 && (s[h + T] = ((a - I) << 24) | (64 << 16) | 0),
+        (f.bits = l),
+        0
+      );
+    };
+  Ne.exports = Kt;
+});
+var J = R((Fi, Ze) => {
+  "use strict";
+  Ze.exports = {
+    Z_NO_FLUSH: 0,
+    Z_PARTIAL_FLUSH: 1,
+    Z_SYNC_FLUSH: 2,
+    Z_FULL_FLUSH: 3,
+    Z_FINISH: 4,
+    Z_BLOCK: 5,
+    Z_TREES: 6,
+    Z_OK: 0,
+    Z_STREAM_END: 1,
+    Z_NEED_DICT: 2,
+    Z_ERRNO: -1,
+    Z_STREAM_ERROR: -2,
+    Z_DATA_ERROR: -3,
+    Z_MEM_ERROR: -4,
+    Z_BUF_ERROR: -5,
+    Z_NO_COMPRESSION: 0,
+    Z_BEST_SPEED: 1,
+    Z_BEST_COMPRESSION: 9,
+    Z_DEFAULT_COMPRESSION: -1,
+    Z_FILTERED: 1,
+    Z_HUFFMAN_ONLY: 2,
+    Z_RLE: 3,
+    Z_FIXED: 4,
+    Z_DEFAULT_STRATEGY: 0,
+    Z_BINARY: 0,
+    Z_TEXT: 1,
+    Z_UNKNOWN: 2,
+    Z_DEFLATED: 8,
+  };
+});
+var bt = R((Vi, O) => {
+  "use strict";
+  var he = Ie(),
+    M = De(),
+    jt = Oe(),
+    X = Me(),
+    Wt = 0,
+    st = 1,
+    ft = 2,
+    {
+      Z_FINISH: Be,
+      Z_BLOCK: Qt,
+      Z_TREES: $,
+      Z_OK: P,
+      Z_STREAM_END: Jt,
+      Z_NEED_DICT: $t,
+      Z_STREAM_ERROR: U,
+      Z_DATA_ERROR: lt,
+      Z_MEM_ERROR: ue,
+      Z_BUF_ERROR: ei,
+      Z_DEFLATED: Ce,
+    } = J(),
+    ne = 16180,
+    Le = 16181,
+    Pe = 16182,
+    ze = 16183,
+    He = 16184,
+    Fe = 16185,
+    Ve = 16186,
+    Ge = 16187,
+    Ye = 16188,
+    Xe = 16189,
+    ie = 16190,
+    Z = 16191,
+    se = 16192,
+    qe = 16193,
+    fe = 16194,
+    Ke = 16195,
+    je = 16196,
+    We = 16197,
+    Qe = 16198,
+    ee = 16199,
+    te = 16200,
+    Je = 16201,
+    $e = 16202,
+    et = 16203,
+    tt = 16204,
+    it = 16205,
+    le = 16206,
+    nt = 16207,
+    rt = 16208,
+    y = 16209,
+    we = 16210,
+    ct = 16211,
+    ti = 852,
+    ii = 592,
+    ni = 15,
+    ri = ni,
+    at = (t) =>
+      ((t >>> 24) & 255) +
+      ((t >>> 8) & 65280) +
+      ((t & 65280) << 8) +
+      ((t & 255) << 24);
+  function ai() {
+    ((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));
+  }
+  var z = (t) => {
+      if (!t) return 1;
+      let i = t.state;
+      return !i || i.strm !== t || i.mode < ne || i.mode > ct ? 1 : 0;
+    },
+    dt = (t) => {
+      if (z(t)) return U;
+      let i = t.state;
+      return (
+        (t.total_in = t.total_out = i.total = 0),
+        (t.msg = ""),
+        i.wrap && (t.adler = i.wrap & 1),
+        (i.mode = ne),
+        (i.last = 0),
+        (i.havedict = 0),
+        (i.flags = -1),
+        (i.dmax = 32768),
+        (i.head = null),
+        (i.hold = 0),
+        (i.bits = 0),
+        (i.lencode = i.lendyn = new Int32Array(ti)),
+        (i.distcode = i.distdyn = new Int32Array(ii)),
+        (i.sane = 1),
+        (i.back = -1),
+        P
+      );
+    },
+    ht = (t) => {
+      if (z(t)) return U;
+      let i = t.state;
+      return ((i.wsize = 0), (i.whave = 0), (i.wnext = 0), dt(t));
+    },
+    ut = (t, i) => {
+      let e;
+      if (z(t)) return U;
+      let r = t.state;
+      return (
+        i < 0 ? ((e = 0), (i = -i)) : ((e = (i >> 4) + 5), i < 48 && (i &= 15)),
+        i && (i < 8 || i > 15)
+          ? U
+          : (r.window !== null && r.wbits !== i && (r.window = null),
+            (r.wrap = e),
+            (r.wbits = i),
+            ht(t))
+      );
+    },
+    wt = (t, i) => {
+      if (!t) return U;
+      let e = new ai();
+      ((t.state = e), (e.strm = t), (e.window = null), (e.mode = ne));
+      let r = ut(t, i);
+      return (r !== P && (t.state = null), r);
+    },
+    oi = (t) => wt(t, ri),
+    ot = !0,
+    ce,
+    de,
+    si = (t) => {
+      if (ot) {
+        ((ce = new Int32Array(512)), (de = new Int32Array(32)));
+        let i = 0;
+        for (; i < 144; ) t.lens[i++] = 8;
+        for (; i < 256; ) t.lens[i++] = 9;
+        for (; i < 280; ) t.lens[i++] = 7;
+        for (; i < 288; ) t.lens[i++] = 8;
+        for (X(st, t.lens, 0, 288, ce, 0, t.work, { bits: 9 }), i = 0; i < 32; )
+          t.lens[i++] = 5;
+        (X(ft, t.lens, 0, 32, de, 0, t.work, { bits: 5 }), (ot = !1));
+      }
+      ((t.lencode = ce), (t.lenbits = 9), (t.distcode = de), (t.distbits = 5));
+    },
+    xt = (t, i, e, r) => {
+      let s,
+        n = t.state;
+      return (
+        n.window === null &&
+          ((n.wsize = 1 << n.wbits),
+          (n.wnext = 0),
+          (n.whave = 0),
+          (n.window = new Uint8Array(n.wsize))),
+        r >= n.wsize
+          ? (n.window.set(i.subarray(e - n.wsize, e), 0),
+            (n.wnext = 0),
+            (n.whave = n.wsize))
+          : ((s = n.wsize - n.wnext),
+            s > r && (s = r),
+            n.window.set(i.subarray(e - r, e - r + s), n.wnext),
+            (r -= s),
+            r
+              ? (n.window.set(i.subarray(e - r, e), 0),
+                (n.wnext = r),
+                (n.whave = n.wsize))
+              : ((n.wnext += s),
+                n.wnext === n.wsize && (n.wnext = 0),
+                n.whave < n.wsize && (n.whave += s))),
+        0
+      );
+    },
+    fi = (t, i) => {
+      let e,
+        r,
+        s,
+        n,
+        c,
+        f,
+        _,
+        a,
+        o,
+        v,
+        w,
+        l,
+        u,
+        I,
+        p = 0,
+        x,
+        T,
+        g,
+        d,
+        E,
+        A,
+        h,
+        S,
+        k = new Uint8Array(4),
+        b,
+        m,
+        L = 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 U;
+      ((e = t.state),
+        e.mode === Z && (e.mode = se),
+        (c = t.next_out),
+        (s = t.output),
+        (_ = t.avail_out),
+        (n = t.next_in),
+        (r = t.input),
+        (f = t.avail_in),
+        (a = e.hold),
+        (o = e.bits),
+        (v = f),
+        (w = _),
+        (S = P));
+      e: for (;;)
+        switch (e.mode) {
+          case ne:
+            if (e.wrap === 0) {
+              e.mode = se;
+              break;
+            }
+            for (; o < 16; ) {
+              if (f === 0) break e;
+              (f--, (a += r[n++] << o), (o += 8));
+            }
+            if (e.wrap & 2 && a === 35615) {
+              (e.wbits === 0 && (e.wbits = 15),
+                (e.check = 0),
+                (k[0] = a & 255),
+                (k[1] = (a >>> 8) & 255),
+                (e.check = M(e.check, k, 2, 0)),
+                (a = 0),
+                (o = 0),
+                (e.mode = Le));
+              break;
+            }
+            if (
+              (e.head && (e.head.done = !1),
+              !(e.wrap & 1) || (((a & 255) << 8) + (a >> 8)) % 31)
+            ) {
+              ((t.msg = "incorrect header check"), (e.mode = y));
+              break;
+            }
+            if ((a & 15) !== Ce) {
+              ((t.msg = "unknown compression method"), (e.mode = y));
+              break;
+            }
+            if (
+              ((a >>>= 4),
+              (o -= 4),
+              (h = (a & 15) + 8),
+              e.wbits === 0 && (e.wbits = h),
+              h > 15 || h > e.wbits)
+            ) {
+              ((t.msg = "invalid window size"), (e.mode = y));
+              break;
+            }
+            ((e.dmax = 1 << e.wbits),
+              (e.flags = 0),
+              (t.adler = e.check = 1),
+              (e.mode = a & 512 ? Xe : Z),
+              (a = 0),
+              (o = 0));
+            break;
+          case Le:
+            for (; o < 16; ) {
+              if (f === 0) break e;
+              (f--, (a += r[n++] << o), (o += 8));
+            }
+            if (((e.flags = a), (e.flags & 255) !== Ce)) {
+              ((t.msg = "unknown compression method"), (e.mode = y));
+              break;
+            }
+            if (e.flags & 57344) {
+              ((t.msg = "unknown header flags set"), (e.mode = y));
+              break;
+            }
+            (e.head && (e.head.text = (a >> 8) & 1),
+              e.flags & 512 &&
+                e.wrap & 4 &&
+                ((k[0] = a & 255),
+                (k[1] = (a >>> 8) & 255),
+                (e.check = M(e.check, k, 2, 0))),
+              (a = 0),
+              (o = 0),
+              (e.mode = Pe));
+          case Pe:
+            for (; o < 32; ) {
+              if (f === 0) break e;
+              (f--, (a += r[n++] << o), (o += 8));
+            }
+            (e.head && (e.head.time = a),
+              e.flags & 512 &&
+                e.wrap & 4 &&
+                ((k[0] = a & 255),
+                (k[1] = (a >>> 8) & 255),
+                (k[2] = (a >>> 16) & 255),
+                (k[3] = (a >>> 24) & 255),
+                (e.check = M(e.check, k, 4, 0))),
+              (a = 0),
+              (o = 0),
+              (e.mode = ze));
+          case ze:
+            for (; o < 16; ) {
+              if (f === 0) break e;
+              (f--, (a += r[n++] << o), (o += 8));
+            }
+            (e.head && ((e.head.xflags = a & 255), (e.head.os = a >> 8)),
+              e.flags & 512 &&
+                e.wrap & 4 &&
+                ((k[0] = a & 255),
+                (k[1] = (a >>> 8) & 255),
+                (e.check = M(e.check, k, 2, 0))),
+              (a = 0),
+              (o = 0),
+              (e.mode = He));
+          case He:
+            if (e.flags & 1024) {
+              for (; o < 16; ) {
+                if (f === 0) break e;
+                (f--, (a += r[n++] << o), (o += 8));
+              }
+              ((e.length = a),
+                e.head && (e.head.extra_len = a),
+                e.flags & 512 &&
+                  e.wrap & 4 &&
+                  ((k[0] = a & 255),
+                  (k[1] = (a >>> 8) & 255),
+                  (e.check = M(e.check, k, 2, 0))),
+                (a = 0),
+                (o = 0));
+            } else e.head && (e.head.extra = null);
+            e.mode = Fe;
+          case Fe:
+            if (
+              e.flags & 1024 &&
+              ((l = e.length),
+              l > f && (l = f),
+              l &&
+                (e.head &&
+                  ((h = e.head.extra_len - e.length),
+                  e.head.extra ||
+                    (e.head.extra = new Uint8Array(e.head.extra_len)),
+                  e.head.extra.set(r.subarray(n, n + l), h)),
+                e.flags & 512 && e.wrap & 4 && (e.check = M(e.check, r, l, n)),
+                (f -= l),
+                (n += l),
+                (e.length -= l)),
+              e.length)
+            )
+              break e;
+            ((e.length = 0), (e.mode = Ve));
+          case Ve:
+            if (e.flags & 2048) {
+              if (f === 0) break e;
+              l = 0;
+              do
+                ((h = r[n + l++]),
+                  e.head &&
+                    h &&
+                    e.length < 65536 &&
+                    (e.head.name += String.fromCharCode(h)));
+              while (h && l < f);
+              if (
+                (e.flags & 512 && e.wrap & 4 && (e.check = M(e.check, r, l, n)),
+                (f -= l),
+                (n += l),
+                h)
+              )
+                break e;
+            } else e.head && (e.head.name = null);
+            ((e.length = 0), (e.mode = Ge));
+          case Ge:
+            if (e.flags & 4096) {
+              if (f === 0) break e;
+              l = 0;
+              do
+                ((h = r[n + l++]),
+                  e.head &&
+                    h &&
+                    e.length < 65536 &&
+                    (e.head.comment += String.fromCharCode(h)));
+              while (h && l < f);
+              if (
+                (e.flags & 512 && e.wrap & 4 && (e.check = M(e.check, r, l, n)),
+                (f -= l),
+                (n += l),
+                h)
+              )
+                break e;
+            } else e.head && (e.head.comment = null);
+            e.mode = Ye;
+          case Ye:
+            if (e.flags & 512) {
+              for (; o < 16; ) {
+                if (f === 0) break e;
+                (f--, (a += r[n++] << o), (o += 8));
+              }
+              if (e.wrap & 4 && a !== (e.check & 65535)) {
+                ((t.msg = "header crc mismatch"), (e.mode = y));
+                break;
+              }
+              ((a = 0), (o = 0));
+            }
+            (e.head && ((e.head.hcrc = (e.flags >> 9) & 1), (e.head.done = !0)),
+              (t.adler = e.check = 0),
+              (e.mode = Z));
+            break;
+          case Xe:
+            for (; o < 32; ) {
+              if (f === 0) break e;
+              (f--, (a += r[n++] << o), (o += 8));
+            }
+            ((t.adler = e.check = at(a)), (a = 0), (o = 0), (e.mode = ie));
+          case ie:
+            if (e.havedict === 0)
+              return (
+                (t.next_out = c),
+                (t.avail_out = _),
+                (t.next_in = n),
+                (t.avail_in = f),
+                (e.hold = a),
+                (e.bits = o),
+                $t
+              );
+            ((t.adler = e.check = 1), (e.mode = Z));
+          case Z:
+            if (i === Qt || i === $) break e;
+          case se:
+            if (e.last) {
+              ((a >>>= o & 7), (o -= o & 7), (e.mode = le));
+              break;
+            }
+            for (; o < 3; ) {
+              if (f === 0) break e;
+              (f--, (a += r[n++] << o), (o += 8));
+            }
+            switch (((e.last = a & 1), (a >>>= 1), (o -= 1), a & 3)) {
+              case 0:
+                e.mode = qe;
+                break;
+              case 1:
+                if ((si(e), (e.mode = ee), i === $)) {
+                  ((a >>>= 2), (o -= 2));
+                  break e;
+                }
+                break;
+              case 2:
+                e.mode = je;
+                break;
+              case 3:
+                ((t.msg = "invalid block type"), (e.mode = y));
+            }
+            ((a >>>= 2), (o -= 2));
+            break;
+          case qe:
+            for (a >>>= o & 7, o -= o & 7; o < 32; ) {
+              if (f === 0) break e;
+              (f--, (a += r[n++] << o), (o += 8));
+            }
+            if ((a & 65535) !== ((a >>> 16) ^ 65535)) {
+              ((t.msg = "invalid stored block lengths"), (e.mode = y));
+              break;
+            }
+            if (
+              ((e.length = a & 65535), (a = 0), (o = 0), (e.mode = fe), i === $)
+            )
+              break e;
+          case fe:
+            e.mode = Ke;
+          case Ke:
+            if (((l = e.length), l)) {
+              if ((l > f && (l = f), l > _ && (l = _), l === 0)) break e;
+              (s.set(r.subarray(n, n + l), c),
+                (f -= l),
+                (n += l),
+                (_ -= l),
+                (c += l),
+                (e.length -= l));
+              break;
+            }
+            e.mode = Z;
+            break;
+          case je:
+            for (; o < 14; ) {
+              if (f === 0) break e;
+              (f--, (a += r[n++] << o), (o += 8));
+            }
+            if (
+              ((e.nlen = (a & 31) + 257),
+              (a >>>= 5),
+              (o -= 5),
+              (e.ndist = (a & 31) + 1),
+              (a >>>= 5),
+              (o -= 5),
+              (e.ncode = (a & 15) + 4),
+              (a >>>= 4),
+              (o -= 4),
+              e.nlen > 286 || e.ndist > 30)
+            ) {
+              ((t.msg = "too many length or distance symbols"), (e.mode = y));
+              break;
+            }
+            ((e.have = 0), (e.mode = We));
+          case We:
+            for (; e.have < e.ncode; ) {
+              for (; o < 3; ) {
+                if (f === 0) break e;
+                (f--, (a += r[n++] << o), (o += 8));
+              }
+              ((e.lens[L[e.have++]] = a & 7), (a >>>= 3), (o -= 3));
+            }
+            for (; e.have < 19; ) e.lens[L[e.have++]] = 0;
+            if (
+              ((e.lencode = e.lendyn),
+              (e.lenbits = 7),
+              (b = { bits: e.lenbits }),
+              (S = X(Wt, e.lens, 0, 19, e.lencode, 0, e.work, b)),
+              (e.lenbits = b.bits),
+              S)
+            ) {
+              ((t.msg = "invalid code lengths set"), (e.mode = y));
+              break;
+            }
+            ((e.have = 0), (e.mode = Qe));
+          case Qe:
+            for (; e.have < e.nlen + e.ndist; ) {
+              for (
+                ;
+                (p = e.lencode[a & ((1 << e.lenbits) - 1)]),
+                  (x = p >>> 24),
+                  (T = (p >>> 16) & 255),
+                  (g = p & 65535),
+                  !(x <= o);
+              ) {
+                if (f === 0) break e;
+                (f--, (a += r[n++] << o), (o += 8));
+              }
+              if (g < 16) ((a >>>= x), (o -= x), (e.lens[e.have++] = g));
+              else {
+                if (g === 16) {
+                  for (m = x + 2; o < m; ) {
+                    if (f === 0) break e;
+                    (f--, (a += r[n++] << o), (o += 8));
+                  }
+                  if (((a >>>= x), (o -= x), e.have === 0)) {
+                    ((t.msg = "invalid bit length repeat"), (e.mode = y));
+                    break;
+                  }
+                  ((h = e.lens[e.have - 1]),
+                    (l = 3 + (a & 3)),
+                    (a >>>= 2),
+                    (o -= 2));
+                } else if (g === 17) {
+                  for (m = x + 3; o < m; ) {
+                    if (f === 0) break e;
+                    (f--, (a += r[n++] << o), (o += 8));
+                  }
+                  ((a >>>= x),
+                    (o -= x),
+                    (h = 0),
+                    (l = 3 + (a & 7)),
+                    (a >>>= 3),
+                    (o -= 3));
+                } else {
+                  for (m = x + 7; o < m; ) {
+                    if (f === 0) break e;
+                    (f--, (a += r[n++] << o), (o += 8));
+                  }
+                  ((a >>>= x),
+                    (o -= x),
+                    (h = 0),
+                    (l = 11 + (a & 127)),
+                    (a >>>= 7),
+                    (o -= 7));
+                }
+                if (e.have + l > e.nlen + e.ndist) {
+                  ((t.msg = "invalid bit length repeat"), (e.mode = y));
+                  break;
+                }
+                for (; l--; ) e.lens[e.have++] = h;
+              }
+            }
+            if (e.mode === y) break;
+            if (e.lens[256] === 0) {
+              ((t.msg = "invalid code -- missing end-of-block"), (e.mode = y));
+              break;
+            }
+            if (
+              ((e.lenbits = 9),
+              (b = { bits: e.lenbits }),
+              (S = X(st, e.lens, 0, e.nlen, e.lencode, 0, e.work, b)),
+              (e.lenbits = b.bits),
+              S)
+            ) {
+              ((t.msg = "invalid literal/lengths set"), (e.mode = y));
+              break;
+            }
+            if (
+              ((e.distbits = 6),
+              (e.distcode = e.distdyn),
+              (b = { bits: e.distbits }),
+              (S = X(ft, e.lens, e.nlen, e.ndist, e.distcode, 0, e.work, b)),
+              (e.distbits = b.bits),
+              S)
+            ) {
+              ((t.msg = "invalid distances set"), (e.mode = y));
+              break;
+            }
+            if (((e.mode = ee), i === $)) break e;
+          case ee:
+            e.mode = te;
+          case te:
+            if (f >= 6 && _ >= 258) {
+              ((t.next_out = c),
+                (t.avail_out = _),
+                (t.next_in = n),
+                (t.avail_in = f),
+                (e.hold = a),
+                (e.bits = o),
+                jt(t, w),
+                (c = t.next_out),
+                (s = t.output),
+                (_ = t.avail_out),
+                (n = t.next_in),
+                (r = t.input),
+                (f = t.avail_in),
+                (a = e.hold),
+                (o = e.bits),
+                e.mode === Z && (e.back = -1));
+              break;
+            }
+            for (
+              e.back = 0;
+              (p = e.lencode[a & ((1 << e.lenbits) - 1)]),
+                (x = p >>> 24),
+                (T = (p >>> 16) & 255),
+                (g = p & 65535),
+                !(x <= o);
+            ) {
+              if (f === 0) break e;
+              (f--, (a += r[n++] << o), (o += 8));
+            }
+            if (T && !(T & 240)) {
+              for (
+                d = x, E = T, A = g;
+                (p = e.lencode[A + ((a & ((1 << (d + E)) - 1)) >> d)]),
+                  (x = p >>> 24),
+                  (T = (p >>> 16) & 255),
+                  (g = p & 65535),
+                  !(d + x <= o);
+              ) {
+                if (f === 0) break e;
+                (f--, (a += r[n++] << o), (o += 8));
+              }
+              ((a >>>= d), (o -= d), (e.back += d));
+            }
+            if (
+              ((a >>>= x), (o -= x), (e.back += x), (e.length = g), T === 0)
+            ) {
+              e.mode = it;
+              break;
+            }
+            if (T & 32) {
+              ((e.back = -1), (e.mode = Z));
+              break;
+            }
+            if (T & 64) {
+              ((t.msg = "invalid literal/length code"), (e.mode = y));
+              break;
+            }
+            ((e.extra = T & 15), (e.mode = Je));
+          case Je:
+            if (e.extra) {
+              for (m = e.extra; o < m; ) {
+                if (f === 0) break e;
+                (f--, (a += r[n++] << o), (o += 8));
+              }
+              ((e.length += a & ((1 << e.extra) - 1)),
+                (a >>>= e.extra),
+                (o -= e.extra),
+                (e.back += e.extra));
+            }
+            ((e.was = e.length), (e.mode = $e));
+          case $e:
+            for (
+              ;
+              (p = e.distcode[a & ((1 << e.distbits) - 1)]),
+                (x = p >>> 24),
+                (T = (p >>> 16) & 255),
+                (g = p & 65535),
+                !(x <= o);
+            ) {
+              if (f === 0) break e;
+              (f--, (a += r[n++] << o), (o += 8));
+            }
+            if (!(T & 240)) {
+              for (
+                d = x, E = T, A = g;
+                (p = e.distcode[A + ((a & ((1 << (d + E)) - 1)) >> d)]),
+                  (x = p >>> 24),
+                  (T = (p >>> 16) & 255),
+                  (g = p & 65535),
+                  !(d + x <= o);
+              ) {
+                if (f === 0) break e;
+                (f--, (a += r[n++] << o), (o += 8));
+              }
+              ((a >>>= d), (o -= d), (e.back += d));
+            }
+            if (((a >>>= x), (o -= x), (e.back += x), T & 64)) {
+              ((t.msg = "invalid distance code"), (e.mode = y));
+              break;
+            }
+            ((e.offset = g), (e.extra = T & 15), (e.mode = et));
+          case et:
+            if (e.extra) {
+              for (m = e.extra; o < m; ) {
+                if (f === 0) break e;
+                (f--, (a += r[n++] << o), (o += 8));
+              }
+              ((e.offset += a & ((1 << e.extra) - 1)),
+                (a >>>= e.extra),
+                (o -= e.extra),
+                (e.back += e.extra));
+            }
+            if (e.offset > e.dmax) {
+              ((t.msg = "invalid distance too far back"), (e.mode = y));
+              break;
+            }
+            e.mode = tt;
+          case tt:
+            if (_ === 0) break e;
+            if (((l = w - _), e.offset > l)) {
+              if (((l = e.offset - l), l > e.whave && e.sane)) {
+                ((t.msg = "invalid distance too far back"), (e.mode = y));
+                break;
+              }
+              (l > e.wnext
+                ? ((l -= e.wnext), (u = e.wsize - l))
+                : (u = e.wnext - l),
+                l > e.length && (l = e.length),
+                (I = e.window));
+            } else ((I = s), (u = c - e.offset), (l = e.length));
+            (l > _ && (l = _), (_ -= l), (e.length -= l));
+            do s[c++] = I[u++];
+            while (--l);
+            e.length === 0 && (e.mode = te);
+            break;
+          case it:
+            if (_ === 0) break e;
+            ((s[c++] = e.length), _--, (e.mode = te));
+            break;
+          case le:
+            if (e.wrap) {
+              for (; o < 32; ) {
+                if (f === 0) break e;
+                (f--, (a |= r[n++] << o), (o += 8));
+              }
+              if (
+                ((w -= _),
+                (t.total_out += w),
+                (e.total += w),
+                e.wrap & 4 &&
+                  w &&
+                  (t.adler = e.check =
+                    e.flags
+                      ? M(e.check, s, w, c - w)
+                      : he(e.check, s, w, c - w)),
+                (w = _),
+                e.wrap & 4 && (e.flags ? a : at(a)) !== e.check)
+              ) {
+                ((t.msg = "incorrect data check"), (e.mode = y));
+                break;
+              }
+              ((a = 0), (o = 0));
+            }
+            e.mode = nt;
+          case nt:
+            if (e.wrap && e.flags) {
+              for (; o < 32; ) {
+                if (f === 0) break e;
+                (f--, (a += r[n++] << o), (o += 8));
+              }
+              if (e.wrap & 4 && a !== (e.total & 4294967295)) {
+                ((t.msg = "incorrect length check"), (e.mode = y));
+                break;
+              }
+              ((a = 0), (o = 0));
+            }
+            e.mode = rt;
+          case rt:
+            S = Jt;
+            break e;
+          case y:
+            S = lt;
+            break e;
+          case we:
+            return ue;
+          case ct:
+          default:
+            return U;
+        }
+      return (
+        (t.next_out = c),
+        (t.avail_out = _),
+        (t.next_in = n),
+        (t.avail_in = f),
+        (e.hold = a),
+        (e.bits = o),
+        (e.wsize ||
+          (w !== t.avail_out && e.mode < y && (e.mode < le || i !== Be))) &&
+        xt(t, t.output, t.next_out, w - t.avail_out)
+          ? ((e.mode = we), ue)
+          : ((v -= t.avail_in),
+            (w -= t.avail_out),
+            (t.total_in += v),
+            (t.total_out += w),
+            (e.total += w),
+            e.wrap & 4 &&
+              w &&
+              (t.adler = e.check =
+                e.flags
+                  ? M(e.check, s, w, t.next_out - w)
+                  : he(e.check, s, w, t.next_out - w)),
+            (t.data_type =
+              e.bits +
+              (e.last ? 64 : 0) +
+              (e.mode === Z ? 128 : 0) +
+              (e.mode === ee || e.mode === fe ? 256 : 0)),
+            ((v === 0 && w === 0) || i === Be) && S === P && (S = ei),
+            S)
+      );
+    },
+    li = (t) => {
+      if (z(t)) return U;
+      let i = t.state;
+      return (i.window && (i.window = null), (t.state = null), P);
+    },
+    ci = (t, i) => {
+      if (z(t)) return U;
+      let e = t.state;
+      return e.wrap & 2 ? ((e.head = i), (i.done = !1), P) : U;
+    },
+    di = (t, i) => {
+      let e = i.length,
+        r,
+        s,
+        n;
+      return z(t) || ((r = t.state), r.wrap !== 0 && r.mode !== ie)
+        ? U
+        : r.mode === ie && ((s = 1), (s = he(s, i, e, 0)), s !== r.check)
+          ? lt
+          : ((n = xt(t, i, e, e)),
+            n ? ((r.mode = we), ue) : ((r.havedict = 1), P));
+    };
+  O.exports.inflateReset = ht;
+  O.exports.inflateReset2 = ut;
+  O.exports.inflateResetKeep = dt;
+  O.exports.inflateInit = oi;
+  O.exports.inflateInit2 = wt;
+  O.exports.inflate = fi;
+  O.exports.inflateEnd = li;
+  O.exports.inflateGetHeader = ci;
+  O.exports.inflateSetDictionary = di;
+  O.exports.inflateInfo = "pako inflate (from Nodeca project)";
+});
+var _t = R((Gi, xe) => {
+  "use strict";
+  var hi = (t, i) => Object.prototype.hasOwnProperty.call(t, i);
+  xe.exports.assign = function (t) {
+    let i = Array.prototype.slice.call(arguments, 1);
+    for (; i.length; ) {
+      let e = i.shift();
+      if (e) {
+        if (typeof e != "object") throw new TypeError(e + "must be non-object");
+        for (let r in e) hi(e, r) && (t[r] = e[r]);
+      }
+    }
+    return t;
+  };
+  xe.exports.flattenChunks = (t) => {
+    let i = 0;
+    for (let r = 0, s = t.length; r < s; r++) i += t[r].length;
+    let e = new Uint8Array(i);
+    for (let r = 0, s = 0, n = t.length; r < n; r++) {
+      let c = t[r];
+      (e.set(c, s), (s += c.length));
+    }
+    return e;
+  };
+});
+var kt = R((Yi, re) => {
+  "use strict";
+  var gt = !0;
+  try {
+    String.fromCharCode.apply(null, new Uint8Array(1));
+  } catch {
+    gt = !1;
+  }
+  var q = new Uint8Array(256);
+  for (let t = 0; t < 256; t++)
+    q[t] =
+      t >= 252
+        ? 6
+        : t >= 248
+          ? 5
+          : t >= 240
+            ? 4
+            : t >= 224
+              ? 3
+              : t >= 192
+                ? 2
+                : 1;
+  q[254] = q[254] = 1;
+  re.exports.string2buf = (t) => {
+    if (typeof TextEncoder == "function" && TextEncoder.prototype.encode)
+      return new TextEncoder().encode(t);
+    let i,
+      e,
+      r,
+      s,
+      n,
+      c = t.length,
+      f = 0;
+    for (s = 0; s < c; s++)
+      ((e = t.charCodeAt(s)),
+        (e & 64512) === 55296 &&
+          s + 1 < c &&
+          ((r = t.charCodeAt(s + 1)),
+          (r & 64512) === 56320 &&
+            ((e = 65536 + ((e - 55296) << 10) + (r - 56320)), s++)),
+        (f += e < 128 ? 1 : e < 2048 ? 2 : e < 65536 ? 3 : 4));
+    for (i = new Uint8Array(f), n = 0, s = 0; n < f; s++)
+      ((e = t.charCodeAt(s)),
+        (e & 64512) === 55296 &&
+          s + 1 < c &&
+          ((r = t.charCodeAt(s + 1)),
+          (r & 64512) === 56320 &&
+            ((e = 65536 + ((e - 55296) << 10) + (r - 56320)), s++)),
+        e < 128
+          ? (i[n++] = e)
+          : e < 2048
+            ? ((i[n++] = 192 | (e >>> 6)), (i[n++] = 128 | (e & 63)))
+            : e < 65536
+              ? ((i[n++] = 224 | (e >>> 12)),
+                (i[n++] = 128 | ((e >>> 6) & 63)),
+                (i[n++] = 128 | (e & 63)))
+              : ((i[n++] = 240 | (e >>> 18)),
+                (i[n++] = 128 | ((e >>> 12) & 63)),
+                (i[n++] = 128 | ((e >>> 6) & 63)),
+                (i[n++] = 128 | (e & 63))));
+    return i;
+  };
+  var ui = (t, i) => {
+    if (i < 65534 && t.subarray && gt)
+      return String.fromCharCode.apply(
+        null,
+        t.length === i ? t : t.subarray(0, i),
+      );
+    let e = "";
+    for (let r = 0; r < i; r++) e += String.fromCharCode(t[r]);
+    return e;
+  };
+  re.exports.buf2string = (t, i) => {
+    let e = i || t.length;
+    if (typeof TextDecoder == "function" && TextDecoder.prototype.decode)
+      return new TextDecoder().decode(t.subarray(0, i));
+    let r,
+      s,
+      n = new Array(e * 2);
+    for (s = 0, r = 0; r < e; ) {
+      let c = t[r++];
+      if (c < 128) {
+        n[s++] = c;
+        continue;
+      }
+      let f = q[c];
+      if (f > 4) {
+        ((n[s++] = 65533), (r += f - 1));
+        continue;
+      }
+      for (c &= f === 2 ? 31 : f === 3 ? 15 : 7; f > 1 && r < e; )
+        ((c = (c << 6) | (t[r++] & 63)), f--);
+      if (f > 1) {
+        n[s++] = 65533;
+        continue;
+      }
+      c < 65536
+        ? (n[s++] = c)
+        : ((c -= 65536),
+          (n[s++] = 55296 | ((c >> 10) & 1023)),
+          (n[s++] = 56320 | (c & 1023)));
+    }
+    return ui(n, s);
+  };
+  re.exports.utf8border = (t, i) => {
+    ((i = i || t.length), i > t.length && (i = t.length));
+    let e = i - 1;
+    for (; e >= 0 && (t[e] & 192) === 128; ) e--;
+    return e < 0 || e === 0 ? i : e + q[t[e]] > i ? e : i;
+  };
+});
+var Et = R((Xi, pt) => {
+  "use strict";
+  pt.exports = {
+    2: "need dictionary",
+    1: "stream end",
+    0: "",
+    "-1": "file error",
+    "-2": "stream error",
+    "-3": "data error",
+    "-4": "insufficient memory",
+    "-5": "buffer error",
+    "-6": "incompatible version",
+  };
+});
+var St = R((qi, mt) => {
+  "use strict";
+  function wi() {
+    ((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));
+  }
+  mt.exports = wi;
+});
+var vt = R((Ki, Tt) => {
+  "use strict";
+  function xi() {
+    ((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));
+  }
+  Tt.exports = xi;
+});
+var Rt = R((ji, V) => {
+  "use strict";
+  var B = bt(),
+    At = _t(),
+    ge = kt(),
+    ke = Et(),
+    bi = St(),
+    _i = vt(),
+    It = Object.prototype.toString,
+    {
+      Z_NO_FLUSH: gi,
+      Z_FINISH: ki,
+      Z_OK: K,
+      Z_STREAM_END: be,
+      Z_NEED_DICT: _e,
+      Z_STREAM_ERROR: pi,
+      Z_DATA_ERROR: yt,
+      Z_MEM_ERROR: Ei,
+    } = J();
+  function j(t) {
+    this.options = At.assign(
+      { chunkSize: 1024 * 64, windowBits: 15, to: "" },
+      t || {},
+    );
+    let i = this.options;
+    (i.raw &&
+      i.windowBits >= 0 &&
+      i.windowBits < 16 &&
+      ((i.windowBits = -i.windowBits),
+      i.windowBits === 0 && (i.windowBits = -15)),
+      i.windowBits >= 0 &&
+        i.windowBits < 16 &&
+        !(t && t.windowBits) &&
+        (i.windowBits += 32),
+      i.windowBits > 15 &&
+        i.windowBits < 48 &&
+        (i.windowBits & 15 || (i.windowBits |= 15)),
+      (this.err = 0),
+      (this.msg = ""),
+      (this.ended = !1),
+      (this.chunks = []),
+      (this.strm = new bi()),
+      (this.strm.avail_out = 0));
+    let e = B.inflateInit2(this.strm, i.windowBits);
+    if (e !== K) throw new Error(ke[e]);
+    if (
+      ((this.header = new _i()),
+      B.inflateGetHeader(this.strm, this.header),
+      i.dictionary &&
+        (typeof i.dictionary == "string"
+          ? (i.dictionary = ge.string2buf(i.dictionary))
+          : It.call(i.dictionary) === "[object ArrayBuffer]" &&
+            (i.dictionary = new Uint8Array(i.dictionary)),
+        i.raw &&
+          ((e = B.inflateSetDictionary(this.strm, i.dictionary)), e !== K)))
+    )
+      throw new Error(ke[e]);
+  }
+  j.prototype.push = function (t, i) {
+    let e = this.strm,
+      r = this.options.chunkSize,
+      s = this.options.dictionary,
+      n,
+      c,
+      f;
+    if (this.ended) return !1;
+    for (
+      i === ~~i ? (c = i) : (c = i === !0 ? ki : gi),
+        It.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(r)), (e.next_out = 0), (e.avail_out = r)),
+          n = B.inflate(e, c),
+          n === _e &&
+            s &&
+            ((n = B.inflateSetDictionary(e, s)),
+            n === K ? (n = B.inflate(e, c)) : n === yt && (n = _e));
+        e.avail_in > 0 && n === be && e.state.wrap > 0 && t[e.next_in] !== 0;
+      )
+        (B.inflateReset(e), (n = B.inflate(e, c)));
+      switch (n) {
+        case pi:
+        case yt:
+        case _e:
+        case Ei:
+          return (this.onEnd(n), (this.ended = !0), !1);
+      }
+      if (((f = e.avail_out), e.next_out && (e.avail_out === 0 || n === be)))
+        if (this.options.to === "string") {
+          let _ = ge.utf8border(e.output, e.next_out),
+            a = e.next_out - _,
+            o = ge.buf2string(e.output, _);
+          ((e.next_out = a),
+            (e.avail_out = r - a),
+            a && e.output.set(e.output.subarray(_, _ + a), 0),
+            this.onData(o));
+        } else
+          this.onData(
+            e.output.length === e.next_out
+              ? e.output
+              : e.output.subarray(0, e.next_out),
+          );
+      if (!(n === K && f === 0)) {
+        if (n === be)
+          return (
+            (n = B.inflateEnd(this.strm)),
+            this.onEnd(n),
+            (this.ended = !0),
+            !0
+          );
+        if (e.avail_in === 0) break;
+      }
+    }
+    return !0;
+  };
+  j.prototype.onData = function (t) {
+    this.chunks.push(t);
+  };
+  j.prototype.onEnd = function (t) {
+    (t === K &&
+      (this.options.to === "string"
+        ? (this.result = this.chunks.join(""))
+        : (this.result = At.flattenChunks(this.chunks))),
+      (this.chunks = []),
+      (this.err = t),
+      (this.msg = this.strm.msg));
+  };
+  function pe(t, i) {
+    let e = new j(i);
+    if ((e.push(t), e.err)) throw e.msg || ke[e.err];
+    return e.result;
+  }
+  function mi(t, i) {
+    return ((i = i || {}), (i.raw = !0), pe(t, i));
+  }
+  V.exports.Inflate = j;
+  V.exports.inflate = pe;
+  V.exports.inflateRaw = mi;
+  V.exports.ungzip = pe;
+  V.exports.constants = J();
+});
+var Nt = 1953029805,
+  Mt = 2917034100;
+function oe(t, i) {
+  if (oe.passThroughDataForTesting) return i;
+  (ae.typeOf.object("key", t), ae.typeOf.object("data", i));
+  let e = t.byteLength;
+  if (e === 0 || e % 4 !== 0)
+    throw new D(
+      "The length of key must be greater than 0 and a multiple of 4.",
+    );
+  let r = new DataView(i),
+    s = r.getUint32(0, !0);
+  if (s === Nt || s === Mt) return i;
+  let n = new DataView(t),
+    c = 0,
+    f = i.byteLength,
+    _ = f - (f % 8),
+    a = e,
+    o,
+    v = 8;
+  for (; c < _; )
+    for (v = (v + 8) % 24, o = v; c < _ && o < a; )
+      (r.setUint32(c, r.getUint32(c, !0) ^ n.getUint32(o, !0), !0),
+        r.setUint32(c + 4, r.getUint32(c + 4, !0) ^ n.getUint32(o + 4, !0), !0),
+        (c += 8),
+        (o += 24));
+  if (c < f)
+    for (o >= a && ((v = (v + 8) % 24), (o = v)); c < f; )
+      (r.setUint8(c, r.getUint8(c) ^ n.getUint8(o)), c++, o++);
+}
+oe.passThroughDataForTesting = !1;
+var Te = oe;
+function Zt(t, i) {
+  return (t & i) !== 0;
+}
+var F = Zt;
+var Bt = [1, 2, 4, 8],
+  ve = 15,
+  Ct = 16,
+  Lt = 64,
+  Pt = 128;
+function N(t, i, e, r, s, n) {
+  ((this._bits = t),
+    (this.cnodeVersion = i),
+    (this.imageryVersion = e),
+    (this.terrainVersion = r),
+    (this.imageryProvider = s),
+    (this.terrainProvider = n),
+    (this.ancestorHasTerrain = !1),
+    (this.terrainState = void 0));
+}
+N.clone = function (t, i) {
+  return (
+    me(i)
+      ? ((i._bits = t._bits),
+        (i.cnodeVersion = t.cnodeVersion),
+        (i.imageryVersion = t.imageryVersion),
+        (i.terrainVersion = t.terrainVersion),
+        (i.imageryProvider = t.imageryProvider),
+        (i.terrainProvider = t.terrainProvider))
+      : (i = new N(
+          t._bits,
+          t.cnodeVersion,
+          t.imageryVersion,
+          t.terrainVersion,
+          t.imageryProvider,
+          t.terrainProvider,
+        )),
+    (i.ancestorHasTerrain = t.ancestorHasTerrain),
+    (i.terrainState = t.terrainState),
+    i
+  );
+};
+N.prototype.setParent = function (t) {
+  this.ancestorHasTerrain = t.ancestorHasTerrain || this.hasTerrain();
+};
+N.prototype.hasSubtree = function () {
+  return F(this._bits, Ct);
+};
+N.prototype.hasImagery = function () {
+  return F(this._bits, Lt);
+};
+N.prototype.hasTerrain = function () {
+  return F(this._bits, Pt);
+};
+N.prototype.hasChildren = function () {
+  return F(this._bits, ve);
+};
+N.prototype.hasChild = function (t) {
+  return F(this._bits, Bt[t]);
+};
+N.prototype.getChildBitmask = function () {
+  return this._bits & ve;
+};
+var ye = N;
+var Ut = Ot(Rt(), 1);
+var G = Uint16Array.BYTES_PER_ELEMENT,
+  H = Int32Array.BYTES_PER_ELEMENT,
+  Y = Uint32Array.BYTES_PER_ELEMENT,
+  C = { METADATA: 0, TERRAIN: 1, DBROOT: 2 };
+C.fromString = function (t) {
+  if (t === "Metadata") return C.METADATA;
+  if (t === "Terrain") return C.TERRAIN;
+  if (t === "DbRoot") return C.DBROOT;
+};
+function Si(t, i) {
+  let e = C.fromString(t.type),
+    r = t.buffer;
+  Te(t.key, r);
+  let s = Di(r);
+  r = s.buffer;
+  let n = s.length;
+  switch (e) {
+    case C.METADATA:
+      return vi(r, n, t.quadKey);
+    case C.TERRAIN:
+      return Ii(r, n, i);
+    case C.DBROOT:
+      return (i.push(r), { buffer: r });
+  }
+}
+var Ti = 32301;
+function vi(t, i, e) {
+  let r = new DataView(t),
+    s = 0,
+    n = r.getUint32(s, !0);
+  if (((s += Y), n !== Ti)) throw new D("Invalid magic");
+  let c = r.getUint32(s, !0);
+  if (((s += Y), c !== 1))
+    throw new D("Invalid data type. Must be 1 for QuadTreePacket");
+  let f = r.getUint32(s, !0);
+  if (((s += Y), f !== 2))
+    throw new D("Invalid QuadTreePacket version. Only version 2 is supported.");
+  let _ = r.getInt32(s, !0);
+  s += H;
+  let a = r.getInt32(s, !0);
+  if (((s += H), a !== 32)) throw new D("Invalid instance size.");
+  let o = r.getInt32(s, !0);
+  s += H;
+  let v = r.getInt32(s, !0);
+  s += H;
+  let w = r.getInt32(s, !0);
+  if (((s += H), o !== _ * a + s)) throw new D("Invalid dataBufferOffset");
+  if (o + v + w !== i) throw new D("Invalid packet offsets");
+  let l = [];
+  for (let g = 0; g < _; ++g) {
+    let d = r.getUint8(s);
+    (++s, ++s);
+    let E = r.getUint16(s, !0);
+    s += G;
+    let A = r.getUint16(s, !0);
+    s += G;
+    let h = r.getUint16(s, !0);
+    ((s += G), (s += G), (s += G), (s += H), (s += H), (s += 8));
+    let S = r.getUint8(s++),
+      k = r.getUint8(s++);
+    ((s += G), l.push(new ye(d, E, A, h, S, k)));
+  }
+  let u = [],
+    I = 0;
+  function p(g, d, E) {
+    let A = !1;
+    if (E === 4) {
+      if (d.hasSubtree()) return;
+      A = !0;
+    }
+    for (let h = 0; h < 4; ++h) {
+      let S = g + h.toString();
+      if (A) u[S] = null;
+      else if (E < 4)
+        if (!d.hasChild(h)) u[S] = null;
+        else {
+          if (I === _) {
+            console.log("Incorrect number of instances");
+            return;
+          }
+          let k = l[I++];
+          ((u[S] = k), p(S, k, E + 1));
+        }
+    }
+  }
+  let x = 0,
+    T = l[I++];
+  return (e === "" ? ++x : (u[e] = T), p(e, T, x), u);
+}
+var yi = 5,
+  Ai = 4;
+function Ii(t, i, e) {
+  let r = new DataView(t),
+    s = function (f) {
+      for (let _ = 0; _ < Ai; ++_) {
+        let a = r.getUint32(f, !0);
+        if (((f += Y), (f += a), f > i))
+          throw new D("Malformed terrain packet found.");
+      }
+      return f;
+    },
+    n = 0,
+    c = [];
+  for (; c.length < yi; ) {
+    let f = n;
+    n = s(n);
+    let _ = t.slice(f, n);
+    (e.push(_), c.push(_));
+  }
+  return c;
+}
+var Dt = 1953029805,
+  Ri = 2917034100;
+function Di(t) {
+  let i = new DataView(t),
+    e = 0,
+    r = i.getUint32(e, !0);
+  if (((e += Y), r !== Dt && r !== Ri)) throw new D("Invalid magic");
+  let s = i.getUint32(e, r === Dt);
+  e += Y;
+  let n = new Uint8Array(t, e),
+    c = Ut.default.inflate(n);
+  if (c.length !== s) throw new D("Size of packet doesn't match header");
+  return c;
+}
+var en = Se(Si);
+export { en as default };