svg-path-commander 2.1.0 → 2.1.1

package/src/process/splitCubic.ts

@@ -1,18 +1,19 @@
 import midPoint from '../math/midPoint';
-import type { CubicSegment } from '../types';
+import type { CubicSegment, PointTuple } from '../types';
 
 /**
  * Split a cubic-bezier segment into two.
  *
  * @param pts the cubic-bezier parameters
+ * @param ratio the cubic-bezier parameters
  * @return two new cubic-bezier segments
  */
-const splitCubic = (pts: number[] /* , ratio */): [CubicSegment, CubicSegment] => {
-  const t = /* ratio || */ 0.5;
-  const p0 = pts.slice(0, 2) as [number, number];
-  const p1 = pts.slice(2, 4) as [number, number];
-  const p2 = pts.slice(4, 6) as [number, number];
-  const p3 = pts.slice(6, 8) as [number, number];
+const splitCubic = (pts: number[], ratio = 0.5): [CubicSegment, CubicSegment] => {
+  const t = ratio;
+  const p0 = pts.slice(0, 2) as PointTuple;
+  const p1 = pts.slice(2, 4) as PointTuple;
+  const p2 = pts.slice(4, 6) as PointTuple;
+  const p3 = pts.slice(6, 8) as PointTuple;
   const p4 = midPoint(p0, p1, t);
   const p5 = midPoint(p1, p2, t);
   const p6 = midPoint(p2, p3, t);

package/src/process/splitPath.ts

@@ -1,4 +1,5 @@
-import type { PathArray } from '../types';
+import paramsParser from '../parser/paramsParser';
+import type { AbsoluteCommand, HSegment, MSegment, PathArray, PointTuple, RelativeCommand, VSegment } from '../types';
 
 /**
  * Split a path into an `Array` of sub-path strings.
@@ -7,20 +8,53 @@ import type { PathArray } from '../types';
  * for visual consistency.
  *
  * @param pathInput the source `pathArray`
- * @return {SVGPath.pathArray[]} an array with all sub-path strings
+ * @return an array with all sub-path strings
  */
 const splitPath = (pathInput: PathArray): PathArray[] => {
   const composite = [] as PathArray[];
   let path: PathArray;
   let pi = -1;
+  let x = 0;
+  let y = 0;
+  let mx = 0;
+  let my = 0;
+  const params = { ...paramsParser };
 
   pathInput.forEach(seg => {
-    if (seg[0] === 'M') {
-      path = [seg];
+    const [pathCommand] = seg;
+    const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;
+    const relCommand = pathCommand.toLowerCase() as RelativeCommand;
+    const isRelative = pathCommand === relCommand;
+    const values = seg.slice(1) as number[];
+
+    if (absCommand === 'M') {
       pi += 1;
+      [x, y] = values as PointTuple;
+      x += isRelative ? params.x : 0;
+      y += isRelative ? params.y : 0;
+      mx = x;
+      my = y;
+      path = [(isRelative ? [absCommand, mx, my] : seg) as MSegment];
     } else {
+      if (absCommand === 'Z') {
+        x = mx;
+        y = my;
+      } else if (absCommand === 'H') {
+        [, x] = seg as HSegment;
+        x += isRelative ? params.x : /* istanbul ignore next @preserve */ 0;
+      } else if (absCommand === 'V') {
+        [, y] = seg as VSegment;
+        y += isRelative ? params.y : /* istanbul ignore next @preserve */ 0;
+      } else {
+        [x, y] = seg.slice(-2) as PointTuple;
+        x += isRelative ? params.x : 0;
+        y += isRelative ? params.y : 0;
+      }
       path.push(seg);
     }
+
+    params.x = x;
+    params.y = y;
     composite[pi] = path;
   });
 

package/src/process/transformPath.ts

@@ -1,14 +1,14 @@
-import normalizePath from './normalizePath';
-// import pathToAbsolute from '../convert/pathToAbsolute';
-// import segmentToCubic from './segmentToCubic';
-// import fixArc from './fixArc';
 import getSVGMatrix from './getSVGMatrix';
 import projection2d from './projection2d';
-import paramsParser from '../parser/paramsParser';
-import replaceArc from './replaceArc';
 import defaultOptions from '../options/options';
-import type { AbsoluteArray, PathArray, TransformObjectValues } from '../types';
-import type { PathTransform, TransformObject } from '../interface';
+import type { AbsoluteArray, CSegment, PathArray, PointTuple, TransformObjectValues } from '../types';
+import type { TransformObject } from '../interface';
+import iterate from './iterate';
+import parsePathString from '../parser/parsePathString';
+import absolutizeSegment from './absolutizeSegment';
+import segmentToCubic from './segmentToCubic';
+import normalizeSegment from './normalizeSegment';
+import paramsParser from '../parser/paramsParser';
 
 /**
  * Apply a 2D / 3D transformation to a `pathArray` instance.
@@ -20,89 +20,96 @@ import type { PathTransform, TransformObject } from '../interface';
  * @param transform the transform functions `Object`
  * @returns the resulted `pathArray`
  */
-const transformPath = (path: string | PathArray, transform?: Partial<TransformObject>): PathArray => {
+const transformPath = (pathInput: PathArray | string, transform?: Partial<TransformObject>) => {
   let x = 0;
   let y = 0;
-  let i;
-  let j;
-  let ii;
-  let jj;
-  let lx;
-  let ly;
-  // REPLACE Arc path commands with Cubic Beziers
-  // we don't have any scripting know-how on 3d ellipse transformation
-  // Arc segments don't work with 3D transformations or skews
-  const absolutePath = replaceArc(path);
+  let mx = 0;
+  let my = 0;
+  let lx = 0;
+  let ly = 0;
+  let j = 0;
+  let jj = 0;
+  let nx = 0;
+  let ny = 0;
+  let pathCommand = 'M';
+  // transform uses it's own set of params
+  const transformParams = { ...paramsParser };
+  const path = parsePathString(pathInput);
   const transformProps = transform && Object.keys(transform);
 
   // when used as a static method, invalidate somehow
-  if (!transform || (transformProps && !transformProps.length)) return absolutePath.slice(0) as PathArray;
+  if (!transform || (transformProps && !transformProps.length)) return path;
 
-  const normalizedPath = normalizePath(absolutePath);
   // transform origin is extremely important
   if (!transform.origin) {
-    const { origin: defaultOrigin } = defaultOptions;
-    Object.assign(transform, { origin: defaultOrigin });
+    Object.assign(transform, { origin: defaultOptions.origin });
   }
+  const origin = transform.origin as [number, number, number];
   const matrixInstance = getSVGMatrix(transform as TransformObjectValues);
-  const { origin } = transform;
-  const params = { ...paramsParser };
-  let segment = [];
-  let seglen = 0;
-  let pathCommand = '';
-  const transformedPath = [] as PathTransform[];
 
-  if (!matrixInstance.isIdentity) {
-    for (i = 0, ii = absolutePath.length; i < ii; i += 1) {
-      segment = normalizedPath[i];
-      seglen = segment.length;
+  if (matrixInstance.isIdentity) return path;
 
-      params.x1 = +segment[seglen - 2];
-      params.y1 = +segment[seglen - 1];
-      params.x2 = +segment[seglen - 4] || params.x1;
-      params.y2 = +segment[seglen - 3] || params.y1;
+  return iterate<AbsoluteArray>(path, (seg, _, i) => {
+    const absSegment = absolutizeSegment(seg, transformParams);
+    [pathCommand] = absSegment;
 
-      const result = {
-        s: absolutePath[i],
-        c: absolutePath[i][0],
-        x: params.x1,
-        y: params.y1,
-      };
+    let result =
+      pathCommand === 'A'
+        ? segmentToCubic(absSegment, transformParams)
+        : ['V', 'H'].includes(pathCommand)
+        ? normalizeSegment(absSegment, transformParams)
+        : absSegment;
+    const isLongArc = result[0] === 'C' && result.length > 7;
+    const normalizedSegment = (isLongArc ? result.slice(0, 7) : result.slice(0)) as typeof result;
 
-      transformedPath.push(result);
+    if (isLongArc) {
+      path.splice(i + 1, 0, ['C', ...result.slice(7)] as CSegment);
+      result = result.slice(0, 7) as CSegment;
     }
 
-    return transformedPath.map(seg => {
-      pathCommand = seg.c;
-      segment = seg.s;
-      if (pathCommand === 'L' || pathCommand === 'H' || pathCommand === 'V') {
-        [lx, ly] = projection2d(matrixInstance, [seg.x, seg.y], origin as [number, number, number]);
-
-        /* istanbul ignore else @preserve */
-        if (x !== lx && y !== ly) {
-          segment = ['L', lx, ly];
-        } else if (y === ly) {
-          segment = ['H', lx];
-        } else if (x === lx) {
-          segment = ['V', ly];
-        }
+    if (result[0] === 'L') {
+      const values = result.slice(-2) as PointTuple;
+      [lx, ly] = projection2d(matrixInstance, values, origin);
 
-        // now update x and y
-        x = lx;
-        y = ly;
-
-        return segment;
-      } else {
-        for (j = 1, jj = segment.length; j < jj; j += 2) {
-          [x, y] = projection2d(matrixInstance, [+segment[j], +segment[j + 1]], origin as [number, number, number]);
-          segment[j] = x;
-          segment[j + 1] = y;
-        }
+      /* istanbul ignore else @preserve */
+      if (x !== lx && y !== ly) {
+        result = ['L', lx, ly];
+      } else if (y === ly) {
+        result = ['H', lx];
+      } else if (x === lx) {
+        result = ['V', ly];
+      }
+    } else {
+      for (j = 1, jj = result.length; j < jj; j += 2) {
+        [lx, ly] = projection2d(matrixInstance, [+result[j], +result[j + 1]], origin);
+        result[j] = lx;
+        result[j + 1] = ly;
+      }
+    }
+    // now update x and y
+    x = lx;
+    y = ly;
 
-        return segment;
+    if (pathCommand === 'Z') {
+      nx = mx;
+      ny = my;
+    } else {
+      [nx, ny] = normalizedSegment.slice(-2) as PointTuple;
+      if (pathCommand === 'M') {
+        mx = nx;
+        my = ny;
       }
-    }) as PathArray;
-  }
-  return absolutePath.slice(0) as AbsoluteArray;
+    }
+
+    const seglen = normalizedSegment.length;
+    transformParams.x1 = +normalizedSegment[seglen - 2];
+    transformParams.y1 = +normalizedSegment[seglen - 1];
+    transformParams.x2 = +normalizedSegment[seglen - 4] || transformParams.x1;
+    transformParams.y2 = +normalizedSegment[seglen - 3] || transformParams.y1;
+    transformParams.x = nx;
+    transformParams.y = ny;
+    return result;
+  });
 };
+
 export default transformPath;

package/src/types.ts

@@ -1,4 +1,13 @@
-import type { LineAttr, CircleAttr, PolyAttr, RectAttr, EllipseAttr, GlyphAttr, TransformObject } from './interface';
+import type {
+  LineAttr,
+  CircleAttr,
+  PolyAttr,
+  RectAttr,
+  EllipseAttr,
+  GlyphAttr,
+  TransformObject,
+  ParserParams,
+} from './interface';
 
 export type SpaceNumber =
   | 0x1680
@@ -196,3 +205,28 @@ export type Point = {
   x: number;
   y: number;
 };
+
+export type PointTuple = [number, number];
+
+export type DerivedPoint = Point & { t: number };
+export type QuadPoints = [Point, Point, Point, Point, Point, Point];
+export type CubicPoints = [Point, Point, Point, Point, Point, Point, Point, Point];
+export type DerivedQuadPoints = [DerivedPoint, DerivedPoint, DerivedPoint, DerivedPoint, DerivedPoint, DerivedPoint];
+export type DerivedCubicPoints = [
+  DerivedPoint,
+  DerivedPoint,
+  DerivedPoint,
+  DerivedPoint,
+  DerivedPoint,
+  DerivedPoint,
+  DerivedPoint,
+  DerivedPoint,
+];
+export type QuadCoordinates = [number, number, number, number, number, number];
+export type CubicCoordinates = [number, number, number, number, number, number, number, number];
+export type ArcCoordinates = [number, number, number, number, number, number, number, number, number];
+export type LineCoordinates = [number, number, number, number];
+
+export type DeriveCallback = (t: number) => Point;
+
+export type IteratorCallback = (segment: PathSegment, params: ParserParams, index: number) => PathSegment;

package/src/util/getPathArea.ts

@@ -1,5 +1,5 @@
 import pathToCurve from '../convert/pathToCurve';
-import type { PathArray } from '../types';
+import type { PointTuple, PathArray, QuadCoordinates } from '../types';
 
 /**
  * Returns the area of a single cubic-bezier segment.
@@ -60,8 +60,8 @@ const getPathArea = (path: PathArray) => {
           [, x, y] = seg;
           return 0;
         default:
-          len = getCubicSegArea(x, y, ...(seg.slice(1) as [number, number, number, number, number, number]));
-          [x, y] = seg.slice(-2) as [number, number];
+          len = getCubicSegArea(x, y, ...(seg.slice(1) as QuadCoordinates));
+          [x, y] = seg.slice(-2) as PointTuple;
           return len;
       }
     })

package/src/util/getPathBBox.ts

@@ -1,15 +1,26 @@
-import { PathBBox } from 'src/interface';
-import { PathArray } from 'src/types';
-import pathFactory from './pathFactory';
-
-/**
- * Returns the bounding box of a shape.
- *
- * @param path the shape `pathArray`
- * @returns the length of the cubic-bezier segment
- */
-const getPathBBox = (path: PathArray | string): PathBBox => {
-  if (!path) {
+import iterate from '../process/iterate';
+import { PathBBox } from '../interface';
+import {
+  ArcCoordinates,
+  CubicCoordinates,
+  LineCoordinates,
+  MSegment,
+  PathArray,
+  Point,
+  PointTuple,
+  QuadCoordinates,
+} from '../types';
+// import pathFactory from './pathFactory';
+import absolutizeSegment from '../process/absolutizeSegment';
+import normalizeSegment from '../process/normalizeSegment';
+import parsePathString from '../parser/parsePathString';
+import { getLineBBox } from '../math/lineTools';
+import { getArcBBox } from '../math/arcTools';
+import { getCubicBBox } from '../math/cubicTools';
+import { getQuadBBox } from '../math/quadTools';
+
+const getPathBBox = (pathInput: PathArray | string) => {
+  if (!pathInput) {
     return {
       x: 0,
       y: 0,
@@ -23,12 +34,67 @@ const getPathBBox = (path: PathArray | string): PathBBox => {
     };
   }
 
-  const props = pathFactory(path);
-  const {
-    min: { x: xMin, y: yMin },
-    max: { x: xMax, y: yMax },
-  } = props.bbox;
+  const path = parsePathString(pathInput);
+  let data = [] as number[];
+  let pathCommand = 'M';
+  let x = 0;
+  let y = 0;
+  let mx = 0;
+  let my = 0;
+  const MIN = [] as Point[];
+  const MAX = [] as Point[];
+  let min = { x, y };
+  let max = { x, y };
+
+  iterate(path, (seg, params) => {
+    const absoluteSegment = absolutizeSegment(seg, params);
+    const normalSegment = normalizeSegment(absoluteSegment, params);
+    [pathCommand] = normalSegment;
+    data = [x, y, ...normalSegment.slice(1)] as number[];
+
+    // this segment is always ZERO
+    /* istanbul ignore else @preserve */
+    if (pathCommand === 'M') {
+      // remember mx, my for Z
+      [, mx, my] = normalSegment as MSegment;
+      min = { x: mx, y: my };
+      max = { x: mx, y: my };
+    } else if (pathCommand === 'L') {
+      ({ min, max } = getLineBBox(...(data as LineCoordinates)));
+    } else if (pathCommand === 'A') {
+      ({ min, max } = getArcBBox(...(data as ArcCoordinates)));
+    } else if (pathCommand === 'C') {
+      ({ min, max } = getCubicBBox(...(data as CubicCoordinates)));
+    } else if (pathCommand === 'Q') {
+      ({ min, max } = getQuadBBox(...(data as QuadCoordinates)));
+    } else if (pathCommand === 'Z') {
+      data = [x, y, mx, my];
+      ({ min, max } = getLineBBox(...(data as LineCoordinates)));
+    }
+
+    MIN.push(min);
+    MAX.push(max);
 
+    if (pathCommand === 'Z') {
+      x = mx;
+      y = my;
+    } else {
+      [x, y] = normalSegment.slice(-2) as PointTuple;
+
+      if (pathCommand === 'M') {
+        mx = x;
+        my = y;
+      }
+    }
+    params.x = x;
+    params.y = y;
+    return normalSegment;
+  });
+
+  const xMin = Math.min(...MIN.map(n => n.x));
+  const xMax = Math.max(...MAX.map(n => n.x));
+  const yMin = Math.min(...MIN.map(n => n.y));
+  const yMax = Math.max(...MAX.map(n => n.y));
   const width = xMax - xMin;
   const height = yMax - yMin;
 
@@ -41,8 +107,9 @@ const getPathBBox = (path: PathArray | string): PathBBox => {
     y2: yMax,
     cx: xMin + width / 2,
     cy: yMin + height / 2,
-    // an estimted guess
+    // an estimated guess
     cz: Math.max(width, height) + Math.min(width, height) / 2,
-  };
+  } satisfies PathBBox;
 };
+
 export default getPathBBox;

package/src/util/getPointAtLength.ts

@@ -1,5 +1,21 @@
-import type { PathArray } from '../types';
-import pathFactory from './pathFactory';
+import DISTANCE_EPSILON from './distanceEpsilon';
+import parsePathString from '../parser/parsePathString';
+import type {
+  ArcCoordinates,
+  CubicCoordinates,
+  LineCoordinates,
+  MSegment,
+  PathArray,
+  PointTuple,
+  QuadCoordinates,
+} from '../types';
+import iterate from '../process/iterate';
+import absolutizeSegment from '../process/absolutizeSegment';
+import normalizeSegment from '../process/normalizeSegment';
+import { getLineLength, getPointAtLineLength } from '../math/lineTools';
+import { getArcLength, getPointAtArcLength } from '../math/arcTools';
+import { getCubicLength, getPointAtCubicLength } from '../math/cubicTools';
+import { getQuadLength, getPointAtQuadLength } from '../math/quadTools';
 
 /**
  * Returns [x,y] coordinates of a point at a given length of a shape.
@@ -8,7 +24,85 @@ import pathFactory from './pathFactory';
  * @param distance the length of the shape to look at
  * @returns the requested {x, y} point coordinates
  */
-const getPointAtLength = (pathInput: string | PathArray, distance: number) => {
-  return pathFactory(pathInput, distance).point;
+const getPointAtLength = (pathInput: string | PathArray, distance?: number) => {
+  const path = parsePathString(pathInput);
+  let isM = false;
+  let data = [] as number[];
+  let pathCommand = 'M';
+  let x = 0;
+  let y = 0;
+  let [mx, my] = path[0].slice(1) as PointTuple;
+  const distanceIsNumber = typeof distance === 'number';
+  let point = { x: mx, y: my };
+  let length = 0;
+  let POINT = point;
+  let totalLength = 0;
+
+  if (!distanceIsNumber) return point;
+
+  if (distance < DISTANCE_EPSILON) {
+    POINT = point;
+  }
+
+  iterate(path, (seg, params) => {
+    const absoluteSegment = absolutizeSegment(seg, params);
+    const normalSegment = normalizeSegment(absoluteSegment, params);
+    [pathCommand] = normalSegment;
+    isM = pathCommand === 'M';
+    data = !isM ? [x, y, ...(normalSegment.slice(1) as number[])] : data;
+
+    // this segment is always ZERO
+    /* istanbul ignore else @preserve */
+    if (isM) {
+      // remember mx, my for Z
+      [, mx, my] = seg as MSegment;
+      point = { x: mx, y: my };
+      length = 0;
+    } else if (pathCommand === 'L') {
+      point = getPointAtLineLength(...(data as LineCoordinates), distance - totalLength);
+      length = getLineLength(...(data as LineCoordinates));
+    } else if (pathCommand === 'A') {
+      point = getPointAtArcLength(...(data as ArcCoordinates), distance - totalLength);
+      length = getArcLength(...(data as ArcCoordinates));
+    } else if (pathCommand === 'C') {
+      point = getPointAtCubicLength(...(data as CubicCoordinates), distance - totalLength);
+      length = getCubicLength(...(data as CubicCoordinates));
+    } else if (pathCommand === 'Q') {
+      point = getPointAtQuadLength(...(data as QuadCoordinates), distance - totalLength);
+      length = getQuadLength(...(data as QuadCoordinates));
+    } else if (pathCommand === 'Z') {
+      data = [x, y, mx, my];
+      point = { x: mx, y: my };
+      length = getLineLength(...(data as LineCoordinates));
+    }
+
+    if (totalLength < distance && totalLength + length >= distance) {
+      POINT = point;
+    }
+
+    totalLength += length;
+    if (pathCommand === 'Z') {
+      x = mx;
+      y = my;
+    } else {
+      [x, y] = normalSegment.slice(-2) as PointTuple;
+
+      if (pathCommand === 'M') {
+        mx = x;
+        my = y;
+      }
+    }
+    params.x = x;
+    params.y = y;
+    return normalSegment;
+  });
+
+  // native `getPointAtLength` behavior when the given distance
+  // is higher than total length
+  if (distance > totalLength - DISTANCE_EPSILON) {
+    POINT = { x, y };
+  }
+
+  return POINT;
 };
 export default getPointAtLength;

package/src/util/getPropertiesAtLength.ts

@@ -1,4 +1,4 @@
-import type { PathArray, PathSegment } from '../types';
+import type { PointTuple, PathArray, PathSegment } from '../types';
 import type { SegmentProperties } from '../interface';
 import parsePathString from '../parser/parsePathString';
 import getTotalLength from './getTotalLength';
@@ -20,7 +20,7 @@ const getPropertiesAtLength = (pathInput: string | PathArray, distance?: number)
   let lengthAtSegment = 0;
   let length = 0;
   let segment = pathArray[0] as PathSegment;
-  const [x, y] = segment.slice(-2) as [number, number];
+  const [x, y] = segment.slice(-2) as PointTuple;
   const point = { x, y };
 
   // If the path is empty, return 0.

package/src/util/getTotalLength.ts

@@ -1,5 +1,21 @@
-import type { PathArray } from '../types';
-import pathFactory from './pathFactory';
+import parsePathString from '../parser/parsePathString';
+import type {
+  ArcCoordinates,
+  CubicCoordinates,
+  LineCoordinates,
+  MSegment,
+  PathArray,
+  PointTuple,
+  QuadCoordinates,
+} from '../types';
+import { getLineLength } from '../math/lineTools';
+import { getArcLength } from '../math/arcTools';
+import { getCubicLength } from '../math/cubicTools';
+import { getQuadLength } from '../math/quadTools';
+import iterate from '../process/iterate';
+import absolutizeSegment from '../process/absolutizeSegment';
+import normalizeSegment from '../process/normalizeSegment';
+// import pathFactory from './pathFactory';
 
 /**
  * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.
@@ -10,7 +26,58 @@ import pathFactory from './pathFactory';
  * @param pathInput the target `pathArray`
  * @returns the shape total length
  */
-const getTotalLength = (pathInput: string | PathArray): number => {
-  return pathFactory(pathInput).length;
+const getTotalLength = (pathInput: string | PathArray) => {
+  const path = parsePathString(pathInput);
+  let isM = false;
+  let data = [] as number[];
+  let pathCommand = 'M';
+  let x = 0;
+  let y = 0;
+  let mx = 0;
+  let my = 0;
+  let totalLength = 0;
+
+  iterate(path, (seg, params) => {
+    const absoluteSegment = absolutizeSegment(seg, params);
+    const normalSegment = normalizeSegment(absoluteSegment, params);
+    [pathCommand] = normalSegment;
+    isM = pathCommand === 'M';
+    data = !isM ? [x, y, ...(normalSegment.slice(1) as number[])] : data;
+
+    // this segment is always ZERO
+    /* istanbul ignore else @preserve */
+    if (isM) {
+      // remember mx, my for Z
+      [, mx, my] = seg as MSegment;
+    } else if (pathCommand === 'L') {
+      totalLength += getLineLength(...(data as LineCoordinates));
+    } else if (pathCommand === 'A') {
+      totalLength += getArcLength(...(data as ArcCoordinates));
+    } else if (pathCommand === 'C') {
+      totalLength += getCubicLength(...(data as CubicCoordinates));
+    } else if (pathCommand === 'Q') {
+      totalLength += getQuadLength(...(data as QuadCoordinates));
+    } else if (pathCommand === 'Z') {
+      data = [x, y, mx, my];
+      totalLength += getLineLength(...(data as LineCoordinates));
+    }
+    if (pathCommand === 'Z') {
+      x = mx;
+      y = my;
+    } else {
+      [x, y] = normalSegment.slice(-2) as PointTuple;
+
+      if (isM) {
+        mx = x;
+        my = y;
+      }
+    }
+    params.x = x;
+    params.y = y;
+    return normalSegment;
+  });
+
+  return totalLength;
 };
+
 export default getTotalLength;