svg-path-commander 2.1.1 → 2.1.2

package/src/process/relativizeSegment.ts

@@ -1,4 +1,3 @@
-import type { ParserParams } from '../interface';
 import type {
   RelativeSegment,
   RelativeCommand,
@@ -10,52 +9,51 @@ import type {
   tSegment,
   sSegment,
   cSegment,
+  MSegment,
+  lSegment,
 } from '../types';
 
 /**
  * Returns a relative segment of a `PathArray` object.
  *
  * @param segment the segment object
- * @param params the coordinates of the previous segment
  * @param index the segment index
- * @returns the absolute segment
+ * @param lastX the last known X value
+ * @param lastY the last known Y value
+ * @returns the relative segment
  */
-const relativizeSegment = (segment: PathSegment, params: ParserParams, index: number) => {
+const relativizeSegment = (segment: PathSegment, index: number, lastX: number, lastY: number) => {
   const [pathCommand] = segment;
-  const { x, y } = params;
-  const values = segment.slice(1).map(Number);
   const relCommand = pathCommand.toLowerCase() as RelativeCommand;
-
-  if (index === 0 && pathCommand === 'M') {
-    return segment;
-  }
+  const isRelative = pathCommand === relCommand;
 
   /* istanbul ignore else @preserve */
-  if (pathCommand !== relCommand) {
-    if (relCommand === 'a') {
-      return [
-        relCommand,
-        values[0],
-        values[1],
-        values[2],
-        values[3],
-        values[4],
-        values[5] - x,
-        values[6] - y,
-      ] as aSegment;
-    } else if (relCommand === 'v') {
-      return [relCommand, values[0] - y] as vSegment;
-    } else if (relCommand === 'h') {
-      return [relCommand, values[0] - x] as hSegment;
-    } else {
-      // use brakets for `eslint: no-case-declaration`
-      // https://stackoverflow.com/a/50753272/803358
-      const relValues = values.map((n, j) => n - (j % 2 ? y : x));
-      // for n, l, c, s, q, t
-      return [relCommand, ...relValues] as qSegment | tSegment | sSegment | cSegment;
-    }
-  }
+  if (index === 0 || isRelative) return segment as MSegment | RelativeSegment;
 
-  return segment as RelativeSegment;
+  if (relCommand === 'a') {
+    return [
+      relCommand,
+      segment[1],
+      segment[2],
+      segment[3],
+      segment[4],
+      segment[5],
+      (segment as aSegment)[6] - lastX,
+      (segment as aSegment)[7] - lastY,
+    ] as aSegment;
+  } else if (relCommand === 'v') {
+    return [relCommand, (segment as vSegment)[1] - lastY] as vSegment;
+  } else if (relCommand === 'h') {
+    return [relCommand, (segment as hSegment)[1] - lastX] as hSegment;
+  } else if (relCommand === 'l') {
+    return [relCommand, (segment as lSegment)[1] - lastX, (segment as lSegment)[2] - lastY] as lSegment;
+  } else {
+    // use brakets for `eslint: no-case-declaration`
+    // https://stackoverflow.com/a/50753272/803358
+    const relValues = (segment.slice(1) as number[]).map((n, j) => n - (j % 2 ? lastY : lastX));
+    // for c, s, q, t
+    return [relCommand as RelativeCommand | number].concat(relValues) as qSegment | tSegment | sSegment | cSegment;
+  }
 };
+
 export default relativizeSegment;

package/src/process/reverseCurve.ts

@@ -1,4 +1,4 @@
-import type { CurveArray } from '../types';
+import type { CSegment, CurveArray, MSegment, PathCommand } from '../types';
 
 /**
  * Reverses all segments of a `pathArray`
@@ -7,15 +7,18 @@ import type { CurveArray } from '../types';
  * @param path the source `pathArray`
  * @returns the reversed `pathArray`
  */
-const reverseCurve = (path: CurveArray): CurveArray => {
+const reverseCurve = (path: CurveArray) => {
   const rotatedCurve = path
     .slice(1)
     .map((x, i, curveOnly) =>
-      !i ? [...path[0].slice(1), ...x.slice(1)] : [...curveOnly[i - 1].slice(-2), ...x.slice(1)],
+      !i ? path[0].slice(1).concat(x.slice(1) as number[]) : curveOnly[i - 1].slice(-2).concat(x.slice(1)),
     )
     .map(x => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))
-    .reverse();
+    .reverse() as (MSegment | CSegment)[];
 
-  return [['M', ...rotatedCurve[0].slice(0, 2)], ...rotatedCurve.map(x => ['C', ...x.slice(2)])] as CurveArray;
+  return [['M' as PathCommand | number].concat(rotatedCurve[0].slice(0, 2))].concat(
+    rotatedCurve.map(x => ['C' as PathCommand | number].concat(x.slice(2))),
+  ) as CurveArray;
 };
+
 export default reverseCurve;

package/src/process/reversePath.ts

@@ -5,6 +5,7 @@ import type {
   MSegment,
   PathArray,
   PathSegment,
+  PointTuple,
   QSegment,
   SSegment,
   TSegment,
@@ -12,90 +13,102 @@ import type {
 } from '../types';
 import pathToAbsolute from '../convert/pathToAbsolute';
 import normalizePath from './normalizePath';
+import iterate from './iterate';
 
 /**
- * Reverses all segments of a `pathArray` and returns a new `pathArray` instance.
+ * Reverses all segments of a `pathArray` and returns a new `pathArray` instance
+ * with absolute values.
  *
  * @param pathInput the source `pathArray`
  * @returns the reversed `pathArray`
  */
-const reversePath = (pathInput: PathArray): PathArray => {
+const reversePath = (pathInput: PathArray) => {
   const absolutePath = pathToAbsolute(pathInput);
-  const isClosed = absolutePath.slice(-1)[0][0] === 'Z';
+  const normalizedPath = normalizePath(absolutePath);
+  const pLen = absolutePath.length;
+  const isClosed = absolutePath[pLen - 1][0] === 'Z';
 
-  const reversedPath = normalizePath(absolutePath)
-    .map((segment, i) => {
-      const [x, y] = segment.slice(-2).map(Number);
-      return {
-        seg: absolutePath[i], // absolute
-        n: segment, // normalized
-        c: absolutePath[i][0], // pathCommand
-        x, // x
-        y, // y
-      };
-    })
-    .map((seg, i, path) => {
-      const segment = seg.seg;
-      const data = seg.n;
-      const prevSeg = i && path[i - 1];
-      const nextSeg = path[i + 1];
-      const pathCommand = seg.c;
-      const pLen = path.length;
-      const x = i ? path[i - 1].x : path[pLen - 1].x;
-      const y = i ? path[i - 1].y : path[pLen - 1].y;
-      let result = [];
+  const reversedPath = iterate(absolutePath, (segment, i) => {
+    const normalizedSegment = normalizedPath[i];
+    const prevSeg = i && absolutePath[i - 1];
+    const prevCommand = prevSeg && prevSeg[0];
+    const nextSeg = absolutePath[i + 1];
+    const nextCommand = nextSeg && nextSeg[0];
+    const [pathCommand] = segment;
+    const [x, y] = normalizedPath[i ? i - 1 : pLen - 1].slice(-2) as PointTuple;
+    let result = segment;
 
-      switch (pathCommand) {
-        case 'M':
-          result = (isClosed ? ['Z'] : [pathCommand, x, y]) as PathSegment;
-          break;
-        case 'A':
-          result = [pathCommand, ...segment.slice(1, -3), segment[5] === 1 ? 0 : 1, x, y] as ASegment;
-          break;
-        case 'C':
-          if (nextSeg && nextSeg.c === 'S') {
-            result = ['S', segment[1], segment[2], x, y] as SSegment;
-          } else {
-            result = [pathCommand, segment[3], segment[4], segment[1], segment[2], x, y] as CSegment;
-          }
-          break;
-        case 'S':
-          if (prevSeg && 'CS'.includes(prevSeg.c) && (!nextSeg || nextSeg.c !== 'S')) {
-            result = ['C', data[3], data[4], data[1], data[2], x, y] as CSegment;
-          } else {
-            result = [pathCommand, data[1], data[2], x, y] as SSegment;
-          }
-          break;
-        case 'Q':
-          if (nextSeg && nextSeg.c === 'T') {
-            result = ['T', x, y] as TSegment;
-          } else {
-            result = [pathCommand, ...segment.slice(1, -2), x, y] as QSegment;
-          }
-          break;
-        case 'T':
-          if (prevSeg && 'QT'.includes(prevSeg.c) && (!nextSeg || nextSeg.c !== 'T')) {
-            result = ['Q', data[1], data[2], x, y] as QSegment;
-          } else {
-            result = [pathCommand, x, y] as TSegment;
-          }
-          break;
-        case 'Z':
-          result = ['M', x, y] as MSegment;
-          break;
-        case 'H':
-          result = [pathCommand, x] as HSegment;
-          break;
-        case 'V':
-          result = [pathCommand, y] as VSegment;
-          break;
-        default:
-          result = [pathCommand, ...segment.slice(1, -2), x, y] as PathSegment;
-      }
+    switch (pathCommand) {
+      case 'M':
+        result = (isClosed ? ['Z'] : [pathCommand, x, y]) as PathSegment;
+        break;
+      case 'A':
+        result = [
+          pathCommand,
+          segment[1],
+          segment[2],
+          segment[3],
+          segment[4],
+          segment[5] === 1 ? 0 : 1,
+          x,
+          y,
+        ] as ASegment;
+        break;
+      case 'C':
+        if (nextSeg && nextCommand === 'S') {
+          result = ['S', segment[1], segment[2], x, y] as SSegment;
+        } else {
+          result = [pathCommand, segment[3], segment[4], segment[1], segment[2], x, y] as CSegment;
+        }
+        break;
+      case 'S':
+        if (prevCommand && 'CS'.includes(prevCommand) && (!nextSeg || nextCommand !== 'S')) {
+          result = [
+            'C',
+            normalizedSegment[3],
+            normalizedSegment[4],
+            normalizedSegment[1],
+            normalizedSegment[2],
+            x,
+            y,
+          ] as CSegment;
+        } else {
+          result = [pathCommand, normalizedSegment[1], normalizedSegment[2], x, y] as SSegment;
+        }
+        break;
+      case 'Q':
+        if (nextSeg && nextCommand === 'T') {
+          result = ['T', x, y] as TSegment;
+        } else {
+          result = [pathCommand, segment[1], segment[2], x, y] as QSegment;
+        }
+        break;
+      case 'T':
+        if (prevCommand && 'QT'.includes(prevCommand) && (!nextSeg || nextCommand !== 'T')) {
+          result = ['Q', normalizedSegment[1], normalizedSegment[2], x, y] as QSegment;
+        } else {
+          result = [pathCommand, x, y] as TSegment;
+        }
+        break;
+      case 'Z':
+        result = ['M', x, y] as MSegment;
+        break;
+      case 'H':
+        result = [pathCommand, x] as HSegment;
+        break;
+      case 'V':
+        result = [pathCommand, y] as VSegment;
+        break;
+      default:
+        result = [pathCommand as typeof pathCommand | number].concat(segment.slice(1, -2), x, y) as PathSegment;
+    }
 
-      return result;
-    });
+    return result;
+  });
 
-  return (isClosed ? reversedPath.reverse() : [reversedPath[0], ...reversedPath.slice(1).reverse()]) as PathArray;
+  return (
+    isClosed ? reversedPath.reverse() : [reversedPath[0] as PathSegment].concat(reversedPath.slice(1).reverse())
+  ) as PathArray;
 };
+
 export default reversePath;

package/src/process/roundPath.ts

@@ -1,6 +1,7 @@
-import type { PathArray, PathSegment } from '../types';
+import type { PathArray } from '../types';
 import defaultOptions from '../options/options';
 import iterate from './iterate';
+import roundSegment from './roundSegment';
 
 /**
  * Rounds the values of a `pathArray` instance to
@@ -12,16 +13,21 @@ import iterate from './iterate';
  */
 const roundPath = (path: PathArray, roundOption?: number | 'off') => {
   let { round } = defaultOptions;
-  if (roundOption === 'off' || round === 'off') return path.slice(0) as PathArray;
   // allow for ZERO decimals
-  round = typeof roundOption === 'number' && roundOption >= 0 ? roundOption : round;
-  // to round values to the power
-  // the `round` value must be integer
-  const pow = typeof round === 'number' && round >= 1 ? 10 ** round : 1;
+  round =
+    roundOption === 'off'
+      ? roundOption
+      : typeof roundOption === 'number' && roundOption >= 0
+      ? roundOption
+      : typeof round === 'number' && round >= 0
+      ? round
+      : /* istanbul ignore next @preserve */ 'off';
+
+  /* istanbul ignore else @preserve */
+  if (round === 'off') return path.slice(0) as PathArray;
 
   return iterate<typeof path>(path, segment => {
-    const values = (segment.slice(1) as number[]).map(n => (round ? Math.round(n * pow) / pow : Math.round(n)));
-    return [segment[0], ...values] as PathSegment;
+    return roundSegment(segment, round);
   });
 };
 export default roundPath;

package/src/process/roundSegment.ts

@@ -0,0 +1,9 @@
+import type { PathCommand, PathSegment } from '../types';
+import roundTo from '../math/roundTo';
+
+const roundSegment = <T extends PathSegment>(segment: T, roundOption: number) => {
+  const values = (segment.slice(1) as number[]).map(n => roundTo(n, roundOption));
+  return [segment[0] as PathCommand | number].concat(values) as T;
+};
+
+export default roundSegment;

package/src/process/segmentToCubic.ts

@@ -15,7 +15,7 @@ const segmentToCubic = (segment: PathSegment, params: ParserParams) => {
   const [pathCommand] = segment;
   const values = segment.slice(1).map(Number);
   const [x, y] = values;
-  let args;
+  // let args;
   const { x1: px1, y1: py1, x: px, y: py } = params;
 
   if (!'TQ'.includes(pathCommand)) {
@@ -28,17 +28,19 @@ const segmentToCubic = (segment: PathSegment, params: ParserParams) => {
     params.y = y;
     return segment;
   } else if (pathCommand === 'A') {
-    args = [px1, py1, ...values] as [number, number, number, number, number, number, number, number, number];
-    return ['C', ...arcToCubic(...args)] as CSegment;
+    return ['C' as string | number].concat(
+      arcToCubic(px1, py1, values[0], values[1], values[2], values[3], values[4], values[5], values[6]),
+    ) as CSegment;
   } else if (pathCommand === 'Q') {
     params.qx = x;
     params.qy = y;
-    args = [px1, py1, ...values] as [number, number, number, number, number, number];
-    return ['C', ...quadToCubic(...args)] as CSegment;
+    return ['C' as string | number].concat(
+      quadToCubic(px1, py1, values[0], values[1], values[2], values[3]),
+    ) as CSegment;
   } else if (pathCommand === 'L') {
-    return ['C', ...lineToCubic(px1, py1, x, y)] as CSegment;
+    return ['C' as string | number].concat(lineToCubic(px1, py1, x, y)) as CSegment;
   } else if (pathCommand === 'Z') {
-    return ['C', ...lineToCubic(px1, py1, px, py)] as CSegment;
+    return ['C' as string | number].concat(lineToCubic(px1, py1, px, py)) as CSegment;
   }
 
   return segment as MSegment | CSegment;

package/src/process/shortenSegment.ts

@@ -1,15 +1,7 @@
+import defaultOptions from '../options/options';
 import type { ParserParams } from '../interface';
-import type {
-  AbsoluteSegment,
-  HSegment,
-  NormalSegment,
-  PathCommand,
-  ShortSegment,
-  SSegment,
-  TSegment,
-  VSegment,
-  ZSegment,
-} from '../types';
+import roundTo from '../math/roundTo';
+import type { AbsoluteSegment, NormalSegment, PathCommand, ShortSegment, SSegment, TSegment } from '../types';
 
 /**
  * Shorten a single segment of a `pathArray` object.
@@ -27,12 +19,12 @@ const shortenSegment = (
   prevCommand: PathCommand,
 ): ShortSegment => {
   const [pathCommand] = segment;
-  const round4 = (n: number) => Math.round(n * 10 ** 4) / 10 ** 4;
-  const segmentValues = segment.slice(1) as number[];
+  const { round: defaultRound } = defaultOptions;
+  const round = typeof defaultRound === 'number' ? defaultRound : /* istanbul ignore next */ 4;
   const normalValues = normalSegment.slice(1) as number[];
-  const { x1: px1, y1: py1, x2: px2, y2: py2, x: px, y: py } = params;
-  let result = segment;
-  const [x, y] = normalValues.slice(-2);
+  const { x1, y1, x2, y2, x, y } = params;
+  const [nx, ny] = normalValues.slice(-2);
+  const result = segment;
 
   if (!'TQ'.includes(pathCommand)) {
     // optional but good to be cautious
@@ -40,26 +32,24 @@ const shortenSegment = (
     params.qy = null;
   }
 
-  if (['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)) {
-    result = [pathCommand, ...segmentValues] as VSegment | HSegment | SSegment | TSegment | ZSegment;
-  } else if (pathCommand === 'L') {
-    if (round4(px) === round4(x)) {
-      result = ['V', y];
-    } else if (round4(py) === round4(y)) {
-      result = ['H', x];
+  if (pathCommand === 'L') {
+    if (roundTo(x, round) === roundTo(nx, round)) {
+      return ['V', ny];
+    } else if (roundTo(y, round) === roundTo(ny, round)) {
+      return ['H', nx];
     }
   } else if (pathCommand === 'C') {
-    const [x1, y1] = normalValues;
+    const [nx1, ny1] = normalValues;
+    params.x1 = nx1;
+    params.y1 = ny1;
 
     if (
       'CS'.includes(prevCommand) &&
-      ((round4(x1) === round4(px1 * 2 - px2) && round4(y1) === round4(py1 * 2 - py2)) ||
-        (round4(px1) === round4(px2 * 2 - px) && round4(py1) === round4(py2 * 2 - py)))
+      ((roundTo(nx1, round) === roundTo(x1 * 2 - x2, round) && roundTo(ny1, round) === roundTo(y1 * 2 - y2, round)) ||
+        (roundTo(x1, round) === roundTo(x2 * 2 - x, round) && roundTo(y1, round) === roundTo(y2 * 2 - y, round)))
     ) {
-      result = ['S', ...normalValues.slice(-4)] as SSegment;
+      return ['S', normalValues[2], normalValues[3], normalValues[4], normalValues[5]] as SSegment;
     }
-    params.x1 = x1;
-    params.y1 = y1;
   } else if (pathCommand === 'Q') {
     const [qx, qy] = normalValues;
     params.qx = qx;
@@ -67,13 +57,15 @@ const shortenSegment = (
 
     if (
       'QT'.includes(prevCommand) &&
-      ((round4(qx) === round4(px1 * 2 - px2) && round4(qy) === round4(py1 * 2 - py2)) ||
-        (round4(px1) === round4(px2 * 2 - px) && round4(py1) === round4(py2 * 2 - py)))
+      roundTo(qx, round) === roundTo(x1 * 2 - x2, round) &&
+      roundTo(qy, round) === roundTo(y1 * 2 - y2, round)
     ) {
-      result = ['T', ...normalValues.slice(-2)] as TSegment;
+      return ['T', normalValues[2], normalValues[3]] as TSegment;
     }
   }
 
+  // ['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)
   return result as ShortSegment;
 };
+
 export default shortenSegment;

package/src/process/splitCubic.ts

@@ -22,8 +22,8 @@ const splitCubic = (pts: number[], ratio = 0.5): [CubicSegment, CubicSegment] =>
   const p9 = midPoint(p7, p8, t);
 
   return [
-    ['C', ...p4, ...p7, ...p9],
-    ['C', ...p8, ...p6, ...p3],
+    ['C', p4[0], p4[1], p7[0], p7[1], p9[0], p9[1]],
+    ['C', p8[0], p8[1], p6[0], p6[1], p3[0], p3[1]],
   ];
 };
 export default splitCubic;

package/src/process/transformPath.ts

@@ -1,14 +1,14 @@
 import getSVGMatrix from './getSVGMatrix';
 import projection2d from './projection2d';
 import defaultOptions from '../options/options';
-import type { AbsoluteArray, CSegment, PathArray, PointTuple, TransformObjectValues } from '../types';
+import type { AbsoluteArray, AbsoluteSegment, CSegment, LSegment, PathArray, 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';
+import absolutizeSegment from './absolutizeSegment';
 
 /**
  * Apply a 2D / 3D transformation to a `pathArray` instance.
@@ -21,16 +21,15 @@ import paramsParser from '../parser/paramsParser';
  * @returns the resulted `pathArray`
  */
 const transformPath = (pathInput: PathArray | string, transform?: Partial<TransformObject>) => {
+  // last x and y transformed values
   let x = 0;
   let y = 0;
-  let mx = 0;
-  let my = 0;
+  // new x and y transformed
   let lx = 0;
   let ly = 0;
+  // segment params iteration index and length
   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 };
@@ -38,7 +37,7 @@ const transformPath = (pathInput: PathArray | string, transform?: Partial<Transf
   const transformProps = transform && Object.keys(transform);
 
   // when used as a static method, invalidate somehow
-  if (!transform || (transformProps && !transformProps.length)) return path;
+  if (!transform || (transformProps && !transformProps.length)) return path.slice(0) as typeof path;
 
   // transform origin is extremely important
   if (!transform.origin) {
@@ -47,29 +46,37 @@ const transformPath = (pathInput: PathArray | string, transform?: Partial<Transf
   const origin = transform.origin as [number, number, number];
   const matrixInstance = getSVGMatrix(transform as TransformObjectValues);
 
-  if (matrixInstance.isIdentity) return path;
+  if (matrixInstance.isIdentity) return path.slice(0) as typeof path;
 
-  return iterate<AbsoluteArray>(path, (seg, _, i) => {
-    const absSegment = absolutizeSegment(seg, transformParams);
-    [pathCommand] = absSegment;
+  return iterate<AbsoluteArray>(path, (seg, index, lastX, lastY) => {
+    transformParams.x = lastX;
+    transformParams.y = lastY;
+    [pathCommand] = seg;
+    const absCommand = pathCommand.toUpperCase();
+    const isRelative = absCommand !== pathCommand;
+    const absoluteSegment = isRelative
+      ? absolutizeSegment(seg, index, lastX, lastY)
+      : (seg.slice(0) as AbsoluteSegment);
 
     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;
+      absCommand === 'A'
+        ? segmentToCubic(absoluteSegment, transformParams)
+        : ['V', 'H'].includes(absCommand)
+        ? normalizeSegment(absoluteSegment, transformParams)
+        : absoluteSegment;
+
+    // update pathCommand
+    pathCommand = result[0];
+    const isLongArc = pathCommand === 'C' && result.length > 7;
+    const tempSegment = (isLongArc ? result.slice(0, 7) : result.slice(0)) as AbsoluteSegment;
 
     if (isLongArc) {
-      path.splice(i + 1, 0, ['C', ...result.slice(7)] as CSegment);
-      result = result.slice(0, 7) as CSegment;
+      path.splice(index + 1, 0, ['C' as typeof pathCommand | number].concat(result.slice(7)) as CSegment);
+      result = tempSegment as CSegment;
     }
 
-    if (result[0] === 'L') {
-      const values = result.slice(-2) as PointTuple;
-      [lx, ly] = projection2d(matrixInstance, values, origin);
+    if (pathCommand === 'L') {
+      [lx, ly] = projection2d(matrixInstance, [(result as LSegment)[1], (result as LSegment)[2]], origin);
 
       /* istanbul ignore else @preserve */
       if (x !== lx && y !== ly) {
@@ -90,24 +97,12 @@ const transformPath = (pathInput: PathArray | string, transform?: Partial<Transf
     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;
-      }
-    }
+    const seglen = tempSegment.length;
+    transformParams.x1 = +tempSegment[seglen - 2];
+    transformParams.y1 = +tempSegment[seglen - 1];
+    transformParams.x2 = +tempSegment[seglen - 4] || transformParams.x1;
+    transformParams.y2 = +tempSegment[seglen - 3] || transformParams.y1;
 
-    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;
   });
 };

package/src/types.ts

@@ -1,13 +1,4 @@
-import type {
-  LineAttr,
-  CircleAttr,
-  PolyAttr,
-  RectAttr,
-  EllipseAttr,
-  GlyphAttr,
-  TransformObject,
-  ParserParams,
-} from './interface';
+import type { LineAttr, CircleAttr, PolyAttr, RectAttr, EllipseAttr, GlyphAttr, TransformObject } from './interface';
 
 export type SpaceNumber =
   | 0x1680
@@ -229,4 +220,9 @@ export type LineCoordinates = [number, number, number, number];
 
 export type DeriveCallback = (t: number) => Point;
 
-export type IteratorCallback = (segment: PathSegment, params: ParserParams, index: number) => PathSegment;
+export type IteratorCallback = (
+  segment: PathSegment,
+  index: number,
+  lastX: number,
+  lastY: number,
+) => PathSegment | false | void | undefined;