@fecp/mobile 1.0.78 → 1.1.0

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/tool/color.js

@@ -0,0 +1,501 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const LRU = require("../core/LRU.js");
+const util = require("../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.default(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 <= 4095)) {
+        setRgba(rgbaArr, 0, 0, 0, 1);
+        return;
+      }
+      setRgba(rgbaArr, (iv & 3840) >> 4 | (iv & 3840) >> 8, iv & 240 | (iv & 240) >> 4, iv & 15 | (iv & 15) << 4, strLen === 5 ? parseInt(str.slice(4), 16) / 15 : 1);
+      putToCache(colorStr, rgbaArr);
+      return rgbaArr;
+    } else if (strLen === 7 || strLen === 9) {
+      var iv = parseInt(str.slice(1, 7), 16);
+      if (!(iv >= 0 && iv <= 16777215)) {
+        setRgba(rgbaArr, 0, 0, 0, 1);
+        return;
+      }
+      setRgba(rgbaArr, (iv & 16711680) >> 16, (iv & 65280) >> 8, iv & 255, strLen === 9 ? parseInt(str.slice(7), 16) / 255 : 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,
+    leftIndex,
+    rightIndex,
+    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.default(100);
+function liftColor(color) {
+  if (util.isString(color)) {
+    var liftedColor = liftedColorCache.get(color);
+    if (!liftedColor) {
+      liftedColor = lift(color, -0.1);
+      liftedColorCache.put(color, liftedColor);
+    }
+    return liftedColor;
+  } else if (util.isGradientObject(color)) {
+    var ret = util.extend({}, color);
+    ret.colorStops = util.map(color.colorStops, function(stop) {
+      return {
+        offset: stop.offset,
+        color: lift(stop.color, -0.1)
+      };
+    });
+    return ret;
+  }
+  return color;
+}
+exports.fastLerp = fastLerp;
+exports.fastMapToColor = fastMapToColor;
+exports.lerp = lerp;
+exports.lift = lift;
+exports.liftColor = liftColor;
+exports.lum = lum;
+exports.mapToColor = mapToColor;
+exports.modifyAlpha = modifyAlpha;
+exports.modifyHSL = modifyHSL;
+exports.parse = parse;
+exports.random = random;
+exports.stringify = stringify;
+exports.toHex = toHex;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/tool/convertPath.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const curve = require("../core/curve.js");
+const PathProxy = require("../core/PathProxy.js");
+var CMD = PathProxy.default.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(x02, y02, x12, y12) {
+    if (!(aroundEqual(x02, x12) && aroundEqual(y02, y12))) {
+      currentSubpath.push(x02, y02, x12, y12, x12, y12);
+    }
+  }
+  function addArc(startAngle2, endAngle2, cx2, cy2, rx2, ry2) {
+    var delta = Math.abs(endAngle2 - startAngle2);
+    var len2 = Math.tan(delta / 4) * 4 / 3;
+    var dir = endAngle2 < startAngle2 ? -1 : 1;
+    var c1 = Math.cos(startAngle2);
+    var s1 = Math.sin(startAngle2);
+    var c2 = Math.cos(endAngle2);
+    var s2 = Math.sin(endAngle2);
+    var x12 = c1 * rx2 + cx2;
+    var y12 = s1 * ry2 + cy2;
+    var x4 = c2 * rx2 + cx2;
+    var y4 = s2 * ry2 + cy2;
+    var hx = rx2 * len2 * dir;
+    var hy = ry2 * len2 * dir;
+    currentSubpath.push(x12 - hx * s1, y12 + 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 = [];
+  curve.cubicSubdivide(x0, x1, x2, x3, 0.5, tmpSegX);
+  curve.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;
+}
+exports.pathToBezierCurves = pathToBezierCurves;
+exports.pathToPolygons = pathToPolygons;