office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/zrender/lib/dom/HandlerProxy.js

@@ -0,0 +1,296 @@
+import { __extends } from 'tslib';
+import { normalizeEvent, addEventListener, removeEventListener, getNativeEvent } from '../core/event.js';
+import { map, each, noop } from '../core/util.js';
+import Eventful from '../core/Eventful.js';
+import env from '../core/env.js';
+
+var TOUCH_CLICK_DELAY = 300;
+var globalEventSupported = env.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 = 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(event) {
+    var pointerType = event.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(event) {
+    event && (event.zrByTouch = true);
+}
+function normalizeGlobalEvent(instance, event) {
+    return normalizeEvent(instance.dom, new FakeGlobalEvent(instance, event), 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 = (function () {
+    function FakeGlobalEvent(instance, event) {
+        this.stopPropagation = noop;
+        this.stopImmediatePropagation = noop;
+        this.preventDefault = noop;
+        this.type = event.type;
+        this.target = this.currentTarget = instance.dom;
+        this.pointerType = event.pointerType;
+        this.clientX = event.clientX;
+        this.clientY = event.clientY;
+    }
+    return FakeGlobalEvent;
+}());
+var localDOMHandlers = {
+    mousedown: function (event) {
+        event = normalizeEvent(this.dom, event);
+        this.__mayPointerCapture = [event.zrX, event.zrY];
+        this.trigger('mousedown', event);
+    },
+    mousemove: function (event) {
+        event = normalizeEvent(this.dom, event);
+        var downPoint = this.__mayPointerCapture;
+        if (downPoint && (event.zrX !== downPoint[0] || event.zrY !== downPoint[1])) {
+            this.__togglePointerCapture(true);
+        }
+        this.trigger('mousemove', event);
+    },
+    mouseup: function (event) {
+        event = normalizeEvent(this.dom, event);
+        this.__togglePointerCapture(false);
+        this.trigger('mouseup', event);
+    },
+    mouseout: function (event) {
+        event = normalizeEvent(this.dom, event);
+        var element = event.toElement || event.relatedTarget;
+        if (!isLocalEl(this, element)) {
+            if (this.__pointerCapturing) {
+                event.zrEventControl = 'no_globalout';
+            }
+            this.trigger('mouseout', event);
+        }
+    },
+    wheel: function (event) {
+        wheelEventSupported = true;
+        event = normalizeEvent(this.dom, event);
+        this.trigger('mousewheel', event);
+    },
+    mousewheel: function (event) {
+        if (wheelEventSupported) {
+            return;
+        }
+        event = normalizeEvent(this.dom, event);
+        this.trigger('mousewheel', event);
+    },
+    touchstart: function (event) {
+        event = normalizeEvent(this.dom, event);
+        markTouch(event);
+        this.__lastTouchMoment = new Date();
+        this.handler.processGesture(event, 'start');
+        localDOMHandlers.mousemove.call(this, event);
+        localDOMHandlers.mousedown.call(this, event);
+    },
+    touchmove: function (event) {
+        event = normalizeEvent(this.dom, event);
+        markTouch(event);
+        this.handler.processGesture(event, 'change');
+        localDOMHandlers.mousemove.call(this, event);
+    },
+    touchend: function (event) {
+        event = normalizeEvent(this.dom, event);
+        markTouch(event);
+        this.handler.processGesture(event, 'end');
+        localDOMHandlers.mouseup.call(this, event);
+        if (+new Date() - (+this.__lastTouchMoment) < TOUCH_CLICK_DELAY) {
+            localDOMHandlers.click.call(this, event);
+        }
+    },
+    pointerdown: function (event) {
+        localDOMHandlers.mousedown.call(this, event);
+    },
+    pointermove: function (event) {
+        if (!isPointerFromTouch(event)) {
+            localDOMHandlers.mousemove.call(this, event);
+        }
+    },
+    pointerup: function (event) {
+        localDOMHandlers.mouseup.call(this, event);
+    },
+    pointerout: function (event) {
+        if (!isPointerFromTouch(event)) {
+            localDOMHandlers.mouseout.call(this, event);
+        }
+    }
+};
+each(['click', 'dblclick', 'contextmenu'], function (name) {
+    localDOMHandlers[name] = function (event) {
+        event = normalizeEvent(this.dom, event);
+        this.trigger(name, event);
+    };
+});
+var globalDOMHandlers = {
+    pointermove: function (event) {
+        if (!isPointerFromTouch(event)) {
+            globalDOMHandlers.mousemove.call(this, event);
+        }
+    },
+    pointerup: function (event) {
+        globalDOMHandlers.mouseup.call(this, event);
+    },
+    mousemove: function (event) {
+        this.trigger('mousemove', event);
+    },
+    mouseup: function (event) {
+        var pointerCaptureReleasing = this.__pointerCapturing;
+        this.__togglePointerCapture(false);
+        this.trigger('mouseup', event);
+        if (pointerCaptureReleasing) {
+            event.zrEventControl = 'only_globalout';
+            this.trigger('mouseout', event);
+        }
+    }
+};
+function mountLocalDOMEventListeners(instance, scope) {
+    var domHandlers = scope.domHandlers;
+    if (env.pointerEventsSupported) {
+        each(localNativeListenerNames.pointer, function (nativeEventName) {
+            mountSingleDOMEventListener(scope, nativeEventName, function (event) {
+                domHandlers[nativeEventName].call(instance, event);
+            });
+        });
+    }
+    else {
+        if (env.touchEventsSupported) {
+            each(localNativeListenerNames.touch, function (nativeEventName) {
+                mountSingleDOMEventListener(scope, nativeEventName, function (event) {
+                    domHandlers[nativeEventName].call(instance, event);
+                    setTouchTimer(scope);
+                });
+            });
+        }
+        each(localNativeListenerNames.mouse, function (nativeEventName) {
+            mountSingleDOMEventListener(scope, nativeEventName, function (event) {
+                event = getNativeEvent(event);
+                if (!scope.touching) {
+                    domHandlers[nativeEventName].call(instance, event);
+                }
+            });
+        });
+    }
+}
+function mountGlobalDOMEventListeners(instance, scope) {
+    if (env.pointerEventsSupported) {
+        each(globalNativeListenerNames.pointer, mount);
+    }
+    else if (!env.touchEventsSupported) {
+        each(globalNativeListenerNames.mouse, mount);
+    }
+    function mount(nativeEventName) {
+        function nativeEventListener(event) {
+            event = getNativeEvent(event);
+            if (!isLocalEl(instance, event.target)) {
+                event = normalizeGlobalEvent(instance, event);
+                scope.domHandlers[nativeEventName].call(instance, event);
+            }
+        }
+        mountSingleDOMEventListener(scope, nativeEventName, nativeEventListener, { capture: true });
+    }
+}
+function mountSingleDOMEventListener(scope, nativeEventName, listener, opt) {
+    scope.mounted[nativeEventName] = listener;
+    scope.listenerOpts[nativeEventName] = opt;
+    addEventListener(scope.domTarget, nativeEventName, listener, opt);
+}
+function unmountDOMEventListeners(scope) {
+    var mounted = scope.mounted;
+    for (var nativeEventName in mounted) {
+        if (mounted.hasOwnProperty(nativeEventName)) {
+            removeEventListener(scope.domTarget, nativeEventName, mounted[nativeEventName], scope.listenerOpts[nativeEventName]);
+        }
+    }
+    scope.mounted = {};
+}
+var DOMHandlerScope = (function () {
+    function DOMHandlerScope(domTarget, domHandlers) {
+        this.mounted = {};
+        this.listenerOpts = {};
+        this.touching = false;
+        this.domTarget = domTarget;
+        this.domHandlers = domHandlers;
+    }
+    return DOMHandlerScope;
+}());
+var HandlerDomProxy = (function (_super) {
+    __extends(HandlerDomProxy, _super);
+    function HandlerDomProxy(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;
+    }
+    HandlerDomProxy.prototype.dispose = function () {
+        unmountDOMEventListeners(this._localHandlerScope);
+        if (globalEventSupported) {
+            unmountDOMEventListeners(this._globalHandlerScope);
+        }
+    };
+    HandlerDomProxy.prototype.setCursor = function (cursorStyle) {
+        this.dom.style && (this.dom.style.cursor = cursorStyle || 'default');
+    };
+    HandlerDomProxy.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 HandlerDomProxy;
+}(Eventful));
+var HandlerProxy = HandlerDomProxy;
+
+export { HandlerProxy as default };

package/esm/node_modules/zrender/lib/graphic/CompoundPath.js

@@ -0,0 +1,52 @@
+import { __extends } from 'tslib';
+import Path from './Path.js';
+
+var CompoundPath = (function (_super) {
+    __extends(CompoundPath, _super);
+    function CompoundPath() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.type = 'compound';
+        return _this;
+    }
+    CompoundPath.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();
+        }
+    };
+    CompoundPath.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);
+        }
+    };
+    CompoundPath.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);
+        }
+    };
+    CompoundPath.prototype.afterBrush = function () {
+        var paths = this.shape.paths || [];
+        for (var i = 0; i < paths.length; i++) {
+            paths[i].pathUpdated();
+        }
+    };
+    CompoundPath.prototype.getBoundingRect = function () {
+        this._updatePathDirty.call(this);
+        return Path.prototype.getBoundingRect.call(this);
+    };
+    return CompoundPath;
+}(Path));
+var CompoundPath$1 = CompoundPath;
+
+export { CompoundPath$1 as default };

package/esm/node_modules/zrender/lib/graphic/Displayable.js

@@ -0,0 +1,327 @@
+import { __extends } from 'tslib';
+import Element from '../Element.js';
+import BoundingRect from '../core/BoundingRect.js';
+import { keys, extend, createObject } from '../core/util.js';
+import { STYLE_CHANGED_BIT, REDRAW_BIT } from './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) {
+    __extends(Displayable, _super);
+    function Displayable(props) {
+        return _super.call(this, props) || this;
+    }
+    Displayable.prototype._init = function (props) {
+        var keysArr = 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({});
+        }
+    };
+    Displayable.prototype.beforeBrush = function () { };
+    Displayable.prototype.afterBrush = function () { };
+    Displayable.prototype.innerBeforeBrush = function () { };
+    Displayable.prototype.innerAfterBrush = function () { };
+    Displayable.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;
+    };
+    Displayable.prototype.contain = function (x, y) {
+        return this.rectContain(x, y);
+    };
+    Displayable.prototype.traverse = function (cb, context) {
+        cb.call(context, this);
+    };
+    Displayable.prototype.rectContain = function (x, y) {
+        var coord = this.transformCoordToLocal(x, y);
+        var rect = this.getBoundingRect();
+        return rect.contain(coord[0], coord[1]);
+    };
+    Displayable.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(0, 0, 0, 0));
+            if (transform) {
+                BoundingRect.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;
+    };
+    Displayable.prototype.setPrevPaintRect = function (paintRect) {
+        if (paintRect) {
+            this._prevPaintRect = this._prevPaintRect || new BoundingRect(0, 0, 0, 0);
+            this._prevPaintRect.copy(paintRect);
+        }
+        else {
+            this._prevPaintRect = null;
+        }
+    };
+    Displayable.prototype.getPrevPaintRect = function () {
+        return this._prevPaintRect;
+    };
+    Displayable.prototype.animateStyle = function (loop) {
+        return this.animate('style', loop);
+    };
+    Displayable.prototype.updateDuringAnimation = function (targetKey) {
+        if (targetKey === 'style') {
+            this.dirtyStyle();
+        }
+        else {
+            this.markRedraw();
+        }
+    };
+    Displayable.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);
+            }
+        }
+    };
+    Displayable.prototype.setStyle = function (keyOrObj, value) {
+        if (typeof keyOrObj === 'string') {
+            this.style[keyOrObj] = value;
+        }
+        else {
+            extend(this.style, keyOrObj);
+        }
+        this.dirtyStyle();
+        return this;
+    };
+    Displayable.prototype.dirtyStyle = function (notRedraw) {
+        if (!notRedraw) {
+            this.markRedraw();
+        }
+        this.__dirty |= STYLE_CHANGED_BIT;
+        if (this._rect) {
+            this._rect = null;
+        }
+    };
+    Displayable.prototype.dirty = function () {
+        this.dirtyStyle();
+    };
+    Displayable.prototype.styleChanged = function () {
+        return !!(this.__dirty & STYLE_CHANGED_BIT);
+    };
+    Displayable.prototype.styleUpdated = function () {
+        this.__dirty &= ~STYLE_CHANGED_BIT;
+    };
+    Displayable.prototype.createStyle = function (obj) {
+        return createObject(DEFAULT_COMMON_STYLE, obj);
+    };
+    Displayable.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();
+    };
+    Displayable.prototype.isStyleObject = function (obj) {
+        return obj[STYLE_MAGIC_KEY];
+    };
+    Displayable.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);
+    };
+    Displayable.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 = 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 = 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];
+                }
+            }
+        }
+    };
+    Displayable.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;
+    };
+    Displayable.prototype._mergeStyle = function (targetStyle, sourceStyle) {
+        extend(targetStyle, sourceStyle);
+        return targetStyle;
+    };
+    Displayable.prototype.getAnimationStyleProps = function () {
+        return DEFAULT_COMMON_ANIMATION_PROPS;
+    };
+    Displayable.initDefaultProps = (function () {
+        var dispProto = Displayable.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 = REDRAW_BIT | STYLE_CHANGED_BIT;
+    })();
+    return Displayable;
+}(Element));
+var tmpRect = new BoundingRect(0, 0, 0, 0);
+var viewRect = new BoundingRect(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);
+}
+var Displayable$1 = Displayable;
+
+export { DEFAULT_COMMON_ANIMATION_PROPS, DEFAULT_COMMON_STYLE, Displayable$1 as default };

package/esm/node_modules/zrender/lib/graphic/Gradient.js

@@ -0,0 +1,15 @@
+var Gradient = (function () {
+    function Gradient(colorStops) {
+        this.colorStops = colorStops || [];
+    }
+    Gradient.prototype.addColorStop = function (offset, color) {
+        this.colorStops.push({
+            offset: offset,
+            color: color
+        });
+    };
+    return Gradient;
+}());
+var Gradient$1 = Gradient;
+
+export { Gradient$1 as default };