svg-path-commander 0.1.25 → 0.2.0-alpha3

package/src/process/projection2d.js

@@ -7,9 +7,9 @@
  * 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
  */
 export default function projection2d(m, point2D, origin) {

package/src/process/reverseCurve.js

@@ -1,9 +1,9 @@
 /**
- * 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`
  */
 export default function reverseCurve(path) {
   const rotatedCurve = path.slice(1)

package/src/process/reversePath.js

@@ -2,11 +2,10 @@ import pathToAbsolute from '../convert/pathToAbsolute';
 import normalizePath from './normalizePath';
 
 /**
- * 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`
  */
 export default function reversePath(pathInput) {
   const absolutePath = pathToAbsolute(pathInput);
@@ -31,7 +30,7 @@ export default 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 = [];
 

package/src/process/roundPath.js

@@ -4,23 +4,24 @@ import clonePath from './clonePath';
  * 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
  */
 export default 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];
   });
 }

package/src/process/segmentToCubic.js

@@ -5,9 +5,9 @@ import lineToCubic from './lineToCubic';
 /**
  * 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
  */
 export default function segmentToCubic(segment, params) {
   const [pathCommand] = segment;

package/src/process/shortenSegment.js

@@ -1,11 +1,11 @@
 /**
  * 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
  */
 export default function shortenSegment(segment, normalSegment, params, prevCommand) {
   const [pathCommand] = segment;

package/src/process/splitCubic.js

@@ -4,7 +4,7 @@ import midPoint from '../math/midPoint';
  * Split a cubic-bezier segment into two.
  *
  * @param {number[]} pts the cubic-bezier parameters
- * @return {SVGPathCommander.cubicSegment[]} two new cubic-bezier segments
+ * @return {SVGPath.cubicSegment[]} two new cubic-bezier segments
  */
 export default function splitCubic(pts/* , ratio */) {
   const t = /* ratio || */ 0.5;

package/src/process/splitPath.js

@@ -7,7 +7,7 @@ import pathToAbsolute from '../convert/pathToAbsolute';
  * 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
  */
 export default function splitPath(pathInput) {

package/src/process/transformPath.js

@@ -14,9 +14,9 @@ import paramsParser from '../parser/paramsParser';
  * 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`
  */
 export default function transformPath(path, transform) {
   let x = 0; let y = 0; let i; let j; let ii; let jj; let lx; let ly; let te;
@@ -31,12 +31,12 @@ export default 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
 
@@ -75,7 +75,7 @@ export default 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,
       };
@@ -112,6 +112,7 @@ export default 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) {
@@ -128,7 +129,7 @@ export default 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;

package/src/svg-path-commander.js

@@ -14,7 +14,11 @@ import optimizePath from './process/optimizePath';
 import normalizePath from './process/normalizePath';
 import transformPath from './process/transformPath';
 
+import error from './parser/error';
+
 import getPathBBox from './util/getPathBBox';
+import getTotalLength from './util/getTotalLength';
+import getPointAtLength from './util/getPointAtLength';
 
 /**
  * Creates a new SVGPathCommander instance with the following properties:
@@ -35,18 +39,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;
@@ -55,7 +66,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;
     }
 
@@ -65,15 +76,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;
@@ -81,6 +91,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
@@ -172,16 +212,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
@@ -191,18 +231,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);

package/src/util/getClosestPoint.js

@@ -3,7 +3,7 @@ import getPropertiesAtPoint from './getPropertiesAtPoint';
 /**
  * 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
  */

package/src/util/getCubicSize.js

@@ -11,7 +11,7 @@ import segmentCubicFactory from './segmentCubicFactory';
  * @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
  */
 export default function getCubicSize(x1, y1, c1x, c1y, c2x, c2y, x2, y2) {
   let a = (c2x - 2 * c1x + x1) - (x2 - 2 * c2x + c1x);

package/src/util/getDrawDirection.js

@@ -5,7 +5,7 @@ import pathToCurve from '../convert/pathToCurve';
  * 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
  */
 export default function getDrawDirection(path) {

package/src/util/getPathArea.js

@@ -27,7 +27,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
  */
 export default function getPathArea(path) {

package/src/util/getPathBBox.js

@@ -4,8 +4,8 @@ import pathToCurve from '../convert/pathToCurve';
 /**
  * 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
  */
 export default function getPathBBox(path) {
   if (!path) {

package/src/util/getPathLength.js

@@ -7,7 +7,7 @@ import pathToCurve from '../convert/pathToCurve';
  * 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
  */
 export default function getPathLength(path) {

package/src/util/getPointAtLength.js

@@ -3,7 +3,7 @@ import pathLengthFactory from './pathLengthFactory';
 /**
  * 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 {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
  */

package/src/util/getPropertiesAtLength.js

@@ -5,9 +5,9 @@ import getTotalLength from './getTotalLength';
  * Returns the segment, its index and length as well as
  * the length to that segment at a given length in a 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
  */
 export default function getPropertiesAtLength(pathInput, distance) {
   const pathArray = parsePathString(pathInput);
@@ -19,7 +19,7 @@ export default 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 };

package/src/util/getPropertiesAtPoint.js

@@ -10,9 +10,9 @@ import normalizePath from '../process/normalizePath';
  * 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
  */
 export default function getPropertiesAtPoint(pathInput, point) {
   const path = fixPath(parsePathString(pathInput));

package/src/util/getSegmentAtLength.js

@@ -2,9 +2,9 @@ import getPropertiesAtLength from './getPropertiesAtLength';
 
 /**
  * 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
  */
 export default function getSegmentAtLength(pathInput, distance) {
   const props = getPropertiesAtLength(pathInput, distance);

package/src/util/getSegmentOfPoint.js

@@ -3,9 +3,9 @@ import getPropertiesAtPoint from './getPropertiesAtPoint';
 /**
  * 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
  */
 export default function getSegmentOfPoint(path, point) {
   const props = getPropertiesAtPoint(path, point);

package/src/util/getTotalLength.js

@@ -6,7 +6,7 @@ import pathLengthFactory from './pathLengthFactory';
  * 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`
+ * @param {string | SVGPath.pathArray} pathInput the target `pathArray`
  * @returns {number} the shape total length
  */
 export default function getTotalLength(pathInput) {

package/src/util/isAbsoluteArray.js

@@ -4,7 +4,7 @@ import isPathArray from './isPathArray';
  * 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
  */
 export default function isAbsoluteArray(path) {

package/src/util/isCurveArray.js

@@ -4,7 +4,7 @@ import isPathArray from './isPathArray';
  * 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
  */
 export default function isCurveArray(path) {

package/src/util/isNormalizedArray.js

@@ -5,7 +5,7 @@ import isAbsoluteArray from './isAbsoluteArray';
  * 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
  */
 export default function isNormalizedArray(path) {

package/src/util/isPathArray.js

@@ -3,7 +3,7 @@ import paramsCount from '../parser/paramsCount';
 /**
  * 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
  */
 export default function isPathArray(path) {

package/src/util/isPointInStroke.js

@@ -3,8 +3,8 @@ import getPropertiesAtPoint from './getPropertiesAtPoint';
 /**
  * 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
  */
 export default function isPointInStroke(pathInput, point) {

package/src/util/isRelativeArray.js

@@ -4,7 +4,7 @@ import isPathArray from './isPathArray';
  * 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
  */
 export default function isRelativeArray(path) {

package/src/util/pathLengthFactory.js

@@ -7,9 +7,10 @@ import segmentCubicFactory from './segmentCubicFactory';
 import segmentQuadFactory from './segmentQuadFactory';
 
 /**
- * Returns a {x,y} point at a given length of a shape or the shape total length.
+ * 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 {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
  */

package/src/util/segmentArcFactory.js

@@ -2,7 +2,7 @@ import segmentCubicFactory from './segmentCubicFactory';
 import arcToCubic from '../process/arcToCubic';
 
 /**
- * Returns the length of a A (arc-to) segment,
+ * 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

package/src/util/segmentCubicFactory.js

@@ -29,7 +29,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

package/src/util/segmentLineFactory.js

@@ -2,7 +2,7 @@ import midPoint from '../math/midPoint';
 import distanceSquareRoot from '../math/distanceSquareRoot';
 
 /**
- * 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

package/src/util/segmentQuadFactory.js

@@ -28,7 +28,7 @@ function getPointAtQuadSegmentLength(x1, y1, cx, cy, x2, y2, t) {
 }
 
 /**
- * Returns the Q (quadratic-bezier) segment length,
+ * Returns the Q (quadratic-bezier) segment length
  * or an {x,y} point at a given length.
  *
  * @param {number} x1 the starting point X