svg-path-commander 2.1.1 → 2.1.2

package/src/math/arcTools.ts

@@ -8,37 +8,38 @@ import type { Point } from '../types';
  * @param theta the angle in radians
  * @returns the arc length
  */
-const ellipticalArcLength = (rx: number, ry: number, theta: number) => {
+const arcLength = (rx: number, ry: number, theta: number) => {
   const halfTheta = theta / 2;
   const sinHalfTheta = Math.sin(halfTheta);
   const cosHalfTheta = Math.cos(halfTheta);
   const term1 = rx ** 2 * sinHalfTheta ** 2;
   const term2 = ry ** 2 * cosHalfTheta ** 2;
-  const arcLength = Math.sqrt(term1 + term2) * theta;
-  return Math.abs(arcLength);
+  const length = Math.sqrt(term1 + term2) * theta;
+  return Math.abs(length);
 };
 
 /**
- * Compute point on ellipse from angle around ellipse (theta);
- * @param theta the arc sweep angle
+ * Find point on ellipse at given angle around ellipse (theta);
  * @param cx the center X
  * @param cy the center Y
  * @param rx the radius X
  * @param ry the radius Y
- * @param alpha the angle
- * @returns a point around ellipse
+ * @param alpha the arc rotation angle in radians
+ * @param theta the arc sweep angle in radians
+ * @returns a point around ellipse at given angle
  */
-const arc = (theta: number, cx: number, cy: number, rx: number, ry: number, alpha: number) => {
+const arcPoint = (cx: number, cy: number, rx: number, ry: number, alpha: number, theta: number) => {
+  const { sin, cos } = Math;
   // theta is angle in radians around arc
   // alpha is angle of rotation of ellipse in radians
-  const cos = Math.cos(alpha);
-  const sin = Math.sin(alpha);
-  const x = rx * Math.cos(theta);
-  const y = ry * Math.sin(theta);
+  const cosA = cos(alpha);
+  const sinA = sin(alpha);
+  const x = rx * cos(theta);
+  const y = ry * sin(theta);
 
   return {
-    x: cx + cos * x - sin * y,
-    y: cy + sin * x + cos * y,
+    x: cx + cosA * x - sinA * y,
+    y: cy + sinA * x + cosA * y,
   };
 };
 
@@ -46,7 +47,7 @@ const arc = (theta: number, cx: number, cy: number, rx: number, ry: number, alph
  * Returns the angle between two points.
  * @param v0 starting point
  * @param v1 ending point
- * @returns the angle
+ * @returns the angle in radian
  */
 const angleBetween = (v0: Point, v1: Point) => {
   const { x: v0x, y: v0y } = v0;
@@ -54,14 +55,12 @@ const angleBetween = (v0: Point, v1: Point) => {
   const p = v0x * v1x + v0y * v1y;
   const n = Math.sqrt((v0x ** 2 + v0y ** 2) * (v1x ** 2 + v1y ** 2));
   const sign = v0x * v1y - v0y * v1x < 0 ? -1 : 1;
-  const angle = sign * Math.acos(p / n);
-
-  return angle;
+  return sign * Math.acos(p / n);
 };
 
 /**
- * Returns the following properties for an Arc segment: center, start angle
- * and radiuses on X and Y coordinates.
+ * Returns the following properties for an Arc segment: center, start angle,
+ * end angle, and radiuses on X and Y axis.
  *
  * @param x1 the starting point X
  * @param y1 the starting point Y
@@ -91,6 +90,7 @@ const getArcProps = (
   const xRot = ((angle % 360) + 360) % 360;
   const xRotRad = xRot * (PI / 180);
 
+  // istanbul ignore next @preserve
   if (x1 === x && y1 === y) {
     return {
       rx,
@@ -107,7 +107,7 @@ const getArcProps = (
       ry,
       startAngle: 0,
       endAngle: 0,
-      center: { x, y },
+      center: { x: (x + x1) / 2, y: (y + y1) / 2 },
     };
   }
 
@@ -165,7 +165,6 @@ const getArcProps = (
 
   const endAngle = startAngle + sweepAngle;
 
-  // to be used later
   // point.ellipticalArcStartAngle = startAngle;
   // point.ellipticalArcEndAngle = startAngle + sweepAngle;
   // point.ellipticalArcAngle = alpha;
@@ -173,8 +172,6 @@ const getArcProps = (
   // point.ellipticalArcCenter = center;
   // point.resultantRx = rx;
   // point.resultantRy = ry;
-  // point.length = ellipticalArcLength(rx, ry, sweepAngle);
-  // point.box = minmax(center.x, center.y, rx, ry, xRotRad, startAngle, startAngle + sweepAngle);
 
   return {
     center,
@@ -198,7 +195,7 @@ const getArcProps = (
  * @param y2 the ending point Y
  * @returns the length of the Arc segment
  */
-export const getArcLength = (
+const getArcLength = (
   x1: number,
   y1: number,
   RX: number,
@@ -210,7 +207,7 @@ export const getArcLength = (
   y: number,
 ) => {
   const { rx, ry, startAngle, endAngle } = getArcProps(x1, y1, RX, RY, angle, LAF, SF, x, y);
-  return ellipticalArcLength(rx, ry, endAngle - startAngle);
+  return arcLength(rx, ry, endAngle - startAngle);
 };
 
 /**
@@ -228,7 +225,7 @@ export const getArcLength = (
  * @param distance a [0-1] ratio
  * @returns a point along the Arc segment
  */
-export const getPointAtArcLength = (
+const getPointAtArcLength = (
   x1: number,
   y1: number,
   RX: number,
@@ -242,10 +239,10 @@ export const getPointAtArcLength = (
 ) => {
   let point = { x: x1, y: y1 };
   const { center, rx, ry, startAngle, endAngle } = getArcProps(x1, y1, RX, RY, angle, LAF, SF, x, y);
-  const length = ellipticalArcLength(rx, ry, endAngle - startAngle);
 
   /* istanbul ignore else @preserve */
   if (typeof distance === 'number') {
+    const length = arcLength(rx, ry, endAngle - startAngle);
     if (distance <= 0) {
       point = { x: x1, y: y1 };
     } else if (distance >= length) {
@@ -278,7 +275,7 @@ export const getPointAtArcLength = (
 };
 
 /**
- * Returns the bounding box for an Arc segment.
+ * Returns the extrema for an Arc segment.
  * @see https://github.com/herrstrietzel/svg-pathdata-getbbox
  *
  * @param x1 the starting point X
@@ -293,7 +290,7 @@ export const getPointAtArcLength = (
  * @returns the extrema of the Arc segment
  *
  */
-export const getArcBBox = (
+const getArcBBox = (
   x1: number,
   y1: number,
   RX: number,
@@ -306,45 +303,46 @@ export const getArcBBox = (
 ) => {
   const { center, rx, ry, startAngle, endAngle } = getArcProps(x1, y1, RX, RY, angle, LAF, SF, x, y);
   const deltaAngle = endAngle - startAngle;
+  const { min, max, tan, atan2, PI } = Math;
 
   // final on path point
   const p = { x, y };
 
   // circle/elipse center coordinates
-  const [cx, cy] = [center.x, center.y];
+  const { x: cx, y: cy } = center;
 
   // collect extreme points – add end point
   const extremes = [p];
 
   // rotation to radians
-  const alpha = (angle * Math.PI) / 180;
-  const tan = Math.tan(alpha);
+  const alpha = (angle * PI) / 180;
+  const tangent = tan(alpha);
 
   /**
    * find min/max from zeroes of directional derivative along x and y
    * along x axis
    */
-  const theta = Math.atan2(-ry * tan, rx);
+  const theta = atan2(-ry * tangent, rx);
   const angle1 = theta;
-  const angle2 = theta + Math.PI;
-  const angle3 = Math.atan2(ry, rx * tan);
-  const angle4 = angle3 + Math.PI;
+  const angle2 = theta + PI;
+  const angle3 = atan2(ry, rx * tangent);
+  const angle4 = angle3 + PI;
 
   // inner bounding box
   const xArr = [x1, x];
   const yArr = [y1, y];
-  const xMin = Math.min(...xArr);
-  const xMax = Math.max(...xArr);
-  const yMin = Math.min(...yArr);
-  const yMax = Math.max(...yArr);
+  const xMin = min(...xArr);
+  const xMax = max(...xArr);
+  const yMin = min(...yArr);
+  const yMax = max(...yArr);
 
   // on path point close after start
   const angleAfterStart = endAngle - deltaAngle * 0.001;
-  const pP2 = arc(angleAfterStart, cx, cy, rx, ry, alpha);
+  const pP2 = arcPoint(cx, cy, rx, ry, alpha, angleAfterStart);
 
   // on path point close before end
   const angleBeforeEnd = endAngle - deltaAngle * 0.999;
-  const pP3 = arc(angleBeforeEnd, cx, cy, rx, ry, alpha);
+  const pP3 = arcPoint(cx, cy, rx, ry, alpha, angleBeforeEnd);
 
   /**
    * expected extremes
@@ -357,38 +355,42 @@ export const getArcBBox = (
   // istanbul ignore if @preserve
   if (pP2.x > xMax || pP3.x > xMax) {
     // get point for this theta
-    extremes.push(arc(angle1, cx, cy, rx, ry, alpha));
+    extremes.push(arcPoint(cx, cy, rx, ry, alpha, angle1));
   }
 
   // left
   // istanbul ignore if @preserve
   if (pP2.x < xMin || pP3.x < xMin) {
     // get anti-symmetric point
-    extremes.push(arc(angle2, cx, cy, rx, ry, alpha));
+    extremes.push(arcPoint(cx, cy, rx, ry, alpha, angle2));
   }
 
   // top
   // istanbul ignore if @preserve
   if (pP2.y < yMin || pP3.y < yMin) {
     // get anti-symmetric point
-    extremes.push(arc(angle4, cx, cy, rx, ry, alpha));
+    extremes.push(arcPoint(cx, cy, rx, ry, alpha, angle4));
   }
 
   // bottom
   // istanbul ignore if @preserve
   if (pP2.y > yMax || pP3.y > yMax) {
     // get point for this theta
-    extremes.push(arc(angle3, cx, cy, rx, ry, alpha));
+    extremes.push(arcPoint(cx, cy, rx, ry, alpha, angle3));
   }
 
   return {
     min: {
-      x: Math.min(...extremes.map(n => n.x)),
-      y: Math.min(...extremes.map(n => n.y)),
+      x: min(...extremes.map(n => n.x)),
+      y: min(...extremes.map(n => n.y)),
     },
     max: {
-      x: Math.max(...extremes.map(n => n.x)),
-      y: Math.max(...extremes.map(n => n.y)),
+      x: max(...extremes.map(n => n.x)),
+      y: max(...extremes.map(n => n.y)),
     },
   };
 };
+
+export { arcPoint, angleBetween, getArcLength, arcLength, getArcBBox, getArcProps, getPointAtArcLength };
+
+export {};

package/src/math/bezier.ts

@@ -15,8 +15,6 @@ import type {
  * @see https://github.com/Pomax/bezierjs
  */
 
-const ZERO = { x: 0, y: 0 };
-
 const Tvalues = [
   -0.0640568928626056260850430826247450385909, 0.0640568928626056260850430826247450385909,
   -0.1911188674736163091586398207570696318404, 0.1911188674736163091586398207570696318404,
@@ -52,7 +50,7 @@ const Cvalues = [
  * @param points
  * @returns
  */
-const derive = (points: QuadPoints | CubicPoints) => {
+const deriveBezier = (points: QuadPoints | CubicPoints) => {
   const dpoints = [] as (DerivedCubicPoints | DerivedQuadPoints)[];
   for (let p = points, d = p.length, c = d - 1; d > 1; d -= 1, c -= 1) {
     const list = [] as unknown as DerivedCubicPoints | DerivedQuadPoints;
@@ -74,7 +72,7 @@ const derive = (points: QuadPoints | CubicPoints) => {
  * @param points
  * @param t
  */
-const compute = (points: DerivedQuadPoints | DerivedCubicPoints, t: number) => {
+const computeBezier = (points: DerivedQuadPoints | DerivedCubicPoints, t: number) => {
   // shortcuts
   /* istanbul ignore next @preserve */
   if (t === 0) {
@@ -119,7 +117,7 @@ const compute = (points: DerivedQuadPoints | DerivedCubicPoints, t: number) => {
   let d = 0;
   /* istanbul ignore else @preserve */
   if (order === 2) {
-    p = [p[0], p[1], p[2], ZERO as DerivedPoint];
+    p = [p[0], p[1], p[2], { x: 0, y: 0 } as DerivedPoint];
     a = mt2;
     b = mt * t * 2;
     c = t2;
@@ -136,14 +134,14 @@ const compute = (points: DerivedQuadPoints | DerivedCubicPoints, t: number) => {
   };
 };
 
-const arcfn = (derivativeFn: DeriveCallback, t: number) => {
+const calculateBezier = (derivativeFn: DeriveCallback, t: number) => {
   const d = derivativeFn(t);
   const l = d.x * d.x + d.y * d.y;
 
   return Math.sqrt(l);
 };
 
-const lengthFn = (derivativeFn: DeriveCallback) => {
+const bezierLength = (derivativeFn: DeriveCallback) => {
   const z = 0.5;
   const len = Tvalues.length;
 
@@ -151,7 +149,7 @@ const lengthFn = (derivativeFn: DeriveCallback) => {
 
   for (let i = 0, t; i < len; i++) {
     t = z * Tvalues[i] + z;
-    sum += Cvalues[i] * arcfn(derivativeFn, t);
+    sum += Cvalues[i] * calculateBezier(derivativeFn, t);
   }
   return z * sum;
 };
@@ -160,7 +158,7 @@ const lengthFn = (derivativeFn: DeriveCallback) => {
  * Returns the length of CubicBezier / Quad segment.
  * @param curve cubic / quad bezier segment
  */
-export const length = (curve: CubicCoordinates | QuadCoordinates) => {
+const getBezierLength = (curve: CubicCoordinates | QuadCoordinates) => {
   const points = [] as unknown as CubicPoints | QuadPoints;
   for (let idx = 0, len = curve.length, step = 2; idx < len; idx += step) {
     points.push({
@@ -168,9 +166,9 @@ export const length = (curve: CubicCoordinates | QuadCoordinates) => {
       y: curve[idx + 1],
     });
   }
-  const dpoints = derive(points);
-  return lengthFn((t: number) => {
-    return compute(dpoints[0], t);
+  const dpoints = deriveBezier(points);
+  return bezierLength((t: number) => {
+    return computeBezier(dpoints[0], t);
   });
 };
 
@@ -179,67 +177,64 @@ const CBEZIER_MINMAX_EPSILON = 0.00000001;
 
 /**
  * Returns the most extreme points in a Quad Bezier segment.
- * @param A
+ * @param A an array which consist of X/Y values
  */
 // https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L89
-export const minmaxQ = (A: [number, number, number]) => {
-  const min = Math.min(A[0], A[2]);
-  const max = Math.max(A[0], A[2]);
+const minmaxQ = ([v1, cp, v2]: [number, number, number]) => {
+  const min = Math.min(v1, v2);
+  const max = Math.max(v1, v2);
 
   /* istanbul ignore next @preserve */
-  if (A[1] >= A[0] ? A[2] >= A[1] : A[2] <= A[1]) {
+  if (cp >= v1 ? v2 >= cp : v2 <= cp) {
     // if no extremum in ]0,1[
     return [min, max] as PointTuple;
   }
 
   // check if the extremum E is min or max
-  const E = (A[0] * A[2] - A[1] * A[1]) / (A[0] - 2 * A[1] + A[2]);
+  const E = (v1 * v2 - cp * cp) / (v1 - 2 * cp + v2);
   return (E < min ? [E, max] : [min, E]) as PointTuple;
 };
 
 /**
  * Returns the most extreme points in a Cubic Bezier segment.
- * @param A
+ * @param A an array which consist of X/Y values
  * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127
  */
-export const minmaxC = (A: [number, number, number, number]) => {
-  const K = A[0] - 3 * A[1] + 3 * A[2] - A[3];
+const minmaxC = ([v1, cp1, cp2, v2]: [number, number, number, number]) => {
+  const K = v1 - 3 * cp1 + 3 * cp2 - v2;
 
   // if the polynomial is (almost) quadratic and not cubic
   /* istanbul ignore next @preserve */
   if (Math.abs(K) < CBEZIER_MINMAX_EPSILON) {
-    if (A[0] === A[3] && A[0] === A[1]) {
+    if (v1 === v2 && v1 === cp1) {
       // no curve, point targeting same location
-      return [A[0], A[3]] as PointTuple;
+      return [v1, v2] as PointTuple;
     }
 
-    return minmaxQ([A[0], -0.5 * A[0] + 1.5 * A[1], A[0] - 3 * A[1] + 3 * A[2]]);
+    return minmaxQ([v1, -0.5 * v1 + 1.5 * cp1, v1 - 3 * cp1 + 3 * cp2]);
   }
 
   // the reduced discriminant of the derivative
-  const T = -A[0] * A[2] + A[0] * A[3] - A[1] * A[2] - A[1] * A[3] + A[1] * A[1] + A[2] * A[2];
+  const T = -v1 * cp2 + v1 * v2 - cp1 * cp2 - cp1 * v2 + cp1 * cp1 + cp2 * cp2;
 
   // if the polynomial is monotone in [0,1]
   if (T <= 0) {
-    return [Math.min(A[0], A[3]), Math.max(A[0], A[3])] as PointTuple;
+    return [Math.min(v1, v2), Math.max(v1, v2)] as PointTuple;
   }
   const S = Math.sqrt(T);
 
   // potential extrema
-  let min = Math.min(A[0], A[3]);
-  let max = Math.max(A[0], A[3]);
+  let min = Math.min(v1, v2);
+  let max = Math.max(v1, v2);
 
-  const L = A[0] - 2 * A[1] + A[2];
+  const L = v1 - 2 * cp1 + cp2;
   // check local extrema
   for (let R = (L + S) / K, i = 1; i <= 2; R = (L - S) / K, i++) {
     // istanbul ignore next @preserve
     if (R > 0 && R < 1) {
       // if the extrema is for R in [0,1]
       const Q =
-        A[0] * (1 - R) * (1 - R) * (1 - R) +
-        A[1] * 3 * (1 - R) * (1 - R) * R +
-        A[2] * 3 * (1 - R) * R * R +
-        A[3] * R * R * R;
+        v1 * (1 - R) * (1 - R) * (1 - R) + cp1 * 3 * (1 - R) * (1 - R) * R + cp2 * 3 * (1 - R) * R * R + v2 * R * R * R;
       if (Q < min) {
         min = Q;
       }
@@ -251,3 +246,16 @@ export const minmaxC = (A: [number, number, number, number]) => {
 
   return [min, max] as PointTuple;
 };
+
+export {
+  Cvalues,
+  Tvalues,
+  minmaxC,
+  minmaxQ,
+  getBezierLength,
+  bezierLength,
+  calculateBezier,
+  computeBezier,
+  deriveBezier,
+  CBEZIER_MINMAX_EPSILON,
+};

package/src/math/cubicTools.ts

@@ -1,8 +1,8 @@
-import { length, minmaxC } from './bezier';
+import { getBezierLength, minmaxC } from './bezier';
 import { type CubicCoordinates } from '../types';
 
 /**
- * Returns a {x,y} point at a given length of a CubicBezier segment.
+ * Returns a point at a given length of a CubicBezier segment.
  *
  * @param x1 the starting point X
  * @param y1 the starting point Y
@@ -15,7 +15,7 @@ import { type CubicCoordinates } from '../types';
  * @param t a [0-1] ratio
  * @returns the point at cubic-bezier segment length
  */
-export const getPointAtCubicSegmentLength = ([x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates, t: number) => {
+const getPointAtCubicSegmentLength = ([x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates, t: number) => {
   const t1 = 1 - t;
   return {
     x: t1 ** 3 * x1 + 3 * t1 ** 2 * t * c1x + 3 * t1 * t ** 2 * c2x + t ** 3 * x2,
@@ -36,7 +36,7 @@ export const getPointAtCubicSegmentLength = ([x1, y1, c1x, c1y, c2x, c2y, x2, y2
  * @param y2 the ending point Y
  * @returns the CubicBezier segment length
  */
-export const getCubicLength = (
+const getCubicLength = (
   x1: number,
   y1: number,
   c1x: number,
@@ -46,7 +46,7 @@ export const getCubicLength = (
   x2: number,
   y2: number,
 ) => {
-  return length([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);
+  return getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);
 };
 
 /**
@@ -63,7 +63,7 @@ export const getCubicLength = (
  * @param distance the distance to look at
  * @returns the point at CubicBezier length
  */
-export const getPointAtCubicLength = (
+const getPointAtCubicLength = (
   x1: number,
   y1: number,
   c1x: number,
@@ -78,7 +78,7 @@ export const getPointAtCubicLength = (
   let point = { x: x1, y: y1 };
   /* istanbul ignore else @preserve */
   if (distanceIsNumber) {
-    const currentLength = length([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);
+    const currentLength = getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);
     if (distance <= 0) {
       // first point already defined
     } else if (distance >= currentLength) {
@@ -103,7 +103,7 @@ export const getPointAtCubicLength = (
  * @param y2 the ending point Y
  * @returns the point at CubicBezier length
  */
-export const getCubicBBox = (
+const getCubicBBox = (
   x1: number,
   y1: number,
   c1x: number,
@@ -120,3 +120,5 @@ export const getCubicBBox = (
     max: { x: cxMinMax[1], y: cyMinMax[1] },
   };
 };
+
+export { getCubicLength, getCubicBBox, getPointAtCubicLength, getPointAtCubicSegmentLength };

package/src/math/distanceSquareRoot.ts

@@ -8,7 +8,7 @@ import { type PointTuple } from '../types';
  * @param b the second point coordinates
  * @returns the distance value
  */
-const distanceSquareRoot = (a: PointTuple, b: PointTuple): number => {
+const distanceSquareRoot = (a: PointTuple, b: PointTuple) => {
   return Math.sqrt((a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]));
 };
 

package/src/math/lineTools.ts

@@ -10,7 +10,7 @@ import distanceSquareRoot from './distanceSquareRoot';
  * @param y2 the ending point Y
  * @returns the line segment length
  */
-export const getLineLength = (x1: number, y1: number, x2: number, y2: number) => {
+const getLineLength = (x1: number, y1: number, x2: number, y2: number) => {
   return distanceSquareRoot([x1, y1], [x2, y2]);
 };
 
@@ -24,12 +24,12 @@ export const getLineLength = (x1: number, y1: number, x2: number, y2: number) =>
  * @param distance the distance to point in [0-1] range
  * @returns the point at length
  */
-export const getPointAtLineLength = (x1: number, y1: number, x2: number, y2: number, distance?: number) => {
-  const length = distanceSquareRoot([x1, y1], [x2, y2]);
+const getPointAtLineLength = (x1: number, y1: number, x2: number, y2: number, distance?: number) => {
   let point = { x: x1, y: y1 };
 
   /* istanbul ignore else @preserve */
   if (typeof distance === 'number') {
+    const length = distanceSquareRoot([x1, y1], [x2, y2]);
     if (distance <= 0) {
       point = { x: x1, y: y1 };
     } else if (distance >= length) {
@@ -52,7 +52,7 @@ export const getPointAtLineLength = (x1: number, y1: number, x2: number, y2: num
  * @param distance the distance to point in [0-1] range
  * @returns the extrema for line segments
  */
-export const getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {
+const getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {
   const { min, max } = Math;
   return {
     min: {
@@ -65,3 +65,5 @@ export const getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {
     },
   };
 };
+
+export { getPointAtLineLength, getLineBBox, getLineLength };

package/src/math/polygonTools.ts

@@ -0,0 +1,48 @@
+import distanceSquareRoot from './distanceSquareRoot';
+import { type PointTuple } from '../types';
+
+/**
+ * d3-polygon-area
+ * https://github.com/d3/d3-polygon
+ *
+ * Returns the area of a polygon.
+ *
+ * @param polygon an array of coordinates
+ * @returns the polygon area
+ */
+const polygonArea = (polygon: PointTuple[]) => {
+  const n = polygon.length;
+  let i = -1;
+  let a: PointTuple;
+  let b = polygon[n - 1];
+  let area = 0;
+
+  /* eslint-disable-next-line */
+  while (++i < n) {
+    a = b;
+    b = polygon[i];
+    area += a[1] * b[0] - a[0] * b[1];
+  }
+
+  return area / 2;
+};
+
+/**
+ * d3-polygon-length
+ * https://github.com/d3/d3-polygon
+ *
+ * Returns the perimeter of a polygon.
+ *
+ * @param polygon an array of coordinates
+ * @returns the polygon length
+ */
+const polygonLength = (polygon: PointTuple[]) => {
+  return polygon.reduce((length, point, i) => {
+    if (i) {
+      return length + distanceSquareRoot(polygon[i - 1], point);
+    }
+    return 0;
+  }, 0);
+};
+
+export { polygonArea, polygonLength };

package/src/math/quadTools.ts

@@ -1,4 +1,4 @@
-import { length, minmaxQ } from './bezier';
+import { getBezierLength, minmaxQ } from './bezier';
 import { type QuadCoordinates } from '../types';
 
 /**
@@ -35,8 +35,8 @@ const getPointAtQuadSegmentLength = ([x1, y1, cx, cy, x2, y2]: QuadCoordinates,
  * @param y2 the ending point Y
  * @returns the QuadraticBezier segment length
  */
-export const getQuadLength = (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number) => {
-  return length([x1, y1, cx, cy, x2, y2]);
+const getQuadLength = (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number) => {
+  return getBezierLength([x1, y1, cx, cy, x2, y2]);
 };
 
 /**
@@ -51,7 +51,7 @@ export const getQuadLength = (x1: number, y1: number, cx: number, cy: number, x2
  * @param distance the distance to look at
  * @returns the point at QuadraticBezier length
  */
-export const getPointAtQuadLength = (
+const getPointAtQuadLength = (
   x1: number,
   y1: number,
   cx: number,
@@ -65,7 +65,7 @@ export const getPointAtQuadLength = (
 
   /* istanbul ignore else @preserve */
   if (distanceIsNumber) {
-    const currentLength = length([x1, y1, cx, cy, x2, y2]);
+    const currentLength = getBezierLength([x1, y1, cx, cy, x2, y2]);
     if (distance <= 0) {
       // first point already defined
     } else if (distance >= currentLength) {
@@ -88,7 +88,7 @@ export const getPointAtQuadLength = (
  * @param y2 the ending point Y
  * @returns the point at CubicBezier length
  */
-export const getQuadBBox = (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number) => {
+const getQuadBBox = (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number) => {
   const cxMinMax = minmaxQ([x1, cx, x2]);
   const cyMinMax = minmaxQ([y1, cy, y2]);
   return {
@@ -96,3 +96,5 @@ export const getQuadBBox = (x1: number, y1: number, cx: number, cy: number, x2:
     max: { x: cxMinMax[1], y: cyMinMax[1] },
   };
 };
+
+export { getPointAtQuadSegmentLength, getQuadLength, getQuadBBox, getPointAtQuadLength };