svg-path-commander 2.1.0 → 2.1.2

package/src/process/normalizePath.ts

@@ -1,44 +1,33 @@
-import pathToAbsolute from '../convert/pathToAbsolute';
 import normalizeSegment from './normalizeSegment';
-import isNormalizedArray from '../util/isNormalizedArray';
-import paramsParser from '../parser/paramsParser';
 import type { NormalArray, PathArray } from '../types';
+import iterate from './iterate';
+import parsePathString from '../parser/parsePathString';
+import paramsParser from '../parser/paramsParser';
 
 /**
- * Normalizes a `path` object for further processing:
+ * Normalizes a `pathArray` object for further processing:
  * * convert segments to absolute values
  * * convert shorthand path commands to their non-shorthand notation
  *
  * @param pathInput the string to be parsed or 'pathArray'
  * @returns the normalized `pathArray`
  */
-const normalizePath = (pathInput: string | PathArray): NormalArray => {
-  if (isNormalizedArray(pathInput)) {
-    return pathInput.slice(0) as NormalArray;
-  }
-
-  const path = pathToAbsolute(pathInput);
+const normalizePath = (pathInput: string | PathArray) => {
+  const path = parsePathString(pathInput);
   const params = { ...paramsParser };
-  const allPathCommands = [];
-  const ii = path.length;
-  let pathCommand = '';
-
-  for (let i = 0; i < ii; i += 1) {
-    [pathCommand] = path[i];
-
-    // Save current path command
-    allPathCommands[i] = pathCommand;
-    path[i] = normalizeSegment(path[i], params);
 
-    const segment = path[i];
-    const seglen = segment.length;
+  return iterate<NormalArray>(path, (seg, _, lastX, lastY) => {
+    params.x = lastX;
+    params.y = lastY;
+    const result = normalizeSegment(seg, params);
 
-    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 seglen = result.length;
+    params.x1 = +result[seglen - 2];
+    params.y1 = +result[seglen - 1];
+    params.x2 = +result[seglen - 4] || params.x1;
+    params.y2 = +result[seglen - 3] || params.y1;
 
-  return path as NormalArray;
+    return result;
+  });
 };
 export default normalizePath;

package/src/process/normalizeSegment.ts

@@ -1,47 +1,84 @@
 import type { ParserParams } from '../interface';
-import type { NormalSegment, PathSegment } from '../types';
+import type {
+  NormalSegment,
+  PointTuple,
+  PathSegment,
+  QSegment,
+  CSegment,
+  LSegment,
+  MSegment,
+  HSegment,
+  VSegment,
+  ASegment,
+  PathCommand,
+} from '../types';
 
 /**
  * Normalizes a single segment of a `pathArray` object.
  *
  * @param segment the segment object
- * @param params the coordinates of the previous segment
+ * @param params the normalization parameters
  * @returns the normalized segment
  */
-const normalizeSegment = (segment: PathSegment, params: ParserParams): NormalSegment => {
+const normalizeSegment = (segment: PathSegment, params: ParserParams) => {
   const [pathCommand] = segment;
-  const { x1: px1, y1: py1, x2: px2, y2: py2 } = params;
-  const values = segment.slice(1).map(Number);
-  let result = segment;
+  const absCommand = pathCommand.toUpperCase();
+  const isRelative = pathCommand !== absCommand;
+  const { x1: px1, y1: py1, x2: px2, y2: py2, x, y } = params;
+  const values = segment.slice(1) as number[];
+  let absValues = values.map((n, j) => n + (isRelative ? (j % 2 ? y : x) : 0));
 
-  if (!'TQ'.includes(pathCommand)) {
+  if (!'TQ'.includes(absCommand)) {
     // optional but good to be cautious
     params.qx = null;
     params.qy = null;
   }
 
-  if (pathCommand === 'H') {
-    result = ['L', segment[1], py1];
-  } else if (pathCommand === 'V') {
-    result = ['L', px1, segment[1]];
-  } else if (pathCommand === 'S') {
+  // istanbul ignore else @preserve
+  if (absCommand === 'A') {
+    absValues = values.slice(0, -2).concat(values[5] + (isRelative ? x : 0), values[6] + (isRelative ? y : 0));
+
+    return ['A' as PathCommand | number].concat(absValues) as ASegment;
+  } else if (absCommand === 'H') {
+    return ['L', (segment as HSegment)[1] + (isRelative ? x : 0), py1] as LSegment;
+  } else if (absCommand === 'V') {
+    return ['L', px1, (segment as VSegment)[1] + (isRelative ? y : 0)] as LSegment;
+  } else if (absCommand === 'L') {
+    return [
+      'L',
+      (segment as LSegment)[1] + (isRelative ? x : 0),
+      (segment as LSegment)[2] + (isRelative ? y : 0),
+    ] as LSegment;
+  } else if (absCommand === 'M') {
+    return [
+      'M',
+      (segment as MSegment)[1] + (isRelative ? x : 0),
+      (segment as MSegment)[2] + (isRelative ? y : 0),
+    ] as MSegment;
+  } else if (absCommand === 'C') {
+    return ['C' as PathCommand | number].concat(absValues) as CSegment;
+  } else if (absCommand === 'S') {
     const x1 = px1 * 2 - px2;
     const y1 = py1 * 2 - py2;
     params.x1 = x1;
     params.y1 = y1;
-    result = ['C', x1, y1, ...(values as [number, number, number, number])];
-  } else if (pathCommand === 'T') {
+    return ['C', x1, y1].concat(absValues) as CSegment;
+  } else if (absCommand === 'T') {
     const qx = px1 * 2 - (params.qx ? params.qx : /* istanbul ignore next */ 0);
     const qy = py1 * 2 - (params.qy ? params.qy : /* istanbul ignore next */ 0);
     params.qx = qx;
     params.qy = qy;
-    result = ['Q', qx, qy, ...(values as [number, number])];
-  } else if (pathCommand === 'Q') {
-    const [nqx, nqy] = values as [number, number];
+    return ['Q', qx, qy].concat(absValues) as QSegment;
+  } else if (absCommand === 'Q') {
+    const [nqx, nqy] = absValues as PointTuple;
     params.qx = nqx;
     params.qy = nqy;
+    return ['Q' as PathCommand | number].concat(absValues) as QSegment;
+  } else if (absCommand === 'Z') {
+    return ['Z'] as NormalSegment;
   }
 
-  return result as NormalSegment;
+  // istanbul ignore next @preserve
+  return segment as NormalSegment;
 };
 export default normalizeSegment;

package/src/process/optimizePath.ts

@@ -1,10 +1,11 @@
-import roundPath from './roundPath';
 import pathToAbsolute from '../convert/pathToAbsolute';
-import pathToRelative from '../convert/pathToRelative';
 import shortenSegment from './shortenSegment';
 import paramsParser from '../parser/paramsParser';
-import normalizePath from './normalizePath';
-import type { PathSegment, HSegment, PathArray, VSegment, PathCommand, AbsoluteSegment } from '../types';
+import type { AbsoluteSegment, PathArray, PathCommand } from '../types';
+import iterate from './iterate';
+import normalizeSegment from './normalizeSegment';
+import relativizeSegment from './relativizeSegment';
+import roundSegment from './roundSegment';
 
 /**
  * Optimizes a `pathArray` object:
@@ -12,72 +13,51 @@ import type { PathSegment, HSegment, PathArray, VSegment, PathCommand, AbsoluteS
  * * select shortest segments from absolute and relative `pathArray`s
  *
  * @param pathInput a string or `pathArray`
- * @param round the amount of decimals to round values to
+ * @param roundOption the amount of decimals to round values to
  * @returns the optimized `pathArray`
  */
-const optimizePath = (pathInput: PathArray, round: 'off' | number): PathArray => {
+const optimizePath = (pathInput: PathArray, roundOption: number) => {
   const path = pathToAbsolute(pathInput);
-  const normalPath = normalizePath(path);
-  const params = { ...paramsParser };
+  // allow for ZERO decimals or use an aggressive value of 2
+  const round =
+    typeof roundOption === 'number' && roundOption >= 0 ? roundOption : /* istanbul ignore next @preserve */ 2;
+  // this utility overrides the iterator params
+  const optimParams = { ...paramsParser };
+
   const allPathCommands = [] as PathCommand[];
-  const ii = path.length;
-  let pathCommand = '' as PathCommand;
-  let prevCommand = '' as PathCommand;
-  let x = 0;
-  let y = 0;
-  let mx = 0;
-  let my = 0;
+  let pathCommand = 'M' as PathCommand;
+  let prevCommand = 'Z' as PathCommand;
 
-  for (let i = 0; i < ii; i += 1) {
-    [pathCommand] = path[i];
+  return iterate(path, (seg, i, lastX, lastY) => {
+    optimParams.x = lastX;
+    optimParams.y = lastY;
+    // const absoluteSegment = absolutizeSegment(seg, optimParams);
+    const normalizedSegment = normalizeSegment(seg, optimParams);
+    let result = seg;
+    [pathCommand] = seg;
 
     // Save current path command
     allPathCommands[i] = pathCommand;
-    // Get previous path command for `shortenSegment`
-    if (i) prevCommand = allPathCommands[i - 1];
-    path[i] = shortenSegment(path[i], normalPath[i], params, prevCommand) as AbsoluteSegment;
-
-    const segment = path[i];
-    const seglen = segment.length;
-
-    // update C, S, Q, T specific params
-    params.x1 = +segment[seglen - 2];
-    params.y1 = +segment[seglen - 1];
-    params.x2 = +segment[seglen - 4] || params.x1;
-    params.y2 = +segment[seglen - 3] || params.y1;
-
-    // update x, y params
-    switch (pathCommand) {
-      case 'Z':
-        x = mx;
-        y = my;
-        break;
-      case 'H':
-        [, x] = segment as HSegment;
-        break;
-      case 'V':
-        [, y] = segment as VSegment;
-        break;
-      default:
-        [x, y] = segment.slice(-2).map(Number);
-
-        if (pathCommand === 'M') {
-          mx = x;
-          my = y;
-        }
+    if (i) {
+      // Get previous path command for `shortenSegment`
+      prevCommand = allPathCommands[i - 1];
+      const shortSegment = shortenSegment(seg as AbsoluteSegment, normalizedSegment, optimParams, prevCommand);
+      const absSegment = roundSegment(shortSegment, round);
+      const absString = absSegment.join('');
+      const relativeSegment = relativizeSegment(shortSegment, i, lastX, lastY);
+      const relSegment = roundSegment(relativeSegment, round);
+      const relString = relSegment.join('');
+      result = absString.length < relString.length ? absSegment : relSegment;
     }
-    params.x = x;
-    params.y = y;
-  }
 
-  const absolutePath = roundPath(path, round);
-  const relativePath = roundPath(pathToRelative(path), round);
+    const seglen = normalizedSegment.length;
+    optimParams.x1 = +normalizedSegment[seglen - 2];
+    optimParams.y1 = +normalizedSegment[seglen - 1];
+    optimParams.x2 = +normalizedSegment[seglen - 4] || optimParams.x1;
+    optimParams.y2 = +normalizedSegment[seglen - 3] || optimParams.y1;
 
-  return absolutePath.map((a: PathSegment, i: number) => {
-    if (i) {
-      return a.join('').length < relativePath[i].join('').length ? a : relativePath[i];
-    }
-    return a;
-  }) as PathArray;
+    return result;
+  });
 };
+
 export default optimizePath;

package/src/process/projection2d.ts

@@ -1,4 +1,5 @@
 import CSSMatrix from '@thednp/dommatrix';
+import { type PointTuple } from '../types';
 
 /**
  * Transforms a specified point using a matrix, returning a new
@@ -12,7 +13,7 @@ import CSSMatrix from '@thednp/dommatrix';
  * @return the resulting Tuple
  */
 const translatePoint = (cssm: CSSMatrix, v: [number, number, number, number]): [number, number, number, number] => {
-  let m = CSSMatrix.Translate(...(v.slice(0, -1) as [number, number, number]));
+  let m = CSSMatrix.Translate(v[0], v[1], v[2]);
 
   [, , , m.m44] = v;
   m = cssm.multiply(m);
@@ -34,9 +35,9 @@ const translatePoint = (cssm: CSSMatrix, v: [number, number, number, number]): [
  * @param origin the [x,y,z] transform origin
  * @returns the projected [x,y] coordinates
  */
-const projection2d = (m: CSSMatrix, point2D: [number, number], origin: [number, number, number]): [number, number] => {
+const projection2d = (m: CSSMatrix, point2D: PointTuple, origin: [number, number, number]): PointTuple => {
   const [originX, originY, originZ] = origin;
-  const [x, y, z] = translatePoint(m, [...point2D, 0, 1]);
+  const [x, y, z] = translatePoint(m, [point2D[0], point2D[1], 0, 1]);
 
   const relativePositionX = x - originX;
   const relativePositionY = y - originY;

package/src/process/relativizeSegment.ts

@@ -0,0 +1,59 @@
+import type {
+  RelativeSegment,
+  RelativeCommand,
+  PathSegment,
+  aSegment,
+  vSegment,
+  hSegment,
+  qSegment,
+  tSegment,
+  sSegment,
+  cSegment,
+  MSegment,
+  lSegment,
+} from '../types';
+
+/**
+ * Returns a relative segment of a `PathArray` object.
+ *
+ * @param segment the segment object
+ * @param index the segment index
+ * @param lastX the last known X value
+ * @param lastY the last known Y value
+ * @returns the relative segment
+ */
+const relativizeSegment = (segment: PathSegment, index: number, lastX: number, lastY: number) => {
+  const [pathCommand] = segment;
+  const relCommand = pathCommand.toLowerCase() as RelativeCommand;
+  const isRelative = pathCommand === relCommand;
+
+  /* istanbul ignore else @preserve */
+  if (index === 0 || isRelative) return segment as MSegment | 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,97 +5,110 @@ import type {
   MSegment,
   PathArray,
   PathSegment,
+  PointTuple,
   QSegment,
   SSegment,
   TSegment,
   VSegment,
-} from 'src/types';
+} 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,5 +1,7 @@
-import type { PathArray } from 'src/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
@@ -9,21 +11,23 @@ import defaultOptions from '../options/options';
  * @param roundOption the amount of decimals to round numbers to
  * @returns the resulted `pathArray` with rounded values
  */
-const roundPath = (path: PathArray, roundOption?: number | 'off'): PathArray => {
+const roundPath = (path: PathArray, roundOption?: number | 'off') => {
   let { round } = defaultOptions;
-  if (roundOption === 'off' || round === 'off') return [...path];
   // 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';
 
-  return path.map(pi => {
-    const values = pi
-      .slice(1)
-      .map(Number)
-      .map(n => (round ? Math.round(n * pow) / pow : Math.round(n)));
-    return [pi[0], ...values];
-  }) as PathArray;
+  /* istanbul ignore else @preserve */
+  if (round === 'off') return path.slice(0) as PathArray;
+
+  return iterate<typeof path>(path, segment => {
+    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;