svg-path-commander 0.1.23 → 0.2.0-alpha1

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

@@ -1,11 +1,11 @@
 /*!
-* SVGPathCommander v0.1.23 (http://thednp.github.io/svg-path-commander)
-* Copyright 2021 © thednp
+* SVGPathCommander v0.2.0alpha1 (http://thednp.github.io/svg-path-commander)
+* Copyright 2022 © thednp
 * Licensed under MIT (https://github.com/thednp/svg-path-commander/blob/master/LICENSE)
 */
 /**
  * SVGPathCommander default options
- * @type {SVGPathCommander.options}
+ * @type {SVGPath.options}
  */
 const defaultOptions = {
   origin: [0, 0, 0],
@@ -23,7 +23,7 @@ const paramsCount = {
 /**
  * Breaks the parsing of a pathString once a segment is finalized.
  *
- * @param {SVGPathCommander.PathParser} path the `PathParser` instance
+ * @param {SVGPath.PathParser} path the `PathParser` instance
  */
 function finalizeSegment(path) {
   let pathCommand = path.pathValue[path.segmentStart];
@@ -51,13 +51,13 @@ function finalizeSegment(path) {
   }
 }
 
-const invalidPathValue = 'Invalid path value';
+const error = 'SVGPathCommander error';
 
 /**
  * Validates an A (arc-to) specific path command value.
  * Usually a `large-arc-flag` or `sweep-flag`.
  *
- * @param {SVGPathCommander.PathParser} path the `PathParser` instance
+ * @param {SVGPath.PathParser} path the `PathParser` instance
  */
 function scanFlag(path) {
   const { index } = path;
@@ -75,7 +75,7 @@ function scanFlag(path) {
     return;
   }
 
-  path.err = `${invalidPathValue}: invalid Arc flag "${ch}", expecting 0 or 1 at index ${index}`;
+  path.err = `${error}: invalid Arc flag "${ch}", expecting 0 or 1 at index ${index}`;
 }
 
 /**
@@ -88,11 +88,13 @@ function isDigit(code) {
   return (code >= 48 && code <= 57); // 0..9
 }
 
+const invalidPathValue = 'Invalid path value';
+
 /**
  * Validates every character of the path string,
  * every path command, negative numbers or floating point numbers.
  *
- * @param {SVGPathCommander.PathParser} path the `PathParser` instance
+ * @param {SVGPath.PathParser} path the `PathParser` instance
  */
 function scanParam(path) {
   const { max, pathValue, index: start } = path;
@@ -105,7 +107,7 @@ function scanParam(path) {
 
   if (index >= max) {
     // path.err = 'SvgPath: missed param (at pos ' + index + ')';
-    path.err = `${invalidPathValue} at ${index}: missing param ${pathValue[index]}`;
+    path.err = `${error}: ${invalidPathValue} at index ${index}, "pathValue" is missing param`;
     return;
   }
   ch = pathValue.charCodeAt(index);
@@ -119,7 +121,7 @@ function scanParam(path) {
   // https://github.com/ariya/esprimas
   if (!isDigit(ch) && ch !== 0x2E/* . */) {
     // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';
-    path.err = `${invalidPathValue} at index ${index}: ${pathValue[index]} is not a number`;
+    path.err = `${error}: ${invalidPathValue} at index ${index}, "${pathValue[index]}" is not a number`;
     return;
   }
 
@@ -134,7 +136,7 @@ function scanParam(path) {
       if (ch && isDigit(ch)) {
         // path.err = 'SvgPath: numbers started with `0` such as `09`
         // are illegal (at pos ' + start + ')';
-        path.err = `${invalidPathValue} at index ${start}: ${pathValue[start]} illegal number`;
+        path.err = `${error}: ${invalidPathValue} at index ${start}, "${pathValue[start]}" illegal number`;
         return;
       }
     }
@@ -158,7 +160,7 @@ function scanParam(path) {
 
   if (ch === 0x65/* e */ || ch === 0x45/* E */) {
     if (hasDot && !hasCeiling && !hasDecimal) {
-      path.err = `${invalidPathValue} at index ${index}: ${pathValue[index]} invalid float exponent`;
+      path.err = `${error}: ${invalidPathValue} at index ${index}, "${pathValue[index]}" invalid float exponent`;
       return;
     }
 
@@ -174,7 +176,7 @@ function scanParam(path) {
       }
     } else {
       // path.err = 'SvgPath: invalid float exponent (at pos ' + index + ')';
-      path.err = `${invalidPathValue} at index ${index}: ${pathValue[index]} invalid float exponent`;
+      path.err = `${error}: ${invalidPathValue} at index ${index}: "${pathValue[index]}" invalid float exponent`;
       return;
     }
   }
@@ -196,7 +198,7 @@ function isSpace(ch) {
   return (ch === 0x0A) || (ch === 0x0D) || (ch === 0x2028) || (ch === 0x2029) // Line terminators
     // White spaces
     || (ch === 0x20) || (ch === 0x09) || (ch === 0x0B) || (ch === 0x0C) || (ch === 0xA0)
-    || (ch >= 0x1680 && specialSpaces.indexOf(ch) >= 0);
+    || (ch >= 0x1680 && specialSpaces.includes(ch));
 }
 
 /**
@@ -204,7 +206,7 @@ function isSpace(ch) {
  * path string every time it encounters any kind of
  * space character.
  *
- * @param {SVGPathCommander.PathParser} path the `PathParser` instance
+ * @param {SVGPath.PathParser} path the `PathParser` instance
  */
 function skipSpaces(path) {
   const { pathValue, max } = path;
@@ -268,7 +270,7 @@ function isArcCommand(code) {
  * Scans every character in the path string to determine
  * where a segment starts and where it ends.
  *
- * @param {SVGPathCommander.PathParser} path the `PathParser` instance
+ * @param {SVGPath.PathParser} path the `PathParser` instance
  */
 function scanSegment(path) {
   const { max, pathValue, index } = path;
@@ -278,7 +280,7 @@ function scanSegment(path) {
   path.segmentStart = index;
 
   if (!isPathCommand(cmdCode)) {
-    path.err = `${invalidPathValue}: ${pathValue[index]} not a path command`;
+    path.err = `${error}: ${invalidPathValue} "${pathValue[index]}" is not a path command`;
     return;
   }
 
@@ -328,7 +330,7 @@ function scanSegment(path) {
 /**
  * Returns a clone of an existing `pathArray`.
  *
- * @param {SVGPathCommander.pathArray | SVGPathCommander.pathSegment} path the source `pathArray`
+ * @param {SVGPath.pathArray | SVGPath.pathSegment} path the source `pathArray`
  * @returns {any} the cloned `pathArray`
  */
 function clonePath(path) {
@@ -342,7 +344,7 @@ function clonePath(path) {
  * @param {string} pathString
  */
 function PathParser(pathString) {
-  /** @type {SVGPathCommander.pathArray} */
+  /** @type {SVGPath.pathArray} */
   // @ts-ignore
   this.segments = [];
   /** @type {string} */
@@ -364,7 +366,7 @@ function PathParser(pathString) {
 /**
  * Iterates an array to check if it's an actual `pathArray`.
  *
- * @param {string | SVGPathCommander.pathArray} path the `pathArray` to be checked
+ * @param {string | SVGPath.pathArray} path the `pathArray` to be checked
  * @returns {boolean} iteration result
  */
 function isPathArray(path) {
@@ -378,8 +380,8 @@ function isPathArray(path) {
  * Parses a path string value and returns an array
  * of segments we like to call `pathArray`.
  *
- * @param {SVGPathCommander.pathArray | string} pathInput the string to be parsed
- * @returns {SVGPathCommander.pathArray} the resulted `pathArray`
+ * @param {SVGPath.pathArray | string} pathInput the string to be parsed
+ * @returns {SVGPath.pathArray | string} the resulted `pathArray`
  */
 function parsePathString(pathInput) {
   if (isPathArray(pathInput)) {
@@ -396,27 +398,22 @@ function parsePathString(pathInput) {
     scanSegment(path);
   }
 
-  if (path.err.length) {
-    // @ts-ignore
-    path.segments = [];
-  } else if (path.segments.length) {
+  if (!path.err.length) {
     if (!'mM'.includes(path.segments[0][0])) {
-      path.err = `${invalidPathValue}: missing M/m`;
-      // @ts-ignore
-      path.segments = [];
+      path.err = `${error}: missing M/m`;
     } else {
       path.segments[0][0] = 'M';
     }
   }
 
-  return path.segments;
+  return path.err ? path.err : path.segments;
 }
 
 /**
  * Iterates an array to check if it's a `pathArray`
  * with all absolute values.
  *
- * @param {string | SVGPathCommander.pathArray} path the `pathArray` to be checked
+ * @param {string | SVGPath.pathArray} path the `pathArray` to be checked
  * @returns {boolean} iteration result
  */
 function isAbsoluteArray(path) {
@@ -429,8 +426,8 @@ function isAbsoluteArray(path) {
  * Parses a path string value or object and returns an array
  * of segments, all converted to absolute values.
  *
- * @param {string | SVGPathCommander.pathArray} pathInput the path string | object
- * @returns {SVGPathCommander.absoluteArray} the resulted `pathArray` with absolute values
+ * @param {string | SVGPath.pathArray} pathInput the path string | object
+ * @returns {SVGPath.absoluteArray} the resulted `pathArray` with absolute values
  */
 function pathToAbsolute(pathInput) {
   if (isAbsoluteArray(pathInput)) {
@@ -446,7 +443,7 @@ function pathToAbsolute(pathInput) {
   return path.map((segment) => {
     const values = segment.slice(1).map(Number);
     const [pathCommand] = segment;
-    /** @type {SVGPathCommander.absoluteCommand} */
+    /** @type {SVGPath.absoluteCommand} */
     // @ts-ignore
     const absCommand = pathCommand.toUpperCase();
 
@@ -456,7 +453,7 @@ function pathToAbsolute(pathInput) {
       my = y;
       return ['M', x, y];
     }
-    /** @type {SVGPathCommander.absoluteSegment} */
+    /** @type {SVGPath.absoluteSegment} */
     // @ts-ignore
     let absoluteSegment = [];
 
@@ -519,7 +516,7 @@ function pathToAbsolute(pathInput) {
  * Iterates an array to check if it's a `pathArray`
  * with relative values.
  *
- * @param {string | SVGPathCommander.pathArray} path the `pathArray` to be checked
+ * @param {string | SVGPath.pathArray} path the `pathArray` to be checked
  * @returns {boolean} iteration result
  */
 function isRelativeArray(path) {
@@ -532,8 +529,8 @@ function isRelativeArray(path) {
  * Parses a path string value or object and returns an array
  * of segments, all converted to relative values.
  *
- * @param {string | SVGPathCommander.pathArray} pathInput the path string | object
- * @returns {SVGPathCommander.relativeArray} the resulted `pathArray` with relative values
+ * @param {string | SVGPath.pathArray} pathInput the path string | object
+ * @returns {SVGPath.relativeArray} the resulted `pathArray` with relative values
  */
 function pathToRelative(pathInput) {
   if (isRelativeArray(pathInput)) {
@@ -549,7 +546,7 @@ function pathToRelative(pathInput) {
   return path.map((segment) => {
     const values = segment.slice(1).map(Number);
     const [pathCommand] = segment;
-    /** @type {SVGPathCommander.relativeCommand} */
+    /** @type {SVGPath.relativeCommand} */
     // @ts-ignore
     const relativeCommand = pathCommand.toLowerCase();
 
@@ -560,7 +557,7 @@ function pathToRelative(pathInput) {
       return ['M', x, y];
     }
 
-    /** @type {SVGPathCommander.relativeSegment} */
+    /** @type {SVGPath.relativeSegment} */
     // @ts-ignore -- trust me DON'T CHANGE
     let relativeSegment = [];
 
@@ -627,7 +624,7 @@ function pathToRelative(pathInput) {
 /**
  * Splits an extended A (arc-to) segment into two cubic-bezier segments.
  *
- * @param {SVGPathCommander.pathArray} path the `pathArray` this segment belongs to
+ * @param {SVGPath.pathArray} path the `pathArray` this segment belongs to
  * @param {string[]} allPathCommands all previous path commands
  * @param {number} i the segment index
  */
@@ -684,10 +681,10 @@ function shorthandToCubic(x1, y1, x2, y2, prevCommand) {
 /**
  * Normalizes a single segment of a `pathArray` object.
  *
- * @param {SVGPathCommander.pathSegment} segment the segment object
+ * @param {SVGPath.pathSegment} segment the segment object
  * @param {any} params the coordinates of the previous segment
  * @param {string} prevCommand the path command of the previous segment
- * @returns {SVGPathCommander.normalSegment} the normalized segment
+ * @returns {SVGPath.normalSegment} the normalized segment
  */
 function normalizeSegment(segment, params, prevCommand) {
   const [pathCommand] = segment;
@@ -734,7 +731,7 @@ function normalizeSegment(segment, params, prevCommand) {
  * with all segments are in non-shorthand notation
  * with absolute values.
  *
- * @param {string | SVGPathCommander.pathArray} path the `pathArray` to be checked
+ * @param {string | SVGPath.pathArray} path the `pathArray` to be checked
  * @returns {boolean} iteration result
  */
 function isNormalizedArray(path) {
@@ -743,7 +740,7 @@ function isNormalizedArray(path) {
 }
 
 /**
- * @type {SVGPathCommander.parserParams}
+ * @type {SVGPath.parserParams}
  */
 const paramsParser = {
   x1: 0, y1: 0, x2: 0, y2: 0, x: 0, y: 0, qx: null, qy: null,
@@ -754,8 +751,8 @@ const paramsParser = {
  * * convert segments to absolute values
  * * convert shorthand path commands to their non-shorthand notation
  *
- * @param {string | SVGPathCommander.pathArray} pathInput the string to be parsed or 'pathArray'
- * @returns {SVGPathCommander.normalArray} the normalized `pathArray`
+ * @param {string | SVGPath.pathArray} pathInput the string to be parsed or 'pathArray'
+ * @returns {SVGPath.normalArray} the normalized `pathArray`
  */
 function normalizePath(pathInput) {
   if (isNormalizedArray(pathInput)) {
@@ -763,7 +760,7 @@ function normalizePath(pathInput) {
     return clonePath(pathInput);
   }
 
-  /** @type {SVGPathCommander.normalArray} */
+  /** @type {SVGPath.normalArray} */
   // @ts-ignore -- `absoluteArray` will become a `normalArray`
   const path = pathToAbsolute(pathInput);
   const params = { ...paramsParser };
@@ -804,8 +801,8 @@ function normalizePath(pathInput) {
  * use `splitPath` first and apply this utility on each
  * sub-path separately.
  *
- * @param {SVGPathCommander.pathArray | string} pathInput the `pathArray` source
- * @return {SVGPathCommander.pathArray} a fixed `pathArray`
+ * @param {SVGPath.pathArray | string} pathInput the `pathArray` source
+ * @return {SVGPath.pathArray} a fixed `pathArray`
  */
 function fixPath(pathInput) {
   const pathArray = parsePathString(pathInput);
@@ -828,7 +825,7 @@ function fixPath(pathInput) {
  * Iterates an array to check if it's a `pathArray`
  * with all C (cubic bezier) segments.
  *
- * @param {string | SVGPathCommander.pathArray} path the `Array` to be checked
+ * @param {string | SVGPath.pathArray} path the `Array` to be checked
  * @returns {boolean} iteration result
  */
 function isCurveArray(path) {
@@ -1017,7 +1014,7 @@ function distanceSquareRoot(a, b) {
 }
 
 /**
- * Returns the length of a line (L,V,H,Z) segment,
+ * Returns the length of a line (L,V,H,Z) segment
  * or a point at a given length.
  *
  * @param {number} x1 the starting point X
@@ -1035,7 +1032,7 @@ function segmentLineFactory(x1, y1, x2, y2, distance) {
     if (distance < margin) {
       return { x: x1, y: y1 };
     }
-    if (distance > length + margin) {
+    if (distance > length) {
       return { x: x2, y: y2 };
     }
     const [x, y] = midPoint([x1, y1], [x2, y2], distance / length);
@@ -1078,9 +1075,9 @@ function lineToCubic(x1, y1, x2, y2) {
 /**
  * Converts any segment to C (cubic-bezier).
  *
- * @param {SVGPathCommander.pathSegment} segment the source segment
- * @param {SVGPathCommander.parserParams} params the source segment parameters
- * @returns {SVGPathCommander.cubicSegment | SVGPathCommander.MSegment} the cubic-bezier segment
+ * @param {SVGPath.pathSegment} segment the source segment
+ * @param {SVGPath.parserParams} params the source segment parameters
+ * @returns {SVGPath.cubicSegment | SVGPath.MSegment} the cubic-bezier segment
  */
 function segmentToCubic(segment, params) {
   const [pathCommand] = segment;
@@ -1129,8 +1126,8 @@ function segmentToCubic(segment, params) {
  * In addition, un-necessary `Z` segment is removed if previous segment
  * extends to the `M` segment.
  *
- * @param {string | SVGPathCommander.pathArray} pathInput the string to be parsed or 'pathArray'
- * @returns {SVGPathCommander.curveArray} the resulted `pathArray` converted to cubic-bezier
+ * @param {string | SVGPath.pathArray} pathInput the string to be parsed or 'pathArray'
+ * @returns {SVGPath.curveArray} the resulted `pathArray` converted to cubic-bezier
  */
 function pathToCurve(pathInput) {
   if (isCurveArray(pathInput)) {
@@ -1169,23 +1166,24 @@ function pathToCurve(pathInput) {
  * Rounds the values of a `pathArray` instance to
  * a specified amount of decimals and returns it.
  *
- * @param {SVGPathCommander.pathArray} path the source `pathArray`
- * @param {number | boolean} roundOption the amount of decimals to round numbers to
- * @returns {SVGPathCommander.pathArray} the resulted `pathArray` with rounded values
+ * @param {SVGPath.pathArray} path the source `pathArray`
+ * @param {number | false} roundOption the amount of decimals to round numbers to
+ * @returns {SVGPath.pathArray} the resulted `pathArray` with rounded values
  */
 function roundPath(path, roundOption) {
   let { round } = defaultOptions;
   if (roundOption === false || round === false) return clonePath(path);
-  round = roundOption >= 1 ? roundOption : round;
+  // round = roundOption >= 1 ? roundOption : round;
+  // allow for ZERO decimals
+  round = roundOption >= 0 ? roundOption : round;
   // to round values to the power
   // the `round` value must be integer
-  // @ts-ignore
   const pow = round >= 1 ? (10 ** round) : 1;
 
   // @ts-ignore -- `pathSegment[]` is `pathArray`
   return path.map((pi) => {
     const values = pi.slice(1).map(Number)
-      .map((n) => (n % 1 === 0 ? n : Math.round(n * pow) / pow));
+      .map((n) => (round ? (Math.round(n * pow) / pow) : Math.round(n)));
     return [pi[0], ...values];
   });
 }
@@ -1194,8 +1192,8 @@ function roundPath(path, roundOption) {
  * Returns a valid `d` attribute string value created
  * by rounding values and concatenating the `pathArray` segments.
  *
- * @param {SVGPathCommander.pathArray} path the `pathArray` object
- * @param {any} round amount of decimals to round values to
+ * @param {SVGPath.pathArray} path the `pathArray` object
+ * @param {number | false} round amount of decimals to round values to
  * @returns {string} the concatenated path string
  */
 function pathToString(path, round) {
@@ -1204,11 +1202,10 @@ function pathToString(path, round) {
 }
 
 /**
- * Reverses all segments and their values of a `pathArray`
- * and returns a new instance.
+ * Reverses all segments of a `pathArray` and returns a new `pathArray` instance.
  *
- * @param {SVGPathCommander.pathArray} pathInput the source `pathArray`
- * @returns {SVGPathCommander.pathArray} the reversed `pathArray`
+ * @param {SVGPath.pathArray} pathInput the source `pathArray`
+ * @returns {SVGPath.pathArray} the reversed `pathArray`
  */
 function reversePath(pathInput) {
   const absolutePath = pathToAbsolute(pathInput);
@@ -1233,7 +1230,7 @@ function reversePath(pathInput) {
     /** @type {number} */
     const x = i ? path[i - 1].x : path[pLen - 1].x;
     const y = i ? path[i - 1].y : path[pLen - 1].y;
-    /** @type {SVGPathCommander.pathSegment} */
+    /** @type {SVGPath.pathSegment} */
     // @ts-ignore
     let result = [];
 
@@ -1307,7 +1304,7 @@ function reversePath(pathInput) {
  * In the process, values are converted to absolute
  * for visual consistency.
  *
- * @param {SVGPathCommander.pathArray | string} pathInput the source `pathArray`
+ * @param {SVGPath.pathArray | string} pathInput the source `pathArray`
  * @return {string[]} an array with all sub-path strings
  */
 function splitPath(pathInput) {
@@ -1321,11 +1318,11 @@ function splitPath(pathInput) {
 /**
  * Shorten a single segment of a `pathArray` object.
  *
- * @param {SVGPathCommander.absoluteSegment} segment the `absoluteSegment` object
- * @param {SVGPathCommander.normalSegment} normalSegment the `normalSegment` object
+ * @param {SVGPath.absoluteSegment} segment the `absoluteSegment` object
+ * @param {SVGPath.normalSegment} normalSegment the `normalSegment` object
  * @param {any} params the coordinates of the previous segment
  * @param {string} prevCommand the path command of the previous segment
- * @returns {SVGPathCommander.shortSegment | SVGPathCommander.pathSegment} the shortened segment
+ * @returns {SVGPath.shortSegment | SVGPath.pathSegment} the shortened segment
  */
 function shortenSegment(segment, normalSegment, params, prevCommand) {
   const [pathCommand] = segment;
@@ -1389,9 +1386,9 @@ function shortenSegment(segment, normalSegment, params, prevCommand) {
  * * implement `auto` for rounding values based on pathBBox
  * * also revers path check if it's smaller string, maybe?
  *
- * @param {SVGPathCommander.pathArray} pathInput a string or `pathArray`
+ * @param {SVGPath.pathArray} pathInput a string or `pathArray`
  * @param {number | boolean} round the amount of decimals to round values to
- * @returns {SVGPathCommander.pathArray} the optimized `pathArray`
+ * @returns {SVGPath.pathArray} the optimized `pathArray`
  */
 function optimizePath(pathInput, round) {
   const path = pathToAbsolute(pathInput);
@@ -2277,14 +2274,15 @@ Object.assign(CSSMatrix, { Version: Version$1 });
 /**
  * Returns a transformation matrix to apply to `<path>` elements.
  *
- * @see SVGPathCommander.transformObject
+ * @see SVGPath.transformObject
  *
- * @param {SVGPathCommander.transformObject} transform the `transformObject`
+ * @param {SVGPath.transformObject} transform the `transformObject`
  * @returns {CSSMatrix} a new transformation matrix
  */
 function getSVGMatrix(transform) {
   let matrix = new CSSMatrix();
   const { origin } = transform;
+  // @ts-ignore -- at this point the origin is surely defined
   const [originX, originY] = origin;
   const { translate } = transform;
   const { rotate } = transform;
@@ -2415,9 +2413,9 @@ function transformEllipse(m, rx, ry, ax) {
  * Details =>
  * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel
  *
- * @param {SVGPathCommander.CSSMatrix} m the transformation matrix
+ * @param {SVGPath.CSSMatrix} m the transformation matrix
  * @param {[number, number]} point2D the initial [x,y] coordinates
- * @param {number[]} origin the initial [x,y] coordinates
+ * @param {number[]} origin the [x,y,z] transform origin
  * @returns {[number, number]} the projected [x,y] coordinates
  */
 function projection2d(m, point2D, origin) {
@@ -2443,9 +2441,9 @@ function projection2d(m, point2D, origin) {
  * Since *SVGElement* doesn't support 3D transformation, this function
  * creates a 2D projection of the <path> element.
  *
- * @param {SVGPathCommander.pathArray} path the `pathArray` to apply transformation
- * @param {SVGPathCommander.transformObject} transform the transform functions `Object`
- * @returns {SVGPathCommander.pathArray} the resulted `pathArray`
+ * @param {SVGPath.pathArray} path the `pathArray` to apply transformation
+ * @param {SVGPath.transformObject} transform the transform functions `Object`
+ * @returns {SVGPath.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;
@@ -2460,12 +2458,12 @@ function transformPath(path, transform) {
   const matrix2d = [a, b, c, d, e, f];
   const params = { ...paramsParser };
   /** @ts-ignore */
-  /** @type {SVGPathCommander.pathSegment} */
+  /** @type {SVGPath.pathSegment} */
   // @ts-ignore
   let segment = [];
   let seglen = 0;
   let pathCommand = '';
-  /** @type {SVGPathCommander.pathTransformList[]} */
+  /** @type {SVGPath.pathTransformList[]} */
   let transformedPath = [];
   const allPathCommands = []; // needed for arc to curve transformation
 
@@ -2504,7 +2502,7 @@ function transformPath(path, transform) {
       params.x2 = +(segment[seglen - 4]) || params.x1;
       params.y2 = +(segment[seglen - 3]) || params.y1;
 
-      /** @type {SVGPathCommander.pathTransformList} */
+      /** @type {SVGPath.pathTransformList} */
       const result = {
         s: absolutePath[i], c: absolutePath[i][0], x: params.x1, y: params.y1,
       };
@@ -2541,6 +2539,7 @@ function transformPath(path, transform) {
         case 'L':
         case 'H':
         case 'V':
+          // @ts-ignore
           [lx, ly] = projection2d(matrixInstance, [seg.x, seg.y], origin);
 
           if (x !== lx && y !== ly) {
@@ -2557,7 +2556,7 @@ function transformPath(path, transform) {
         default:
 
           for (j = 1, jj = segment.length; j < jj; j += 2) {
-            // compute line coordinates without altering previous coordinates
+            // @ts-ignore compute line coordinates without altering previous coordinates
             [x, y] = projection2d(matrixInstance, [+segment[j], +segment[j + 1]], origin);
             segment[j] = x;
             segment[j + 1] = y;
@@ -2599,7 +2598,7 @@ function getPointAtCubicSegmentLength(x1, y1, c1x, c1y, c2x, c2y, x2, y2, t) {
 }
 
 /**
- * Returns the length of a C (cubic-bezier) segment,
+ * Returns the length of a C (cubic-bezier) segment
  * or an {x,y} point at a given length.
  *
  * @param {number} x1 the starting point X
@@ -2614,15 +2613,16 @@ function getPointAtCubicSegmentLength(x1, y1, c1x, c1y, c2x, c2y, x2, y2, t) {
  * @returns {{x: number, y: number} | number} the segment length or point
  */
 function segmentCubicFactory(x1, y1, c1x, c1y, c2x, c2y, x2, y2, distance) {
-  let x = x1; let y = y1;
+  const distanceIsNumber = typeof distance === 'number';
   const lengthMargin = 0.001;
+  let x = x1; let y = y1;
   let totalLength = 0;
   let prev = [x1, y1, totalLength];
   /** @type {[number, number]} */
   let cur = [x1, y1];
   let t = 0;
 
-  if (typeof distance === 'number' && distance < lengthMargin) {
+  if (distanceIsNumber && distance < lengthMargin) {
     return { x, y };
   }
 
@@ -2634,7 +2634,7 @@ function segmentCubicFactory(x1, y1, c1x, c1y, c2x, c2y, x2, y2, distance) {
     totalLength += distanceSquareRoot(cur, [x, y]);
     cur = [x, y];
 
-    if (typeof distance === 'number' && totalLength >= distance) {
+    if (distanceIsNumber && totalLength >= distance) {
       const dv = (totalLength - distance) / (totalLength - prev[2]);
 
       return {
@@ -2645,7 +2645,7 @@ function segmentCubicFactory(x1, y1, c1x, c1y, c2x, c2y, x2, y2, distance) {
     prev = [x, y, totalLength];
   }
 
-  if (typeof distance === 'number' && distance >= totalLength) {
+  if (distanceIsNumber && distance >= totalLength) {
     return { x: x2, y: y2 };
   }
   return totalLength;
@@ -2662,7 +2662,7 @@ function segmentCubicFactory(x1, y1, c1x, c1y, c2x, c2y, x2, y2, distance) {
  * @param {number} c2y the second control point Y
  * @param {number} x2 the ending point X
  * @param {number} y2 the ending point Y
- * @returns {SVGPathCommander.segmentLimits} the bounding box of the cubic-bezier segment
+ * @returns {SVGPath.segmentLimits} the bounding box of the cubic-bezier segment
  */
 function getCubicSize(x1, y1, c1x, c1y, c2x, c2y, x2, y2) {
   let a = (c2x - 2 * c1x + x1) - (x2 - 2 * c2x + c1x);
@@ -2719,8 +2719,8 @@ function getCubicSize(x1, y1, c1x, c1y, c2x, c2y, x2, y2) {
 /**
  * Returns the bounding box of a shape.
  *
- * @param {SVGPathCommander.pathArray} path the shape `pathArray`
- * @returns {SVGPathCommander.pathBBox} the length of the cubic-bezier segment
+ * @param {SVGPath.pathArray} path the shape `pathArray`
+ * @returns {SVGPath.pathBBox} the length of the cubic-bezier segment
  */
 function getPathBBox(path) {
   if (!path) {
@@ -2777,6 +2777,254 @@ function getPathBBox(path) {
   };
 }
 
+/**
+ * Returns the length of an A (arc-to) segment
+ * or an {x,y} point at a given length.
+ *
+ * @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} distance the point distance
+ * @returns {{x: number, y: number} | number} the segment length or point
+ */
+function segmentArcFactory(X1, Y1, RX, RY, angle, LAF, SF, X2, Y2, distance) {
+  const cubicSeg = arcToCubic(X1, Y1, RX, RY, angle, LAF, SF, X2, Y2);
+  const distanceIsNumber = typeof distance === 'number';
+  let [x, y] = [X1, Y1];
+  const lengthMargin = 0.001;
+  let totalLength = 0;
+  let cubicSubseg = [];
+  let argsc = [];
+  let segLen = 0;
+
+  if (distanceIsNumber && distance < lengthMargin) {
+    return { x, y };
+  }
+
+  for (let i = 0, ii = cubicSeg.length; i < ii; i += 6) {
+    cubicSubseg = cubicSeg.slice(i, i + 6);
+    argsc = [x, y, ...cubicSubseg];
+    // @ts-ignore
+    segLen = segmentCubicFactory(...argsc);
+    if (distanceIsNumber && totalLength + segLen >= distance) {
+      // @ts-ignore -- this is a `cubicSegment`
+      return segmentCubicFactory(...argsc, distance - totalLength);
+    }
+    totalLength += segLen;
+    [x, y] = cubicSubseg.slice(-2);
+  }
+
+  if (distanceIsNumber && distance >= totalLength) {
+    return { x: X2, y: Y2 };
+  }
+
+  return totalLength;
+}
+
+/**
+ * Returns the {x,y} coordinates of a point at a
+ * given length of a quad-bezier segment.
+ *
+ * @see https://github.com/substack/point-at-length
+ *
+ * @param {number} x1 the starting point X
+ * @param {number} y1 the starting point Y
+ * @param {number} cx the control point X
+ * @param {number} cy the control point Y
+ * @param {number} x2 the ending point X
+ * @param {number} y2 the ending point Y
+ * @param {number} t a [0-1] ratio
+ * @returns {{x: number, y: number}} the requested {x,y} coordinates
+ */
+function getPointAtQuadSegmentLength(x1, y1, cx, cy, x2, y2, t) {
+  const t1 = 1 - t;
+  return {
+    x: (t1 ** 2) * x1
+      + 2 * t1 * t * cx
+      + (t ** 2) * x2,
+    y: (t1 ** 2) * y1
+      + 2 * t1 * t * cy
+      + (t ** 2) * y2,
+  };
+}
+
+/**
+ * Returns the Q (quadratic-bezier) segment length
+ * or an {x,y} point at a given length.
+ *
+ * @param {number} x1 the starting point X
+ * @param {number} y1 the starting point Y
+ * @param {number} qx the control point X
+ * @param {number} qy the control point Y
+ * @param {number} x2 the ending point X
+ * @param {number} y2 the ending point Y
+ * @param {number=} distance the distance to point
+ * @returns {{x: number, y: number} | number} the segment length or point
+ */
+function segmentQuadFactory(x1, y1, qx, qy, x2, y2, distance) {
+  const distanceIsNumber = typeof distance === 'number';
+  const lengthMargin = 0.001;
+  let x = x1; let y = y1;
+  let totalLength = 0;
+  let prev = [x1, y1, totalLength];
+  /** @type {[number, number]} */
+  let cur = [x1, y1];
+  let t = 0;
+
+  if (distanceIsNumber && distance < lengthMargin) {
+    return { x, y };
+  }
+
+  const n = 100;
+  for (let j = 0; j <= n; j += 1) {
+    t = j / n;
+
+    ({ x, y } = getPointAtQuadSegmentLength(x1, y1, qx, qy, x2, y2, t));
+    totalLength += distanceSquareRoot(cur, [x, y]);
+    cur = [x, y];
+
+    if (distanceIsNumber && totalLength >= distance) {
+      const dv = (totalLength - distance) / (totalLength - prev[2]);
+
+      return {
+        x: cur[0] * (1 - dv) + prev[0] * dv,
+        y: cur[1] * (1 - dv) + prev[1] * dv,
+      };
+    }
+    prev = [x, y, totalLength];
+  }
+  if (distanceIsNumber && distance >= totalLength) {
+    return { x: x2, y: y2 };
+  }
+  return totalLength;
+}
+
+/**
+ * Returns a {x,y} point at a given length
+ * of a shape or the shape total length.
+ *
+ * @param {string | SVGPath.pathArray} pathInput the `pathArray` to look into
+ * @param {number=} distance the length of the shape to look at
+ * @returns {{x: number, y: number} | number} the total length or point
+ */
+function pathLengthFactory(pathInput, distance) {
+  const path = fixPath(normalizePath(pathInput));
+  const distanceIsNumber = typeof distance === 'number';
+  let totalLength = 0;
+  let isM = true;
+  /** @type {number[]} */
+  let data = [];
+  let pathCommand = 'M';
+  let segLen = 0;
+  let x = 0;
+  let y = 0;
+  let mx = 0;
+  let my = 0;
+  let seg;
+
+  for (let i = 0, ll = path.length; i < ll; i += 1) {
+    seg = path[i];
+    [pathCommand] = seg;
+    isM = pathCommand === 'M';
+    // @ts-ignore
+    data = !isM ? [x, y, ...seg.slice(1)] : data;
+
+    // this segment is always ZERO
+    if (isM) {
+      // remember mx, my for Z
+      // @ts-ignore
+      [, mx, my] = seg;
+      if (distanceIsNumber && distance < 0.001) {
+        return { x: mx, y: my };
+      }
+    } else if (pathCommand === 'L') {
+      // @ts-ignore
+      segLen = segmentLineFactory(...data);
+      if (distanceIsNumber && totalLength + segLen >= distance) {
+        // @ts-ignore
+        return segmentLineFactory(...data, distance - totalLength);
+      }
+      totalLength += segLen;
+    } else if (pathCommand === 'A') {
+      // @ts-ignore
+      segLen = segmentArcFactory(...data);
+      if (distanceIsNumber && totalLength + segLen >= distance) {
+        // @ts-ignore
+        return segmentArcFactory(...data, distance - totalLength);
+      }
+      totalLength += segLen;
+    } else if (pathCommand === 'C') {
+      // @ts-ignore
+      segLen = segmentCubicFactory(...data);
+      if (distanceIsNumber && totalLength + segLen >= distance) {
+        // @ts-ignore
+        return segmentCubicFactory(...data, distance - totalLength);
+      }
+      totalLength += segLen;
+    } else if (pathCommand === 'Q') {
+      // @ts-ignore
+      segLen = segmentQuadFactory(...data);
+      if (distanceIsNumber && totalLength + segLen >= distance) {
+        // @ts-ignore
+        return segmentQuadFactory(...data, distance - totalLength);
+      }
+      totalLength += segLen;
+    } else if (pathCommand === 'Z') {
+      data = [x, y, mx, my];
+      // @ts-ignore
+      segLen = segmentLineFactory(...data);
+      if (distanceIsNumber && totalLength + segLen >= distance) {
+        // @ts-ignore
+        return segmentLineFactory(...data, distance - totalLength);
+      }
+      totalLength += segLen;
+    }
+
+    // @ts-ignore -- needed for the below
+    [x, y] = pathCommand !== 'Z' ? seg.slice(-2) : [mx, my];
+  }
+
+  // native `getPointAtLength` behavior when the given distance
+  // is higher than total length
+  if (distanceIsNumber && distance >= totalLength) {
+    return { x, y };
+  }
+
+  return totalLength;
+}
+
+/**
+ * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.
+ *
+ * The `normalizePath` version is lighter, faster, more efficient and more accurate
+ * with paths that are not `curveArray`.
+ *
+ * @param {string | SVGPath.pathArray} pathInput the target `pathArray`
+ * @returns {number} the shape total length
+ */
+function getTotalLength(pathInput) {
+  // @ts-ignore - it's fine
+  return pathLengthFactory(pathInput);
+}
+
+/**
+ * Returns [x,y] coordinates of a point at a given length of a shape.
+ *
+ * @param {string | SVGPath.pathArray} pathInput the `pathArray` to look into
+ * @param {number} distance the length of the shape to look at
+ * @returns {{x: number, y: number}} the requested {x, y} point coordinates
+ */
+function getPointAtLength(pathInput, distance) {
+  // @ts-ignore
+  return pathLengthFactory(pathInput, distance);
+}
+
 /**
  * Creates a new SVGPathCommander instance with the following properties:
  * * segments: `pathArray`
@@ -2796,18 +3044,25 @@ class SVGPathCommander {
   constructor(pathValue, config) {
     const instanceOptions = config || {};
 
+    const undefPath = typeof pathValue === 'undefined';
+
+    if (undefPath || !pathValue.length) {
+      throw TypeError(`${error}: "pathValue" is ${undefPath ? 'undefined' : 'empty'}`);
+    }
+
+    const segments = parsePathString(pathValue);
+    if (typeof segments === 'string') {
+      throw TypeError(segments);
+    }
+
     /**
-     * @type {SVGPathCommander.pathArray}
+     * @type {SVGPath.pathArray}
      */
-    this.segments = parsePathString(pathValue);
-    const BBox = getPathBBox(this.segments);
+    this.segments = segments;
+
     const {
-      width,
-      height,
-      cx,
-      cy,
-      cz,
-    } = BBox;
+      width, height, cx, cy, cz,
+    } = this.getBBox();
 
     // set instance options.round
     let { round, origin } = defaultOptions;
@@ -2816,7 +3071,7 @@ class SVGPathCommander {
     if (roundOption === 'auto') {
       const pathScale = (`${Math.floor(Math.max(width, height))}`).length;
       round = pathScale >= 4 ? 0 : 4 - pathScale;
-    } else if ((Number.isInteger(roundOption) && roundOption >= 1) || roundOption === false) {
+    } else if (Number.isInteger(roundOption) || roundOption === false) {
       round = roundOption;
     }
 
@@ -2826,15 +3081,14 @@ class SVGPathCommander {
       origin = [
         !Number.isNaN(originX) ? originX : cx,
         !Number.isNaN(originY) ? originY : cy,
-        originZ || cz,
+        !Number.isNaN(originZ) ? originZ : cz,
       ];
     } else {
       origin = [cx, cy, cz];
     }
 
     /**
-     * @type {number | boolean}
-     * @default 4
+     * @type {number | false}
      */
     this.round = round;
     this.origin = origin;
@@ -2842,6 +3096,36 @@ class SVGPathCommander {
     return this;
   }
 
+  /**
+   * Returns the path bounding box, equivalent to native `path.getBBox()`.
+   * @public
+   * @returns {SVGPath.pathBBox}
+   */
+  getBBox() {
+    return getPathBBox(this.segments);
+  }
+
+  /**
+   * Returns the total path length, equivalent to native `path.getTotalLength()`.
+   * @public
+   * @returns {number}
+   */
+  getTotalLength() {
+    return getTotalLength(this.segments);
+  }
+
+  /**
+   * Returns an `{x,y}` point in the path stroke at a given length,
+   * equivalent to the native `path.getPointAtLength()`.
+   *
+   * @public
+   * @param {number} length the length
+   * @returns {{x: number, y:number}} the requested point
+   */
+  getPointAtLength(length) {
+    return getPointAtLength(this.segments, length);
+  }
+
   /**
    * Convert path to absolute values
    * @public
@@ -2933,16 +3217,16 @@ class SVGPathCommander {
 
   /**
    * Transform path using values from an `Object` defined as `transformObject`.
-   * @see SVGPathCommander.transformObject for a quick refference
+   * @see SVGPath.transformObject for a quick refference
    *
-   * @param {SVGPathCommander.transformObject} source a `transformObject`as described above
+   * @param {SVGPath.transformObject} source a `transformObject`as described above
    * @public
    */
   transform(source) {
     if (!source || typeof source !== 'object' || (typeof source === 'object'
       && !['translate', 'rotate', 'skew', 'scale'].some((x) => x in source))) return this;
 
-    /** @type {SVGPathCommander.transformObject} */
+    /** @type {SVGPath.transformObject} */
     const transform = {};
     Object.keys(source).forEach((fn) => {
       // @ts-ignore
@@ -2952,18 +3236,18 @@ class SVGPathCommander {
 
     // if origin is not specified
     // it's important that we have one
+    const [cx, cy, cz] = this.origin;
     const { origin } = transform;
-    if (origin && origin.length >= 2) {
+
+    if (Array.isArray(origin) && origin.length >= 2) {
       const [originX, originY, originZ] = origin.map(Number);
-      const [cx, cy, cz] = this.origin;
       transform.origin = [
         !Number.isNaN(originX) ? originX : cx,
         !Number.isNaN(originY) ? originY : cy,
         originZ || cz,
       ];
     } else {
-      // @ts-ignore
-      transform.origin = { ...this.origin };
+      transform.origin = [cx, cy, cz];
     }
 
     this.segments = transformPath(segments, transform);
@@ -3026,7 +3310,7 @@ function getCubicSegArea(x1, y1, c1x, c1y, c2x, c2y, x2, y2) {
  *
  * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js
  *
- * @param {SVGPathCommander.pathArray} path the shape `pathArray`
+ * @param {SVGPath.pathArray} path the shape `pathArray`
  * @returns {number} the length of the cubic-bezier segment
  */
 function getPathArea(path) {
@@ -3053,7 +3337,7 @@ function getPathArea(path) {
  * This is the `pathToCurve` version which is faster and more efficient for
  * paths that are `curveArray`.
  *
- * @param {string | SVGPathCommander.curveArray} path the target `pathArray`
+ * @param {string | SVGPath.curveArray} path the target `pathArray`
  * @returns {number} the `curveArray` total length
  */
 function getPathLength(path) {
@@ -3066,243 +3350,11 @@ function getPathLength(path) {
   return totalLength;
 }
 
-/**
- * Returns the length of a A (arc-to) segment,
- * or an {x,y} point at a given length.
- *
- * @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} distance the point distance
- * @returns {{x: number, y: number} | number} the segment length or point
- */
-function segmentArcFactory(X1, Y1, RX, RY, angle, LAF, SF, X2, Y2, distance) {
-  let [x, y] = [X1, Y1];
-  const cubicSeg = arcToCubic(X1, Y1, RX, RY, angle, LAF, SF, X2, Y2);
-  const lengthMargin = 0.001;
-  let totalLength = 0;
-  let cubicSubseg = [];
-  let argsc = [];
-  let segLen = 0;
-
-  if (typeof distance === 'number' && distance < lengthMargin) {
-    return { x, y };
-  }
-
-  for (let i = 0, ii = cubicSeg.length; i < ii; i += 6) {
-    cubicSubseg = cubicSeg.slice(i, i + 6);
-    argsc = [x, y, ...cubicSubseg];
-    // @ts-ignore
-    segLen = segmentCubicFactory(...argsc);
-    if (typeof distance === 'number' && totalLength + segLen >= distance) {
-      // @ts-ignore -- this is a `cubicSegment`
-      return segmentCubicFactory(...argsc, distance - totalLength);
-    }
-    totalLength += segLen;
-    [x, y] = cubicSubseg.slice(-2);
-  }
-
-  if (typeof distance === 'number' && distance >= totalLength) {
-    return { x: X2, y: Y2 };
-  }
-
-  return totalLength;
-}
-
-/**
- * Returns the {x,y} coordinates of a point at a
- * given length of a quad-bezier segment.
- *
- * @see https://github.com/substack/point-at-length
- *
- * @param {number} x1 the starting point X
- * @param {number} y1 the starting point Y
- * @param {number} cx the control point X
- * @param {number} cy the control point Y
- * @param {number} x2 the ending point X
- * @param {number} y2 the ending point Y
- * @param {number} t a [0-1] ratio
- * @returns {{x: number, y: number}} the requested {x,y} coordinates
- */
-function getPointAtQuadSegmentLength(x1, y1, cx, cy, x2, y2, t) {
-  const t1 = 1 - t;
-  return {
-    x: (t1 ** 2) * x1
-      + 2 * t1 * t * cx
-      + (t ** 2) * x2,
-    y: (t1 ** 2) * y1
-      + 2 * t1 * t * cy
-      + (t ** 2) * y2,
-  };
-}
-
-/**
- * Returns the Q (quadratic-bezier) segment length,
- * or an {x,y} point at a given length.
- *
- * @param {number} x1 the starting point X
- * @param {number} y1 the starting point Y
- * @param {number} qx the control point X
- * @param {number} qy the control point Y
- * @param {number} x2 the ending point X
- * @param {number} y2 the ending point Y
- * @param {number=} distance the distance to point
- * @returns {{x: number, y: number} | number} the segment length or point
- */
-function segmentQuadFactory(x1, y1, qx, qy, x2, y2, distance) {
-  let x = x1; let y = y1;
-  const lengthMargin = 0.001;
-  let totalLength = 0;
-  let prev = [x1, y1, totalLength];
-  /** @type {[number, number]} */
-  let cur = [x1, y1];
-  let t = 0;
-
-  if (typeof distance === 'number' && distance < lengthMargin) {
-    return { x, y };
-  }
-
-  const n = 100;
-  for (let j = 0; j <= n; j += 1) {
-    t = j / n;
-
-    ({ x, y } = getPointAtQuadSegmentLength(x1, y1, qx, qy, x2, y2, t));
-    totalLength += distanceSquareRoot(cur, [x, y]);
-    cur = [x, y];
-
-    if (typeof distance === 'number' && totalLength >= distance) {
-      const dv = (totalLength - distance) / (totalLength - prev[2]);
-
-      return {
-        x: cur[0] * (1 - dv) + prev[0] * dv,
-        y: cur[1] * (1 - dv) + prev[1] * dv,
-      };
-    }
-    prev = [x, y, totalLength];
-  }
-  if (typeof distance === 'number' && distance >= totalLength) {
-    return { x: x2, y: y2 };
-  }
-  return totalLength;
-}
-
-/**
- * Returns a {x,y} point at a given length of a shape or the shape total length.
- *
- * @param {string | SVGPathCommander.pathArray} pathInput the `pathArray` to look into
- * @param {number=} distance the length of the shape to look at
- * @returns {{x: number, y: number} | number} the total length or point
- */
-function pathLengthFactory(pathInput, distance) {
-  let totalLength = 0;
-  let isM = true;
-  /** @type {number[]} */
-  let data = [];
-  let pathCommand = 'M';
-  let segLen = 0;
-  let x = 0;
-  let y = 0;
-  let mx = 0;
-  let my = 0;
-  let seg;
-  const path = fixPath(normalizePath(pathInput));
-
-  for (let i = 0, ll = path.length; i < ll; i += 1) {
-    seg = path[i];
-    [pathCommand] = seg;
-    isM = pathCommand === 'M';
-    // @ts-ignore
-    data = !isM ? [x, y, ...seg.slice(1)] : data;
-
-    // this segment is always ZERO
-    if (isM) {
-      // remember mx, my for Z
-      // @ts-ignore
-      [, mx, my] = seg;
-      if (typeof distance === 'number' && distance < 0.001) {
-        return { x: mx, y: my };
-      }
-    } else if (pathCommand === 'L') {
-      // @ts-ignore
-      segLen = segmentLineFactory(...data);
-      if (distance && totalLength + segLen >= distance) {
-        // @ts-ignore
-        return segmentLineFactory(...data, distance - totalLength);
-      }
-      totalLength += segLen;
-    } else if (pathCommand === 'A') {
-      // @ts-ignore
-      segLen = segmentArcFactory(...data);
-      if (distance && totalLength + segLen >= distance) {
-        // @ts-ignore
-        return segmentArcFactory(...data, distance - totalLength);
-      }
-      totalLength += segLen;
-    } else if (pathCommand === 'C') {
-      // @ts-ignore
-      segLen = segmentCubicFactory(...data);
-      if (distance && totalLength + segLen >= distance) {
-        // @ts-ignore
-        return segmentCubicFactory(...data, distance - totalLength);
-      }
-      totalLength += segLen;
-    } else if (pathCommand === 'Q') {
-      // @ts-ignore
-      segLen = segmentQuadFactory(...data);
-      if (distance && totalLength + segLen >= distance) {
-        // @ts-ignore
-        return segmentQuadFactory(...data, distance - totalLength);
-      }
-      totalLength += segLen;
-    } else if (pathCommand === 'Z') {
-      data = [x, y, mx, my];
-      // @ts-ignore
-      segLen = segmentLineFactory(...data);
-      if (distance && totalLength + segLen >= distance) {
-        // @ts-ignore
-        return segmentLineFactory(...data, distance - totalLength);
-      }
-      totalLength += segLen;
-    }
-
-    // @ts-ignore -- needed for the below
-    [x, y] = pathCommand !== 'Z' ? seg.slice(-2) : [mx, my];
-  }
-
-  // native `getPointAtLength` behavior when the given distance
-  // is higher than total length
-  if (distance && distance >= totalLength) {
-    return { x, y };
-  }
-
-  return totalLength;
-}
-
-/**
- * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.
- *
- * The `normalizePath` version is lighter, faster, more efficient and more accurate
- * with paths that are not `curveArray`.
- *
- * @param {string | SVGPathCommander.pathArray} pathInput the target `pathArray`
- * @returns {number} the shape total length
- */
-function getTotalLength(pathInput) {
-  // @ts-ignore - it's fine
-  return pathLengthFactory(pathInput);
-}
-
 /**
  * Check if a path is drawn clockwise and returns true if so,
  * false otherwise.
  *
- * @param {SVGPathCommander.pathArray} path the path string or `pathArray`
+ * @param {SVGPath.pathArray} path the path string or `pathArray`
  * @returns {boolean} true when clockwise or false if not
  */
 function getDrawDirection(path) {
@@ -3310,37 +3362,12 @@ function getDrawDirection(path) {
 }
 
 /**
- * Returns [x,y] coordinates of a point at a given length of a shape.
- *
- * @param {string | SVGPathCommander.pathArray} pathInput the `pathArray` to look into
- * @param {number} distance the length of the shape to look at
- * @returns {{x: number, y: number}} the requested {x, y} point coordinates
- */
-function getPointAtLength(pathInput, distance) {
-  // @ts-ignore
-  return pathLengthFactory(pathInput, distance);
-}
-
-/**
- * Returns [x,y] coordinates of a point at a given length of a shape.
- * `pathToCurve` version.
+ * Returns the segment, its index and length as well as
+ * the length to that segment at a given length in a path.
  *
- * @deprecated
- *
- * @param {string | SVGPathCommander.pathArray} pathInput the `pathArray` to look into
- * @param {number} distance the length of the shape to look at
- * @returns {{x: number, y: number}} the requested {x, y} point coordinates
- */
-function getPointAtPathLength(pathInput, distance) {
-  return getPointAtLength(pathInput, distance);
-}
-
-/**
- * Returns the properties at a given length in path.
- *
- * @param {string | SVGPathCommander.pathArray} pathInput target `pathArray`
+ * @param {string | SVGPath.pathArray} pathInput target `pathArray`
  * @param {number=} distance the given length
- * @returns {SVGPathCommander.segmentProperties=} the requested properties
+ * @returns {SVGPath.segmentProperties=} the requested properties
  */
 function getPropertiesAtLength(pathInput, distance) {
   const pathArray = parsePathString(pathInput);
@@ -3352,7 +3379,7 @@ function getPropertiesAtLength(pathInput, distance) {
   let index = pathTemp.length - 1;
   let lengthAtSegment = 0;
   let length = 0;
-  /** @type {SVGPathCommander.pathSegment} */
+  /** @type {SVGPath.pathSegment} */
   let segment = pathArray[0];
   const [x, y] = segment.slice(-2);
   const point = { x, y };
@@ -3396,12 +3423,13 @@ function getPropertiesAtLength(pathInput, distance) {
 }
 
 /**
- * Returns the point in path closest to a given point.
+ * Returns the point and segment in path closest to a given point as well as
+ * the distance to the path stroke.
  * @see https://bl.ocks.org/mbostock/8027637
  *
- * @param {string | SVGPathCommander.pathArray} pathInput target `pathArray`
+ * @param {string | SVGPath.pathArray} pathInput target `pathArray`
  * @param {{x: number, y: number}} point the given point
- * @returns {SVGPathCommander.pointProperties} the requested properties
+ * @returns {SVGPath.pointProperties} the requested properties
  */
 function getPropertiesAtPoint(pathInput, point) {
   const path = fixPath(parsePathString(pathInput));
@@ -3460,7 +3488,7 @@ function getPropertiesAtPoint(pathInput, point) {
     }
   }
 
-  const segment = getPropertiesAtLength(path, bestDistance);
+  const segment = getPropertiesAtLength(path, bestLength);
   const distance = Math.sqrt(bestDistance);
 
   return { closest, distance, segment };
@@ -3469,7 +3497,7 @@ function getPropertiesAtPoint(pathInput, point) {
 /**
  * Returns the point in path closest to a given point.
  *
- * @param {string | SVGPathCommander.pathArray} pathInput target `pathArray`
+ * @param {string | SVGPath.pathArray} pathInput target `pathArray`
  * @param {{x: number, y: number}} point the given point
  * @returns {{x: number, y: number}} the best match
  */
@@ -3480,9 +3508,9 @@ function getClosestPoint(pathInput, point) {
 /**
  * Returns the path segment which contains a given point.
  *
- * @param {string | SVGPathCommander.pathArray} path the `pathArray` to look into
+ * @param {string | SVGPath.pathArray} path the `pathArray` to look into
  * @param {{x: number, y: number}} point the point of the shape to look for
- * @returns {SVGPathCommander.pathSegment?} the requested segment
+ * @returns {SVGPath.pathSegment?} the requested segment
  */
 function getSegmentOfPoint(path, point) {
   const props = getPropertiesAtPoint(path, point);
@@ -3492,9 +3520,9 @@ function getSegmentOfPoint(path, point) {
 
 /**
  * Returns the segment at a given length.
- * @param {string | SVGPathCommander.pathArray} pathInput the target `pathArray`
+ * @param {string | SVGPath.pathArray} pathInput the target `pathArray`
  * @param {number} distance the distance in path to look at
- * @returns {SVGPathCommander.pathSegment?} the requested segment
+ * @returns {SVGPath.pathSegment?} the requested segment
  */
 function getSegmentAtLength(pathInput, distance) {
   const props = getPropertiesAtLength(pathInput, distance);
@@ -3505,8 +3533,8 @@ function getSegmentAtLength(pathInput, distance) {
 /**
  * Checks if a given point is in the stroke of a path.
  *
- * @param {string | SVGPathCommander.pathArray} pathInput target path
- * @param {{x: number, y: number}} point
+ * @param {string | SVGPath.pathArray} pathInput target path
+ * @param {{x: number, y: number}} point the given `{x,y}` point
  * @returns {boolean} the query result
  */
 function isPointInStroke(pathInput, point) {
@@ -3553,8 +3581,8 @@ const shapeParams = {
 /**
  * Returns a new `pathArray` from line attributes.
  *
- * @param {SVGPathCommander.lineAttr} attr shape configuration
- * @returns {SVGPathCommander.pathArray} a new line `pathArray`
+ * @param {SVGPath.lineAttr} attr shape configuration
+ * @returns {SVGPath.pathArray} a new line `pathArray`
  */
 function getLinePath(attr) {
   const {
@@ -3566,14 +3594,14 @@ function getLinePath(attr) {
 /**
  * Returns a new `pathArray` like from polyline/polygon attributes.
  *
- * @param {SVGPathCommander.polyAttr} attr shape configuration
- * @return {SVGPathCommander.pathArray} a new polygon/polyline `pathArray`
+ * @param {SVGPath.polyAttr} attr shape configuration
+ * @return {SVGPath.pathArray} a new polygon/polyline `pathArray`
  */
 function getPolyPath(attr) {
-  /** @type {SVGPathCommander.pathArray} */
+  /** @type {SVGPath.pathArray} */
   // @ts-ignore -- it's an empty `pathArray`
   const pathArray = [];
-  const points = attr.points.split(/[\s|,]/).map(Number);
+  const points = attr.points.trim().split(/[\s|,]/).map(Number);
 
   let index = 0;
   while (index < points.length) {
@@ -3587,8 +3615,8 @@ function getPolyPath(attr) {
 /**
  * Returns a new `pathArray` from circle attributes.
  *
- * @param {SVGPathCommander.circleAttr} attr shape configuration
- * @return {SVGPathCommander.pathArray} a circle `pathArray`
+ * @param {SVGPath.circleAttr} attr shape configuration
+ * @return {SVGPath.pathArray} a circle `pathArray`
  */
 function getCirclePath(attr) {
   const {
@@ -3605,8 +3633,8 @@ function getCirclePath(attr) {
 /**
  * Returns a new `pathArray` from ellipse attributes.
  *
- * @param {SVGPathCommander.ellipseAttr} attr shape configuration
- * @return {SVGPathCommander.pathArray} an ellipse `pathArray`
+ * @param {SVGPath.ellipseAttr} attr shape configuration
+ * @return {SVGPath.pathArray} an ellipse `pathArray`
  */
 function getEllipsePath(attr) {
   const {
@@ -3623,8 +3651,8 @@ function getEllipsePath(attr) {
 /**
  * Returns a new `pathArray` like from rect attributes.
  *
- * @param {SVGPathCommander.rectAttr} attr object with properties above
- * @return {SVGPathCommander.pathArray} a new `pathArray` from `<rect>` attributes
+ * @param {SVGPath.rectAttr} attr object with properties above
+ * @return {SVGPath.pathArray} a new `pathArray` from `<rect>` attributes
  */
 function getRectanglePath(attr) {
   const x = +attr.x || 0;
@@ -3670,12 +3698,12 @@ function getRectanglePath(attr) {
  * is `true`, it will replace the target.
  *
  * It can also work with an options object,
- * @see SVGPathCommander.shapeOps
+ * @see SVGPath.shapeOps
  *
  * The newly created `<path>` element keeps all non-specific
  * attributes like `class`, `fill`, etc.
  *
- * @param {SVGPathCommander.shapeTypes | SVGPathCommander.shapeOps} element target shape
+ * @param {SVGPath.shapeTypes | SVGPath.shapeOps} element target shape
  * @param {boolean=} replace option to replace target
  * @return {SVGPathElement | boolean} the newly created `<path>` element
  */
@@ -3729,11 +3757,11 @@ function shapeToPath(element, replace) {
 }
 
 /**
- * Reverses all segments and their values from a `pathArray`
+ * Reverses all segments of a `pathArray`
  * which consists of only C (cubic-bezier) path commands.
  *
- * @param {SVGPathCommander.curveArray} path the source `pathArray`
- * @returns {SVGPathCommander.curveArray} the reversed `pathArray`
+ * @param {SVGPath.curveArray} path the source `pathArray`
+ * @returns {SVGPath.curveArray} the reversed `pathArray`
  */
 function reverseCurve(path) {
   const rotatedCurve = path.slice(1)
@@ -3770,7 +3798,6 @@ const Util = {
   getTotalLength,
   getPathLength,
   getPointAtLength,
-  getPointAtPathLength,
   getClosestPoint,
   getSegmentOfPoint,
   getPropertiesAtPoint,
@@ -3790,7 +3817,7 @@ const Util = {
   options: defaultOptions,
 };
 
-var version = "0.1.23";
+var version = "0.2.0alpha1";
 
 // @ts-ignore