office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/zrender/lib/tool/color.js

@@ -0,0 +1,432 @@
+import LRU from '../core/LRU.js';
+import { isString, isGradientObject, extend, map } from '../core/util.js';
+
+var kCSSColorTable = {
+    'transparent': [0, 0, 0, 0], 'aliceblue': [240, 248, 255, 1],
+    'antiquewhite': [250, 235, 215, 1], 'aqua': [0, 255, 255, 1],
+    'aquamarine': [127, 255, 212, 1], 'azure': [240, 255, 255, 1],
+    'beige': [245, 245, 220, 1], 'bisque': [255, 228, 196, 1],
+    'black': [0, 0, 0, 1], 'blanchedalmond': [255, 235, 205, 1],
+    'blue': [0, 0, 255, 1], 'blueviolet': [138, 43, 226, 1],
+    'brown': [165, 42, 42, 1], 'burlywood': [222, 184, 135, 1],
+    'cadetblue': [95, 158, 160, 1], 'chartreuse': [127, 255, 0, 1],
+    'chocolate': [210, 105, 30, 1], 'coral': [255, 127, 80, 1],
+    'cornflowerblue': [100, 149, 237, 1], 'cornsilk': [255, 248, 220, 1],
+    'crimson': [220, 20, 60, 1], 'cyan': [0, 255, 255, 1],
+    'darkblue': [0, 0, 139, 1], 'darkcyan': [0, 139, 139, 1],
+    'darkgoldenrod': [184, 134, 11, 1], 'darkgray': [169, 169, 169, 1],
+    'darkgreen': [0, 100, 0, 1], 'darkgrey': [169, 169, 169, 1],
+    'darkkhaki': [189, 183, 107, 1], 'darkmagenta': [139, 0, 139, 1],
+    'darkolivegreen': [85, 107, 47, 1], 'darkorange': [255, 140, 0, 1],
+    'darkorchid': [153, 50, 204, 1], 'darkred': [139, 0, 0, 1],
+    'darksalmon': [233, 150, 122, 1], 'darkseagreen': [143, 188, 143, 1],
+    'darkslateblue': [72, 61, 139, 1], 'darkslategray': [47, 79, 79, 1],
+    'darkslategrey': [47, 79, 79, 1], 'darkturquoise': [0, 206, 209, 1],
+    'darkviolet': [148, 0, 211, 1], 'deeppink': [255, 20, 147, 1],
+    'deepskyblue': [0, 191, 255, 1], 'dimgray': [105, 105, 105, 1],
+    'dimgrey': [105, 105, 105, 1], 'dodgerblue': [30, 144, 255, 1],
+    'firebrick': [178, 34, 34, 1], 'floralwhite': [255, 250, 240, 1],
+    'forestgreen': [34, 139, 34, 1], 'fuchsia': [255, 0, 255, 1],
+    'gainsboro': [220, 220, 220, 1], 'ghostwhite': [248, 248, 255, 1],
+    'gold': [255, 215, 0, 1], 'goldenrod': [218, 165, 32, 1],
+    'gray': [128, 128, 128, 1], 'green': [0, 128, 0, 1],
+    'greenyellow': [173, 255, 47, 1], 'grey': [128, 128, 128, 1],
+    'honeydew': [240, 255, 240, 1], 'hotpink': [255, 105, 180, 1],
+    'indianred': [205, 92, 92, 1], 'indigo': [75, 0, 130, 1],
+    'ivory': [255, 255, 240, 1], 'khaki': [240, 230, 140, 1],
+    'lavender': [230, 230, 250, 1], 'lavenderblush': [255, 240, 245, 1],
+    'lawngreen': [124, 252, 0, 1], 'lemonchiffon': [255, 250, 205, 1],
+    'lightblue': [173, 216, 230, 1], 'lightcoral': [240, 128, 128, 1],
+    'lightcyan': [224, 255, 255, 1], 'lightgoldenrodyellow': [250, 250, 210, 1],
+    'lightgray': [211, 211, 211, 1], 'lightgreen': [144, 238, 144, 1],
+    'lightgrey': [211, 211, 211, 1], 'lightpink': [255, 182, 193, 1],
+    'lightsalmon': [255, 160, 122, 1], 'lightseagreen': [32, 178, 170, 1],
+    'lightskyblue': [135, 206, 250, 1], 'lightslategray': [119, 136, 153, 1],
+    'lightslategrey': [119, 136, 153, 1], 'lightsteelblue': [176, 196, 222, 1],
+    'lightyellow': [255, 255, 224, 1], 'lime': [0, 255, 0, 1],
+    'limegreen': [50, 205, 50, 1], 'linen': [250, 240, 230, 1],
+    'magenta': [255, 0, 255, 1], 'maroon': [128, 0, 0, 1],
+    'mediumaquamarine': [102, 205, 170, 1], 'mediumblue': [0, 0, 205, 1],
+    'mediumorchid': [186, 85, 211, 1], 'mediumpurple': [147, 112, 219, 1],
+    'mediumseagreen': [60, 179, 113, 1], 'mediumslateblue': [123, 104, 238, 1],
+    'mediumspringgreen': [0, 250, 154, 1], 'mediumturquoise': [72, 209, 204, 1],
+    'mediumvioletred': [199, 21, 133, 1], 'midnightblue': [25, 25, 112, 1],
+    'mintcream': [245, 255, 250, 1], 'mistyrose': [255, 228, 225, 1],
+    'moccasin': [255, 228, 181, 1], 'navajowhite': [255, 222, 173, 1],
+    'navy': [0, 0, 128, 1], 'oldlace': [253, 245, 230, 1],
+    'olive': [128, 128, 0, 1], 'olivedrab': [107, 142, 35, 1],
+    'orange': [255, 165, 0, 1], 'orangered': [255, 69, 0, 1],
+    'orchid': [218, 112, 214, 1], 'palegoldenrod': [238, 232, 170, 1],
+    'palegreen': [152, 251, 152, 1], 'paleturquoise': [175, 238, 238, 1],
+    'palevioletred': [219, 112, 147, 1], 'papayawhip': [255, 239, 213, 1],
+    'peachpuff': [255, 218, 185, 1], 'peru': [205, 133, 63, 1],
+    'pink': [255, 192, 203, 1], 'plum': [221, 160, 221, 1],
+    'powderblue': [176, 224, 230, 1], 'purple': [128, 0, 128, 1],
+    'red': [255, 0, 0, 1], 'rosybrown': [188, 143, 143, 1],
+    'royalblue': [65, 105, 225, 1], 'saddlebrown': [139, 69, 19, 1],
+    'salmon': [250, 128, 114, 1], 'sandybrown': [244, 164, 96, 1],
+    'seagreen': [46, 139, 87, 1], 'seashell': [255, 245, 238, 1],
+    'sienna': [160, 82, 45, 1], 'silver': [192, 192, 192, 1],
+    'skyblue': [135, 206, 235, 1], 'slateblue': [106, 90, 205, 1],
+    'slategray': [112, 128, 144, 1], 'slategrey': [112, 128, 144, 1],
+    'snow': [255, 250, 250, 1], 'springgreen': [0, 255, 127, 1],
+    'steelblue': [70, 130, 180, 1], 'tan': [210, 180, 140, 1],
+    'teal': [0, 128, 128, 1], 'thistle': [216, 191, 216, 1],
+    'tomato': [255, 99, 71, 1], 'turquoise': [64, 224, 208, 1],
+    'violet': [238, 130, 238, 1], 'wheat': [245, 222, 179, 1],
+    'white': [255, 255, 255, 1], 'whitesmoke': [245, 245, 245, 1],
+    'yellow': [255, 255, 0, 1], 'yellowgreen': [154, 205, 50, 1]
+};
+function clampCssByte(i) {
+    i = Math.round(i);
+    return i < 0 ? 0 : i > 255 ? 255 : i;
+}
+function clampCssAngle(i) {
+    i = Math.round(i);
+    return i < 0 ? 0 : i > 360 ? 360 : i;
+}
+function clampCssFloat(f) {
+    return f < 0 ? 0 : f > 1 ? 1 : f;
+}
+function parseCssInt(val) {
+    var str = val;
+    if (str.length && str.charAt(str.length - 1) === '%') {
+        return clampCssByte(parseFloat(str) / 100 * 255);
+    }
+    return clampCssByte(parseInt(str, 10));
+}
+function parseCssFloat(val) {
+    var str = val;
+    if (str.length && str.charAt(str.length - 1) === '%') {
+        return clampCssFloat(parseFloat(str) / 100);
+    }
+    return clampCssFloat(parseFloat(str));
+}
+function cssHueToRgb(m1, m2, h) {
+    if (h < 0) {
+        h += 1;
+    }
+    else if (h > 1) {
+        h -= 1;
+    }
+    if (h * 6 < 1) {
+        return m1 + (m2 - m1) * h * 6;
+    }
+    if (h * 2 < 1) {
+        return m2;
+    }
+    if (h * 3 < 2) {
+        return m1 + (m2 - m1) * (2 / 3 - h) * 6;
+    }
+    return m1;
+}
+function lerpNumber(a, b, p) {
+    return a + (b - a) * p;
+}
+function setRgba(out, r, g, b, a) {
+    out[0] = r;
+    out[1] = g;
+    out[2] = b;
+    out[3] = a;
+    return out;
+}
+function copyRgba(out, a) {
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    out[3] = a[3];
+    return out;
+}
+var colorCache = new LRU(20);
+var lastRemovedArr = null;
+function putToCache(colorStr, rgbaArr) {
+    if (lastRemovedArr) {
+        copyRgba(lastRemovedArr, rgbaArr);
+    }
+    lastRemovedArr = colorCache.put(colorStr, lastRemovedArr || (rgbaArr.slice()));
+}
+function parse(colorStr, rgbaArr) {
+    if (!colorStr) {
+        return;
+    }
+    rgbaArr = rgbaArr || [];
+    var cached = colorCache.get(colorStr);
+    if (cached) {
+        return copyRgba(rgbaArr, cached);
+    }
+    colorStr = colorStr + '';
+    var str = colorStr.replace(/ /g, '').toLowerCase();
+    if (str in kCSSColorTable) {
+        copyRgba(rgbaArr, kCSSColorTable[str]);
+        putToCache(colorStr, rgbaArr);
+        return rgbaArr;
+    }
+    var strLen = str.length;
+    if (str.charAt(0) === '#') {
+        if (strLen === 4 || strLen === 5) {
+            var iv = parseInt(str.slice(1, 4), 16);
+            if (!(iv >= 0 && iv <= 0xfff)) {
+                setRgba(rgbaArr, 0, 0, 0, 1);
+                return;
+            }
+            setRgba(rgbaArr, ((iv & 0xf00) >> 4) | ((iv & 0xf00) >> 8), (iv & 0xf0) | ((iv & 0xf0) >> 4), (iv & 0xf) | ((iv & 0xf) << 4), strLen === 5 ? parseInt(str.slice(4), 16) / 0xf : 1);
+            putToCache(colorStr, rgbaArr);
+            return rgbaArr;
+        }
+        else if (strLen === 7 || strLen === 9) {
+            var iv = parseInt(str.slice(1, 7), 16);
+            if (!(iv >= 0 && iv <= 0xffffff)) {
+                setRgba(rgbaArr, 0, 0, 0, 1);
+                return;
+            }
+            setRgba(rgbaArr, (iv & 0xff0000) >> 16, (iv & 0xff00) >> 8, iv & 0xff, strLen === 9 ? parseInt(str.slice(7), 16) / 0xff : 1);
+            putToCache(colorStr, rgbaArr);
+            return rgbaArr;
+        }
+        return;
+    }
+    var op = str.indexOf('(');
+    var ep = str.indexOf(')');
+    if (op !== -1 && ep + 1 === strLen) {
+        var fname = str.substr(0, op);
+        var params = str.substr(op + 1, ep - (op + 1)).split(',');
+        var alpha = 1;
+        switch (fname) {
+            case 'rgba':
+                if (params.length !== 4) {
+                    return params.length === 3
+                        ? setRgba(rgbaArr, +params[0], +params[1], +params[2], 1)
+                        : setRgba(rgbaArr, 0, 0, 0, 1);
+                }
+                alpha = parseCssFloat(params.pop());
+            case 'rgb':
+                if (params.length >= 3) {
+                    setRgba(rgbaArr, parseCssInt(params[0]), parseCssInt(params[1]), parseCssInt(params[2]), params.length === 3 ? alpha : parseCssFloat(params[3]));
+                    putToCache(colorStr, rgbaArr);
+                    return rgbaArr;
+                }
+                else {
+                    setRgba(rgbaArr, 0, 0, 0, 1);
+                    return;
+                }
+            case 'hsla':
+                if (params.length !== 4) {
+                    setRgba(rgbaArr, 0, 0, 0, 1);
+                    return;
+                }
+                params[3] = parseCssFloat(params[3]);
+                hsla2rgba(params, rgbaArr);
+                putToCache(colorStr, rgbaArr);
+                return rgbaArr;
+            case 'hsl':
+                if (params.length !== 3) {
+                    setRgba(rgbaArr, 0, 0, 0, 1);
+                    return;
+                }
+                hsla2rgba(params, rgbaArr);
+                putToCache(colorStr, rgbaArr);
+                return rgbaArr;
+            default:
+                return;
+        }
+    }
+    setRgba(rgbaArr, 0, 0, 0, 1);
+    return;
+}
+function hsla2rgba(hsla, rgba) {
+    var h = (((parseFloat(hsla[0]) % 360) + 360) % 360) / 360;
+    var s = parseCssFloat(hsla[1]);
+    var l = parseCssFloat(hsla[2]);
+    var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
+    var m1 = l * 2 - m2;
+    rgba = rgba || [];
+    setRgba(rgba, clampCssByte(cssHueToRgb(m1, m2, h + 1 / 3) * 255), clampCssByte(cssHueToRgb(m1, m2, h) * 255), clampCssByte(cssHueToRgb(m1, m2, h - 1 / 3) * 255), 1);
+    if (hsla.length === 4) {
+        rgba[3] = hsla[3];
+    }
+    return rgba;
+}
+function rgba2hsla(rgba) {
+    if (!rgba) {
+        return;
+    }
+    var R = rgba[0] / 255;
+    var G = rgba[1] / 255;
+    var B = rgba[2] / 255;
+    var vMin = Math.min(R, G, B);
+    var vMax = Math.max(R, G, B);
+    var delta = vMax - vMin;
+    var L = (vMax + vMin) / 2;
+    var H;
+    var S;
+    if (delta === 0) {
+        H = 0;
+        S = 0;
+    }
+    else {
+        if (L < 0.5) {
+            S = delta / (vMax + vMin);
+        }
+        else {
+            S = delta / (2 - vMax - vMin);
+        }
+        var deltaR = (((vMax - R) / 6) + (delta / 2)) / delta;
+        var deltaG = (((vMax - G) / 6) + (delta / 2)) / delta;
+        var deltaB = (((vMax - B) / 6) + (delta / 2)) / delta;
+        if (R === vMax) {
+            H = deltaB - deltaG;
+        }
+        else if (G === vMax) {
+            H = (1 / 3) + deltaR - deltaB;
+        }
+        else if (B === vMax) {
+            H = (2 / 3) + deltaG - deltaR;
+        }
+        if (H < 0) {
+            H += 1;
+        }
+        if (H > 1) {
+            H -= 1;
+        }
+    }
+    var hsla = [H * 360, S, L];
+    if (rgba[3] != null) {
+        hsla.push(rgba[3]);
+    }
+    return hsla;
+}
+function lift(color, level) {
+    var colorArr = parse(color);
+    if (colorArr) {
+        for (var i = 0; i < 3; i++) {
+            if (level < 0) {
+                colorArr[i] = colorArr[i] * (1 - level) | 0;
+            }
+            else {
+                colorArr[i] = ((255 - colorArr[i]) * level + colorArr[i]) | 0;
+            }
+            if (colorArr[i] > 255) {
+                colorArr[i] = 255;
+            }
+            else if (colorArr[i] < 0) {
+                colorArr[i] = 0;
+            }
+        }
+        return stringify(colorArr, colorArr.length === 4 ? 'rgba' : 'rgb');
+    }
+}
+function toHex(color) {
+    var colorArr = parse(color);
+    if (colorArr) {
+        return ((1 << 24) + (colorArr[0] << 16) + (colorArr[1] << 8) + (+colorArr[2])).toString(16).slice(1);
+    }
+}
+function fastLerp(normalizedValue, colors, out) {
+    if (!(colors && colors.length)
+        || !(normalizedValue >= 0 && normalizedValue <= 1)) {
+        return;
+    }
+    out = out || [];
+    var value = normalizedValue * (colors.length - 1);
+    var leftIndex = Math.floor(value);
+    var rightIndex = Math.ceil(value);
+    var leftColor = colors[leftIndex];
+    var rightColor = colors[rightIndex];
+    var dv = value - leftIndex;
+    out[0] = clampCssByte(lerpNumber(leftColor[0], rightColor[0], dv));
+    out[1] = clampCssByte(lerpNumber(leftColor[1], rightColor[1], dv));
+    out[2] = clampCssByte(lerpNumber(leftColor[2], rightColor[2], dv));
+    out[3] = clampCssFloat(lerpNumber(leftColor[3], rightColor[3], dv));
+    return out;
+}
+var fastMapToColor = fastLerp;
+function lerp(normalizedValue, colors, fullOutput) {
+    if (!(colors && colors.length)
+        || !(normalizedValue >= 0 && normalizedValue <= 1)) {
+        return;
+    }
+    var value = normalizedValue * (colors.length - 1);
+    var leftIndex = Math.floor(value);
+    var rightIndex = Math.ceil(value);
+    var leftColor = parse(colors[leftIndex]);
+    var rightColor = parse(colors[rightIndex]);
+    var dv = value - leftIndex;
+    var color = stringify([
+        clampCssByte(lerpNumber(leftColor[0], rightColor[0], dv)),
+        clampCssByte(lerpNumber(leftColor[1], rightColor[1], dv)),
+        clampCssByte(lerpNumber(leftColor[2], rightColor[2], dv)),
+        clampCssFloat(lerpNumber(leftColor[3], rightColor[3], dv))
+    ], 'rgba');
+    return fullOutput
+        ? {
+            color: color,
+            leftIndex: leftIndex,
+            rightIndex: rightIndex,
+            value: value
+        }
+        : color;
+}
+var mapToColor = lerp;
+function modifyHSL(color, h, s, l) {
+    var colorArr = parse(color);
+    if (color) {
+        colorArr = rgba2hsla(colorArr);
+        h != null && (colorArr[0] = clampCssAngle(h));
+        s != null && (colorArr[1] = parseCssFloat(s));
+        l != null && (colorArr[2] = parseCssFloat(l));
+        return stringify(hsla2rgba(colorArr), 'rgba');
+    }
+}
+function modifyAlpha(color, alpha) {
+    var colorArr = parse(color);
+    if (colorArr && alpha != null) {
+        colorArr[3] = clampCssFloat(alpha);
+        return stringify(colorArr, 'rgba');
+    }
+}
+function stringify(arrColor, type) {
+    if (!arrColor || !arrColor.length) {
+        return;
+    }
+    var colorStr = arrColor[0] + ',' + arrColor[1] + ',' + arrColor[2];
+    if (type === 'rgba' || type === 'hsva' || type === 'hsla') {
+        colorStr += ',' + arrColor[3];
+    }
+    return type + '(' + colorStr + ')';
+}
+function lum(color, backgroundLum) {
+    var arr = parse(color);
+    return arr
+        ? (0.299 * arr[0] + 0.587 * arr[1] + 0.114 * arr[2]) * arr[3] / 255
+            + (1 - arr[3]) * backgroundLum
+        : 0;
+}
+function random() {
+    return stringify([
+        Math.round(Math.random() * 255),
+        Math.round(Math.random() * 255),
+        Math.round(Math.random() * 255)
+    ], 'rgb');
+}
+var liftedColorCache = new LRU(100);
+function liftColor(color) {
+    if (isString(color)) {
+        var liftedColor = liftedColorCache.get(color);
+        if (!liftedColor) {
+            liftedColor = lift(color, -0.1);
+            liftedColorCache.put(color, liftedColor);
+        }
+        return liftedColor;
+    }
+    else if (isGradientObject(color)) {
+        var ret = extend({}, color);
+        ret.colorStops = map(color.colorStops, function (stop) { return ({
+            offset: stop.offset,
+            color: lift(stop.color, -0.1)
+        }); });
+        return ret;
+    }
+    return color;
+}
+
+export { fastLerp, fastMapToColor, lerp, lift, liftColor, lum, mapToColor, modifyAlpha, modifyHSL, parse, random, stringify, toHex };

package/esm/node_modules/zrender/lib/tool/convertPath.js

@@ -0,0 +1,200 @@
+import { cubicSubdivide } from '../core/curve.js';
+import PathProxy from '../core/PathProxy.js';
+
+var CMD = PathProxy.CMD;
+function aroundEqual(a, b) {
+    return Math.abs(a - b) < 1e-5;
+}
+function pathToBezierCurves(path) {
+    var data = path.data;
+    var len = path.len();
+    var bezierArrayGroups = [];
+    var currentSubpath;
+    var xi = 0;
+    var yi = 0;
+    var x0 = 0;
+    var y0 = 0;
+    function createNewSubpath(x, y) {
+        if (currentSubpath && currentSubpath.length > 2) {
+            bezierArrayGroups.push(currentSubpath);
+        }
+        currentSubpath = [x, y];
+    }
+    function addLine(x0, y0, x1, y1) {
+        if (!(aroundEqual(x0, x1) && aroundEqual(y0, y1))) {
+            currentSubpath.push(x0, y0, x1, y1, x1, y1);
+        }
+    }
+    function addArc(startAngle, endAngle, cx, cy, rx, ry) {
+        var delta = Math.abs(endAngle - startAngle);
+        var len = Math.tan(delta / 4) * 4 / 3;
+        var dir = endAngle < startAngle ? -1 : 1;
+        var c1 = Math.cos(startAngle);
+        var s1 = Math.sin(startAngle);
+        var c2 = Math.cos(endAngle);
+        var s2 = Math.sin(endAngle);
+        var x1 = c1 * rx + cx;
+        var y1 = s1 * ry + cy;
+        var x4 = c2 * rx + cx;
+        var y4 = s2 * ry + cy;
+        var hx = rx * len * dir;
+        var hy = ry * len * dir;
+        currentSubpath.push(x1 - hx * s1, y1 + hy * c1, x4 + hx * s2, y4 - hy * c2, x4, y4);
+    }
+    var x1;
+    var y1;
+    var x2;
+    var y2;
+    for (var i = 0; i < len;) {
+        var cmd = data[i++];
+        var isFirst = i === 1;
+        if (isFirst) {
+            xi = data[i];
+            yi = data[i + 1];
+            x0 = xi;
+            y0 = yi;
+            if (cmd === CMD.L || cmd === CMD.C || cmd === CMD.Q) {
+                currentSubpath = [x0, y0];
+            }
+        }
+        switch (cmd) {
+            case CMD.M:
+                xi = x0 = data[i++];
+                yi = y0 = data[i++];
+                createNewSubpath(x0, y0);
+                break;
+            case CMD.L:
+                x1 = data[i++];
+                y1 = data[i++];
+                addLine(xi, yi, x1, y1);
+                xi = x1;
+                yi = y1;
+                break;
+            case CMD.C:
+                currentSubpath.push(data[i++], data[i++], data[i++], data[i++], xi = data[i++], yi = data[i++]);
+                break;
+            case CMD.Q:
+                x1 = data[i++];
+                y1 = data[i++];
+                x2 = data[i++];
+                y2 = data[i++];
+                currentSubpath.push(xi + 2 / 3 * (x1 - xi), yi + 2 / 3 * (y1 - yi), x2 + 2 / 3 * (x1 - x2), y2 + 2 / 3 * (y1 - y2), x2, y2);
+                xi = x2;
+                yi = y2;
+                break;
+            case CMD.A:
+                var cx = data[i++];
+                var cy = data[i++];
+                var rx = data[i++];
+                var ry = data[i++];
+                var startAngle = data[i++];
+                var endAngle = data[i++] + startAngle;
+                i += 1;
+                var anticlockwise = !data[i++];
+                x1 = Math.cos(startAngle) * rx + cx;
+                y1 = Math.sin(startAngle) * ry + cy;
+                if (isFirst) {
+                    x0 = x1;
+                    y0 = y1;
+                    createNewSubpath(x0, y0);
+                }
+                else {
+                    addLine(xi, yi, x1, y1);
+                }
+                xi = Math.cos(endAngle) * rx + cx;
+                yi = Math.sin(endAngle) * ry + cy;
+                var step = (anticlockwise ? -1 : 1) * Math.PI / 2;
+                for (var angle = startAngle; anticlockwise ? angle > endAngle : angle < endAngle; angle += step) {
+                    var nextAngle = anticlockwise ? Math.max(angle + step, endAngle)
+                        : Math.min(angle + step, endAngle);
+                    addArc(angle, nextAngle, cx, cy, rx, ry);
+                }
+                break;
+            case CMD.R:
+                x0 = xi = data[i++];
+                y0 = yi = data[i++];
+                x1 = x0 + data[i++];
+                y1 = y0 + data[i++];
+                createNewSubpath(x1, y0);
+                addLine(x1, y0, x1, y1);
+                addLine(x1, y1, x0, y1);
+                addLine(x0, y1, x0, y0);
+                addLine(x0, y0, x1, y0);
+                break;
+            case CMD.Z:
+                currentSubpath && addLine(xi, yi, x0, y0);
+                xi = x0;
+                yi = y0;
+                break;
+        }
+    }
+    if (currentSubpath && currentSubpath.length > 2) {
+        bezierArrayGroups.push(currentSubpath);
+    }
+    return bezierArrayGroups;
+}
+function adpativeBezier(x0, y0, x1, y1, x2, y2, x3, y3, out, scale) {
+    if (aroundEqual(x0, x1) && aroundEqual(y0, y1) && aroundEqual(x2, x3) && aroundEqual(y2, y3)) {
+        out.push(x3, y3);
+        return;
+    }
+    var PIXEL_DISTANCE = 2 / scale;
+    var PIXEL_DISTANCE_SQR = PIXEL_DISTANCE * PIXEL_DISTANCE;
+    var dx = x3 - x0;
+    var dy = y3 - y0;
+    var d = Math.sqrt(dx * dx + dy * dy);
+    dx /= d;
+    dy /= d;
+    var dx1 = x1 - x0;
+    var dy1 = y1 - y0;
+    var dx2 = x2 - x3;
+    var dy2 = y2 - y3;
+    var cp1LenSqr = dx1 * dx1 + dy1 * dy1;
+    var cp2LenSqr = dx2 * dx2 + dy2 * dy2;
+    if (cp1LenSqr < PIXEL_DISTANCE_SQR && cp2LenSqr < PIXEL_DISTANCE_SQR) {
+        out.push(x3, y3);
+        return;
+    }
+    var projLen1 = dx * dx1 + dy * dy1;
+    var projLen2 = -dx * dx2 - dy * dy2;
+    var d1Sqr = cp1LenSqr - projLen1 * projLen1;
+    var d2Sqr = cp2LenSqr - projLen2 * projLen2;
+    if (d1Sqr < PIXEL_DISTANCE_SQR && projLen1 >= 0
+        && d2Sqr < PIXEL_DISTANCE_SQR && projLen2 >= 0) {
+        out.push(x3, y3);
+        return;
+    }
+    var tmpSegX = [];
+    var tmpSegY = [];
+    cubicSubdivide(x0, x1, x2, x3, 0.5, tmpSegX);
+    cubicSubdivide(y0, y1, y2, y3, 0.5, tmpSegY);
+    adpativeBezier(tmpSegX[0], tmpSegY[0], tmpSegX[1], tmpSegY[1], tmpSegX[2], tmpSegY[2], tmpSegX[3], tmpSegY[3], out, scale);
+    adpativeBezier(tmpSegX[4], tmpSegY[4], tmpSegX[5], tmpSegY[5], tmpSegX[6], tmpSegY[6], tmpSegX[7], tmpSegY[7], out, scale);
+}
+function pathToPolygons(path, scale) {
+    var bezierArrayGroups = pathToBezierCurves(path);
+    var polygons = [];
+    scale = scale || 1;
+    for (var i = 0; i < bezierArrayGroups.length; i++) {
+        var beziers = bezierArrayGroups[i];
+        var polygon = [];
+        var x0 = beziers[0];
+        var y0 = beziers[1];
+        polygon.push(x0, y0);
+        for (var k = 2; k < beziers.length;) {
+            var x1 = beziers[k++];
+            var y1 = beziers[k++];
+            var x2 = beziers[k++];
+            var y2 = beziers[k++];
+            var x3 = beziers[k++];
+            var y3 = beziers[k++];
+            adpativeBezier(x0, y0, x1, y1, x2, y2, x3, y3, polygon, scale);
+            x0 = x3;
+            y0 = y3;
+        }
+        polygons.push(polygon);
+    }
+    return polygons;
+}
+
+export { pathToBezierCurves, pathToPolygons };