modern-path2d 1.0.0 → 1.1.0

package/dist/index.d.ts

@@ -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 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;
 
-declare function setCanvasContext(ctx: CanvasRenderingContext2D, style: Partial<PathStyle>): void;
+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,19 +130,25 @@ 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[];
+    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;
@@ -185,62 +161,31 @@ declare abstract class Curve {
         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[];
-    getMinMax(min?: Vector2, max?: Vector2): {
-        min: Vector2;
-        max: Vector2;
-    };
-}
-
-declare class CubicBezierCurve extends Curve {
-    start: Vector2;
-    startControl: Vector2;
-    endControl: Vector2;
-    end: Vector2;
-    constructor(start?: Vector2, startControl?: Vector2, endControl?: Vector2, end?: Vector2);
-    getPoint(t: number, output?: Vector2): Vector2;
-    getControlPoints(): Vector2[];
-    protected _solveQuadratic(a: number, b: number, c: number): number[];
-    getMinMax(min?: Vector2, max?: Vector2): {
-        min: Vector2;
-        max: Vector2;
-    };
-    toCommands(): PathCommand[];
-    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);
+    center: Vector2;
+    radius: Vector2;
+    constructor(cx?: number, cy?: number, rx?: number, ry?: number, rotation?: number, startAngle?: number, endAngle?: number, clockwise?: boolean);
     isClockwise(): boolean;
     getPoint(t: number, output?: Vector2): Vector2;
-    toCommands(): PathCommand[];
+    toCommands(): Path2DCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
     matrix(matrix: Matrix3): this;
-    getControlPoints(): Vector2[];
+    getControlPointRefs(): Vector2[];
+    getAdaptivePointArray(output?: number[]): number[];
+    fillTriangulate(options?: FillTriangulateOptions): FillTriangulateResult;
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
         max: Vector2;
@@ -248,143 +193,173 @@ declare class EllipseCurve extends Curve {
     copy(source: EllipseCurve): this;
 }
 
-declare class LineCurve extends Curve {
-    start: Vector2;
-    end: Vector2;
-    constructor(start?: Vector2, end?: Vector2);
+declare class ArcCurve extends EllipseCurve {
+    constructor(cx?: number, cy?: number, radius?: number, startAngle?: number, endAngle?: number, clockwise?: boolean);
+    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;
-    getPointAt(u: number, output?: Vector2): Vector2;
-    getTangent(_t: number, output?: Vector2): Vector2;
-    getTangentAt(u: number, output?: Vector2): Vector2;
-    getControlPoints(): Vector2[];
+    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: 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[];
+declare class CubicBezierCurve extends Curve {
+    p1: Vector2;
+    cp1: Vector2;
+    cp2: Vector2;
+    p2: Vector2;
+    static from(p1: Vector2, cp1: Vector2, cp2: Vector2, p2: Vector2): CubicBezierCurve;
+    constructor(p1x: number, p1y: number, cp1x: number, cp1y: number, cp2x: number, cp2y: number, p2x: number, p2y: number);
+    getPoint(t: number, output?: Vector2): 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;
     };
-    toCommands(): PathCommand[];
+    toCommands(): Path2DCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
+    copy(source: CubicBezierCurve): this;
 }
 
-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;
+declare class LineCurve extends Curve {
+    p1: Vector2;
+    p2: Vector2;
+    static from(p1: Vector2, p2: Vector2): LineCurve;
+    constructor(p1x: number, p1y: number, p2x: number, p2y: number);
     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[];
+    getTangent(_t: number, output?: Vector2): Vector2;
+    getTangentAt(u: number, output?: Vector2): 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 PloygonCurve extends CompositeCurve<LineCurve> {
+    static equilateral(cx?: number, cy?: number, radius?: number, sideCount?: number): PloygonCurve;
 }
 
 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(p1: Vector2, cp: Vector2, p2: Vector2): QuadraticBezierCurve;
+    constructor(p1x: number, p1y: number, cpx: number, cpy: number, p2x: number, p2y: number);
     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[];
-    drawTo(ctx: CanvasRenderingContext2D): this;
+declare class RectangleCurve extends PloygonCurve {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    fillTriangulate(options?: FillTriangulateOptions): FillTriangulateResult;
 }
 
 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;
@@ -397,27 +372,53 @@ declare class CurvePath extends Curve {
     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;
     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;
@@ -428,11 +429,9 @@ declare class Path2D {
     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;
+    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;
@@ -443,25 +442,28 @@ declare class Path2D {
         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 +480,16 @@ 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 pathDataToPathCommands(d: string): PathCommand[];
+declare function svgPathCommandsToData(commands: Path2DCommand[]): Path2DData;
 
-declare function parseSVGToDOM(svg: string | SVGElement): SVGElement;
-declare function parseSVG(svg: string | SVGElement): Path2D[];
+declare function svgPathDataToCommands(data: Path2DData): Path2DCommand[];
 
-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 parseSVGToDOM(svg: string | SVGElement): SVGElement;
+declare function parseSVG(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, 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, SplineCurve, type StrokeLinecap, type StrokeLinejoin, type StrokeTriangulateOptions, type StrokeTriangulateResult, Vector2, type VectorLike, catmullRom, cubicBezier, drawPoint, fillTriangulate, getAdaptiveCubicBezierCurvePoints, getAdaptiveQuadraticBezierCurvePoints, parseArcCommand, parsePathDataArgs, parseSVG, parseSVGToDOM, quadraticBezier, setCanvasContext, strokeTriangulate, svgPathCommandsAddToPath2D, svgPathCommandsToData, svgPathDataToCommands };