modern-path2d 1.7.0 → 1.8.0

package/dist/index.d.cts

@@ -249,6 +249,20 @@ declare class Transform2D {
     destroy(): void;
 }
 
+type BooleanOp = 'union' | 'intersection' | 'difference' | 'xor';
+/**
+ * A flat ring: `[x0, y0, x1, y1, …]` (the same layout {@link Curve.getAdaptiveVertices} produces).
+ * A path is described as an array of such rings (one per sub-path).
+ */
+type FlatRing = number[];
+/**
+ * Boolean operation between two ring soups, returning the result as flat rings (shells wound
+ * counter-clockwise, holes clockwise — so a nonzero fill renders them correctly). Powered by the
+ * Martinez–Rueda sweep-line clipper (`polygon-clipping`); because the inputs are sampled outlines,
+ * the result is a polygonal approximation of curved paths.
+ */
+declare function polygonBoolean(op: BooleanOp, ringsA: FlatRing[], ringsB: FlatRing[]): FlatRing[];
+
 declare function catmullRom(t: number, p0: number, p1: number, p2: number, p3: number): number;
 
 interface CssFunctionArg {
@@ -375,6 +389,12 @@ interface LineStyle {
     cap: LineCap;
     miterLimit: number;
 }
+/**
+ * Derive a triangulator {@link LineStyle} from a (partial) {@link Path2DStyle}. This is what
+ * makes `path.strokeTriangulate()` honor `style.strokeWidth` / `strokeLinejoin` / `strokeLinecap`
+ * / `strokeMiterlimit` instead of silently falling back to a 1px miter hairline.
+ */
+declare function resolveLineStyle(style?: Partial<Path2DStyle>): LineStyle;
 declare function strokeTriangulate(points: number[], options?: StrokeTriangulateOptions): StrokeTriangulatedResult;
 
 interface IsPointInFillOptions {
@@ -413,6 +433,13 @@ declare abstract class Curve {
     getPointAt(u: number, output?: Vector2): Vector2;
     isClockwise(): boolean;
     getControlPointRefs(): Vector2[];
+    /**
+     * Reverse the traversal direction in place (start ↔ end, same geometry). The base
+     * implementation reverses the order of the control-point *values*, which is correct for
+     * line / Bézier / spline primitives whose {@link getControlPointRefs} order matches their
+     * parametric order. {@link RoundCurve} (angle-based) and composites (child order) override it.
+     */
+    reverse(): this;
     applyTransform(transform: Transform2D | ((point: Vector2) => void)): this;
     getUnevenVertices(count?: number, output?: number[]): number[];
     getSpacedVertices(count?: number, output?: number[]): number[];
@@ -428,6 +455,16 @@ declare abstract class Curve {
     getUToTMapping(u: number, distance?: number): number;
     getTangent(t: number, output?: Vector2): Vector2;
     getTangentAt(u: number, output?: Vector2): Vector2;
+    /**
+     * PathKit-style sample at an absolute arc-length `distance` along the curve: the point, the unit
+     * tangent, and the tangent `angle` in radians. `distance` is clamped to `[0, getLength()]`, so
+     * passing `0`/`getLength()` always yields the endpoints. See {@link PathMeasure} for a wrapper.
+     */
+    getPosTan(distance: number): {
+        position: Vector2;
+        tangent: Vector2;
+        angle: number;
+    };
     getNormal(t: number, output?: Vector2): Vector2;
     getNormalAt(u: number, output?: Vector2): Vector2;
     getTForPoint(target: Vector2Like, epsilon?: number): number;
@@ -464,6 +501,13 @@ declare abstract class Curve {
     contains(x: number, y: number, options?: IsPointInFillOptions): boolean;
     getFillVertices(_options?: FillTriangulateOptions): number[];
     fillTriangulate(options?: FillTriangulateOptions): FillTriangulatedResult;
+    /**
+     * Whether this curve forms a closed loop (its outline should be stroked without end caps,
+     * stitching the last vertex back to the first). The base test is purely geometric — the first
+     * sampled vertex coincides with the last. Curves that close without a duplicated endpoint
+     * (a full-revolution {@link RoundCurve}, rectangles, polygons) override this.
+     */
+    isClosed(): boolean;
     strokeTriangulate(options?: StrokeTriangulateOptions): StrokeTriangulatedResult;
     toCommands(): Path2DCommand[];
     toData(): Path2DData;
@@ -494,6 +538,13 @@ declare class RoundCurve extends Curve {
     set dy(val: number);
     constructor(_center?: Vector2, _radius?: Vector2, _diff?: Vector2, rotate?: number, startAngle?: number, endAngle?: number, clockwise?: boolean);
     isClockwise(): boolean;
+    /**
+     * A circle/ellipse arc is closed when it sweeps (at least) a full revolution — the sampled
+     * outline does not duplicate the start vertex, so the geometric first==last test in the base
+     * class would wrongly report a full circle as open and leave a seam gap in the stroke.
+     */
+    isClosed(): boolean;
+    reverse(): this;
     protected _getDeltaAngle(): number;
     getPoint(t: number, output?: Vector2): Vector2;
     /**
@@ -541,7 +592,14 @@ declare class CompositeCurve<T extends Curve = Curve> extends Curve {
     protected _removeNextPointIfEqualPrevPoint(output: number[], offset: number): number[];
     getSpacedVertices(count?: number, output?: number[]): number[];
     getAdaptiveVertices(output?: number[]): number[];
+    /**
+     * A composite is closed when its single child is closed (e.g. a lone full-circle arc), or when
+     * its assembled outline returns to its start (rectangles, polygons, multi-segment loops).
+     */
+    isClosed(): boolean;
     strokeTriangulate(options?: StrokeTriangulateOptions): StrokeTriangulatedResult;
+    /** Reverse the sub-curve order and reverse each sub-curve, so the whole outline runs backwards. */
+    reverse(): this;
     getFillVertices(options?: FillTriangulateOptions): number[];
     applyTransform(transform: Transform2D | ((point: Vector2) => void)): this;
     getMinMax(min?: Vector2, max?: Vector2): {
@@ -564,6 +622,7 @@ declare class CubicBezierCurve extends Curve {
     getPoint(t: number, output?: Vector2): Vector2;
     getAdaptiveVertices(output?: number[]): number[];
     getControlPointRefs(): Vector2[];
+    reverse(): this;
     protected _solveQuadratic(a: number, b: number, c: number): number[];
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
@@ -589,6 +648,7 @@ declare class LineCurve extends Curve {
     getTangent(_t: number, output?: Vector2): Vector2;
     getTangentAt(u: number, output?: Vector2): Vector2;
     getControlPointRefs(): Vector2[];
+    reverse(): this;
     getAdaptiveVertices(output?: number[]): number[];
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
@@ -621,6 +681,7 @@ declare class QuadraticBezierCurve extends Curve {
     constructor(p1?: Vector2, cp?: Vector2, p2?: Vector2);
     getPoint(t: number, output?: Vector2): Vector2;
     getControlPointRefs(): Vector2[];
+    reverse(): this;
     getAdaptiveVertices(output?: number[]): number[];
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
@@ -665,6 +726,7 @@ declare class SplineCurve extends Curve {
     constructor(points?: Vector2[]);
     getPoint(t: number, output?: Vector2): Vector2;
     getControlPointRefs(): Vector2[];
+    reverse(): this;
     copyFrom(source: SplineCurve): this;
 }
 
@@ -676,6 +738,13 @@ declare class CurvePath extends CompositeCurve {
     addPoints(points: Vector2[]): this;
     addCommands(commands: Path2DCommand[]): this;
     addData(data: string): this;
+    /**
+     * A sub-path is closed if it was explicitly closed (`autoClose`, i.e. a `Z`/`closePath`), or if
+     * it forms a geometric loop / wraps a single closed primitive (handled by the base class).
+     */
+    isClosed(): boolean;
+    /** Reverse direction, then refresh the {@link startPoint}/{@link currentPoint} cursors. */
+    reverse(): this;
     protected _closeVertices(output: number[]): number[];
     getUnevenVertices(count?: number, output?: number[]): number[];
     getSpacedVertices(count?: number, output?: number[]): number[];
@@ -760,6 +829,23 @@ declare class Path2D<T = any> extends CompositeCurve<CurvePath> {
     /** Per-sub-path sampled rings, cached for repeated hit tests. */
     protected _getRings(): number[][];
     isPointInFill(point: Vector2Like, options?: IsPointInFillOptions): boolean;
+    /** Build a `Path2D` from flat rings (`[x0,y0,…]` per sub-path); closed-and-filled as sub-paths. */
+    static fromRings(rings: number[][], style?: Partial<Path2DStyle>): Path2D;
+    /**
+     * Boolean (path) operation against another path, returning a NEW `Path2D` whose outline is the
+     * polygonal result. Curves are sampled before clipping, so the result is a polygonal
+     * approximation (see {@link polygonBoolean}). The result inherits this path's `style` unless
+     * overridden via `style`. Holes are emitted as oppositely-wound sub-paths (nonzero fill).
+     */
+    booleanOp(op: BooleanOp, other: Path2D, style?: Partial<Path2DStyle>): Path2D;
+    /** `this ∪ other` — the combined filled area. */
+    union(other: Path2D, style?: Partial<Path2DStyle>): Path2D;
+    /** `this ∩ other` — only the overlapping area. */
+    intersection(other: Path2D, style?: Partial<Path2DStyle>): Path2D;
+    /** `this − other` — this path with `other` cut away. */
+    difference(other: Path2D, style?: Partial<Path2DStyle>): Path2D;
+    /** `this ⊕ other` — areas covered by exactly one of the two paths. */
+    xor(other: Path2D, style?: Partial<Path2DStyle>): Path2D;
     /**
      * Test whether a point lies on this path's stroke. A hit on any sub-path counts.
      *
@@ -833,6 +919,40 @@ declare class Path2DSet<T = any> {
     }>): HTMLCanvasElement;
 }
 
+interface PosTan {
+    position: Vector2;
+    tangent: Vector2;
+    angle: number;
+}
+/**
+ * PathKit/Skia-style arc-length measurement over any {@link Curve} (including `CurvePath` and
+ * `Path2D`). Wraps the curve's existing arc-length cache, so repeated queries are cheap.
+ *
+ * ```ts
+ * const measure = new PathMeasure(path)
+ * const { position, angle } = measure.getPosTan(measure.getLength() * progress)
+ * ```
+ */
+declare class PathMeasure {
+    curve: Curve;
+    constructor(curve: Curve);
+    /** Total arc length of the path. */
+    getLength(): number;
+    /** Whether the path forms a closed loop (see {@link Curve.isClosed}). */
+    isClosed(): boolean;
+    /** Point + unit tangent + tangent angle at an absolute arc-length `distance` (clamped). */
+    getPosTan(distance: number): PosTan;
+    /** Point at an absolute arc-length `distance` (clamped to `[0, getLength()]`). */
+    getPosition(distance: number): Vector2;
+    /** Point + tangent at a normalized progress `t ∈ [0, 1]` along the path. */
+    getPosTanAtProgress(t: number): PosTan;
+    /**
+     * Evenly sample the path into `count + 1` {@link PosTan} entries (arc-length spaced), e.g. to
+     * lay glyphs along a path or drive an `animate(progress)`-style traversal.
+     */
+    sample(count?: number): PosTan[];
+}
+
 declare class FFDControlGrid {
     rows: number;
     cols: number;
@@ -875,5 +995,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, 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 };
+export { ArcCurve, BoundingBox, CompositeCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, EquilateralPolygonCurve, FFDControlGrid, LineCurve, PI, PI_2, Path2D, Path2DSet, PathMeasure, 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, polygonBoolean, quadraticBezier, resolveLineStyle, setCanvasContext, strokeTriangulate, svgPathCommandsAddToPath2D, svgPathCommandsToData, svgPathDataToCommands, svgToDom, svgToPath2DSet, toKebabCase };
+export type { BooleanOp, CssFunction, CssFunctionArg, DrawPointOptions, FillRule, FillTriangulateOptions, FillTriangulatedResult, FlatRing, IsPointInFillOptions, IsPointInStrokeOptions, LineCap, LineJoin, LineStyle, ParseCssFunctionContext, Path2DCommand, Path2DData, Path2DDrawStyle, Path2DStyle, PosTan, StrokeLinecap, StrokeLinejoin, StrokeTriangulateOptions, StrokeTriangulatedResult, TransformableObject, TriangulatedResult, Vector2Like };

package/dist/index.d.mts

@@ -249,6 +249,20 @@ declare class Transform2D {
     destroy(): void;
 }
 
+type BooleanOp = 'union' | 'intersection' | 'difference' | 'xor';
+/**
+ * A flat ring: `[x0, y0, x1, y1, …]` (the same layout {@link Curve.getAdaptiveVertices} produces).
+ * A path is described as an array of such rings (one per sub-path).
+ */
+type FlatRing = number[];
+/**
+ * Boolean operation between two ring soups, returning the result as flat rings (shells wound
+ * counter-clockwise, holes clockwise — so a nonzero fill renders them correctly). Powered by the
+ * Martinez–Rueda sweep-line clipper (`polygon-clipping`); because the inputs are sampled outlines,
+ * the result is a polygonal approximation of curved paths.
+ */
+declare function polygonBoolean(op: BooleanOp, ringsA: FlatRing[], ringsB: FlatRing[]): FlatRing[];
+
 declare function catmullRom(t: number, p0: number, p1: number, p2: number, p3: number): number;
 
 interface CssFunctionArg {
@@ -375,6 +389,12 @@ interface LineStyle {
     cap: LineCap;
     miterLimit: number;
 }
+/**
+ * Derive a triangulator {@link LineStyle} from a (partial) {@link Path2DStyle}. This is what
+ * makes `path.strokeTriangulate()` honor `style.strokeWidth` / `strokeLinejoin` / `strokeLinecap`
+ * / `strokeMiterlimit` instead of silently falling back to a 1px miter hairline.
+ */
+declare function resolveLineStyle(style?: Partial<Path2DStyle>): LineStyle;
 declare function strokeTriangulate(points: number[], options?: StrokeTriangulateOptions): StrokeTriangulatedResult;
 
 interface IsPointInFillOptions {
@@ -413,6 +433,13 @@ declare abstract class Curve {
     getPointAt(u: number, output?: Vector2): Vector2;
     isClockwise(): boolean;
     getControlPointRefs(): Vector2[];
+    /**
+     * Reverse the traversal direction in place (start ↔ end, same geometry). The base
+     * implementation reverses the order of the control-point *values*, which is correct for
+     * line / Bézier / spline primitives whose {@link getControlPointRefs} order matches their
+     * parametric order. {@link RoundCurve} (angle-based) and composites (child order) override it.
+     */
+    reverse(): this;
     applyTransform(transform: Transform2D | ((point: Vector2) => void)): this;
     getUnevenVertices(count?: number, output?: number[]): number[];
     getSpacedVertices(count?: number, output?: number[]): number[];
@@ -428,6 +455,16 @@ declare abstract class Curve {
     getUToTMapping(u: number, distance?: number): number;
     getTangent(t: number, output?: Vector2): Vector2;
     getTangentAt(u: number, output?: Vector2): Vector2;
+    /**
+     * PathKit-style sample at an absolute arc-length `distance` along the curve: the point, the unit
+     * tangent, and the tangent `angle` in radians. `distance` is clamped to `[0, getLength()]`, so
+     * passing `0`/`getLength()` always yields the endpoints. See {@link PathMeasure} for a wrapper.
+     */
+    getPosTan(distance: number): {
+        position: Vector2;
+        tangent: Vector2;
+        angle: number;
+    };
     getNormal(t: number, output?: Vector2): Vector2;
     getNormalAt(u: number, output?: Vector2): Vector2;
     getTForPoint(target: Vector2Like, epsilon?: number): number;
@@ -464,6 +501,13 @@ declare abstract class Curve {
     contains(x: number, y: number, options?: IsPointInFillOptions): boolean;
     getFillVertices(_options?: FillTriangulateOptions): number[];
     fillTriangulate(options?: FillTriangulateOptions): FillTriangulatedResult;
+    /**
+     * Whether this curve forms a closed loop (its outline should be stroked without end caps,
+     * stitching the last vertex back to the first). The base test is purely geometric — the first
+     * sampled vertex coincides with the last. Curves that close without a duplicated endpoint
+     * (a full-revolution {@link RoundCurve}, rectangles, polygons) override this.
+     */
+    isClosed(): boolean;
     strokeTriangulate(options?: StrokeTriangulateOptions): StrokeTriangulatedResult;
     toCommands(): Path2DCommand[];
     toData(): Path2DData;
@@ -494,6 +538,13 @@ declare class RoundCurve extends Curve {
     set dy(val: number);
     constructor(_center?: Vector2, _radius?: Vector2, _diff?: Vector2, rotate?: number, startAngle?: number, endAngle?: number, clockwise?: boolean);
     isClockwise(): boolean;
+    /**
+     * A circle/ellipse arc is closed when it sweeps (at least) a full revolution — the sampled
+     * outline does not duplicate the start vertex, so the geometric first==last test in the base
+     * class would wrongly report a full circle as open and leave a seam gap in the stroke.
+     */
+    isClosed(): boolean;
+    reverse(): this;
     protected _getDeltaAngle(): number;
     getPoint(t: number, output?: Vector2): Vector2;
     /**
@@ -541,7 +592,14 @@ declare class CompositeCurve<T extends Curve = Curve> extends Curve {
     protected _removeNextPointIfEqualPrevPoint(output: number[], offset: number): number[];
     getSpacedVertices(count?: number, output?: number[]): number[];
     getAdaptiveVertices(output?: number[]): number[];
+    /**
+     * A composite is closed when its single child is closed (e.g. a lone full-circle arc), or when
+     * its assembled outline returns to its start (rectangles, polygons, multi-segment loops).
+     */
+    isClosed(): boolean;
     strokeTriangulate(options?: StrokeTriangulateOptions): StrokeTriangulatedResult;
+    /** Reverse the sub-curve order and reverse each sub-curve, so the whole outline runs backwards. */
+    reverse(): this;
     getFillVertices(options?: FillTriangulateOptions): number[];
     applyTransform(transform: Transform2D | ((point: Vector2) => void)): this;
     getMinMax(min?: Vector2, max?: Vector2): {
@@ -564,6 +622,7 @@ declare class CubicBezierCurve extends Curve {
     getPoint(t: number, output?: Vector2): Vector2;
     getAdaptiveVertices(output?: number[]): number[];
     getControlPointRefs(): Vector2[];
+    reverse(): this;
     protected _solveQuadratic(a: number, b: number, c: number): number[];
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
@@ -589,6 +648,7 @@ declare class LineCurve extends Curve {
     getTangent(_t: number, output?: Vector2): Vector2;
     getTangentAt(u: number, output?: Vector2): Vector2;
     getControlPointRefs(): Vector2[];
+    reverse(): this;
     getAdaptiveVertices(output?: number[]): number[];
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
@@ -621,6 +681,7 @@ declare class QuadraticBezierCurve extends Curve {
     constructor(p1?: Vector2, cp?: Vector2, p2?: Vector2);
     getPoint(t: number, output?: Vector2): Vector2;
     getControlPointRefs(): Vector2[];
+    reverse(): this;
     getAdaptiveVertices(output?: number[]): number[];
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
@@ -665,6 +726,7 @@ declare class SplineCurve extends Curve {
     constructor(points?: Vector2[]);
     getPoint(t: number, output?: Vector2): Vector2;
     getControlPointRefs(): Vector2[];
+    reverse(): this;
     copyFrom(source: SplineCurve): this;
 }
 
@@ -676,6 +738,13 @@ declare class CurvePath extends CompositeCurve {
     addPoints(points: Vector2[]): this;
     addCommands(commands: Path2DCommand[]): this;
     addData(data: string): this;
+    /**
+     * A sub-path is closed if it was explicitly closed (`autoClose`, i.e. a `Z`/`closePath`), or if
+     * it forms a geometric loop / wraps a single closed primitive (handled by the base class).
+     */
+    isClosed(): boolean;
+    /** Reverse direction, then refresh the {@link startPoint}/{@link currentPoint} cursors. */
+    reverse(): this;
     protected _closeVertices(output: number[]): number[];
     getUnevenVertices(count?: number, output?: number[]): number[];
     getSpacedVertices(count?: number, output?: number[]): number[];
@@ -760,6 +829,23 @@ declare class Path2D<T = any> extends CompositeCurve<CurvePath> {
     /** Per-sub-path sampled rings, cached for repeated hit tests. */
     protected _getRings(): number[][];
     isPointInFill(point: Vector2Like, options?: IsPointInFillOptions): boolean;
+    /** Build a `Path2D` from flat rings (`[x0,y0,…]` per sub-path); closed-and-filled as sub-paths. */
+    static fromRings(rings: number[][], style?: Partial<Path2DStyle>): Path2D;
+    /**
+     * Boolean (path) operation against another path, returning a NEW `Path2D` whose outline is the
+     * polygonal result. Curves are sampled before clipping, so the result is a polygonal
+     * approximation (see {@link polygonBoolean}). The result inherits this path's `style` unless
+     * overridden via `style`. Holes are emitted as oppositely-wound sub-paths (nonzero fill).
+     */
+    booleanOp(op: BooleanOp, other: Path2D, style?: Partial<Path2DStyle>): Path2D;
+    /** `this ∪ other` — the combined filled area. */
+    union(other: Path2D, style?: Partial<Path2DStyle>): Path2D;
+    /** `this ∩ other` — only the overlapping area. */
+    intersection(other: Path2D, style?: Partial<Path2DStyle>): Path2D;
+    /** `this − other` — this path with `other` cut away. */
+    difference(other: Path2D, style?: Partial<Path2DStyle>): Path2D;
+    /** `this ⊕ other` — areas covered by exactly one of the two paths. */
+    xor(other: Path2D, style?: Partial<Path2DStyle>): Path2D;
     /**
      * Test whether a point lies on this path's stroke. A hit on any sub-path counts.
      *
@@ -833,6 +919,40 @@ declare class Path2DSet<T = any> {
     }>): HTMLCanvasElement;
 }
 
+interface PosTan {
+    position: Vector2;
+    tangent: Vector2;
+    angle: number;
+}
+/**
+ * PathKit/Skia-style arc-length measurement over any {@link Curve} (including `CurvePath` and
+ * `Path2D`). Wraps the curve's existing arc-length cache, so repeated queries are cheap.
+ *
+ * ```ts
+ * const measure = new PathMeasure(path)
+ * const { position, angle } = measure.getPosTan(measure.getLength() * progress)
+ * ```
+ */
+declare class PathMeasure {
+    curve: Curve;
+    constructor(curve: Curve);
+    /** Total arc length of the path. */
+    getLength(): number;
+    /** Whether the path forms a closed loop (see {@link Curve.isClosed}). */
+    isClosed(): boolean;
+    /** Point + unit tangent + tangent angle at an absolute arc-length `distance` (clamped). */
+    getPosTan(distance: number): PosTan;
+    /** Point at an absolute arc-length `distance` (clamped to `[0, getLength()]`). */
+    getPosition(distance: number): Vector2;
+    /** Point + tangent at a normalized progress `t ∈ [0, 1]` along the path. */
+    getPosTanAtProgress(t: number): PosTan;
+    /**
+     * Evenly sample the path into `count + 1` {@link PosTan} entries (arc-length spaced), e.g. to
+     * lay glyphs along a path or drive an `animate(progress)`-style traversal.
+     */
+    sample(count?: number): PosTan[];
+}
+
 declare class FFDControlGrid {
     rows: number;
     cols: number;
@@ -875,5 +995,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, 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 };
+export { ArcCurve, BoundingBox, CompositeCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, EquilateralPolygonCurve, FFDControlGrid, LineCurve, PI, PI_2, Path2D, Path2DSet, PathMeasure, 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, polygonBoolean, quadraticBezier, resolveLineStyle, setCanvasContext, strokeTriangulate, svgPathCommandsAddToPath2D, svgPathCommandsToData, svgPathDataToCommands, svgToDom, svgToPath2DSet, toKebabCase };
+export type { BooleanOp, CssFunction, CssFunctionArg, DrawPointOptions, FillRule, FillTriangulateOptions, FillTriangulatedResult, FlatRing, IsPointInFillOptions, IsPointInStrokeOptions, LineCap, LineJoin, LineStyle, ParseCssFunctionContext, Path2DCommand, Path2DData, Path2DDrawStyle, Path2DStyle, PosTan, StrokeLinecap, StrokeLinejoin, StrokeTriangulateOptions, StrokeTriangulatedResult, TransformableObject, TriangulatedResult, Vector2Like };

package/dist/index.d.ts

@@ -249,6 +249,20 @@ declare class Transform2D {
     destroy(): void;
 }
 
+type BooleanOp = 'union' | 'intersection' | 'difference' | 'xor';
+/**
+ * A flat ring: `[x0, y0, x1, y1, …]` (the same layout {@link Curve.getAdaptiveVertices} produces).
+ * A path is described as an array of such rings (one per sub-path).
+ */
+type FlatRing = number[];
+/**
+ * Boolean operation between two ring soups, returning the result as flat rings (shells wound
+ * counter-clockwise, holes clockwise — so a nonzero fill renders them correctly). Powered by the
+ * Martinez–Rueda sweep-line clipper (`polygon-clipping`); because the inputs are sampled outlines,
+ * the result is a polygonal approximation of curved paths.
+ */
+declare function polygonBoolean(op: BooleanOp, ringsA: FlatRing[], ringsB: FlatRing[]): FlatRing[];
+
 declare function catmullRom(t: number, p0: number, p1: number, p2: number, p3: number): number;
 
 interface CssFunctionArg {
@@ -375,6 +389,12 @@ interface LineStyle {
     cap: LineCap;
     miterLimit: number;
 }
+/**
+ * Derive a triangulator {@link LineStyle} from a (partial) {@link Path2DStyle}. This is what
+ * makes `path.strokeTriangulate()` honor `style.strokeWidth` / `strokeLinejoin` / `strokeLinecap`
+ * / `strokeMiterlimit` instead of silently falling back to a 1px miter hairline.
+ */
+declare function resolveLineStyle(style?: Partial<Path2DStyle>): LineStyle;
 declare function strokeTriangulate(points: number[], options?: StrokeTriangulateOptions): StrokeTriangulatedResult;
 
 interface IsPointInFillOptions {
@@ -413,6 +433,13 @@ declare abstract class Curve {
     getPointAt(u: number, output?: Vector2): Vector2;
     isClockwise(): boolean;
     getControlPointRefs(): Vector2[];
+    /**
+     * Reverse the traversal direction in place (start ↔ end, same geometry). The base
+     * implementation reverses the order of the control-point *values*, which is correct for
+     * line / Bézier / spline primitives whose {@link getControlPointRefs} order matches their
+     * parametric order. {@link RoundCurve} (angle-based) and composites (child order) override it.
+     */
+    reverse(): this;
     applyTransform(transform: Transform2D | ((point: Vector2) => void)): this;
     getUnevenVertices(count?: number, output?: number[]): number[];
     getSpacedVertices(count?: number, output?: number[]): number[];
@@ -428,6 +455,16 @@ declare abstract class Curve {
     getUToTMapping(u: number, distance?: number): number;
     getTangent(t: number, output?: Vector2): Vector2;
     getTangentAt(u: number, output?: Vector2): Vector2;
+    /**
+     * PathKit-style sample at an absolute arc-length `distance` along the curve: the point, the unit
+     * tangent, and the tangent `angle` in radians. `distance` is clamped to `[0, getLength()]`, so
+     * passing `0`/`getLength()` always yields the endpoints. See {@link PathMeasure} for a wrapper.
+     */
+    getPosTan(distance: number): {
+        position: Vector2;
+        tangent: Vector2;
+        angle: number;
+    };
     getNormal(t: number, output?: Vector2): Vector2;
     getNormalAt(u: number, output?: Vector2): Vector2;
     getTForPoint(target: Vector2Like, epsilon?: number): number;
@@ -464,6 +501,13 @@ declare abstract class Curve {
     contains(x: number, y: number, options?: IsPointInFillOptions): boolean;
     getFillVertices(_options?: FillTriangulateOptions): number[];
     fillTriangulate(options?: FillTriangulateOptions): FillTriangulatedResult;
+    /**
+     * Whether this curve forms a closed loop (its outline should be stroked without end caps,
+     * stitching the last vertex back to the first). The base test is purely geometric — the first
+     * sampled vertex coincides with the last. Curves that close without a duplicated endpoint
+     * (a full-revolution {@link RoundCurve}, rectangles, polygons) override this.
+     */
+    isClosed(): boolean;
     strokeTriangulate(options?: StrokeTriangulateOptions): StrokeTriangulatedResult;
     toCommands(): Path2DCommand[];
     toData(): Path2DData;
@@ -494,6 +538,13 @@ declare class RoundCurve extends Curve {
     set dy(val: number);
     constructor(_center?: Vector2, _radius?: Vector2, _diff?: Vector2, rotate?: number, startAngle?: number, endAngle?: number, clockwise?: boolean);
     isClockwise(): boolean;
+    /**
+     * A circle/ellipse arc is closed when it sweeps (at least) a full revolution — the sampled
+     * outline does not duplicate the start vertex, so the geometric first==last test in the base
+     * class would wrongly report a full circle as open and leave a seam gap in the stroke.
+     */
+    isClosed(): boolean;
+    reverse(): this;
     protected _getDeltaAngle(): number;
     getPoint(t: number, output?: Vector2): Vector2;
     /**
@@ -541,7 +592,14 @@ declare class CompositeCurve<T extends Curve = Curve> extends Curve {
     protected _removeNextPointIfEqualPrevPoint(output: number[], offset: number): number[];
     getSpacedVertices(count?: number, output?: number[]): number[];
     getAdaptiveVertices(output?: number[]): number[];
+    /**
+     * A composite is closed when its single child is closed (e.g. a lone full-circle arc), or when
+     * its assembled outline returns to its start (rectangles, polygons, multi-segment loops).
+     */
+    isClosed(): boolean;
     strokeTriangulate(options?: StrokeTriangulateOptions): StrokeTriangulatedResult;
+    /** Reverse the sub-curve order and reverse each sub-curve, so the whole outline runs backwards. */
+    reverse(): this;
     getFillVertices(options?: FillTriangulateOptions): number[];
     applyTransform(transform: Transform2D | ((point: Vector2) => void)): this;
     getMinMax(min?: Vector2, max?: Vector2): {
@@ -564,6 +622,7 @@ declare class CubicBezierCurve extends Curve {
     getPoint(t: number, output?: Vector2): Vector2;
     getAdaptiveVertices(output?: number[]): number[];
     getControlPointRefs(): Vector2[];
+    reverse(): this;
     protected _solveQuadratic(a: number, b: number, c: number): number[];
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
@@ -589,6 +648,7 @@ declare class LineCurve extends Curve {
     getTangent(_t: number, output?: Vector2): Vector2;
     getTangentAt(u: number, output?: Vector2): Vector2;
     getControlPointRefs(): Vector2[];
+    reverse(): this;
     getAdaptiveVertices(output?: number[]): number[];
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
@@ -621,6 +681,7 @@ declare class QuadraticBezierCurve extends Curve {
     constructor(p1?: Vector2, cp?: Vector2, p2?: Vector2);
     getPoint(t: number, output?: Vector2): Vector2;
     getControlPointRefs(): Vector2[];
+    reverse(): this;
     getAdaptiveVertices(output?: number[]): number[];
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
@@ -665,6 +726,7 @@ declare class SplineCurve extends Curve {
     constructor(points?: Vector2[]);
     getPoint(t: number, output?: Vector2): Vector2;
     getControlPointRefs(): Vector2[];
+    reverse(): this;
     copyFrom(source: SplineCurve): this;
 }
 
@@ -676,6 +738,13 @@ declare class CurvePath extends CompositeCurve {
     addPoints(points: Vector2[]): this;
     addCommands(commands: Path2DCommand[]): this;
     addData(data: string): this;
+    /**
+     * A sub-path is closed if it was explicitly closed (`autoClose`, i.e. a `Z`/`closePath`), or if
+     * it forms a geometric loop / wraps a single closed primitive (handled by the base class).
+     */
+    isClosed(): boolean;
+    /** Reverse direction, then refresh the {@link startPoint}/{@link currentPoint} cursors. */
+    reverse(): this;
     protected _closeVertices(output: number[]): number[];
     getUnevenVertices(count?: number, output?: number[]): number[];
     getSpacedVertices(count?: number, output?: number[]): number[];
@@ -760,6 +829,23 @@ declare class Path2D<T = any> extends CompositeCurve<CurvePath> {
     /** Per-sub-path sampled rings, cached for repeated hit tests. */
     protected _getRings(): number[][];
     isPointInFill(point: Vector2Like, options?: IsPointInFillOptions): boolean;
+    /** Build a `Path2D` from flat rings (`[x0,y0,…]` per sub-path); closed-and-filled as sub-paths. */
+    static fromRings(rings: number[][], style?: Partial<Path2DStyle>): Path2D;
+    /**
+     * Boolean (path) operation against another path, returning a NEW `Path2D` whose outline is the
+     * polygonal result. Curves are sampled before clipping, so the result is a polygonal
+     * approximation (see {@link polygonBoolean}). The result inherits this path's `style` unless
+     * overridden via `style`. Holes are emitted as oppositely-wound sub-paths (nonzero fill).
+     */
+    booleanOp(op: BooleanOp, other: Path2D, style?: Partial<Path2DStyle>): Path2D;
+    /** `this ∪ other` — the combined filled area. */
+    union(other: Path2D, style?: Partial<Path2DStyle>): Path2D;
+    /** `this ∩ other` — only the overlapping area. */
+    intersection(other: Path2D, style?: Partial<Path2DStyle>): Path2D;
+    /** `this − other` — this path with `other` cut away. */
+    difference(other: Path2D, style?: Partial<Path2DStyle>): Path2D;
+    /** `this ⊕ other` — areas covered by exactly one of the two paths. */
+    xor(other: Path2D, style?: Partial<Path2DStyle>): Path2D;
     /**
      * Test whether a point lies on this path's stroke. A hit on any sub-path counts.
      *
@@ -833,6 +919,40 @@ declare class Path2DSet<T = any> {
     }>): HTMLCanvasElement;
 }
 
+interface PosTan {
+    position: Vector2;
+    tangent: Vector2;
+    angle: number;
+}
+/**
+ * PathKit/Skia-style arc-length measurement over any {@link Curve} (including `CurvePath` and
+ * `Path2D`). Wraps the curve's existing arc-length cache, so repeated queries are cheap.
+ *
+ * ```ts
+ * const measure = new PathMeasure(path)
+ * const { position, angle } = measure.getPosTan(measure.getLength() * progress)
+ * ```
+ */
+declare class PathMeasure {
+    curve: Curve;
+    constructor(curve: Curve);
+    /** Total arc length of the path. */
+    getLength(): number;
+    /** Whether the path forms a closed loop (see {@link Curve.isClosed}). */
+    isClosed(): boolean;
+    /** Point + unit tangent + tangent angle at an absolute arc-length `distance` (clamped). */
+    getPosTan(distance: number): PosTan;
+    /** Point at an absolute arc-length `distance` (clamped to `[0, getLength()]`). */
+    getPosition(distance: number): Vector2;
+    /** Point + tangent at a normalized progress `t ∈ [0, 1]` along the path. */
+    getPosTanAtProgress(t: number): PosTan;
+    /**
+     * Evenly sample the path into `count + 1` {@link PosTan} entries (arc-length spaced), e.g. to
+     * lay glyphs along a path or drive an `animate(progress)`-style traversal.
+     */
+    sample(count?: number): PosTan[];
+}
+
 declare class FFDControlGrid {
     rows: number;
     cols: number;
@@ -875,5 +995,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, 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 };
+export { ArcCurve, BoundingBox, CompositeCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, EquilateralPolygonCurve, FFDControlGrid, LineCurve, PI, PI_2, Path2D, Path2DSet, PathMeasure, 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, polygonBoolean, quadraticBezier, resolveLineStyle, setCanvasContext, strokeTriangulate, svgPathCommandsAddToPath2D, svgPathCommandsToData, svgPathDataToCommands, svgToDom, svgToPath2DSet, toKebabCase };
+export type { BooleanOp, CssFunction, CssFunctionArg, DrawPointOptions, FillRule, FillTriangulateOptions, FillTriangulatedResult, FlatRing, IsPointInFillOptions, IsPointInStrokeOptions, LineCap, LineJoin, LineStyle, ParseCssFunctionContext, Path2DCommand, Path2DData, Path2DDrawStyle, Path2DStyle, PosTan, StrokeLinecap, StrokeLinejoin, StrokeTriangulateOptions, StrokeTriangulatedResult, TransformableObject, TriangulatedResult, Vector2Like };