yahee-components 0.0.70 → 0.0.71

package/es/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/core/GestureMgr.js

@@ -0,0 +1,63 @@
+import { clientToLocal as p } from "./event.js";
+var _ = function() {
+  function r() {
+    this._track = [];
+  }
+  return r.prototype.recognize = function(t, n, e) {
+    return this._doTrack(t, n, e), this._recognize(t);
+  }, r.prototype.clear = function() {
+    return this._track.length = 0, this;
+  }, r.prototype._doTrack = function(t, n, e) {
+    var o = t.touches;
+    if (o) {
+      for (var c = {
+        points: [],
+        touches: [],
+        target: n,
+        event: t
+      }, i = 0, f = o.length; i < f; i++) {
+        var h = o[i], a = p(e, h, {});
+        c.points.push([a.zrX, a.zrY]), c.touches.push(h);
+      }
+      this._track.push(c);
+    }
+  }, r.prototype._recognize = function(t) {
+    for (var n in u)
+      if (u.hasOwnProperty(n)) {
+        var e = u[n](this._track, t);
+        if (e)
+          return e;
+      }
+  }, r;
+}();
+function s(r) {
+  var t = r[1][0] - r[0][0], n = r[1][1] - r[0][1];
+  return Math.sqrt(t * t + n * n);
+}
+function g(r) {
+  return [
+    (r[0][0] + r[1][0]) / 2,
+    (r[0][1] + r[1][1]) / 2
+  ];
+}
+var u = {
+  pinch: function(r, t) {
+    var n = r.length;
+    if (n) {
+      var e = (r[n - 1] || {}).points, o = (r[n - 2] || {}).points || e;
+      if (o && o.length > 1 && e && e.length > 1) {
+        var c = s(e) / s(o);
+        !isFinite(c) && (c = 1), t.pinchScale = c;
+        var i = g(e);
+        return t.pinchX = i[0], t.pinchY = i[1], {
+          type: "pinch",
+          target: r[0].target,
+          event: t
+        };
+      }
+    }
+  }
+};
+export {
+  _ as GestureMgr
+};

package/es/node_modules/.pnpm/zrender@6.0.0/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/es/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/core/OrientedBoundingRect.js

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

package/es/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/core/PathProxy.js

@@ -0,0 +1,309 @@
+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 _t, fromArc as Dt, fromQuadratic as Lt, fromCubic as Tt } from "./bbox.js";
+import { quadraticSubdivide as pt, 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 u = s - e;
+    return this.addData(h.A, t, r, a, a, e, u, 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) {
+    if (this._saveData) {
+      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) {
+    if (this._saveData) {
+      t instanceof Array || (t = [t]);
+      for (var r = t.length, a = 0, e = this._len, s = 0; s < r; s++)
+        a += t[s].len();
+      var i = this.data;
+      if (st && (i instanceof Float32Array || !i) && (this.data = new Float32Array(e + a), e > 0 && i))
+        for (var u = 0; u < e; u++)
+          this.data[u] = i[u];
+      for (var s = 0; s < r; s++)
+        for (var l = t[s].data, u = 0; u < l.length; u++)
+          this.data[e++] = l[u];
+      this._len = e;
+    }
+  }, v.prototype.addData = function(t, r, a, e, s, i, u, l, d) {
+    if (this._saveData) {
+      var _ = this.data;
+      this._len + arguments.length > _.length && (this._expandData(), _ = this.data);
+      for (var c = 0; c < arguments.length; c++)
+        _[this._len++] = arguments[c];
+    }
+  }, 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 u = t[i++], l = i === 1;
+      switch (l && (r = t[i], a = t[i + 1], e = r, s = a), u) {
+        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:
+          _t(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:
+          Lt(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++], _ = t[i++], c = t[i++], n = t[i++], y = t[i++], D = t[i++] + y;
+          i += 1;
+          var L = !t[i++];
+          l && (e = V(y) * c + d, s = Y(y) * n + _), Dt(d, _, c, n, y, D, L, g, k), r = V(D) * c + d, a = Y(D) * n + _;
+          break;
+        case h.R:
+          e = r = t[i++], s = a = t[i++];
+          var f = t[i++], m = t[i++];
+          _t(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, u = 0, l = 0;
+    this._pathSegLen || (this._pathSegLen = []);
+    for (var d = this._pathSegLen, _ = 0, c = 0, n = 0; n < r; ) {
+      var y = t[n++], D = n === 1;
+      D && (s = t[n], i = t[n + 1], u = s, l = i);
+      var L = -1;
+      switch (y) {
+        case h.M:
+          s = u = t[n++], i = l = 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) && (L = 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++];
+          L = 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++];
+          L = 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++], b = t[n++], H = t[n++], x = H + b;
+          n += 1, D && (u = V(b) * z + G, l = Y(b) * p + F), L = et(z, p) * it(w, Math.abs(H)), s = V(x) * z + G, i = Y(x) * p + F;
+          break;
+        case h.R: {
+          u = s = t[n++], l = i = t[n++];
+          var Q = t[n++], R = t[n++];
+          L = Q * 2 + R * 2;
+          break;
+        }
+        case h.Z: {
+          var P = u - s, T = l - i;
+          L = Math.sqrt(P * P + T * T), s = u, i = l;
+          break;
+        }
+      }
+      L >= 0 && (d[c++] = L, _ += L);
+    }
+    return this._pathLen = _, _;
+  }, v.prototype.rebuildPath = function(t, r) {
+    var a = this.data, e = this._ux, s = this._uy, i = this._len, u, l, d, _, c, n, y = r < 1, D, L, f = 0, m = 0, P, T = 0, E, U;
+    if (!(y && (this._pathSegLen || this._calculateLength(), D = this._pathSegLen, L = this._pathLen, P = r * L, !P)))
+      t: for (var o = 0; o < i; ) {
+        var A = a[o++], G = o === 1;
+        switch (G && (d = a[o], _ = a[o + 1], u = d, l = _), A !== h.L && T > 0 && (t.lineTo(E, U), T = 0), A) {
+          case h.M:
+            u = d = a[o++], l = _ = a[o++], t.moveTo(d, _);
+            break;
+          case h.L: {
+            c = a[o++], n = a[o++];
+            var F = S(c - d), z = S(n - _);
+            if (F > e || z > s) {
+              if (y) {
+                var p = D[m++];
+                if (f + p > P) {
+                  var b = (P - f) / p;
+                  t.lineTo(d * (1 - b) + c * b, _ * (1 - b) + n * b);
+                  break t;
+                }
+                f += p;
+              }
+              t.lineTo(c, n), d = c, _ = n, T = 0;
+            } else {
+              var H = F * F + z * z;
+              H > T && (E = c, 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 = D[m++];
+              if (f + p > P) {
+                var b = (P - f) / p;
+                ct(d, x, R, at, b, X), ct(_, Q, N, rt, b, 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, _ = rt;
+            break;
+          }
+          case h.Q: {
+            var x = a[o++], Q = a[o++], R = a[o++], N = a[o++];
+            if (y) {
+              var p = D[m++];
+              if (f + p > P) {
+                var b = (P - f) / p;
+                pt(d, x, R, b, X), pt(_, Q, N, b, Z), t.quadraticCurveTo(X[1], Z[1], X[2], Z[2]);
+                break t;
+              }
+              f += p;
+            }
+            t.quadraticCurveTo(x, Q, R, N), d = R, _ = 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 = D[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 && (u = V(B) * O + W, l = Y(B) * $ + tt), d = V(I) * O + W, _ = Y(I) * $ + tt;
+            break;
+          case h.R:
+            u = d = a[o], l = _ = a[o + 1], c = a[o++], n = a[o++];
+            var j = a[o++], J = a[o++];
+            if (y) {
+              var p = D[m++];
+              if (f + p > P) {
+                var C = P - f;
+                t.moveTo(c, n), t.lineTo(c + it(C, j), n), C -= j, C > 0 && t.lineTo(c + j, n + it(C, J)), C -= J, C > 0 && t.lineTo(c + et(j - C, 0), n + J), C -= j, C > 0 && t.lineTo(c, n + et(J - C, 0));
+                break t;
+              }
+              f += p;
+            }
+            t.rect(c, n, j, J);
+            break;
+          case h.Z:
+            if (y) {
+              var p = D[m++];
+              if (f + p > P) {
+                var b = (P - f) / p;
+                t.lineTo(d * (1 - b) + u * b, _ * (1 - b) + l * b);
+                break t;
+              }
+              f += p;
+            }
+            t.closePath(), d = u, _ = l;
+        }
+      }
+  }, 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.prototype.canSave = function() {
+    return !!this._saveData;
+  }, 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/es/node_modules/.pnpm/zrender@6.0.0/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/es/node_modules/.pnpm/zrender@6.0.0/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/es/node_modules/.pnpm/zrender@6.0.0/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
+};