web-core-tcm 0.0.54 → 0.0.61

package/dist/node_modules/zrender/lib/core/LRU.js

@@ -0,0 +1,52 @@
+var h = /* @__PURE__ */ (function() {
+  function e(t) {
+    this.value = t;
+  }
+  return e;
+})(), u = (function() {
+  function e() {
+    this._len = 0;
+  }
+  return e.prototype.insert = function(t) {
+    var i = new h(t);
+    return this.insertEntry(i), i;
+  }, e.prototype.insertEntry = function(t) {
+    this.head ? (this.tail.next = t, t.prev = this.tail, t.next = null, this.tail = t) : this.head = this.tail = t, this._len++;
+  }, e.prototype.remove = function(t) {
+    var i = t.prev, n = t.next;
+    i ? i.next = n : this.head = n, n ? n.prev = i : this.tail = i, t.next = t.prev = null, this._len--;
+  }, e.prototype.len = function() {
+    return this._len;
+  }, e.prototype.clear = function() {
+    this.head = this.tail = null, this._len = 0;
+  }, e;
+})(), p = (function() {
+  function e(t) {
+    this._list = new u(), this._maxSize = 10, this._map = {}, this._maxSize = t;
+  }
+  return e.prototype.put = function(t, i) {
+    var n = this._list, l = this._map, a = null;
+    if (l[t] == null) {
+      var o = n.len(), r = this._lastRemovedEntry;
+      if (o >= this._maxSize && o > 0) {
+        var s = n.head;
+        n.remove(s), delete l[s.key], a = s.value, this._lastRemovedEntry = s;
+      }
+      r ? r.value = i : r = new h(i), r.key = t, n.insertEntry(r), l[t] = r;
+    }
+    return a;
+  }, e.prototype.get = function(t) {
+    var i = this._map[t], n = this._list;
+    if (i != null)
+      return i !== n.tail && (n.remove(i), n.insertEntry(i)), i.value;
+  }, e.prototype.clear = function() {
+    this._list.clear(), this._map = {};
+  }, e.prototype.len = function() {
+    return this._list.len();
+  }, e;
+})();
+export {
+  h as Entry,
+  u as LinkedList,
+  p as default
+};

package/dist/node_modules/zrender/lib/core/OrientedBoundingRect.js

@@ -0,0 +1,46 @@
+import o from "./Point.js";
+var u = [0, 0], l = [0, 0], x = new o(), p = new o(), g = (function() {
+  function _(n, a) {
+    this._corners = [], this._axes = [], this._origin = [0, 0];
+    for (var t = 0; t < 4; t++)
+      this._corners[t] = new o();
+    for (var t = 0; t < 2; t++)
+      this._axes[t] = new o();
+    n && this.fromBoundingRect(n, a);
+  }
+  return _.prototype.fromBoundingRect = function(n, a) {
+    var t = this._corners, e = this._axes, v = n.x, s = n.y, f = v + n.width, i = s + n.height;
+    if (t[0].set(v, s), t[1].set(f, s), t[2].set(f, i), t[3].set(v, i), a)
+      for (var r = 0; r < 4; r++)
+        t[r].transform(a);
+    o.sub(e[0], t[1], t[0]), o.sub(e[1], t[3], t[0]), e[0].normalize(), e[1].normalize();
+    for (var r = 0; r < 2; r++)
+      this._origin[r] = e[r].dot(t[0]);
+  }, _.prototype.intersect = function(n, a) {
+    var t = !0, e = !a;
+    return x.set(1 / 0, 1 / 0), p.set(0, 0), !this._intersectCheckOneSide(this, n, x, p, e, 1) && (t = !1, e) || !this._intersectCheckOneSide(n, this, x, p, e, -1) && (t = !1, e) || e || o.copy(a, t ? x : p), t;
+  }, _.prototype._intersectCheckOneSide = function(n, a, t, e, v, s) {
+    for (var f = !0, i = 0; i < 2; i++) {
+      var r = this._axes[i];
+      if (this._getProjMinMaxOnAxis(i, n._corners, u), this._getProjMinMaxOnAxis(i, a._corners, l), u[1] < l[0] || u[0] > l[1]) {
+        if (f = !1, v)
+          return f;
+        var h = Math.abs(l[0] - u[1]), c = Math.abs(u[0] - l[1]);
+        Math.min(h, c) > e.len() && (h < c ? o.scale(e, r, -h * s) : o.scale(e, r, c * s));
+      } else if (t) {
+        var h = Math.abs(l[0] - u[1]), c = Math.abs(u[0] - l[1]);
+        Math.min(h, c) < t.len() && (h < c ? o.scale(t, r, h * s) : o.scale(t, r, -c * s));
+      }
+    }
+    return f;
+  }, _.prototype._getProjMinMaxOnAxis = function(n, a, t) {
+    for (var e = this._axes[n], v = this._origin, s = a[0].dot(e) + v[n], f = s, i = s, r = 1; r < a.length; r++) {
+      var h = a[r].dot(e) + v[n];
+      f = Math.min(h, f), i = Math.max(h, i);
+    }
+    t[0] = f, t[1] = i;
+  }, _;
+})();
+export {
+  g as default
+};

package/dist/node_modules/zrender/lib/core/PathProxy.js

@@ -0,0 +1,300 @@
+import { min as bt, max as mt } from "./vector.js";
+import yt from "./BoundingRect.js";
+import { devicePixelRatio as ut } from "../config.js";
+import { fromLine as pt, fromArc as Lt, fromQuadratic as Dt, fromCubic as Tt } from "./bbox.js";
+import { quadraticSubdivide as _t, cubicSubdivide as ct, quadraticLength as Ct, cubicLength as Mt } from "./curve.js";
+var h = {
+  M: 1,
+  L: 2,
+  C: 3,
+  Q: 4,
+  A: 5,
+  Z: 6,
+  R: 7
+}, X = [], Z = [], M = [], q = [], g = [], k = [], it = Math.min, et = Math.max, V = Math.cos, Y = Math.sin, S = Math.abs, vt = Math.PI, w = vt * 2, st = typeof Float32Array < "u", K = [];
+function nt(v) {
+  var t = Math.round(v / vt * 1e8) / 1e8;
+  return t % 2 * vt;
+}
+function gt(v, t) {
+  var r = nt(v[0]);
+  r < 0 && (r += w);
+  var a = r - v[0], e = v[1];
+  e += a, !t && e - r >= w ? e = r + w : t && r - e >= w ? e = r - w : !t && r > e ? e = r + (w - nt(r - e)) : t && r < e && (e = r - (w - nt(e - r))), v[0] = r, v[1] = e;
+}
+var wt = (function() {
+  function v(t) {
+    this.dpr = 1, this._xi = 0, this._yi = 0, this._x0 = 0, this._y0 = 0, this._len = 0, t && (this._saveData = !1), this._saveData && (this.data = []);
+  }
+  return v.prototype.increaseVersion = function() {
+    this._version++;
+  }, v.prototype.getVersion = function() {
+    return this._version;
+  }, v.prototype.setScale = function(t, r, a) {
+    a = a || 0, a > 0 && (this._ux = S(a / ut / t) || 0, this._uy = S(a / ut / r) || 0);
+  }, v.prototype.setDPR = function(t) {
+    this.dpr = t;
+  }, v.prototype.setContext = function(t) {
+    this._ctx = t;
+  }, v.prototype.getContext = function() {
+    return this._ctx;
+  }, v.prototype.beginPath = function() {
+    return this._ctx && this._ctx.beginPath(), this.reset(), this;
+  }, v.prototype.reset = function() {
+    this._saveData && (this._len = 0), this._pathSegLen && (this._pathSegLen = null, this._pathLen = 0), this._version++;
+  }, v.prototype.moveTo = function(t, r) {
+    return this._drawPendingPt(), this.addData(h.M, t, r), this._ctx && this._ctx.moveTo(t, r), this._x0 = t, this._y0 = r, this._xi = t, this._yi = r, this;
+  }, v.prototype.lineTo = function(t, r) {
+    var a = S(t - this._xi), e = S(r - this._yi), s = a > this._ux || e > this._uy;
+    if (this.addData(h.L, t, r), this._ctx && s && this._ctx.lineTo(t, r), s)
+      this._xi = t, this._yi = r, this._pendingPtDist = 0;
+    else {
+      var i = a * a + e * e;
+      i > this._pendingPtDist && (this._pendingPtX = t, this._pendingPtY = r, this._pendingPtDist = i);
+    }
+    return this;
+  }, v.prototype.bezierCurveTo = function(t, r, a, e, s, i) {
+    return this._drawPendingPt(), this.addData(h.C, t, r, a, e, s, i), this._ctx && this._ctx.bezierCurveTo(t, r, a, e, s, i), this._xi = s, this._yi = i, this;
+  }, v.prototype.quadraticCurveTo = function(t, r, a, e) {
+    return this._drawPendingPt(), this.addData(h.Q, t, r, a, e), this._ctx && this._ctx.quadraticCurveTo(t, r, a, e), this._xi = a, this._yi = e, this;
+  }, v.prototype.arc = function(t, r, a, e, s, i) {
+    this._drawPendingPt(), K[0] = e, K[1] = s, gt(K, i), e = K[0], s = K[1];
+    var c = s - e;
+    return this.addData(h.A, t, r, a, a, e, c, 0, i ? 0 : 1), this._ctx && this._ctx.arc(t, r, a, e, s, i), this._xi = V(s) * a + t, this._yi = Y(s) * a + r, this;
+  }, v.prototype.arcTo = function(t, r, a, e, s) {
+    return this._drawPendingPt(), this._ctx && this._ctx.arcTo(t, r, a, e, s), this;
+  }, v.prototype.rect = function(t, r, a, e) {
+    return this._drawPendingPt(), this._ctx && this._ctx.rect(t, r, a, e), this.addData(h.R, t, r, a, e), this;
+  }, v.prototype.closePath = function() {
+    this._drawPendingPt(), this.addData(h.Z);
+    var t = this._ctx, r = this._x0, a = this._y0;
+    return t && t.closePath(), this._xi = r, this._yi = a, this;
+  }, v.prototype.fill = function(t) {
+    t && t.fill(), this.toStatic();
+  }, v.prototype.stroke = function(t) {
+    t && t.stroke(), this.toStatic();
+  }, v.prototype.len = function() {
+    return this._len;
+  }, v.prototype.setData = function(t) {
+    var r = t.length;
+    !(this.data && this.data.length === r) && st && (this.data = new Float32Array(r));
+    for (var a = 0; a < r; a++)
+      this.data[a] = t[a];
+    this._len = r;
+  }, v.prototype.appendPath = function(t) {
+    t instanceof Array || (t = [t]);
+    for (var r = t.length, a = 0, e = this._len, s = 0; s < r; s++)
+      a += t[s].len();
+    st && this.data instanceof Float32Array && (this.data = new Float32Array(e + a));
+    for (var s = 0; s < r; s++)
+      for (var i = t[s].data, c = 0; c < i.length; c++)
+        this.data[e++] = i[c];
+    this._len = e;
+  }, v.prototype.addData = function(t, r, a, e, s, i, c, b, d) {
+    if (this._saveData) {
+      var u = this.data;
+      this._len + arguments.length > u.length && (this._expandData(), u = this.data);
+      for (var _ = 0; _ < arguments.length; _++)
+        u[this._len++] = arguments[_];
+    }
+  }, v.prototype._drawPendingPt = function() {
+    this._pendingPtDist > 0 && (this._ctx && this._ctx.lineTo(this._pendingPtX, this._pendingPtY), this._pendingPtDist = 0);
+  }, v.prototype._expandData = function() {
+    if (!(this.data instanceof Array)) {
+      for (var t = [], r = 0; r < this._len; r++)
+        t[r] = this.data[r];
+      this.data = t;
+    }
+  }, v.prototype.toStatic = function() {
+    if (this._saveData) {
+      this._drawPendingPt();
+      var t = this.data;
+      t instanceof Array && (t.length = this._len, st && this._len > 11 && (this.data = new Float32Array(t)));
+    }
+  }, v.prototype.getBoundingRect = function() {
+    M[0] = M[1] = g[0] = g[1] = Number.MAX_VALUE, q[0] = q[1] = k[0] = k[1] = -Number.MAX_VALUE;
+    var t = this.data, r = 0, a = 0, e = 0, s = 0, i;
+    for (i = 0; i < this._len; ) {
+      var c = t[i++], b = i === 1;
+      switch (b && (r = t[i], a = t[i + 1], e = r, s = a), c) {
+        case h.M:
+          r = e = t[i++], a = s = t[i++], g[0] = e, g[1] = s, k[0] = e, k[1] = s;
+          break;
+        case h.L:
+          pt(r, a, t[i], t[i + 1], g, k), r = t[i++], a = t[i++];
+          break;
+        case h.C:
+          Tt(r, a, t[i++], t[i++], t[i++], t[i++], t[i], t[i + 1], g, k), r = t[i++], a = t[i++];
+          break;
+        case h.Q:
+          Dt(r, a, t[i++], t[i++], t[i], t[i + 1], g, k), r = t[i++], a = t[i++];
+          break;
+        case h.A:
+          var d = t[i++], u = t[i++], _ = t[i++], n = t[i++], y = t[i++], L = t[i++] + y;
+          i += 1;
+          var D = !t[i++];
+          b && (e = V(y) * _ + d, s = Y(y) * n + u), Lt(d, u, _, n, y, L, D, g, k), r = V(L) * _ + d, a = Y(L) * n + u;
+          break;
+        case h.R:
+          e = r = t[i++], s = a = t[i++];
+          var f = t[i++], m = t[i++];
+          pt(e, s, e + f, s + m, g, k);
+          break;
+        case h.Z:
+          r = e, a = s;
+          break;
+      }
+      bt(M, M, g), mt(q, q, k);
+    }
+    return i === 0 && (M[0] = M[1] = q[0] = q[1] = 0), new yt(M[0], M[1], q[0] - M[0], q[1] - M[1]);
+  }, v.prototype._calculateLength = function() {
+    var t = this.data, r = this._len, a = this._ux, e = this._uy, s = 0, i = 0, c = 0, b = 0;
+    this._pathSegLen || (this._pathSegLen = []);
+    for (var d = this._pathSegLen, u = 0, _ = 0, n = 0; n < r; ) {
+      var y = t[n++], L = n === 1;
+      L && (s = t[n], i = t[n + 1], c = s, b = i);
+      var D = -1;
+      switch (y) {
+        case h.M:
+          s = c = t[n++], i = b = t[n++];
+          break;
+        case h.L: {
+          var f = t[n++], m = t[n++], P = f - s, T = m - i;
+          (S(P) > a || S(T) > e || n === r - 1) && (D = Math.sqrt(P * P + T * T), s = f, i = m);
+          break;
+        }
+        case h.C: {
+          var E = t[n++], U = t[n++], f = t[n++], m = t[n++], o = t[n++], A = t[n++];
+          D = Mt(s, i, E, U, f, m, o, A, 10), s = o, i = A;
+          break;
+        }
+        case h.Q: {
+          var E = t[n++], U = t[n++], f = t[n++], m = t[n++];
+          D = Ct(s, i, E, U, f, m, 10), s = f, i = m;
+          break;
+        }
+        case h.A:
+          var G = t[n++], F = t[n++], z = t[n++], p = t[n++], l = t[n++], H = t[n++], x = H + l;
+          n += 1, L && (c = V(l) * z + G, b = Y(l) * p + F), D = et(z, p) * it(w, Math.abs(H)), s = V(x) * z + G, i = Y(x) * p + F;
+          break;
+        case h.R: {
+          c = s = t[n++], b = i = t[n++];
+          var Q = t[n++], R = t[n++];
+          D = Q * 2 + R * 2;
+          break;
+        }
+        case h.Z: {
+          var P = c - s, T = b - i;
+          D = Math.sqrt(P * P + T * T), s = c, i = b;
+          break;
+        }
+      }
+      D >= 0 && (d[_++] = D, u += D);
+    }
+    return this._pathLen = u, u;
+  }, v.prototype.rebuildPath = function(t, r) {
+    var a = this.data, e = this._ux, s = this._uy, i = this._len, c, b, d, u, _, n, y = r < 1, L, D, f = 0, m = 0, P, T = 0, E, U;
+    if (!(y && (this._pathSegLen || this._calculateLength(), L = this._pathSegLen, D = this._pathLen, P = r * D, !P)))
+      t: for (var o = 0; o < i; ) {
+        var A = a[o++], G = o === 1;
+        switch (G && (d = a[o], u = a[o + 1], c = d, b = u), A !== h.L && T > 0 && (t.lineTo(E, U), T = 0), A) {
+          case h.M:
+            c = d = a[o++], b = u = a[o++], t.moveTo(d, u);
+            break;
+          case h.L: {
+            _ = a[o++], n = a[o++];
+            var F = S(_ - d), z = S(n - u);
+            if (F > e || z > s) {
+              if (y) {
+                var p = L[m++];
+                if (f + p > P) {
+                  var l = (P - f) / p;
+                  t.lineTo(d * (1 - l) + _ * l, u * (1 - l) + n * l);
+                  break t;
+                }
+                f += p;
+              }
+              t.lineTo(_, n), d = _, u = n, T = 0;
+            } else {
+              var H = F * F + z * z;
+              H > T && (E = _, U = n, T = H);
+            }
+            break;
+          }
+          case h.C: {
+            var x = a[o++], Q = a[o++], R = a[o++], N = a[o++], at = a[o++], rt = a[o++];
+            if (y) {
+              var p = L[m++];
+              if (f + p > P) {
+                var l = (P - f) / p;
+                ct(d, x, R, at, l, X), ct(u, Q, N, rt, l, Z), t.bezierCurveTo(X[1], Z[1], X[2], Z[2], X[3], Z[3]);
+                break t;
+              }
+              f += p;
+            }
+            t.bezierCurveTo(x, Q, R, N, at, rt), d = at, u = rt;
+            break;
+          }
+          case h.Q: {
+            var x = a[o++], Q = a[o++], R = a[o++], N = a[o++];
+            if (y) {
+              var p = L[m++];
+              if (f + p > P) {
+                var l = (P - f) / p;
+                _t(d, x, R, l, X), _t(u, Q, N, l, Z), t.quadraticCurveTo(X[1], Z[1], X[2], Z[2]);
+                break t;
+              }
+              f += p;
+            }
+            t.quadraticCurveTo(x, Q, R, N), d = R, u = N;
+            break;
+          }
+          case h.A:
+            var W = a[o++], tt = a[o++], O = a[o++], $ = a[o++], B = a[o++], ot = a[o++], dt = a[o++], ht = !a[o++], Pt = O > $ ? O : $, lt = S(O - $) > 1e-3, I = B + ot, ft = !1;
+            if (y) {
+              var p = L[m++];
+              f + p > P && (I = B + ot * (P - f) / p, ft = !0), f += p;
+            }
+            if (lt && t.ellipse ? t.ellipse(W, tt, O, $, dt, B, I, ht) : t.arc(W, tt, Pt, B, I, ht), ft)
+              break t;
+            G && (c = V(B) * O + W, b = Y(B) * $ + tt), d = V(I) * O + W, u = Y(I) * $ + tt;
+            break;
+          case h.R:
+            c = d = a[o], b = u = a[o + 1], _ = a[o++], n = a[o++];
+            var j = a[o++], J = a[o++];
+            if (y) {
+              var p = L[m++];
+              if (f + p > P) {
+                var C = P - f;
+                t.moveTo(_, n), t.lineTo(_ + it(C, j), n), C -= j, C > 0 && t.lineTo(_ + j, n + it(C, J)), C -= J, C > 0 && t.lineTo(_ + et(j - C, 0), n + J), C -= j, C > 0 && t.lineTo(_, n + et(J - C, 0));
+                break t;
+              }
+              f += p;
+            }
+            t.rect(_, n, j, J);
+            break;
+          case h.Z:
+            if (y) {
+              var p = L[m++];
+              if (f + p > P) {
+                var l = (P - f) / p;
+                t.lineTo(d * (1 - l) + c * l, u * (1 - l) + b * l);
+                break t;
+              }
+              f += p;
+            }
+            t.closePath(), d = c, u = b;
+        }
+      }
+  }, v.prototype.clone = function() {
+    var t = new v(), r = this.data;
+    return t.data = r.slice ? r.slice() : Array.prototype.slice.call(r), t._len = this._len, t;
+  }, v.CMD = h, v.initDefaultProps = (function() {
+    var t = v.prototype;
+    t._saveData = !0, t._ux = 0, t._uy = 0, t._pendingPtDist = 0, t._version = 0;
+  })(), v;
+})();
+export {
+  wt as default,
+  gt as normalizeArcAngles
+};

package/dist/node_modules/zrender/lib/core/Point.js

@@ -0,0 +1,72 @@
+var o = (function() {
+  function i(t, n) {
+    this.x = t || 0, this.y = n || 0;
+  }
+  return i.prototype.copy = function(t) {
+    return this.x = t.x, this.y = t.y, this;
+  }, i.prototype.clone = function() {
+    return new i(this.x, this.y);
+  }, i.prototype.set = function(t, n) {
+    return this.x = t, this.y = n, this;
+  }, i.prototype.equal = function(t) {
+    return t.x === this.x && t.y === this.y;
+  }, i.prototype.add = function(t) {
+    return this.x += t.x, this.y += t.y, this;
+  }, i.prototype.scale = function(t) {
+    this.x *= t, this.y *= t;
+  }, i.prototype.scaleAndAdd = function(t, n) {
+    this.x += t.x * n, this.y += t.y * n;
+  }, i.prototype.sub = function(t) {
+    return this.x -= t.x, this.y -= t.y, this;
+  }, i.prototype.dot = function(t) {
+    return this.x * t.x + this.y * t.y;
+  }, i.prototype.len = function() {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }, i.prototype.lenSquare = function() {
+    return this.x * this.x + this.y * this.y;
+  }, i.prototype.normalize = function() {
+    var t = this.len();
+    return this.x /= t, this.y /= t, this;
+  }, i.prototype.distance = function(t) {
+    var n = this.x - t.x, y = this.y - t.y;
+    return Math.sqrt(n * n + y * y);
+  }, i.prototype.distanceSquare = function(t) {
+    var n = this.x - t.x, y = this.y - t.y;
+    return n * n + y * y;
+  }, i.prototype.negate = function() {
+    return this.x = -this.x, this.y = -this.y, this;
+  }, i.prototype.transform = function(t) {
+    if (t) {
+      var n = this.x, y = this.y;
+      return this.x = t[0] * n + t[2] * y + t[4], this.y = t[1] * n + t[3] * y + t[5], this;
+    }
+  }, i.prototype.toArray = function(t) {
+    return t[0] = this.x, t[1] = this.y, t;
+  }, i.prototype.fromArray = function(t) {
+    this.x = t[0], this.y = t[1];
+  }, i.set = function(t, n, y) {
+    t.x = n, t.y = y;
+  }, i.copy = function(t, n) {
+    t.x = n.x, t.y = n.y;
+  }, i.len = function(t) {
+    return Math.sqrt(t.x * t.x + t.y * t.y);
+  }, i.lenSquare = function(t) {
+    return t.x * t.x + t.y * t.y;
+  }, i.dot = function(t, n) {
+    return t.x * n.x + t.y * n.y;
+  }, i.add = function(t, n, y) {
+    t.x = n.x + y.x, t.y = n.y + y.y;
+  }, i.sub = function(t, n, y) {
+    t.x = n.x - y.x, t.y = n.y - y.y;
+  }, i.scale = function(t, n, y) {
+    t.x = n.x * y, t.y = n.y * y;
+  }, i.scaleAndAdd = function(t, n, y, r) {
+    t.x = n.x + y.x * r, t.y = n.y + y.y * r;
+  }, i.lerp = function(t, n, y, r) {
+    var s = 1 - r;
+    t.x = s * n.x + r * y.x, t.y = s * n.y + r * y.y;
+  }, i;
+})();
+export {
+  o as default
+};

package/dist/node_modules/zrender/lib/core/Transformable.js

@@ -0,0 +1,105 @@
+import { identity as d, create as c, mul as l, copy as x, invert as R, rotate as P } from "./matrix.js";
+import { applyTransform as k } from "./vector.js";
+var g = d, L = 5e-5;
+function e(a) {
+  return a > L || a < -L;
+}
+var f = [], h = [], v = c(), p = Math.abs, A = (function() {
+  function a() {
+  }
+  return a.prototype.getLocalTransform = function(r) {
+    return a.getLocalTransform(this, r);
+  }, a.prototype.setPosition = function(r) {
+    this.x = r[0], this.y = r[1];
+  }, a.prototype.setScale = function(r) {
+    this.scaleX = r[0], this.scaleY = r[1];
+  }, a.prototype.setSkew = function(r) {
+    this.skewX = r[0], this.skewY = r[1];
+  }, a.prototype.setOrigin = function(r) {
+    this.originX = r[0], this.originY = r[1];
+  }, a.prototype.needLocalTransform = function() {
+    return e(this.rotation) || e(this.x) || e(this.y) || e(this.scaleX - 1) || e(this.scaleY - 1) || e(this.skewX) || e(this.skewY);
+  }, a.prototype.updateTransform = function() {
+    var r = this.parent && this.parent.transform, t = this.needLocalTransform(), o = this.transform;
+    if (!(t || r)) {
+      o && (g(o), this.invTransform = null);
+      return;
+    }
+    o = o || c(), t ? this.getLocalTransform(o) : g(o), r && (t ? l(o, r, o) : x(o, r)), this.transform = o, this._resolveGlobalScaleRatio(o);
+  }, a.prototype._resolveGlobalScaleRatio = function(r) {
+    var t = this.globalScaleRatio;
+    if (t != null && t !== 1) {
+      this.getGlobalScale(f);
+      var o = f[0] < 0 ? -1 : 1, n = f[1] < 0 ? -1 : 1, s = ((f[0] - o) * t + o) / f[0] || 0, i = ((f[1] - n) * t + n) / f[1] || 0;
+      r[0] *= s, r[1] *= s, r[2] *= i, r[3] *= i;
+    }
+    this.invTransform = this.invTransform || c(), R(this.invTransform, r);
+  }, a.prototype.getComputedTransform = function() {
+    for (var r = this, t = []; r; )
+      t.push(r), r = r.parent;
+    for (; r = t.pop(); )
+      r.updateTransform();
+    return this.transform;
+  }, a.prototype.setLocalTransform = function(r) {
+    if (r) {
+      var t = r[0] * r[0] + r[1] * r[1], o = r[2] * r[2] + r[3] * r[3], n = Math.atan2(r[1], r[0]), s = Math.PI / 2 + n - Math.atan2(r[3], r[2]);
+      o = Math.sqrt(o) * Math.cos(s), t = Math.sqrt(t), this.skewX = s, this.skewY = 0, this.rotation = -n, this.x = +r[4], this.y = +r[5], this.scaleX = t, this.scaleY = o, this.originX = 0, this.originY = 0;
+    }
+  }, a.prototype.decomposeTransform = function() {
+    if (this.transform) {
+      var r = this.parent, t = this.transform;
+      r && r.transform && (r.invTransform = r.invTransform || c(), l(h, r.invTransform, t), t = h);
+      var o = this.originX, n = this.originY;
+      (o || n) && (v[4] = o, v[5] = n, l(h, t, v), h[4] -= o, h[5] -= n, t = h), this.setLocalTransform(t);
+    }
+  }, a.prototype.getGlobalScale = function(r) {
+    var t = this.transform;
+    return r = r || [], t ? (r[0] = Math.sqrt(t[0] * t[0] + t[1] * t[1]), r[1] = Math.sqrt(t[2] * t[2] + t[3] * t[3]), t[0] < 0 && (r[0] = -r[0]), t[3] < 0 && (r[1] = -r[1]), r) : (r[0] = 1, r[1] = 1, r);
+  }, a.prototype.transformCoordToLocal = function(r, t) {
+    var o = [r, t], n = this.invTransform;
+    return n && k(o, o, n), o;
+  }, a.prototype.transformCoordToGlobal = function(r, t) {
+    var o = [r, t], n = this.transform;
+    return n && k(o, o, n), o;
+  }, a.prototype.getLineScale = function() {
+    var r = this.transform;
+    return r && p(r[0] - 1) > 1e-10 && p(r[3] - 1) > 1e-10 ? Math.sqrt(p(r[0] * r[3] - r[2] * r[1])) : 1;
+  }, a.prototype.copyTransform = function(r) {
+    q(this, r);
+  }, a.getLocalTransform = function(r, t) {
+    t = t || [];
+    var o = r.originX || 0, n = r.originY || 0, s = r.scaleX, i = r.scaleY, u = r.anchorX, T = r.anchorY, y = r.rotation || 0, S = r.x, b = r.y, m = r.skewX ? Math.tan(r.skewX) : 0, X = r.skewY ? Math.tan(-r.skewY) : 0;
+    if (o || n || u || T) {
+      var Y = o + u, w = n + T;
+      t[4] = -Y * s - m * w * i, t[5] = -w * i - X * Y * s;
+    } else
+      t[4] = t[5] = 0;
+    return t[0] = s, t[3] = i, t[1] = X * s, t[2] = m * i, y && P(t, t, y), t[4] += o + S, t[5] += n + b, t;
+  }, a.initDefaultProps = (function() {
+    var r = a.prototype;
+    r.scaleX = r.scaleY = r.globalScaleRatio = 1, r.x = r.y = r.originX = r.originY = r.skewX = r.skewY = r.rotation = r.anchorX = r.anchorY = 0;
+  })(), a;
+})(), M = [
+  "x",
+  "y",
+  "originX",
+  "originY",
+  "anchorX",
+  "anchorY",
+  "rotation",
+  "scaleX",
+  "scaleY",
+  "skewX",
+  "skewY"
+];
+function q(a, r) {
+  for (var t = 0; t < M.length; t++) {
+    var o = M[t];
+    a[o] = r[o];
+  }
+}
+export {
+  M as TRANSFORMABLE_PROPS,
+  q as copyTransform,
+  A as default
+};

package/dist/node_modules/zrender/lib/core/WeakMap.js

@@ -0,0 +1,26 @@
+var i = Math.round(Math.random() * 9), o = typeof Object.defineProperty == "function", u = (function() {
+  function e() {
+    this._id = "__ec_inner_" + i++;
+  }
+  return e.prototype.get = function(t) {
+    return this._guard(t)[this._id];
+  }, e.prototype.set = function(t, r) {
+    var n = this._guard(t);
+    return o ? Object.defineProperty(n, this._id, {
+      value: r,
+      enumerable: !1,
+      configurable: !0
+    }) : n[this._id] = r, this;
+  }, e.prototype.delete = function(t) {
+    return this.has(t) ? (delete this._guard(t)[this._id], !0) : !1;
+  }, e.prototype.has = function(t) {
+    return !!this._guard(t)[this._id];
+  }, e.prototype._guard = function(t) {
+    if (t !== Object(t))
+      throw TypeError("Value of WeakMap is not a non-null object.");
+    return t;
+  }, e;
+})();
+export {
+  u as default
+};

package/dist/node_modules/zrender/lib/core/bbox.js

@@ -0,0 +1,52 @@
+import { min as H, max as J, create as j } from "./vector.js";
+import { quadraticAt as K, cubicExtrema as N, cubicAt as O, quadraticExtremum as R } from "./curve.js";
+var b = Math.min, I = Math.max, Q = Math.sin, S = Math.cos, p = Math.PI * 2, C = j(), D = j(), L = j();
+function V(t, c, u) {
+  if (t.length !== 0) {
+    for (var a = t[0], r = a[0], v = a[0], M = a[1], i = a[1], f = 1; f < t.length; f++)
+      a = t[f], r = b(r, a[0]), v = I(v, a[0]), M = b(M, a[1]), i = I(i, a[1]);
+    c[0] = r, c[1] = M, u[0] = v, u[1] = i;
+  }
+}
+function W(t, c, u, a, r, v) {
+  r[0] = b(t, u), r[1] = b(c, a), v[0] = I(t, u), v[1] = I(c, a);
+}
+var F = [], G = [];
+function X(t, c, u, a, r, v, M, i, f, o) {
+  var E = N, P = O, q = E(t, u, r, M, F);
+  f[0] = 1 / 0, f[1] = 1 / 0, o[0] = -1 / 0, o[1] = -1 / 0;
+  for (var h = 0; h < q; h++) {
+    var z = P(t, u, r, M, F[h]);
+    f[0] = b(z, f[0]), o[0] = I(z, o[0]);
+  }
+  q = E(c, a, v, i, G);
+  for (var h = 0; h < q; h++) {
+    var B = P(c, a, v, i, G[h]);
+    f[1] = b(B, f[1]), o[1] = I(B, o[1]);
+  }
+  f[0] = b(t, f[0]), o[0] = I(t, o[0]), f[0] = b(M, f[0]), o[0] = I(M, o[0]), f[1] = b(c, f[1]), o[1] = I(c, o[1]), f[1] = b(i, f[1]), o[1] = I(i, o[1]);
+}
+function Y(t, c, u, a, r, v, M, i) {
+  var f = R, o = K, E = I(b(f(t, u, r), 1), 0), P = I(b(f(c, a, v), 1), 0), q = o(t, u, r, E), h = o(c, a, v, P);
+  M[0] = b(t, r, q), M[1] = b(c, v, h), i[0] = I(t, r, q), i[1] = I(c, v, h);
+}
+function Z(t, c, u, a, r, v, M, i, f) {
+  var o = H, E = J, P = Math.abs(r - v);
+  if (P % p < 1e-4 && P > 1e-4) {
+    i[0] = t - u, i[1] = c - a, f[0] = t + u, f[1] = c + a;
+    return;
+  }
+  if (C[0] = S(r) * u + t, C[1] = Q(r) * a + c, D[0] = S(v) * u + t, D[1] = Q(v) * a + c, o(i, C, D), E(f, C, D), r = r % p, r < 0 && (r = r + p), v = v % p, v < 0 && (v = v + p), r > v && !M ? v += p : r < v && M && (r += p), M) {
+    var q = v;
+    v = r, r = q;
+  }
+  for (var h = 0; h < v; h += Math.PI / 2)
+    h > r && (L[0] = S(h) * u + t, L[1] = Q(h) * a + c, o(i, L, i), E(f, L, f));
+}
+export {
+  Z as fromArc,
+  X as fromCubic,
+  W as fromLine,
+  V as fromPoints,
+  Y as fromQuadratic
+};