@excalidraw/math 0.18.0-6135548 → 0.18.0-699826

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 = [
@@ -202,113 +210,6 @@ var LegendreGaussN24CValues = [
   0.0123412297999872
 ];
 
-// src/line.ts
-function line(a, b) {
-  return [a, b];
-}
-function linesIntersectAt(a, b) {
-  const A1 = a[1][1] - a[0][1];
-  const B1 = a[0][0] - a[1][0];
-  const A2 = b[1][1] - b[0][1];
-  const B2 = b[0][0] - b[1][0];
-  const D = A1 * B2 - A2 * B1;
-  if (D !== 0) {
-    const C1 = A1 * a[0][0] + B1 * a[0][1];
-    const C2 = A2 * b[0][0] + B2 * b[0][1];
-    return pointFrom((C1 * B2 - C2 * B1) / D, (A1 * C2 - A2 * C1) / D);
-  }
-  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;
-  }
-  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) => {
-  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;
-  }
-  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 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;
-  }
-  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)
-  );
-}
-
 // src/curve.ts
 function curve(a, b, c, d) {
   return [a, b, c, d];
@@ -361,8 +262,15 @@ var initial_guesses = [
   [0.2, 0],
   [0.8, 0]
 ];
-var calculate = ([t0, s0], l, c) => {
-  const solution = solveWithAnalyticalJacobian(c, l, t0, s0, 0.01, 3);
+var calculate = ([t0, s0], l, c, tolerance = 0.01, iterLimit = 4) => {
+  const solution = solveWithAnalyticalJacobian(
+    c,
+    l,
+    t0,
+    s0,
+    tolerance,
+    iterLimit
+  );
   if (!solution) {
     return null;
   }
@@ -372,33 +280,37 @@ var calculate = ([t0, s0], l, c) => {
   }
   return bezierEquation(c, t);
 };
-function curveIntersectLineSegment(c, l) {
-  let solution = calculate(initial_guesses[0], l, c);
+function curveIntersectLineSegment(c, l, opts) {
+  let solution = calculate(
+    initial_guesses[0],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit
+  );
   if (solution) {
     return [solution];
   }
-  solution = calculate(initial_guesses[1], l, c);
+  solution = calculate(
+    initial_guesses[1],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit
+  );
   if (solution) {
     return [solution];
   }
-  solution = calculate(initial_guesses[2], l, c);
+  solution = calculate(
+    initial_guesses[2],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit
+  );
   if (solution) {
     return [solution];
   }
-  const startHit = lineSegmentIntersectionPoints(
-    lineSegment(bezierEquation(c, 0), bezierEquation(c, 1 / 20)),
-    l
-  );
-  if (startHit) {
-    return [startHit];
-  }
-  const endHit = lineSegmentIntersectionPoints(
-    lineSegment(bezierEquation(c, 19 / 20), bezierEquation(c, 1)),
-    l
-  );
-  if (endHit) {
-    return [endHit];
-  }
   return [];
 }
 function curveClosestPoint(c, p, tolerance = 1e-3) {
@@ -708,6 +620,113 @@ function ellipseLineIntersectionPoints({ center, halfWidth, halfHeight }, [g, h]
   return candidates;
 }
 
+// src/line.ts
+function line(a, b) {
+  return [a, b];
+}
+function linesIntersectAt(a, b) {
+  const A1 = a[1][1] - a[0][1];
+  const B1 = a[0][0] - a[1][0];
+  const A2 = b[1][1] - b[0][1];
+  const B2 = b[0][0] - b[1][0];
+  const D = A1 * B2 - A2 * B1;
+  if (D !== 0) {
+    const C1 = A1 * a[0][0] + B1 * a[0][1];
+    const C2 = A2 * b[0][0] + B2 * b[0][1];
+    return pointFrom((C1 * B2 - C2 * B1) / D, (A1 * C2 - A2 * C1) / D);
+  }
+  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[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) => {
+  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;
+  }
+  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 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;
+  }
+  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)
+  );
+}
+
 // src/polygon.ts
 function polygon(...points) {
   return polygonClose(points);
@@ -860,6 +879,7 @@ export {
   isPoint,
   isPointWithinBounds,
   isRightAngleRads,
+  isValidPoint,
   isVector,
   line,
   lineSegment,