@excalidraw/math 0.18.0-414182f → 0.18.0-43a92e6

package/dist/dev/index.js

@@ -101,8 +101,8 @@ var vectorNormalize = (v) => {
 var vectorNormal = (v) => vector(v[1], -v[0]);
 
 // src/point.ts
-function pointFrom(x, y) {
-  return [x, y];
+function pointFrom(xOrCoords, y) {
+  return typeof xOrCoords === "object" ? [xOrCoords.x, xOrCoords.y] : [xOrCoords, y];
 }
 function pointFromArray(numberArray) {
   return numberArray.length === 2 ? pointFrom(numberArray[0], numberArray[1]) : void 0;
@@ -120,7 +120,12 @@ function pointsEqual(a, b, tolerance = PRECISION) {
   const abs = Math.abs;
   return abs(a[0] - b[0]) < tolerance && abs(a[1] - b[1]) < tolerance;
 }
-function pointRotateRads([x, y], [cx, cy], angle) {
+function pointRotateRads(point, center, angle) {
+  if (!angle) {
+    return point;
+  }
+  const [x, y] = point;
+  const [cx, cy] = center;
   return pointFrom(
     (x - cx) * Math.cos(angle) - (y - cy) * Math.sin(angle) + cx,
     (x - cx) * Math.sin(angle) + (y - cy) * Math.cos(angle) + cy
@@ -147,6 +152,9 @@ var pointScaleFromOrigin = (p, mid, multiplier) => pointTranslate(mid, vectorSca
 var isPointWithinBounds = (p, q, r) => {
   return q[0] <= Math.max(p[0], r[0]) && q[0] >= Math.min(p[0], r[0]) && q[1] <= Math.max(p[1], r[1]) && q[1] >= Math.min(p[1], r[1]);
 };
+var isValidPoint = (point) => {
+  return Array.isArray(point) && point.length === 2 && isFiniteNumber(point[0]) && isFiniteNumber(point[1]);
+};
 
 // src/constants.ts
 var LegendreGaussN24TValues = [
@@ -206,41 +214,41 @@ var LegendreGaussN24CValues = [
 function curve(a, b, c, d) {
   return [a, b, c, d];
 }
-function gradient(f, t0, s0, delta = 1e-6) {
-  return [
-    (f(t0 + delta, s0) - f(t0 - delta, s0)) / (2 * delta),
-    (f(t0, s0 + delta) - f(t0, s0 - delta)) / (2 * delta)
-  ];
-}
-function solve(f, t0, s0, tolerance = 1e-3, iterLimit = 10) {
+function solveWithAnalyticalJacobian(curve2, lineSegment2, t0, s0, tolerance = 1e-3, iterLimit = 10) {
   let error = Infinity;
   let iter = 0;
   while (error >= tolerance) {
     if (iter >= iterLimit) {
       return null;
     }
-    const y0 = f(t0, s0);
-    const jacobian = [
-      gradient((t, s) => f(t, s)[0], t0, s0),
-      gradient((t, s) => f(t, s)[1], t0, s0)
-    ];
-    const b = [[-y0[0]], [-y0[1]]];
-    const det = jacobian[0][0] * jacobian[1][1] - jacobian[0][1] * jacobian[1][0];
-    if (det === 0) {
+    const bt = 1 - t0;
+    const bt2 = bt * bt;
+    const bt3 = bt2 * bt;
+    const t0_2 = t0 * t0;
+    const t0_3 = t0_2 * t0;
+    const bezierX = bt3 * curve2[0][0] + 3 * bt2 * t0 * curve2[1][0] + 3 * bt * t0_2 * curve2[2][0] + t0_3 * curve2[3][0];
+    const bezierY = bt3 * curve2[0][1] + 3 * bt2 * t0 * curve2[1][1] + 3 * bt * t0_2 * curve2[2][1] + t0_3 * curve2[3][1];
+    const lineX = lineSegment2[0][0] + s0 * (lineSegment2[1][0] - lineSegment2[0][0]);
+    const lineY = lineSegment2[0][1] + s0 * (lineSegment2[1][1] - lineSegment2[0][1]);
+    const fx = bezierX - lineX;
+    const fy = bezierY - lineY;
+    error = Math.abs(fx) + Math.abs(fy);
+    if (error < tolerance) {
+      break;
+    }
+    const dfx_dt = -3 * bt2 * curve2[0][0] + 3 * bt2 * curve2[1][0] - 6 * bt * t0 * curve2[1][0] - 3 * t0_2 * curve2[2][0] + 6 * bt * t0 * curve2[2][0] + 3 * t0_2 * curve2[3][0];
+    const dfy_dt = -3 * bt2 * curve2[0][1] + 3 * bt2 * curve2[1][1] - 6 * bt * t0 * curve2[1][1] - 3 * t0_2 * curve2[2][1] + 6 * bt * t0 * curve2[2][1] + 3 * t0_2 * curve2[3][1];
+    const dfx_ds = -(lineSegment2[1][0] - lineSegment2[0][0]);
+    const dfy_ds = -(lineSegment2[1][1] - lineSegment2[0][1]);
+    const det = dfx_dt * dfy_ds - dfx_ds * dfy_dt;
+    if (Math.abs(det) < 1e-12) {
       return null;
     }
-    const iJ = [
-      [jacobian[1][1] / det, -jacobian[0][1] / det],
-      [-jacobian[1][0] / det, jacobian[0][0] / det]
-    ];
-    const h = [
-      [iJ[0][0] * b[0][0] + iJ[0][1] * b[1][0]],
-      [iJ[1][0] * b[0][0] + iJ[1][1] * b[1][0]]
-    ];
-    t0 = t0 + h[0][0];
-    s0 = s0 + h[1][0];
-    const [tErr, sErr] = f(t0, s0);
-    error = Math.max(Math.abs(tErr), Math.abs(sErr));
+    const invDet = 1 / det;
+    const dt = invDet * (dfy_ds * -fx - dfx_ds * -fy);
+    const ds = invDet * (-dfy_dt * -fx + dfx_dt * -fy);
+    t0 += dt;
+    s0 += ds;
     iter += 1;
   }
   return [t0, s0];
@@ -249,53 +257,63 @@ var bezierEquation = (c, t) => pointFrom(
   (1 - t) ** 3 * c[0][0] + 3 * (1 - t) ** 2 * t * c[1][0] + 3 * (1 - t) * t ** 2 * c[2][0] + t ** 3 * c[3][0],
   (1 - t) ** 3 * c[0][1] + 3 * (1 - t) ** 2 * t * c[1][1] + 3 * (1 - t) * t ** 2 * c[2][1] + t ** 3 * c[3][1]
 );
-function curveIntersectLineSegment(c, l) {
-  const line2 = (s) => pointFrom(
-    l[0][0] + s * (l[1][0] - l[0][0]),
-    l[0][1] + s * (l[1][1] - l[0][1])
+var initial_guesses = [
+  [0.5, 0],
+  [0.2, 0],
+  [0.8, 0]
+];
+var calculate = ([t0, s0], l, c, tolerance = 0.01, iterLimit = 4) => {
+  const solution = solveWithAnalyticalJacobian(
+    c,
+    l,
+    t0,
+    s0,
+    tolerance,
+    iterLimit
+  );
+  if (!solution) {
+    return null;
+  }
+  const [t, s] = solution;
+  if (t < 0 || t > 1 || s < 0 || s > 1) {
+    return null;
+  }
+  return bezierEquation(c, t);
+};
+function curveIntersectLineSegment(c, l, opts) {
+  let solution = calculate(
+    initial_guesses[0],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit
   );
-  const initial_guesses = [
-    [0.5, 0],
-    [0.2, 0],
-    [0.8, 0]
-  ];
-  const calculate = ([t0, s0]) => {
-    const solution2 = solve(
-      (t2, s2) => {
-        const bezier_point = bezierEquation(c, t2);
-        const line_point = line2(s2);
-        return [
-          bezier_point[0] - line_point[0],
-          bezier_point[1] - line_point[1]
-        ];
-      },
-      t0,
-      s0
-    );
-    if (!solution2) {
-      return null;
-    }
-    const [t, s] = solution2;
-    if (t < 0 || t > 1 || s < 0 || s > 1) {
-      return null;
-    }
-    return bezierEquation(c, t);
-  };
-  let solution = calculate(initial_guesses[0]);
   if (solution) {
     return [solution];
   }
-  solution = calculate(initial_guesses[1]);
+  solution = calculate(
+    initial_guesses[1],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit
+  );
   if (solution) {
     return [solution];
   }
-  solution = calculate(initial_guesses[2]);
+  solution = calculate(
+    initial_guesses[2],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit
+  );
   if (solution) {
     return [solution];
   }
   return [];
 }
-function curveClosestPoint(c, p, tolerance = 1e-3) {
+function curveClosestParameter(c, p, tolerance = 1e-3) {
   const localMinimum = (min, max, f, e = tolerance) => {
     let m = min;
     let n = max;
@@ -312,7 +330,7 @@ function curveClosestPoint(c, p, tolerance = 1e-3) {
   };
   const maxSteps = 30;
   let closestStep = 0;
-  for (let min = Infinity, step = 0; step < maxSteps; step++) {
+  for (let min = Infinity, step = 0; step <= maxSteps; step++) {
     const d = pointDistance(p, bezierEquation(c, step / maxSteps));
     if (d < min) {
       min = d;
@@ -321,22 +339,18 @@ function curveClosestPoint(c, p, tolerance = 1e-3) {
   }
   const t0 = Math.max((closestStep - 1) / maxSteps, 0);
   const t1 = Math.min((closestStep + 1) / maxSteps, 1);
-  const solution = localMinimum(
+  const param = localMinimum(
     t0,
     t1,
     (t) => pointDistance(p, bezierEquation(c, t))
   );
-  if (!solution) {
-    return null;
-  }
-  return bezierEquation(c, solution);
+  return param ?? closestStep / maxSteps;
 }
-function curvePointDistance(c, p) {
-  const closest = curveClosestPoint(c, p);
-  if (!closest) {
-    return 0;
-  }
-  return pointDistance(p, closest);
+function curveClosestPoint(c, p, tolerance = 1e-3) {
+  return bezierEquation(c, curveClosestParameter(c, p, tolerance));
+}
+function curvePointDistance(c, p, tolerance = 1e-3) {
+  return pointDistance(p, curveClosestPoint(c, p, tolerance));
 }
 function isCurve(v) {
   return Array.isArray(v) && v.length === 4 && isPoint(v[0]) && isPoint(v[1]) && isPoint(v[2]) && isPoint(v[3]);
@@ -454,14 +468,13 @@ function curveLengthAtParameter(c, t) {
   }
   return z1 * sum;
 }
-function curvePointAtLength(c, percent) {
+function curvePointAtLength(c, percent, totalLength = curveLength(c)) {
   if (percent <= 0) {
     return bezierEquation(c, 0);
   }
   if (percent >= 1) {
     return bezierEquation(c, 1);
   }
-  const totalLength = curveLength(c);
   const targetLength = totalLength * percent;
   let tMin = 0;
   let tMax = 1;
@@ -510,6 +523,9 @@ var ellipseDistanceFromPoint = (p, ellipse2) => {
     vectorFromPoint(p),
     vectorScale(vectorFromPoint(center), -1)
   );
+  if (a === b) {
+    return Math.abs(Math.hypot(translatedPoint[0], translatedPoint[1]) - a);
+  }
   const px = Math.abs(translatedPoint[0]);
   const py = Math.abs(translatedPoint[1]);
   let tx = 0.707;
@@ -525,6 +541,9 @@ var ellipseDistanceFromPoint = (p, ellipse2) => {
     const qy = py - ey;
     const r = Math.hypot(ry, rx);
     const q = Math.hypot(qy, qx);
+    if (q === 0) {
+      break;
+    }
     tx = Math.min(1, Math.max(0, (qx * r / q + ex) / a));
     ty = Math.min(1, Math.max(0, (qy * r / q + ey) / b));
     const t = Math.hypot(ty, tx);
@@ -532,8 +551,8 @@ var ellipseDistanceFromPoint = (p, ellipse2) => {
     ty /= t;
   }
   const [minX, minY] = [
-    a * tx * Math.sign(translatedPoint[0]),
-    b * ty * Math.sign(translatedPoint[1])
+    a * tx * (translatedPoint[0] < 0 ? -1 : 1),
+    b * ty * (translatedPoint[1] < 0 ? -1 : 1)
   ];
   return pointDistance(pointFromVector(translatedPoint), pointFrom(minX, minY));
 };
@@ -620,82 +639,98 @@ function linesIntersectAt(a, b) {
   return null;
 }
 
-// src/segment.ts
-function lineSegment(a, b) {
-  return [a, b];
-}
-var isLineSegment = (segment) => Array.isArray(segment) && segment.length === 2 && isPoint(segment[0]) && isPoint(segment[0]);
-var lineSegmentRotate = (l, angle, origin) => {
-  return lineSegment(
-    pointRotateRads(l[0], origin || pointCenter(l[0], l[1]), angle),
-    pointRotateRads(l[1], origin || pointCenter(l[0], l[1]), angle)
-  );
-};
-var segmentsIntersectAt = (a, b) => {
-  const a0 = vectorFromPoint(a[0]);
-  const a1 = vectorFromPoint(a[1]);
-  const b0 = vectorFromPoint(b[0]);
-  const b1 = vectorFromPoint(b[1]);
-  const r = vectorSubtract(a1, a0);
-  const s = vectorSubtract(b1, b0);
-  const denominator = vectorCross(r, s);
-  if (denominator === 0) {
-    return null;
+// src/pca.ts
+function centroid(points) {
+  let cx = 0;
+  let cy = 0;
+  for (const [x, y] of points) {
+    cx += x;
+    cy += y;
   }
-  const i = vectorSubtract(vectorFromPoint(b[0]), vectorFromPoint(a[0]));
-  const u = vectorCross(i, r) / denominator;
-  const t = vectorCross(i, s) / denominator;
-  if (u === 0) {
-    return null;
+  return pointFrom(cx / points.length, cy / points.length);
+}
+function principalAxes(points) {
+  if (points.length < 2) {
+    console.error("Degenerate point set: at least two points are required");
   }
-  const p = vectorAdd(a0, vectorScale(r, t));
-  if (t >= 0 && t < 1 && u >= 0 && u < 1) {
-    return pointFromVector(p);
+  const c = centroid(points);
+  let m20 = 0;
+  let m02 = 0;
+  let m11 = 0;
+  for (const [x, y] of points) {
+    const dx = x - c[0];
+    const dy = y - c[1];
+    m20 += dx * dx;
+    m02 += dy * dy;
+    m11 += dx * dy;
   }
-  return null;
-};
-var pointOnLineSegment = (point, line2, threshold = PRECISION) => {
-  const distance = distanceToLineSegment(point, line2);
-  if (distance === 0) {
-    return true;
+  m20 /= points.length;
+  m02 /= points.length;
+  m11 /= points.length;
+  const trace = m20 + m02;
+  const diff = Math.hypot(m20 - m02, 2 * m11);
+  const majorVariance = (trace + diff) / 2;
+  const minorVariance = (trace - diff) / 2;
+  let major;
+  if (Math.abs(m11) > Number.EPSILON) {
+    major = vectorNormalize(vector(majorVariance - m02, m11));
+  } else {
+    major = m20 >= m02 ? vector(1, 0) : vector(0, 1);
   }
-  return distance < threshold;
-};
-var distanceToLineSegment = (point, line2) => {
-  const [x, y] = point;
-  const [[x1, y1], [x2, y2]] = line2;
-  const A = x - x1;
-  const B = y - y1;
-  const C = x2 - x1;
-  const D = y2 - y1;
-  const dot = A * C + B * D;
-  const len_sq = C * C + D * D;
-  let param = -1;
-  if (len_sq !== 0) {
-    param = dot / len_sq;
+  return {
+    centroid: c,
+    major,
+    minor: vectorNormal(major),
+    majorVariance,
+    minorVariance
+  };
+}
+function principalCoords(points, axes, scale = 1) {
+  const { centroid: c, major, minor } = axes;
+  return points.map(([x, y]) => {
+    const dx = x - c[0];
+    const dy = y - c[1];
+    return [
+      (dx * major[0] + dy * major[1]) * scale,
+      (dx * minor[0] + dy * minor[1]) * scale
+    ];
+  });
+}
+function orientPrincipalAxes(points, axes) {
+  const u = principalCoords(points, axes).map(([uu]) => uu);
+  if (skewness(u) <= 0) {
+    return axes;
   }
-  let xx;
-  let yy;
-  if (param < 0) {
-    xx = x1;
-    yy = y1;
-  } else if (param > 1) {
-    xx = x2;
-    yy = y2;
-  } else {
-    xx = x1 + param * C;
-    yy = y1 + param * D;
+  const major = vectorScale(axes.major, -1);
+  return { ...axes, major, minor: vectorNormal(major) };
+}
+function elongation(axes) {
+  return axes.majorVariance > 0 ? axes.minorVariance / axes.majorVariance : 1;
+}
+function standardizedMoment(values, order) {
+  const n = values.length;
+  let mean = 0;
+  for (const v of values) {
+    mean += v;
   }
-  const dx = x - xx;
-  const dy = y - yy;
-  return Math.sqrt(dx * dx + dy * dy);
-};
-function lineSegmentIntersectionPoints(l, s, threshold) {
-  const candidate = linesIntersectAt(line(l[0], l[1]), line(s[0], s[1]));
-  if (!candidate || !pointOnLineSegment(candidate, s, threshold) || !pointOnLineSegment(candidate, l, threshold)) {
-    return null;
+  mean /= n;
+  let variance = 0;
+  let moment = 0;
+  for (const v of values) {
+    const d = v - mean;
+    variance += d * d;
+    moment += d ** order;
   }
-  return candidate;
+  variance /= n;
+  moment /= n;
+  const sigma = Math.sqrt(variance);
+  return sigma > Number.EPSILON ? moment / sigma ** order : 0;
+}
+function skewness(values) {
+  return standardizedMoment(values, 3);
+}
+function kurtosis(values) {
+  return standardizedMoment(values, 4);
 }
 
 // src/polygon.ts
@@ -741,21 +776,84 @@ var polygonIncludesPointNonZero = (point, polygon2) => {
   }
   return windingNumber !== 0;
 };
-var pointOnPolygon = (p, poly, threshold = PRECISION) => {
-  let on = false;
-  for (let i = 0, l = poly.length - 1; i < l; i++) {
-    if (pointOnLineSegment(p, lineSegment(poly[i], poly[i + 1]), threshold)) {
-      on = true;
-      break;
-    }
-  }
-  return on;
-};
 function polygonClose(polygon2) {
   return polygonIsClosed(polygon2) ? polygon2 : [...polygon2, polygon2[0]];
 }
-function polygonIsClosed(polygon2) {
-  return pointsEqual(polygon2[0], polygon2[polygon2.length - 1]);
+function polygonIsClosed(polygon2, tolerance = PRECISION) {
+  return pointsEqual(polygon2[0], polygon2[polygon2.length - 1], tolerance);
+}
+function polygonSignedArea(polygon2, tolerance = PRECISION) {
+  const pts = polygonIsClosed(polygon2, tolerance) ? polygon2.slice(0, -1) : polygon2;
+  let sum = 0;
+  for (let i = 0, j = pts.length - 1; i < pts.length; j = i++) {
+    sum += pts[j][0] * pts[i][1] - pts[i][0] * pts[j][1];
+  }
+  return sum / 2;
+}
+function polygonArea(polygon2, tolerance = PRECISION) {
+  return Math.abs(polygonSignedArea(polygon2, tolerance));
+}
+function convexHull(points) {
+  if (points.length < 3) {
+    return [...points];
+  }
+  const sorted = [...points].sort(
+    (a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]
+  );
+  const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+  const half = (pts) => {
+    const chain = [];
+    for (const p of pts) {
+      while (chain.length >= 2 && cross(chain[chain.length - 2], chain[chain.length - 1], p) <= 0) {
+        chain.pop();
+      }
+      chain.push(p);
+    }
+    chain.pop();
+    return chain;
+  };
+  const hull = [...half(sorted), ...half([...sorted].reverse())];
+  return hull.length >= 3 ? hull : [...points];
+}
+function simplifyConvexPolygon(polygon2, angleThreshold) {
+  if (polygon2.length < 3) {
+    return [...polygon2];
+  }
+  const turnAt = (i) => {
+    const prev = polygon2[(i - 1 + polygon2.length) % polygon2.length];
+    const curr = polygon2[i];
+    const next = polygon2[(i + 1) % polygon2.length];
+    const inAngle = Math.atan2(curr[1] - prev[1], curr[0] - prev[0]);
+    const outAngle = Math.atan2(next[1] - curr[1], next[0] - curr[0]);
+    return Math.abs(normalizeTurn(outAngle - inAngle));
+  };
+  let start = 0;
+  for (let i = 1; i < polygon2.length; i++) {
+    if (turnAt(i) > turnAt(start)) {
+      start = i;
+    }
+  }
+  const simplified = [];
+  let accumulated = 0;
+  for (let k = 0; k < polygon2.length; k++) {
+    const i = (start + k) % polygon2.length;
+    accumulated += turnAt(i);
+    if (accumulated >= angleThreshold) {
+      simplified.push(polygon2[i]);
+      accumulated = 0;
+    }
+  }
+  return simplified.length >= 3 ? simplified : [...polygon2];
+}
+function normalizeTurn(angle) {
+  let a = angle;
+  while (a > Math.PI) {
+    a -= 2 * Math.PI;
+  }
+  while (a < -Math.PI) {
+    a += 2 * Math.PI;
+  }
+  return a;
 }
 
 // src/range.ts
@@ -787,6 +885,91 @@ var rangeIncludesValue = (value, [min, max]) => {
   return value >= min && value <= max;
 };
 
+// src/segment.ts
+function lineSegment(a, b) {
+  return [a, b];
+}
+var isLineSegment = (segment) => Array.isArray(segment) && segment.length === 2 && isPoint(segment[0]) && isPoint(segment[1]);
+var lineSegmentRotate = (l, angle, origin) => {
+  return lineSegment(
+    pointRotateRads(l[0], origin || pointCenter(l[0], l[1]), angle),
+    pointRotateRads(l[1], origin || pointCenter(l[0], l[1]), angle)
+  );
+};
+var segmentsIntersectAt = (a, b) => {
+  const a0 = vectorFromPoint(a[0]);
+  const a1 = vectorFromPoint(a[1]);
+  const b0 = vectorFromPoint(b[0]);
+  const b1 = vectorFromPoint(b[1]);
+  const r = vectorSubtract(a1, a0);
+  const s = vectorSubtract(b1, b0);
+  const denominator = vectorCross(r, s);
+  if (denominator === 0) {
+    return null;
+  }
+  const i = vectorSubtract(vectorFromPoint(b[0]), vectorFromPoint(a[0]));
+  const u = vectorCross(i, r) / denominator;
+  const t = vectorCross(i, s) / denominator;
+  if (u === 0) {
+    return null;
+  }
+  const p = vectorAdd(a0, vectorScale(r, t));
+  if (t >= 0 && t < 1 && u >= 0 && u < 1) {
+    return pointFromVector(p);
+  }
+  return null;
+};
+var pointOnLineSegment = (point, line2, threshold = PRECISION) => {
+  const distance = distanceToLineSegment(point, line2);
+  if (distance === 0) {
+    return true;
+  }
+  return distance < threshold;
+};
+var distanceToLineSegment = (point, line2) => {
+  return pointDistance(
+    point,
+    lineSegmentPointAt(line2, lineSegmentClosestParameter(point, line2))
+  );
+};
+function lineSegmentPointAt(line2, t) {
+  const [[x1, y1], [x2, y2]] = line2;
+  return pointFrom(x1 + t * (x2 - x1), y1 + t * (y2 - y1));
+}
+function lineSegmentIntersectionPoints(l, s, threshold) {
+  const candidate = linesIntersectAt(line(l[0], l[1]), line(s[0], s[1]));
+  if (!candidate || !pointOnLineSegment(candidate, s, threshold) || !pointOnLineSegment(candidate, l, threshold)) {
+    return null;
+  }
+  return candidate;
+}
+function lineSegmentsDistance(s1, s2) {
+  if (lineSegmentIntersectionPoints(s1, s2)) {
+    return 0;
+  }
+  return Math.min(
+    distanceToLineSegment(s1[0], s2),
+    distanceToLineSegment(s1[1], s2),
+    distanceToLineSegment(s2[0], s1),
+    distanceToLineSegment(s2[1], s1)
+  );
+}
+function lineSegmentClosestParameter(point, line2) {
+  const [x, y] = point;
+  const [[x1, y1], [x2, y2]] = line2;
+  const A = x - x1;
+  const B = y - y1;
+  const C = x2 - x1;
+  const D = y2 - y1;
+  const dot = A * C + B * D;
+  const len_sq = C * C + D * D;
+  let param = 0;
+  if (len_sq !== 0) {
+    param = dot / len_sq;
+  }
+  return Math.max(0, Math.min(1, param));
+}
+
 // src/rectangle.ts
 function rectangle(topLeft, bottomRight) {
   return [topLeft, bottomRight];
@@ -823,10 +1006,13 @@ export {
   average,
   bezierEquation,
   cartesian2Polar,
+  centroid,
   clamp,
+  convexHull,
   curve,
   curveCatmullRomCubicApproxPoints,
   curveCatmullRomQuadraticApproxPoints,
+  curveClosestParameter,
   curveClosestPoint,
   curveIntersectLineSegment,
   curveLength,
@@ -843,6 +1029,7 @@ export {
   ellipseLineIntersectionPoints,
   ellipseSegmentInterceptPoints,
   ellipseTouchesPoint,
+  elongation,
   isCloseTo,
   isCurve,
   isFiniteNumber,
@@ -850,14 +1037,20 @@ export {
   isPoint,
   isPointWithinBounds,
   isRightAngleRads,
+  isValidPoint,
   isVector,
+  kurtosis,
   line,
   lineSegment,
+  lineSegmentClosestParameter,
   lineSegmentIntersectionPoints,
+  lineSegmentPointAt,
   lineSegmentRotate,
+  lineSegmentsDistance,
   linesIntersectAt,
   normalizeRadians,
   offsetPointsForQuadraticBezier,
+  orientPrincipalAxes,
   pointCenter,
   pointDistance,
   pointDistanceSq,
@@ -866,16 +1059,20 @@ export {
   pointFromPair,
   pointFromVector,
   pointOnLineSegment,
-  pointOnPolygon,
   pointRotateDegs,
   pointRotateRads,
   pointScaleFromOrigin,
   pointTranslate,
   pointsEqual,
   polygon,
+  polygonArea,
   polygonFromPoints,
   polygonIncludesPoint,
   polygonIncludesPointNonZero,
+  polygonIsClosed,
+  polygonSignedArea,
+  principalAxes,
+  principalCoords,
   radiansBetweenAngles,
   radiansDifference,
   radiansToDegrees,
@@ -891,6 +1088,9 @@ export {
   round,
   roundToStep,
   segmentsIntersectAt,
+  simplifyConvexPolygon,
+  skewness,
+  standardizedMoment,
   triangleIncludesPoint,
   vector,
   vectorAdd,