@fecp/mobile 1.0.78 → 1.1.0

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

@@ -0,0 +1,203 @@
+import { translate, scale, create } from "./matrix.mjs";
+import Point from "./Point.mjs";
+var mathMin = Math.min;
+var mathMax = Math.max;
+var lt = new Point();
+var rb = new Point();
+var lb = new Point();
+var rt = new Point();
+var minTv = new Point();
+var maxTv = new Point();
+var BoundingRect = function() {
+  function BoundingRect2(x, y, width, height) {
+    if (width < 0) {
+      x = x + width;
+      width = -width;
+    }
+    if (height < 0) {
+      y = y + height;
+      height = -height;
+    }
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+  }
+  BoundingRect2.prototype.union = function(other) {
+    var x = mathMin(other.x, this.x);
+    var y = mathMin(other.y, this.y);
+    if (isFinite(this.x) && isFinite(this.width)) {
+      this.width = mathMax(other.x + other.width, this.x + this.width) - x;
+    } else {
+      this.width = other.width;
+    }
+    if (isFinite(this.y) && isFinite(this.height)) {
+      this.height = mathMax(other.y + other.height, this.y + this.height) - y;
+    } else {
+      this.height = other.height;
+    }
+    this.x = x;
+    this.y = y;
+  };
+  BoundingRect2.prototype.applyTransform = function(m) {
+    BoundingRect2.applyTransform(this, this, m);
+  };
+  BoundingRect2.prototype.calculateTransform = function(b) {
+    var a = this;
+    var sx = b.width / a.width;
+    var sy = b.height / a.height;
+    var m = create();
+    translate(m, m, [-a.x, -a.y]);
+    scale(m, m, [sx, sy]);
+    translate(m, m, [b.x, b.y]);
+    return m;
+  };
+  BoundingRect2.prototype.intersect = function(b, mtv) {
+    if (!b) {
+      return false;
+    }
+    if (!(b instanceof BoundingRect2)) {
+      b = BoundingRect2.create(b);
+    }
+    var a = this;
+    var ax0 = a.x;
+    var ax1 = a.x + a.width;
+    var ay0 = a.y;
+    var ay1 = a.y + a.height;
+    var bx0 = b.x;
+    var bx1 = b.x + b.width;
+    var by0 = b.y;
+    var by1 = b.y + b.height;
+    var overlap = !(ax1 < bx0 || bx1 < ax0 || ay1 < by0 || by1 < ay0);
+    if (mtv) {
+      var dMin = Infinity;
+      var dMax = 0;
+      var d0 = Math.abs(ax1 - bx0);
+      var d1 = Math.abs(bx1 - ax0);
+      var d2 = Math.abs(ay1 - by0);
+      var d3 = Math.abs(by1 - ay0);
+      var dx = Math.min(d0, d1);
+      var dy = Math.min(d2, d3);
+      if (ax1 < bx0 || bx1 < ax0) {
+        if (dx > dMax) {
+          dMax = dx;
+          if (d0 < d1) {
+            Point.set(maxTv, -d0, 0);
+          } else {
+            Point.set(maxTv, d1, 0);
+          }
+        }
+      } else {
+        if (dx < dMin) {
+          dMin = dx;
+          if (d0 < d1) {
+            Point.set(minTv, d0, 0);
+          } else {
+            Point.set(minTv, -d1, 0);
+          }
+        }
+      }
+      if (ay1 < by0 || by1 < ay0) {
+        if (dy > dMax) {
+          dMax = dy;
+          if (d2 < d3) {
+            Point.set(maxTv, 0, -d2);
+          } else {
+            Point.set(maxTv, 0, d3);
+          }
+        }
+      } else {
+        if (dx < dMin) {
+          dMin = dx;
+          if (d2 < d3) {
+            Point.set(minTv, 0, d2);
+          } else {
+            Point.set(minTv, 0, -d3);
+          }
+        }
+      }
+    }
+    if (mtv) {
+      Point.copy(mtv, overlap ? minTv : maxTv);
+    }
+    return overlap;
+  };
+  BoundingRect2.prototype.contain = function(x, y) {
+    var rect = this;
+    return x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height;
+  };
+  BoundingRect2.prototype.clone = function() {
+    return new BoundingRect2(this.x, this.y, this.width, this.height);
+  };
+  BoundingRect2.prototype.copy = function(other) {
+    BoundingRect2.copy(this, other);
+  };
+  BoundingRect2.prototype.plain = function() {
+    return {
+      x: this.x,
+      y: this.y,
+      width: this.width,
+      height: this.height
+    };
+  };
+  BoundingRect2.prototype.isFinite = function() {
+    return isFinite(this.x) && isFinite(this.y) && isFinite(this.width) && isFinite(this.height);
+  };
+  BoundingRect2.prototype.isZero = function() {
+    return this.width === 0 || this.height === 0;
+  };
+  BoundingRect2.create = function(rect) {
+    return new BoundingRect2(rect.x, rect.y, rect.width, rect.height);
+  };
+  BoundingRect2.copy = function(target, source) {
+    target.x = source.x;
+    target.y = source.y;
+    target.width = source.width;
+    target.height = source.height;
+  };
+  BoundingRect2.applyTransform = function(target, source, m) {
+    if (!m) {
+      if (target !== source) {
+        BoundingRect2.copy(target, source);
+      }
+      return;
+    }
+    if (m[1] < 1e-5 && m[1] > -1e-5 && m[2] < 1e-5 && m[2] > -1e-5) {
+      var sx = m[0];
+      var sy = m[3];
+      var tx = m[4];
+      var ty = m[5];
+      target.x = source.x * sx + tx;
+      target.y = source.y * sy + ty;
+      target.width = source.width * sx;
+      target.height = source.height * sy;
+      if (target.width < 0) {
+        target.x += target.width;
+        target.width = -target.width;
+      }
+      if (target.height < 0) {
+        target.y += target.height;
+        target.height = -target.height;
+      }
+      return;
+    }
+    lt.x = lb.x = source.x;
+    lt.y = rt.y = source.y;
+    rb.x = rt.x = source.x + source.width;
+    rb.y = lb.y = source.y + source.height;
+    lt.transform(m);
+    rt.transform(m);
+    rb.transform(m);
+    lb.transform(m);
+    target.x = mathMin(lt.x, rb.x, lb.x, rt.x);
+    target.y = mathMin(lt.y, rb.y, lb.y, rt.y);
+    var maxX = mathMax(lt.x, rb.x, lb.x, rt.x);
+    var maxY = mathMax(lt.y, rb.y, lb.y, rt.y);
+    target.width = maxX - target.x;
+    target.height = maxY - target.y;
+  };
+  return BoundingRect2;
+}();
+export {
+  BoundingRect as default
+};

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

@@ -0,0 +1,153 @@
+var Eventful = function() {
+  function Eventful2(eventProcessors) {
+    if (eventProcessors) {
+      this._$eventProcessor = eventProcessors;
+    }
+  }
+  Eventful2.prototype.on = function(event, query, handler, context) {
+    if (!this._$handlers) {
+      this._$handlers = {};
+    }
+    var _h = this._$handlers;
+    if (typeof query === "function") {
+      context = handler;
+      handler = query;
+      query = null;
+    }
+    if (!handler || !event) {
+      return this;
+    }
+    var eventProcessor = this._$eventProcessor;
+    if (query != null && eventProcessor && eventProcessor.normalizeQuery) {
+      query = eventProcessor.normalizeQuery(query);
+    }
+    if (!_h[event]) {
+      _h[event] = [];
+    }
+    for (var i = 0; i < _h[event].length; i++) {
+      if (_h[event][i].h === handler) {
+        return this;
+      }
+    }
+    var wrap = {
+      h: handler,
+      query,
+      ctx: context || this,
+      callAtLast: handler.zrEventfulCallAtLast
+    };
+    var lastIndex = _h[event].length - 1;
+    var lastWrap = _h[event][lastIndex];
+    lastWrap && lastWrap.callAtLast ? _h[event].splice(lastIndex, 0, wrap) : _h[event].push(wrap);
+    return this;
+  };
+  Eventful2.prototype.isSilent = function(eventName) {
+    var _h = this._$handlers;
+    return !_h || !_h[eventName] || !_h[eventName].length;
+  };
+  Eventful2.prototype.off = function(eventType, handler) {
+    var _h = this._$handlers;
+    if (!_h) {
+      return this;
+    }
+    if (!eventType) {
+      this._$handlers = {};
+      return this;
+    }
+    if (handler) {
+      if (_h[eventType]) {
+        var newList = [];
+        for (var i = 0, l = _h[eventType].length; i < l; i++) {
+          if (_h[eventType][i].h !== handler) {
+            newList.push(_h[eventType][i]);
+          }
+        }
+        _h[eventType] = newList;
+      }
+      if (_h[eventType] && _h[eventType].length === 0) {
+        delete _h[eventType];
+      }
+    } else {
+      delete _h[eventType];
+    }
+    return this;
+  };
+  Eventful2.prototype.trigger = function(eventType) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+      args[_i - 1] = arguments[_i];
+    }
+    if (!this._$handlers) {
+      return this;
+    }
+    var _h = this._$handlers[eventType];
+    var eventProcessor = this._$eventProcessor;
+    if (_h) {
+      var argLen = args.length;
+      var len = _h.length;
+      for (var i = 0; i < len; i++) {
+        var hItem = _h[i];
+        if (eventProcessor && eventProcessor.filter && hItem.query != null && !eventProcessor.filter(eventType, hItem.query)) {
+          continue;
+        }
+        switch (argLen) {
+          case 0:
+            hItem.h.call(hItem.ctx);
+            break;
+          case 1:
+            hItem.h.call(hItem.ctx, args[0]);
+            break;
+          case 2:
+            hItem.h.call(hItem.ctx, args[0], args[1]);
+            break;
+          default:
+            hItem.h.apply(hItem.ctx, args);
+            break;
+        }
+      }
+    }
+    eventProcessor && eventProcessor.afterTrigger && eventProcessor.afterTrigger(eventType);
+    return this;
+  };
+  Eventful2.prototype.triggerWithContext = function(type) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+      args[_i - 1] = arguments[_i];
+    }
+    if (!this._$handlers) {
+      return this;
+    }
+    var _h = this._$handlers[type];
+    var eventProcessor = this._$eventProcessor;
+    if (_h) {
+      var argLen = args.length;
+      var ctx = args[argLen - 1];
+      var len = _h.length;
+      for (var i = 0; i < len; i++) {
+        var hItem = _h[i];
+        if (eventProcessor && eventProcessor.filter && hItem.query != null && !eventProcessor.filter(type, hItem.query)) {
+          continue;
+        }
+        switch (argLen) {
+          case 0:
+            hItem.h.call(ctx);
+            break;
+          case 1:
+            hItem.h.call(ctx, args[0]);
+            break;
+          case 2:
+            hItem.h.call(ctx, args[0], args[1]);
+            break;
+          default:
+            hItem.h.apply(ctx, args.slice(1, argLen - 1));
+            break;
+        }
+      }
+    }
+    eventProcessor && eventProcessor.afterTrigger && eventProcessor.afterTrigger(type);
+    return this;
+  };
+  return Eventful2;
+}();
+export {
+  Eventful as default
+};

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

@@ -0,0 +1,81 @@
+import { clientToLocal } from "./event.mjs";
+var GestureMgr = function() {
+  function GestureMgr2() {
+    this._track = [];
+  }
+  GestureMgr2.prototype.recognize = function(event, target, root) {
+    this._doTrack(event, target, root);
+    return this._recognize(event);
+  };
+  GestureMgr2.prototype.clear = function() {
+    this._track.length = 0;
+    return this;
+  };
+  GestureMgr2.prototype._doTrack = function(event, target, root) {
+    var touches = event.touches;
+    if (!touches) {
+      return;
+    }
+    var trackItem = {
+      points: [],
+      touches: [],
+      target,
+      event
+    };
+    for (var i = 0, len = touches.length; i < len; i++) {
+      var touch = touches[i];
+      var pos = clientToLocal(root, touch, {});
+      trackItem.points.push([pos.zrX, pos.zrY]);
+      trackItem.touches.push(touch);
+    }
+    this._track.push(trackItem);
+  };
+  GestureMgr2.prototype._recognize = function(event) {
+    for (var eventName in recognizers) {
+      if (recognizers.hasOwnProperty(eventName)) {
+        var gestureInfo = recognizers[eventName](this._track, event);
+        if (gestureInfo) {
+          return gestureInfo;
+        }
+      }
+    }
+  };
+  return GestureMgr2;
+}();
+function dist(pointPair) {
+  var dx = pointPair[1][0] - pointPair[0][0];
+  var dy = pointPair[1][1] - pointPair[0][1];
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function center(pointPair) {
+  return [
+    (pointPair[0][0] + pointPair[1][0]) / 2,
+    (pointPair[0][1] + pointPair[1][1]) / 2
+  ];
+}
+var recognizers = {
+  pinch: function(tracks, event) {
+    var trackLen = tracks.length;
+    if (!trackLen) {
+      return;
+    }
+    var pinchEnd = (tracks[trackLen - 1] || {}).points;
+    var pinchPre = (tracks[trackLen - 2] || {}).points || pinchEnd;
+    if (pinchPre && pinchPre.length > 1 && pinchEnd && pinchEnd.length > 1) {
+      var pinchScale = dist(pinchEnd) / dist(pinchPre);
+      !isFinite(pinchScale) && (pinchScale = 1);
+      event.pinchScale = pinchScale;
+      var pinchCenter = center(pinchEnd);
+      event.pinchX = pinchCenter[0];
+      event.pinchY = pinchCenter[1];
+      return {
+        type: "pinch",
+        target: tracks[0].target,
+        event
+      };
+    }
+  }
+};
+export {
+  GestureMgr
+};

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

@@ -0,0 +1,108 @@
+var Entry = /* @__PURE__ */ function() {
+  function Entry2(val) {
+    this.value = val;
+  }
+  return Entry2;
+}();
+var LinkedList = function() {
+  function LinkedList2() {
+    this._len = 0;
+  }
+  LinkedList2.prototype.insert = function(val) {
+    var entry = new Entry(val);
+    this.insertEntry(entry);
+    return entry;
+  };
+  LinkedList2.prototype.insertEntry = function(entry) {
+    if (!this.head) {
+      this.head = this.tail = entry;
+    } else {
+      this.tail.next = entry;
+      entry.prev = this.tail;
+      entry.next = null;
+      this.tail = entry;
+    }
+    this._len++;
+  };
+  LinkedList2.prototype.remove = function(entry) {
+    var prev = entry.prev;
+    var next = entry.next;
+    if (prev) {
+      prev.next = next;
+    } else {
+      this.head = next;
+    }
+    if (next) {
+      next.prev = prev;
+    } else {
+      this.tail = prev;
+    }
+    entry.next = entry.prev = null;
+    this._len--;
+  };
+  LinkedList2.prototype.len = function() {
+    return this._len;
+  };
+  LinkedList2.prototype.clear = function() {
+    this.head = this.tail = null;
+    this._len = 0;
+  };
+  return LinkedList2;
+}();
+var LRU = function() {
+  function LRU2(maxSize) {
+    this._list = new LinkedList();
+    this._maxSize = 10;
+    this._map = {};
+    this._maxSize = maxSize;
+  }
+  LRU2.prototype.put = function(key, value) {
+    var list = this._list;
+    var map = this._map;
+    var removed = null;
+    if (map[key] == null) {
+      var len = list.len();
+      var entry = this._lastRemovedEntry;
+      if (len >= this._maxSize && len > 0) {
+        var leastUsedEntry = list.head;
+        list.remove(leastUsedEntry);
+        delete map[leastUsedEntry.key];
+        removed = leastUsedEntry.value;
+        this._lastRemovedEntry = leastUsedEntry;
+      }
+      if (entry) {
+        entry.value = value;
+      } else {
+        entry = new Entry(value);
+      }
+      entry.key = key;
+      list.insertEntry(entry);
+      map[key] = entry;
+    }
+    return removed;
+  };
+  LRU2.prototype.get = function(key) {
+    var entry = this._map[key];
+    var list = this._list;
+    if (entry != null) {
+      if (entry !== list.tail) {
+        list.remove(entry);
+        list.insertEntry(entry);
+      }
+      return entry.value;
+    }
+  };
+  LRU2.prototype.clear = function() {
+    this._list.clear();
+    this._map = {};
+  };
+  LRU2.prototype.len = function() {
+    return this._list.len();
+  };
+  return LRU2;
+}();
+export {
+  Entry,
+  LinkedList,
+  LRU as default
+};

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

@@ -0,0 +1,119 @@
+import Point from "./Point.mjs";
+var extent = [0, 0];
+var extent2 = [0, 0];
+var minTv = new Point();
+var maxTv = new Point();
+var OrientedBoundingRect = function() {
+  function OrientedBoundingRect2(rect, transform) {
+    this._corners = [];
+    this._axes = [];
+    this._origin = [0, 0];
+    for (var i = 0; i < 4; i++) {
+      this._corners[i] = new Point();
+    }
+    for (var i = 0; i < 2; i++) {
+      this._axes[i] = new Point();
+    }
+    if (rect) {
+      this.fromBoundingRect(rect, transform);
+    }
+  }
+  OrientedBoundingRect2.prototype.fromBoundingRect = function(rect, transform) {
+    var corners = this._corners;
+    var axes = this._axes;
+    var x = rect.x;
+    var y = rect.y;
+    var x2 = x + rect.width;
+    var y2 = y + rect.height;
+    corners[0].set(x, y);
+    corners[1].set(x2, y);
+    corners[2].set(x2, y2);
+    corners[3].set(x, y2);
+    if (transform) {
+      for (var i = 0; i < 4; i++) {
+        corners[i].transform(transform);
+      }
+    }
+    Point.sub(axes[0], corners[1], corners[0]);
+    Point.sub(axes[1], corners[3], corners[0]);
+    axes[0].normalize();
+    axes[1].normalize();
+    for (var i = 0; i < 2; i++) {
+      this._origin[i] = axes[i].dot(corners[0]);
+    }
+  };
+  OrientedBoundingRect2.prototype.intersect = function(other, mtv) {
+    var overlapped = true;
+    var noMtv = !mtv;
+    minTv.set(Infinity, Infinity);
+    maxTv.set(0, 0);
+    if (!this._intersectCheckOneSide(this, other, minTv, maxTv, noMtv, 1)) {
+      overlapped = false;
+      if (noMtv) {
+        return overlapped;
+      }
+    }
+    if (!this._intersectCheckOneSide(other, this, minTv, maxTv, noMtv, -1)) {
+      overlapped = false;
+      if (noMtv) {
+        return overlapped;
+      }
+    }
+    if (!noMtv) {
+      Point.copy(mtv, overlapped ? minTv : maxTv);
+    }
+    return overlapped;
+  };
+  OrientedBoundingRect2.prototype._intersectCheckOneSide = function(self, other, minTv2, maxTv2, noMtv, inverse) {
+    var overlapped = true;
+    for (var i = 0; i < 2; i++) {
+      var axis = this._axes[i];
+      this._getProjMinMaxOnAxis(i, self._corners, extent);
+      this._getProjMinMaxOnAxis(i, other._corners, extent2);
+      if (extent[1] < extent2[0] || extent[0] > extent2[1]) {
+        overlapped = false;
+        if (noMtv) {
+          return overlapped;
+        }
+        var dist0 = Math.abs(extent2[0] - extent[1]);
+        var dist1 = Math.abs(extent[0] - extent2[1]);
+        if (Math.min(dist0, dist1) > maxTv2.len()) {
+          if (dist0 < dist1) {
+            Point.scale(maxTv2, axis, -dist0 * inverse);
+          } else {
+            Point.scale(maxTv2, axis, dist1 * inverse);
+          }
+        }
+      } else if (minTv2) {
+        var dist0 = Math.abs(extent2[0] - extent[1]);
+        var dist1 = Math.abs(extent[0] - extent2[1]);
+        if (Math.min(dist0, dist1) < minTv2.len()) {
+          if (dist0 < dist1) {
+            Point.scale(minTv2, axis, dist0 * inverse);
+          } else {
+            Point.scale(minTv2, axis, -dist1 * inverse);
+          }
+        }
+      }
+    }
+    return overlapped;
+  };
+  OrientedBoundingRect2.prototype._getProjMinMaxOnAxis = function(dim, corners, out) {
+    var axis = this._axes[dim];
+    var origin = this._origin;
+    var proj = corners[0].dot(axis) + origin[dim];
+    var min = proj;
+    var max = proj;
+    for (var i = 1; i < corners.length; i++) {
+      var proj_1 = corners[i].dot(axis) + origin[dim];
+      min = Math.min(proj_1, min);
+      max = Math.max(proj_1, max);
+    }
+    out[0] = min;
+    out[1] = max;
+  };
+  return OrientedBoundingRect2;
+}();
+export {
+  OrientedBoundingRect as default
+};