modern-path2d 1.6.0 → 1.6.1

package/dist/index.cjs

@@ -598,7 +598,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) {
@@ -703,7 +703,7 @@ function nonzeroFillRule(paths) {
       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 +726,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;
@@ -2713,6 +2827,40 @@ class Curve {
     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.getAdaptiveVertices(), 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.getAdaptiveVertices(), 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();
   }
@@ -3852,6 +4000,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.getAdaptiveVertices();
+    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) {
@@ -4215,6 +4374,40 @@ class Path2D extends CompositeCurve {
     });
     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).
+   */
+  isPointInFill(point, options = {}) {
+    const fillRule = options.fillRule ?? this.style.fillRule ?? "nonzero";
+    return pointInPolygons(
+      point,
+      this.curves.map((curve) => curve.getAdaptiveVertices()),
+      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) => {
@@ -4392,6 +4585,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 +4814,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;

package/dist/index.d.cts

@@ -308,6 +308,45 @@ interface NonzeroFillRuleResult {
 }
 declare function nonzeroFillRule(paths: number[][]): NonzeroFillRuleResult[];
 
+/**
+ * Test whether a point lies inside a single polygon ring.
+ *
+ * `vertices` is a flat `[x0, y0, x1, y1, ...]` array and is treated as implicitly closed
+ * (the last vertex connects back to the first). A ring with fewer than 3 points has no
+ * area and always returns `false`.
+ *
+ * @param point The point to test.
+ * @param vertices Flat vertex array of the ring.
+ * @param fillRule `'nonzero'` (default, matches SVG/Canvas) or `'evenodd'`.
+ */
+declare function pointInPolygon(point: Vector2Like, vertices: number[], fillRule?: FillRule): boolean;
+/**
+ * Test whether a point lies inside a shape composed of multiple rings (sub-paths).
+ *
+ * This is the multi-ring counterpart of {@link pointInPolygon} and is what donut /
+ * hollow shapes need: every ring is evaluated together so holes are honored.
+ * - `'nonzero'`: sum the signed winding numbers of all rings, inside if the total ≠ 0.
+ * - `'evenodd'`: sum the ray-crossing counts of all rings, inside if the total is odd.
+ *
+ * @param point The point to test.
+ * @param polygons Array of flat vertex arrays, one per ring.
+ * @param fillRule `'nonzero'` (default) or `'evenodd'`.
+ */
+declare function pointInPolygons(point: Vector2Like, polygons: number[][], fillRule?: FillRule): boolean;
+/**
+ * Shortest distance from a point to a single line segment a→b.
+ */
+declare function pointToSegmentDistance(point: Vector2Like, a: Vector2Like, b: Vector2Like): number;
+/**
+ * Shortest distance from a point to a polyline.
+ *
+ * @param point The point to test.
+ * @param vertices Flat `[x0, y0, x1, y1, ...]` array of the polyline.
+ * @param closed When `true`, also considers the closing edge from the last vertex back
+ *   to the first (use for closed paths, e.g. `z`/`Z` or `CurvePath.autoClose`).
+ */
+declare function pointToPolylineDistance(point: Vector2Like, vertices: number[], closed?: boolean): number;
+
 declare function quadraticBezier(t: number, p0: number, p1: number, p2: number): number;
 
 type LineCap = 'butt' | 'round' | 'square';
@@ -333,6 +372,14 @@ interface LineStyle {
 }
 declare function strokeTriangulate(points: number[], options?: StrokeTriangulateOptions): StrokeTriangulatedResult;
 
+interface IsPointInFillOptions {
+    fillRule?: FillRule;
+}
+interface IsPointInStrokeOptions {
+    strokeWidth?: number;
+    tolerance?: number;
+    closed?: boolean;
+}
 declare abstract class Curve {
     arcLengthDivision: number;
     protected _lengths: number[];
@@ -363,6 +410,32 @@ declare abstract class Curve {
         max: Vector2;
     };
     getBoundingBox(): BoundingBox;
+    /**
+     * 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: Vector2Like, options?: IsPointInFillOptions): boolean;
+    /**
+     * 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: Vector2Like, options?: IsPointInStrokeOptions): boolean;
+    /**
+     * Concise PathKit-style fill containment test: `contains(x, y)` is shorthand for
+     * {@link isPointInFill} with a `{ x, y }` point.
+     */
+    contains(x: number, y: number, options?: IsPointInFillOptions): boolean;
     getFillVertices(_options?: FillTriangulateOptions): number[];
     fillTriangulate(options?: FillTriangulateOptions): FillTriangulatedResult;
     strokeTriangulate(options?: StrokeTriangulateOptions): StrokeTriangulatedResult;
@@ -559,6 +632,11 @@ declare class CurvePath extends CompositeCurve {
     getSpacedVertices(count?: number, output?: number[]): number[];
     getAdaptiveVertices(output?: number[]): number[];
     getFillVertices(options?: FillTriangulateOptions): number[];
+    /**
+     * 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: Vector2Like, options?: IsPointInStrokeOptions): boolean;
     protected _setCurrentPoint(point: Vector2Like): this;
     protected _connetLineTo(curve: Curve): this;
     closePath(): this;
@@ -617,6 +695,25 @@ declare class Path2D<T = any> extends CompositeCurve<CurvePath> {
     skew(ax: number, ay?: number, target?: Vector2Like): this;
     rotate(rad: number, target?: Vector2Like): this;
     bold(b: number): 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).
+     */
+    isPointInFill(point: Vector2Like, options?: IsPointInFillOptions): boolean;
+    /**
+     * 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: Vector2Like, options?: IsPointInStrokeOptions): boolean;
     getMinMax(min?: Vector2, max?: Vector2, withStyle?: boolean): {
         min: Vector2;
         max: Vector2;
@@ -641,6 +738,36 @@ declare class Path2DSet<T = any> {
     paths: Path2D<T>[];
     viewBox?: number[] | undefined;
     constructor(paths?: Path2D<T>[], viewBox?: number[] | undefined);
+    /**
+     * 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: Vector2Like, options?: {
+        fillRule?: FillRule;
+    }): boolean;
+    /**
+     * Concise PathKit-style fill containment test across the whole set; shorthand for
+     * {@link isPointInFill} with a `{ x, y }` point.
+     */
+    contains(x: number, y: number, options?: {
+        fillRule?: FillRule;
+    }): boolean;
+    /**
+     * 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: Vector2Like, options?: {
+        stroke?: boolean;
+        tolerance?: number;
+        fillRule?: FillRule;
+    }): Path2D<T> | undefined;
     getBoundingBox(withStyle?: boolean): BoundingBox | undefined;
     toTriangulatedSvgString(result?: TriangulatedResult | TriangulatedResult[], padding?: number): string;
     toTriangulatedSvg(result?: TriangulatedResult | TriangulatedResult[], padding?: number): SVGElement;
@@ -694,5 +821,5 @@ declare function svgToDom(svg: string | SVGElement): SVGElement;
 
 declare function svgToPath2DSet(svg: string | SVGElement): Path2DSet;
 
-export { ArcCurve, BoundingBox, CompositeCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, EquilateralPolygonCurve, FFDControlGrid, LineCurve, PI, PI_2, Path2D, Path2DSet, PolygonCurve, QuadraticBezierCurve, RectangleCurve, RoundRectangleCurve, SplineCurve, Transform2D, Vector2, applyFFD, catmullRom, cubicBezier, drawPoint, fillTriangulate, getAdaptiveCubicBezierCurvePoints, getAdaptiveQuadraticBezierCurvePoints, getDirectedArea, getIntersectionPoint, nonzeroFillRule, parseArcCommand, parseCssArg, parseCssArgs, parseCssFunctions, parsePathDataArgs, quadraticBezier, setCanvasContext, strokeTriangulate, svgPathCommandsAddToPath2D, svgPathCommandsToData, svgPathDataToCommands, svgToDom, svgToPath2DSet, toKebabCase };
-export type { CssFunction, CssFunctionArg, DrawPointOptions, FillRule, FillTriangulateOptions, FillTriangulatedResult, LineCap, LineJoin, LineStyle, ParseCssFunctionContext, Path2DCommand, Path2DData, Path2DDrawStyle, Path2DStyle, StrokeLinecap, StrokeLinejoin, StrokeTriangulateOptions, StrokeTriangulatedResult, TransformableObject, TriangulatedResult, Vector2Like };
+export { ArcCurve, BoundingBox, CompositeCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, EquilateralPolygonCurve, FFDControlGrid, LineCurve, PI, PI_2, Path2D, Path2DSet, PolygonCurve, QuadraticBezierCurve, RectangleCurve, RoundRectangleCurve, SplineCurve, Transform2D, Vector2, applyFFD, catmullRom, cubicBezier, drawPoint, fillTriangulate, getAdaptiveCubicBezierCurvePoints, getAdaptiveQuadraticBezierCurvePoints, getDirectedArea, getIntersectionPoint, nonzeroFillRule, parseArcCommand, parseCssArg, parseCssArgs, parseCssFunctions, parsePathDataArgs, pointInPolygon, pointInPolygons, pointToPolylineDistance, pointToSegmentDistance, quadraticBezier, setCanvasContext, strokeTriangulate, svgPathCommandsAddToPath2D, svgPathCommandsToData, svgPathDataToCommands, svgToDom, svgToPath2DSet, toKebabCase };
+export type { CssFunction, CssFunctionArg, DrawPointOptions, FillRule, FillTriangulateOptions, FillTriangulatedResult, IsPointInFillOptions, IsPointInStrokeOptions, LineCap, LineJoin, LineStyle, ParseCssFunctionContext, Path2DCommand, Path2DData, Path2DDrawStyle, Path2DStyle, StrokeLinecap, StrokeLinejoin, StrokeTriangulateOptions, StrokeTriangulatedResult, TransformableObject, TriangulatedResult, Vector2Like };

package/dist/index.d.mts

@@ -308,6 +308,45 @@ interface NonzeroFillRuleResult {
 }
 declare function nonzeroFillRule(paths: number[][]): NonzeroFillRuleResult[];
 
+/**
+ * Test whether a point lies inside a single polygon ring.
+ *
+ * `vertices` is a flat `[x0, y0, x1, y1, ...]` array and is treated as implicitly closed
+ * (the last vertex connects back to the first). A ring with fewer than 3 points has no
+ * area and always returns `false`.
+ *
+ * @param point The point to test.
+ * @param vertices Flat vertex array of the ring.
+ * @param fillRule `'nonzero'` (default, matches SVG/Canvas) or `'evenodd'`.
+ */
+declare function pointInPolygon(point: Vector2Like, vertices: number[], fillRule?: FillRule): boolean;
+/**
+ * Test whether a point lies inside a shape composed of multiple rings (sub-paths).
+ *
+ * This is the multi-ring counterpart of {@link pointInPolygon} and is what donut /
+ * hollow shapes need: every ring is evaluated together so holes are honored.
+ * - `'nonzero'`: sum the signed winding numbers of all rings, inside if the total ≠ 0.
+ * - `'evenodd'`: sum the ray-crossing counts of all rings, inside if the total is odd.
+ *
+ * @param point The point to test.
+ * @param polygons Array of flat vertex arrays, one per ring.
+ * @param fillRule `'nonzero'` (default) or `'evenodd'`.
+ */
+declare function pointInPolygons(point: Vector2Like, polygons: number[][], fillRule?: FillRule): boolean;
+/**
+ * Shortest distance from a point to a single line segment a→b.
+ */
+declare function pointToSegmentDistance(point: Vector2Like, a: Vector2Like, b: Vector2Like): number;
+/**
+ * Shortest distance from a point to a polyline.
+ *
+ * @param point The point to test.
+ * @param vertices Flat `[x0, y0, x1, y1, ...]` array of the polyline.
+ * @param closed When `true`, also considers the closing edge from the last vertex back
+ *   to the first (use for closed paths, e.g. `z`/`Z` or `CurvePath.autoClose`).
+ */
+declare function pointToPolylineDistance(point: Vector2Like, vertices: number[], closed?: boolean): number;
+
 declare function quadraticBezier(t: number, p0: number, p1: number, p2: number): number;
 
 type LineCap = 'butt' | 'round' | 'square';
@@ -333,6 +372,14 @@ interface LineStyle {
 }
 declare function strokeTriangulate(points: number[], options?: StrokeTriangulateOptions): StrokeTriangulatedResult;
 
+interface IsPointInFillOptions {
+    fillRule?: FillRule;
+}
+interface IsPointInStrokeOptions {
+    strokeWidth?: number;
+    tolerance?: number;
+    closed?: boolean;
+}
 declare abstract class Curve {
     arcLengthDivision: number;
     protected _lengths: number[];
@@ -363,6 +410,32 @@ declare abstract class Curve {
         max: Vector2;
     };
     getBoundingBox(): BoundingBox;
+    /**
+     * 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: Vector2Like, options?: IsPointInFillOptions): boolean;
+    /**
+     * 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: Vector2Like, options?: IsPointInStrokeOptions): boolean;
+    /**
+     * Concise PathKit-style fill containment test: `contains(x, y)` is shorthand for
+     * {@link isPointInFill} with a `{ x, y }` point.
+     */
+    contains(x: number, y: number, options?: IsPointInFillOptions): boolean;
     getFillVertices(_options?: FillTriangulateOptions): number[];
     fillTriangulate(options?: FillTriangulateOptions): FillTriangulatedResult;
     strokeTriangulate(options?: StrokeTriangulateOptions): StrokeTriangulatedResult;
@@ -559,6 +632,11 @@ declare class CurvePath extends CompositeCurve {
     getSpacedVertices(count?: number, output?: number[]): number[];
     getAdaptiveVertices(output?: number[]): number[];
     getFillVertices(options?: FillTriangulateOptions): number[];
+    /**
+     * 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: Vector2Like, options?: IsPointInStrokeOptions): boolean;
     protected _setCurrentPoint(point: Vector2Like): this;
     protected _connetLineTo(curve: Curve): this;
     closePath(): this;
@@ -617,6 +695,25 @@ declare class Path2D<T = any> extends CompositeCurve<CurvePath> {
     skew(ax: number, ay?: number, target?: Vector2Like): this;
     rotate(rad: number, target?: Vector2Like): this;
     bold(b: number): 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).
+     */
+    isPointInFill(point: Vector2Like, options?: IsPointInFillOptions): boolean;
+    /**
+     * 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: Vector2Like, options?: IsPointInStrokeOptions): boolean;
     getMinMax(min?: Vector2, max?: Vector2, withStyle?: boolean): {
         min: Vector2;
         max: Vector2;
@@ -641,6 +738,36 @@ declare class Path2DSet<T = any> {
     paths: Path2D<T>[];
     viewBox?: number[] | undefined;
     constructor(paths?: Path2D<T>[], viewBox?: number[] | undefined);
+    /**
+     * 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: Vector2Like, options?: {
+        fillRule?: FillRule;
+    }): boolean;
+    /**
+     * Concise PathKit-style fill containment test across the whole set; shorthand for
+     * {@link isPointInFill} with a `{ x, y }` point.
+     */
+    contains(x: number, y: number, options?: {
+        fillRule?: FillRule;
+    }): boolean;
+    /**
+     * 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: Vector2Like, options?: {
+        stroke?: boolean;
+        tolerance?: number;
+        fillRule?: FillRule;
+    }): Path2D<T> | undefined;
     getBoundingBox(withStyle?: boolean): BoundingBox | undefined;
     toTriangulatedSvgString(result?: TriangulatedResult | TriangulatedResult[], padding?: number): string;
     toTriangulatedSvg(result?: TriangulatedResult | TriangulatedResult[], padding?: number): SVGElement;
@@ -694,5 +821,5 @@ declare function svgToDom(svg: string | SVGElement): SVGElement;
 
 declare function svgToPath2DSet(svg: string | SVGElement): Path2DSet;
 
-export { ArcCurve, BoundingBox, CompositeCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, EquilateralPolygonCurve, FFDControlGrid, LineCurve, PI, PI_2, Path2D, Path2DSet, PolygonCurve, QuadraticBezierCurve, RectangleCurve, RoundRectangleCurve, SplineCurve, Transform2D, Vector2, applyFFD, catmullRom, cubicBezier, drawPoint, fillTriangulate, getAdaptiveCubicBezierCurvePoints, getAdaptiveQuadraticBezierCurvePoints, getDirectedArea, getIntersectionPoint, nonzeroFillRule, parseArcCommand, parseCssArg, parseCssArgs, parseCssFunctions, parsePathDataArgs, quadraticBezier, setCanvasContext, strokeTriangulate, svgPathCommandsAddToPath2D, svgPathCommandsToData, svgPathDataToCommands, svgToDom, svgToPath2DSet, toKebabCase };
-export type { CssFunction, CssFunctionArg, DrawPointOptions, FillRule, FillTriangulateOptions, FillTriangulatedResult, LineCap, LineJoin, LineStyle, ParseCssFunctionContext, Path2DCommand, Path2DData, Path2DDrawStyle, Path2DStyle, StrokeLinecap, StrokeLinejoin, StrokeTriangulateOptions, StrokeTriangulatedResult, TransformableObject, TriangulatedResult, Vector2Like };
+export { ArcCurve, BoundingBox, CompositeCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, EquilateralPolygonCurve, FFDControlGrid, LineCurve, PI, PI_2, Path2D, Path2DSet, PolygonCurve, QuadraticBezierCurve, RectangleCurve, RoundRectangleCurve, SplineCurve, Transform2D, Vector2, applyFFD, catmullRom, cubicBezier, drawPoint, fillTriangulate, getAdaptiveCubicBezierCurvePoints, getAdaptiveQuadraticBezierCurvePoints, getDirectedArea, getIntersectionPoint, nonzeroFillRule, parseArcCommand, parseCssArg, parseCssArgs, parseCssFunctions, parsePathDataArgs, pointInPolygon, pointInPolygons, pointToPolylineDistance, pointToSegmentDistance, quadraticBezier, setCanvasContext, strokeTriangulate, svgPathCommandsAddToPath2D, svgPathCommandsToData, svgPathDataToCommands, svgToDom, svgToPath2DSet, toKebabCase };
+export type { CssFunction, CssFunctionArg, DrawPointOptions, FillRule, FillTriangulateOptions, FillTriangulatedResult, IsPointInFillOptions, IsPointInStrokeOptions, LineCap, LineJoin, LineStyle, ParseCssFunctionContext, Path2DCommand, Path2DData, Path2DDrawStyle, Path2DStyle, StrokeLinecap, StrokeLinejoin, StrokeTriangulateOptions, StrokeTriangulatedResult, TransformableObject, TriangulatedResult, Vector2Like };