modern-path2d 1.0.1 → 1.2.0

package/dist/index.d.mts

@@ -1,83 +1,53 @@
-/**
- * @link https://developer.mozilla.org/docs/Web/SVG/Attribute/d
- */
-type PathCommand = {
-    type: 'm' | 'M';
-    x: number;
-    y: number;
-} | {
-    type: 'h' | 'H';
-    x: number;
-} | {
-    type: 'v' | 'V';
-    y: number;
-} | {
-    type: 'l' | 'L';
-    x: number;
-    y: number;
-} | {
-    type: 'c' | 'C';
-    x1: number;
-    y1: number;
-    x2: number;
-    y2: number;
-    x: number;
-    y: number;
-} | {
-    type: 's' | 'S';
-    x2: number;
-    y2: number;
-    x: number;
-    y: number;
-} | {
-    type: 'q' | 'Q';
-    x1: number;
-    y1: number;
-    x: number;
-    y: number;
-} | {
-    type: 't' | 'T';
-    x: number;
-    y: number;
-} | {
-    type: 'a' | 'A';
-    rx: number;
-    ry: number;
-    angle: number;
-    largeArcFlag: number;
-    sweepFlag: number;
-    x: number;
-    y: number;
-} | {
-    type: 'z' | 'Z';
-};
-type FillRule = 'nonzero' | 'evenodd';
-type StrokeLinecap = 'butt' | 'round' | 'square';
-type StrokeLinejoin = 'arcs' | 'bevel' | 'miter' | 'miter-clip' | 'round';
-interface PathDrawStyle {
-    fill: string | CanvasGradient | CanvasPattern;
-    stroke: string | CanvasGradient | CanvasPattern;
-    shadowColor: string;
-    shadowOffsetX: number;
-    shadowOffsetY: number;
-    shadowBlur: number;
+interface DrawPointOptions {
+    radius?: number;
 }
-interface PathStyle extends PathDrawStyle {
-    [key: string]: any;
-    fillOpacity: number;
-    fillRule: FillRule;
-    opacity: number;
-    strokeOpacity: number;
-    strokeWidth: number;
-    strokeLinecap: StrokeLinecap;
-    strokeLinejoin: StrokeLinejoin;
-    strokeMiterlimit: number;
-    strokeDasharray: number[];
-    strokeDashoffset: number;
-    visibility: string;
+declare function drawPoint(ctx: CanvasRenderingContext2D, x: number, y: number, options?: DrawPointOptions): void;
+
+declare function catmullRom(t: number, p0: number, p1: number, p2: number, p3: number): number;
+
+declare function cubicBezier(t: number, p0: number, p1: number, p2: number, p3: number): number;
+
+interface FillTriangulateOptions {
+    holes?: number[];
+    vertices?: number[];
+    indices?: number[];
+    verticesStride?: number;
+    verticesOffset?: number;
+    indicesOffset?: number;
 }
+interface FillTriangulateResult {
+    vertices: number[];
+    indices: number[];
+}
+declare function fillTriangulate(points: number[], options?: FillTriangulateOptions): FillTriangulateResult;
+
+declare function getAdaptiveCubicBezierCurvePoints(sX: number, sY: number, x1: number, y1: number, x2: number, y2: number, x: number, y: number, smoothness: number | undefined, points: number[]): number[];
 
-declare function setCanvasContext(ctx: CanvasRenderingContext2D, style: Partial<PathStyle>): void;
+declare function getAdaptiveQuadraticBezierCurvePoints(sX: number, sY: number, x1: number, y1: number, x: number, y: number, smoothness: number | undefined, points: number[]): number[];
+
+declare function quadraticBezier(t: number, p0: number, p1: number, p2: number): number;
+
+type LineCap = 'butt' | 'round' | 'square';
+type LineJoin = 'round' | 'bevel' | 'miter';
+interface StrokeTriangulateOptions {
+    vertices?: number[];
+    indices?: number[];
+    lineStyle?: LineStyle;
+    flipAlignment?: boolean;
+    closed?: boolean;
+}
+interface StrokeTriangulateResult {
+    vertices: number[];
+    indices: number[];
+}
+interface LineStyle {
+    width: number;
+    alignment: number;
+    join: LineJoin;
+    cap: LineCap;
+    miterLimit: number;
+}
+declare function strokeTriangulate(points: number[], options?: StrokeTriangulateOptions): StrokeTriangulateResult;
 
 declare class Matrix3 {
     elements: number[];
@@ -160,201 +130,197 @@ declare class BoundingBox {
 }
 
 declare abstract class Curve {
-    arcLengthDivisions: number;
-    protected _cacheArcLengths?: number[];
-    protected _needsUpdate: boolean;
-    isClockwise(): boolean;
+    startT: number;
+    endT: number;
+    arcLengthDivision: number;
+    protected _arcLengths?: number[];
     abstract getPoint(t: number, output?: Vector2): Vector2;
     getPointAt(u: number, output?: Vector2): Vector2;
-    getPoints(divisions?: number): Vector2[];
-    abstract getControlPoints(): Vector2[];
-    forEachControlPoints(cb: (point: Vector2, index: number) => void): this;
-    getSpacedPoints(divisions?: number): Vector2[];
+    isClockwise(): boolean;
+    getControlPointRefs(): Vector2[];
+    applyTransform(transform: Matrix3): this;
+    getUnevenPointArray(count?: number, output?: number[]): number[];
+    getSpacedPointArray(count?: number, output?: number[]): number[];
+    getAdaptivePointArray(output?: number[]): number[];
+    protected _pointArrayToPoint(array: number[], output?: Vector2[]): Vector2[];
+    getSpacedPoints(count?: number, output?: Vector2[]): Vector2[];
+    getUnevenPoints(count?: number, output?: Vector2[]): Vector2[];
+    getAdaptivePoints(output?: Vector2[]): Vector2[];
+    getPoints(count?: number, output?: Vector2[]): Vector2[];
     getLength(): number;
-    getLengths(divisions?: number): number[];
-    updateArcLengths(): void;
+    getLengths(): number[];
+    updateLengths(): void;
     getUToTMapping(u: number, distance?: number): number;
     getTangent(t: number, output?: Vector2): Vector2;
     getTangentAt(u: number, output?: Vector2): Vector2;
     getNormal(t: number, output?: Vector2): Vector2;
     getNormalAt(u: number, output?: Vector2): Vector2;
     getTForPoint(target: VectorLike, epsilon?: number): number;
-    matrix(matrix: Matrix3): this;
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
         max: Vector2;
     };
     getBoundingBox(): BoundingBox;
-    toCommands(): PathCommand[];
-    toData(): string;
+    fillTriangulate(options?: FillTriangulateOptions): FillTriangulateResult;
+    strokeTriangulate(options?: StrokeTriangulateOptions): StrokeTriangulateResult;
+    toCommands(): Path2DCommand[];
+    toData(): Path2DData;
     drawTo(ctx: CanvasRenderingContext2D): this;
     copy(source: Curve): this;
     clone(): this;
 }
 
-declare class CircleCurve extends Curve {
-    center: Vector2;
-    radius: number;
-    start: number;
-    end: number;
-    constructor(center: Vector2, radius: number, start?: number, end?: number);
-    getPoint(t: number): Vector2;
-    getTangent(t: number, output?: Vector2): Vector2;
-    getNormal(t: number, output?: Vector2): Vector2;
-    getControlPoints(): Vector2[];
+declare class RoundCurve extends Curve {
+    _center: Vector2;
+    _radius: Vector2;
+    _diff: Vector2;
+    rotate: number;
+    startAngle: number;
+    endAngle: number;
+    clockwise: boolean;
+    get cx(): number;
+    set cx(val: number);
+    get cy(): number;
+    set cy(val: number);
+    get rx(): number;
+    set rx(val: number);
+    get ry(): number;
+    set ry(val: number);
+    get dx(): number;
+    set dx(val: number);
+    get dy(): number;
+    set dy(val: number);
+    constructor(_center: Vector2, _radius: Vector2, _diff: Vector2, rotate?: number, startAngle?: number, endAngle?: number, clockwise?: boolean);
+    isClockwise(): boolean;
+    getPoint(t: number, output?: Vector2): Vector2;
+    toCommands(): Path2DCommand[];
+    drawTo(ctx: CanvasRenderingContext2D): this;
+    applyTransform(matrix: Matrix3): this;
+    getControlPointRefs(): Vector2[];
+    getAdaptivePointArray(output?: number[]): number[];
+    fillTriangulate(options?: FillTriangulateOptions): FillTriangulateResult;
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
         max: Vector2;
     };
+    copy(source: RoundCurve): this;
 }
 
-declare class CubicBezierCurve extends Curve {
-    start: Vector2;
-    startControl: Vector2;
-    endControl: Vector2;
-    end: Vector2;
-    constructor(start?: Vector2, startControl?: Vector2, endControl?: Vector2, end?: Vector2);
+declare class ArcCurve extends RoundCurve {
+    readonly radius: number;
+    constructor(cx?: number, cy?: number, radius?: number, startAngle?: number, endAngle?: number, clockwise?: boolean);
+    drawTo(ctx: CanvasRenderingContext2D): this;
+    getAdaptivePointArray(output?: number[]): number[];
+}
+
+declare class CompositeCurve<T extends Curve = Curve> extends Curve {
+    curves: T[];
+    constructor(curves?: T[]);
+    addCurve(curve: T): this;
     getPoint(t: number, output?: Vector2): Vector2;
-    getControlPoints(): Vector2[];
-    protected _solveQuadratic(a: number, b: number, c: number): number[];
+    updateLengths(): void;
+    getControlPointRefs(): Vector2[];
+    getAdaptivePointArray(output?: number[]): number[];
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
         max: Vector2;
     };
-    toCommands(): PathCommand[];
+    getBoundingBox(): BoundingBox;
+    toCommands(): Path2DCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
-    copy(source: CubicBezierCurve): this;
 }
 
-declare class EllipseCurve extends Curve {
-    center: Vector2;
-    radiusX: number;
-    radiusY: number;
-    rotation: number;
-    startAngle: number;
-    endAngle: number;
-    clockwise: boolean;
-    constructor(center?: Vector2, radiusX?: number, radiusY?: number, rotation?: number, startAngle?: number, endAngle?: number, clockwise?: boolean);
-    isClockwise(): boolean;
+declare class CubicBezierCurve extends Curve {
+    p1: Vector2;
+    cp1: Vector2;
+    cp2: Vector2;
+    p2: Vector2;
+    static from(p1x: number, p1y: number, cp1x: number, cp1y: number, cp2x: number, cp2y: number, p2x: number, p2y: number): CubicBezierCurve;
+    constructor(p1: Vector2, cp1: Vector2, cp2: Vector2, p2: Vector2);
     getPoint(t: number, output?: Vector2): Vector2;
-    toCommands(): PathCommand[];
-    drawTo(ctx: CanvasRenderingContext2D): this;
-    matrix(matrix: Matrix3): this;
-    getControlPoints(): Vector2[];
+    getAdaptivePointArray(output?: number[]): number[];
+    getControlPointRefs(): Vector2[];
+    protected _solveQuadratic(a: number, b: number, c: number): number[];
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
         max: Vector2;
     };
-    copy(source: EllipseCurve): this;
+    toCommands(): Path2DCommand[];
+    drawTo(ctx: CanvasRenderingContext2D): this;
+    copy(source: CubicBezierCurve): this;
+}
+
+declare class EllipseCurve extends RoundCurve {
+    constructor(cx?: number, cy?: number, rx?: number, ry?: number, rotate?: number, startAngle?: number, endAngle?: number, clockwise?: boolean);
+    drawTo(ctx: CanvasRenderingContext2D): this;
 }
 
 declare class LineCurve extends Curve {
-    start: Vector2;
-    end: Vector2;
-    constructor(start?: Vector2, end?: Vector2);
+    p1: Vector2;
+    p2: Vector2;
+    static from(p1x: number, p1y: number, p2x: number, p2y: number): LineCurve;
+    constructor(p1: Vector2, p2: Vector2);
     getPoint(t: number, output?: Vector2): Vector2;
     getPointAt(u: number, output?: Vector2): Vector2;
     getTangent(_t: number, output?: Vector2): Vector2;
     getTangentAt(u: number, output?: Vector2): Vector2;
-    getControlPoints(): Vector2[];
+    getControlPointRefs(): Vector2[];
+    getAdaptivePointArray(output?: number[]): number[];
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
         max: Vector2;
     };
-    toCommands(): PathCommand[];
+    toCommands(): Path2DCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
     copy(source: LineCurve): this;
 }
 
-declare class HeartCurve extends Curve {
-    center: Vector2;
-    size: number;
-    start: number;
-    end: number;
-    curves: (CircleCurve | LineCurve)[];
-    curveT: number;
-    constructor(center: Vector2, size: number, start?: number, end?: number);
-    update(): this;
-    getPoint(t: number): Vector2;
-    getPointAt(t: number): Vector2;
-    getCurve(t: number): CircleCurve | LineCurve;
-    getTangent(t: number, output?: Vector2): Vector2;
-    getNormal(t: number, output?: Vector2): Vector2;
-    getControlPoints(): Vector2[];
-    getMinMax(min?: Vector2, max?: Vector2): {
-        min: Vector2;
-        max: Vector2;
-    };
-    toCommands(): PathCommand[];
-    drawTo(ctx: CanvasRenderingContext2D): this;
+declare class PloygonCurve extends CompositeCurve<LineCurve> {
 }
 
-declare class PloygonCurve extends Curve {
-    center: Vector2;
-    radius: number;
-    number: number;
-    start: number;
-    end: number;
-    curves: LineCurve[];
-    curveT: number;
-    points: Vector2[];
-    constructor(center: Vector2, radius?: number, number?: number, start?: number, end?: number);
-    update(): this;
-    getCurve(t: number): LineCurve;
-    getPoint(t: number, output?: Vector2): Vector2;
-    getPointAt(u: number, output?: Vector2): Vector2;
-    getTangent(t: number, output?: Vector2): Vector2;
-    getNormal(t: number, output?: Vector2): Vector2;
-    getControlPoints(): Vector2[];
-    getMinMax(min?: Vector2, max?: Vector2): {
-        min: Vector2;
-        max: Vector2;
-    };
-    toCommands(): PathCommand[];
-    drawTo(ctx: CanvasRenderingContext2D): this;
+declare class EquilateralPloygonCurve extends PloygonCurve {
+    readonly cx: number;
+    readonly cy: number;
+    readonly radius: number;
+    readonly sideCount: number;
+    constructor(cx?: number, cy?: number, radius?: number, sideCount?: number);
 }
 
 declare class QuadraticBezierCurve extends Curve {
-    start: Vector2;
-    control: Vector2;
-    end: Vector2;
-    constructor(start?: Vector2, control?: Vector2, end?: Vector2);
+    p1: Vector2;
+    cp: Vector2;
+    p2: Vector2;
+    static from(p1x: number, p1y: number, cpx: number, cpy: number, p2x: number, p2y: number): QuadraticBezierCurve;
+    constructor(p1: Vector2, cp: Vector2, p2: Vector2);
     getPoint(t: number, output?: Vector2): Vector2;
-    getControlPoints(): Vector2[];
+    getControlPointRefs(): Vector2[];
+    getAdaptivePointArray(output?: number[]): number[];
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
         max: Vector2;
     };
-    toCommands(): PathCommand[];
+    toCommands(): Path2DCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
     copy(source: QuadraticBezierCurve): this;
 }
 
-declare class RectangularCurve extends Curve {
-    center: Vector2;
-    rx: number;
-    aspectRatio: number;
-    start: number;
-    end: number;
-    curves: LineCurve[];
-    curveT: number;
-    get x(): number;
-    get y(): number;
-    get width(): number;
-    get height(): number;
-    constructor(center: Vector2, rx: number, aspectRatio?: number, start?: number, end?: number);
-    update(): this;
-    getCurve(t: number): LineCurve;
-    getPoint(t: number, output?: Vector2): Vector2;
-    getPointAt(u: number, output?: Vector2): Vector2;
-    getTangent(t: number, output?: Vector2): Vector2;
-    getNormal(t: number, output?: Vector2): Vector2;
-    getControlPoints(): Vector2[];
-    getMinMax(min?: Vector2, max?: Vector2): {
-        min: Vector2;
-        max: Vector2;
-    };
-    toCommands(): PathCommand[];
+declare class RectangleCurve extends PloygonCurve {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    drawTo(ctx: CanvasRenderingContext2D): this;
+    fillTriangulate(options?: FillTriangulateOptions): FillTriangulateResult;
+}
+
+declare class RoundRectangleCurve extends RoundCurve {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly radius: number;
+    constructor(x?: number, y?: number, width?: number, height?: number, radius?: number);
     drawTo(ctx: CanvasRenderingContext2D): this;
 }
 
@@ -362,29 +328,76 @@ declare class SplineCurve extends Curve {
     points: Vector2[];
     constructor(points?: Vector2[]);
     getPoint(t: number, output?: Vector2): Vector2;
-    getControlPoints(): Vector2[];
+    getControlPointRefs(): Vector2[];
     copy(source: SplineCurve): this;
 }
 
-declare class CurvePath extends Curve {
-    curves: Curve[];
+/**
+ * @link https://developer.mozilla.org/docs/Web/SVG/Attribute/d
+ */
+type Path2DCommand = {
+    type: 'm' | 'M';
+    x: number;
+    y: number;
+} | {
+    type: 'h' | 'H';
+    x: number;
+} | {
+    type: 'v' | 'V';
+    y: number;
+} | {
+    type: 'l' | 'L';
+    x: number;
+    y: number;
+} | {
+    type: 'c' | 'C';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    x: number;
+    y: number;
+} | {
+    type: 's' | 'S';
+    x2: number;
+    y2: number;
+    x: number;
+    y: number;
+} | {
+    type: 'q' | 'Q';
+    x1: number;
+    y1: number;
+    x: number;
+    y: number;
+} | {
+    type: 't' | 'T';
+    x: number;
+    y: number;
+} | {
+    type: 'a' | 'A';
+    rx: number;
+    ry: number;
+    angle: number;
+    largeArcFlag: number;
+    sweepFlag: number;
+    x: number;
+    y: number;
+} | {
+    type: 'z' | 'Z';
+};
+
+declare class CurvePath extends CompositeCurve {
     startPoint?: Vector2;
     currentPoint?: Vector2;
     autoClose: boolean;
-    protected _cacheLengths: number[];
     constructor(points?: Vector2[]);
-    addCurve(curve: Curve): this;
     addPoints(points: Vector2[]): this;
-    addCommands(commands: PathCommand[]): this;
+    addCommands(commands: Path2DCommand[]): this;
     addData(data: string): this;
-    getPoint(t: number, output?: Vector2): Vector2;
-    getControlPoints(): Vector2[];
-    getLength(): number;
-    updateArcLengths(): void;
-    getCurveLengths(): number[];
-    getSpacedPoints(divisions?: number): Vector2[];
-    getPoints(divisions?: number): Vector2[];
+    getUnevenPointArray(count?: number, output?: number[]): number[];
+    getSpacedPointArray(count?: number, output?: number[]): number[];
     protected _setCurrentPoint(point: VectorLike): this;
+    protected _connetLineTo(curve: Curve): this;
     closePath(): this;
     moveTo(x: number, y: number): this;
     lineTo(x: number, y: number): this;
@@ -395,29 +408,56 @@ declare class CurvePath extends Curve {
     arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): this;
     ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): this;
     relativeEllipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): this;
-    rect(x: number, y: number, w: number, h: number): this;
+    rect(x: number, y: number, width: number, height: number): this;
+    roundRect(x: number, y: number, width: number, height: number, radii: number): this;
     splineThru(points: Vector2[]): this;
-    getMinMax(min?: Vector2, max?: Vector2): {
-        min: Vector2;
-        max: Vector2;
-    };
-    getBoundingBox(): BoundingBox;
-    toCommands(): PathCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
     copy(source: CurvePath): this;
 }
 
+/**
+ * Svg path data
+ *
+ * @link https://developer.mozilla.org/docs/Web/SVG/Attribute/d
+ */
+type Path2DData = string;
+
+type FillRule = 'nonzero' | 'evenodd';
+type StrokeLinecap = 'butt' | 'round' | 'square';
+type StrokeLinejoin = 'arcs' | 'bevel' | 'miter' | 'miter-clip' | 'round';
+interface Path2DDrawStyle {
+    fill: string | CanvasGradient | CanvasPattern;
+    stroke: string | CanvasGradient | CanvasPattern;
+    shadowColor: string;
+    shadowOffsetX: number;
+    shadowOffsetY: number;
+    shadowBlur: number;
+}
+interface Path2DStyle extends Path2DDrawStyle {
+    [key: string]: any;
+    fillOpacity: number;
+    fillRule: FillRule;
+    opacity: number;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeLinecap: StrokeLinecap;
+    strokeLinejoin: StrokeLinejoin;
+    strokeMiterlimit: number;
+    strokeDasharray: number[];
+    strokeDashoffset: number;
+    visibility: string;
+}
+
 /**
  * @link https://developer.mozilla.org/zh-CN/docs/Web/API/Path2D
  */
-declare class Path2D {
-    currentPath: CurvePath;
-    paths: CurvePath[];
-    style: Partial<PathStyle>;
+declare class Path2D extends CompositeCurve<CurvePath> {
+    currentCurve: CurvePath;
+    style: Partial<Path2DStyle>;
     get startPoint(): Vector2 | undefined;
     get currentPoint(): Vector2 | undefined;
     get strokeWidth(): number;
-    constructor(path?: Path2D | PathCommand[] | string, style?: Partial<PathStyle>);
+    constructor(path?: Path2D | Path2DCommand[] | Path2DData, style?: Partial<Path2DStyle>);
     addPath(path: Path2D | CurvePath): this;
     closePath(): this;
     moveTo(x: number, y: number): this;
@@ -427,41 +467,43 @@ declare class Path2D {
     arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): this;
     arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): this;
     ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): this;
-    rect(x: number, y: number, w: number, h: number): this;
-    addCommands(commands: PathCommand[]): this;
-    addData(data: string): this;
+    rect(x: number, y: number, width: number, height: number): this;
+    roundRect(x: number, y: number, width: number, height: number, radii: number): this;
+    addCommands(commands: Path2DCommand[]): this;
+    addData(data: Path2DData): this;
     splineThru(points: Vector2[]): this;
-    getControlPoints(): Vector2[];
-    getCurves(): Curve[];
     scale(sx: number, sy?: number, target?: VectorLike): this;
     skew(ax: number, ay?: number, target?: VectorLike): this;
     rotate(a: number, target?: VectorLike): this;
     bold(b: number): this;
-    matrix(matrix: Matrix3): this;
+    applyTransform(transform: Matrix3): this;
     getMinMax(min?: Vector2, max?: Vector2, withStyle?: boolean): {
         min: Vector2;
         max: Vector2;
     };
     getBoundingBox(withStyle?: boolean): BoundingBox;
-    drawTo(ctx: CanvasRenderingContext2D, style?: Partial<PathStyle>): this;
-    drawControlPointsTo(ctx: CanvasRenderingContext2D, style?: Partial<PathStyle>): this;
-    toCommands(): PathCommand[];
-    toData(): string;
+    drawTo(ctx: CanvasRenderingContext2D, style?: Partial<Path2DStyle>): this;
+    drawControlPointsTo(ctx: CanvasRenderingContext2D, style?: Partial<Path2DStyle>): this;
+    toCommands(): Path2DCommand[];
+    toData(): Path2DData;
     toSVGPathString(): string;
+    copy(source: Path2D): this;
+    clone(): this;
+}
+
+declare class Path2DSet {
+    paths: Path2D[];
+    constructor(paths?: Path2D[]);
+    getBoundingBox(withStyle?: boolean): BoundingBox | undefined;
     toSVGString(): string;
     toSVGUrl(): string;
     toSVG(): SVGElement;
-    toCanvas(options?: Partial<PathStyle & {
+    toCanvas(options?: Partial<Path2DStyle & {
         pixelRatio: number;
     }>): HTMLCanvasElement;
-    copy(source: Path2D): this;
-    clone(): this;
 }
 
-/**
- * @link http://www.w3.org/TR/SVG11/implnote.html#PathElementImplementationNotes
- */
-declare function addPathCommandsToPath2D(commands: PathCommand[], path: Path2D | CurvePath): void;
+declare function setCanvasContext(ctx: CanvasRenderingContext2D, style: Partial<Path2DStyle>): void;
 
 /**
  * @link https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
@@ -478,19 +520,17 @@ declare function parseArcCommand(path: Path2D | CurvePath, rx: number, ry: numbe
  */
 declare function parsePathDataArgs(input: string, flags?: number[], stride?: number): number[];
 
-declare function pathCommandsToPathData(commands: PathCommand[]): string;
+/**
+ * @link http://www.w3.org/TR/SVG11/implnote.html#PathElementImplementationNotes
+ */
+declare function svgPathCommandsAddToPath2D(commands: Path2DCommand[], path: Path2D | CurvePath): void;
+
+declare function svgPathCommandsToData(commands: Path2DCommand[]): Path2DData;
 
-declare function pathDataToPathCommands(d: string): PathCommand[];
+declare function svgPathDataToCommands(data: Path2DData): Path2DCommand[];
 
-declare function parseSVGToDOM(svg: string | SVGElement): SVGElement;
-declare function parseSVG(svg: string | SVGElement): Path2D[];
+declare function svgToDom(svg: string | SVGElement): SVGElement;
 
-declare function getPathsBoundingBox(paths: Path2D[], withStyle?: boolean): BoundingBox | undefined;
-declare function pathsToSVGString(paths: Path2D[]): string;
-declare function pathsToSVGUrl(paths: Path2D[]): string;
-declare function pathsToSVG(paths: Path2D[]): SVGElement;
-declare function pathsToCanvas(paths: Path2D[], options?: Partial<PathStyle & {
-    pixelRatio: number;
-}>): HTMLCanvasElement;
+declare function svgToPath2DSet(svg: string | SVGElement): Path2DSet;
 
-export { BoundingBox, CircleCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, type FillRule, HeartCurve, LineCurve, Matrix3, Path2D, type PathCommand, type PathDrawStyle, type PathStyle, PloygonCurve, QuadraticBezierCurve, RectangularCurve, SplineCurve, type StrokeLinecap, type StrokeLinejoin, Vector2, type VectorLike, addPathCommandsToPath2D, getPathsBoundingBox, parseArcCommand, parsePathDataArgs, parseSVG, parseSVGToDOM, pathCommandsToPathData, pathDataToPathCommands, pathsToCanvas, pathsToSVG, pathsToSVGString, pathsToSVGUrl, setCanvasContext };
+export { ArcCurve, BoundingBox, CompositeCurve, CubicBezierCurve, Curve, CurvePath, type DrawPointOptions, EllipseCurve, EquilateralPloygonCurve, type FillRule, type FillTriangulateOptions, type FillTriangulateResult, type LineCap, LineCurve, type LineJoin, type LineStyle, Matrix3, Path2D, type Path2DCommand, type Path2DData, type Path2DDrawStyle, Path2DSet, type Path2DStyle, PloygonCurve, QuadraticBezierCurve, RectangleCurve, RoundRectangleCurve, SplineCurve, type StrokeLinecap, type StrokeLinejoin, type StrokeTriangulateOptions, type StrokeTriangulateResult, Vector2, type VectorLike, catmullRom, cubicBezier, drawPoint, fillTriangulate, getAdaptiveCubicBezierCurvePoints, getAdaptiveQuadraticBezierCurvePoints, parseArcCommand, parsePathDataArgs, quadraticBezier, setCanvasContext, strokeTriangulate, svgPathCommandsAddToPath2D, svgPathCommandsToData, svgPathDataToCommands, svgToDom, svgToPath2DSet };