office-viewer 0.3.13 → 0.3.15

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

@@ -1,296 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,327 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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 };