svg-path-commander 2.1.0 → 2.1.2

package/src/interface.ts

@@ -5,7 +5,8 @@ export type SegmentProperties = {
   index: number;
   length: number;
   lengthAtSegment: number;
-  [key: string]: any;
+  // point: Point;
+  // [key: string]: any;
 };
 
 export type PointProperties = {
@@ -106,7 +107,7 @@ export type LengthFactory = {
 };
 
 export type Options = {
-  round: 'auto' | 'off' | number;
+  round: 'off' | number;
   origin: number[];
 };
 

package/src/math/arcTools.ts

@@ -1,4 +1,4 @@
-import { default as getLineSegmentProperties } from './lineTools';
+import { getPointAtLineLength } from './lineTools';
 import type { Point } from '../types';
 
 /**
@@ -8,59 +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);
 };
 
 /**
- * Returns the most extreme points in an Arc segment.
- * @param x Center X coordinate of the ellipse arc
- * @param y Center Y coordinate of the ellipse arc
- * @param rx Radius on the X axis of the ellipse
- * @param ry Radius on the Y axis of the ellipse
- * @param rotation The ellipse rotation angle in radians
- * @param startAngle The ellipse start angle in radians
- * @param endAngle The ellipse end angle in radians
- * @see https://stackoverflow.com/questions/87734/how-do-you-calculate-the-axis-aligned-bounding-box-of-an-ellipse
+ * 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 arc rotation angle in radians
+ * @param theta the arc sweep angle in radians
+ * @returns a point around ellipse at given angle
  */
-const minmax = (
-  x: number,
-  y: number,
-  rx: number,
-  ry: number,
-  rotation: number,
-  startAngle: number,
-  endAngle: number,
-) => {
-  const { cos, sin, min, max } = Math;
-  const cosRotation = cos(rotation);
-  const sinRotation = sin(rotation);
-
-  // Rotate parametric equations
-  const xRotated = (t: number) => {
-    return x + rx * cos(t) * cosRotation - ry * sin(t) * sinRotation;
-  };
-  const yRotated = (t: number) => {
-    return y + ry * sin(t) * cosRotation + rx * cos(t) * sinRotation;
-  };
-
-  // Evaluate at start and end angles
-  const startX = xRotated(startAngle);
-  const startY = yRotated(startAngle);
-  const endX = xRotated(endAngle);
-  const endY = yRotated(endAngle);
+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 cosA = cos(alpha);
+  const sinA = sin(alpha);
+  const x = rx * cos(theta);
+  const y = ry * sin(theta);
 
-  // Find minimum and maximum x and y values
-  // Return AABB
   return {
-    min: { x: min(startX, endX), y: min(startY, endY) },
-    max: { x: max(startX, endX), y: max(startY, endY) },
+    x: cx + cosA * x - sinA * y,
+    y: cy + sinA * x + cosA * y,
   };
 };
 
@@ -68,7 +47,7 @@ const minmax = (
  * 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;
@@ -76,26 +55,25 @@ 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 properties for an Arc segment.
+ * 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
- * @param c1x the first control point X
- * @param c1y the first control point Y
- * @param c2x the second control point X
- * @param c2y the second control point Y
+ * @param RX the radius on X axis
+ * @param RY the radius on Y axis
+ * @param angle the ellipse rotation in degrees
+ * @param LAF the large arc flag
+ * @param SF the sweep flag
  * @param x2 the ending point X
  * @param y2 the ending point Y
- * @param distance a [0-1] ratio
- * @returns properties specific to Arc segmentas well as the segment length, point at length and the bounding box
+ * @returns properties specific to Arc segments
  */
-const getSegmentProperties = (
+const getArcProps = (
   x1: number,
   y1: number,
   RX: number,
@@ -105,7 +83,6 @@ const getSegmentProperties = (
   SF: number,
   x: number,
   y: number,
-  distance?: number,
 ) => {
   const { abs, sin, cos, sqrt, PI } = Math;
   let rx = abs(RX);
@@ -113,16 +90,25 @@ const getSegmentProperties = (
   const xRot = ((angle % 360) + 360) % 360;
   const xRotRad = xRot * (PI / 180);
 
+  // istanbul ignore next @preserve
   if (x1 === x && y1 === y) {
     return {
-      point: { x, y },
-      length: 0,
-      bbox: { min: { x, y }, max: { x, y } },
+      rx,
+      ry,
+      startAngle: 0,
+      endAngle: 0,
+      center: { x, y },
     };
   }
 
   if (rx === 0 || ry === 0) {
-    return getLineSegmentProperties(x1, y1, x, y, distance);
+    return {
+      rx,
+      ry,
+      startAngle: 0,
+      endAngle: 0,
+      center: { x: (x + x1) / 2, y: (y + y1) / 2 },
+    };
   }
 
   const dx = (x1 - x) / 2;
@@ -144,6 +130,7 @@ const getSegmentProperties = (
   const cSquareRootDenom = rx ** 2 * transformedPoint.y ** 2 + ry ** 2 * transformedPoint.x ** 2;
 
   let cRadicand = cSquareNumerator / cSquareRootDenom;
+  /* istanbul ignore next @preserve */
   cRadicand = cRadicand < 0 ? 0 : cRadicand;
   const cCoef = (LAF !== SF ? 1 : -1) * sqrt(cRadicand);
   const transformedCenter = {
@@ -176,17 +163,8 @@ const getSegmentProperties = (
   }
   sweepAngle %= 2 * PI;
 
-  const alpha = startAngle + sweepAngle * (distance || 0);
   const endAngle = startAngle + sweepAngle;
-  const ellipseComponentX = rx * cos(alpha);
-  const ellipseComponentY = ry * sin(alpha);
-
-  const point = {
-    x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY + center.x,
-    y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY + center.y,
-  };
 
-  // to be used later
   // point.ellipticalArcStartAngle = startAngle;
   // point.ellipticalArcEndAngle = startAngle + sweepAngle;
   // point.ellipticalArcAngle = alpha;
@@ -194,24 +172,225 @@ const getSegmentProperties = (
   // 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 {
-    point,
     center,
-    angle: alpha,
     startAngle,
     endAngle,
-    radiusX: rx,
-    radiusY: ry,
-    get length() {
-      return ellipticalArcLength(rx, ry, sweepAngle);
+    rx,
+    ry,
+  };
+};
+
+/**
+ * Returns the length of an Arc segment.
+ *
+ * @param x1 the starting point X
+ * @param y1 the starting point Y
+ * @param c1x the first control point X
+ * @param c1y the first control point Y
+ * @param c2x the second control point X
+ * @param c2y the second control point Y
+ * @param x2 the ending point X
+ * @param y2 the ending point Y
+ * @returns the length of the Arc segment
+ */
+const getArcLength = (
+  x1: number,
+  y1: number,
+  RX: number,
+  RY: number,
+  angle: number,
+  LAF: number,
+  SF: number,
+  x: number,
+  y: number,
+) => {
+  const { rx, ry, startAngle, endAngle } = getArcProps(x1, y1, RX, RY, angle, LAF, SF, x, y);
+  return arcLength(rx, ry, endAngle - startAngle);
+};
+
+/**
+ * Returns a point along an Arc segment at a given distance.
+ *
+ * @param x1 the starting point X
+ * @param y1 the starting point Y
+ * @param RX the radius on X axis
+ * @param RY the radius on Y axis
+ * @param angle the ellipse rotation in degrees
+ * @param LAF the large arc flag
+ * @param SF the sweep flag
+ * @param x2 the ending point X
+ * @param y2 the ending point Y
+ * @param distance a [0-1] ratio
+ * @returns a point along the Arc segment
+ */
+const getPointAtArcLength = (
+  x1: number,
+  y1: number,
+  RX: number,
+  RY: number,
+  angle: number,
+  LAF: number,
+  SF: number,
+  x: number,
+  y: number,
+  distance?: number,
+) => {
+  let point = { x: x1, y: y1 };
+  const { center, rx, ry, startAngle, endAngle } = getArcProps(x1, y1, RX, RY, angle, LAF, SF, x, y);
+
+  /* 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) {
+      point = { x, y };
+    } else {
+      /* istanbul ignore next @preserve */
+      if (x1 === x && y1 === y) {
+        return { x, y };
+      }
+      /* istanbul ignore next @preserve */
+      if (rx === 0 || ry === 0) {
+        return getPointAtLineLength(x1, y1, x, y, distance);
+      }
+      const { PI, cos, sin } = Math;
+      const sweepAngle = endAngle - startAngle;
+      const xRot = ((angle % 360) + 360) % 360;
+      const xRotRad = xRot * (PI / 180);
+      const alpha = startAngle + sweepAngle * (distance / length);
+      const ellipseComponentX = rx * cos(alpha);
+      const ellipseComponentY = ry * sin(alpha);
+
+      point = {
+        x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY + center.x,
+        y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY + center.y,
+      };
+    }
+  }
+
+  return point;
+};
+
+/**
+ * Returns the extrema for an Arc segment.
+ * @see https://github.com/herrstrietzel/svg-pathdata-getbbox
+ *
+ * @param x1 the starting point X
+ * @param y1 the starting point Y
+ * @param RX the radius on X axis
+ * @param RY the radius on Y axis
+ * @param angle the ellipse rotation in degrees
+ * @param LAF the large arc flag
+ * @param SF the sweep flag
+ * @param x2 the ending point X
+ * @param y2 the ending point Y
+ * @returns the extrema of the Arc segment
+ *
+ */
+const getArcBBox = (
+  x1: number,
+  y1: number,
+  RX: number,
+  RY: number,
+  angle: number,
+  LAF: number,
+  SF: number,
+  x: number,
+  y: number,
+) => {
+  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 { x: cx, y: cy } = center;
+
+  // collect extreme points – add end point
+  const extremes = [p];
+
+  // rotation to radians
+  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 = atan2(-ry * tangent, rx);
+  const angle1 = theta;
+  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 = 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 = arcPoint(cx, cy, rx, ry, alpha, angleAfterStart);
+
+  // on path point close before end
+  const angleBeforeEnd = endAngle - deltaAngle * 0.999;
+  const pP3 = arcPoint(cx, cy, rx, ry, alpha, angleBeforeEnd);
+
+  /**
+   * expected extremes
+   * if leaving inner bounding box
+   * (between segment start and end point)
+   * otherwise exclude elliptic extreme points
+   */
+
+  // right
+  // istanbul ignore if @preserve
+  if (pP2.x > xMax || pP3.x > xMax) {
+    // get point for this theta
+    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(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(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(arcPoint(cx, cy, rx, ry, alpha, angle3));
+  }
+
+  return {
+    min: {
+      x: min(...extremes.map(n => n.x)),
+      y: min(...extremes.map(n => n.y)),
     },
-    get bbox() {
-      return minmax(center.x, center.y, rx, ry, xRotRad, startAngle, startAngle + sweepAngle);
+    max: {
+      x: max(...extremes.map(n => n.x)),
+      y: max(...extremes.map(n => n.y)),
     },
   };
 };
 
-export default getSegmentProperties;
+export { arcPoint, angleBetween, getArcLength, arcLength, getArcBBox, getArcProps, getPointAtArcLength };
+
+export {};

package/src/math/bezier.ts

@@ -1,12 +1,20 @@
-import { type Point } from '../types';
+import type {
+  PointTuple,
+  DerivedPoint,
+  QuadPoints,
+  CubicPoints,
+  DerivedQuadPoints,
+  DerivedCubicPoints,
+  QuadCoordinates,
+  CubicCoordinates,
+  DeriveCallback,
+} from '../types';
 
 /**
  * Tools from bezier.js by Mike 'Pomax' Kamermans
  * @see https://github.com/Pomax/bezierjs
  */
 
-const ZERO = { x: 0, y: 0 };
-
 const Tvalues = [
   -0.0640568928626056260850430826247450385909, 0.0640568928626056260850430826247450385909,
   -0.1911188674736163091586398207570696318404, 0.1911188674736163091586398207570696318404,
@@ -37,31 +45,12 @@ const Cvalues = [
   0.0123412297999871995468056670700372915759, 0.0123412297999871995468056670700372915759,
 ];
 
-type DerivedPoint = Point & { t: number };
-type QuadPoints = [Point, Point, Point, Point, Point, Point];
-type CubicPoints = [Point, Point, Point, Point, Point, Point, Point, Point];
-type DerivedQuadPoints = [DerivedPoint, DerivedPoint, DerivedPoint, DerivedPoint, DerivedPoint, DerivedPoint];
-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];
-
-type DeriveCallback = (t: number) => Point;
-
 /**
  *
  * @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;
@@ -83,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) {
@@ -128,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;
@@ -145,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;
 
@@ -160,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;
 };
@@ -169,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({
@@ -177,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);
   });
 };
 
@@ -188,66 +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 else @preserve */
-  if (A[1] >= A[0] ? A[2] >= A[1] : A[2] <= A[1]) {
+  /* istanbul ignore next @preserve */
+  if (cp >= v1 ? v2 >= cp : v2 <= cp) {
     // if no extremum in ]0,1[
-    return [min, max] as [number, number];
+    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]);
-  return (E < min ? [E, max] : [min, E]) as [number, number];
+  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 else @preserve */
+  /* 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 [number, number];
+      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 [number, number];
+    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;
       }
@@ -257,5 +244,18 @@ export const minmaxC = (A: [number, number, number, number]) => {
     }
   }
 
-  return [min, max] as [number, number];
+  return [min, max] as PointTuple;
+};
+
+export {
+  Cvalues,
+  Tvalues,
+  minmaxC,
+  minmaxQ,
+  getBezierLength,
+  bezierLength,
+  calculateBezier,
+  computeBezier,
+  deriveBezier,
+  CBEZIER_MINMAX_EPSILON,
 };