@realsee/dnalogel 3.59.13 → 3.60.0

package/libs/shared-utils/three/Magnifier.js

@@ -1,7 +1,7 @@
 var P = Object.defineProperty;
 var p = (r, t, e) => t in r ? P(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
 var n = (r, t, e) => (p(r, typeof t != "symbol" ? t + "" : t, e), e);
-import b from "hammerjs";
+import { hammerExports as b } from "../../vendor/hammerjs/hammer.js";
 import * as l from "three";
 import { Subscribe as C } from "../Subscribe.js";
 class E {
@@ -93,8 +93,8 @@ class E {
         return [(v.x + 1) / 2 * h.x, (v.y + 1) / 2 * h.y];
       } else
         return [this.renderCenter.x, h.y - this.renderCenter.y];
-    })(), f = 1, c = i / t, g = s / t, y = f * t, u = this.five.getPixels(o - c / 2, a - c / 2, c, g, y), x = Math.floor(i * f), m = Math.floor(s * f);
-    D(u, x, m), (this.imageData.width !== x || this.imageData.height !== m) && (this.imageData = new ImageData(x, m)), this.imageData.data.set(u), e.putImageData(this.imageData, 0, 0), this.canvas.style.visibility = "visible";
+    })(), f = 1, c = i / t, x = s / t, y = f * t, u = this.five.getPixels(o - c / 2, a - c / 2, c, x, y), g = Math.floor(i * f), m = Math.floor(s * f);
+    D(u, g, m), (this.imageData.width !== g || this.imageData.height !== m) && (this.imageData = new ImageData(g, m)), this.imageData.data.set(u), e.putImageData(this.imageData, 0, 0), this.canvas.style.visibility = "visible";
   }
   getRenderCenter() {
     return this.renderCenter;
@@ -135,8 +135,8 @@ class E {
     const {
       min: { x: i, y: s },
       max: { x: h, y: o }
-    } = e, a = this.offset.x + t.deltaX, f = this.offset.y + t.deltaY, c = Math.min(Math.max(a, i), h), g = Math.min(Math.max(f, s), o);
-    return { translateX: c, translateY: g };
+    } = e, a = this.offset.x + t.deltaX, f = this.offset.y + t.deltaY, c = Math.min(Math.max(a, i), h), x = Math.min(Math.max(f, s), o);
+    return { translateX: c, translateY: x };
   }
 }
 function d(r, t, e) {

package/libs/shared-utils/three/PointSelector/utils/PointSelectorHelper.js

@@ -8,7 +8,7 @@ import { PointHelper as b } from "./PointHelper.js";
 import { Subscribe as g } from "../../../Subscribe.js";
 import { PointHelper2 as o } from "./PointHelper2.js";
 import "../../core/Sphere.js";
-import "animejs";
+import "../../../../vendor/animejs/lib/anime.es.js";
 class R {
   constructor(i, e) {
     t(this, "five");

package/libs/shared-utils/three/blink.js

@@ -9,7 +9,7 @@ var T = (l, r, a) => r in l ? R(l, r, { enumerable: !0, configurable: !0, writab
       L.call(r, a) && T(l, a, r[a]);
   return l;
 };
-import x from "animejs";
+import { anime as x } from "../../vendor/animejs/lib/anime.es.js";
 import * as v from "three";
 import { toArray as d } from "../util.js";
 const f = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map();

package/libs/shared-utils/three/earcut3D.js

@@ -1,12 +1,12 @@
-import c from "earcut";
+import { earcutExports as c } from "../../vendor/earcut/src/earcut.js";
 import { getNormal as i } from "./getNormal.js";
 import * as r from "three";
-function f(o) {
+function p(o) {
   if (o.length < 3)
     return [];
   const n = i(o), e = new r.Quaternion().setFromUnitVectors(new r.Vector3(0, 1, 0), n), a = o.map((t) => t.clone().applyQuaternion(e)).flatMap((t) => [t.x, t.z]);
   return c(a);
 }
 export {
-  f as earcut3D
+  p as earcut3D
 };

package/libs/shared-utils/three/index.js

@@ -1,11 +1,11 @@
-import "hammerjs";
+import "../../vendor/hammerjs/hammer.js";
 import "three";
 import "./PointSelector/index.js";
-import "three/examples/jsm/renderers/CSS3DRenderer";
 import "../tag.js";
+import "./CSS3DRenderer/index.js";
 import "@realsee/five/line";
 import "./core/Five_LineMaterial2.js";
 import "./core/Sphere.js";
-import "animejs";
+import "../../vendor/animejs/lib/anime.es.js";
 import "../../vendor/@tweenjs/tween/dist/tween.esm.js.js";
 import "../five/FivePuppet.js";

package/libs/shared-utils/three/libs/NURBSCurve.js

@@ -0,0 +1,22 @@
+import { Curve as a, Vector3 as c, Vector4 as p } from "three";
+import { NURBSUtils as l } from "./NURBSUtils.js";
+var e = function(n, s, o, r, t) {
+  a.call(this), this.degree = n, this.knots = s, this.controlPoints = [], this.startKnot = r || 0, this.endKnot = t || this.knots.length - 1;
+  for (var i = 0; i < o.length; ++i) {
+    var h = o[i];
+    this.controlPoints[i] = new p(h.x, h.y, h.z, h.w);
+  }
+};
+e.prototype = Object.create(a.prototype);
+e.prototype.constructor = e;
+e.prototype.getPoint = function(n, s) {
+  var o = s || new c(), r = this.knots[this.startKnot] + n * (this.knots[this.endKnot] - this.knots[this.startKnot]), t = l.calcBSplinePoint(this.degree, this.knots, this.controlPoints, r);
+  return t.w != 1 && t.divideScalar(t.w), o.set(t.x, t.y, t.z);
+};
+e.prototype.getTangent = function(n, s) {
+  var o = s || new c(), r = this.knots[0] + n * (this.knots[this.knots.length - 1] - this.knots[0]), t = l.calcNURBSDerivatives(this.degree, this.knots, this.controlPoints, r, 1);
+  return o.copy(t[1]).normalize(), o;
+};
+export {
+  e as NURBSCurve
+};

package/libs/shared-utils/three/libs/NURBSUtils.js

@@ -0,0 +1,212 @@
+import { Vector4 as F, Vector3 as R } from "three";
+var A = {
+  /*
+  	Finds knot vector span.
+  
+  	p : degree
+  	u : parametric value
+  	U : knot vector
+  
+  	returns the span
+  	*/
+  findSpan: function(e, o, c) {
+    var i = c.length - e - 1;
+    if (o >= c[i])
+      return i - 1;
+    if (o <= c[e])
+      return e;
+    for (var v = e, f = i, a = Math.floor((v + f) / 2); o < c[a] || o >= c[a + 1]; )
+      o < c[a] ? f = a : v = a, a = Math.floor((v + f) / 2);
+    return a;
+  },
+  /*
+  	Calculate basis functions. See The NURBS Book, page 70, algorithm A2.2
+  
+  	span : span in which u lies
+  	u    : parametric point
+  	p    : degree
+  	U    : knot vector
+  
+  	returns array[p+1] with basis functions values.
+  	*/
+  calcBasisFunctions: function(e, o, c, i) {
+    var v = [], f = [], a = [];
+    v[0] = 1;
+    for (var n = 1; n <= c; ++n) {
+      f[n] = o - i[e + 1 - n], a[n] = i[e + n] - o;
+      for (var l = 0, u = 0; u < n; ++u) {
+        var h = a[u + 1], r = f[n - u], w = v[u] / (h + r);
+        v[u] = l + h * w, l = r * w;
+      }
+      v[n] = l;
+    }
+    return v;
+  },
+  /*
+  	Calculate B-Spline curve points. See The NURBS Book, page 82, algorithm A3.1.
+  
+  	p : degree of B-Spline
+  	U : knot vector
+  	P : control points (x, y, z, w)
+  	u : parametric point
+  
+  	returns point for given u
+  	*/
+  calcBSplinePoint: function(e, o, c, i) {
+    for (var v = this.findSpan(e, i, o), f = this.calcBasisFunctions(v, i, e, o), a = new F(0, 0, 0, 0), n = 0; n <= e; ++n) {
+      var l = c[v - e + n], u = f[n], h = l.w * u;
+      a.x += l.x * h, a.y += l.y * h, a.z += l.z * h, a.w += l.w * u;
+    }
+    return a;
+  },
+  /*
+  	Calculate basis functions derivatives. See The NURBS Book, page 72, algorithm A2.3.
+  
+  	span : span in which u lies
+  	u    : parametric point
+  	p    : degree
+  	n    : number of derivatives to calculate
+  	U    : knot vector
+  
+  	returns array[n+1][p+1] with basis functions derivatives
+  	*/
+  calcBasisFunctionDerivatives: function(e, o, c, i, v) {
+    for (var f = [], a = 0; a <= c; ++a)
+      f[a] = 0;
+    for (var n = [], a = 0; a <= i; ++a)
+      n[a] = f.slice(0);
+    for (var l = [], a = 0; a <= c; ++a)
+      l[a] = f.slice(0);
+    l[0][0] = 1;
+    for (var u = f.slice(0), h = f.slice(0), r = 1; r <= c; ++r) {
+      u[r] = o - v[e + 1 - r], h[r] = v[e + r] - o;
+      for (var w = 0, s = 0; s < r; ++s) {
+        var t = h[s + 1], y = u[r - s];
+        l[r][s] = t + y;
+        var x = l[s][r - 1] / l[r][s];
+        l[s][r] = w + t * x, w = y * x;
+      }
+      l[r][r] = w;
+    }
+    for (var r = 0; r <= c; ++r)
+      n[0][r] = l[r][c];
+    for (var s = 0; s <= c; ++s) {
+      for (var m = 0, S = 1, B = [], a = 0; a <= c; ++a)
+        B[a] = f.slice(0);
+      B[0][0] = 1;
+      for (var d = 1; d <= i; ++d) {
+        var g = 0, D = s - d, z = c - d;
+        s >= d && (B[S][0] = B[m][0] / l[z + 1][D], g = B[S][0] * l[D][z]);
+        for (var C = D >= -1 ? 1 : -D, K = s - 1 <= z ? d - 1 : c - s, r = C; r <= K; ++r)
+          B[S][r] = (B[m][r] - B[m][r - 1]) / l[z + 1][D + r], g += B[S][r] * l[D + r][z];
+        s <= z && (B[S][d] = -B[m][d - 1] / l[z + 1][s], g += B[S][d] * l[s][z]), n[d][s] = g;
+        var r = m;
+        m = S, S = r;
+      }
+    }
+    for (var s = c, d = 1; d <= i; ++d) {
+      for (var r = 0; r <= c; ++r)
+        n[d][r] *= s;
+      s *= c - d;
+    }
+    return n;
+  },
+  /*
+  		Calculate derivatives of a B-Spline. See The NURBS Book, page 93, algorithm A3.2.
+  
+  		p  : degree
+  		U  : knot vector
+  		P  : control points
+  		u  : Parametric points
+  		nd : number of derivatives
+  
+  		returns array[d+1] with derivatives
+  		*/
+  calcBSplineDerivatives: function(e, o, c, i, v) {
+    for (var f = v < e ? v : e, a = [], n = this.findSpan(e, i, o), l = this.calcBasisFunctionDerivatives(n, i, e, f, o), u = [], h = 0; h < c.length; ++h) {
+      var r = c[h].clone(), w = r.w;
+      r.x *= w, r.y *= w, r.z *= w, u[h] = r;
+    }
+    for (var t = 0; t <= f; ++t) {
+      for (var r = u[n - e].clone().multiplyScalar(l[t][0]), y = 1; y <= e; ++y)
+        r.add(u[n - e + y].clone().multiplyScalar(l[t][y]));
+      a[t] = r;
+    }
+    for (var t = f + 1; t <= v + 1; ++t)
+      a[t] = new F(0, 0, 0);
+    return a;
+  },
+  /*
+  	Calculate "K over I"
+  
+  	returns k!/(i!(k-i)!)
+  	*/
+  calcKoverI: function(e, o) {
+    for (var c = 1, i = 2; i <= e; ++i)
+      c *= i;
+    for (var v = 1, i = 2; i <= o; ++i)
+      v *= i;
+    for (var i = 2; i <= e - o; ++i)
+      v *= i;
+    return c / v;
+  },
+  /*
+  	Calculate derivatives (0-nd) of rational curve. See The NURBS Book, page 127, algorithm A4.2.
+  
+  	Pders : result of function calcBSplineDerivatives
+  
+  	returns array with derivatives for rational curve.
+  	*/
+  calcRationalCurveDerivatives: function(e) {
+    for (var o = e.length, c = [], i = [], v = 0; v < o; ++v) {
+      var f = e[v];
+      c[v] = new R(f.x, f.y, f.z), i[v] = f.w;
+    }
+    for (var a = [], n = 0; n < o; ++n) {
+      for (var l = c[n].clone(), v = 1; v <= n; ++v)
+        l.sub(a[n - v].clone().multiplyScalar(this.calcKoverI(n, v) * i[v]));
+      a[n] = l.divideScalar(i[0]);
+    }
+    return a;
+  },
+  /*
+  	Calculate NURBS curve derivatives. See The NURBS Book, page 127, algorithm A4.2.
+  
+  	p  : degree
+  	U  : knot vector
+  	P  : control points in homogeneous space
+  	u  : parametric points
+  	nd : number of derivatives
+  
+  	returns array with derivatives.
+  	*/
+  calcNURBSDerivatives: function(e, o, c, i, v) {
+    var f = this.calcBSplineDerivatives(e, o, c, i, v);
+    return this.calcRationalCurveDerivatives(f);
+  },
+  /*
+  	Calculate rational B-Spline surface point. See The NURBS Book, page 134, algorithm A4.3.
+  
+  	p1, p2 : degrees of B-Spline surface
+  	U1, U2 : knot vectors
+  	P      : control points (x, y, z, w)
+  	u, v   : parametric values
+  
+  	returns point for given (u, v)
+  	*/
+  calcSurfacePoint: function(e, o, c, i, v, f, a, n) {
+    for (var l = this.findSpan(e, f, c), u = this.findSpan(o, a, i), h = this.calcBasisFunctions(l, f, e, c), r = this.calcBasisFunctions(u, a, o, i), w = [], t = 0; t <= o; ++t) {
+      w[t] = new F(0, 0, 0, 0);
+      for (var y = 0; y <= e; ++y) {
+        var x = v[l - e + y][u - o + t].clone(), m = x.w;
+        x.x *= m, x.y *= m, x.z *= m, w[t].add(x.multiplyScalar(h[y]));
+      }
+    }
+    for (var S = new F(0, 0, 0, 0), t = 0; t <= o; ++t)
+      S.add(w[t].multiplyScalar(r[t]));
+    S.divideScalar(S.w), n.set(S.x, S.y, S.z);
+  }
+};
+export {
+  A as NURBSUtils
+};

package/libs/shared-utils/three/libs/inflate.js

@@ -0,0 +1,282 @@
+/** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */
+var tt = {}, b = void 0, et = tt;
+function C(i, e) {
+  var t = i.split("."), r = et;
+  !(t[0] in r) && r.execScript && r.execScript("var " + t[0]);
+  for (var s; t.length && (s = t.shift()); )
+    !t.length && e !== b ? r[s] = e : r = r[s] ? r[s] : r[s] = {};
+}
+var o = typeof Uint8Array != "undefined" && typeof Uint16Array != "undefined" && typeof Uint32Array != "undefined" && typeof DataView != "undefined";
+function k(i) {
+  var e = i.length, t = 0, r = Number.POSITIVE_INFINITY, s, h, n, a, f, l, u, y, c, d;
+  for (y = 0; y < e; ++y)
+    i[y] > t && (t = i[y]), i[y] < r && (r = i[y]);
+  for (s = 1 << t, h = new (o ? Uint32Array : Array)(s), n = 1, a = 0, f = 2; n <= t; ) {
+    for (y = 0; y < e; ++y)
+      if (i[y] === n) {
+        for (l = 0, u = a, c = 0; c < n; ++c)
+          l = l << 1 | u & 1, u >>= 1;
+        for (d = n << 16 | y, c = l; c < s; c += f)
+          h[c] = d;
+        ++a;
+      }
+    ++n, a <<= 1, f <<= 1;
+  }
+  return [h, t, r];
+}
+function A(i, e) {
+  switch (this.g = [], this.h = 32768, this.d = this.f = this.a = this.l = 0, this.input = o ? new Uint8Array(i) : i, this.m = !1, this.i = x, this.r = !1, (e || !(e = {})) && (e.index && (this.a = e.index), e.bufferSize && (this.h = e.bufferSize), e.bufferType && (this.i = e.bufferType), e.resize && (this.r = e.resize)), this.i) {
+    case D:
+      this.b = 32768, this.c = new (o ? Uint8Array : Array)(32768 + this.h + 258);
+      break;
+    case x:
+      this.b = 0, this.c = new (o ? Uint8Array : Array)(this.h), this.e = this.z, this.n = this.v, this.j = this.w;
+      break;
+    default:
+      throw Error("invalid inflate mode");
+  }
+}
+var D = 0, x = 1, J = { t: D, s: x };
+A.prototype.k = function() {
+  for (; !this.m; ) {
+    var i = v(this, 3);
+    switch (i & 1 && (this.m = !0), i >>>= 1, i) {
+      case 0:
+        var e = this.input, t = this.a, r = this.c, s = this.b, h = e.length, n = b, a = b, f = r.length, l = b;
+        if (this.d = this.f = 0, t + 1 >= h)
+          throw Error("invalid uncompressed block header: LEN");
+        if (n = e[t++] | e[t++] << 8, t + 1 >= h)
+          throw Error("invalid uncompressed block header: NLEN");
+        if (a = e[t++] | e[t++] << 8, n === ~a)
+          throw Error("invalid uncompressed block header: length verify");
+        if (t + n > e.length)
+          throw Error("input buffer is broken");
+        switch (this.i) {
+          case D:
+            for (; s + n > r.length; ) {
+              if (l = f - s, n -= l, o)
+                r.set(e.subarray(t, t + l), s), s += l, t += l;
+              else
+                for (; l--; )
+                  r[s++] = e[t++];
+              this.b = s, r = this.e(), s = this.b;
+            }
+            break;
+          case x:
+            for (; s + n > r.length; )
+              r = this.e({ p: 2 });
+            break;
+          default:
+            throw Error("invalid inflate mode");
+        }
+        if (o)
+          r.set(e.subarray(t, t + n), s), s += n, t += n;
+        else
+          for (; n--; )
+            r[s++] = e[t++];
+        this.a = t, this.b = s, this.c = r;
+        break;
+      case 1:
+        this.j(st, ht);
+        break;
+      case 2:
+        for (var u = v(this, 5) + 257, y = v(this, 5) + 1, c = v(this, 4) + 4, d = new (o ? Uint8Array : Array)(O.length), K = b, V = b, G = b, w = b, z = b, N = b, E = b, p = b, H = b, p = 0; p < c; ++p)
+          d[O[p]] = v(this, 3);
+        if (!o)
+          for (p = c, c = d.length; p < c; ++p)
+            d[O[p]] = 0;
+        for (K = k(d), w = new (o ? Uint8Array : Array)(u + y), p = 0, H = u + y; p < H; )
+          switch (z = T(this, K), z) {
+            case 16:
+              for (E = 3 + v(this, 2); E--; )
+                w[p++] = N;
+              break;
+            case 17:
+              for (E = 3 + v(this, 3); E--; )
+                w[p++] = 0;
+              N = 0;
+              break;
+            case 18:
+              for (E = 11 + v(this, 7); E--; )
+                w[p++] = 0;
+              N = 0;
+              break;
+            default:
+              N = w[p++] = z;
+          }
+        V = k(o ? w.subarray(0, u) : w.slice(0, u)), G = k(o ? w.subarray(u) : w.slice(u)), this.j(V, G);
+        break;
+      default:
+        throw Error("unknown BTYPE: " + i);
+    }
+  }
+  return this.n();
+};
+var Q = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15], O = o ? new Uint16Array(Q) : Q, R = [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, 258, 258], rt = o ? new Uint16Array(R) : R, W = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0], S = o ? new Uint8Array(W) : W, X = [
+  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
+], it = o ? new Uint16Array(X) : X, _ = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13], Z = o ? new Uint8Array(_) : _, B = new (o ? Uint8Array : Array)(288), g, $;
+g = 0;
+for ($ = B.length; g < $; ++g)
+  B[g] = 143 >= g ? 8 : 255 >= g ? 9 : 279 >= g ? 7 : 8;
+var st = k(B), L = new (o ? Uint8Array : Array)(30), j, F;
+j = 0;
+for (F = L.length; j < F; ++j)
+  L[j] = 5;
+var ht = k(L);
+function v(i, e) {
+  for (var t = i.f, r = i.d, s = i.input, h = i.a, n = s.length, a; r < e; ) {
+    if (h >= n)
+      throw Error("input buffer is broken");
+    t |= s[h++] << r, r += 8;
+  }
+  return a = t & (1 << e) - 1, i.f = t >>> e, i.d = r - e, i.a = h, a;
+}
+function T(i, e) {
+  for (var t = i.f, r = i.d, s = i.input, h = i.a, n = s.length, a = e[0], f = e[1], l, u; r < f && !(h >= n); )
+    t |= s[h++] << r, r += 8;
+  if (l = a[t & (1 << f) - 1], u = l >>> 16, u > r)
+    throw Error("invalid code length: " + u);
+  return i.f = t >> u, i.d = r - u, i.a = h, l & 65535;
+}
+A.prototype.j = function(i, e) {
+  var t = this.c, r = this.b;
+  this.o = i;
+  for (var s = t.length - 258, h, n, a, f; (h = T(this, i)) !== 256; )
+    if (256 > h)
+      r >= s && (this.b = r, t = this.e(), r = this.b), t[r++] = h;
+    else
+      for (n = h - 257, f = rt[n], 0 < S[n] && (f += v(this, S[n])), h = T(this, e), a = it[h], 0 < Z[h] && (a += v(this, Z[h])), r >= s && (this.b = r, t = this.e(), r = this.b); f--; )
+        t[r] = t[r++ - a];
+  for (; 8 <= this.d; )
+    this.d -= 8, this.a--;
+  this.b = r;
+};
+A.prototype.w = function(i, e) {
+  var t = this.c, r = this.b;
+  this.o = i;
+  for (var s = t.length, h, n, a, f; (h = T(this, i)) !== 256; )
+    if (256 > h)
+      r >= s && (t = this.e(), s = t.length), t[r++] = h;
+    else
+      for (n = h - 257, f = rt[n], 0 < S[n] && (f += v(this, S[n])), h = T(this, e), a = it[h], 0 < Z[h] && (a += v(this, Z[h])), r + f > s && (t = this.e(), s = t.length); f--; )
+        t[r] = t[r++ - a];
+  for (; 8 <= this.d; )
+    this.d -= 8, this.a--;
+  this.b = r;
+};
+A.prototype.e = function() {
+  var i = new (o ? Uint8Array : Array)(this.b - 32768), e = this.b - 32768, t, r, s = this.c;
+  if (o)
+    i.set(s.subarray(32768, i.length));
+  else
+    for (t = 0, r = i.length; t < r; ++t)
+      i[t] = s[t + 32768];
+  if (this.g.push(i), this.l += i.length, o)
+    s.set(s.subarray(e, e + 32768));
+  else
+    for (t = 0; 32768 > t; ++t)
+      s[t] = s[e + t];
+  return this.b = 32768, s;
+};
+A.prototype.z = function(i) {
+  var e, t = this.input.length / this.a + 1 | 0, r, s, h, n = this.input, a = this.c;
+  return i && (typeof i.p == "number" && (t = i.p), typeof i.u == "number" && (t += i.u)), 2 > t ? (r = (n.length - this.a) / this.o[2], h = 258 * (r / 2) | 0, s = h < a.length ? a.length + h : a.length << 1) : s = a.length * t, o ? (e = new Uint8Array(s), e.set(a)) : e = a, this.c = e;
+};
+A.prototype.n = function() {
+  var i = 0, e = this.c, t = this.g, r, s = new (o ? Uint8Array : Array)(this.l + (this.b - 32768)), h, n, a, f;
+  if (t.length === 0)
+    return o ? this.c.subarray(32768, this.b) : this.c.slice(32768, this.b);
+  for (h = 0, n = t.length; h < n; ++h)
+    for (r = t[h], a = 0, f = r.length; a < f; ++a)
+      s[i++] = r[a];
+  for (h = 32768, n = this.b; h < n; ++h)
+    s[i++] = e[h];
+  return this.g = [], this.buffer = s;
+};
+A.prototype.v = function() {
+  var i, e = this.b;
+  return o ? this.r ? (i = new Uint8Array(e), i.set(this.c.subarray(0, e))) : i = this.c.subarray(0, e) : (this.c.length > e && (this.c.length = e), i = this.c), this.buffer = i;
+};
+function Y(i, e) {
+  var t, r;
+  switch (this.input = i, this.a = 0, (e || !(e = {})) && (e.index && (this.a = e.index), e.verify && (this.A = e.verify)), t = i[this.a++], r = i[this.a++], t & 15) {
+    case M:
+      this.method = M;
+      break;
+    default:
+      throw Error("unsupported compression method");
+  }
+  if (((t << 8) + r) % 31 !== 0)
+    throw Error("invalid fcheck flag:" + ((t << 8) + r) % 31);
+  if (r & 32)
+    throw Error("fdict flag is not supported");
+  this.q = new A(i, { index: this.a, bufferSize: e.bufferSize, bufferType: e.bufferType, resize: e.resize });
+}
+Y.prototype.k = function() {
+  var i = this.input, e, t;
+  if (e = this.q.k(), this.a = this.q.a, this.A) {
+    t = (i[this.a++] << 24 | i[this.a++] << 16 | i[this.a++] << 8 | i[this.a++]) >>> 0;
+    var r = e;
+    if (typeof r == "string") {
+      var s = r.split(""), h, n;
+      for (h = 0, n = s.length; h < n; h++)
+        s[h] = (s[h].charCodeAt(0) & 255) >>> 0;
+      r = s;
+    }
+    for (var a = 1, f = 0, l = r.length, u, y = 0; 0 < l; ) {
+      u = 1024 < l ? 1024 : l, l -= u;
+      do
+        a += r[y++], f += a;
+      while (--u);
+      a %= 65521, f %= 65521;
+    }
+    if (t !== (f << 16 | a) >>> 0)
+      throw Error("invalid adler-32 checksum");
+  }
+  return e;
+};
+var M = 8;
+C("Zlib.Inflate", Y);
+C("Zlib.Inflate.prototype.decompress", Y.prototype.k);
+var P = { ADAPTIVE: J.s, BLOCK: J.t }, I, m, U, q;
+if (Object.keys)
+  I = Object.keys(P);
+else
+  for (m in I = [], U = 0, P)
+    I[U++] = m;
+U = 0;
+for (q = I.length; U < q; ++U)
+  m = I[U], C("Zlib.Inflate.BufferType." + m, P[m]);
+var nt = tt.Zlib;
+export {
+  nt as Zlib
+};