modern-path2d 1.6.0 → 1.7.0

package/dist/index.d.cts

@@ -298,7 +298,12 @@ declare function getDirectedArea(vertices: number[]): number;
 declare const PI: number;
 declare const PI_2: number;
 declare function toKebabCase(str: string): string;
-declare function getIntersectionPoint(p1: Vector2, p2: Vector2, q1: Vector2, q2: Vector2): Vector2;
+/**
+ * Intersection of line p1→p2 with line q1→q2, or `null` when the segments are parallel
+ * (`crossRS === 0`) or the intersection lies too far off p1→p2 (`|t| > 1`). Callers must
+ * handle `null` (e.g. `Path2D.bold` skips the join when there is no usable point).
+ */
+declare function getIntersectionPoint(p1: Vector2, p2: Vector2, q1: Vector2, q2: Vector2): Vector2 | null;
 
 interface NonzeroFillRuleResult {
     index: number;
@@ -308,6 +313,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,10 +377,39 @@ 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[];
+    protected _adaptiveCache?: number[];
+    /**
+     * Parent composite, set lazily when a composite caches its children. Lets
+     * {@link invalidate} propagate up so an ancestor's caches refresh too.
+     */
+    _owner?: Curve;
+    protected _invalidating: boolean;
     abstract getPoint(t: number, output?: Vector2): Vector2;
+    /**
+     * 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(): this;
+    /** Clears this curve's own caches. Composites also clear their children (see override). */
+    protected _invalidateSelf(): void;
+    /**
+     * Sampled outline cached for repeated hit tests (read-only — do not mutate the result).
+     * Invalidated by {@link invalidate}.
+     */
+    protected _getCachedAdaptiveVertices(): number[];
     getPointAt(u: number, output?: Vector2): Vector2;
     isClockwise(): boolean;
     getControlPointRefs(): Vector2[];
@@ -363,6 +436,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;
@@ -397,6 +496,21 @@ declare class RoundCurve extends Curve {
     isClockwise(): boolean;
     protected _getDeltaAngle(): number;
     getPoint(t: number, output?: Vector2): Vector2;
+    /**
+     * Point on the ellipse at an absolute angle (mirrors {@link getPoint}'s parameterization,
+     * ignoring `_diff`).
+     */
+    protected _pointAtAngle(angle: number, output: Vector2): Vector2;
+    /**
+     * 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?: Vector2): {
+        min: Vector2;
+        max: Vector2;
+    };
     toCommands(): Path2DCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
     applyTransform(transform: Transform2D): this;
@@ -414,7 +528,10 @@ declare class ArcCurve extends RoundCurve {
 
 declare class CompositeCurve<T extends Curve = Curve> extends Curve {
     curves: T[];
+    protected _adaptiveCacheLen: number;
     constructor(curves?: T[]);
+    protected _invalidateSelf(): void;
+    protected _getCachedAdaptiveVertices(): number[];
     getFlatCurves(): Curve[];
     addCurve(curve: T): this;
     getPoint(t: number, output?: Vector2): Vector2;
@@ -526,7 +643,12 @@ declare class RectangleCurve extends PolygonCurve {
     copyFrom(source: RectangleCurve): this;
 }
 
-declare class RoundRectangleCurve extends RoundCurve {
+/**
+ * A rounded rectangle, modelled as a real composite of 4 `LineCurve` edges + 4 quarter
+ * `ArcCurve` corners (like {@link RectangleCurve}). `getPoint`/`getLength`/`getMinMax`/
+ * `toCommands` therefore describe the actual rounded outline — not a bare ellipse.
+ */
+declare class RoundRectangleCurve extends CompositeCurve {
     x: number;
     y: number;
     width: number;
@@ -559,6 +681,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;
@@ -590,6 +717,8 @@ declare class CurvePath extends CompositeCurve {
  */
 declare class Path2D<T = any> extends CompositeCurve<CurvePath> {
     protected _meta?: T;
+    protected _ringsCache?: number[][];
+    protected _ringsCacheLen: number;
     currentCurve: CurvePath;
     style: Partial<Path2DStyle>;
     get startPoint(): Vector2 | undefined;
@@ -617,6 +746,28 @@ 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).
+     */
+    protected _invalidateSelf(): void;
+    /** Per-sub-path sampled rings, cached for repeated hit tests. */
+    protected _getRings(): number[][];
+    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 +792,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 +875,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

@@ -298,7 +298,12 @@ declare function getDirectedArea(vertices: number[]): number;
 declare const PI: number;
 declare const PI_2: number;
 declare function toKebabCase(str: string): string;
-declare function getIntersectionPoint(p1: Vector2, p2: Vector2, q1: Vector2, q2: Vector2): Vector2;
+/**
+ * Intersection of line p1→p2 with line q1→q2, or `null` when the segments are parallel
+ * (`crossRS === 0`) or the intersection lies too far off p1→p2 (`|t| > 1`). Callers must
+ * handle `null` (e.g. `Path2D.bold` skips the join when there is no usable point).
+ */
+declare function getIntersectionPoint(p1: Vector2, p2: Vector2, q1: Vector2, q2: Vector2): Vector2 | null;
 
 interface NonzeroFillRuleResult {
     index: number;
@@ -308,6 +313,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,10 +377,39 @@ 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[];
+    protected _adaptiveCache?: number[];
+    /**
+     * Parent composite, set lazily when a composite caches its children. Lets
+     * {@link invalidate} propagate up so an ancestor's caches refresh too.
+     */
+    _owner?: Curve;
+    protected _invalidating: boolean;
     abstract getPoint(t: number, output?: Vector2): Vector2;
+    /**
+     * 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(): this;
+    /** Clears this curve's own caches. Composites also clear their children (see override). */
+    protected _invalidateSelf(): void;
+    /**
+     * Sampled outline cached for repeated hit tests (read-only — do not mutate the result).
+     * Invalidated by {@link invalidate}.
+     */
+    protected _getCachedAdaptiveVertices(): number[];
     getPointAt(u: number, output?: Vector2): Vector2;
     isClockwise(): boolean;
     getControlPointRefs(): Vector2[];
@@ -363,6 +436,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;
@@ -397,6 +496,21 @@ declare class RoundCurve extends Curve {
     isClockwise(): boolean;
     protected _getDeltaAngle(): number;
     getPoint(t: number, output?: Vector2): Vector2;
+    /**
+     * Point on the ellipse at an absolute angle (mirrors {@link getPoint}'s parameterization,
+     * ignoring `_diff`).
+     */
+    protected _pointAtAngle(angle: number, output: Vector2): Vector2;
+    /**
+     * 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?: Vector2): {
+        min: Vector2;
+        max: Vector2;
+    };
     toCommands(): Path2DCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
     applyTransform(transform: Transform2D): this;
@@ -414,7 +528,10 @@ declare class ArcCurve extends RoundCurve {
 
 declare class CompositeCurve<T extends Curve = Curve> extends Curve {
     curves: T[];
+    protected _adaptiveCacheLen: number;
     constructor(curves?: T[]);
+    protected _invalidateSelf(): void;
+    protected _getCachedAdaptiveVertices(): number[];
     getFlatCurves(): Curve[];
     addCurve(curve: T): this;
     getPoint(t: number, output?: Vector2): Vector2;
@@ -526,7 +643,12 @@ declare class RectangleCurve extends PolygonCurve {
     copyFrom(source: RectangleCurve): this;
 }
 
-declare class RoundRectangleCurve extends RoundCurve {
+/**
+ * A rounded rectangle, modelled as a real composite of 4 `LineCurve` edges + 4 quarter
+ * `ArcCurve` corners (like {@link RectangleCurve}). `getPoint`/`getLength`/`getMinMax`/
+ * `toCommands` therefore describe the actual rounded outline — not a bare ellipse.
+ */
+declare class RoundRectangleCurve extends CompositeCurve {
     x: number;
     y: number;
     width: number;
@@ -559,6 +681,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;
@@ -590,6 +717,8 @@ declare class CurvePath extends CompositeCurve {
  */
 declare class Path2D<T = any> extends CompositeCurve<CurvePath> {
     protected _meta?: T;
+    protected _ringsCache?: number[][];
+    protected _ringsCacheLen: number;
     currentCurve: CurvePath;
     style: Partial<Path2DStyle>;
     get startPoint(): Vector2 | undefined;
@@ -617,6 +746,28 @@ 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).
+     */
+    protected _invalidateSelf(): void;
+    /** Per-sub-path sampled rings, cached for repeated hit tests. */
+    protected _getRings(): number[][];
+    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 +792,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 +875,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 };