svg-path-commander 0.1.10-alpha2 → 0.1.10-alpha3

package/dist/svg-path-commander.esm.js

@@ -1,5 +1,5 @@
 /*!
-* SVGPathCommander v0.1.10alpha2 (http://thednp.github.io/svg-path-commander)
+* SVGPathCommander v0.1.10alpha3 (http://thednp.github.io/svg-path-commander)
 * Copyright 2021 © thednp
 * Licensed under MIT (https://github.com/thednp/svg-path-commander/blob/master/LICENSE)
 */
@@ -39,9 +39,11 @@ function finalizeSegment(path) {
   }
 
   if (pathComLK === 'r') {
+    // @ts-ignore
     path.segments.push([pathCommand].concat(params));
   } else {
     while (params.length >= paramsCount[pathComLK]) {
+      // @ts-ignore
       path.segments.push([pathCommand].concat(params.splice(0, paramsCount[pathComLK])));
       if (!paramsCount[pathComLK]) {
         break;
@@ -80,7 +82,7 @@ function scanFlag(path) {
 /**
  * Checks if a character is a digit.
  *
- * @param {string} code the character to check
+ * @param {number} code the character to check
  * @returns {boolean} check result
  */
 function isDigit(code) {
@@ -185,18 +187,17 @@ function scanParam(path) {
 /**
  * Checks if the character is a space.
  *
- * @param {string} code the character to check
+ * @param {number} ch the character to check
  * @returns {boolean} check result
  */
-function isSpace(code) {
+function isSpace(ch) {
   const specialSpaces = [
     0x1680, 0x180E, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006,
     0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF];
-  // Line terminators
-  return (code === 0x0A) || (code === 0x0D) || (code === 0x2028) || (code === 0x2029)
+  return (ch === 0x0A) || (ch === 0x0D) || (ch === 0x2028) || (ch === 0x2029) // Line terminators
     // White spaces
-    || (code === 0x20) || (code === 0x09) || (code === 0x0B) || (code === 0x0C) || (code === 0xA0)
-    || (code >= 0x1680 && specialSpaces.indexOf(code) >= 0);
+    || (ch === 0x20) || (ch === 0x09) || (ch === 0x0B) || (ch === 0x0C) || (ch === 0xA0)
+    || (ch >= 0x1680 && specialSpaces.indexOf(ch) >= 0);
 }
 
 /**
@@ -243,7 +244,7 @@ function isPathCommand(code) {
  * Checks if the character is or belongs to a number.
  * [0-9]|+|-|.
  *
- * @param {string} code the character to check
+ * @param {number} code the character to check
  * @returns {boolean} check result
  */
 function isDigitStart(code) {
@@ -256,7 +257,7 @@ function isDigitStart(code) {
 /**
  * Checks if the character is an A (arc-to) path command.
  *
- * @param {string} code the character to check
+ * @param {number} code the character to check
  * @returns {boolean} check result
  */
 function isArcCommand(code) {
@@ -387,9 +388,10 @@ function isPathArray(path) {
  */
 function parsePathString(pathInput) {
   if (isPathArray(pathInput)) {
+    // @ts-ignore
     return clonePath(pathInput);
   }
-
+  // @ts-ignore
   const path = new SVGPathArray(pathInput);
 
   skipSpaces(path);
@@ -672,12 +674,12 @@ function pathToString(path, round) {
  * Returns the missing control point from an
  * T (shorthand quadratic bezier) segment.
  *
- * @param {Number} x1 curve start x
- * @param {Number} y1 curve start y
- * @param {Number} qx control point x
- * @param {Number} qy control point y
- * @param {String} prevCommand the previous path command
- * @returns {Object} the missing control point
+ * @param {number} x1 curve start x
+ * @param {number} y1 curve start y
+ * @param {number} qx control point x
+ * @param {number} qy control point y
+ * @param {string} prevCommand the previous path command
+ * @returns {{qx: number, qy: number}}} the missing control point
  */
 function shorthandToQuad(x1, y1, qx, qy, prevCommand) {
   return 'QT'.indexOf(prevCommand) > -1
@@ -689,12 +691,12 @@ function shorthandToQuad(x1, y1, qx, qy, prevCommand) {
  * Returns the missing control point from an
  * S (shorthand cubic bezier) segment.
  *
- * @param {Number} x1 curve start x
- * @param {Number} y1 curve start y
- * @param {Number} x2 curve end x
- * @param {Number} y2 curve end y
- * @param {String} prevCommand the previous path command
- * @returns {Object} the missing control point
+ * @param {number} x1 curve start x
+ * @param {number} y1 curve start y
+ * @param {number} x2 curve end x
+ * @param {number} y2 curve end y
+ * @param {string} prevCommand the previous path command
+ * @returns {{x1: number, y1: number}}} the missing control point
  */
 function shorthandToCubic(x1, y1, x2, y2, prevCommand) {
   return 'CS'.indexOf(prevCommand) > -1
@@ -706,14 +708,14 @@ function shorthandToCubic(x1, y1, x2, y2, prevCommand) {
  * Normalizes a single segment of a `pathArray` object.
  *
  * @param {SVGPC.pathSegment} segment the segment object
- * @param {Object} params the coordinates of the previous segment
+ * @param {any} params the coordinates of the previous segment
  * @param {String} prevCommand the path command of the previous segment
- * @returns {SVGPC.pathSegment} the normalized segment
+ * @returns {any} the normalized segment
  */
 function normalizeSegment(segment, params, prevCommand) {
   const [pathCommand] = segment;
   const xy = segment.slice(1);
-  let result = segment;
+  let result = segment.slice();
 
   if ('TQ'.indexOf(segment[0]) < 0) {
     // optional but good to be cautious
@@ -940,8 +942,9 @@ const epsilon = 1e-9;
  * Returns an {x,y} vector rotated by a given
  * angle in radian.
  *
- * @param {Number} x the initial vector x
- * @param {Number} y the initial vector y
+ * @param {number} x the initial vector x
+ * @param {number} y the initial vector y
+ * @param {number} rad the radian vector angle
  * @returns {{x: number, y: number}} the rotated vector
  */
 function rotateVector(x, y, rad) {
@@ -956,29 +959,27 @@ function rotateVector(x, y, rad) {
  * For more information of where this math came from visit:
  * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
  *
- * @param {number} x1 the starting x position
- * @param {number} y1 the starting y position
- * @param {number} rx x-radius of the arc
- * @param {number} ry y-radius of the arc
+ * @param {number} X1 the starting x position
+ * @param {number} Y1 the starting y position
+ * @param {number} RX x-radius of the arc
+ * @param {number} RY y-radius of the arc
  * @param {number} angle x-axis-rotation of the arc
  * @param {number} LAF large-arc-flag of the arc
  * @param {number} SF sweep-flag of the arc
- * @param {number} x2 the ending x position
- * @param {number} y2 the ending y position
+ * @param {number} X2 the ending x position
+ * @param {number} Y2 the ending y position
  * @param {number[] | null} recursive the parameters needed to split arc into 2 segments
- * @return {number[]} the resulting cubic-bezier segment(s)
+ * @return {any} the resulting cubic-bezier segment(s)
  */
-function arcToCubic(x1, y1, rx, ry, angle, LAF, SF, x2, y2, recursive) {
+// export default function arcToCubic(x1, y1, rx, ry, angle, LAF, SF, x2, y2, recursive) {
+function arcToCubic(X1, Y1, RX, RY, angle, LAF, SF, X2, Y2, recursive) {
+  let x1 = X1; let y1 = Y1; let rx = RX; let ry = RY; let x2 = X2; let y2 = Y2;
+  // for more information of where this Math came from visit:
+  // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
   const d120 = (Math.PI * 120) / 180;
-  const rad = (Math.PI / 180) * (angle || 0);
-  /** @type {number[]} */
+
+  const rad = (Math.PI / 180) * (+angle || 0);
   let res = [];
-  let X1 = x1;
-  let X2 = x2;
-  let Y1 = y1;
-  let Y2 = y2;
-  let RX = rx;
-  let RY = ry;
   let xy;
   let f1;
   let f2;
@@ -986,41 +987,39 @@ function arcToCubic(x1, y1, rx, ry, angle, LAF, SF, x2, y2, recursive) {
   let cy;
 
   if (!recursive) {
-    xy = rotateVector(X1, Y1, -rad);
-    X1 = xy.x;
-    Y1 = xy.y;
-    xy = rotateVector(X2, Y2, -rad);
-    X2 = xy.x;
-    Y2 = xy.y;
-
-    const x = (X1 - X2) / 2;
-    const y = (Y1 - Y2) / 2;
-    let h = (x ** 2) / (RX ** 2) + (y ** 2) / (RY ** 2);
+    xy = rotateVector(x1, y1, -rad);
+    x1 = xy.x;
+    y1 = xy.y;
+    xy = rotateVector(x2, y2, -rad);
+    x2 = xy.x;
+    y2 = xy.y;
+
+    const x = (x1 - x2) / 2;
+    const y = (y1 - y2) / 2;
+    let h = (x * x) / (rx * rx) + (y * y) / (ry * ry);
     if (h > 1) {
       h = Math.sqrt(h);
-      RX *= h;
-      RY *= h;
+      rx *= h;
+      ry *= h;
     }
-    const rx2 = RX ** 2;
-    const ry2 = RY ** 2;
-    const k = (LAF === SF ? -1 : 1)
-          * Math.sqrt(Math.abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x)
-          / (rx2 * y * y + ry2 * x * x)));
+    const rx2 = rx * rx;
+    const ry2 = ry * ry;
 
-    cx = ((k * RX * y) / RY) + ((X1 + X2) / 2);
-    cy = ((k * -RY * x) / RX) + ((Y1 + Y2) / 2);
+    const k = (LAF === SF ? -1 : 1)
+            * Math.sqrt(Math.abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x)
+                / (rx2 * y * y + ry2 * x * x)));
 
+    cx = ((k * rx * y) / ry) + ((x1 + x2) / 2);
+    cy = ((k * -ry * x) / rx) + ((y1 + y2) / 2);
     // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise
-    f1 = Math.asin((((Y1 - cy) / RY) * 10 ** 9 >> 0) / (10 ** 9));
+    f1 = (Math.asin((((y1 - cy) / ry))) * (10 ** 9) >> 0) / (10 ** 9);
     // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise
-    f2 = Math.asin((((Y2 - cy) / RY) * 10 ** 9 >> 0) / (10 ** 9));
-
-    f1 = X1 < cx ? Math.PI - f1 : f1;
-    f2 = X2 < cx ? Math.PI - f2 : f2;
-
-    if (f1 < 0) { f1 = Math.PI * 2 + f1; }
-    if (f2 < 0) { f2 = Math.PI * 2 + f2; }
+    f2 = (Math.asin((((y2 - cy) / ry))) * (10 ** 9) >> 0) / (10 ** 9);
 
+    f1 = x1 < cx ? Math.PI - f1 : f1;
+    f2 = x2 < cx ? Math.PI - f2 : f2;
+    if (f1 < 0) (f1 = Math.PI * 2 + f1);
+    if (f2 < 0) (f2 = Math.PI * 2 + f2);
     if (SF && f1 > f2) {
       f1 -= Math.PI * 2;
     }
@@ -1028,51 +1027,43 @@ function arcToCubic(x1, y1, rx, ry, angle, LAF, SF, x2, y2, recursive) {
       f2 -= Math.PI * 2;
     }
   } else {
-    const [r1, r2, r3, r4] = recursive;
-    f1 = r1;
-    f2 = r2;
-    cx = r3;
-    cy = r4;
+    [f1, f2, cx, cy] = recursive;
   }
-
   let df = f2 - f1;
-
   if (Math.abs(df) > d120) {
     const f2old = f2;
-    const x2old = X2;
-    const y2old = Y2;
-
+    const x2old = x2;
+    const y2old = y2;
     f2 = f1 + d120 * (SF && f2 > f1 ? 1 : -1);
-    X2 = cx + RX * Math.cos(f2);
-    Y2 = cy + RY * Math.sin(f2);
-    res = arcToCubic(X2, Y2, RX, RY, angle, 0, SF, x2old, y2old, [f2, f2old, cx, cy]);
+    x2 = cx + rx * Math.cos(f2);
+    y2 = cy + ry * Math.sin(f2);
+    res = arcToCubic(x2, y2, rx, ry, angle, 0, SF, x2old, y2old, [f2, f2old, cx, cy]);
   }
-
   df = f2 - f1;
   const c1 = Math.cos(f1);
   const s1 = Math.sin(f1);
   const c2 = Math.cos(f2);
   const s2 = Math.sin(f2);
   const t = Math.tan(df / 4);
-  const hx = (4 / 3) * RX * t;
-  const hy = (4 / 3) * RY * t;
-  const m1 = [X1, Y1];
-  const m2 = [X1 + hx * s1, Y1 - hy * c1];
-  const m3 = [X2 + hx * s2, Y2 - hy * c2];
-  const m4 = [X2, Y2];
+  const hx = (4 / 3) * rx * t;
+  const hy = (4 / 3) * ry * t;
+  const m1 = [x1, y1];
+  const m2 = [x1 + hx * s1, y1 - hy * c1];
+  const m3 = [x2 + hx * s2, y2 - hy * c2];
+  const m4 = [x2, y2];
   m2[0] = 2 * m1[0] - m2[0];
   m2[1] = 2 * m1[1] - m2[1];
-
   if (recursive) {
-    return [m2, m3, m4].concat(res).map((n) => +n);
+    return [m2, m3, m4].concat(res);
   }
-  res = [m2, m3, m4].concat(res).join().split(',').map((n) => +n);
-  return res.map((rz, i) => {
-    if (i % 2) {
-      return rotateVector(res[i - 1], rz, rad).y;
-    }
-    return rotateVector(rz, res[i + 1], rad).x;
-  });
+  res = [m2, m3, m4].concat(res).join().split(',');
+  const newres = [];
+  for (let i = 0, ii = res.length; i < ii; i += 1) {
+    newres[i] = i % 2
+      // @ts-ignore
+      ? rotateVector(res[i - 1], res[i], rad).y : rotateVector(res[i], res[i + 1], rad).x;
+  }
+  return newres;
 }
 
 /**
@@ -1102,15 +1093,15 @@ function quadToCubic(x1, y1, qx, qy, x2, y2) {
  * Returns the {x,y} coordinates of a point at a
  * given length of a cubic-bezier segment.
  *
- * @param {Number} p1x the starting point X
- * @param {Number} p1y the starting point Y
- * @param {Number} c1x the first control point X
- * @param {Number} c1y the first control point Y
- * @param {Number} c2x the second control point X
- * @param {Number} c2y the second control point Y
- * @param {Number} px2 the ending point X
- * @param {Number} py2 the ending point Y
- * @param {Number} t a [0-1] ratio
+ * @param {number} p1x the starting point X
+ * @param {number} p1y the starting point Y
+ * @param {number} c1x the first control point X
+ * @param {number} c1y the first control point Y
+ * @param {number} c2x the second control point X
+ * @param {number} c2y the second control point Y
+ * @param {number} p2x the ending point X
+ * @param {number} p2y the ending point Y
+ * @param {number} t a [0-1] ratio
  * @returns {{x: number, y: number}} the requested {x,y} coordinates
  */
 function getPointAtSegLength(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {
@@ -1144,11 +1135,11 @@ function midPoint(a, b, t) {
 /**
  * Converts an L (line-to) segment to C (cubic-bezier).
  *
- * @param {Number} x1 line start x
- * @param {Number} y1 line start y
- * @param {Number} x2 line end x
- * @param {Number} y2 line end y
- * @returns {Number[]} the cubic-bezier segment
+ * @param {number} x1 line start x
+ * @param {number} y1 line start y
+ * @param {number} x2 line end x
+ * @param {number} y2 line end y
+ * @returns {number[]} the cubic-bezier segment
  */
 function lineToCubic(x1, y1, x2, y2) {
   const t = 0.5;
@@ -1159,7 +1150,9 @@ function lineToCubic(x1, y1, x2, y2) {
   const p4 = midPoint(p2, p3, t);
   const p5 = midPoint(p3, p4, t);
   const p6 = midPoint(p4, p5, t);
+  // @ts-ignore
   const cp1 = getPointAtSegLength.apply(0, p0.concat(p2, p4, p6, t));
+  // @ts-ignore
   const cp2 = getPointAtSegLength.apply(0, p6.concat(p5, p3, p1, 0));
 
   return [cp1.x, cp1.y, cp2.x, cp2.y, x2, y2];
@@ -1219,6 +1212,8 @@ function fixArc(path, allPathCommands, i) {
     while (segment.length) {
       // if created multiple C:s, their original seg is saved
       allPathCommands[i] = 'A';
+      // path.splice(i++, 0, ['C'].concat(segment.splice(0, 6)));
+      // @ts-ignore
       path.splice(ni += 1, 0, ['C'].concat(segment.splice(0, 6)));
     }
     path.splice(i, 1);
@@ -2045,18 +2040,21 @@ function getSVGMatrix(transform) {
   if ((Array.isArray(translate) && translate.some((x) => +x !== 0)) || !Number.isNaN(translate)) {
     matrix = Array.isArray(translate)
       ? matrix.translate(+translate[0] || 0, +translate[1] || 0, +translate[2] || 0)
+      // @ts-ignore
       : matrix.translate(+translate || 0);
   }
 
   if (rotate || skew || scale) {
     // set SVG transform-origin, always defined
     // matrix = matrix.translate(+originX,+originY,+originZ)
+    // @ts-ignore
     matrix = matrix.translate(+originX, +originY);
 
     // set rotation
     if (rotate) {
       matrix = Array.isArray(rotate) && rotate.some((x) => +x !== 0)
         ? matrix.rotate(+rotate[0] || 0, +rotate[1] || 0, +rotate[2] || 0)
+        // @ts-ignore
         : matrix.rotate(+rotate || 0);
     }
     // set skew(s)
@@ -2072,10 +2070,12 @@ function getSVGMatrix(transform) {
     if (!Number.isNaN(scale) || (Array.isArray(scale) && scale.some((x) => +x !== 1))) {
       matrix = Array.isArray(scale)
         ? (matrix.scale(+scale[0] || 1, +scale[1] || 1, +scale[2] || 1))
+        // @ts-ignore
         : matrix.scale(+scale || 1);
     }
     // set SVG transform-origin
     // matrix = matrix.translate(-originX,-originY,-originZ)
+    // @ts-ignore
     matrix = matrix.translate(-originX, -originY);
   }
   return matrix;
@@ -2335,8 +2335,9 @@ function getCubicSize(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {
   const y = [p1y, p2y];
   const x = [p1x, p2x];
   let dot;
-
+  // @ts-ignore
   if (Math.abs(t1) > '1e12') t1 = 0.5;
+  // @ts-ignore
   if (Math.abs(t2) > '1e12') t2 = 0.5;
 
   if (t1 > 0 && t1 < 1) {
@@ -2354,8 +2355,9 @@ function getCubicSize(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {
   c = p1y - c1y;
   t1 = (-b + Math.sqrt(b * b - 4 * a * c)) / 2 / a;
   t2 = (-b - Math.sqrt(b * b - 4 * a * c)) / 2 / a;
-
+  // @ts-ignore
   if (Math.abs(t1) > '1e12') t1 = 0.5;
+  // @ts-ignore
   if (Math.abs(t2) > '1e12') t2 = 0.5;
 
   if (t1 > 0 && t1 < 1) {
@@ -2435,35 +2437,39 @@ function pathToCurve(pathInput) {
 function getPathBBox(path) {
   if (!path) {
     return {
-      x: 0, y: 0, width: 0, height: 0, x2: 0, y2: 0,
+      x: 0, y: 0, width: 0, height: 0, x2: 0, y2: 0, cx: 0, cy: 0,
     };
   }
   const pathCurve = pathToCurve(path);
-
-  let x = 0;
-  let y = 0;
-  let X = [];
-  let Y = [];
+  // @ts-ignore
+  let x = 0; let y = 0; let X = []; let Y = [];
 
   pathCurve.forEach((segment) => {
     const [s1, s2] = segment.slice(-2);
     if (segment[0] === 'M') {
-      x = s1;
-      y = s2;
+      x = +s1;
+      y = +s2;
       X.push(s1);
       Y.push(s2);
     } else {
+      // @ts-ignore
       const dim = getCubicSize.apply(0, [x, y].concat(segment.slice(1)));
+      // @ts-ignore
       X = X.concat(dim.min.x, dim.max.x);
+      // @ts-ignore
       Y = Y.concat(dim.min.y, dim.max.y);
-      x = s1;
-      y = s2;
+      x = +s1;
+      y = +s2;
     }
   });
 
+  // @ts-ignore
   const xTop = Math.min.apply(0, X);
+  // @ts-ignore
   const yTop = Math.min.apply(0, Y);
+  // @ts-ignore
   const xBot = Math.max.apply(0, X);
+  // @ts-ignore
   const yBot = Math.max.apply(0, Y);
   const width = xBot - xTop;
   const height = yBot - yTop;
@@ -2508,7 +2514,7 @@ function getCubicSegArea(x0, y0, x1, y1, x2, y2, x3, y3) {
  * => https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js
  *
  * @param {SVGPC.pathArray} path the shape `pathArray`
- * @returns {SVGPC.pathBBox} the length of the cubic-bezier segment
+ * @returns {number} the length of the cubic-bezier segment
  */
 function getPathArea(path) {
   let x = 0; let y = 0;
@@ -2524,13 +2530,23 @@ function getPathArea(path) {
         y = my;
         return 0;
       default:
+        // @ts-ignore
         len = getCubicSegArea.apply(0, [x, y].concat(seg.slice(1)));
+        // @ts-ignore
         [x, y] = seg.slice(-2);
         return len;
     }
   }).reduce((a, b) => a + b, 0);
 }
 
+/**
+ * @param {number} p1
+ * @param {number} p2
+ * @param {number} p3
+ * @param {number} p4
+ * @param {number} t a [0-1] ratio
+ * @returns {number}
+ */
 function base3(p1, p2, p3, p4, t) {
   const t1 = -3 * p1 + 9 * p2 - 9 * p3 + 3 * p4;
   const t2 = t * t1 + 6 * p1 - 12 * p2 + 6 * p3;
@@ -2540,19 +2556,19 @@ function base3(p1, p2, p3, p4, t) {
 /**
  * Returns the C (cubic-bezier) segment length.
  *
- * @param {Number} x1 the starting point X
- * @param {Number} y1 the starting point Y
- * @param {Number} x2 the first control point X
- * @param {Number} y2 the first control point Y
- * @param {Number} x3 the second control point X
- * @param {Number} y3 the second control point Y
- * @param {Number} x4 the ending point X
- * @param {Number} y4 the ending point Y
- * @param {Number} z a [0-1] ratio
- * @returns {Number} the cubic-bezier segment length
+ * @param {number} x1 the starting point X
+ * @param {number} y1 the starting point Y
+ * @param {number} x2 the first control point X
+ * @param {number} y2 the first control point Y
+ * @param {number} x3 the second control point X
+ * @param {number} y3 the second control point Y
+ * @param {number} x4 the ending point X
+ * @param {number} y4 the ending point Y
+ * @param {number} z a [0-1] ratio
+ * @returns {number} the cubic-bezier segment length
  */
 function getSegCubicLength(x1, y1, x2, y2, x3, y3, x4, y4, z) {
-  let Z;
+  let Z = z;
   if (z === null || Number.isNaN(+z)) Z = 1;
 
   // Z = Z > 1 ? 1 : Z < 0 ? 0 : Z;
@@ -2582,12 +2598,13 @@ function getSegCubicLength(x1, y1, x2, y2, x3, y3, x4, y4, z) {
  * pathToCurve version
  *
  * @param {SVGPC.pathArray} path the ending point Y
- * @returns {Number} the shape total length
+ * @returns {number} the shape total length
  */
 function getPathLength(path) {
   let totalLength = 0;
   pathToCurve(path).forEach((s, i, curveArray) => {
     totalLength += s[0] === 'M' ? 0
+      // @ts-ignore
       : getSegCubicLength.apply(0, curveArray[i - 1].slice(-2).concat(s.slice(1)));
   });
   return totalLength;
@@ -2608,23 +2625,25 @@ function getDrawDirection(path) {
  * Returns [x,y] coordinates of a point at a given length of a shape.
  *
  * @param {string | SVGPC.pathArray} path the `pathArray` to look into
- * @param {Number} length the length of the shape to look at
- * @returns {Number[]} the requested [x,y] coordinates
+ * @param {number} length the length of the shape to look at
+ * @returns {number[]} the requested [x,y] coordinates
  */
 function getPointAtLength(path, length) {
   let totalLength = 0;
   let segLen;
   let data;
   let result;
-
+  // @ts-ignore
   return pathToCurve(path).map((seg, i, curveArray) => {
     data = i ? curveArray[i - 1].slice(-2).concat(seg.slice(1)) : seg.slice(1);
+    // @ts-ignore
     segLen = i ? getSegCubicLength.apply(0, data) : 0;
     totalLength += segLen;
 
     if (i === 0) {
       result = { x: data[0], y: data[1] };
     } else if (totalLength > length && length > totalLength - segLen) {
+      // @ts-ignore
       result = getPointAtSegLength.apply(0, data.concat(1 - (totalLength - length) / segLen));
     } else {
       result = null;
@@ -2803,12 +2822,13 @@ function shapeToPath(element, replace) {
 
   const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
   const type = element.tagName;
-  /** @type {string[]} */
+  /** @ts-ignore */
   const shapeAttrs = shapeParams[type];
 
   // set config
   const config = {};
   config.type = type;
+  /** @ts-ignore */
   shapeAttrs.forEach((p) => { config[p] = element.getAttribute(p); });
 
   // set no-specific shape attributes: fill, stroke, etc
@@ -2818,10 +2838,15 @@ function shapeToPath(element, replace) {
 
   // set d
   let description;
+  /** @ts-ignore */
   if (type === 'circle') description = pathToString(getCirclePath(config));
+  /** @ts-ignore */
   else if (type === 'ellipse') description = pathToString(getEllipsePath(config));
+  /** @ts-ignore */
   else if (['polyline', 'polygon'].includes(type)) description = pathToString(getPolyPath(config));
+  /** @ts-ignore */
   else if (type === 'rect') description = pathToString(getRectanglePath(config));
+  /** @ts-ignore */
   else if (type === 'line') description = pathToString(getLinePath(config));
   else if (type === 'glyph') description = element.getAttribute('d');
 
@@ -2852,12 +2877,13 @@ function reverseCurve(path) {
     .map((x) => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))
     .reverse();
 
-  return [['M'].concat(rotatedCurve[0]
-    .slice(0, 2))]
+  // @ts-ignore
+  return [['M'].concat(rotatedCurve[0].slice(0, 2))]
+    // @ts-ignore
     .concat(rotatedCurve.map((x) => ['C'].concat(x.slice(2))));
 }
 
-var version = "0.1.10alpha2";
+var version = "0.1.10alpha3";
 
 // @ts-ignore