toosoon-utils 4.1.4 → 4.1.5

package/README.md

@@ -1326,6 +1326,7 @@ Utility classes for manipulating curves.
 Utility abstract class for manipulating curves.
 
 - [new Curve()](#curve)
+  - .isCurve: `true`
   - [.arcLengthDivisions](#curve-arc-length-divisions): `number`
   - [.needsUpdate](#curve-needs-update): `boolean`
   - [.getPoint(t)](#curve-get-point-method): `[number, number]`
@@ -1469,9 +1470,7 @@ static Curve.isClosed(points: Array<[number, number]>): boolean;
 
 ### LineCurve <a id="line-curve"></a>
 
-Utility class for manipulating lines.
-
-[Extends Curve](#curve)
+Utility class extending [Curve](#curve) for manipulating lines.
 
 - [new LineCurve(x1, y1, x2, y2)](#line-curve)
 
@@ -1484,9 +1483,7 @@ Utility class for manipulating lines.
 
 ### PolylineCurve <a id="polyline-curve"></a>
 
-Utility class for manipulating Polyline curves.
-
-[Extends Curve](#curve)
+Utility class extending [Curve](#curve) for manipulating polylines.
 
 - [new PolylineCurve(points)](#polyline-curve)
 
@@ -1496,9 +1493,7 @@ Utility class for manipulating Polyline curves.
 
 ### QuadraticBezierCurve <a id="quadratic-bezier-curve"></a>
 
-Utility class for manipulating Quadratic Bézier curves.
-
-[Extends Curve](#curve)
+Utility class extending [Curve](#curve) for manipulating Quadratic Bézier curves.
 
 - [new QuadraticBezierCurve(x1, y1, cpx, cpy, x2, y2)](#quadratic-bezier-curve)
 
@@ -1513,9 +1508,7 @@ Utility class for manipulating Quadratic Bézier curves.
 
 ### CubicBezierCurve <a id="cubic-bezier-curve"></a>
 
-Utility class for manipulating Cubic Bézier curves.
-
-[Extends Curve](#curve)
+Utility class extending [Curve](#curve) for manipulating Cubic Bézier curves.
 
 - [new CubicBezierCurve(x1, y1, cp1x, cp1y, cp2x, cp2y x2, y2)](#cubic-bezier-curve)
 
@@ -1530,13 +1523,11 @@ Utility class for manipulating Cubic Bézier curves.
 | x2        | `number` |         | X-axis coordinate of the end point.            |
 | y2        | `number` |         | Y-axis coordinate of the end point.            |
 
-### CatmulRomCurve <a id="catmul-rom-curve"></a>
-
-Utility class for manipulating Catmull-Rom curves.
+### CatmullRomCurve <a id="catmull-rom-curve"></a>
 
-[Extends Curve](#curve)
+Utility class extending [Curve](#curve) for manipulating Catmull-Rom curves.
 
-- [new CatmulRomCurve(x1, y1, cp1x, cp1y, cp2x, cp2y x2, y2)](#catmul-rom-bezier-curve)
+- [new CatmullRomCurve(x1, y1, cp1x, cp1y, cp2x, cp2y x2, y2)](#catmull-rom-bezier-curve)
 
 | Parameter | Type     | Default | Description                                    |
 | --------- | -------- | ------- | ---------------------------------------------- |
@@ -1551,9 +1542,7 @@ Utility class for manipulating Catmull-Rom curves.
 
 ### SplineCurve <a id="spline-curve"></a>
 
-Utility class for manipulating Spline curves.
-
-[Extends Curve](#curve)
+Utility class extending [Curve](#curve) for manipulating splines.
 
 - [new SplineCurve(points)](#spline-curve)
 
@@ -1563,9 +1552,7 @@ Utility class for manipulating Spline curves.
 
 ### EllipseCurve <a id="ellipse-curve"></a>
 
-Utility class for manipulating Ellipse curves.
-
-[Extends Curve](#curve)
+Utility class extending [Curve](#curve) for manipulating ellipses.
 
 - [new EllipseCurve(cx, cy, rx, ry, rotation, startAngle, endAngle, counterclockwise)](#ellipse-curve)
 
@@ -1582,9 +1569,7 @@ Utility class for manipulating Ellipse curves.
 
 ### ArcCurve <a id="arc-curve"></a>
 
-Utility class for manipulating Arc curves.
-
-[Extends Curve](#curve)
+Utility class extending [Curve](#curve) for manipulating arcs.
 
 - [new ArcCurve(cx, cy, radius, startAngle, endAngle, counterclockwise)](#arc-curve)
 
@@ -1597,109 +1582,97 @@ Utility class for manipulating Arc curves.
 | [endAngle]         | `number`  |         | Rotation angle of the arc (in radians).        |
 | [counterclockwise] | `boolean` |         | Flag indicating the direction of the arc.      |
 
-### PathCurve <a id="path-curve"></a>
-
-Utility class for manipulating connected curves.
+### Path <a id="path"></a>
 
-[Extends Curve](#curve)
+Utility class extending [Curve](#curve) for manipulating connected curves.
 
-- [new PathCurve()](#path-curve)
-  - [.curves](#path-curve-curves): `Curve[]`
-  - [.points](#path-curve-points): `Array<number, number>`
-  - [.autoClose](#path-curve-auto-close): `boolean`
-  - [.add()](#path-curve-add-method): `void`
-  - [.getCurveLengths()](#path-curve-get-curve-lengths-method): `number[]`
-  - [.closePath()](#path-curve-close-path-method): `void`
+- [new Path()](#path)
+  - .isPath: `true`
+  - [.curves](#path-curves): `Curve[]`
+  - [.points](#path-points): `Array<[number, number]>`
+  - [.autoClose](#path-auto-close): `boolean`
+  - [.add()](#path-add-method): `void`
+  - [.getCurveLengths()](#path-get-curve-lengths-method): `number[]`
 
 #### Properties
 
-##### curves <a id="path-curve-curves"></a>
+##### curves <a id="path-curves"></a>
 
 Array of curves composing the path.
 
 ```ts
-PathCurve.curves: Curve[];
+Path.curves: Curve[];
 ```
 
-##### points <a id="path-curve-points"></a>
+##### points <a id="path-points"></a>
 
 Array of points composing the path.
 
 ```ts
-PathCurve.points: Array<[number, number]>;
+Path.points: Array<[number, number]>;
 ```
 
-##### autoClose <a id="path-curve-auto-close"></a>
+##### autoClose <a id="path-auto-close"></a>
 
 ```ts
-PathCurve.autoClose: boolean;
+Path.autoClose: boolean;
 ```
 
 #### Methods
 
-##### add <a id="path-curve-add-method"></a>
+##### add <a id="path-add-method"></a>
 
 Add a curve to this curve path.
 
 - `curve`: Curve to add.
 
 ```ts
-PathCurve.add(curve: Curve): void;
+Path.add(curve: Curve): void;
 ```
 
-##### getCurveLengths <a id="path-curve-get-curve-lengths-method"></a>
+##### getCurveLengths <a id="path-get-curve-lengths-method"></a>
 
 Compute the cumulative curve lengths of the curve path.
 
 ```ts
-PathCurve.getCurveLengths(): number[];
+Path.getCurveLengths(): number[];
 ```
 
-##### closePath <a id="path-curve-close-path-method"></a>
-
-Add a line curve to close the curve path.
-
-```ts
-PathCurve.closePath(): void;
-```
-
-### Path <a id="path"></a>
-
-Utility class for manipulating paths.
-It works by serializing 2D Canvas API to SVG path data.
+### PathContext <a id="path-context"></a>
 
-[Extends PathCurve](#path-curve)
+Utility class extending [Path](#path) providing methods similar to the 2D Canvas API.
 
-- [new Path()](#path)
-- [.currentPosition](#path-current-position): `[number, number]`
-- [.setFromPoints(points)](#path-set-from-points-method): `this`
-- [.moveTo(x, y)](#path-move-to-method): `this`
-- [.lineTo(x, y)](#path-line-to-method): `this`
-- [.polylineTo(points)](#path-polyline-to-method): `this`
-- [.arcTo(x1, y1, x2, y2, radius)](#path-arc-to-method): `this`
-- [.quadraticCurveTo(cpx, cpy, x2, y2)](#path-quadratic-curve-to-method): `this`
-- [.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2)](#path-bezier-curve-to-method): `this`
-- [.catmulRomCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2)](#path-catmul-rom-to-method): `this`
-- [.splineTo(points)](#path-spline-to-method): `this`
-- [.ellipse(cx, cy, rx, ry, rotation, startAngle, endAngle, counterclockwise)](#path-ellipse-method): `this`
-- [.arc(cx, cy, radius, startAngle, endAngle, counterclockwise)](#path-arc-method): `this`
-- [.rect(x, y, width, height)](#path-rect-method): `this`
-- [.roundRect(x, y, width, height, radius)](#path-round-rect-method): `this`
-- [.closePath()](#path-close-path-method): `this`
+- [new PathContext()](#path-context)
+  - [.currentPosition](#path-context-current-position): `[number, number]`
+  - [.setFromPoints(points)](#path-context-set-from-points-method): `this`
+  - [.beginPath()](#path-context-begin-path-method): `this`
+  - [.closePath()](#path-context-close-path-method): `this`
+  - [.moveTo(x, y)](#path-context-move-to-method): `this`
+  - [.lineTo(x, y)](#path-context-line-to-method): `this`
+  - [.polylineTo(points)](#path-context-polyline-to-method): `this`
+  - [.arcTo(x1, y1, x2, y2, radius)](#path-context-arc-to-method): `this`
+  - [.quadraticCurveTo(cpx, cpy, x2, y2)](#path-context-quadratic-curve-to-method): `this`
+  - [.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2)](#path-context-bezier-curve-to-method): `this`
+  - [.catmullRomCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2)](#path-context-catmull-rom-to-method): `this`
+  - [.splineTo(points)](#path-context-spline-to-method): `this`
+  - [.ellipse(cx, cy, rx, ry, rotation, startAngle, endAngle, counterclockwise)](#path-context-ellipse-method): `this`
+  - [.arc(cx, cy, radius, startAngle, endAngle, counterclockwise)](#path-context-arc-method): `this`
+  - [.rect(x, y, width, height)](#path-context-rect-method): `this`
+  - [.roundRect(x, y, width, height, radius)](#path-context-round-rect-method): `this`
 
 #### Properties
 
-##### currentPosition <a id="path-current-position"></a>
+##### currentPosition <a id="path-context-current-position"></a>
 
 Path current offset position.
 
 ```ts
-Path.currentPosition: [number, number];
+PathContext.currentPosition: [number, number];
 ```
 
 #### Methods
 
-##### setFromPoints(points) <a id="path-set-from-points-method"></a>
+##### setFromPoints(points) <a id="path-context-set-from-points-method"></a>
 
 Create a path from the given list of points.
 
@@ -1707,10 +1680,28 @@ Create a path from the given list of points.
 - `[type]`: Type of curve used for creating the path.
 
 ```ts
-Path.setFromPoints(points: Array<[number, number]>, type?: 'lines' | 'polyline' | 'spline'): this;
+PathContext.setFromPoints(points: Array<[number, number]>, type?: 'lines' | 'polyline' | 'spline'): this;
+```
+
+##### beginPath() <a id="path-context-begin-path-method"></a>
+
+Begin the path.
+Reset `currentPosition`.
+
+```ts
+PathContext.beginPath(): this;
 ```
 
-##### moveTo(x, y) <a id="path-move-to-method"></a>
+##### closePath <a id="path-context-close-path-method"></a>
+
+Draw a line from the ending position to the beginning position of the path.
+Add an instance of [LineCurve](#line-curve) to the path.
+
+```ts
+PathContext.closePath(): this;
+```
+
+##### moveTo(x, y) <a id="path-context-move-to-method"></a>
 
 Move `currentPosition` to the coordinates specified by `x` and `y`.
 
@@ -1718,10 +1709,10 @@ Move `currentPosition` to the coordinates specified by `x` and `y`.
 - `y`: Y-axis coordinate of the point.
 
 ```ts
-Path.moveTo(x: number, y: number): this;
+PathContext.moveTo(x: number, y: number): this;
 ```
 
-##### lineTo(x, y) <a id="path-line-to-method"></a>
+##### lineTo(x, y) <a id="path-context-line-to-method"></a>
 
 Draw a line from the current position to the position specified by `x` and `y`.
 Add an instance of [LineCurve](#line-curve) to the path.
@@ -1730,10 +1721,10 @@ Add an instance of [LineCurve](#line-curve) to the path.
 - `y`: Y-axis coordinate of the point.
 
 ```ts
-Path.lineTo(x: number, y: number): this;
+PathContext.lineTo(x: number, y: number): this;
 ```
 
-##### polylineTo(points) <a id="path-polyline-to-method"></a>
+##### polylineTo(points) <a id="path-context-polyline-to-method"></a>
 
 Draw a Polyline curve from the current position through the given points.
 Add an instance of [PolylineCurve](#polyline-curve) to the path.
@@ -1741,10 +1732,10 @@ Add an instance of [PolylineCurve](#polyline-curve) to the path.
 - `points`: Array of points defining the curve.
 
 ```ts
-Path.polylineTo(points: Array<[number, number]>): this;
+PathContext.polylineTo(points: Array<[number, number]>): this;
 ```
 
-##### arcTo(x1, y1, x2, y2, radius) <a id="path-arc-to-method"></a>
+##### arcTo(x1, y1, x2, y2, radius) <a id="path-context-arc-to-method"></a>
 
 Draw an Arc curve from the current position, tangential to the 2 segments created by both control points
 Add an instance of [ArcCurve](#arc-curve) to the path.
@@ -1756,10 +1747,10 @@ Add an instance of [ArcCurve](#arc-curve) to the path.
 - `radius`: Arc radius (Must be non-negative).
 
 ```ts
-Path.arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): this;
+PathContext.arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): this;
 ```
 
-##### quadraticCurveTo(cpx, cpy, x2, y2) <a id="path-quadratic-curve-to-method"></a>
+##### quadraticCurveTo(cpx, cpy, x2, y2) <a id="path-context-quadratic-curve-to-method"></a>
 
 Draw a Quadratic Bézier curve from the current position to the end point specified by `x` and `y`, using the control point specified by `cpx` and `cpy`.
 Add an instance of [QuadraticBezierCurve](#quadratic-bezier-curve) to the path.
@@ -1770,10 +1761,10 @@ Add an instance of [QuadraticBezierCurve](#quadratic-bezier-curve) to the path.
 - `y2`: Y-axis coordinate of the end point.
 
 ```ts
-Path.quadraticCurveTo(cpx: number, cpy: number, x2: number, y2: number): this;
+PathContext.quadraticCurveTo(cpx: number, cpy: number, x2: number, y2: number): this;
 ```
 
-##### bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2) <a id="path-bezier-curve-to-method"></a>
+##### bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2) <a id="path-context-bezier-curve-to-method"></a>
 
 Draw a Cubic Bézier curve from the current position to the end point specified by `x` and `y`, using the control point specified by (`cp1x`, `cp1y`) and (`cp2x`, `cp2y`).
 Add an instance of [CubicBezierCurve](#cubic-bezier-curve) to the path.
@@ -1786,13 +1777,13 @@ Add an instance of [CubicBezierCurve](#cubic-bezier-curve) to the path.
 - `y2`: Y-axis coordinate of the end point.
 
 ```ts
-Path.bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x2: number, y2: number): this;
+PathContext.bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x2: number, y2: number): this;
 ```
 
-##### catmulRomCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2) <a id="path-catmul-rom-curve-to-method"></a>
+##### catmullRomCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2) <a id="path-context-catmull-rom-curve-to-method"></a>
 
-Draw a Catmul-Rom curve from the current position to the end point specified by `x` and `y`, using the control points specified by (`cp1x`, `cp1y`) and (`cp2x`, `cp2y`).
-Add an instance of [CatmullRomCurve](#catmul-rom-curve) to the path.
+Draw a Catmull-Rom curve from the current position to the end point specified by `x` and `y`, using the control points specified by (`cp1x`, `cp1y`) and (`cp2x`, `cp2y`).
+Add an instance of [CatmullRomCurve](#catmull-rom-curve) to the path.
 
 - `cp1x`: X-axis coordinate of the first control point.
 - `cp1y`: Y-axis coordinate of the first control point.
@@ -1802,10 +1793,10 @@ Add an instance of [CatmullRomCurve](#catmul-rom-curve) to the path.
 - `y2`: Y-axis coordinate of the end point.
 
 ```ts
-Path.catmulRomCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x2: number, y2: number): this;
+PathContext.catmullRomCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x2: number, y2: number): this;
 ```
 
-##### splineTo(points) <a id="path-spline-to-method"></a>
+##### splineTo(points) <a id="path-context-spline-to-method"></a>
 
 Draw a Spline curve from the current position through the given points.
 Add an instance of [SplineCurve](#spline-curve) to the path.
@@ -1813,10 +1804,10 @@ Add an instance of [SplineCurve](#spline-curve) to the path.
 - `points`: Array of points defining the curve.
 
 ```ts
-Path.splineTo(points: Array<[number, number]>): this;
+PathContext.splineTo(points: Array<[number, number]>): this;
 ```
 
-##### ellipse(cx, cy, rx, ry, rotation, startAngle, endAngle, counterclockwise) <a id="path-ellipse-method"></a>
+##### ellipse(cx, cy, rx, ry, rotation, startAngle, endAngle, counterclockwise) <a id="path-context-ellipse-method"></a>
 
 Draw an Ellispe curve which is centered at (`cx`, `cy`) position.
 Add an instance of [EllipseCurve](#ellipse-curve) to the path.
@@ -1831,10 +1822,10 @@ Add an instance of [EllipseCurve](#ellipse-curve) to the path.
 - `[counterclockwise]`: Flag indicating the direction of the arc.
 
 ```ts
-Path.ellipse(cx: number, cy: number, rx: number, ry: number, rotation?: number, startAngle?: number, endAngle?: number, counterclockwise?: boolean): this;
+PathContext.ellipse(cx: number, cy: number, rx: number, ry: number, rotation?: number, startAngle?: number, endAngle?: number, counterclockwise?: boolean): this;
 ```
 
-##### arc(cx, cy, radius, startAngle, endAngle, counterclockwise) <a id="path-arc-method"></a>
+##### arc(cx, cy, radius, startAngle, endAngle, counterclockwise) <a id="path-context-arc-method"></a>
 
 Draw an Arc curve which is centered at (`cx`, `cy`) position.
 Add an instance of [ArcCurve](#arc-curve) to the path.
@@ -1847,10 +1838,10 @@ Add an instance of [ArcCurve](#arc-curve) to the path.
 - `[counterclockwise]`: Flag indicating the direction of the arc.
 
 ```ts
-Path.arc(cx: number, cy: number, radius: number, startAngle?: number, endAngle?: number, counterclockwise?: boolean): this;
+PathContext.arc(cx: number, cy: number, radius: number, startAngle?: number, endAngle?: number, counterclockwise?: boolean): this;
 ```
 
-##### rect(x, y, width, height) <a id="path-rect-method"></a>
+##### rect(x, y, width, height) <a id="path-context-rect-method"></a>
 
 Draw a rectangular path from the start position specified by `x` and `y` to the end position using `width` and `height`.
 Add an instance of [PolylineCurve](#polyline-curve) to the path.
@@ -1861,10 +1852,10 @@ Add an instance of [PolylineCurve](#polyline-curve) to the path.
 - `height`: Rectangle height (Positive values are down, and negative are up).
 
 ```ts
-Path.rect(x: number, y: number, width: number, height: number): this;
+PathContext.rect(x: number, y: number, width: number, height: number): this;
 ```
 
-##### roundRect(x, y, width, height, radius) <a id="path-round-rect-method"></a>
+##### roundRect(x, y, width, height, radius) <a id="path-context-round-rect-method"></a>
 
 Draw a rounded rectangular path from the start position specified by `x` and `y` to the end position using `width` and `height`.
 
@@ -1875,47 +1866,109 @@ Draw a rounded rectangular path from the start position specified by `x` and `y`
 - `radius`: Radius of the circular arc to be used for the corners of the rectangle.
 
 ```ts
-Path.roundRect(x: number, y: number, width: number, height: number, radius: number | number[]): this;
+PathContext.roundRect(x: number, y: number, width: number, height: number, radius: number | number[]): this;
 ```
 
-##### closePath() <a id="path-close-path-method"></a>
+### PathSVG <a id="path-svg"></a>
 
-Add a line curve to close the curve path.
-Add an instance of [LineCurve](#line-curve) to the path.
+Utility class extending [PathContext](#path-context) for manipulating connected curves and generating SVG path.
+It works by serializing 2D Canvas API to SVG path data.
+
+- [new PathSVG()](#path-svg-constructor)
+  - `static` [.serialize(curve, params)](#path-svg-static-serialize-method): `string`
+  - `static` [.serializeLineCurve(curve)](#path-svg-static-serialize-line-curve-method): `string`
+  - `static` [.serializePolylineCurve(curve)](#path-svg-static-serialize-polyline-curve-method): `string`
+  - `static` [.serializeQuadraticBezierCurve(curve)](#path-svg-static-serialize-quadratic-bezier-curve-method): `string`
+  - `static` [.serializeCubicBezierCurve(curve)](#path-svg-static-serialize-cubic-bezier-curve-method): `string`
+  - `static` [.serializeCatmullRomCurve(curve, params)](#path-svg-static-serialize-catmull-rom-curve-method): `string`
+  - `static` [.serializeSplineCurve(curve, params)](#path-svg-static-serialize-spline-curve-method): `string`
+  - `static` [.serializeEllipseCurve(curve)](#path-svg-static-serialize-ellipse-curve-method): `string`
+  - `static` [.serializeArcCurve(curve)](#path-svg-static-serialize-arc-curve-method): `string`
+  - [.toString(params)](#path-svg-to-string-method): `string`
+
+#### Methods
+
+##### serialize(curve) <a id="path-svg-static-serialize-method"></a>
+
+Serialize a [Curve](#curve)
 
 ```ts
-Path.closePath(): this;
+static PathSVG.serialize(curve: Curve, params: object): string;
 ```
 
-### PathSVG <a id="path-svg"></a>
+##### serializeLineCurve(curve) <a id="path-svg-static-serialize-line-curve-method"></a>
 
-Utility class for manipulating paths and generating SVG path.
-It works by serializing 2D Canvas API to SVG path data.
+Serialize a [LineCurve](#line-curve)
 
-[Extends Path](#path)
+```ts
+static PathSVG.serializeLineCurve(curve: LineCurve): string;
+```
 
-- [new PathSVG()](#path-svg-constructor)
-  - [.curveResolution](#path-svg-curve-resolution): `number`
-  - [.toString()](#path-svg-to-string-method): `string`
+##### serializePolylineCurve(curve) <a id="path-svg-static-serialize-polyline-method"></a>
 
-#### Properties
+Serialize a [PolylineCurve](#polyline-curve).
 
-##### curveResolution <a id="path-svg-curve-resolution"></a>
+```ts
+static PathSVG.serializePolylineCurve(curve: PolylineCurve): string;
+```
 
-Resolution used for Catmul-Rom curve and Spline curve approximations.
+##### serializeQuadraticBezierCurve(curve) <a id="path-svg-static-serialize-quadratic-bezier-method"></a>
+
+Serialize a [QuadraticBezierCurve](#quadratic-bezier-curve).
 
 ```ts
-PathSVG.curveResolution: number;
+static PathSVG.serializeQuadraticBezierCurve(curve: QuadraticBezierCurve): string;
 ```
 
-#### Methods
+##### serializeCubicBezierCurve(curve) <a id="path-svg-static-serialize-cubic-bezier-method"></a>
+
+Serialize a [CubicBezierCurve](#cubic-bezier-curve).
 
-##### toString() <a id="path-svg-to-string-method"></a>
+```ts
+static PathSVG.serializeCubicBezierCurve(curve: CubicBezierCurve): string;
+```
+
+##### serializeCatmullRomCurve(curve) <a id="path-svg-static-serialize-catmull-rom-method"></a>
+
+Serialize a [CatmullRomCurve](#catmull-rom-curve).
+
+```ts
+static PathSVG.serializeCatmullRomCurve(curve: CatmullRomCurve, params: object): string;
+```
+
+##### serializeSplineCurve(curve) <a id="path-svg-static-serialize-spline-method"></a>
+
+Serialize a [SplineCurve](#spline-curve).
+
+```ts
+static PathSVG.serializeSplineCurve(curve: SplineCurve, params: object): string;
+```
+
+##### serializeEllipseCurve(curve) <a id="path-svg-static-serialize-ellipse-method"></a>
+
+Serialize a [EllipseCurve](#ellipse-curve).
+
+```ts
+static PathSVG.serializeEllipseCurve(curve: EllipseCurve): string;
+```
+
+##### serializeArcCurve(curve) <a id="path-svg-static-serialize-arc-method"></a>
+
+Serialize a [ArcCurve](#arc-curve).
+
+```ts
+static PathSVG.serializeArcCurve(curve: ArcCurve): string;
+```
+
+##### toString(params) <a id="path-svg-to-string-method"></a>
 
 Return SVG path data string.
 
+- `[params]`
+- `[params.curveResolution=5]`: Resolution used for Catmull-Rom curves and Spline curves approximations.
+
 ```ts
-PathSVG.toString(): string;
+PathSVG.toString(params: object): string;
 ```
 
 ### Color scale

package/lib/extras/curves/ArcCurve.d.ts

@@ -1,6 +1,6 @@
 import EllipseCurve from './EllipseCurve';
 /**
- * Utility class for manipulating Arc curves
+ * Utility class for manipulating arcs
  *
  * @exports
  * @class ArcCurve

package/lib/extras/curves/ArcCurve.js

@@ -1,6 +1,6 @@
 import EllipseCurve from './EllipseCurve';
 /**
- * Utility class for manipulating Arc curves
+ * Utility class for manipulating arcs
  *
  * @exports
  * @class ArcCurve

package/lib/extras/curves/CatmullRomCurve.d.ts

@@ -0,0 +1,62 @@
+import type { Point } from '../../types';
+import Curve from './Curve';
+/**
+ * Utility class for manipulating Catmull-Rom curves
+ *
+ * @exports
+ * @class CatmullRomCurve
+ * @extends Curve
+ */
+export default class CatmullRomCurve extends Curve {
+    readonly type: string;
+    /**
+     * X-axis coordinate of the start point
+     */
+    x1: number;
+    /**
+     * Y-axis coordinate of the start point
+     */
+    y1: number;
+    /**
+     * X-axis coordinate of the first control point
+     */
+    cp1x: number;
+    /**
+     * Y-axis coordinate of the first control point
+     */
+    cp1y: number;
+    /**
+     * X-axis coordinate of the second control point
+     */
+    cp2x: number;
+    /**
+     * Y-axis coordinate of the second control point
+     */
+    cp2y: number;
+    /**
+     * X-axis coordinate of the end point
+     */
+    x2: number;
+    /**
+     * Y-axis coordinate of the end point
+     */
+    y2: number;
+    /**
+     * @param {number} x1   X-axis coordinate of the start point
+     * @param {number} y1   Y-axis coordinate of the start point
+     * @param {number} cp1x X-axis coordinate of the first control point
+     * @param {number} cp1y Y-axis coordinate of the first control point
+     * @param {number} cp2x X-axis coordinate of the second control point
+     * @param {number} cp2y Y-axis coordinate of the second control point
+     * @param {number} x2   X-axis coordinate of the end point
+     * @param {number} y2   Y-axis coordinate of the end point
+     */
+    constructor(x1: number, y1: number, cp1x: number, cp1y: number, cp2x: number, cp2y: number, x2: number, y2: number);
+    /**
+     * Interpolate a point on the Catmull-Rom curve
+     *
+     * @param {number} t Normalized time value to interpolate
+     * @returns {Point} Interpolated coordinates on the curve
+     */
+    getPoint(t: number): Point;
+}