@fecp/mobile 1.0.79 → 1.1.0

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/dom/HandlerProxy.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const event = require("../core/event.js");
+const util = require("../core/util.js");
+const Eventful = require("../core/Eventful.js");
+const env = require("../core/env.js");
+var TOUCH_CLICK_DELAY = 300;
+var globalEventSupported = env.default.domSupported;
+var localNativeListenerNames = function() {
+  var mouseHandlerNames = [
+    "click",
+    "dblclick",
+    "mousewheel",
+    "wheel",
+    "mouseout",
+    "mouseup",
+    "mousedown",
+    "mousemove",
+    "contextmenu"
+  ];
+  var touchHandlerNames = [
+    "touchstart",
+    "touchend",
+    "touchmove"
+  ];
+  var pointerEventNameMap = {
+    pointerdown: 1,
+    pointerup: 1,
+    pointermove: 1,
+    pointerout: 1
+  };
+  var pointerHandlerNames = util.map(mouseHandlerNames, function(name) {
+    var nm = name.replace("mouse", "pointer");
+    return pointerEventNameMap.hasOwnProperty(nm) ? nm : name;
+  });
+  return {
+    mouse: mouseHandlerNames,
+    touch: touchHandlerNames,
+    pointer: pointerHandlerNames
+  };
+}();
+var globalNativeListenerNames = {
+  mouse: ["mousemove", "mouseup"],
+  pointer: ["pointermove", "pointerup"]
+};
+var wheelEventSupported = false;
+function isPointerFromTouch(event2) {
+  var pointerType = event2.pointerType;
+  return pointerType === "pen" || pointerType === "touch";
+}
+function setTouchTimer(scope) {
+  scope.touching = true;
+  if (scope.touchTimer != null) {
+    clearTimeout(scope.touchTimer);
+    scope.touchTimer = null;
+  }
+  scope.touchTimer = setTimeout(function() {
+    scope.touching = false;
+    scope.touchTimer = null;
+  }, 700);
+}
+function markTouch(event2) {
+  event2 && (event2.zrByTouch = true);
+}
+function normalizeGlobalEvent(instance, event$1) {
+  return event.normalizeEvent(instance.dom, new FakeGlobalEvent(instance, event$1), true);
+}
+function isLocalEl(instance, el) {
+  var elTmp = el;
+  var isLocal = false;
+  while (elTmp && elTmp.nodeType !== 9 && !(isLocal = elTmp.domBelongToZr || elTmp !== el && elTmp === instance.painterRoot)) {
+    elTmp = elTmp.parentNode;
+  }
+  return isLocal;
+}
+var FakeGlobalEvent = /* @__PURE__ */ function() {
+  function FakeGlobalEvent2(instance, event2) {
+    this.stopPropagation = util.noop;
+    this.stopImmediatePropagation = util.noop;
+    this.preventDefault = util.noop;
+    this.type = event2.type;
+    this.target = this.currentTarget = instance.dom;
+    this.pointerType = event2.pointerType;
+    this.clientX = event2.clientX;
+    this.clientY = event2.clientY;
+  }
+  return FakeGlobalEvent2;
+}();
+var localDOMHandlers = {
+  mousedown: function(event$1) {
+    event$1 = event.normalizeEvent(this.dom, event$1);
+    this.__mayPointerCapture = [event$1.zrX, event$1.zrY];
+    this.trigger("mousedown", event$1);
+  },
+  mousemove: function(event$1) {
+    event$1 = event.normalizeEvent(this.dom, event$1);
+    var downPoint = this.__mayPointerCapture;
+    if (downPoint && (event$1.zrX !== downPoint[0] || event$1.zrY !== downPoint[1])) {
+      this.__togglePointerCapture(true);
+    }
+    this.trigger("mousemove", event$1);
+  },
+  mouseup: function(event$1) {
+    event$1 = event.normalizeEvent(this.dom, event$1);
+    this.__togglePointerCapture(false);
+    this.trigger("mouseup", event$1);
+  },
+  mouseout: function(event$1) {
+    event$1 = event.normalizeEvent(this.dom, event$1);
+    var element = event$1.toElement || event$1.relatedTarget;
+    if (!isLocalEl(this, element)) {
+      if (this.__pointerCapturing) {
+        event$1.zrEventControl = "no_globalout";
+      }
+      this.trigger("mouseout", event$1);
+    }
+  },
+  wheel: function(event$1) {
+    wheelEventSupported = true;
+    event$1 = event.normalizeEvent(this.dom, event$1);
+    this.trigger("mousewheel", event$1);
+  },
+  mousewheel: function(event$1) {
+    if (wheelEventSupported) {
+      return;
+    }
+    event$1 = event.normalizeEvent(this.dom, event$1);
+    this.trigger("mousewheel", event$1);
+  },
+  touchstart: function(event$1) {
+    event$1 = event.normalizeEvent(this.dom, event$1);
+    markTouch(event$1);
+    this.__lastTouchMoment = /* @__PURE__ */ new Date();
+    this.handler.processGesture(event$1, "start");
+    localDOMHandlers.mousemove.call(this, event$1);
+    localDOMHandlers.mousedown.call(this, event$1);
+  },
+  touchmove: function(event$1) {
+    event$1 = event.normalizeEvent(this.dom, event$1);
+    markTouch(event$1);
+    this.handler.processGesture(event$1, "change");
+    localDOMHandlers.mousemove.call(this, event$1);
+  },
+  touchend: function(event$1) {
+    event$1 = event.normalizeEvent(this.dom, event$1);
+    markTouch(event$1);
+    this.handler.processGesture(event$1, "end");
+    localDOMHandlers.mouseup.call(this, event$1);
+    if (+/* @__PURE__ */ new Date() - +this.__lastTouchMoment < TOUCH_CLICK_DELAY) {
+      localDOMHandlers.click.call(this, event$1);
+    }
+  },
+  pointerdown: function(event2) {
+    localDOMHandlers.mousedown.call(this, event2);
+  },
+  pointermove: function(event2) {
+    if (!isPointerFromTouch(event2)) {
+      localDOMHandlers.mousemove.call(this, event2);
+    }
+  },
+  pointerup: function(event2) {
+    localDOMHandlers.mouseup.call(this, event2);
+  },
+  pointerout: function(event2) {
+    if (!isPointerFromTouch(event2)) {
+      localDOMHandlers.mouseout.call(this, event2);
+    }
+  }
+};
+util.each(["click", "dblclick", "contextmenu"], function(name) {
+  localDOMHandlers[name] = function(event$1) {
+    event$1 = event.normalizeEvent(this.dom, event$1);
+    this.trigger(name, event$1);
+  };
+});
+var globalDOMHandlers = {
+  pointermove: function(event2) {
+    if (!isPointerFromTouch(event2)) {
+      globalDOMHandlers.mousemove.call(this, event2);
+    }
+  },
+  pointerup: function(event2) {
+    globalDOMHandlers.mouseup.call(this, event2);
+  },
+  mousemove: function(event2) {
+    this.trigger("mousemove", event2);
+  },
+  mouseup: function(event2) {
+    var pointerCaptureReleasing = this.__pointerCapturing;
+    this.__togglePointerCapture(false);
+    this.trigger("mouseup", event2);
+    if (pointerCaptureReleasing) {
+      event2.zrEventControl = "only_globalout";
+      this.trigger("mouseout", event2);
+    }
+  }
+};
+function mountLocalDOMEventListeners(instance, scope) {
+  var domHandlers = scope.domHandlers;
+  if (env.default.pointerEventsSupported) {
+    util.each(localNativeListenerNames.pointer, function(nativeEventName) {
+      mountSingleDOMEventListener(scope, nativeEventName, function(event2) {
+        domHandlers[nativeEventName].call(instance, event2);
+      });
+    });
+  } else {
+    if (env.default.touchEventsSupported) {
+      util.each(localNativeListenerNames.touch, function(nativeEventName) {
+        mountSingleDOMEventListener(scope, nativeEventName, function(event2) {
+          domHandlers[nativeEventName].call(instance, event2);
+          setTouchTimer(scope);
+        });
+      });
+    }
+    util.each(localNativeListenerNames.mouse, function(nativeEventName) {
+      mountSingleDOMEventListener(scope, nativeEventName, function(event$1) {
+        event$1 = event.getNativeEvent(event$1);
+        if (!scope.touching) {
+          domHandlers[nativeEventName].call(instance, event$1);
+        }
+      });
+    });
+  }
+}
+function mountGlobalDOMEventListeners(instance, scope) {
+  if (env.default.pointerEventsSupported) {
+    util.each(globalNativeListenerNames.pointer, mount);
+  } else if (!env.default.touchEventsSupported) {
+    util.each(globalNativeListenerNames.mouse, mount);
+  }
+  function mount(nativeEventName) {
+    function nativeEventListener(event$1) {
+      event$1 = event.getNativeEvent(event$1);
+      if (!isLocalEl(instance, event$1.target)) {
+        event$1 = normalizeGlobalEvent(instance, event$1);
+        scope.domHandlers[nativeEventName].call(instance, event$1);
+      }
+    }
+    mountSingleDOMEventListener(scope, nativeEventName, nativeEventListener, { capture: true });
+  }
+}
+function mountSingleDOMEventListener(scope, nativeEventName, listener, opt) {
+  scope.mounted[nativeEventName] = listener;
+  scope.listenerOpts[nativeEventName] = opt;
+  event.addEventListener(scope.domTarget, nativeEventName, listener, opt);
+}
+function unmountDOMEventListeners(scope) {
+  var mounted = scope.mounted;
+  for (var nativeEventName in mounted) {
+    if (mounted.hasOwnProperty(nativeEventName)) {
+      event.removeEventListener(scope.domTarget, nativeEventName, mounted[nativeEventName], scope.listenerOpts[nativeEventName]);
+    }
+  }
+  scope.mounted = {};
+}
+var DOMHandlerScope = /* @__PURE__ */ function() {
+  function DOMHandlerScope2(domTarget, domHandlers) {
+    this.mounted = {};
+    this.listenerOpts = {};
+    this.touching = false;
+    this.domTarget = domTarget;
+    this.domHandlers = domHandlers;
+  }
+  return DOMHandlerScope2;
+}();
+var HandlerDomProxy = function(_super) {
+  tslib_es6.__extends(HandlerDomProxy2, _super);
+  function HandlerDomProxy2(dom, painterRoot) {
+    var _this = _super.call(this) || this;
+    _this.__pointerCapturing = false;
+    _this.dom = dom;
+    _this.painterRoot = painterRoot;
+    _this._localHandlerScope = new DOMHandlerScope(dom, localDOMHandlers);
+    if (globalEventSupported) {
+      _this._globalHandlerScope = new DOMHandlerScope(document, globalDOMHandlers);
+    }
+    mountLocalDOMEventListeners(_this, _this._localHandlerScope);
+    return _this;
+  }
+  HandlerDomProxy2.prototype.dispose = function() {
+    unmountDOMEventListeners(this._localHandlerScope);
+    if (globalEventSupported) {
+      unmountDOMEventListeners(this._globalHandlerScope);
+    }
+  };
+  HandlerDomProxy2.prototype.setCursor = function(cursorStyle) {
+    this.dom.style && (this.dom.style.cursor = cursorStyle || "default");
+  };
+  HandlerDomProxy2.prototype.__togglePointerCapture = function(isPointerCapturing) {
+    this.__mayPointerCapture = null;
+    if (globalEventSupported && +this.__pointerCapturing ^ +isPointerCapturing) {
+      this.__pointerCapturing = isPointerCapturing;
+      var globalHandlerScope = this._globalHandlerScope;
+      isPointerCapturing ? mountGlobalDOMEventListeners(this, globalHandlerScope) : unmountDOMEventListeners(globalHandlerScope);
+    }
+  };
+  return HandlerDomProxy2;
+}(Eventful.default);
+exports.default = HandlerDomProxy;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/CompoundPath.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const Path = require("./Path.js");
+var CompoundPath = function(_super) {
+  tslib_es6.__extends(CompoundPath2, _super);
+  function CompoundPath2() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = "compound";
+    return _this;
+  }
+  CompoundPath2.prototype._updatePathDirty = function() {
+    var paths = this.shape.paths;
+    var dirtyPath = this.shapeChanged();
+    for (var i = 0; i < paths.length; i++) {
+      dirtyPath = dirtyPath || paths[i].shapeChanged();
+    }
+    if (dirtyPath) {
+      this.dirtyShape();
+    }
+  };
+  CompoundPath2.prototype.beforeBrush = function() {
+    this._updatePathDirty();
+    var paths = this.shape.paths || [];
+    var scale = this.getGlobalScale();
+    for (var i = 0; i < paths.length; i++) {
+      if (!paths[i].path) {
+        paths[i].createPathProxy();
+      }
+      paths[i].path.setScale(scale[0], scale[1], paths[i].segmentIgnoreThreshold);
+    }
+  };
+  CompoundPath2.prototype.buildPath = function(ctx, shape) {
+    var paths = shape.paths || [];
+    for (var i = 0; i < paths.length; i++) {
+      paths[i].buildPath(ctx, paths[i].shape, true);
+    }
+  };
+  CompoundPath2.prototype.afterBrush = function() {
+    var paths = this.shape.paths || [];
+    for (var i = 0; i < paths.length; i++) {
+      paths[i].pathUpdated();
+    }
+  };
+  CompoundPath2.prototype.getBoundingRect = function() {
+    this._updatePathDirty.call(this);
+    return Path.default.prototype.getBoundingRect.call(this);
+  };
+  return CompoundPath2;
+}(Path.default);
+exports.default = CompoundPath;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/Displayable.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const Element = require("../Element.js");
+const BoundingRect = require("../core/BoundingRect.js");
+const util = require("../core/util.js");
+const constants = require("./constants.js");
+var STYLE_MAGIC_KEY = "__zr_style_" + Math.round(Math.random() * 10);
+var DEFAULT_COMMON_STYLE = {
+  shadowBlur: 0,
+  shadowOffsetX: 0,
+  shadowOffsetY: 0,
+  shadowColor: "#000",
+  opacity: 1,
+  blend: "source-over"
+};
+var DEFAULT_COMMON_ANIMATION_PROPS = {
+  style: {
+    shadowBlur: true,
+    shadowOffsetX: true,
+    shadowOffsetY: true,
+    shadowColor: true,
+    opacity: true
+  }
+};
+DEFAULT_COMMON_STYLE[STYLE_MAGIC_KEY] = true;
+var PRIMARY_STATES_KEYS = ["z", "z2", "invisible"];
+var PRIMARY_STATES_KEYS_IN_HOVER_LAYER = ["invisible"];
+var Displayable = function(_super) {
+  tslib_es6.__extends(Displayable2, _super);
+  function Displayable2(props) {
+    return _super.call(this, props) || this;
+  }
+  Displayable2.prototype._init = function(props) {
+    var keysArr = util.keys(props);
+    for (var i = 0; i < keysArr.length; i++) {
+      var key = keysArr[i];
+      if (key === "style") {
+        this.useStyle(props[key]);
+      } else {
+        _super.prototype.attrKV.call(this, key, props[key]);
+      }
+    }
+    if (!this.style) {
+      this.useStyle({});
+    }
+  };
+  Displayable2.prototype.beforeBrush = function() {
+  };
+  Displayable2.prototype.afterBrush = function() {
+  };
+  Displayable2.prototype.innerBeforeBrush = function() {
+  };
+  Displayable2.prototype.innerAfterBrush = function() {
+  };
+  Displayable2.prototype.shouldBePainted = function(viewWidth, viewHeight, considerClipPath, considerAncestors) {
+    var m = this.transform;
+    if (this.ignore || this.invisible || this.style.opacity === 0 || this.culling && isDisplayableCulled(this, viewWidth, viewHeight) || m && !m[0] && !m[3]) {
+      return false;
+    }
+    if (considerClipPath && this.__clipPaths) {
+      for (var i = 0; i < this.__clipPaths.length; ++i) {
+        if (this.__clipPaths[i].isZeroArea()) {
+          return false;
+        }
+      }
+    }
+    if (considerAncestors && this.parent) {
+      var parent_1 = this.parent;
+      while (parent_1) {
+        if (parent_1.ignore) {
+          return false;
+        }
+        parent_1 = parent_1.parent;
+      }
+    }
+    return true;
+  };
+  Displayable2.prototype.contain = function(x, y) {
+    return this.rectContain(x, y);
+  };
+  Displayable2.prototype.traverse = function(cb, context) {
+    cb.call(context, this);
+  };
+  Displayable2.prototype.rectContain = function(x, y) {
+    var coord = this.transformCoordToLocal(x, y);
+    var rect = this.getBoundingRect();
+    return rect.contain(coord[0], coord[1]);
+  };
+  Displayable2.prototype.getPaintRect = function() {
+    var rect = this._paintRect;
+    if (!this._paintRect || this.__dirty) {
+      var transform = this.transform;
+      var elRect = this.getBoundingRect();
+      var style = this.style;
+      var shadowSize = style.shadowBlur || 0;
+      var shadowOffsetX = style.shadowOffsetX || 0;
+      var shadowOffsetY = style.shadowOffsetY || 0;
+      rect = this._paintRect || (this._paintRect = new BoundingRect.default(0, 0, 0, 0));
+      if (transform) {
+        BoundingRect.default.applyTransform(rect, elRect, transform);
+      } else {
+        rect.copy(elRect);
+      }
+      if (shadowSize || shadowOffsetX || shadowOffsetY) {
+        rect.width += shadowSize * 2 + Math.abs(shadowOffsetX);
+        rect.height += shadowSize * 2 + Math.abs(shadowOffsetY);
+        rect.x = Math.min(rect.x, rect.x + shadowOffsetX - shadowSize);
+        rect.y = Math.min(rect.y, rect.y + shadowOffsetY - shadowSize);
+      }
+      var tolerance = this.dirtyRectTolerance;
+      if (!rect.isZero()) {
+        rect.x = Math.floor(rect.x - tolerance);
+        rect.y = Math.floor(rect.y - tolerance);
+        rect.width = Math.ceil(rect.width + 1 + tolerance * 2);
+        rect.height = Math.ceil(rect.height + 1 + tolerance * 2);
+      }
+    }
+    return rect;
+  };
+  Displayable2.prototype.setPrevPaintRect = function(paintRect) {
+    if (paintRect) {
+      this._prevPaintRect = this._prevPaintRect || new BoundingRect.default(0, 0, 0, 0);
+      this._prevPaintRect.copy(paintRect);
+    } else {
+      this._prevPaintRect = null;
+    }
+  };
+  Displayable2.prototype.getPrevPaintRect = function() {
+    return this._prevPaintRect;
+  };
+  Displayable2.prototype.animateStyle = function(loop) {
+    return this.animate("style", loop);
+  };
+  Displayable2.prototype.updateDuringAnimation = function(targetKey) {
+    if (targetKey === "style") {
+      this.dirtyStyle();
+    } else {
+      this.markRedraw();
+    }
+  };
+  Displayable2.prototype.attrKV = function(key, value) {
+    if (key !== "style") {
+      _super.prototype.attrKV.call(this, key, value);
+    } else {
+      if (!this.style) {
+        this.useStyle(value);
+      } else {
+        this.setStyle(value);
+      }
+    }
+  };
+  Displayable2.prototype.setStyle = function(keyOrObj, value) {
+    if (typeof keyOrObj === "string") {
+      this.style[keyOrObj] = value;
+    } else {
+      util.extend(this.style, keyOrObj);
+    }
+    this.dirtyStyle();
+    return this;
+  };
+  Displayable2.prototype.dirtyStyle = function(notRedraw) {
+    if (!notRedraw) {
+      this.markRedraw();
+    }
+    this.__dirty |= constants.STYLE_CHANGED_BIT;
+    if (this._rect) {
+      this._rect = null;
+    }
+  };
+  Displayable2.prototype.dirty = function() {
+    this.dirtyStyle();
+  };
+  Displayable2.prototype.styleChanged = function() {
+    return !!(this.__dirty & constants.STYLE_CHANGED_BIT);
+  };
+  Displayable2.prototype.styleUpdated = function() {
+    this.__dirty &= -3;
+  };
+  Displayable2.prototype.createStyle = function(obj) {
+    return util.createObject(DEFAULT_COMMON_STYLE, obj);
+  };
+  Displayable2.prototype.useStyle = function(obj) {
+    if (!obj[STYLE_MAGIC_KEY]) {
+      obj = this.createStyle(obj);
+    }
+    if (this.__inHover) {
+      this.__hoverStyle = obj;
+    } else {
+      this.style = obj;
+    }
+    this.dirtyStyle();
+  };
+  Displayable2.prototype.isStyleObject = function(obj) {
+    return obj[STYLE_MAGIC_KEY];
+  };
+  Displayable2.prototype._innerSaveToNormal = function(toState) {
+    _super.prototype._innerSaveToNormal.call(this, toState);
+    var normalState = this._normalState;
+    if (toState.style && !normalState.style) {
+      normalState.style = this._mergeStyle(this.createStyle(), this.style);
+    }
+    this._savePrimaryToNormal(toState, normalState, PRIMARY_STATES_KEYS);
+  };
+  Displayable2.prototype._applyStateObj = function(stateName, state, normalState, keepCurrentStates, transition, animationCfg) {
+    _super.prototype._applyStateObj.call(this, stateName, state, normalState, keepCurrentStates, transition, animationCfg);
+    var needsRestoreToNormal = !(state && keepCurrentStates);
+    var targetStyle;
+    if (state && state.style) {
+      if (transition) {
+        if (keepCurrentStates) {
+          targetStyle = state.style;
+        } else {
+          targetStyle = this._mergeStyle(this.createStyle(), normalState.style);
+          this._mergeStyle(targetStyle, state.style);
+        }
+      } else {
+        targetStyle = this._mergeStyle(this.createStyle(), keepCurrentStates ? this.style : normalState.style);
+        this._mergeStyle(targetStyle, state.style);
+      }
+    } else if (needsRestoreToNormal) {
+      targetStyle = normalState.style;
+    }
+    if (targetStyle) {
+      if (transition) {
+        var sourceStyle = this.style;
+        this.style = this.createStyle(needsRestoreToNormal ? {} : sourceStyle);
+        if (needsRestoreToNormal) {
+          var changedKeys = util.keys(sourceStyle);
+          for (var i = 0; i < changedKeys.length; i++) {
+            var key = changedKeys[i];
+            if (key in targetStyle) {
+              targetStyle[key] = targetStyle[key];
+              this.style[key] = sourceStyle[key];
+            }
+          }
+        }
+        var targetKeys = util.keys(targetStyle);
+        for (var i = 0; i < targetKeys.length; i++) {
+          var key = targetKeys[i];
+          this.style[key] = this.style[key];
+        }
+        this._transitionState(stateName, {
+          style: targetStyle
+        }, animationCfg, this.getAnimationStyleProps());
+      } else {
+        this.useStyle(targetStyle);
+      }
+    }
+    var statesKeys = this.__inHover ? PRIMARY_STATES_KEYS_IN_HOVER_LAYER : PRIMARY_STATES_KEYS;
+    for (var i = 0; i < statesKeys.length; i++) {
+      var key = statesKeys[i];
+      if (state && state[key] != null) {
+        this[key] = state[key];
+      } else if (needsRestoreToNormal) {
+        if (normalState[key] != null) {
+          this[key] = normalState[key];
+        }
+      }
+    }
+  };
+  Displayable2.prototype._mergeStates = function(states) {
+    var mergedState = _super.prototype._mergeStates.call(this, states);
+    var mergedStyle;
+    for (var i = 0; i < states.length; i++) {
+      var state = states[i];
+      if (state.style) {
+        mergedStyle = mergedStyle || {};
+        this._mergeStyle(mergedStyle, state.style);
+      }
+    }
+    if (mergedStyle) {
+      mergedState.style = mergedStyle;
+    }
+    return mergedState;
+  };
+  Displayable2.prototype._mergeStyle = function(targetStyle, sourceStyle) {
+    util.extend(targetStyle, sourceStyle);
+    return targetStyle;
+  };
+  Displayable2.prototype.getAnimationStyleProps = function() {
+    return DEFAULT_COMMON_ANIMATION_PROPS;
+  };
+  Displayable2.initDefaultProps = function() {
+    var dispProto = Displayable2.prototype;
+    dispProto.type = "displayable";
+    dispProto.invisible = false;
+    dispProto.z = 0;
+    dispProto.z2 = 0;
+    dispProto.zlevel = 0;
+    dispProto.culling = false;
+    dispProto.cursor = "pointer";
+    dispProto.rectHover = false;
+    dispProto.incremental = false;
+    dispProto._rect = null;
+    dispProto.dirtyRectTolerance = 0;
+    dispProto.__dirty = constants.REDRAW_BIT | constants.STYLE_CHANGED_BIT;
+  }();
+  return Displayable2;
+}(Element.default);
+var tmpRect = new BoundingRect.default(0, 0, 0, 0);
+var viewRect = new BoundingRect.default(0, 0, 0, 0);
+function isDisplayableCulled(el, width, height) {
+  tmpRect.copy(el.getBoundingRect());
+  if (el.transform) {
+    tmpRect.applyTransform(el.transform);
+  }
+  viewRect.width = width;
+  viewRect.height = height;
+  return !tmpRect.intersect(viewRect);
+}
+exports.DEFAULT_COMMON_ANIMATION_PROPS = DEFAULT_COMMON_ANIMATION_PROPS;
+exports.DEFAULT_COMMON_STYLE = DEFAULT_COMMON_STYLE;
+exports.default = Displayable;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/graphic/Gradient.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var Gradient = function() {
+  function Gradient2(colorStops) {
+    this.colorStops = colorStops || [];
+  }
+  Gradient2.prototype.addColorStop = function(offset, color) {
+    this.colorStops.push({
+      offset,
+      color
+    });
+  };
+  return Gradient2;
+}();
+exports.default = Gradient;