svg-path-commander 2.0.10 → 2.1.1

package/src/process/transformPath.ts

@@ -1,13 +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 defaultOptions from '../options/options';
-import type { PathArray, PathCommand, 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.
@@ -19,110 +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;
-  const absolutePath = pathToAbsolute(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];
+  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 = '';
-  let transformedPath = [] as PathTransform[];
-  const allPathCommands = [] as PathCommand[]; // needed for arc to curve transformation
-
-  if (!matrixInstance.isIdentity) {
-    for (i = 0, ii = absolutePath.length; i < ii; i += 1) {
-      segment = absolutePath[i];
 
-      /* istanbul ignore else */
-      if (absolutePath[i]) [pathCommand] = segment;
+  if (matrixInstance.isIdentity) return path;
 
-      // REPLACE Arc path commands with Cubic Beziers
-      // we don't have any scripting know-how on 3d ellipse transformation
-      // Arc segments don't work 3D transformations or skews
-      /// ////////////////////////////////////////
-      allPathCommands[i] = pathCommand as PathCommand;
+  return iterate<AbsoluteArray>(path, (seg, _, i) => {
+    const absSegment = absolutizeSegment(seg, transformParams);
+    [pathCommand] = absSegment;
 
-      if (pathCommand === 'A') {
-        segment = segmentToCubic(normalizedPath[i], params);
+    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;
 
-        absolutePath[i] = segmentToCubic(normalizedPath[i], params);
-        fixArc(absolutePath, allPathCommands, i);
+    if (isLongArc) {
+      path.splice(i + 1, 0, ['C', ...result.slice(7)] as CSegment);
+      result = result.slice(0, 7) as CSegment;
+    }
 
-        normalizedPath[i] = segmentToCubic(normalizedPath[i], params);
-        fixArc(normalizedPath, allPathCommands, i);
-        ii = Math.max(absolutePath.length, normalizedPath.length);
+    if (result[0] === 'L') {
+      const values = result.slice(-2) as PointTuple;
+      [lx, ly] = projection2d(matrixInstance, values, origin);
+
+      /* 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;
       }
-
-      /// ////////////////////////////////////////
-      segment = normalizedPath[i];
-      seglen = segment.length;
-
-      params.x1 = +segment[seglen - 2];
-      params.y1 = +segment[seglen - 1];
-      params.x2 = +segment[seglen - 4] || params.x1;
-      params.y2 = +segment[seglen - 3] || params.y1;
-
-      const result = {
-        s: absolutePath[i],
-        c: absolutePath[i][0],
-        x: params.x1,
-        y: params.y1,
-      };
-
-      transformedPath = [...transformedPath, ...[result]];
     }
-
-    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 */
-        if (x !== lx && y !== ly) {
-          segment = ['L', lx, ly];
-        } else if (y === ly) {
-          segment = ['H', lx];
-        } else if (x === lx) {
-          segment = ['V', ly];
-        }
-
-        // 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;
-        }
-
-        return segment;
+    // now update x and y
+    x = lx;
+    y = ly;
+
+    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];
+    }
+
+    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
@@ -191,3 +200,33 @@ export type ShapeTags = 'line' | 'polyline' | 'polygon' | 'ellipse' | 'circle' |
 export type ShapeOps = LineAttr | PolyAttr | PolyAttr | EllipseAttr | CircleAttr | RectAttr | GlyphAttr;
 
 export type TransformObjectValues = Partial<TransformObject> & { origin: [number, number, number] };
+
+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/distanceEpsilon.ts

@@ -0,0 +1,3 @@
+const DISTANCE_EPSILON = 0.00001;
+
+export default DISTANCE_EPSILON;

package/src/util/getClosestPoint.ts

@@ -8,7 +8,7 @@ import getPropertiesAtPoint from './getPropertiesAtPoint';
  * @param point the given point
  * @returns the best match
  */
-const getClosestPoint = (pathInput: string | PathArray, point: { x: number; y: number }): { x: number; y: number } => {
+const getClosestPoint = (pathInput: string | PathArray, point: { x: number; y: number }) => {
   return getPropertiesAtPoint(pathInput, point).closest;
 };
 

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 pathLengthFactory from './pathLengthFactory';
-
-/**
- * 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,11 +34,67 @@ const getPathBBox = (path?: PathArray | string): PathBBox => {
     };
   }
 
-  const {
-    min: { x: xMin, y: yMin },
-    max: { x: xMax, y: yMax },
-  } = pathLengthFactory(path);
+  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;
 
@@ -40,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 pathLengthFactory from './pathLengthFactory';
+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 pathLengthFactory from './pathLengthFactory';
  * @param distance the length of the shape to look at
  * @returns the requested {x, y} point coordinates
  */
-const getPointAtLength = (pathInput: string | PathArray, distance: number): { x: number; y: number } => {
-  return pathLengthFactory(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';
@@ -14,13 +14,13 @@ import getTotalLength from './getTotalLength';
 const getPropertiesAtLength = (pathInput: string | PathArray, distance?: number): SegmentProperties => {
   const pathArray = parsePathString(pathInput);
 
-  let pathTemp = [...pathArray] as PathArray;
+  let pathTemp = pathArray.slice(0) as PathArray;
   let pathLength = getTotalLength(pathTemp);
   let index = pathTemp.length - 1;
   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.
@@ -64,4 +64,5 @@ const getPropertiesAtLength = (pathInput: string | PathArray, distance?: number)
 
   return segments.find(({ lengthAtSegment: l }) => l <= distance) as SegmentProperties;
 };
+
 export default getPropertiesAtLength;

package/src/util/getPropertiesAtPoint.ts

@@ -36,6 +36,7 @@ const getPropertiesAtPoint = (pathInput: string | PathArray, point: { x: number;
   for (let scanLength = 0; scanLength <= pathLength; scanLength += precision) {
     scan = getPointAtLength(normalPath, scanLength);
     scanDistance = distanceTo(scan);
+
     if (scanDistance < bestDistance) {
       closest = scan;
       bestLength = scanLength;
@@ -52,13 +53,14 @@ const getPropertiesAtPoint = (pathInput: string | PathArray, point: { x: number;
   let beforeDistance = 0;
   let afterDistance = 0;
 
-  while (precision > 0.5) {
+  while (precision > 0.000001) {
     beforeLength = bestLength - precision;
     before = getPointAtLength(normalPath, beforeLength);
     beforeDistance = distanceTo(before);
     afterLength = bestLength + precision;
     after = getPointAtLength(normalPath, afterLength);
     afterDistance = distanceTo(after);
+
     if (beforeLength >= 0 && beforeDistance < bestDistance) {
       closest = before;
       bestLength = beforeLength;
@@ -70,6 +72,7 @@ const getPropertiesAtPoint = (pathInput: string | PathArray, point: { x: number;
     } else {
       precision /= 2;
     }
+    if (precision < 0.00001) break;
   }
 
   const segment = getPropertiesAtLength(path, bestLength);

package/src/util/getTotalLength.ts

@@ -1,5 +1,21 @@
-import type { PathArray } from '../types';
-import pathLengthFactory from './pathLengthFactory';
+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 pathLengthFactory from './pathLengthFactory';
  * @param pathInput the target `pathArray`
  * @returns the shape total length
  */
-const getTotalLength = (pathInput: string | PathArray): number => {
-  return pathLengthFactory(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;