@utrecht/web-component-library-stencil 1.0.0-alpha.24 → 1.0.0-alpha.240

package/dist/collection/node_modules/svgo/plugins/convertPathData.js

@@ -0,0 +1,1023 @@
+'use strict';
+
+const { collectStylesheet, computeStyle } = require('../lib/style.js');
+const { pathElems } = require('./_collections.js');
+const { path2js, js2path } = require('./_path.js');
+const { applyTransforms } = require('./_applyTransforms.js');
+const { cleanupOutData } = require('../lib/svgo/tools');
+
+exports.name = 'convertPathData';
+exports.type = 'visitor';
+exports.active = true;
+exports.description =
+  'optimizes path data: writes in shorter form, applies transformations';
+
+exports.params = {
+  applyTransforms: true,
+  applyTransformsStroked: true,
+  makeArcs: {
+    threshold: 2.5, // coefficient of rounding error
+    tolerance: 0.5, // percentage of radius
+  },
+  straightCurves: true,
+  lineShorthands: true,
+  curveSmoothShorthands: true,
+  floatPrecision: 3,
+  transformPrecision: 5,
+  removeUseless: true,
+  collapseRepeated: true,
+  utilizeAbsolute: true,
+  leadingZero: true,
+  negativeExtraSpace: true,
+  noSpaceAfterFlags: false, // a20 60 45 0 1 30 20 → a20 60 45 0130 20
+  forceAbsolutePath: false,
+};
+
+let roundData;
+let precision;
+let error;
+let arcThreshold;
+let arcTolerance;
+
+/**
+ * Convert absolute Path to relative,
+ * collapse repeated instructions,
+ * detect and convert Lineto shorthands,
+ * remove useless instructions like "l0,0",
+ * trim useless delimiters and leading zeros,
+ * decrease accuracy of floating-point numbers.
+ *
+ * @see https://www.w3.org/TR/SVG11/paths.html#PathData
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = (root, params) => {
+  const stylesheet = collectStylesheet(root);
+  return {
+    element: {
+      enter: (node) => {
+        if (pathElems.includes(node.name) && node.attributes.d != null) {
+          const computedStyle = computeStyle(stylesheet, node);
+          precision = params.floatPrecision;
+          error =
+            precision !== false
+              ? +Math.pow(0.1, precision).toFixed(precision)
+              : 1e-2;
+          roundData = precision > 0 && precision < 20 ? strongRound : round;
+          if (params.makeArcs) {
+            arcThreshold = params.makeArcs.threshold;
+            arcTolerance = params.makeArcs.tolerance;
+          }
+          const hasMarkerMid = computedStyle['marker-mid'] != null;
+
+          const maybeHasStroke =
+            computedStyle.stroke &&
+            (computedStyle.stroke.type === 'dynamic' ||
+              computedStyle.stroke.value !== 'none');
+          const maybeHasLinecap =
+            computedStyle['stroke-linecap'] &&
+            (computedStyle['stroke-linecap'].type === 'dynamic' ||
+              computedStyle['stroke-linecap'].value !== 'butt');
+          const maybeHasStrokeAndLinecap = maybeHasStroke && maybeHasLinecap;
+
+          var data = path2js(node);
+
+          // TODO: get rid of functions returns
+          if (data.length) {
+            if (params.applyTransforms) {
+              applyTransforms(node, data, params);
+            }
+
+            convertToRelative(data);
+
+            data = filters(data, params, {
+              maybeHasStrokeAndLinecap,
+              hasMarkerMid,
+            });
+
+            if (params.utilizeAbsolute) {
+              data = convertToMixed(data, params);
+            }
+
+            js2path(node, data, params);
+          }
+        }
+      },
+    },
+  };
+};
+
+/**
+ * Convert absolute path data coordinates to relative.
+ *
+ * @param {Array} path input path data
+ * @param {Object} params plugin params
+ * @return {Array} output path data
+ */
+const convertToRelative = (pathData) => {
+  let start = [0, 0];
+  let cursor = [0, 0];
+  let prevCoords = [0, 0];
+
+  for (let i = 0; i < pathData.length; i += 1) {
+    const pathItem = pathData[i];
+    let { command, args } = pathItem;
+
+    // moveto (x y)
+    if (command === 'm') {
+      // update start and cursor
+      cursor[0] += args[0];
+      cursor[1] += args[1];
+      start[0] = cursor[0];
+      start[1] = cursor[1];
+    }
+    if (command === 'M') {
+      // M → m
+      // skip first moveto
+      if (i !== 0) {
+        command = 'm';
+      }
+      args[0] -= cursor[0];
+      args[1] -= cursor[1];
+      // update start and cursor
+      cursor[0] += args[0];
+      cursor[1] += args[1];
+      start[0] = cursor[0];
+      start[1] = cursor[1];
+    }
+
+    // lineto (x y)
+    if (command === 'l') {
+      cursor[0] += args[0];
+      cursor[1] += args[1];
+    }
+    if (command === 'L') {
+      // L → l
+      command = 'l';
+      args[0] -= cursor[0];
+      args[1] -= cursor[1];
+      cursor[0] += args[0];
+      cursor[1] += args[1];
+    }
+
+    // horizontal lineto (x)
+    if (command === 'h') {
+      cursor[0] += args[0];
+    }
+    if (command === 'H') {
+      // H → h
+      command = 'h';
+      args[0] -= cursor[0];
+      cursor[0] += args[0];
+    }
+
+    // vertical lineto (y)
+    if (command === 'v') {
+      cursor[1] += args[0];
+    }
+    if (command === 'V') {
+      // V → v
+      command = 'v';
+      args[0] -= cursor[1];
+      cursor[1] += args[0];
+    }
+
+    // curveto (x1 y1 x2 y2 x y)
+    if (command === 'c') {
+      cursor[0] += args[4];
+      cursor[1] += args[5];
+    }
+    if (command === 'C') {
+      // C → c
+      command = 'c';
+      args[0] -= cursor[0];
+      args[1] -= cursor[1];
+      args[2] -= cursor[0];
+      args[3] -= cursor[1];
+      args[4] -= cursor[0];
+      args[5] -= cursor[1];
+      cursor[0] += args[4];
+      cursor[1] += args[5];
+    }
+
+    // smooth curveto (x2 y2 x y)
+    if (command === 's') {
+      cursor[0] += args[2];
+      cursor[1] += args[3];
+    }
+    if (command === 'S') {
+      // S → s
+      command = 's';
+      args[0] -= cursor[0];
+      args[1] -= cursor[1];
+      args[2] -= cursor[0];
+      args[3] -= cursor[1];
+      cursor[0] += args[2];
+      cursor[1] += args[3];
+    }
+
+    // quadratic Bézier curveto (x1 y1 x y)
+    if (command === 'q') {
+      cursor[0] += args[2];
+      cursor[1] += args[3];
+    }
+    if (command === 'Q') {
+      // Q → q
+      command = 'q';
+      args[0] -= cursor[0];
+      args[1] -= cursor[1];
+      args[2] -= cursor[0];
+      args[3] -= cursor[1];
+      cursor[0] += args[2];
+      cursor[1] += args[3];
+    }
+
+    // smooth quadratic Bézier curveto (x y)
+    if (command === 't') {
+      cursor[0] += args[0];
+      cursor[1] += args[1];
+    }
+    if (command === 'T') {
+      // T → t
+      command = 't';
+      args[0] -= cursor[0];
+      args[1] -= cursor[1];
+      cursor[0] += args[0];
+      cursor[1] += args[1];
+    }
+
+    // elliptical arc (rx ry x-axis-rotation large-arc-flag sweep-flag x y)
+    if (command === 'a') {
+      cursor[0] += args[5];
+      cursor[1] += args[6];
+    }
+    if (command === 'A') {
+      // A → a
+      command = 'a';
+      args[5] -= cursor[0];
+      args[6] -= cursor[1];
+      cursor[0] += args[5];
+      cursor[1] += args[6];
+    }
+
+    // closepath
+    if (command === 'Z' || command === 'z') {
+      // reset cursor
+      cursor[0] = start[0];
+      cursor[1] = start[1];
+    }
+
+    pathItem.command = command;
+    pathItem.args = args;
+    // store absolute coordinates for later use
+    // base should preserve reference from other element
+    pathItem.base = prevCoords;
+    pathItem.coords = [cursor[0], cursor[1]];
+    prevCoords = pathItem.coords;
+  }
+
+  return pathData;
+};
+
+/**
+ * Main filters loop.
+ *
+ * @param {Array} path input path data
+ * @param {Object} params plugin params
+ * @return {Array} output path data
+ */
+function filters(path, params, { maybeHasStrokeAndLinecap, hasMarkerMid }) {
+  var stringify = data2Path.bind(null, params),
+    relSubpoint = [0, 0],
+    pathBase = [0, 0],
+    prev = {};
+
+  path = path.filter(function (item, index, path) {
+    let command = item.command;
+    let data = item.args;
+    let next = path[index + 1];
+
+    if (command !== 'Z' && command !== 'z') {
+      var sdata = data,
+        circle;
+
+      if (command === 's') {
+        sdata = [0, 0].concat(data);
+
+        if (command === 'c' || command === 's') {
+          var pdata = prev.args,
+            n = pdata.length;
+
+          // (-x, -y) of the prev tangent point relative to the current point
+          sdata[0] = pdata[n - 2] - pdata[n - 4];
+          sdata[1] = pdata[n - 1] - pdata[n - 3];
+        }
+      }
+
+      // convert curves to arcs if possible
+      if (
+        params.makeArcs &&
+        (command == 'c' || command == 's') &&
+        isConvex(sdata) &&
+        (circle = findCircle(sdata))
+      ) {
+        var r = roundData([circle.radius])[0],
+          angle = findArcAngle(sdata, circle),
+          sweep = sdata[5] * sdata[0] - sdata[4] * sdata[1] > 0 ? 1 : 0,
+          arc = {
+            command: 'a',
+            args: [r, r, 0, 0, sweep, sdata[4], sdata[5]],
+            coords: item.coords.slice(),
+            base: item.base,
+          },
+          output = [arc],
+          // relative coordinates to adjust the found circle
+          relCenter = [
+            circle.center[0] - sdata[4],
+            circle.center[1] - sdata[5],
+          ],
+          relCircle = { center: relCenter, radius: circle.radius },
+          arcCurves = [item],
+          hasPrev = 0,
+          suffix = '',
+          nextLonghand;
+
+        if (
+          (prev.command == 'c' &&
+            isConvex(prev.args) &&
+            isArcPrev(prev.args, circle)) ||
+          (prev.command == 'a' && prev.sdata && isArcPrev(prev.sdata, circle))
+        ) {
+          arcCurves.unshift(prev);
+          arc.base = prev.base;
+          arc.args[5] = arc.coords[0] - arc.base[0];
+          arc.args[6] = arc.coords[1] - arc.base[1];
+          var prevData = prev.command == 'a' ? prev.sdata : prev.args;
+          var prevAngle = findArcAngle(prevData, {
+            center: [
+              prevData[4] + circle.center[0],
+              prevData[5] + circle.center[1],
+            ],
+            radius: circle.radius,
+          });
+          angle += prevAngle;
+          if (angle > Math.PI) arc.args[3] = 1;
+          hasPrev = 1;
+        }
+
+        // check if next curves are fitting the arc
+        for (
+          var j = index;
+          (next = path[++j]) && ~'cs'.indexOf(next.command);
+
+        ) {
+          var nextData = next.args;
+          if (next.command == 's') {
+            nextLonghand = makeLonghand(
+              { command: 's', args: next.args.slice() },
+              path[j - 1].args
+            );
+            nextData = nextLonghand.args;
+            nextLonghand.args = nextData.slice(0, 2);
+            suffix = stringify([nextLonghand]);
+          }
+          if (isConvex(nextData) && isArc(nextData, relCircle)) {
+            angle += findArcAngle(nextData, relCircle);
+            if (angle - 2 * Math.PI > 1e-3) break; // more than 360°
+            if (angle > Math.PI) arc.args[3] = 1;
+            arcCurves.push(next);
+            if (2 * Math.PI - angle > 1e-3) {
+              // less than 360°
+              arc.coords = next.coords;
+              arc.args[5] = arc.coords[0] - arc.base[0];
+              arc.args[6] = arc.coords[1] - arc.base[1];
+            } else {
+              // full circle, make a half-circle arc and add a second one
+              arc.args[5] = 2 * (relCircle.center[0] - nextData[4]);
+              arc.args[6] = 2 * (relCircle.center[1] - nextData[5]);
+              arc.coords = [
+                arc.base[0] + arc.args[5],
+                arc.base[1] + arc.args[6],
+              ];
+              arc = {
+                command: 'a',
+                args: [
+                  r,
+                  r,
+                  0,
+                  0,
+                  sweep,
+                  next.coords[0] - arc.coords[0],
+                  next.coords[1] - arc.coords[1],
+                ],
+                coords: next.coords,
+                base: arc.coords,
+              };
+              output.push(arc);
+              j++;
+              break;
+            }
+            relCenter[0] -= nextData[4];
+            relCenter[1] -= nextData[5];
+          } else break;
+        }
+
+        if ((stringify(output) + suffix).length < stringify(arcCurves).length) {
+          if (path[j] && path[j].command == 's') {
+            makeLonghand(path[j], path[j - 1].args);
+          }
+          if (hasPrev) {
+            var prevArc = output.shift();
+            roundData(prevArc.args);
+            relSubpoint[0] += prevArc.args[5] - prev.args[prev.args.length - 2];
+            relSubpoint[1] += prevArc.args[6] - prev.args[prev.args.length - 1];
+            prev.command = 'a';
+            prev.args = prevArc.args;
+            item.base = prev.coords = prevArc.coords;
+          }
+          arc = output.shift();
+          if (arcCurves.length == 1) {
+            item.sdata = sdata.slice(); // preserve curve data for future checks
+          } else if (arcCurves.length - 1 - hasPrev > 0) {
+            // filter out consumed next items
+            path.splice.apply(
+              path,
+              [index + 1, arcCurves.length - 1 - hasPrev].concat(output)
+            );
+          }
+          if (!arc) return false;
+          command = 'a';
+          data = arc.args;
+          item.coords = arc.coords;
+        }
+      }
+
+      // Rounding relative coordinates, taking in account accummulating error
+      // to get closer to absolute coordinates. Sum of rounded value remains same:
+      // l .25 3 .25 2 .25 3 .25 2 -> l .3 3 .2 2 .3 3 .2 2
+      if (precision !== false) {
+        if (
+          command === 'm' ||
+          command === 'l' ||
+          command === 't' ||
+          command === 'q' ||
+          command === 's' ||
+          command === 'c'
+        ) {
+          for (var i = data.length; i--; ) {
+            data[i] += item.base[i % 2] - relSubpoint[i % 2];
+          }
+        } else if (command == 'h') {
+          data[0] += item.base[0] - relSubpoint[0];
+        } else if (command == 'v') {
+          data[0] += item.base[1] - relSubpoint[1];
+        } else if (command == 'a') {
+          data[5] += item.base[0] - relSubpoint[0];
+          data[6] += item.base[1] - relSubpoint[1];
+        }
+        roundData(data);
+
+        if (command == 'h') relSubpoint[0] += data[0];
+        else if (command == 'v') relSubpoint[1] += data[0];
+        else {
+          relSubpoint[0] += data[data.length - 2];
+          relSubpoint[1] += data[data.length - 1];
+        }
+        roundData(relSubpoint);
+
+        if (command === 'M' || command === 'm') {
+          pathBase[0] = relSubpoint[0];
+          pathBase[1] = relSubpoint[1];
+        }
+      }
+
+      // convert straight curves into lines segments
+      if (params.straightCurves) {
+        if (
+          (command === 'c' && isCurveStraightLine(data)) ||
+          (command === 's' && isCurveStraightLine(sdata))
+        ) {
+          if (next && next.command == 's') makeLonghand(next, data); // fix up next curve
+          command = 'l';
+          data = data.slice(-2);
+        } else if (command === 'q' && isCurveStraightLine(data)) {
+          if (next && next.command == 't') makeLonghand(next, data); // fix up next curve
+          command = 'l';
+          data = data.slice(-2);
+        } else if (
+          command === 't' &&
+          prev.command !== 'q' &&
+          prev.command !== 't'
+        ) {
+          command = 'l';
+          data = data.slice(-2);
+        } else if (command === 'a' && (data[0] === 0 || data[1] === 0)) {
+          command = 'l';
+          data = data.slice(-2);
+        }
+      }
+
+      // horizontal and vertical line shorthands
+      // l 50 0 → h 50
+      // l 0 50 → v 50
+      if (params.lineShorthands && command === 'l') {
+        if (data[1] === 0) {
+          command = 'h';
+          data.pop();
+        } else if (data[0] === 0) {
+          command = 'v';
+          data.shift();
+        }
+      }
+
+      // collapse repeated commands
+      // h 20 h 30 -> h 50
+      if (
+        params.collapseRepeated &&
+        hasMarkerMid === false &&
+        (command === 'm' || command === 'h' || command === 'v') &&
+        prev.command &&
+        command == prev.command.toLowerCase() &&
+        ((command != 'h' && command != 'v') ||
+          prev.args[0] >= 0 == data[0] >= 0)
+      ) {
+        prev.args[0] += data[0];
+        if (command != 'h' && command != 'v') {
+          prev.args[1] += data[1];
+        }
+        prev.coords = item.coords;
+        path[index] = prev;
+        return false;
+      }
+
+      // convert curves into smooth shorthands
+      if (params.curveSmoothShorthands && prev.command) {
+        // curveto
+        if (command === 'c') {
+          // c + c → c + s
+          if (
+            prev.command === 'c' &&
+            data[0] === -(prev.args[2] - prev.args[4]) &&
+            data[1] === -(prev.args[3] - prev.args[5])
+          ) {
+            command = 's';
+            data = data.slice(2);
+          }
+
+          // s + c → s + s
+          else if (
+            prev.command === 's' &&
+            data[0] === -(prev.args[0] - prev.args[2]) &&
+            data[1] === -(prev.args[1] - prev.args[3])
+          ) {
+            command = 's';
+            data = data.slice(2);
+          }
+
+          // [^cs] + c → [^cs] + s
+          else if (
+            prev.command !== 'c' &&
+            prev.command !== 's' &&
+            data[0] === 0 &&
+            data[1] === 0
+          ) {
+            command = 's';
+            data = data.slice(2);
+          }
+        }
+
+        // quadratic Bézier curveto
+        else if (command === 'q') {
+          // q + q → q + t
+          if (
+            prev.command === 'q' &&
+            data[0] === prev.args[2] - prev.args[0] &&
+            data[1] === prev.args[3] - prev.args[1]
+          ) {
+            command = 't';
+            data = data.slice(2);
+          }
+
+          // t + q → t + t
+          else if (
+            prev.command === 't' &&
+            data[2] === prev.args[0] &&
+            data[3] === prev.args[1]
+          ) {
+            command = 't';
+            data = data.slice(2);
+          }
+        }
+      }
+
+      // remove useless non-first path segments
+      if (params.removeUseless && !maybeHasStrokeAndLinecap) {
+        // l 0,0 / h 0 / v 0 / q 0,0 0,0 / t 0,0 / c 0,0 0,0 0,0 / s 0,0 0,0
+        if (
+          (command === 'l' ||
+            command === 'h' ||
+            command === 'v' ||
+            command === 'q' ||
+            command === 't' ||
+            command === 'c' ||
+            command === 's') &&
+          data.every(function (i) {
+            return i === 0;
+          })
+        ) {
+          path[index] = prev;
+          return false;
+        }
+
+        // a 25,25 -30 0,1 0,0
+        if (command === 'a' && data[5] === 0 && data[6] === 0) {
+          path[index] = prev;
+          return false;
+        }
+      }
+
+      item.command = command;
+      item.args = data;
+
+      prev = item;
+    } else {
+      // z resets coordinates
+      relSubpoint[0] = pathBase[0];
+      relSubpoint[1] = pathBase[1];
+      if (prev.command === 'Z' || prev.command === 'z') return false;
+      prev = item;
+    }
+
+    return true;
+  });
+
+  return path;
+}
+
+/**
+ * Writes data in shortest form using absolute or relative coordinates.
+ *
+ * @param {Array} data input path data
+ * @return {Boolean} output
+ */
+function convertToMixed(path, params) {
+  var prev = path[0];
+
+  path = path.filter(function (item, index) {
+    if (index == 0) return true;
+    if (item.command === 'Z' || item.command === 'z') {
+      prev = item;
+      return true;
+    }
+
+    var command = item.command,
+      data = item.args,
+      adata = data.slice();
+
+    if (
+      command === 'm' ||
+      command === 'l' ||
+      command === 't' ||
+      command === 'q' ||
+      command === 's' ||
+      command === 'c'
+    ) {
+      for (var i = adata.length; i--; ) {
+        adata[i] += item.base[i % 2];
+      }
+    } else if (command == 'h') {
+      adata[0] += item.base[0];
+    } else if (command == 'v') {
+      adata[0] += item.base[1];
+    } else if (command == 'a') {
+      adata[5] += item.base[0];
+      adata[6] += item.base[1];
+    }
+
+    roundData(adata);
+
+    var absoluteDataStr = cleanupOutData(adata, params),
+      relativeDataStr = cleanupOutData(data, params);
+
+    // Convert to absolute coordinates if it's shorter or forceAbsolutePath is true.
+    // v-20 -> V0
+    // Don't convert if it fits following previous command.
+    // l20 30-10-50 instead of l20 30L20 30
+    if (
+      params.forceAbsolutePath ||
+      (absoluteDataStr.length < relativeDataStr.length &&
+        !(
+          params.negativeExtraSpace &&
+          command == prev.command &&
+          prev.command.charCodeAt(0) > 96 &&
+          absoluteDataStr.length == relativeDataStr.length - 1 &&
+          (data[0] < 0 ||
+            (/^0\./.test(data[0]) && prev.args[prev.args.length - 1] % 1))
+        ))
+    ) {
+      item.command = command.toUpperCase();
+      item.args = adata;
+    }
+
+    prev = item;
+
+    return true;
+  });
+
+  return path;
+}
+
+/**
+ * Checks if curve is convex. Control points of such a curve must form
+ * a convex quadrilateral with diagonals crosspoint inside of it.
+ *
+ * @param {Array} data input path data
+ * @return {Boolean} output
+ */
+function isConvex(data) {
+  var center = getIntersection([
+    0,
+    0,
+    data[2],
+    data[3],
+    data[0],
+    data[1],
+    data[4],
+    data[5],
+  ]);
+
+  return (
+    center &&
+    data[2] < center[0] == center[0] < 0 &&
+    data[3] < center[1] == center[1] < 0 &&
+    data[4] < center[0] == center[0] < data[0] &&
+    data[5] < center[1] == center[1] < data[1]
+  );
+}
+
+/**
+ * Computes lines equations by two points and returns their intersection point.
+ *
+ * @param {Array} coords 8 numbers for 4 pairs of coordinates (x,y)
+ * @return {Array|undefined} output coordinate of lines' crosspoint
+ */
+function getIntersection(coords) {
+  // Prev line equation parameters.
+  var a1 = coords[1] - coords[3], // y1 - y2
+    b1 = coords[2] - coords[0], // x2 - x1
+    c1 = coords[0] * coords[3] - coords[2] * coords[1], // x1 * y2 - x2 * y1
+    // Next line equation parameters
+    a2 = coords[5] - coords[7], // y1 - y2
+    b2 = coords[6] - coords[4], // x2 - x1
+    c2 = coords[4] * coords[7] - coords[5] * coords[6], // x1 * y2 - x2 * y1
+    denom = a1 * b2 - a2 * b1;
+
+  if (!denom) return; // parallel lines havn't an intersection
+
+  var cross = [(b1 * c2 - b2 * c1) / denom, (a1 * c2 - a2 * c1) / -denom];
+  if (
+    !isNaN(cross[0]) &&
+    !isNaN(cross[1]) &&
+    isFinite(cross[0]) &&
+    isFinite(cross[1])
+  ) {
+    return cross;
+  }
+}
+
+/**
+ * Decrease accuracy of floating-point numbers
+ * in path data keeping a specified number of decimals.
+ * Smart rounds values like 2.3491 to 2.35 instead of 2.349.
+ * Doesn't apply "smartness" if the number precision fits already.
+ *
+ * @param {Array} data input data array
+ * @return {Array} output data array
+ */
+function strongRound(data) {
+  for (var i = data.length; i-- > 0; ) {
+    if (data[i].toFixed(precision) != data[i]) {
+      var rounded = +data[i].toFixed(precision - 1);
+      data[i] =
+        +Math.abs(rounded - data[i]).toFixed(precision + 1) >= error
+          ? +data[i].toFixed(precision)
+          : rounded;
+    }
+  }
+  return data;
+}
+
+/**
+ * Simple rounding function if precision is 0.
+ *
+ * @param {Array} data input data array
+ * @return {Array} output data array
+ */
+function round(data) {
+  for (var i = data.length; i-- > 0; ) {
+    data[i] = Math.round(data[i]);
+  }
+  return data;
+}
+
+/**
+ * Checks if a curve is a straight line by measuring distance
+ * from middle points to the line formed by end points.
+ *
+ * @param {Array} xs array of curve points x-coordinates
+ * @param {Array} ys array of curve points y-coordinates
+ * @return {Boolean}
+ */
+
+function isCurveStraightLine(data) {
+  // Get line equation a·x + b·y + c = 0 coefficients a, b (c = 0) by start and end points.
+  var i = data.length - 2,
+    a = -data[i + 1], // y1 − y2 (y1 = 0)
+    b = data[i], // x2 − x1 (x1 = 0)
+    d = 1 / (a * a + b * b); // same part for all points
+
+  if (i <= 1 || !isFinite(d)) return false; // curve that ends at start point isn't the case
+
+  // Distance from point (x0, y0) to the line is sqrt((c − a·x0 − b·y0)² / (a² + b²))
+  while ((i -= 2) >= 0) {
+    if (Math.sqrt(Math.pow(a * data[i] + b * data[i + 1], 2) * d) > error)
+      return false;
+  }
+
+  return true;
+}
+
+/**
+ * Converts next curve from shorthand to full form using the current curve data.
+ *
+ * @param {Object} item curve to convert
+ * @param {Array} data current curve data
+ */
+
+function makeLonghand(item, data) {
+  switch (item.command) {
+    case 's':
+      item.command = 'c';
+      break;
+    case 't':
+      item.command = 'q';
+      break;
+  }
+  item.args.unshift(
+    data[data.length - 2] - data[data.length - 4],
+    data[data.length - 1] - data[data.length - 3]
+  );
+  return item;
+}
+
+/**
+ * Returns distance between two points
+ *
+ * @param {Array} point1 first point coordinates
+ * @param {Array} point2 second point coordinates
+ * @return {Number} distance
+ */
+
+function getDistance(point1, point2) {
+  return Math.hypot(point1[0] - point2[0], point1[1] - point2[1]);
+}
+
+/**
+ * Returns coordinates of the curve point corresponding to the certain t
+ * a·(1 - t)³·p1 + b·(1 - t)²·t·p2 + c·(1 - t)·t²·p3 + d·t³·p4,
+ * where pN are control points and p1 is zero due to relative coordinates.
+ *
+ * @param {Array} curve array of curve points coordinates
+ * @param {Number} t parametric position from 0 to 1
+ * @return {Array} Point coordinates
+ */
+
+function getCubicBezierPoint(curve, t) {
+  var sqrT = t * t,
+    cubT = sqrT * t,
+    mt = 1 - t,
+    sqrMt = mt * mt;
+
+  return [
+    3 * sqrMt * t * curve[0] + 3 * mt * sqrT * curve[2] + cubT * curve[4],
+    3 * sqrMt * t * curve[1] + 3 * mt * sqrT * curve[3] + cubT * curve[5],
+  ];
+}
+
+/**
+ * Finds circle by 3 points of the curve and checks if the curve fits the found circle.
+ *
+ * @param {Array} curve
+ * @return {Object|undefined} circle
+ */
+
+function findCircle(curve) {
+  var midPoint = getCubicBezierPoint(curve, 1 / 2),
+    m1 = [midPoint[0] / 2, midPoint[1] / 2],
+    m2 = [(midPoint[0] + curve[4]) / 2, (midPoint[1] + curve[5]) / 2],
+    center = getIntersection([
+      m1[0],
+      m1[1],
+      m1[0] + m1[1],
+      m1[1] - m1[0],
+      m2[0],
+      m2[1],
+      m2[0] + (m2[1] - midPoint[1]),
+      m2[1] - (m2[0] - midPoint[0]),
+    ]),
+    radius = center && getDistance([0, 0], center),
+    tolerance = Math.min(arcThreshold * error, (arcTolerance * radius) / 100);
+
+  if (
+    center &&
+    radius < 1e15 &&
+    [1 / 4, 3 / 4].every(function (point) {
+      return (
+        Math.abs(
+          getDistance(getCubicBezierPoint(curve, point), center) - radius
+        ) <= tolerance
+      );
+    })
+  )
+    return { center: center, radius: radius };
+}
+
+/**
+ * Checks if a curve fits the given circle.
+ *
+ * @param {Object} circle
+ * @param {Array} curve
+ * @return {Boolean}
+ */
+
+function isArc(curve, circle) {
+  var tolerance = Math.min(
+    arcThreshold * error,
+    (arcTolerance * circle.radius) / 100
+  );
+
+  return [0, 1 / 4, 1 / 2, 3 / 4, 1].every(function (point) {
+    return (
+      Math.abs(
+        getDistance(getCubicBezierPoint(curve, point), circle.center) -
+          circle.radius
+      ) <= tolerance
+    );
+  });
+}
+
+/**
+ * Checks if a previous curve fits the given circle.
+ *
+ * @param {Object} circle
+ * @param {Array} curve
+ * @return {Boolean}
+ */
+
+function isArcPrev(curve, circle) {
+  return isArc(curve, {
+    center: [circle.center[0] + curve[4], circle.center[1] + curve[5]],
+    radius: circle.radius,
+  });
+}
+
+/**
+ * Finds angle of a curve fitting the given arc.
+
+ * @param {Array} curve
+ * @param {Object} relCircle
+ * @return {Number} angle
+ */
+
+function findArcAngle(curve, relCircle) {
+  var x1 = -relCircle.center[0],
+    y1 = -relCircle.center[1],
+    x2 = curve[4] - relCircle.center[0],
+    y2 = curve[5] - relCircle.center[1];
+
+  return Math.acos(
+    (x1 * x2 + y1 * y2) / Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+  );
+}
+
+/**
+ * Converts given path data to string.
+ *
+ * @param {Object} params
+ * @param {Array} pathData
+ * @return {String}
+ */
+
+function data2Path(params, pathData) {
+  return pathData.reduce(function (pathString, item) {
+    var strData = '';
+    if (item.args) {
+      strData = cleanupOutData(roundData(item.args.slice()), params);
+    }
+    return pathString + item.command + strData;
+  }, '');
+}