office-viewer 0.3.13 → 0.3.14

package/esm/node_modules/zrender/lib/graphic/shape/Polyline.js

@@ -1,36 +0,0 @@
-import { __extends } from 'tslib';
-import Path from '../Path.js';
-import { buildPath } from '../helper/poly.js';
-
-var PolylineShape = (function () {
-    function PolylineShape() {
-        this.points = null;
-        this.percent = 1;
-        this.smooth = 0;
-        this.smoothConstraint = null;
-    }
-    return PolylineShape;
-}());
-var Polyline = (function (_super) {
-    __extends(Polyline, _super);
-    function Polyline(opts) {
-        return _super.call(this, opts) || this;
-    }
-    Polyline.prototype.getDefaultStyle = function () {
-        return {
-            stroke: '#000',
-            fill: null
-        };
-    };
-    Polyline.prototype.getDefaultShape = function () {
-        return new PolylineShape();
-    };
-    Polyline.prototype.buildPath = function (ctx, shape) {
-        buildPath(ctx, shape, false);
-    };
-    return Polyline;
-}(Path));
-Polyline.prototype.type = 'polyline';
-var Polyline$1 = Polyline;
-
-export { PolylineShape, Polyline$1 as default };

package/esm/node_modules/zrender/lib/graphic/shape/Rect.js

@@ -1,59 +0,0 @@
-import { __extends } from 'tslib';
-import Path from '../Path.js';
-import { buildPath } from '../helper/roundRect.js';
-import { subPixelOptimizeRect } from '../helper/subPixelOptimize.js';
-
-var RectShape = (function () {
-    function RectShape() {
-        this.x = 0;
-        this.y = 0;
-        this.width = 0;
-        this.height = 0;
-    }
-    return RectShape;
-}());
-var subPixelOptimizeOutputShape = {};
-var Rect = (function (_super) {
-    __extends(Rect, _super);
-    function Rect(opts) {
-        return _super.call(this, opts) || this;
-    }
-    Rect.prototype.getDefaultShape = function () {
-        return new RectShape();
-    };
-    Rect.prototype.buildPath = function (ctx, shape) {
-        var x;
-        var y;
-        var width;
-        var height;
-        if (this.subPixelOptimize) {
-            var optimizedShape = subPixelOptimizeRect(subPixelOptimizeOutputShape, shape, this.style);
-            x = optimizedShape.x;
-            y = optimizedShape.y;
-            width = optimizedShape.width;
-            height = optimizedShape.height;
-            optimizedShape.r = shape.r;
-            shape = optimizedShape;
-        }
-        else {
-            x = shape.x;
-            y = shape.y;
-            width = shape.width;
-            height = shape.height;
-        }
-        if (!shape.r) {
-            ctx.rect(x, y, width, height);
-        }
-        else {
-            buildPath(ctx, shape);
-        }
-    };
-    Rect.prototype.isZeroArea = function () {
-        return !this.shape.width || !this.shape.height;
-    };
-    return Rect;
-}(Path));
-Rect.prototype.type = 'rect';
-var Rect$1 = Rect;
-
-export { RectShape, Rect$1 as default };

package/esm/node_modules/zrender/lib/graphic/shape/Ring.js

@@ -1,35 +0,0 @@
-import { __extends } from 'tslib';
-import Path from '../Path.js';
-
-var RingShape = (function () {
-    function RingShape() {
-        this.cx = 0;
-        this.cy = 0;
-        this.r = 0;
-        this.r0 = 0;
-    }
-    return RingShape;
-}());
-var Ring = (function (_super) {
-    __extends(Ring, _super);
-    function Ring(opts) {
-        return _super.call(this, opts) || this;
-    }
-    Ring.prototype.getDefaultShape = function () {
-        return new RingShape();
-    };
-    Ring.prototype.buildPath = function (ctx, shape) {
-        var x = shape.cx;
-        var y = shape.cy;
-        var PI2 = Math.PI * 2;
-        ctx.moveTo(x + shape.r, y);
-        ctx.arc(x, y, shape.r, 0, PI2, false);
-        ctx.moveTo(x + shape.r0, y);
-        ctx.arc(x, y, shape.r0, 0, PI2, true);
-    };
-    return Ring;
-}(Path));
-Ring.prototype.type = 'ring';
-var Ring$1 = Ring;
-
-export { RingShape, Ring$1 as default };

package/esm/node_modules/zrender/lib/graphic/shape/Sector.js

@@ -1,38 +0,0 @@
-import { __extends } from 'tslib';
-import Path from '../Path.js';
-import { buildPath } from '../helper/roundSector.js';
-
-var SectorShape = (function () {
-    function SectorShape() {
-        this.cx = 0;
-        this.cy = 0;
-        this.r0 = 0;
-        this.r = 0;
-        this.startAngle = 0;
-        this.endAngle = Math.PI * 2;
-        this.clockwise = true;
-        this.cornerRadius = 0;
-    }
-    return SectorShape;
-}());
-var Sector = (function (_super) {
-    __extends(Sector, _super);
-    function Sector(opts) {
-        return _super.call(this, opts) || this;
-    }
-    Sector.prototype.getDefaultShape = function () {
-        return new SectorShape();
-    };
-    Sector.prototype.buildPath = function (ctx, shape) {
-        buildPath(ctx, shape);
-    };
-    Sector.prototype.isZeroArea = function () {
-        return this.shape.startAngle === this.shape.endAngle
-            || this.shape.r === this.shape.r0;
-    };
-    return Sector;
-}(Path));
-Sector.prototype.type = 'sector';
-var Sector$1 = Sector;
-
-export { SectorShape, Sector$1 as default };

package/esm/node_modules/zrender/lib/mixin/Draggable.js

@@ -1,68 +0,0 @@
-var Param = (function () {
-    function Param(target, e) {
-        this.target = target;
-        this.topTarget = e && e.topTarget;
-    }
-    return Param;
-}());
-var Draggable = (function () {
-    function Draggable(handler) {
-        this.handler = handler;
-        handler.on('mousedown', this._dragStart, this);
-        handler.on('mousemove', this._drag, this);
-        handler.on('mouseup', this._dragEnd, this);
-    }
-    Draggable.prototype._dragStart = function (e) {
-        var draggingTarget = e.target;
-        while (draggingTarget && !draggingTarget.draggable) {
-            draggingTarget = draggingTarget.parent || draggingTarget.__hostTarget;
-        }
-        if (draggingTarget) {
-            this._draggingTarget = draggingTarget;
-            draggingTarget.dragging = true;
-            this._x = e.offsetX;
-            this._y = e.offsetY;
-            this.handler.dispatchToElement(new Param(draggingTarget, e), 'dragstart', e.event);
-        }
-    };
-    Draggable.prototype._drag = function (e) {
-        var draggingTarget = this._draggingTarget;
-        if (draggingTarget) {
-            var x = e.offsetX;
-            var y = e.offsetY;
-            var dx = x - this._x;
-            var dy = y - this._y;
-            this._x = x;
-            this._y = y;
-            draggingTarget.drift(dx, dy, e);
-            this.handler.dispatchToElement(new Param(draggingTarget, e), 'drag', e.event);
-            var dropTarget = this.handler.findHover(x, y, draggingTarget).target;
-            var lastDropTarget = this._dropTarget;
-            this._dropTarget = dropTarget;
-            if (draggingTarget !== dropTarget) {
-                if (lastDropTarget && dropTarget !== lastDropTarget) {
-                    this.handler.dispatchToElement(new Param(lastDropTarget, e), 'dragleave', e.event);
-                }
-                if (dropTarget && dropTarget !== lastDropTarget) {
-                    this.handler.dispatchToElement(new Param(dropTarget, e), 'dragenter', e.event);
-                }
-            }
-        }
-    };
-    Draggable.prototype._dragEnd = function (e) {
-        var draggingTarget = this._draggingTarget;
-        if (draggingTarget) {
-            draggingTarget.dragging = false;
-        }
-        this.handler.dispatchToElement(new Param(draggingTarget, e), 'dragend', e.event);
-        if (this._dropTarget) {
-            this.handler.dispatchToElement(new Param(this._dropTarget, e), 'drop', e.event);
-        }
-        this._draggingTarget = null;
-        this._dropTarget = null;
-    };
-    return Draggable;
-}());
-var Draggable$1 = Draggable;
-
-export { Draggable$1 as default };

package/esm/node_modules/zrender/lib/svg/Painter.js

@@ -1,255 +0,0 @@
-import { brush, setClipPath, setGradient, setPattern } from './graphic.js';
-import { createBrushScope, createVNode, getCssString, createSVGVNode, vNodeToString, createElement } from './core.js';
-import { isPattern, encodeBase64, isGradient, normalizeColor } from './helper.js';
-import { map, keys, retrieve2, noop, extend, logError } from '../core/util.js';
-import patch, { updateAttrs } from './patch.js';
-import { getSize } from '../canvas/helper.js';
-
-var svgId = 0;
-var SVGPainter = (function () {
-    function SVGPainter(root, storage, opts) {
-        this.type = 'svg';
-        this.refreshHover = createMethodNotSupport('refreshHover');
-        this.configLayer = createMethodNotSupport('configLayer');
-        this.storage = storage;
-        this._opts = opts = extend({}, opts);
-        this.root = root;
-        this._id = 'zr' + svgId++;
-        this._oldVNode = createSVGVNode(opts.width, opts.height);
-        if (root && !opts.ssr) {
-            var viewport = this._viewport = document.createElement('div');
-            viewport.style.cssText = 'position:relative;overflow:hidden';
-            var svgDom = this._svgDom = this._oldVNode.elm = createElement('svg');
-            updateAttrs(null, this._oldVNode);
-            viewport.appendChild(svgDom);
-            root.appendChild(viewport);
-        }
-        this.resize(opts.width, opts.height);
-    }
-    SVGPainter.prototype.getType = function () {
-        return this.type;
-    };
-    SVGPainter.prototype.getViewportRoot = function () {
-        return this._viewport;
-    };
-    SVGPainter.prototype.getViewportRootOffset = function () {
-        var viewportRoot = this.getViewportRoot();
-        if (viewportRoot) {
-            return {
-                offsetLeft: viewportRoot.offsetLeft || 0,
-                offsetTop: viewportRoot.offsetTop || 0
-            };
-        }
-    };
-    SVGPainter.prototype.getSvgDom = function () {
-        return this._svgDom;
-    };
-    SVGPainter.prototype.refresh = function () {
-        if (this.root) {
-            var vnode = this.renderToVNode({
-                willUpdate: true
-            });
-            vnode.attrs.style = 'position:absolute;left:0;top:0;user-select:none';
-            patch(this._oldVNode, vnode);
-            this._oldVNode = vnode;
-        }
-    };
-    SVGPainter.prototype.renderOneToVNode = function (el) {
-        return brush(el, createBrushScope(this._id));
-    };
-    SVGPainter.prototype.renderToVNode = function (opts) {
-        opts = opts || {};
-        var list = this.storage.getDisplayList(true);
-        var width = this._width;
-        var height = this._height;
-        var scope = createBrushScope(this._id);
-        scope.animation = opts.animation;
-        scope.willUpdate = opts.willUpdate;
-        scope.compress = opts.compress;
-        scope.emphasis = opts.emphasis;
-        var children = [];
-        var bgVNode = this._bgVNode = createBackgroundVNode(width, height, this._backgroundColor, scope);
-        bgVNode && children.push(bgVNode);
-        var mainVNode = !opts.compress
-            ? (this._mainVNode = createVNode('g', 'main', {}, [])) : null;
-        this._paintList(list, scope, mainVNode ? mainVNode.children : children);
-        mainVNode && children.push(mainVNode);
-        var defs = map(keys(scope.defs), function (id) { return scope.defs[id]; });
-        if (defs.length) {
-            children.push(createVNode('defs', 'defs', {}, defs));
-        }
-        if (opts.animation) {
-            var animationCssStr = getCssString(scope.cssNodes, scope.cssAnims, { newline: true });
-            if (animationCssStr) {
-                var styleNode = createVNode('style', 'stl', {}, [], animationCssStr);
-                children.push(styleNode);
-            }
-        }
-        return createSVGVNode(width, height, children, opts.useViewBox);
-    };
-    SVGPainter.prototype.renderToString = function (opts) {
-        opts = opts || {};
-        return vNodeToString(this.renderToVNode({
-            animation: retrieve2(opts.cssAnimation, true),
-            emphasis: retrieve2(opts.cssEmphasis, true),
-            willUpdate: false,
-            compress: true,
-            useViewBox: retrieve2(opts.useViewBox, true)
-        }), { newline: true });
-    };
-    SVGPainter.prototype.setBackgroundColor = function (backgroundColor) {
-        this._backgroundColor = backgroundColor;
-    };
-    SVGPainter.prototype.getSvgRoot = function () {
-        return this._mainVNode && this._mainVNode.elm;
-    };
-    SVGPainter.prototype._paintList = function (list, scope, out) {
-        var listLen = list.length;
-        var clipPathsGroupsStack = [];
-        var clipPathsGroupsStackDepth = 0;
-        var currentClipPathGroup;
-        var prevClipPaths;
-        var clipGroupNodeIdx = 0;
-        for (var i = 0; i < listLen; i++) {
-            var displayable = list[i];
-            if (!displayable.invisible) {
-                var clipPaths = displayable.__clipPaths;
-                var len = clipPaths && clipPaths.length || 0;
-                var prevLen = prevClipPaths && prevClipPaths.length || 0;
-                var lca = void 0;
-                for (lca = Math.max(len - 1, prevLen - 1); lca >= 0; lca--) {
-                    if (clipPaths && prevClipPaths
-                        && clipPaths[lca] === prevClipPaths[lca]) {
-                        break;
-                    }
-                }
-                for (var i_1 = prevLen - 1; i_1 > lca; i_1--) {
-                    clipPathsGroupsStackDepth--;
-                    currentClipPathGroup = clipPathsGroupsStack[clipPathsGroupsStackDepth - 1];
-                }
-                for (var i_2 = lca + 1; i_2 < len; i_2++) {
-                    var groupAttrs = {};
-                    setClipPath(clipPaths[i_2], groupAttrs, scope);
-                    var g = createVNode('g', 'clip-g-' + clipGroupNodeIdx++, groupAttrs, []);
-                    (currentClipPathGroup ? currentClipPathGroup.children : out).push(g);
-                    clipPathsGroupsStack[clipPathsGroupsStackDepth++] = g;
-                    currentClipPathGroup = g;
-                }
-                prevClipPaths = clipPaths;
-                var ret = brush(displayable, scope);
-                if (ret) {
-                    (currentClipPathGroup ? currentClipPathGroup.children : out).push(ret);
-                }
-            }
-        }
-    };
-    SVGPainter.prototype.resize = function (width, height) {
-        var opts = this._opts;
-        var root = this.root;
-        var viewport = this._viewport;
-        width != null && (opts.width = width);
-        height != null && (opts.height = height);
-        if (root && viewport) {
-            viewport.style.display = 'none';
-            width = getSize(root, 0, opts);
-            height = getSize(root, 1, opts);
-            viewport.style.display = '';
-        }
-        if (this._width !== width || this._height !== height) {
-            this._width = width;
-            this._height = height;
-            if (viewport) {
-                var viewportStyle = viewport.style;
-                viewportStyle.width = width + 'px';
-                viewportStyle.height = height + 'px';
-            }
-            if (!isPattern(this._backgroundColor)) {
-                var svgDom = this._svgDom;
-                if (svgDom) {
-                    svgDom.setAttribute('width', width);
-                    svgDom.setAttribute('height', height);
-                }
-                var bgEl = this._bgVNode && this._bgVNode.elm;
-                if (bgEl) {
-                    bgEl.setAttribute('width', width);
-                    bgEl.setAttribute('height', height);
-                }
-            }
-            else {
-                this.refresh();
-            }
-        }
-    };
-    SVGPainter.prototype.getWidth = function () {
-        return this._width;
-    };
-    SVGPainter.prototype.getHeight = function () {
-        return this._height;
-    };
-    SVGPainter.prototype.dispose = function () {
-        if (this.root) {
-            this.root.innerHTML = '';
-        }
-        this._svgDom =
-            this._viewport =
-                this.storage =
-                    this._oldVNode =
-                        this._bgVNode =
-                            this._mainVNode = null;
-    };
-    SVGPainter.prototype.clear = function () {
-        if (this._svgDom) {
-            this._svgDom.innerHTML = null;
-        }
-        this._oldVNode = null;
-    };
-    SVGPainter.prototype.toDataURL = function (base64) {
-        var str = this.renderToString();
-        var prefix = 'data:image/svg+xml;';
-        if (base64) {
-            str = encodeBase64(str);
-            return str && prefix + 'base64,' + str;
-        }
-        return prefix + 'charset=UTF-8,' + encodeURIComponent(str);
-    };
-    return SVGPainter;
-}());
-function createMethodNotSupport(method) {
-    return function () {
-        if (process.env.NODE_ENV !== 'production') {
-            logError('In SVG mode painter not support method "' + method + '"');
-        }
-    };
-}
-function createBackgroundVNode(width, height, backgroundColor, scope) {
-    var bgVNode;
-    if (backgroundColor && backgroundColor !== 'none') {
-        bgVNode = createVNode('rect', 'bg', {
-            width: width,
-            height: height,
-            x: '0',
-            y: '0'
-        });
-        if (isGradient(backgroundColor)) {
-            setGradient({ fill: backgroundColor }, bgVNode.attrs, 'fill', scope);
-        }
-        else if (isPattern(backgroundColor)) {
-            setPattern({
-                style: {
-                    fill: backgroundColor
-                },
-                dirty: noop,
-                getBoundingRect: function () { return ({ width: width, height: height }); }
-            }, bgVNode.attrs, 'fill', scope);
-        }
-        else {
-            var _a = normalizeColor(backgroundColor), color = _a.color, opacity = _a.opacity;
-            bgVNode.attrs.fill = color;
-            opacity < 1 && (bgVNode.attrs['fill-opacity'] = opacity);
-        }
-    }
-    return bgVNode;
-}
-var SVGPainter$1 = SVGPainter;
-
-export { SVGPainter$1 as default };

package/esm/node_modules/zrender/lib/svg/SVGPathRebuilder.js

@@ -1,106 +0,0 @@
-import { isAroundZero } from './helper.js';
-
-var mathSin = Math.sin;
-var mathCos = Math.cos;
-var PI = Math.PI;
-var PI2 = Math.PI * 2;
-var degree = 180 / PI;
-var SVGPathRebuilder = (function () {
-    function SVGPathRebuilder() {
-    }
-    SVGPathRebuilder.prototype.reset = function (precision) {
-        this._start = true;
-        this._d = [];
-        this._str = '';
-        this._p = Math.pow(10, precision || 4);
-    };
-    SVGPathRebuilder.prototype.moveTo = function (x, y) {
-        this._add('M', x, y);
-    };
-    SVGPathRebuilder.prototype.lineTo = function (x, y) {
-        this._add('L', x, y);
-    };
-    SVGPathRebuilder.prototype.bezierCurveTo = function (x, y, x2, y2, x3, y3) {
-        this._add('C', x, y, x2, y2, x3, y3);
-    };
-    SVGPathRebuilder.prototype.quadraticCurveTo = function (x, y, x2, y2) {
-        this._add('Q', x, y, x2, y2);
-    };
-    SVGPathRebuilder.prototype.arc = function (cx, cy, r, startAngle, endAngle, anticlockwise) {
-        this.ellipse(cx, cy, r, r, 0, startAngle, endAngle, anticlockwise);
-    };
-    SVGPathRebuilder.prototype.ellipse = function (cx, cy, rx, ry, psi, startAngle, endAngle, anticlockwise) {
-        var dTheta = endAngle - startAngle;
-        var clockwise = !anticlockwise;
-        var dThetaPositive = Math.abs(dTheta);
-        var isCircle = isAroundZero(dThetaPositive - PI2)
-            || (clockwise ? dTheta >= PI2 : -dTheta >= PI2);
-        var unifiedTheta = dTheta > 0 ? dTheta % PI2 : (dTheta % PI2 + PI2);
-        var large = false;
-        if (isCircle) {
-            large = true;
-        }
-        else if (isAroundZero(dThetaPositive)) {
-            large = false;
-        }
-        else {
-            large = (unifiedTheta >= PI) === !!clockwise;
-        }
-        var x0 = cx + rx * mathCos(startAngle);
-        var y0 = cy + ry * mathSin(startAngle);
-        if (this._start) {
-            this._add('M', x0, y0);
-        }
-        var xRot = Math.round(psi * degree);
-        if (isCircle) {
-            var p = 1 / this._p;
-            var dTheta_1 = (clockwise ? 1 : -1) * (PI2 - p);
-            this._add('A', rx, ry, xRot, 1, +clockwise, cx + rx * mathCos(startAngle + dTheta_1), cy + ry * mathSin(startAngle + dTheta_1));
-            if (p > 1e-2) {
-                this._add('A', rx, ry, xRot, 0, +clockwise, x0, y0);
-            }
-        }
-        else {
-            var x = cx + rx * mathCos(endAngle);
-            var y = cy + ry * mathSin(endAngle);
-            this._add('A', rx, ry, xRot, +large, +clockwise, x, y);
-        }
-    };
-    SVGPathRebuilder.prototype.rect = function (x, y, w, h) {
-        this._add('M', x, y);
-        this._add('l', w, 0);
-        this._add('l', 0, h);
-        this._add('l', -w, 0);
-        this._add('Z');
-    };
-    SVGPathRebuilder.prototype.closePath = function () {
-        if (this._d.length > 0) {
-            this._add('Z');
-        }
-    };
-    SVGPathRebuilder.prototype._add = function (cmd, a, b, c, d, e, f, g, h) {
-        var vals = [];
-        var p = this._p;
-        for (var i = 1; i < arguments.length; i++) {
-            var val = arguments[i];
-            if (isNaN(val)) {
-                this._invalid = true;
-                return;
-            }
-            vals.push(Math.round(val * p) / p);
-        }
-        this._d.push(cmd + vals.join(' '));
-        this._start = cmd === 'Z';
-    };
-    SVGPathRebuilder.prototype.generateStr = function () {
-        this._str = this._invalid ? '' : this._d.join('');
-        this._d = [];
-    };
-    SVGPathRebuilder.prototype.getStr = function () {
-        return this._str;
-    };
-    return SVGPathRebuilder;
-}());
-var SVGPathRebuilder$1 = SVGPathRebuilder;
-
-export { SVGPathRebuilder$1 as default };