modern-path2d 1.6.0 → 1.7.0

package/dist/index.cjs

@@ -126,7 +126,10 @@ class Vector2 {
     return this.set(this._x * x, this._y * y);
   }
   divide(x = 0, y = x) {
-    return this.set(this._x / x, this._y / y);
+    return this.set(
+      x === 0 ? this._x : this._x / x,
+      y === 0 ? this._y : this._y / y
+    );
   }
   cross(p) {
     return this._x * p.y - this._y * p.x;
@@ -319,17 +322,11 @@ function getIntersectionPoint(p1, p2, q1, q2) {
   const q1p1 = q1.clone().sub(p1);
   const crossRS = r.cross(s);
   if (crossRS === 0) {
-    return new Vector2(
-      (p1.x + q1.x) / 2,
-      (p1.y + q1.y) / 2
-    );
+    return null;
   }
   const t = q1p1.cross(s) / crossRS;
   if (Math.abs(t) > 1) {
-    return new Vector2(
-      (p1.x + q1.x) / 2,
-      (p1.y + q1.y) / 2
-    );
+    return null;
   }
   return new Vector2(
     p1.x + t * r.x,
@@ -598,7 +595,7 @@ function getDirectedArea(vertices) {
 function cross(ax, ay, bx, by, cx, cy) {
   return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
 }
-function windingNumber(px, py, polygon) {
+function windingNumber$1(px, py, polygon) {
   const polygonLen = polygon.length;
   let wn = 0;
   for (let i = 0, j = polygonLen - 2; i < polygonLen; j = i, i += 2) {
@@ -621,11 +618,16 @@ function distance(p1, p2) {
   const dy = p2[1] - p1[1];
   return Math.sqrt(dx * dx + dy * dy);
 }
+function aabbIntersects(a, b) {
+  return a.minX <= b.maxX && a.maxX >= b.minX && a.minY <= b.maxY && a.maxY >= b.minY;
+}
 function nonzeroFillRule(paths) {
   const results = paths.map((_, i) => ({ index: i }));
-  const testPointsGroups = paths.map((path) => {
+  const bboxes = [];
+  const testPointsGroups = paths.map((path, pathIndex) => {
     const len = path.length;
     if (!len) {
+      bboxes[pathIndex] = null;
       return [];
     }
     let xMinYAuto = [Number.MAX_SAFE_INTEGER, 0];
@@ -648,6 +650,12 @@ function nonzeroFillRule(paths) {
         xAutoYMax = [x, y];
       }
     }
+    bboxes[pathIndex] = {
+      minX: xMinYAuto[0],
+      minY: xAutoYMin[1],
+      maxX: xMaxYAuto[0],
+      maxY: xAutoYMax[1]
+    };
     const mid = [
       (xMinYAuto[0] + xMaxYAuto[0]) / 2,
       (xAutoYMin[1] + xAutoYMax[1]) / 2
@@ -696,14 +704,19 @@ function nonzeroFillRule(paths) {
   for (let i = 0, len = paths.length; i < len; i++) {
     const _results = [];
     const testPoints = testPointsGroups[i];
+    const boxI = bboxes[i];
     for (let j = 0; j < len; j++) {
       if (i === j)
         continue;
+      const boxJ = bboxes[j];
+      if (!boxI || !boxJ || !aabbIntersects(boxI, boxJ)) {
+        continue;
+      }
       const wnMap = {};
       const wnList = [];
       for (let p = 0, pLen = testPoints.length; p < pLen; p++) {
         const [x, y] = testPoints[p];
-        const winding = windingNumber(x, y, paths[j]);
+        const winding = windingNumber$1(x, y, paths[j]);
         wnMap[winding] = (wnMap[winding] ?? 0) + 1;
         wnList.push(winding);
       }
@@ -726,6 +739,120 @@ function nonzeroFillRule(paths) {
   return results;
 }
 
+function isLeft(ax, ay, bx, by, px, py) {
+  return (bx - ax) * (py - ay) - (px - ax) * (by - ay);
+}
+function windingNumber(px, py, vertices) {
+  const len = vertices.length;
+  let wn = 0;
+  for (let i = 0; i < len; i += 2) {
+    const ax = vertices[i];
+    const ay = vertices[i + 1];
+    const k = (i + 2) % len;
+    const bx = vertices[k];
+    const by = vertices[k + 1];
+    if (ay <= py) {
+      if (by > py && isLeft(ax, ay, bx, by, px, py) > 0) {
+        wn++;
+      }
+    } else {
+      if (by <= py && isLeft(ax, ay, bx, by, px, py) < 0) {
+        wn--;
+      }
+    }
+  }
+  return wn;
+}
+function crossingNumber(px, py, vertices) {
+  const len = vertices.length;
+  let cn = 0;
+  for (let i = 0; i < len; i += 2) {
+    const ax = vertices[i];
+    const ay = vertices[i + 1];
+    const k = (i + 2) % len;
+    const bx = vertices[k];
+    const by = vertices[k + 1];
+    if (ay <= py && by > py || ay > py && by <= py) {
+      const t = (py - ay) / (by - ay);
+      if (px < ax + t * (bx - ax)) {
+        cn++;
+      }
+    }
+  }
+  return cn;
+}
+function segmentDistance(px, py, ax, ay, bx, by) {
+  const dx = bx - ax;
+  const dy = by - ay;
+  const lenSq = dx * dx + dy * dy;
+  let t = lenSq === 0 ? 0 : ((px - ax) * dx + (py - ay) * dy) / lenSq;
+  if (t < 0) {
+    t = 0;
+  } else if (t > 1) {
+    t = 1;
+  }
+  const cx = ax + t * dx;
+  const cy = ay + t * dy;
+  return Math.hypot(px - cx, py - cy);
+}
+function pointInPolygon(point, vertices, fillRule = "nonzero") {
+  if (vertices.length < 6) {
+    return false;
+  }
+  if (fillRule === "evenodd") {
+    return (crossingNumber(point.x, point.y, vertices) & 1) === 1;
+  }
+  return windingNumber(point.x, point.y, vertices) !== 0;
+}
+function pointInPolygons(point, polygons, fillRule = "nonzero") {
+  const { x, y } = point;
+  if (fillRule === "evenodd") {
+    let cn = 0;
+    for (let i = 0, len = polygons.length; i < len; i++) {
+      const ring = polygons[i];
+      if (ring.length >= 6) {
+        cn += crossingNumber(x, y, ring);
+      }
+    }
+    return (cn & 1) === 1;
+  }
+  let wn = 0;
+  for (let i = 0, len = polygons.length; i < len; i++) {
+    const ring = polygons[i];
+    if (ring.length >= 6) {
+      wn += windingNumber(x, y, ring);
+    }
+  }
+  return wn !== 0;
+}
+function pointToSegmentDistance(point, a, b) {
+  return segmentDistance(point.x, point.y, a.x, a.y, b.x, b.y);
+}
+function pointToPolylineDistance(point, vertices, closed = false) {
+  const len = vertices.length;
+  if (len < 2) {
+    return Infinity;
+  }
+  const { x: px, y: py } = point;
+  if (len === 2) {
+    return Math.hypot(px - vertices[0], py - vertices[1]);
+  }
+  let min = Infinity;
+  for (let i = 0; i < len - 2; i += 2) {
+    const d = segmentDistance(px, py, vertices[i], vertices[i + 1], vertices[i + 2], vertices[i + 3]);
+    if (d < min) {
+      min = d;
+    }
+  }
+  if (closed && len >= 6) {
+    const d = segmentDistance(px, py, vertices[len - 2], vertices[len - 1], vertices[0], vertices[1]);
+    if (d < min) {
+      min = d;
+    }
+  }
+  return min;
+}
+
 function quadraticBezierP0(t, p) {
   const k = 1 - t;
   return k * k * p;
@@ -2539,6 +2666,41 @@ function svgToPath2DSet(svg) {
 class Curve {
   arcLengthDivision = 200;
   _lengths = [];
+  _adaptiveCache;
+  /**
+   * Parent composite, set lazily when a composite caches its children. Lets
+   * {@link invalidate} propagate up so an ancestor's caches refresh too.
+   */
+  _owner;
+  _invalidating = false;
+  /**
+   * Drop cached arc lengths and the cached sampled outline used by hit testing, then
+   * bubble up to {@link _owner}. Called automatically by {@link applyTransform} and the
+   * `Path2D` mutators; call it manually after mutating control-point coordinates in place —
+   * the caches cannot observe such mutations.
+   */
+  invalidate() {
+    if (this._invalidating) {
+      return this;
+    }
+    this._invalidating = true;
+    this._invalidateSelf();
+    this._owner?.invalidate();
+    this._invalidating = false;
+    return this;
+  }
+  /** Clears this curve's own caches. Composites also clear their children (see override). */
+  _invalidateSelf() {
+    this._lengths.length = 0;
+    this._adaptiveCache = void 0;
+  }
+  /**
+   * Sampled outline cached for repeated hit tests (read-only — do not mutate the result).
+   * Invalidated by {@link invalidate}.
+   */
+  _getCachedAdaptiveVertices() {
+    return this._adaptiveCache ??= this.getAdaptiveVertices();
+  }
   getPointAt(u, output = new Vector2()) {
     return this.getPoint(this.getUToTMapping(u), output);
   }
@@ -2557,6 +2719,7 @@ class Curve {
         transform.apply(p, p);
       }
     });
+    this.invalidate();
     return this;
   }
   getUnevenVertices(count = 5, output = []) {
@@ -2701,18 +2864,65 @@ class Curve {
     return mid;
   }
   getMinMax(min = Vector2.MAX, max = Vector2.MIN) {
-    const potins = this.getPoints();
-    for (let i = 0, len = potins.length; i < len; i++) {
-      const p = potins[i];
-      min.clampMin(p);
-      max.clampMax(p);
+    const vertices = this.getAdaptiveVertices();
+    let minX = min.x;
+    let minY = min.y;
+    let maxX = max.x;
+    let maxY = max.y;
+    for (let i = 0, len = vertices.length; i < len; i += 2) {
+      const x = vertices[i];
+      const y = vertices[i + 1];
+      if (x < minX)
+        minX = x;
+      if (y < minY)
+        minY = y;
+      if (x > maxX)
+        maxX = x;
+      if (y > maxY)
+        maxY = y;
     }
+    min.set(minX, minY);
+    max.set(maxX, maxY);
     return { min: min.finite(), max: max.finite() };
   }
   getBoundingBox() {
     const { min, max } = this.getMinMax();
     return new BoundingBox(min.x, min.y, max.x - min.x, max.y - min.y);
   }
+  /**
+   * Test whether a point lies inside the area enclosed by this curve.
+   *
+   * The curve is sampled via {@link getAdaptiveVertices} into a single implicitly closed
+   * ring. This is purely geometric (it ignores any `fill`/`stroke` style), mirroring
+   * `CanvasRenderingContext2D.isPointInPath`.
+   *
+   * Composites that hold multiple sub-paths (e.g. {@link Path2D}) override this so holes
+   * are honored — a single `Curve` is always one ring.
+   */
+  isPointInFill(point, options = {}) {
+    return pointInPolygon(point, this._getCachedAdaptiveVertices(), options.fillRule);
+  }
+  /**
+   * Test whether a point lies on this curve's stroke, i.e. within `strokeWidth / 2 + tolerance`
+   * of the sampled outline. The point must be in the same coordinate space as the curve.
+   *
+   * Options: `strokeWidth` (path units, default `1`), `tolerance` (extra hit slack in path
+   * units, default `0` — useful for thin strokes; no coordinate scaling is assumed, so convert
+   * pixel tolerance to path units upstream if your path is normalized), and `closed` (whether
+   * to include the closing edge from the last vertex back to the first).
+   */
+  isPointInStroke(point, options = {}) {
+    const { strokeWidth = 1, tolerance = 0, closed = false } = options;
+    const distance = pointToPolylineDistance(point, this._getCachedAdaptiveVertices(), closed);
+    return distance <= strokeWidth / 2 + tolerance;
+  }
+  /**
+   * Concise PathKit-style fill containment test: `contains(x, y)` is shorthand for
+   * {@link isPointInFill} with a `{ x, y }` point.
+   */
+  contains(x, y, options = {}) {
+    return this.isPointInFill({ x, y }, options);
+  }
   getFillVertices(_options) {
     return this.getAdaptiveVertices();
   }
@@ -2847,6 +3057,64 @@ class RoundCurve extends Curve {
     }
     return output.set(_x, _y);
   }
+  /**
+   * Point on the ellipse at an absolute angle (mirrors {@link getPoint}'s parameterization,
+   * ignoring `_diff`).
+   */
+  _pointAtAngle(angle, output) {
+    let x = this.cx + this.rx * Math.cos(angle);
+    let y = this.cy + this.ry * Math.sin(angle);
+    if (this.rotate !== 0) {
+      const cos = Math.cos(this.rotate);
+      const sin = Math.sin(this.rotate);
+      const tx = x - this.cx;
+      const ty = y - this.cy;
+      x = tx * cos - ty * sin + this.cx;
+      y = tx * sin + ty * cos + this.cy;
+    }
+    return output.set(x, y);
+  }
+  /**
+   * Analytical bounds of the (elliptical) arc: the start/end points plus the per-axis
+   * extrema angles that fall within the swept interval. Matches {@link getPoint}, so it is
+   * exact for `ArcCurve`/`EllipseCurve`. The `_diff` offset (used only by the legacy
+   * `_getAdaptiveVerticesByCircle` path) is intentionally ignored here.
+   */
+  getMinMax(min = Vector2.MAX, max = Vector2.MIN) {
+    const { startAngle, rotate } = this;
+    const delta = this._getDeltaAngle();
+    const cosT = Math.cos(rotate);
+    const sinT = Math.sin(rotate);
+    const p = tempV2;
+    let minX = min.x;
+    let minY = min.y;
+    let maxX = max.x;
+    let maxY = max.y;
+    const consider = (angle) => {
+      this._pointAtAngle(angle, p);
+      if (p.x < minX)
+        minX = p.x;
+      if (p.y < minY)
+        minY = p.y;
+      if (p.x > maxX)
+        maxX = p.x;
+      if (p.y > maxY)
+        maxY = p.y;
+    };
+    consider(startAngle);
+    consider(startAngle + delta);
+    const ax = Math.atan2(-this.ry * sinT, this.rx * cosT);
+    const ay = Math.atan2(this.ry * cosT, this.rx * sinT);
+    const bases = [ax, ax + Math.PI, ay, ay + Math.PI];
+    for (let i = 0; i < 4; i++) {
+      if (angleInSweep(bases[i], startAngle, delta)) {
+        consider(bases[i]);
+      }
+    }
+    min.set(minX, minY);
+    max.set(maxX, maxY);
+    return { min: min.finite(), max: max.finite() };
+  }
   toCommands() {
     const { cx, cy, rx, ry, startAngle, endAngle, clockwise, rotate } = this;
     const startX = cx + rx * Math.cos(startAngle) * Math.cos(rotate) - ry * Math.sin(startAngle) * Math.sin(rotate);
@@ -2897,6 +3165,7 @@ class RoundCurve extends Curve {
     } else {
       transfEllipseNoSkew(this, transform);
     }
+    this.invalidate();
     return this;
   }
   getControlPointRefs() {
@@ -3037,6 +3306,23 @@ class RoundCurve extends Curve {
     return this;
   }
 }
+function angleInSweep(a, start, delta) {
+  const PI_2 = Math.PI * 2;
+  const eps = 1e-9;
+  if (Math.abs(delta) >= PI_2 - eps) {
+    return true;
+  }
+  let off = (a - start) % PI_2;
+  if (delta >= 0) {
+    if (off < -eps)
+      off += PI_2;
+    return off >= -eps && off <= delta + eps;
+  }
+  if (off > eps) {
+    off -= PI_2;
+  }
+  return off <= eps && off >= delta - eps;
+}
 function transfEllipseGeneric(curve, m) {
   const a = curve.rx;
   const b = curve.ry;
@@ -3275,6 +3561,22 @@ class CompositeCurve extends Curve {
     super();
     this.curves = curves;
   }
+  _adaptiveCacheLen = -1;
+  _invalidateSelf() {
+    super._invalidateSelf();
+    this._adaptiveCacheLen = -1;
+    this.curves.forEach((curve) => curve.invalidate());
+  }
+  _getCachedAdaptiveVertices() {
+    if (!this._adaptiveCache || this._adaptiveCacheLen !== this.curves.length) {
+      this.curves.forEach((curve) => {
+        curve._owner = this;
+      });
+      this._adaptiveCache = this.getAdaptiveVertices();
+      this._adaptiveCacheLen = this.curves.length;
+    }
+    return this._adaptiveCache;
+  }
   getFlatCurves() {
     return this.curves.flatMap((curve) => {
       if (curve instanceof CompositeCurve) {
@@ -3320,6 +3622,7 @@ class CompositeCurve extends Curve {
   updateLengths() {
     const lengths = [];
     for (let i = 0, sum = 0, len = this.curves.length; i < len; i++) {
+      this.curves[i]._owner = this;
       sum += this.curves[i].getLength();
       lengths.push(sum);
     }
@@ -3388,7 +3691,10 @@ class CompositeCurve extends Curve {
     }
   }
   applyTransform(transform) {
+    this._invalidating = true;
     this.curves.forEach((curve) => curve.applyTransform(transform));
+    this._invalidating = false;
+    this.invalidate();
     return this;
   }
   getMinMax(min = Vector2.MAX, max = Vector2.MIN) {
@@ -3727,7 +4033,7 @@ class RectangleCurve extends PolygonCurve {
   }
 }
 
-class RoundRectangleCurve extends RoundCurve {
+class RoundRectangleCurve extends CompositeCurve {
   constructor(x = 0, y = 0, width = 1, height = 1, radius = 1) {
     super();
     this.x = x;
@@ -3738,25 +4044,53 @@ class RoundRectangleCurve extends RoundCurve {
     this.update();
   }
   update() {
-    const { x, y, width, height, radius } = this;
-    const halfWidth = width / 2;
-    const halfHeight = height / 2;
-    const cx = x + halfWidth;
-    const cy = y + halfHeight;
-    const rx = Math.max(0, Math.min(radius, Math.min(halfWidth, halfHeight)));
-    const ry = rx;
-    this._center = new Vector2(cx, cy);
-    this._radius = new Vector2(rx, ry);
-    this._diff = new Vector2(halfWidth - rx, halfHeight - ry);
+    const { x, y, width, height } = this;
+    const r = Math.max(0, Math.min(this.radius, Math.abs(width) / 2, Math.abs(height) / 2));
+    const x0 = x;
+    const x1 = x + r;
+    const x2 = x + width - r;
+    const x3 = x + width;
+    const y0 = y;
+    const y1 = y + r;
+    const y2 = y + height - r;
+    const y3 = y + height;
+    if (r <= 0) {
+      this.curves = [
+        LineCurve.from(x0, y0, x3, y0),
+        LineCurve.from(x3, y0, x3, y3),
+        LineCurve.from(x3, y3, x0, y3),
+        LineCurve.from(x0, y3, x0, y0)
+      ];
+    } else {
+      const HALF_PI = Math.PI / 2;
+      this.curves = [
+        LineCurve.from(x1, y0, x2, y0),
+        // top edge
+        new ArcCurve(x2, y1, r, -HALF_PI, 0, true),
+        // top-right corner
+        LineCurve.from(x3, y1, x3, y2),
+        // right edge
+        new ArcCurve(x2, y2, r, 0, HALF_PI, true),
+        // bottom-right corner
+        LineCurve.from(x2, y3, x1, y3),
+        // bottom edge
+        new ArcCurve(x1, y2, r, HALF_PI, Math.PI, true),
+        // bottom-left corner
+        LineCurve.from(x0, y2, x0, y1),
+        // left edge
+        new ArcCurve(x1, y1, r, Math.PI, Math.PI * 1.5, true)
+        // top-left corner
+      ];
+    }
+    this.invalidate();
     return this;
   }
   drawTo(ctx) {
-    const { x, y, width, height, radius } = this;
-    ctx.roundRect(x, y, width, height, radius);
+    ctx.roundRect(this.x, this.y, this.width, this.height, this.radius);
     return this;
   }
   copyFrom(source) {
-    super.copyFrom(source);
+    this.arcLengthDivision = source.arcLengthDivision;
     this.x = source.x;
     this.y = source.y;
     this.width = source.width;
@@ -3852,6 +4186,17 @@ class CurvePath extends CompositeCurve {
       super.getFillVertices(options)
     );
   }
+  /**
+   * Same as {@link Curve.isPointInStroke}, but `closed` defaults to this sub-path's actual
+   * closed-ness: explicitly `autoClose`, or geometrically closed (first vertex === last).
+   */
+  isPointInStroke(point, options = {}) {
+    const { strokeWidth = 1, tolerance = 0 } = options;
+    const vertices = this._getCachedAdaptiveVertices();
+    const len = vertices.length;
+    const closed = options.closed ?? (this.autoClose || len >= 6 && vertices[0] === vertices[len - 2] && vertices[1] === vertices[len - 1]);
+    return pointToPolylineDistance(point, vertices, closed) <= strokeWidth / 2 + tolerance;
+  }
   _setCurrentPoint(point) {
     this.currentPoint = new Vector2(point.x, point.y);
     if (!this.startPoint) {
@@ -4025,6 +4370,8 @@ class CurvePath extends CompositeCurve {
 
 class Path2D extends CompositeCurve {
   _meta;
+  _ringsCache;
+  _ringsCacheLen = -1;
   currentCurve = new CurvePath();
   style;
   get startPoint() {
@@ -4143,18 +4490,21 @@ class Path2D extends CompositeCurve {
     this.getControlPointRefs().forEach((point) => {
       point.scale(sx, sy, target);
     });
+    this.invalidate();
     return this;
   }
   skew(ax, ay = 0, target = { x: 0, y: 0 }) {
     this.getControlPointRefs().forEach((point) => {
       point.skew(ax, ay, target);
     });
+    this.invalidate();
     return this;
   }
   rotate(rad, target = { x: 0, y: 0 }) {
     this.getControlPointRefs().forEach((point) => {
       point.rotate(rad, target);
     });
+    this.invalidate();
     return this;
   }
   bold(b) {
@@ -4213,38 +4563,67 @@ class Path2D extends CompositeCurve {
         }
       });
     });
+    this.invalidate();
     return this;
   }
+  /**
+   * Test whether a point lies inside the filled area of this path.
+   *
+   * Each sub-path ({@link CurvePath}) is sampled into its own ring and all rings are
+   * evaluated together via {@link pointInPolygons}, so holes (donut / hollow shapes) are
+   * honored. This is purely geometric and ignores `style.fill` — for the `fill: 'none'`
+   * fallback, gate the call upstream (see {@link Path2DSet.hitTest}).
+   *
+   * Defaults `fillRule` to `style.fillRule`, then `'nonzero'` (matching SVG/Canvas).
+   */
+  _invalidateSelf() {
+    super._invalidateSelf();
+    this._ringsCache = void 0;
+    this._ringsCacheLen = -1;
+  }
+  /** Per-sub-path sampled rings, cached for repeated hit tests. */
+  _getRings() {
+    if (!this._ringsCache || this._ringsCacheLen !== this.curves.length) {
+      this._ringsCache = this.curves.map((curve) => {
+        curve._owner = this;
+        return curve.getAdaptiveVertices();
+      });
+      this._ringsCacheLen = this.curves.length;
+    }
+    return this._ringsCache;
+  }
+  isPointInFill(point, options = {}) {
+    const fillRule = options.fillRule ?? this.style.fillRule ?? "nonzero";
+    return pointInPolygons(point, this._getRings(), fillRule);
+  }
+  /**
+   * Test whether a point lies on this path's stroke. A hit on any sub-path counts.
+   *
+   * Defaults `strokeWidth` to this path's own {@link strokeWidth} (which is `0` when
+   * `style.stroke` is `'none'`). Each sub-path infers its own closed-ness unless `closed`
+   * is given explicitly.
+   */
+  isPointInStroke(point, options = {}) {
+    const strokeWidth = options.strokeWidth ?? this.strokeWidth;
+    const { tolerance = 0, closed } = options;
+    return this.curves.some((curve) => curve.isPointInStroke(point, {
+      strokeWidth,
+      tolerance,
+      closed
+    }));
+  }
   getMinMax(min = Vector2.MAX, max = Vector2.MIN, withStyle = true) {
-    const strokeWidth = this.strokeWidth;
     this.curves.forEach((curve) => {
       curve.getMinMax(min, max);
-      if (withStyle) {
-        if (strokeWidth > 1) {
-          const halfStrokeWidth = strokeWidth / 2;
-          const isClockwise = curve.isClockwise();
-          const points = [];
-          for (let t = 0; t <= 1; t += 1 / curve.arcLengthDivision) {
-            const point = curve.getPoint(t);
-            const normal = curve.getNormal(t);
-            const dist1 = normal.clone().scale(isClockwise ? halfStrokeWidth : -halfStrokeWidth);
-            const dist2 = normal.clone().scale(isClockwise ? -halfStrokeWidth : halfStrokeWidth);
-            points.push(
-              point.clone().add(dist1),
-              point.clone().add(dist2),
-              point.clone().add({ x: halfStrokeWidth, y: 0 }),
-              point.clone().add({ x: -halfStrokeWidth, y: 0 }),
-              point.clone().add({ x: 0, y: halfStrokeWidth }),
-              point.clone().add({ x: 0, y: -halfStrokeWidth }),
-              point.clone().add({ x: halfStrokeWidth, y: halfStrokeWidth }),
-              point.clone().add({ x: -halfStrokeWidth, y: -halfStrokeWidth })
-            );
-          }
-          min.clampMin(...points);
-          max.clampMax(...points);
-        }
-      }
     });
+    if (withStyle) {
+      const strokeWidth = this.strokeWidth;
+      if (strokeWidth > 1 && Number.isFinite(min.x)) {
+        const half = strokeWidth / 2;
+        min.set(min.x - half, min.y - half);
+        max.set(max.x + half, max.y + half);
+      }
+    }
     return { min: min.finite(), max: max.finite() };
   }
   strokeTriangulate(options) {
@@ -4392,6 +4771,44 @@ class Path2DSet {
     this.paths = paths;
     this.viewBox = viewBox;
   }
+  /**
+   * Test whether a point lies inside the filled area of any path in this set.
+   * Purely geometric (ignores `fill: 'none'`); use {@link hitTest} for style-aware hits.
+   */
+  isPointInFill(point, options = {}) {
+    return this.paths.some((path) => path.isPointInFill(point, options));
+  }
+  /**
+   * Concise PathKit-style fill containment test across the whole set; shorthand for
+   * {@link isPointInFill} with a `{ x, y }` point.
+   */
+  contains(x, y, options = {}) {
+    return this.isPointInFill({ x, y }, options);
+  }
+  /**
+   * Find the topmost path hit by a point, or `undefined` if none.
+   *
+   * Paths are tested top-to-bottom (last drawn first). For each path a fill hit is checked
+   * first (skipped when `style.fill` is `'none'`), then — if `stroke` is enabled — a stroke
+   * hit (skipped when `style.stroke` is `'none'`). This honors the "fill: none falls back to
+   * stroke" rule; the coordinate space of `point` must match the paths (no scaling assumed).
+   *
+   * Options: `stroke` (also test strokes, default `true`), `tolerance` (extra stroke hit slack
+   * in path units, default `0`), and `fillRule` (overrides each path's own fill rule).
+   */
+  hitTest(point, options = {}) {
+    const { stroke = true, tolerance, fillRule } = options;
+    for (let i = this.paths.length - 1; i >= 0; i--) {
+      const path = this.paths[i];
+      if ((path.style.fill ?? "#000") !== "none" && path.isPointInFill(point, { fillRule })) {
+        return path;
+      }
+      if (stroke && (path.style.stroke ?? "none") !== "none" && path.isPointInStroke(point, { tolerance })) {
+        return path;
+      }
+    }
+    return void 0;
+  }
   getBoundingBox(withStyle = true) {
     if (!this.paths.length) {
       return void 0;
@@ -4583,6 +5000,10 @@ exports.parseCssArg = parseCssArg;
 exports.parseCssArgs = parseCssArgs;
 exports.parseCssFunctions = parseCssFunctions;
 exports.parsePathDataArgs = parsePathDataArgs;
+exports.pointInPolygon = pointInPolygon;
+exports.pointInPolygons = pointInPolygons;
+exports.pointToPolylineDistance = pointToPolylineDistance;
+exports.pointToSegmentDistance = pointToSegmentDistance;
 exports.quadraticBezier = quadraticBezier;
 exports.setCanvasContext = setCanvasContext;
 exports.strokeTriangulate = strokeTriangulate;