svg-path-commander 0.1.10-alpha3 → 0.1.10

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

@@ -1,5 +1,5 @@
 /*!
-* SVGPathCommander v0.1.10alpha3 (http://thednp.github.io/svg-path-commander)
+* SVGPathCommander v0.1.10 (http://thednp.github.io/svg-path-commander)
 * Copyright 2021 © thednp
 * Licensed under MIT (https://github.com/thednp/svg-path-commander/blob/master/LICENSE)
 */
@@ -23,31 +23,26 @@ const paramsCount = {
 /**
  * Breaks the parsing of a pathString once a segment is finalized.
  *
- * @param {SVGPC.parserPathArray} path the `parserPathArray` instance
+ * @param {svgpcNS.pathParser} path the `PathParser` instance
  */
 function finalizeSegment(path) {
   let pathCommand = path.pathValue[path.segmentStart];
-  let pathComLK = pathCommand.toLowerCase();
-  let params = path.data;
+  let LK = pathCommand.toLowerCase();
+  let { data } = path;
 
   // Process duplicated commands (without comand name)
-  if (pathComLK === 'm' && params.length > 2) {
-    path.segments.push([pathCommand, params[0], params[1]]);
-    params = params.slice(2);
-    pathComLK = 'l';
-    pathCommand = (pathCommand === 'm') ? 'l' : 'L';
+  if (LK === 'm' && data.length > 2) {
+    path.segments.push([pathCommand, data[0], data[1]]);
+    data = data.slice(2);
+    LK = 'l';
+    pathCommand = pathCommand === 'm' ? 'l' : 'L';
   }
 
-  if (pathComLK === 'r') {
+  while (data.length >= paramsCount[LK]) {
     // @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;
-      }
+    path.segments.push([pathCommand].concat(data.splice(0, paramsCount[LK])));
+    if (!paramsCount[LK]) {
+      break;
     }
   }
 }
@@ -58,7 +53,7 @@ const invalidPathValue = 'Invalid path value';
  * Validates an A (arc-to) specific path command value.
  * Usually a `large-arc-flag` or `sweep-flag`.
  *
- * @param {SVGPC.parserPathArray} path the `parserPathArray` instance
+ * @param {svgpcNS.pathParser} path the `PathParser` instance
  */
 function scanFlag(path) {
   const { index } = path;
@@ -93,7 +88,7 @@ function isDigit(code) {
  * Validates every character of the path string,
  * every path command, negative numbers or floating point numbers.
  *
- * @param {SVGPC.parserPathArray} path the `parserPathArray` instance
+ * @param {svgpcNS.pathParser} path the `PathParser` instance
  */
 function scanParam(path) {
   const { max, pathValue, index: start } = path;
@@ -205,7 +200,7 @@ function isSpace(ch) {
  * path string every time it encounters any kind of
  * space character.
  *
- * @param {SVGPC.parserPathArray} path the `parserPathArray` instance
+ * @param {svgpcNS.pathParser} path the `PathParser` instance
  */
 function skipSpaces(path) {
   const { pathValue, max } = path;
@@ -233,7 +228,7 @@ function isPathCommand(code) {
     case 0x71/* q */:
     case 0x74/* t */:
     case 0x61/* a */:
-    case 0x72/* r */:
+    // case 0x72/* r */: // R is not supported
       return true;
     default:
       return false;
@@ -269,7 +264,7 @@ function isArcCommand(code) {
  * Scans every character in the path string to determine
  * where a segment starts and where it ends.
  *
- * @param {SVGPC.parserPathArray} path the `parserPathArray` instance
+ * @param {svgpcNS.pathParser} path the `PathParser` instance
  */
 function scanSegment(path) {
   const { max, pathValue, index } = path;
@@ -326,29 +321,28 @@ function scanSegment(path) {
   finalizeSegment(path);
 }
 
-// @ts-nocheck
 /**
  * Returns a clone of an existing `pathArray`.
  *
- * @param {SVGPC.pathArray | string[]} path the source `pathArray`
- * @returns {SVGPC.pathArray} the cloned `pathArray`
+ * @param {svgpcNS.pathArray | any[] | string} path the source `pathArray`
+ * @returns {any} the cloned `pathArray`
  */
 function clonePath(path) {
-  return path.map((x) => {
+  return Array.isArray(path) ? path.map((x) => {
     if (Array.isArray(x)) {
       return clonePath(x);
     }
     return !Number.isNaN(+x) ? +x : x;
-  });
+  }) : path;
 }
 
 /**
- * The `parserPathArray` used by the parser.
+ * The `PathParser` used by the parser.
  *
  * @param {string} pathString
  */
-function SVGPathArray(pathString) {
-  /** @type {[string, ...number[]][]} */
+function PathParser(pathString) {
+  /** @type {svgpcNS.pathArray} */
   this.segments = [];
   /** @type {string} */
   this.pathValue = pathString;
@@ -369,7 +363,7 @@ function SVGPathArray(pathString) {
 /**
  * Iterates an array to check if it's an actual `pathArray`.
  *
- * @param {string | SVGPC.pathArray} path the `pathArray` to be checked
+ * @param {string | svgpcNS.pathArray} path the `pathArray` to be checked
  * @returns {boolean} iteration result
  */
 function isPathArray(path) {
@@ -383,16 +377,15 @@ function isPathArray(path) {
  * Parses a path string value and returns an array
  * of segments we like to call `pathArray`.
  *
- * @param {string | SVGPC.pathArray} pathInput the string to be parsed
- * @returns {SVGPC.pathArray} the resulted `pathArray`
+ * @param {svgpcNS.pathArray | string} pathInput the string to be parsed
+ * @returns {svgpcNS.pathArray} the resulted `pathArray`
  */
 function parsePathString(pathInput) {
   if (isPathArray(pathInput)) {
-    // @ts-ignore
     return clonePath(pathInput);
   }
-  // @ts-ignore
-  const path = new SVGPathArray(pathInput);
+
+  const path = new PathParser(`${pathInput}`); // TS expects string
 
   skipSpaces(path);
 
@@ -403,7 +396,7 @@ function parsePathString(pathInput) {
   if (path.err.length) {
     path.segments = [];
   } else if (path.segments.length) {
-    if ('mM'.indexOf(path.segments[0][0]) < 0) {
+    if (!'mM'.includes(path.segments[0][0])) {
       path.err = `${invalidPathValue}: missing M/m`;
       path.segments = [];
     } else {
@@ -418,7 +411,7 @@ function parsePathString(pathInput) {
  * Iterates an array to check if it's a `pathArray`
  * with all absolute values.
  *
- * @param {string | SVGPC.pathArray} path the `pathArray` to be checked
+ * @param {string | svgpcNS.pathArray} path the `pathArray` to be checked
  * @returns {boolean} iteration result
  */
 function isAbsoluteArray(path) {
@@ -430,17 +423,17 @@ function isAbsoluteArray(path) {
  * Parses a path string value or object and returns an array
  * of segments, all converted to absolute values.
  *
- * @param {string | SVGPC.pathArray} pathInput the path string | object
- * @returns {SVGPC.pathArray} the resulted `pathArray` with absolute values
+ * @param {svgpcNS.pathArray | string} pathInput the path string | object
+ * @returns {svgpcNS.pathArray} the resulted `pathArray` with absolute values
  */
 function pathToAbsolute(pathInput) {
-  if (Array.isArray(pathInput) && isAbsoluteArray(pathInput)) {
+  if (isAbsoluteArray(pathInput)) {
     return clonePath(pathInput);
   }
 
   const path = parsePathString(pathInput);
   const ii = path.length;
-  /** @type {SVGPC.pathArray} */
+  /** @type {svgpcNS.pathArray} */
   const resultArray = [];
   let x = 0;
   let y = 0;
@@ -461,6 +454,8 @@ function pathToAbsolute(pathInput) {
     const segment = path[i];
     const [pathCommand] = segment;
     const absCommand = pathCommand.toUpperCase();
+    /** @type {svgpcNS.pathSegment} */
+    // @ts-ignore -- trust me
     const absoluteSegment = [];
     let newSeg = [];
 
@@ -495,7 +490,7 @@ function pathToAbsolute(pathInput) {
         absoluteSegment.push(segment[j]);
       }
     }
-    // @ts-ignore
+
     resultArray.push(absoluteSegment);
 
     const segLength = absoluteSegment.length;
@@ -528,7 +523,7 @@ function pathToAbsolute(pathInput) {
  * Iterates an array to check if it's a `pathArray`
  * with relative values.
  *
- * @param {string | SVGPC.pathArray} path the `pathArray` to be checked
+ * @param {string | svgpcNS.pathArray} path the `pathArray` to be checked
  * @returns {boolean} iteration result
  */
 function isRelativeArray(path) {
@@ -540,17 +535,17 @@ function isRelativeArray(path) {
  * Parses a path string value or object and returns an array
  * of segments, all converted to relative values.
  *
- * @param {string | SVGPC.pathArray} pathInput the path string | object
- * @returns {SVGPC.pathArray} the resulted `pathArray` with relative values
+ * @param {string | svgpcNS.pathArray} pathInput the path string | object
+ * @returns {svgpcNS.pathArray} the resulted `pathArray` with relative values
  */
 function pathToRelative(pathInput) {
-  if (Array.isArray(pathInput) && isRelativeArray(pathInput)) {
+  if (isRelativeArray(pathInput)) {
     return clonePath(pathInput);
   }
 
   const path = parsePathString(pathInput);
   const ii = path.length;
-  /** @type {SVGPC.pathArray} */
+  /** @type {svgpcNS.pathArray} */
   const resultArray = [];
   let x = 0;
   let y = 0;
@@ -571,7 +566,9 @@ function pathToRelative(pathInput) {
     const segment = path[i];
     const [pathCommand] = segment;
     const relativeCommand = pathCommand.toLowerCase();
-    const relativeSegment = []; // this a test to please TS
+    /** @type {svgpcNS.pathSegment} */
+    // @ts-ignore -- trust me DON'T CHANGE
+    const relativeSegment = [];
     let newSeg = [];
 
     if (pathCommand !== relativeCommand) {
@@ -607,7 +604,6 @@ function pathToRelative(pathInput) {
         relativeSegment.push(segment[j]);
       }
     }
-    // @ts-ignore
     resultArray.push(relativeSegment);
 
     const segLength = relativeSegment.length;
@@ -635,39 +631,54 @@ function pathToRelative(pathInput) {
  * Rounds the values of a `pathArray` instance to
  * a specified amount of decimals and returns it.
  *
- * @param {SVGPC.pathArray} path the source `pathArray`
- * @param {null | number} round the amount of decimals to round numbers to
- * @returns {SVGPC.pathArray} the resulted `pathArray` with rounded values
+ * @param {svgpcNS.pathArray} path the source `pathArray`
+ * @param {number | boolean | null} round the amount of decimals to round numbers to
+ * @returns {svgpcNS.pathArray} the resulted `pathArray` with rounded values
  */
 function roundPath(path, round) {
   const { round: defaultRound, decimals: defaultDecimals } = SVGPCO;
   const decimalsOption = round && !Number.isNaN(+round) ? +round
     : defaultRound && defaultDecimals;
 
-  if (!decimalsOption) return clonePath(path);
+  if (round === false || (!defaultRound && !decimalsOption)) return clonePath(path);
 
-  // @ts-ignore
-  return path.map((seg) => seg.map((c) => {
-    const nr = +c;
-    const dc = 10 ** decimalsOption;
-    if (!Number.isNaN(nr)) {
-      return nr % 1 === 0 ? nr : Math.round(nr * dc) / dc;
+  const dc = 10 ** decimalsOption;
+  /** @type {svgpcNS.pathArray} */
+  const result = [];
+  const pl = path.length;
+  /** @type {svgpcNS.pathSegment} */
+  let segment;
+  /** @type {number} */
+  let n = 0;
+  let pi = [];
+
+  // FOR works best with TS
+  for (let i = 0; i < pl; i += 1) {
+    pi = path[i];
+    segment = [''];
+    for (let j = 0; j < pi.length; j += 1) {
+      if (!j) segment[j] = pi[j];
+      else {
+        n = +pi[j];
+        segment.push(!j || n % 1 === 0 ? n : Math.round(n * dc) / dc);
+      }
     }
-    return c;
-  }));
+    result.push(segment);
+  }
+  return result;
 }
 
 /**
  * Returns a valid `d` attribute string value created
  * by rounding values and concatenating the `pathArray` segments.
  *
- * @param {SVGPC.pathArray} path the `pathArray` object
- * @param {number | null} round amount of decimals to round values to
+ * @param {svgpcNS.pathArray} path the `pathArray` object
+ * @param {any} round amount of decimals to round values to
  * @returns {string} the concatenated path string
  */
 function pathToString(path, round) {
   return roundPath(path, round)
-    .map((x) => x[0].concat(x.slice(1).join(' '))).join('');
+    .map((x) => x[0] + (x.slice(1).join(' '))).join('');
 }
 
 /**
@@ -707,9 +718,9 @@ function shorthandToCubic(x1, y1, x2, y2, prevCommand) {
 /**
  * Normalizes a single segment of a `pathArray` object.
  *
- * @param {SVGPC.pathSegment} segment the segment object
+ * @param {svgpcNS.pathSegment} segment the segment object
  * @param {any} params the coordinates of the previous segment
- * @param {String} prevCommand the path command of the previous segment
+ * @param {string} prevCommand the path command of the previous segment
  * @returns {any} the normalized segment
  */
 function normalizeSegment(segment, params, prevCommand) {
@@ -717,7 +728,7 @@ function normalizeSegment(segment, params, prevCommand) {
   const xy = segment.slice(1);
   let result = segment.slice();
 
-  if ('TQ'.indexOf(segment[0]) < 0) {
+  if (!'TQ'.includes(segment[0])) {
     // optional but good to be cautious
     params.qx = null;
     params.qy = null;
@@ -750,7 +761,7 @@ function normalizeSegment(segment, params, prevCommand) {
  * with all segments are in non-shorthand notation
  * with absolute values.
  *
- * @param {string | SVGPC.pathArray} path the `pathArray` to be checked
+ * @param {string | svgpcNS.pathArray} path the `pathArray` to be checked
  * @returns {boolean} iteration result
  */
 function isNormalizedArray(path) {
@@ -765,8 +776,8 @@ function isNormalizedArray(path) {
  * * convert segments to absolute values
  * * convert shorthand path commands to their non-shorthand notation
  *
- * @param {string | SVGPC.pathArray} pathInput the string to be parsed or 'pathArray'
- * @returns {SVGPC.pathArray} the normalized `pathArray`
+ * @param {string | svgpcNS.pathArray} pathInput the string to be parsed or 'pathArray'
+ * @returns {svgpcNS.pathArray} the normalized `pathArray`
  */
 function normalizePath(pathInput) { // path|pathString
   if (Array.isArray(pathInput) && isNormalizedArray(pathInput)) {
@@ -779,13 +790,14 @@ function normalizePath(pathInput) { // path|pathString
   };
   const allPathCommands = [];
   const ii = path.length;
+  let pathCommand = '';
   let prevCommand = '';
   let segment;
   let seglen;
 
   for (let i = 0; i < ii; i += 1) {
     // save current path command
-    const [pathCommand] = path[i];
+    [pathCommand] = path[i];
 
     // Save current path command
     allPathCommands[i] = pathCommand;
@@ -809,8 +821,8 @@ function normalizePath(pathInput) { // path|pathString
  * Reverses all segments and their values of a `pathArray`
  * and returns a new instance.
  *
- * @param {SVGPC.pathArray} pathInput the source `pathArray`
- * @returns {SVGPC.pathArray} the reversed `pathArray`
+ * @param {svgpcNS.pathArray} pathInput the source `pathArray`
+ * @returns {svgpcNS.pathArray} the reversed `pathArray`
  */
 function reversePath(pathInput) {
   const absolutePath = pathToAbsolute(pathInput);
@@ -899,7 +911,7 @@ function reversePath(pathInput) {
  * In the process, values are converted to absolute
  * for visual consistency.
  *
- * @param {SVGPC.pathArray | string} pathInput the cubic-bezier parameters
+ * @param {svgpcNS.pathArray | string} pathInput the cubic-bezier parameters
  * @return {string[]} an array with all sub-path strings
  */
 function splitPath(pathInput) {
@@ -916,16 +928,19 @@ function splitPath(pathInput) {
  * * create a new `pathArray` with elements with shortest segments
  * from absolute and relative `pathArray`s
  *
- * @param {string | SVGPC.pathArray} pathInput a string or `pathArray`
+ * @param {string | svgpcNS.pathArray} pathInput a string or `pathArray`
  * @param {number | null} round the amount of decimals to round values to
- * @returns {SVGPC.pathArray} the optimized `pathArray`
+ * @returns {svgpcNS.pathArray} the optimized `pathArray`
  */
 function optimizePath(pathInput, round) {
   const absolutePath = roundPath(pathToAbsolute(pathInput), round);
   const relativePath = roundPath(pathToRelative(pathInput), round);
+
   return absolutePath.map((x, i) => {
     if (i) {
-      return x.join('').length < relativePath[i].join('').length ? x : relativePath[i];
+      return x.join('').length < relativePath[i].join('').length
+        ? x
+        : relativePath[i];
     }
     return x;
   });
@@ -934,7 +949,7 @@ function optimizePath(pathInput, round) {
 /**
  * A global namespace for epsilon.
  *
- * @type {Number}
+ * @type {number}
  */
 const epsilon = 1e-9;
 
@@ -1069,13 +1084,13 @@ function arcToCubic(X1, Y1, RX, RY, angle, LAF, SF, X2, Y2, recursive) {
 /**
  * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).
  *
- * @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 {Number} x2 curve end x
- * @param {Number} y2 curve end y
- * @returns {Number[]} the cubic-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 {number} x2 curve end x
+ * @param {number} y2 curve end y
+ * @returns {number[]} the cubic-bezier segment
  */
 function quadToCubic(x1, y1, qx, qy, x2, y2) {
   const r13 = 1 / 3;
@@ -1150,7 +1165,7 @@ 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
+  // @ts-ignore -- rest operator won't fix
   const cp1 = getPointAtSegLength.apply(0, p0.concat(p2, p4, p6, t));
   // @ts-ignore
   const cp2 = getPointAtSegLength.apply(0, p6.concat(p5, p3, p1, 0));
@@ -1161,12 +1176,12 @@ function lineToCubic(x1, y1, x2, y2) {
 /**
  * Converts any segment to C (cubic-bezier).
  *
- * @param {SVGPC.pathSegment} segment the source segment
- * @param {SVGPC.parserParams} params the source segment parameters
- * @returns {SVGPC.pathSegment} the cubic-bezier segment
+ * @param {svgpcNS.pathSegment} segment the source segment
+ * @param {svgpcNS.parserParams} params the source segment parameters
+ * @returns {svgpcNS.pathSegment} the cubic-bezier segment
  */
 function segmentToCubic(segment, params) {
-  if ('TQ'.indexOf(segment[0]) < 0) {
+  if (!'TQ'.includes(segment[0])) {
     params.qx = null;
     params.qy = null;
   }
@@ -1199,7 +1214,7 @@ function segmentToCubic(segment, params) {
 /**
  * Splits an extended A (arc-to) segment into two cubic-bezier segments.
  *
- * @param {SVGPC.pathArray} path the `pathArray` this segment belongs to
+ * @param {svgpcNS.pathArray} path the `pathArray` this segment belongs to
  * @param {string[]} allPathCommands all previous path commands
  * @param {Number} i the index of the segment
  */
@@ -1213,23 +1228,13 @@ function fixArc(path, allPathCommands, i) {
       // 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
+      // @ts-ignore -- cannot fix
       path.splice(ni += 1, 0, ['C'].concat(segment.splice(0, 6)));
     }
     path.splice(i, 1);
   }
 }
 
-var version$1 = "0.0.16alpha4";
-
-// @ts-ignore
-
-/**
- * A global namespace for library version.
- * @type {string}
- */
-const DMVersion = version$1;
-
 // DOMMatrix Static methods
 // * `fromFloat64Array` and `fromFloat32Array` methods are not supported;
 // * `fromArray` a more simple implementation, should also accept float[32/64]Array;
@@ -1291,25 +1296,25 @@ function fromArray(array) {
     m.m34 = m34;
     m.m44 = m44;
   } else if (a.length === 6) {
-    const [m11, m12, m21, m22, m41, m42] = a;
+    const [M11, M12, M21, M22, M41, M42] = a;
 
-    m.m11 = m11;
-    m.a = m11;
+    m.m11 = M11;
+    m.a = M11;
 
-    m.m12 = m12;
-    m.b = m12;
+    m.m12 = M12;
+    m.b = M12;
 
-    m.m21 = m21;
-    m.c = m21;
+    m.m21 = M21;
+    m.c = M21;
 
-    m.m22 = m22;
-    m.d = m22;
+    m.m22 = M22;
+    m.d = M22;
 
-    m.m41 = m41;
-    m.e = m41;
+    m.m41 = M41;
+    m.e = M41;
 
-    m.m42 = m42;
-    m.f = m42;
+    m.m42 = M42;
+    m.f = M42;
   } else {
     throw new TypeError('CSSMatrix: expecting an Array of 6/16 values.');
   }
@@ -1320,7 +1325,7 @@ function fromArray(array) {
  * Creates a new mutable `CSSMatrix` instance given an existing matrix or a
  * `DOMMatrix` instance which provides the values for its properties.
  *
- * @param {CSSMatrix | DOMMatrix | DMNS.jsonMatrix} m the source matrix to feed values from.
+ * @param {CSSMatrix | DOMMatrix | CSSMatrixNS.JSONMatrix} m the source matrix to feed values from.
  * @return {CSSMatrix} the resulted matrix.
  */
 function fromMatrix(m) {
@@ -1359,9 +1364,20 @@ function fromString(source) {
   }
   const str = String(source).replace(/\s/g, '');
   let m = new CSSMatrix();
+  const invalidStringError = `CSSMatrix: invalid transform string "${source}"`;
   let is2D = true;
+  // const transformFunctions = [
+  //   'matrix', 'matrix3d', 'perspective', 'translate3d',
+  //   'translate', 'translateX', 'translateY', 'translateZ',
+  //   'rotate', 'rotate3d', 'rotateX', 'rotateY', 'rotateZ',
+  //   'scale', 'scale3d', 'skewX', 'skewY'];
   const tramsformObject = str.split(')').filter((f) => f).map((fn) => {
     const [prop, value] = fn.split('(');
+    if (!value) {
+      // invalidate
+      throw TypeError(invalidStringError);
+    }
+
     const components = value.split(',')
       .map((n) => (n.includes('rad') ? parseFloat(n) * (180 / Math.PI) : parseFloat(n)));
     const [x, y, z, a] = components;
@@ -1421,6 +1437,8 @@ function fromString(source) {
         // @ts-ignore unfortunately
         m = m[fn](...axeValues);
       }
+    } else {
+      throw TypeError(invalidStringError);
     }
   });
 
@@ -1711,7 +1729,7 @@ class CSSMatrix {
   /**
    * Sets a new `Boolean` flag value for `this.isIdentity` matrix property.
    *
-   * @param {Boolean} value sets a new flag for this property
+   * @param {boolean} value sets a new flag for this property
    */
   set isIdentity(value) {
     this.isIdentity = value;
@@ -1722,7 +1740,7 @@ class CSSMatrix {
    * matrix is one in which every value is 0 except those on the main diagonal from top-left
    * to bottom-right corner (in other words, where the offsets in each direction are equal).
    *
-   * @return {Boolean} the current property value
+   * @return {boolean} the current property value
    */
   get isIdentity() {
     const m = this;
@@ -1736,7 +1754,7 @@ class CSSMatrix {
    * A `Boolean` flag whose value is `true` if the matrix was initialized as a 2D matrix
    * and `false` if the matrix is 3D.
    *
-   * @return {Boolean} the current property value
+   * @return {boolean} the current property value
    */
   get is2D() {
     const m = this;
@@ -1746,7 +1764,7 @@ class CSSMatrix {
   /**
    * Sets a new `Boolean` flag value for `this.is2D` matrix property.
    *
-   * @param {Boolean} value sets a new flag for this property
+   * @param {boolean} value sets a new flag for this property
    */
   set is2D(value) {
     this.is2D = value;
@@ -1833,7 +1851,7 @@ class CSSMatrix {
    * The result can also be used as a second parameter for the `fromMatrix` static method
    * to load values into a matrix instance.
    *
-   * @return {DMNS.jsonMatrix} an *Object* with all matrix values.
+   * @return {CSSMatrixNS.JSONMatrix} an *Object* with all matrix values.
    */
   toJSON() {
     return JSON.parse(JSON.stringify(this));
@@ -1844,7 +1862,7 @@ class CSSMatrix {
    * matrix multiplied by the passed matrix, with the passed matrix to the right.
    * This matrix is not modified.
    *
-   * @param {CSSMatrix | DOMMatrix | DMNS.jsonMatrix} m2 CSSMatrix
+   * @param {CSSMatrix | DOMMatrix | CSSMatrixNS.JSONMatrix} m2 CSSMatrix
    * @return {CSSMatrix} The resulted matrix.
    */
   multiply(m2) {
@@ -1965,8 +1983,8 @@ class CSSMatrix {
    *
    * @copyright thednp © 2021
    *
-   * @param {DMNS.PointTuple | DOMPoint} v Tuple or DOMPoint
-   * @return {DMNS.PointTuple} the resulting Tuple
+   * @param {CSSMatrixNS.PointTuple | DOMPoint} v Tuple or DOMPoint
+   * @return {CSSMatrixNS.PointTuple} the resulting Tuple
    */
   transformPoint(v) {
     const M = this;
@@ -1988,8 +2006,8 @@ class CSSMatrix {
    * {x,y,z,w} Tuple *Object* comprising the transformed vector.
    * Neither the matrix nor the original vector are altered.
    *
-   * @param {DMNS.PointTuple} t Tuple with `{x,y,z,w}` components
-   * @return {DMNS.PointTuple} the resulting Tuple
+   * @param {CSSMatrixNS.PointTuple} t Tuple with `{x,y,z,w}` components
+   * @return {CSSMatrixNS.PointTuple} the resulting Tuple
    */
   transform(t) {
     const m = this;
@@ -2018,19 +2036,18 @@ CSSMatrix.Multiply = Multiply;
 CSSMatrix.fromArray = fromArray;
 CSSMatrix.fromMatrix = fromMatrix;
 CSSMatrix.fromString = fromString;
-CSSMatrix.Version = DMVersion;
 
 /**
  * Returns a transformation matrix to apply to `<path>` elements.
  *
- * @param {SVGPC.transformObject} transform the `transformObject`
+ * @param {svgpcNS.transformObject} transform the `transformObject`
  * @returns {CSSMatrix} a new transformation matrix
  */
 function getSVGMatrix(transform) {
   let matrix = new CSSMatrix();
   const { origin } = transform;
-  const originX = +origin[0];
-  const originY = +origin[1];
+  const originX = origin[0];
+  const originY = origin[1];
   const { translate } = transform;
   const { rotate } = transform;
   const { skew } = transform;
@@ -2040,22 +2057,20 @@ 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);
+      : matrix.translate(+translate || 0, 0, 0);
   }
 
   if (rotate || skew || scale) {
     // set SVG transform-origin, always defined
     // matrix = matrix.translate(+originX,+originY,+originZ)
-    // @ts-ignore
+    // @ts-ignore -- SVG transform origin is always 2D
     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);
+        : matrix.rotate(0, 0, +rotate || 0);
     }
     // set skew(s)
     if (Array.isArray(skew) && skew.some((x) => +x !== 0)) {
@@ -2070,12 +2085,11 @@ 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);
+        : matrix.scale(+scale || 1, +scale || 1, +scale || 1);
     }
     // set SVG transform-origin
     // matrix = matrix.translate(-originX,-originY,-originZ)
-    // @ts-ignore
+    // @ts-ignore -- SVG transform origin is always 2D
     matrix = matrix.translate(-originX, -originY);
   }
   return matrix;
@@ -2162,7 +2176,7 @@ function transformEllipse(m, rx, ry, ax) {
  * Details =>
  * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel
  *
- * @param {SVGPC.CSSMatrix} m the transformation matrix
+ * @param {svgpcNS.CSSMatrix} m the transformation matrix
  * @param {Number[]} point2D the initial [x,y] coordinates
  * @param {number[]} origin the initial [x,y] coordinates
  * @returns {Number[]} the projected [x,y] coordinates
@@ -2190,9 +2204,9 @@ function projection2d(m, point2D, origin) {
  * Since *SVGElement* doesn't support 3D transformation, this function
  * creates a 2D projection of the <path> element.
  *
- * @param {SVGPC.pathArray} path the `pathArray` to apply transformation
+ * @param {svgpcNS.pathArray} path the `pathArray` to apply transformation
  * @param {any} transform the transform functions `Object`
- * @returns {SVGPC.pathArray} the resulted `pathArray`
+ * @returns {svgpcNS.pathArray} the resulted `pathArray`
  */
 function transformPath(path, transform) {
   let x = 0; let y = 0; let i; let j; let ii; let jj; let lx; let ly; let te;
@@ -2324,7 +2338,7 @@ function transformPath(path, transform) {
  * @param {number} c2y the second control point Y
  * @param {number} p2x the ending point X
  * @param {number} p2y the ending point Y
- * @returns {SVGPC.segmentLimits} the length of the cubic-bezier segment
+ * @returns {svgpcNS.segmentLimits} the length of the cubic-bezier segment
  */
 function getCubicSize(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {
   let a = (c2x - 2 * c1x + p1x) - (p2x - 2 * c2x + c1x);
@@ -2380,7 +2394,7 @@ function getCubicSize(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {
  * Iterates an array to check if it's a `pathArray`
  * with all C (cubic bezier) segments.
  *
- * @param {string | SVGPC.pathArray} path the `Array` to be checked
+ * @param {string | svgpcNS.pathArray} path the `Array` to be checked
  * @returns {boolean} iteration result
  */
 function isCurveArray(path) {
@@ -2392,11 +2406,11 @@ function isCurveArray(path) {
  * Parses a path string value or 'pathArray' and returns a new one
  * in which all segments are converted to cubic-bezier.
  *
- * @param {string | SVGPC.pathArray} pathInput the string to be parsed or object
- * @returns {SVGPC.pathArray} the resulted `pathArray` converted to cubic-bezier
+ * @param {string | svgpcNS.pathArray} pathInput the string to be parsed or object
+ * @returns {svgpcNS.pathArray} the resulted `pathArray` converted to cubic-bezier
  */
 function pathToCurve(pathInput) {
-  if (Array.isArray(pathInput) && isCurveArray(pathInput)) {
+  if (isCurveArray(pathInput)) {
     return clonePath(pathInput);
   }
 
@@ -2404,15 +2418,15 @@ function pathToCurve(pathInput) {
   const params = {
     x1: 0, y1: 0, x2: 0, y2: 0, x: 0, y: 0, qx: null, qy: null,
   };
+  /** @type {string[]} */
   const allPathCommands = [];
-  let pathCommand = '';
+  let pathCommand = ''; // ts-lint
   let ii = path.length;
 
   for (let i = 0; i < ii; i += 1) {
     const segment = path[i];
     const seglen = segment.length;
     if (segment) [pathCommand] = segment;
-
     allPathCommands[i] = pathCommand;
     path[i] = segmentToCubic(segment, params);
 
@@ -2431,8 +2445,8 @@ function pathToCurve(pathInput) {
 /**
  * Returns the bounding box of a shape.
  *
- * @param {SVGPC.pathArray} path the shape `pathArray`
- * @returns {SVGPC.pathBBox} the length of the cubic-bezier segment
+ * @param {svgpcNS.pathArray} path the shape `pathArray`
+ * @returns {svgpcNS.pathBBox} the length of the cubic-bezier segment
  */
 function getPathBBox(path) {
   if (!path) {
@@ -2513,7 +2527,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`
+ * @param {svgpcNS.pathArray} path the shape `pathArray`
  * @returns {number} the length of the cubic-bezier segment
  */
 function getPathArea(path) {
@@ -2524,8 +2538,8 @@ function getPathArea(path) {
     switch (seg[0]) {
       case 'M':
       case 'Z':
-        mx = seg[0] === 'M' ? seg[1] : mx;
-        my = seg[0] === 'M' ? seg[2] : my;
+        // @ts-ignore
+        mx = seg[0] === 'M' ? seg[1] : mx; my = seg[0] === 'M' ? seg[2] : my;
         x = mx;
         y = my;
         return 0;
@@ -2597,7 +2611,7 @@ function getSegCubicLength(x1, y1, x2, y2, x3, y3, x4, y4, z) {
  * or the equivalent to `shape.getTotalLength()`
  * pathToCurve version
  *
- * @param {SVGPC.pathArray} path the ending point Y
+ * @param {svgpcNS.pathArray} path the ending point Y
  * @returns {number} the shape total length
  */
 function getPathLength(path) {
@@ -2614,7 +2628,7 @@ function getPathLength(path) {
  * Check if a path is drawn clockwise and returns true if so,
  * false otherwise.
  *
- * @param {string | SVGPC.pathArray} path the path string or `pathArray`
+ * @param {string | svgpcNS.pathArray} path the path string or `pathArray`
  * @returns {boolean} true when clockwise or false if not
  */
 function getDrawDirection(path) {
@@ -2624,7 +2638,7 @@ 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 {string | svgpcNS.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
  */
@@ -2665,7 +2679,7 @@ function isValidPath(pathString) {
     return false;
   }
 
-  const path = new SVGPathArray(pathString);
+  const path = new PathParser(pathString);
 
   skipSpaces(path);
 
@@ -2678,6 +2692,7 @@ function isValidPath(pathString) {
 
 /**
  * Supported shapes and their specific parameters.
+ * @type {Object.<string, string[]>}
  */
 const shapeParams = {
   circle: ['cx', 'cy', 'r'],
@@ -2691,8 +2706,8 @@ const shapeParams = {
 /**
  * Returns a new `pathArray` from line attributes.
  *
- * @param {SVGPC.lineAttr} attr shape configuration
- * @return {SVGPC.pathArray} a new line `pathArray`
+ * @param {svgpcNS.lineAttr} attr shape configuration
+ * @return {svgpcNS.pathArray} a new line `pathArray`
  */
 function getLinePath(attr) {
   const {
@@ -2704,11 +2719,11 @@ function getLinePath(attr) {
 /**
  * Returns a new `pathArray` like from polyline/polygon attributes.
  *
- * @param {SVGPC.polyAttr} attr shape configuration
- * @return {SVGPC.pathArray} a new polygon/polyline `pathArray`
+ * @param {svgpcNS.polyAttr} attr shape configuration
+ * @return {svgpcNS.pathArray} a new polygon/polyline `pathArray`
  */
 function getPolyPath(attr) {
-  /** @type {SVGPC.pathArray} */
+  /** @type {svgpcNS.pathArray} */
   const pathArray = [];
   const points = attr.points.split(/[\s|,]/).map(Number);
 
@@ -2724,8 +2739,8 @@ function getPolyPath(attr) {
 /**
  * Returns a new `pathArray` from circle attributes.
  *
- * @param {SVGPC.circleAttr} attr shape configuration
- * @return {SVGPC.pathArray} a circle `pathArray`
+ * @param {svgpcNS.circleAttr} attr shape configuration
+ * @return {svgpcNS.pathArray} a circle `pathArray`
  */
 function getCirclePath(attr) {
   const {
@@ -2742,8 +2757,8 @@ function getCirclePath(attr) {
 /**
  * Returns a new `pathArray` from ellipse attributes.
  *
- * @param {SVGPC.ellipseAttr} attr shape configuration
- * @return {SVGPC.pathArray} an ellipse `pathArray`
+ * @param {svgpcNS.ellipseAttr} attr shape configuration
+ * @return {svgpcNS.pathArray} an ellipse `pathArray`
  */
 function getEllipsePath(attr) {
   const {
@@ -2760,8 +2775,8 @@ function getEllipsePath(attr) {
 /**
  * Returns a new `pathArray` like from rect attributes.
  *
- * @param {SVGPC.rectAttr} attr object with properties above
- * @return {SVGPC.pathArray} a new `pathArray` from `<rect>` attributes
+ * @param {svgpcNS.rectAttr} attr object with properties above
+ * @return {svgpcNS.pathArray} a new `pathArray` from `<rect>` attributes
  */
 function getRectanglePath(attr) {
   const x = +attr.x || 0;
@@ -2809,7 +2824,7 @@ function getRectanglePath(attr) {
  * The newly created `<path>` element keeps all non-specific
  * attributes like `class`, `fill`, etc.
  *
- * @param {SVGPC.shapeTypes} element target shape
+ * @param {svgpcNS.shapeTypes} element target shape
  * @param {boolean} replace option to replace target
  * @return {?SVGPathElement} the newly created `<path>` element
  */
@@ -2822,13 +2837,13 @@ function shapeToPath(element, replace) {
 
   const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
   const type = element.tagName;
-  /** @ts-ignore */
   const shapeAttrs = shapeParams[type];
-
-  // set config
+  /** set config
+   * @type {any}
+   */
   const config = {};
   config.type = type;
-  /** @ts-ignore */
+
   shapeAttrs.forEach((p) => { config[p] = element.getAttribute(p); });
 
   // set no-specific shape attributes: fill, stroke, etc
@@ -2838,16 +2853,14 @@ 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));
+  const { round, decimals } = SVGPCO;
+  const rounding = round && decimals ? decimals : null;
+
+  if (type === 'circle') description = pathToString(getCirclePath(config), rounding);
+  else if (type === 'ellipse') description = pathToString(getEllipsePath(config), rounding);
+  else if (['polyline', 'polygon'].includes(type)) description = pathToString(getPolyPath(config), rounding);
+  else if (type === 'rect') description = pathToString(getRectanglePath(config), rounding);
+  else if (type === 'line') description = pathToString(getLinePath(config), rounding);
   else if (type === 'glyph') description = element.getAttribute('d');
 
   // replace target element
@@ -2866,8 +2879,8 @@ function shapeToPath(element, replace) {
  * Reverses all segments and their values from a `pathArray`
  * which consists of only C (cubic-bezier) path commands.
  *
- * @param {SVGPC.pathArray} path the source `pathArray`
- * @returns {SVGPC.pathArray} the reversed `pathArray`
+ * @param {svgpcNS.pathArray} path the source `pathArray`
+ * @returns {svgpcNS.pathArray} the reversed `pathArray`
  */
 function reverseCurve(path) {
   const rotatedCurve = path.slice(1)
@@ -2883,7 +2896,7 @@ function reverseCurve(path) {
     .concat(rotatedCurve.map((x) => ['C'].concat(x.slice(2))));
 }
 
-var version = "0.1.10alpha3";
+var version = "0.1.10";
 
 // @ts-ignore
 
@@ -2925,8 +2938,6 @@ const Util = {
   Version,
 };
 
-// import isPathArray from './util/isPathArray';
-
 /**
  * Creates a new SVGPathCommander instance.
  *
@@ -2948,13 +2959,13 @@ class SVGPathCommander {
       round = 0;
     }
 
-    const { decimals } = round && (options || SVGPCO);
+    const { decimals } = round ? (options || SVGPCO) : { decimals: false };
 
     // set instance options
-    this.round = round === 0 ? 0 : decimals;
+    this.round = decimals;
     // ZERO | FALSE will disable rounding numbers
 
-    /** @type {SVGPC.pathArray} */
+    /** @type {svgpcNS.pathArray} */
     this.segments = parsePathString(pathValue);
 
     /** * @type {string} */
@@ -2994,20 +3005,21 @@ class SVGPathCommander {
     const { segments } = this;
     const split = splitPath(this.toString());
     const subPath = split.length > 1 ? split : 0;
+    /**
+     * @param {svgpcNS.pathArray} x
+     * @param {number} i
+     */
+    const reverser = (x, i) => {
+      if (onlySubpath) {
+        return i ? reversePath(x) : parsePathString(x);
+      }
+      return reversePath(x);
+    };
 
-    const absoluteMultiPath = subPath && clonePath(subPath)
-      .map((x, i) => {
-        if (onlySubpath) {
-          // @ts-ignore
-          return i ? reversePath(x) : parsePathString(x);
-        }
-        // @ts-ignore
-        return reversePath(x);
-      });
+    const absoluteMultiPath = subPath && clonePath(subPath).map(reverser);
 
     let path = [];
     if (subPath) {
-      // @ts-ignore
       path = absoluteMultiPath.flat(1);
     } else {
       path = onlySubpath ? segments : reversePath(segments);
@@ -3045,7 +3057,7 @@ class SVGPathCommander {
 
   /**
    * Transform path using values from an `Object` defined as `transformObject`.
-   * @see SVGPC.transformObject for a quick refference
+   * @see svgpcNS.transformObject for a quick refference
    *
    * @param {Object.<string, (number | number[])>} source a `transformObject`as described above
    * @public
@@ -3061,7 +3073,7 @@ class SVGPathCommander {
     // it's important that we have one
     if (!transform.origin) {
       const BBox = getPathBBox(segments);
-      transform.origin = [BBox.cx, BBox.cy, BBox.cx];
+      transform.origin = [+BBox.cx, +BBox.cy];
     }
 
     this.segments = transformPath(segments, transform);