office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/zrender/lib/canvas/graphic.js

@@ -0,0 +1,567 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Displayable = require('../graphic/Displayable.js');
+var PathProxy = require('../core/PathProxy.js');
+var image = require('../graphic/helper/image.js');
+var helper = require('./helper.js');
+var Path = require('../graphic/Path.js');
+var Image = require('../graphic/Image.js');
+var TSpan = require('../graphic/TSpan.js');
+var util = require('../core/util.js');
+var dashStyle = require('./dashStyle.js');
+var constants = require('../graphic/constants.js');
+var platform = require('../core/platform.js');
+
+var pathProxyForDraw = new PathProxy["default"](true);
+function styleHasStroke(style) {
+    var stroke = style.stroke;
+    return !(stroke == null || stroke === 'none' || !(style.lineWidth > 0));
+}
+function isValidStrokeFillStyle(strokeOrFill) {
+    return typeof strokeOrFill === 'string' && strokeOrFill !== 'none';
+}
+function styleHasFill(style) {
+    var fill = style.fill;
+    return fill != null && fill !== 'none';
+}
+function doFillPath(ctx, style) {
+    if (style.fillOpacity != null && style.fillOpacity !== 1) {
+        var originalGlobalAlpha = ctx.globalAlpha;
+        ctx.globalAlpha = style.fillOpacity * style.opacity;
+        ctx.fill();
+        ctx.globalAlpha = originalGlobalAlpha;
+    }
+    else {
+        ctx.fill();
+    }
+}
+function doStrokePath(ctx, style) {
+    if (style.strokeOpacity != null && style.strokeOpacity !== 1) {
+        var originalGlobalAlpha = ctx.globalAlpha;
+        ctx.globalAlpha = style.strokeOpacity * style.opacity;
+        ctx.stroke();
+        ctx.globalAlpha = originalGlobalAlpha;
+    }
+    else {
+        ctx.stroke();
+    }
+}
+function createCanvasPattern(ctx, pattern, el) {
+    var image$1 = image.createOrUpdateImage(pattern.image, pattern.__image, el);
+    if (image.isImageReady(image$1)) {
+        var canvasPattern = ctx.createPattern(image$1, pattern.repeat || 'repeat');
+        if (typeof DOMMatrix === 'function'
+            && canvasPattern
+            && canvasPattern.setTransform) {
+            var matrix = new DOMMatrix();
+            matrix.translateSelf((pattern.x || 0), (pattern.y || 0));
+            matrix.rotateSelf(0, 0, (pattern.rotation || 0) * util.RADIAN_TO_DEGREE);
+            matrix.scaleSelf((pattern.scaleX || 1), (pattern.scaleY || 1));
+            canvasPattern.setTransform(matrix);
+        }
+        return canvasPattern;
+    }
+}
+function brushPath(ctx, el, style, inBatch) {
+    var _a;
+    var hasStroke = styleHasStroke(style);
+    var hasFill = styleHasFill(style);
+    var strokePercent = style.strokePercent;
+    var strokePart = strokePercent < 1;
+    var firstDraw = !el.path;
+    if ((!el.silent || strokePart) && firstDraw) {
+        el.createPathProxy();
+    }
+    var path = el.path || pathProxyForDraw;
+    var dirtyFlag = el.__dirty;
+    if (!inBatch) {
+        var fill = style.fill;
+        var stroke = style.stroke;
+        var hasFillGradient = hasFill && !!fill.colorStops;
+        var hasStrokeGradient = hasStroke && !!stroke.colorStops;
+        var hasFillPattern = hasFill && !!fill.image;
+        var hasStrokePattern = hasStroke && !!stroke.image;
+        var fillGradient = void 0;
+        var strokeGradient = void 0;
+        var fillPattern = void 0;
+        var strokePattern = void 0;
+        var rect = void 0;
+        if (hasFillGradient || hasStrokeGradient) {
+            rect = el.getBoundingRect();
+        }
+        if (hasFillGradient) {
+            fillGradient = dirtyFlag
+                ? helper.getCanvasGradient(ctx, fill, rect)
+                : el.__canvasFillGradient;
+            el.__canvasFillGradient = fillGradient;
+        }
+        if (hasStrokeGradient) {
+            strokeGradient = dirtyFlag
+                ? helper.getCanvasGradient(ctx, stroke, rect)
+                : el.__canvasStrokeGradient;
+            el.__canvasStrokeGradient = strokeGradient;
+        }
+        if (hasFillPattern) {
+            fillPattern = (dirtyFlag || !el.__canvasFillPattern)
+                ? createCanvasPattern(ctx, fill, el)
+                : el.__canvasFillPattern;
+            el.__canvasFillPattern = fillPattern;
+        }
+        if (hasStrokePattern) {
+            strokePattern = (dirtyFlag || !el.__canvasStrokePattern)
+                ? createCanvasPattern(ctx, stroke, el)
+                : el.__canvasStrokePattern;
+            el.__canvasStrokePattern = fillPattern;
+        }
+        if (hasFillGradient) {
+            ctx.fillStyle = fillGradient;
+        }
+        else if (hasFillPattern) {
+            if (fillPattern) {
+                ctx.fillStyle = fillPattern;
+            }
+            else {
+                hasFill = false;
+            }
+        }
+        if (hasStrokeGradient) {
+            ctx.strokeStyle = strokeGradient;
+        }
+        else if (hasStrokePattern) {
+            if (strokePattern) {
+                ctx.strokeStyle = strokePattern;
+            }
+            else {
+                hasStroke = false;
+            }
+        }
+    }
+    var scale = el.getGlobalScale();
+    path.setScale(scale[0], scale[1], el.segmentIgnoreThreshold);
+    var lineDash;
+    var lineDashOffset;
+    if (ctx.setLineDash && style.lineDash) {
+        _a = dashStyle.getLineDash(el), lineDash = _a[0], lineDashOffset = _a[1];
+    }
+    var needsRebuild = true;
+    if (firstDraw || (dirtyFlag & constants.SHAPE_CHANGED_BIT)) {
+        path.setDPR(ctx.dpr);
+        if (strokePart) {
+            path.setContext(null);
+        }
+        else {
+            path.setContext(ctx);
+            needsRebuild = false;
+        }
+        path.reset();
+        el.buildPath(path, el.shape, inBatch);
+        path.toStatic();
+        el.pathUpdated();
+    }
+    if (needsRebuild) {
+        path.rebuildPath(ctx, strokePart ? strokePercent : 1);
+    }
+    if (lineDash) {
+        ctx.setLineDash(lineDash);
+        ctx.lineDashOffset = lineDashOffset;
+    }
+    if (!inBatch) {
+        if (style.strokeFirst) {
+            if (hasStroke) {
+                doStrokePath(ctx, style);
+            }
+            if (hasFill) {
+                doFillPath(ctx, style);
+            }
+        }
+        else {
+            if (hasFill) {
+                doFillPath(ctx, style);
+            }
+            if (hasStroke) {
+                doStrokePath(ctx, style);
+            }
+        }
+    }
+    if (lineDash) {
+        ctx.setLineDash([]);
+    }
+}
+function brushImage(ctx, el, style) {
+    var image$1 = el.__image = image.createOrUpdateImage(style.image, el.__image, el, el.onload);
+    if (!image$1 || !image.isImageReady(image$1)) {
+        return;
+    }
+    var x = style.x || 0;
+    var y = style.y || 0;
+    var width = el.getWidth();
+    var height = el.getHeight();
+    var aspect = image$1.width / image$1.height;
+    if (width == null && height != null) {
+        width = height * aspect;
+    }
+    else if (height == null && width != null) {
+        height = width / aspect;
+    }
+    else if (width == null && height == null) {
+        width = image$1.width;
+        height = image$1.height;
+    }
+    if (style.sWidth && style.sHeight) {
+        var sx = style.sx || 0;
+        var sy = style.sy || 0;
+        ctx.drawImage(image$1, sx, sy, style.sWidth, style.sHeight, x, y, width, height);
+    }
+    else if (style.sx && style.sy) {
+        var sx = style.sx;
+        var sy = style.sy;
+        var sWidth = width - sx;
+        var sHeight = height - sy;
+        ctx.drawImage(image$1, sx, sy, sWidth, sHeight, x, y, width, height);
+    }
+    else {
+        ctx.drawImage(image$1, x, y, width, height);
+    }
+}
+function brushText(ctx, el, style) {
+    var _a;
+    var text = style.text;
+    text != null && (text += '');
+    if (text) {
+        ctx.font = style.font || platform.DEFAULT_FONT;
+        ctx.textAlign = style.textAlign;
+        ctx.textBaseline = style.textBaseline;
+        var lineDash = void 0;
+        var lineDashOffset = void 0;
+        if (ctx.setLineDash && style.lineDash) {
+            _a = dashStyle.getLineDash(el), lineDash = _a[0], lineDashOffset = _a[1];
+        }
+        if (lineDash) {
+            ctx.setLineDash(lineDash);
+            ctx.lineDashOffset = lineDashOffset;
+        }
+        if (style.strokeFirst) {
+            if (styleHasStroke(style)) {
+                ctx.strokeText(text, style.x, style.y);
+            }
+            if (styleHasFill(style)) {
+                ctx.fillText(text, style.x, style.y);
+            }
+        }
+        else {
+            if (styleHasFill(style)) {
+                ctx.fillText(text, style.x, style.y);
+            }
+            if (styleHasStroke(style)) {
+                ctx.strokeText(text, style.x, style.y);
+            }
+        }
+        if (lineDash) {
+            ctx.setLineDash([]);
+        }
+    }
+}
+var SHADOW_NUMBER_PROPS = ['shadowBlur', 'shadowOffsetX', 'shadowOffsetY'];
+var STROKE_PROPS = [
+    ['lineCap', 'butt'], ['lineJoin', 'miter'], ['miterLimit', 10]
+];
+function bindCommonProps(ctx, style, prevStyle, forceSetAll, scope) {
+    var styleChanged = false;
+    if (!forceSetAll) {
+        prevStyle = prevStyle || {};
+        if (style === prevStyle) {
+            return false;
+        }
+    }
+    if (forceSetAll || style.opacity !== prevStyle.opacity) {
+        flushPathDrawn(ctx, scope);
+        styleChanged = true;
+        var opacity = Math.max(Math.min(style.opacity, 1), 0);
+        ctx.globalAlpha = isNaN(opacity) ? Displayable.DEFAULT_COMMON_STYLE.opacity : opacity;
+    }
+    if (forceSetAll || style.blend !== prevStyle.blend) {
+        if (!styleChanged) {
+            flushPathDrawn(ctx, scope);
+            styleChanged = true;
+        }
+        ctx.globalCompositeOperation = style.blend || Displayable.DEFAULT_COMMON_STYLE.blend;
+    }
+    for (var i = 0; i < SHADOW_NUMBER_PROPS.length; i++) {
+        var propName = SHADOW_NUMBER_PROPS[i];
+        if (forceSetAll || style[propName] !== prevStyle[propName]) {
+            if (!styleChanged) {
+                flushPathDrawn(ctx, scope);
+                styleChanged = true;
+            }
+            ctx[propName] = ctx.dpr * (style[propName] || 0);
+        }
+    }
+    if (forceSetAll || style.shadowColor !== prevStyle.shadowColor) {
+        if (!styleChanged) {
+            flushPathDrawn(ctx, scope);
+            styleChanged = true;
+        }
+        ctx.shadowColor = style.shadowColor || Displayable.DEFAULT_COMMON_STYLE.shadowColor;
+    }
+    return styleChanged;
+}
+function bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetAll, scope) {
+    var style = getStyle(el, scope.inHover);
+    var prevStyle = forceSetAll
+        ? null
+        : (prevEl && getStyle(prevEl, scope.inHover) || {});
+    if (style === prevStyle) {
+        return false;
+    }
+    var styleChanged = bindCommonProps(ctx, style, prevStyle, forceSetAll, scope);
+    if (forceSetAll || style.fill !== prevStyle.fill) {
+        if (!styleChanged) {
+            flushPathDrawn(ctx, scope);
+            styleChanged = true;
+        }
+        isValidStrokeFillStyle(style.fill) && (ctx.fillStyle = style.fill);
+    }
+    if (forceSetAll || style.stroke !== prevStyle.stroke) {
+        if (!styleChanged) {
+            flushPathDrawn(ctx, scope);
+            styleChanged = true;
+        }
+        isValidStrokeFillStyle(style.stroke) && (ctx.strokeStyle = style.stroke);
+    }
+    if (forceSetAll || style.opacity !== prevStyle.opacity) {
+        if (!styleChanged) {
+            flushPathDrawn(ctx, scope);
+            styleChanged = true;
+        }
+        ctx.globalAlpha = style.opacity == null ? 1 : style.opacity;
+    }
+    if (el.hasStroke()) {
+        var lineWidth = style.lineWidth;
+        var newLineWidth = lineWidth / ((style.strokeNoScale && el.getLineScale) ? el.getLineScale() : 1);
+        if (ctx.lineWidth !== newLineWidth) {
+            if (!styleChanged) {
+                flushPathDrawn(ctx, scope);
+                styleChanged = true;
+            }
+            ctx.lineWidth = newLineWidth;
+        }
+    }
+    for (var i = 0; i < STROKE_PROPS.length; i++) {
+        var prop = STROKE_PROPS[i];
+        var propName = prop[0];
+        if (forceSetAll || style[propName] !== prevStyle[propName]) {
+            if (!styleChanged) {
+                flushPathDrawn(ctx, scope);
+                styleChanged = true;
+            }
+            ctx[propName] = style[propName] || prop[1];
+        }
+    }
+    return styleChanged;
+}
+function bindImageStyle(ctx, el, prevEl, forceSetAll, scope) {
+    return bindCommonProps(ctx, getStyle(el, scope.inHover), prevEl && getStyle(prevEl, scope.inHover), forceSetAll, scope);
+}
+function setContextTransform(ctx, el) {
+    var m = el.transform;
+    var dpr = ctx.dpr || 1;
+    if (m) {
+        ctx.setTransform(dpr * m[0], dpr * m[1], dpr * m[2], dpr * m[3], dpr * m[4], dpr * m[5]);
+    }
+    else {
+        ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    }
+}
+function updateClipStatus(clipPaths, ctx, scope) {
+    var allClipped = false;
+    for (var i = 0; i < clipPaths.length; i++) {
+        var clipPath = clipPaths[i];
+        allClipped = allClipped || clipPath.isZeroArea();
+        setContextTransform(ctx, clipPath);
+        ctx.beginPath();
+        clipPath.buildPath(ctx, clipPath.shape);
+        ctx.clip();
+    }
+    scope.allClipped = allClipped;
+}
+function isTransformChanged(m0, m1) {
+    if (m0 && m1) {
+        return m0[0] !== m1[0]
+            || m0[1] !== m1[1]
+            || m0[2] !== m1[2]
+            || m0[3] !== m1[3]
+            || m0[4] !== m1[4]
+            || m0[5] !== m1[5];
+    }
+    else if (!m0 && !m1) {
+        return false;
+    }
+    return true;
+}
+var DRAW_TYPE_PATH = 1;
+var DRAW_TYPE_IMAGE = 2;
+var DRAW_TYPE_TEXT = 3;
+var DRAW_TYPE_INCREMENTAL = 4;
+function canPathBatch(style) {
+    var hasFill = styleHasFill(style);
+    var hasStroke = styleHasStroke(style);
+    return !(style.lineDash
+        || !(+hasFill ^ +hasStroke)
+        || (hasFill && typeof style.fill !== 'string')
+        || (hasStroke && typeof style.stroke !== 'string')
+        || style.strokePercent < 1
+        || style.strokeOpacity < 1
+        || style.fillOpacity < 1);
+}
+function flushPathDrawn(ctx, scope) {
+    scope.batchFill && ctx.fill();
+    scope.batchStroke && ctx.stroke();
+    scope.batchFill = '';
+    scope.batchStroke = '';
+}
+function getStyle(el, inHover) {
+    return inHover ? (el.__hoverStyle || el.style) : el.style;
+}
+function brushSingle(ctx, el) {
+    brush(ctx, el, { inHover: false, viewWidth: 0, viewHeight: 0 }, true);
+}
+function brush(ctx, el, scope, isLast) {
+    var m = el.transform;
+    if (!el.shouldBePainted(scope.viewWidth, scope.viewHeight, false, false)) {
+        el.__dirty &= ~constants.REDRAW_BIT;
+        el.__isRendered = false;
+        return;
+    }
+    var clipPaths = el.__clipPaths;
+    var prevElClipPaths = scope.prevElClipPaths;
+    var forceSetTransform = false;
+    var forceSetStyle = false;
+    if (!prevElClipPaths || helper.isClipPathChanged(clipPaths, prevElClipPaths)) {
+        if (prevElClipPaths && prevElClipPaths.length) {
+            flushPathDrawn(ctx, scope);
+            ctx.restore();
+            forceSetStyle = forceSetTransform = true;
+            scope.prevElClipPaths = null;
+            scope.allClipped = false;
+            scope.prevEl = null;
+        }
+        if (clipPaths && clipPaths.length) {
+            flushPathDrawn(ctx, scope);
+            ctx.save();
+            updateClipStatus(clipPaths, ctx, scope);
+            forceSetTransform = true;
+        }
+        scope.prevElClipPaths = clipPaths;
+    }
+    if (scope.allClipped) {
+        el.__isRendered = false;
+        return;
+    }
+    el.beforeBrush && el.beforeBrush();
+    el.innerBeforeBrush();
+    var prevEl = scope.prevEl;
+    if (!prevEl) {
+        forceSetStyle = forceSetTransform = true;
+    }
+    var canBatchPath = el instanceof Path["default"]
+        && el.autoBatch
+        && canPathBatch(el.style);
+    if (forceSetTransform || isTransformChanged(m, prevEl.transform)) {
+        flushPathDrawn(ctx, scope);
+        setContextTransform(ctx, el);
+    }
+    else if (!canBatchPath) {
+        flushPathDrawn(ctx, scope);
+    }
+    var style = getStyle(el, scope.inHover);
+    if (el instanceof Path["default"]) {
+        if (scope.lastDrawType !== DRAW_TYPE_PATH) {
+            forceSetStyle = true;
+            scope.lastDrawType = DRAW_TYPE_PATH;
+        }
+        bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetStyle, scope);
+        if (!canBatchPath || (!scope.batchFill && !scope.batchStroke)) {
+            ctx.beginPath();
+        }
+        brushPath(ctx, el, style, canBatchPath);
+        if (canBatchPath) {
+            scope.batchFill = style.fill || '';
+            scope.batchStroke = style.stroke || '';
+        }
+    }
+    else {
+        if (el instanceof TSpan["default"]) {
+            if (scope.lastDrawType !== DRAW_TYPE_TEXT) {
+                forceSetStyle = true;
+                scope.lastDrawType = DRAW_TYPE_TEXT;
+            }
+            bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetStyle, scope);
+            brushText(ctx, el, style);
+        }
+        else if (el instanceof Image["default"]) {
+            if (scope.lastDrawType !== DRAW_TYPE_IMAGE) {
+                forceSetStyle = true;
+                scope.lastDrawType = DRAW_TYPE_IMAGE;
+            }
+            bindImageStyle(ctx, el, prevEl, forceSetStyle, scope);
+            brushImage(ctx, el, style);
+        }
+        else if (el.getTemporalDisplayables) {
+            if (scope.lastDrawType !== DRAW_TYPE_INCREMENTAL) {
+                forceSetStyle = true;
+                scope.lastDrawType = DRAW_TYPE_INCREMENTAL;
+            }
+            brushIncremental(ctx, el, scope);
+        }
+    }
+    if (canBatchPath && isLast) {
+        flushPathDrawn(ctx, scope);
+    }
+    el.innerAfterBrush();
+    el.afterBrush && el.afterBrush();
+    scope.prevEl = el;
+    el.__dirty = 0;
+    el.__isRendered = true;
+}
+function brushIncremental(ctx, el, scope) {
+    var displayables = el.getDisplayables();
+    var temporalDisplayables = el.getTemporalDisplayables();
+    ctx.save();
+    var innerScope = {
+        prevElClipPaths: null,
+        prevEl: null,
+        allClipped: false,
+        viewWidth: scope.viewWidth,
+        viewHeight: scope.viewHeight,
+        inHover: scope.inHover
+    };
+    var i;
+    var len;
+    for (i = el.getCursor(), len = displayables.length; i < len; i++) {
+        var displayable = displayables[i];
+        displayable.beforeBrush && displayable.beforeBrush();
+        displayable.innerBeforeBrush();
+        brush(ctx, displayable, innerScope, i === len - 1);
+        displayable.innerAfterBrush();
+        displayable.afterBrush && displayable.afterBrush();
+        innerScope.prevEl = displayable;
+    }
+    for (var i_1 = 0, len_1 = temporalDisplayables.length; i_1 < len_1; i_1++) {
+        var displayable = temporalDisplayables[i_1];
+        displayable.beforeBrush && displayable.beforeBrush();
+        displayable.innerBeforeBrush();
+        brush(ctx, displayable, innerScope, i_1 === len_1 - 1);
+        displayable.innerAfterBrush();
+        displayable.afterBrush && displayable.afterBrush();
+        innerScope.prevEl = displayable;
+    }
+    el.clearTemporalDisplayables();
+    el.notClear = true;
+    ctx.restore();
+}
+
+exports.brush = brush;
+exports.brushSingle = brushSingle;
+exports.createCanvasPattern = createCanvasPattern;

package/lib/node_modules/zrender/lib/canvas/helper.js

@@ -0,0 +1,89 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function isSafeNum(num) {
+    return isFinite(num);
+}
+function createLinearGradient(ctx, obj, rect) {
+    var x = obj.x == null ? 0 : obj.x;
+    var x2 = obj.x2 == null ? 1 : obj.x2;
+    var y = obj.y == null ? 0 : obj.y;
+    var y2 = obj.y2 == null ? 0 : obj.y2;
+    if (!obj.global) {
+        x = x * rect.width + rect.x;
+        x2 = x2 * rect.width + rect.x;
+        y = y * rect.height + rect.y;
+        y2 = y2 * rect.height + rect.y;
+    }
+    x = isSafeNum(x) ? x : 0;
+    x2 = isSafeNum(x2) ? x2 : 1;
+    y = isSafeNum(y) ? y : 0;
+    y2 = isSafeNum(y2) ? y2 : 0;
+    var canvasGradient = ctx.createLinearGradient(x, y, x2, y2);
+    return canvasGradient;
+}
+function createRadialGradient(ctx, obj, rect) {
+    var width = rect.width;
+    var height = rect.height;
+    var min = Math.min(width, height);
+    var x = obj.x == null ? 0.5 : obj.x;
+    var y = obj.y == null ? 0.5 : obj.y;
+    var r = obj.r == null ? 0.5 : obj.r;
+    if (!obj.global) {
+        x = x * width + rect.x;
+        y = y * height + rect.y;
+        r = r * min;
+    }
+    x = isSafeNum(x) ? x : 0.5;
+    y = isSafeNum(y) ? y : 0.5;
+    r = r >= 0 && isSafeNum(r) ? r : 0.5;
+    var canvasGradient = ctx.createRadialGradient(x, y, 0, x, y, r);
+    return canvasGradient;
+}
+function getCanvasGradient(ctx, obj, rect) {
+    var canvasGradient = obj.type === 'radial'
+        ? createRadialGradient(ctx, obj, rect)
+        : createLinearGradient(ctx, obj, rect);
+    var colorStops = obj.colorStops;
+    for (var i = 0; i < colorStops.length; i++) {
+        canvasGradient.addColorStop(colorStops[i].offset, colorStops[i].color);
+    }
+    return canvasGradient;
+}
+function isClipPathChanged(clipPaths, prevClipPaths) {
+    if (clipPaths === prevClipPaths || (!clipPaths && !prevClipPaths)) {
+        return false;
+    }
+    if (!clipPaths || !prevClipPaths || (clipPaths.length !== prevClipPaths.length)) {
+        return true;
+    }
+    for (var i = 0; i < clipPaths.length; i++) {
+        if (clipPaths[i] !== prevClipPaths[i]) {
+            return true;
+        }
+    }
+    return false;
+}
+function parseInt10(val) {
+    return parseInt(val, 10);
+}
+function getSize(root, whIdx, opts) {
+    var wh = ['width', 'height'][whIdx];
+    var cwh = ['clientWidth', 'clientHeight'][whIdx];
+    var plt = ['paddingLeft', 'paddingTop'][whIdx];
+    var prb = ['paddingRight', 'paddingBottom'][whIdx];
+    if (opts[wh] != null && opts[wh] !== 'auto') {
+        return parseFloat(opts[wh]);
+    }
+    var stl = document.defaultView.getComputedStyle(root);
+    return ((root[cwh] || parseInt10(stl[wh]) || parseInt10(root.style[wh]))
+        - (parseInt10(stl[plt]) || 0)
+        - (parseInt10(stl[prb]) || 0)) | 0;
+}
+
+exports.createLinearGradient = createLinearGradient;
+exports.createRadialGradient = createRadialGradient;
+exports.getCanvasGradient = getCanvasGradient;
+exports.getSize = getSize;
+exports.isClipPathChanged = isClipPathChanged;

package/lib/node_modules/zrender/lib/config.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var env = require('./core/env.js');
+
+var dpr = 1;
+if (env["default"].hasGlobalWindow) {
+    dpr = Math.max(window.devicePixelRatio
+        || (window.screen && window.screen.deviceXDPI / window.screen.logicalXDPI)
+        || 1, 1);
+}
+var devicePixelRatio = dpr;
+var DARK_MODE_THRESHOLD = 0.4;
+var DARK_LABEL_COLOR = '#333';
+var LIGHT_LABEL_COLOR = '#ccc';
+var LIGHTER_LABEL_COLOR = '#eee';
+
+exports.DARK_LABEL_COLOR = DARK_LABEL_COLOR;
+exports.DARK_MODE_THRESHOLD = DARK_MODE_THRESHOLD;
+exports.LIGHTER_LABEL_COLOR = LIGHTER_LABEL_COLOR;
+exports.LIGHT_LABEL_COLOR = LIGHT_LABEL_COLOR;
+exports.devicePixelRatio = devicePixelRatio;