@fecp/mobile 1.0.79 → 1.1.1

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/core/Point.mjs

@@ -0,0 +1,131 @@
+var Point = function() {
+  function Point2(x, y) {
+    this.x = x || 0;
+    this.y = y || 0;
+  }
+  Point2.prototype.copy = function(other) {
+    this.x = other.x;
+    this.y = other.y;
+    return this;
+  };
+  Point2.prototype.clone = function() {
+    return new Point2(this.x, this.y);
+  };
+  Point2.prototype.set = function(x, y) {
+    this.x = x;
+    this.y = y;
+    return this;
+  };
+  Point2.prototype.equal = function(other) {
+    return other.x === this.x && other.y === this.y;
+  };
+  Point2.prototype.add = function(other) {
+    this.x += other.x;
+    this.y += other.y;
+    return this;
+  };
+  Point2.prototype.scale = function(scalar) {
+    this.x *= scalar;
+    this.y *= scalar;
+  };
+  Point2.prototype.scaleAndAdd = function(other, scalar) {
+    this.x += other.x * scalar;
+    this.y += other.y * scalar;
+  };
+  Point2.prototype.sub = function(other) {
+    this.x -= other.x;
+    this.y -= other.y;
+    return this;
+  };
+  Point2.prototype.dot = function(other) {
+    return this.x * other.x + this.y * other.y;
+  };
+  Point2.prototype.len = function() {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  };
+  Point2.prototype.lenSquare = function() {
+    return this.x * this.x + this.y * this.y;
+  };
+  Point2.prototype.normalize = function() {
+    var len = this.len();
+    this.x /= len;
+    this.y /= len;
+    return this;
+  };
+  Point2.prototype.distance = function(other) {
+    var dx = this.x - other.x;
+    var dy = this.y - other.y;
+    return Math.sqrt(dx * dx + dy * dy);
+  };
+  Point2.prototype.distanceSquare = function(other) {
+    var dx = this.x - other.x;
+    var dy = this.y - other.y;
+    return dx * dx + dy * dy;
+  };
+  Point2.prototype.negate = function() {
+    this.x = -this.x;
+    this.y = -this.y;
+    return this;
+  };
+  Point2.prototype.transform = function(m) {
+    if (!m) {
+      return;
+    }
+    var x = this.x;
+    var y = this.y;
+    this.x = m[0] * x + m[2] * y + m[4];
+    this.y = m[1] * x + m[3] * y + m[5];
+    return this;
+  };
+  Point2.prototype.toArray = function(out) {
+    out[0] = this.x;
+    out[1] = this.y;
+    return out;
+  };
+  Point2.prototype.fromArray = function(input) {
+    this.x = input[0];
+    this.y = input[1];
+  };
+  Point2.set = function(p, x, y) {
+    p.x = x;
+    p.y = y;
+  };
+  Point2.copy = function(p, p2) {
+    p.x = p2.x;
+    p.y = p2.y;
+  };
+  Point2.len = function(p) {
+    return Math.sqrt(p.x * p.x + p.y * p.y);
+  };
+  Point2.lenSquare = function(p) {
+    return p.x * p.x + p.y * p.y;
+  };
+  Point2.dot = function(p0, p1) {
+    return p0.x * p1.x + p0.y * p1.y;
+  };
+  Point2.add = function(out, p0, p1) {
+    out.x = p0.x + p1.x;
+    out.y = p0.y + p1.y;
+  };
+  Point2.sub = function(out, p0, p1) {
+    out.x = p0.x - p1.x;
+    out.y = p0.y - p1.y;
+  };
+  Point2.scale = function(out, p0, scalar) {
+    out.x = p0.x * scalar;
+    out.y = p0.y * scalar;
+  };
+  Point2.scaleAndAdd = function(out, p0, p1, scalar) {
+    out.x = p0.x + p1.x * scalar;
+    out.y = p0.y + p1.y * scalar;
+  };
+  Point2.lerp = function(out, p0, p1, t) {
+    var onet = 1 - t;
+    out.x = onet * p0.x + t * p1.x;
+    out.y = onet * p0.y + t * p1.y;
+  };
+  return Point2;
+}();
+export {
+  Point as default
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/core/Transformable.mjs

@@ -0,0 +1,236 @@
+import { identity, create, mul, copy, invert, rotate } from "./matrix.mjs";
+import { applyTransform } from "./vector.mjs";
+var mIdentity = identity;
+var EPSILON = 5e-5;
+function isNotAroundZero(val) {
+  return val > EPSILON || val < -5e-5;
+}
+var scaleTmp = [];
+var tmpTransform = [];
+var originTransform = create();
+var abs = Math.abs;
+var Transformable = function() {
+  function Transformable2() {
+  }
+  Transformable2.prototype.getLocalTransform = function(m) {
+    return Transformable2.getLocalTransform(this, m);
+  };
+  Transformable2.prototype.setPosition = function(arr) {
+    this.x = arr[0];
+    this.y = arr[1];
+  };
+  Transformable2.prototype.setScale = function(arr) {
+    this.scaleX = arr[0];
+    this.scaleY = arr[1];
+  };
+  Transformable2.prototype.setSkew = function(arr) {
+    this.skewX = arr[0];
+    this.skewY = arr[1];
+  };
+  Transformable2.prototype.setOrigin = function(arr) {
+    this.originX = arr[0];
+    this.originY = arr[1];
+  };
+  Transformable2.prototype.needLocalTransform = function() {
+    return isNotAroundZero(this.rotation) || isNotAroundZero(this.x) || isNotAroundZero(this.y) || isNotAroundZero(this.scaleX - 1) || isNotAroundZero(this.scaleY - 1) || isNotAroundZero(this.skewX) || isNotAroundZero(this.skewY);
+  };
+  Transformable2.prototype.updateTransform = function() {
+    var parentTransform = this.parent && this.parent.transform;
+    var needLocalTransform = this.needLocalTransform();
+    var m = this.transform;
+    if (!(needLocalTransform || parentTransform)) {
+      if (m) {
+        mIdentity(m);
+        this.invTransform = null;
+      }
+      return;
+    }
+    m = m || create();
+    if (needLocalTransform) {
+      this.getLocalTransform(m);
+    } else {
+      mIdentity(m);
+    }
+    if (parentTransform) {
+      if (needLocalTransform) {
+        mul(m, parentTransform, m);
+      } else {
+        copy(m, parentTransform);
+      }
+    }
+    this.transform = m;
+    this._resolveGlobalScaleRatio(m);
+  };
+  Transformable2.prototype._resolveGlobalScaleRatio = function(m) {
+    var globalScaleRatio = this.globalScaleRatio;
+    if (globalScaleRatio != null && globalScaleRatio !== 1) {
+      this.getGlobalScale(scaleTmp);
+      var relX = scaleTmp[0] < 0 ? -1 : 1;
+      var relY = scaleTmp[1] < 0 ? -1 : 1;
+      var sx = ((scaleTmp[0] - relX) * globalScaleRatio + relX) / scaleTmp[0] || 0;
+      var sy = ((scaleTmp[1] - relY) * globalScaleRatio + relY) / scaleTmp[1] || 0;
+      m[0] *= sx;
+      m[1] *= sx;
+      m[2] *= sy;
+      m[3] *= sy;
+    }
+    this.invTransform = this.invTransform || create();
+    invert(this.invTransform, m);
+  };
+  Transformable2.prototype.getComputedTransform = function() {
+    var transformNode = this;
+    var ancestors = [];
+    while (transformNode) {
+      ancestors.push(transformNode);
+      transformNode = transformNode.parent;
+    }
+    while (transformNode = ancestors.pop()) {
+      transformNode.updateTransform();
+    }
+    return this.transform;
+  };
+  Transformable2.prototype.setLocalTransform = function(m) {
+    if (!m) {
+      return;
+    }
+    var sx = m[0] * m[0] + m[1] * m[1];
+    var sy = m[2] * m[2] + m[3] * m[3];
+    var rotation = Math.atan2(m[1], m[0]);
+    var shearX = Math.PI / 2 + rotation - Math.atan2(m[3], m[2]);
+    sy = Math.sqrt(sy) * Math.cos(shearX);
+    sx = Math.sqrt(sx);
+    this.skewX = shearX;
+    this.skewY = 0;
+    this.rotation = -rotation;
+    this.x = +m[4];
+    this.y = +m[5];
+    this.scaleX = sx;
+    this.scaleY = sy;
+    this.originX = 0;
+    this.originY = 0;
+  };
+  Transformable2.prototype.decomposeTransform = function() {
+    if (!this.transform) {
+      return;
+    }
+    var parent = this.parent;
+    var m = this.transform;
+    if (parent && parent.transform) {
+      parent.invTransform = parent.invTransform || create();
+      mul(tmpTransform, parent.invTransform, m);
+      m = tmpTransform;
+    }
+    var ox = this.originX;
+    var oy = this.originY;
+    if (ox || oy) {
+      originTransform[4] = ox;
+      originTransform[5] = oy;
+      mul(tmpTransform, m, originTransform);
+      tmpTransform[4] -= ox;
+      tmpTransform[5] -= oy;
+      m = tmpTransform;
+    }
+    this.setLocalTransform(m);
+  };
+  Transformable2.prototype.getGlobalScale = function(out) {
+    var m = this.transform;
+    out = out || [];
+    if (!m) {
+      out[0] = 1;
+      out[1] = 1;
+      return out;
+    }
+    out[0] = Math.sqrt(m[0] * m[0] + m[1] * m[1]);
+    out[1] = Math.sqrt(m[2] * m[2] + m[3] * m[3]);
+    if (m[0] < 0) {
+      out[0] = -out[0];
+    }
+    if (m[3] < 0) {
+      out[1] = -out[1];
+    }
+    return out;
+  };
+  Transformable2.prototype.transformCoordToLocal = function(x, y) {
+    var v2 = [x, y];
+    var invTransform = this.invTransform;
+    if (invTransform) {
+      applyTransform(v2, v2, invTransform);
+    }
+    return v2;
+  };
+  Transformable2.prototype.transformCoordToGlobal = function(x, y) {
+    var v2 = [x, y];
+    var transform = this.transform;
+    if (transform) {
+      applyTransform(v2, v2, transform);
+    }
+    return v2;
+  };
+  Transformable2.prototype.getLineScale = function() {
+    var m = this.transform;
+    return m && abs(m[0] - 1) > 1e-10 && abs(m[3] - 1) > 1e-10 ? Math.sqrt(abs(m[0] * m[3] - m[2] * m[1])) : 1;
+  };
+  Transformable2.prototype.copyTransform = function(source) {
+    copyTransform(this, source);
+  };
+  Transformable2.getLocalTransform = function(target, m) {
+    m = m || [];
+    var ox = target.originX || 0;
+    var oy = target.originY || 0;
+    var sx = target.scaleX;
+    var sy = target.scaleY;
+    var ax = target.anchorX;
+    var ay = target.anchorY;
+    var rotation = target.rotation || 0;
+    var x = target.x;
+    var y = target.y;
+    var skewX = target.skewX ? Math.tan(target.skewX) : 0;
+    var skewY = target.skewY ? Math.tan(-target.skewY) : 0;
+    if (ox || oy || ax || ay) {
+      var dx = ox + ax;
+      var dy = oy + ay;
+      m[4] = -dx * sx - skewX * dy * sy;
+      m[5] = -dy * sy - skewY * dx * sx;
+    } else {
+      m[4] = m[5] = 0;
+    }
+    m[0] = sx;
+    m[3] = sy;
+    m[1] = skewY * sx;
+    m[2] = skewX * sy;
+    rotation && rotate(m, m, rotation);
+    m[4] += ox + x;
+    m[5] += oy + y;
+    return m;
+  };
+  Transformable2.initDefaultProps = function() {
+    var proto = Transformable2.prototype;
+    proto.scaleX = proto.scaleY = proto.globalScaleRatio = 1;
+    proto.x = proto.y = proto.originX = proto.originY = proto.skewX = proto.skewY = proto.rotation = proto.anchorX = proto.anchorY = 0;
+  }();
+  return Transformable2;
+}();
+var TRANSFORMABLE_PROPS = [
+  "x",
+  "y",
+  "originX",
+  "originY",
+  "anchorX",
+  "anchorY",
+  "rotation",
+  "scaleX",
+  "scaleY",
+  "skewX",
+  "skewY"
+];
+function copyTransform(target, source) {
+  for (var i = 0; i < TRANSFORMABLE_PROPS.length; i++) {
+    var propName = TRANSFORMABLE_PROPS[i];
+    target[propName] = source[propName];
+  }
+}
+export {
+  TRANSFORMABLE_PROPS,
+  copyTransform,
+  Transformable as default
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/core/WeakMap.mjs

@@ -0,0 +1,43 @@
+var wmUniqueIndex = Math.round(Math.random() * 9);
+var supportDefineProperty = typeof Object.defineProperty === "function";
+var WeakMap = function() {
+  function WeakMap2() {
+    this._id = "__ec_inner_" + wmUniqueIndex++;
+  }
+  WeakMap2.prototype.get = function(key) {
+    return this._guard(key)[this._id];
+  };
+  WeakMap2.prototype.set = function(key, value) {
+    var target = this._guard(key);
+    if (supportDefineProperty) {
+      Object.defineProperty(target, this._id, {
+        value,
+        enumerable: false,
+        configurable: true
+      });
+    } else {
+      target[this._id] = value;
+    }
+    return this;
+  };
+  WeakMap2.prototype["delete"] = function(key) {
+    if (this.has(key)) {
+      delete this._guard(key)[this._id];
+      return true;
+    }
+    return false;
+  };
+  WeakMap2.prototype.has = function(key) {
+    return !!this._guard(key)[this._id];
+  };
+  WeakMap2.prototype._guard = function(key) {
+    if (key !== Object(key)) {
+      throw TypeError("Value of WeakMap is not a non-null object.");
+    }
+    return key;
+  };
+  return WeakMap2;
+}();
+export {
+  WeakMap as default
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/core/bbox.mjs

@@ -0,0 +1,130 @@
+import { create, min, max } from "./vector.mjs";
+import { quadraticAt, cubicExtrema, cubicAt, quadraticExtremum } from "./curve.mjs";
+var mathMin = Math.min;
+var mathMax = Math.max;
+var mathSin = Math.sin;
+var mathCos = Math.cos;
+var PI2 = Math.PI * 2;
+var start = create();
+var end = create();
+var extremity = create();
+function fromPoints(points, min2, max2) {
+  if (points.length === 0) {
+    return;
+  }
+  var p = points[0];
+  var left = p[0];
+  var right = p[0];
+  var top = p[1];
+  var bottom = p[1];
+  for (var i = 1; i < points.length; i++) {
+    p = points[i];
+    left = mathMin(left, p[0]);
+    right = mathMax(right, p[0]);
+    top = mathMin(top, p[1]);
+    bottom = mathMax(bottom, p[1]);
+  }
+  min2[0] = left;
+  min2[1] = top;
+  max2[0] = right;
+  max2[1] = bottom;
+}
+function fromLine(x0, y0, x1, y1, min2, max2) {
+  min2[0] = mathMin(x0, x1);
+  min2[1] = mathMin(y0, y1);
+  max2[0] = mathMax(x0, x1);
+  max2[1] = mathMax(y0, y1);
+}
+var xDim = [];
+var yDim = [];
+function fromCubic(x0, y0, x1, y1, x2, y2, x3, y3, min2, max2) {
+  var cubicExtrema$1 = cubicExtrema;
+  var cubicAt$1 = cubicAt;
+  var n = cubicExtrema$1(x0, x1, x2, x3, xDim);
+  min2[0] = Infinity;
+  min2[1] = Infinity;
+  max2[0] = -Infinity;
+  max2[1] = -Infinity;
+  for (var i = 0; i < n; i++) {
+    var x = cubicAt$1(x0, x1, x2, x3, xDim[i]);
+    min2[0] = mathMin(x, min2[0]);
+    max2[0] = mathMax(x, max2[0]);
+  }
+  n = cubicExtrema$1(y0, y1, y2, y3, yDim);
+  for (var i = 0; i < n; i++) {
+    var y = cubicAt$1(y0, y1, y2, y3, yDim[i]);
+    min2[1] = mathMin(y, min2[1]);
+    max2[1] = mathMax(y, max2[1]);
+  }
+  min2[0] = mathMin(x0, min2[0]);
+  max2[0] = mathMax(x0, max2[0]);
+  min2[0] = mathMin(x3, min2[0]);
+  max2[0] = mathMax(x3, max2[0]);
+  min2[1] = mathMin(y0, min2[1]);
+  max2[1] = mathMax(y0, max2[1]);
+  min2[1] = mathMin(y3, min2[1]);
+  max2[1] = mathMax(y3, max2[1]);
+}
+function fromQuadratic(x0, y0, x1, y1, x2, y2, min2, max2) {
+  var quadraticExtremum$1 = quadraticExtremum;
+  var quadraticAt$1 = quadraticAt;
+  var tx = mathMax(mathMin(quadraticExtremum$1(x0, x1, x2), 1), 0);
+  var ty = mathMax(mathMin(quadraticExtremum$1(y0, y1, y2), 1), 0);
+  var x = quadraticAt$1(x0, x1, x2, tx);
+  var y = quadraticAt$1(y0, y1, y2, ty);
+  min2[0] = mathMin(x0, x2, x);
+  min2[1] = mathMin(y0, y2, y);
+  max2[0] = mathMax(x0, x2, x);
+  max2[1] = mathMax(y0, y2, y);
+}
+function fromArc(x, y, rx, ry, startAngle, endAngle, anticlockwise, min$1, max$1) {
+  var vec2Min = min;
+  var vec2Max = max;
+  var diff = Math.abs(startAngle - endAngle);
+  if (diff % PI2 < 1e-4 && diff > 1e-4) {
+    min$1[0] = x - rx;
+    min$1[1] = y - ry;
+    max$1[0] = x + rx;
+    max$1[1] = y + ry;
+    return;
+  }
+  start[0] = mathCos(startAngle) * rx + x;
+  start[1] = mathSin(startAngle) * ry + y;
+  end[0] = mathCos(endAngle) * rx + x;
+  end[1] = mathSin(endAngle) * ry + y;
+  vec2Min(min$1, start, end);
+  vec2Max(max$1, start, end);
+  startAngle = startAngle % PI2;
+  if (startAngle < 0) {
+    startAngle = startAngle + PI2;
+  }
+  endAngle = endAngle % PI2;
+  if (endAngle < 0) {
+    endAngle = endAngle + PI2;
+  }
+  if (startAngle > endAngle && !anticlockwise) {
+    endAngle += PI2;
+  } else if (startAngle < endAngle && anticlockwise) {
+    startAngle += PI2;
+  }
+  if (anticlockwise) {
+    var tmp = endAngle;
+    endAngle = startAngle;
+    startAngle = tmp;
+  }
+  for (var angle = 0; angle < endAngle; angle += Math.PI / 2) {
+    if (angle > startAngle) {
+      extremity[0] = mathCos(angle) * rx + x;
+      extremity[1] = mathSin(angle) * ry + y;
+      vec2Min(min$1, extremity, min$1);
+      vec2Max(max$1, extremity, max$1);
+    }
+  }
+}
+export {
+  fromArc,
+  fromCubic,
+  fromLine,
+  fromPoints,
+  fromQuadratic
+};