toosoon-utils 4.1.9 → 4.2.0

package/README.md

@@ -398,32 +398,6 @@ Calculate the distance between two points.
 distance(x1: number, y1: number, x2: number, y2: number): number;
 ```
 
-##### dot(x1, y1, x2, y2)
-
-Calculate the dot product of two vectors.
-
-- `x1`: X-axis coordinate of the first vector.
-- `y1`: Y-axis coordinate of the first vector.
-- `x2`: X-axis coordinate of the second vector.
-- `y2`: Y-axis coordinate of the second vector.
-
-```ts
-dot(x1: number, y1: number, x2: number, y2: number): number;
-```
-
-##### cross(x1, y1, x2, y2)
-
-Calculate the cross product of two vectors.
-
-- `x1`: X-axis coordinate of the first vector.
-- `y1`: Y-axis coordinate of the first vector.
-- `x2`: X-axis coordinate of the second vector.
-- `y2`: Y-axis coordinate of the second vector.
-
-```ts
-cross(x1: number, y1: number, x2: number, y2: number): number;
-```
-
 ##### diagonal(width, height)
 
 Calculate the length of the diagonal of a rectangle.
@@ -435,201 +409,6 @@ Calculate the length of the diagonal of a rectangle.
 diagonal(width: number, height: number): number;
 ```
 
-##### radToSphere(radius, phi, theta)
-
-Convert radians to a 3D point on the surface of a unit sphere.
-
-- `radius`: Radius of the sphere.
-- `phi`: Polar angle from the y (up) axis [0, PI].
-- `theta`: Equator angle around the y (up) axis [0, 2*PI].
-- `[target]`: Target vector.
-
-```ts
-radToSphere(radius: number, phi: number, theta: number, target?: [number, number, number]): [number, number, number];
-```
-
-#### Curves
-
-##### line(t, x1, y1, x2, y2)
-
-Interpolate a point on line.
-
-- `t`: Normalized time value to interpolate.
-- `x1`: X-axis coordinate of the start point.
-- `y1`: Y-axis coordinate of the start point.
-- `x2`: X-axis coordinate of the end point.
-- `y2`: Y-axis coordinate of the end point.
-
-```ts
-line(
-  t: number,
-  x1: number,
-  y1: number,
-  x2: number,
-  y2: number
-): [number, number];
-```
-
-##### quadraticBezier(t, x1, y1, cpx, cpy, x2, y2)
-
-Interpolate a point on Quadratic Bézier curve.
-
-- `t`: Normalized time value to interpolate.
-- `x1`: X-axis coordinate of the start point.
-- `y1`: Y-axis coordinate of the start point.
-- `cpx`: X-axis coordinate of the control point.
-- `cpy`: Y-axis coordinate of the control point.
-- `x2`: X-axis coordinate of the end point.
-- `y2`: Y-axis coordinate of the end point.
-
-```ts
-quadraticBezier(
-  t: number,
-  x1: number,
-  y1: number,
-  cpx: number,
-  cpy: number,
-  x2: number,
-  y2: number
-): [number, number];
-```
-
-##### cubicBezier(t, x1, y1, cp1x, cp1y, cp2x, cp2y, x2, y2)
-
-Interpolate a point on Cubic Bézier curve.
-
-- `t`: Normalized time value to interpolate.
-- `x1`: X-axis coordinate of the start point.
-- `y1`: Y-axis coordinate of the start point.
-- `cp1x`: X-axis coordinate of the first control point.
-- `cp1y`: Y-axis coordinate of the first control point.
-- `cp2x`: X-axis coordinate of the second control point.
-- `cp2y`: Y-axis coordinate of the second control point.
-- `x2`: X-axis coordinate of the end point.
-- `y2`: Y-axis coordinate of the end point.
-
-```ts
-cubicBezier(
-  t: number,
-  x1: number,
-  y1: number,
-  cp1x: number,
-  cp1y: number,
-  cp2x: number,
-  cp2y: number,
-  x2: number,
-  y2: number
-): [number, number];
-```
-
-##### catmullRom(t, x1, y1, cp1x, cpy1, cp2x, cp2y, x2, y2)
-
-Interpolate a point on a Catmull-Rom spline.
-
-- `t`: Normalized time value to interpolate.
-- `x1`: X-axis coordinate of the start point.
-- `y1`: Y-axis coordinate of the start point.
-- `cp1x`: X-axis coordinate of the first control point.
-- `cp1y`: Y-axis coordinate of the first control point.
-- `cp2x`: X-axis coordinate of the second control point.
-- `cp2y`: Y-axis coordinate of the second control point.
-- `x2`: X-axis coordinate of the end point.
-- `y2`: Y-axis coordinate of the end point.
-
-```ts
-catmullRom(
-  t: number,
-  x1: number,
-  y1: number,
-  cp1x: number,
-  cp1y: number,
-  cp2x: number,
-  cp2y: number,
-  x2: number,
-  y2: number
-): [number, number];
-```
-
-##### ellipse(t, cx, cy, rx, ry, rotation, startAngle, endAngle, counterclockwise)
-
-Interpolate a point on an elliptical arc.
-
-- `t`: Normalized time value to interpolate.
-- `cx`: X-axis coordinate of the center of the ellipse.
-- `cy`: Y-axis coordinate of the center of the ellipse.
-- `rx`: X-radius of the ellipse.
-- `ry`: Y-radius of the ellipse.
-- `[rotation=0]`: Rotation angle of the ellipse (in radians), counterclockwise from the positive X-axis.
-- `[startAngle=0]`: Start angle of the arc (in radians).
-- `[endAngle=TWO_PI]`: Rotation angle of the arc (in radians).
-- `[counterclockwise=false]`: Flag indicating the direction of the arc.
-
-```ts
-ellipse(
-  t: number,
-  cx: number,
-  cy: number,
-  rx: number,
-  ry: number,
-  rotation?: number,
-  startAngle?: number,
-  endAngle?: number,
-  counterclockwise?: boolean
-): [number, number];
-```
-
-##### arc(t, cx, cy, radius, startAngle, endAngle, counterclockwise)
-
-Interpolate a point on a circular arc.
-
-- `t`: Normalized time value to interpolate.
-- `cx`: X-axis coordinate of the center of the circle.
-- `cy`: Y-axis coordinate of the center of the circle.
-- `radius`: Radius of the circle.
-- `[startAngle]`: Start angle of the arc (in radians).
-- `[endAngle]`: End angle of the arc (in radians).
-- `[counterclockwise=false]`: Flag indicating the direction of the arc.
-
-```ts
-arc(
-  t: number,
-  cx: number,
-  cy: number,
-  radius: number,
-  startAngle?: number,
-  endAngle?: number,
-  counterclockwise?: boolean
-): [number, number];
-```
-
-##### isCoincident(x1, y1, x2, y2)
-
-Check if two points are coincident.
-
-- `x1`: X-axis coordinate of the first point.
-- `y1`: Y-axis coordinate of the first point.
-- `x2`: X-axis coordinate of the second point.
-- `y2`: Y-axis coordinate of the second point.
-
-```ts
-isCoincident(x1: number, y1: number, x2: number, y2: number): boolean;
-```
-
-##### isCollinear(x1, y1, x2, y2, x3, y3)
-
-Check if 3 points are collinear.
-
-- `x1`: X-axis coordinate of the first point.
-- `y1`: Y-axis coordinate of the first point.
-- `x2`: X-axis coordinate of the second point.
-- `y2`: Y-axis coordinate of the second point.
-- `x3`: Y-axis coordinate of the third point.
-- `y3`: Y-axis coordinate of the third point.
-
-```ts
-isCollinear(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): boolean;
-```
-
 #### Fit
 
 ```ts
@@ -734,9 +513,20 @@ Clamp a value between two bounds.
 clamp(value: number, min?: number, max?: number): number;
 ```
 
+##### snap(value, multiple)
+
+Round a number up to a nearest multiple.
+
+- `value`: Value to round.
+- `[multiple=1]`: Multiple to round to.
+
+```ts
+snap(value: number, multiple?: number): number;
+```
+
 ##### lerp(t, min, max)
 
-Linear interpolation between two values (lerping).
+Interpolate a value between two values using Linear interpolation (lerping).
 
 - `t`: Normalized time value to interpolate.
 - `min`: Minimum value.
@@ -746,9 +536,35 @@ Linear interpolation between two values (lerping).
 lerp(t: number, min: number, max: number): number;
 ```
 
+##### normalize(value, min, max)
+
+Normalize a value between two bounds.
+
+- `value`: Value to normalize.
+- `min`: Minimum boundary.
+- `max`: Maximum boundary.
+
+```ts
+normalize(value: number, min: number, max: number): number;
+```
+
+##### map(value, currentMin, currentMax, targetMin, targetMax)
+
+Re-map a number from one range to another.
+
+- `value`: Value to re-map.
+- `currentMin`: Lower bound of the value's current range.
+- `currentMax`: Upper bound of the value's current range.
+- `targetMin`: Lower bound of the value's target range.
+- `targetMax`: Upper bound of the value's target range.
+
+```ts
+map(value: number, currentMin: number, currentMax: number, targetMin: number, targetMax: number): number;
+```
+
 ##### triLerp(t, min, max, target)
 
-Triangular interpolation between two values.
+Interpolate a value between two values using Triangular interpolation.
 
 - `t`: Normalized time value to interpolate.
 - `min`: Minimum value.
@@ -761,7 +577,7 @@ triLerp(t: number, min: number, max: number, target: number): number;
 
 ##### expLerp(t, currentMin, currentMax, targetMin, targetMax)
 
-Exponential interpolation between two values.
+Interpolate a value using Exponential interpolation.
 
 - `t`: Normalized time value to interpolate.
 - `currentMin`: Lower bound of the value's current range.
@@ -773,41 +589,45 @@ Exponential interpolation between two values.
 expLerp(t: number, currentMin: number, currentMax: number, targetMin: number, targetMax: number): number;
 ```
 
-##### normalize(value, min, max)
+##### quadraticBezier(t, p1, cp, p2)
 
-Normalize a value between two bounds.
+Interpolate a value using Quadratic Bézier interpolation.
 
-- `value`: Value to normalize.
-- `min`: Minimum boundary.
-- `max`: Maximum boundary.
+- `t`: Normalized time value to interpolate.
+- `p1`: Start point.
+- `cp`: Control point.
+- `p2`: End point.
 
 ```ts
-normalize(value: number, min: number, max: number): number;
+quadraticBezier(t: number, p1: number, cp: number, p2: number): number;
 ```
 
-##### map(value, currentMin, currentMax, targetMin, targetMax)
+##### cubicBezier(t, p1, cp1, cp2, p2)
 
-Re-map a number from one range to another.
+Interpolate a value using Cubic Bézier interpolation.
 
-- `value`: Value to re-map.
-- `currentMin`: Lower bound of the value's current range.
-- `currentMax`: Upper bound of the value's current range.
-- `targetMin`: Lower bound of the value's target range.
-- `targetMax`: Upper bound of the value's target range.
+- `t`: Normalized time value to interpolate.
+- `p1`: Start point.
+- `cp1`: First control point.
+- `cp2`: Second control point.
+- `p2`: End point.
 
 ```ts
-map(value: number, currentMin: number, currentMax: number, targetMin: number, targetMax: number): number;
+cubicBezier(t: number, p1: number, cp1: number, cp2: number, p2: number): number;
 ```
 
-##### snap(value, multiple)
+##### catmullRom(t, p1, cp1, cp2, p2)
 
-Round a number up to a nearest multiple.
+Interpolate a value using Catmull-Rom interpolation.
 
-- `value`: Value to round.
-- `[multiple=1]`: Multiple to round to.
+- `t`: Normalized time value to interpolate.
+- `p1`: Start point.
+- `cp1`: First control point.
+- `cp2`: Second control point.
+- `p2`: End point.
 
 ```ts
-snap(value: number, multiple?: number): number;
+catmullRom(t: number, p1: number, cp1: number, cp2: number, p2: number): number;
 ```
 
 ##### modAbs(value, length)
@@ -987,10 +807,9 @@ randomGaussian(mean?: number, spread?: number): number;
 Produce a random 2D point around the perimiter of a unit circle.
 
 - `[radius=1]`: Radius of the circle.
-- `[target]`: Target vector.
 
 ```ts
-onCircle(radius?: number, target?: [number, number]): [number, number];
+onCircle(radius?: number): [number, number];
 ```
 
 ##### insideCircle(radius)
@@ -998,32 +817,29 @@ onCircle(radius?: number, target?: [number, number]): [number, number];
 Produce a random 2D point inside a unit circle.
 
 - `[radius=1]`: Radius of the circle.
-- `[target]` Target vector.
 
 ```ts
-insideCircle(radius?: number, target?: [number, number]): [number, number];
+insideCircle(radius?: number): [number, number];
 ```
 
 ##### onSphere(radius)
 
-Produce a random 3D point on the surface of a unit sphere.
+Produce a random 3D point on the surface of a sphere.
 
 - `[radius=1]`: Radius of the sphere.
-- `[target]`: Target vector.
 
 ```ts
-onSphere(radius?: number, target?: [number, number, number]): [number, number, number];
+onSphere(radius?: number): [number, number, number];
 ```
 
 ##### insideSphere(radius)
 
-Produce a random 3D point inside a unit sphere.
+Produce a random 3D point inside a sphere.
 
 - `[radius=1]`: Radius of the sphere.
-- `[target]`: Target vector.
 
 ```ts
-insideSphere(radius?: number, target?: [number, number, number]): [number, number, number];
+insideSphere(radius?: number): [number, number, number];
 ```
 
 ### Pseudo-Random Number Generator (PRNG)
@@ -1345,657 +1161,57 @@ removeTrailingSlash(path: string): string;
 
 ## Utility classes
 
-Utility classes for manipulating curves.
-
-### Curve <a id="curve"></a>
-
-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]`
-  - [.getPointAt(u)](#curve-get-point-at-method): `[number, number]`
-  - [.getPoints(divisions)](#curve-get-points-method): `Array<[number, number]>`
-  - [.getSpacedPoints(divisions)](#curve-get-spaced-points-method): `Array<[number, number]>`
-  - [.getLengths()](#curve-get-length-method): `number`
-  - [.getLengths()](#curve-get-lengths-method): `number[]`
-  - [.updateArcLengths()](#curve-update-arc-lengths-method): `void`
-  - [.getUtoTmapping(t, targetArcLength)](#curve-get-u-to-t-mapping-method): `number`
-  - [.getTangent(t)](#curve-get-tangent-method): `[number, number]`
-  - [.getTangentAt(u)](#curve-get-tangent-at-method): `[number, number]`
-  - `static` [.isClosed(points)](#curve-static-is-closed-method): `boolean`
-
-#### Properties
-
-##### arcLengthDivisions <a id="curve-arc-length-divisions"></a>
-
-Amount of divisions when calculating the cumulative segment lengths of a curve.
-
-```ts
-Curve.arcLengthDivisions: number;
-```
-
-##### needsUpdate <a id="curve-needs-update"></a>
-
-Must be set to `true` if the curve parameters have changed.
-
-```ts
-Curve.needsUpdate: boolean;
-```
-
-#### Methods
-
-##### getPoint(t) <a id="curve-get-point-method"></a>
-
-Interpolate a point on the curve.
-
-- `u`: Normalized time value to interpolate.
-
-```ts
-Curve.getPoint(t: number): [number, number];
-```
-
-##### getPointAt(u) <a id="curve-get-point-at-method"></a>
-
-Interpolate a point on the curve.
-
-- `u`: Normalized position value to interpolate.
-
-```ts
-Curve.getPointAt(u: number): [number, number];
-```
-
-##### getPoints(divisions) <a id="curve-get-points-method"></a>
-
-Compute the curve shape into an array of points.
-
-- `[divisions=5]`: Number of divisions.
-
-```ts
-Curve.getPoints(divisions?: number): Array<[number, number]>;
-```
-
-##### getSpacedPoints(divisions) <a id="curve-get-spaced-points-method"></a>
-
-Compute the curve shape into an array of equi-spaced points across the entire curve.
-
-- `[divisions=5]`: Number of divisions.
-
-```ts
-Curve.getSpacedPoints(divisions?: number): Array<[number, number]>;
-```
-
-##### getLength() <a id="curve-get-lengt-methodh"></a>
-
-Compute the total arc length of the curve.
-
-```ts
-Curve.getLength(): number;
-```
-
-##### getLengths() <a id="curve-get-lengths-method"></a>
-
-Compute the cumulative segment lengths of the curve.
-
-- `[divisions]`: Number of divisions.
-
-```ts
-Curve.getLengths(divisions?: number): number[];
-```
-
-##### updateArcLengths() <a id="curve-get-point-method"></a>
-
-Update the cached cumulative segment lengths.
-
-```ts
-Curve.updateArcLengths(): void;
-```
-
-##### getUtoTmapping(t, targetArcLength) <a id="curve-get-u-to-t)mapping-method"></a>
-
-Re-map a normalized position value into normalized time.
-
-- `u`: Normalized position value to interpolate.
-- `[targetArcLength]`: Distance on the curve.
-
-```ts
-Curve.getUtoTmapping(u: number, targetArcLength?: number): number;
-```
-
-##### getTangent(t) <a id="curve-get-tangent-method"></a>
-
-Compute an unit vector tangent for the given normalized time value.
-
-- `t`: Normalized time value.
-
-```ts
-Curve.getTangent(t: number): [number, number];
-```
-
-##### getTangentAt(u) <a id="curve-get-tangent-at-method"></a>
-
-Compute an unit vector tangent for the given normalized position value.
-
-- `u`: Normalized position value.
-
-```ts
-Curve.getTangentAt(u: number): [number, number];
-```
-
-##### `static` isClosed(points) <a id="curve-static-is-closed-method"></a>
-
-Static method to check if given points are defining a closed curve.
-
-- `points`: Points to check.
-
-```ts
-static Curve.isClosed(points: Array<[number, number]>): boolean;
-```
-
-### LineCurve <a id="line-curve"></a>
-
-Utility class extending [Curve](#curve) for manipulating lines.
-
-- [new LineCurve(x1, y1, x2, y2)](#line-curve)
-
-| Parameter | Type     | Default | Description                           |
-| --------- | -------- | ------- | ------------------------------------- |
-| x1        | `number` |         | X-axis coordinate of the start point. |
-| y1        | `number` |         | Y-axis coordinate of the start point. |
-| x2        | `number` |         | X-axis coordinate of the end point.   |
-| y2        | `number` |         | Y-axis coordinate of the end point.   |
-
-### PolylineCurve <a id="polyline-curve"></a>
-
-Utility class extending [Curve](#curve) for manipulating polylines.
-
-- [new PolylineCurve(points)](#polyline-curve)
-
-| Parameter | Type                      | Default | Description                         |
-| --------- | ------------------------- | ------- | ----------------------------------- |
-| [points]  | `Array<[number, number]>` | `[]`    | Array of points defining the curve. |
-
-### QuadraticBezierCurve <a id="quadratic-bezier-curve"></a>
-
-Utility class extending [Curve](#curve) for manipulating Quadratic Bézier curves.
-
-- [new QuadraticBezierCurve(x1, y1, cpx, cpy, x2, y2)](#quadratic-bezier-curve)
-
-| Parameter | Type     | Default | Description                             |
-| --------- | -------- | ------- | --------------------------------------- |
-| x1        | `number` |         | X-axis coordinate of the start point.   |
-| y1        | `number` |         | Y-axis coordinate of the start point.   |
-| cpx       | `number` |         | X-axis coordinate of the control point. |
-| cpy       | `number` |         | Y-axis coordinate of the control point. |
-| x2        | `number` |         | X-axis coordinate of the end point.     |
-| y2        | `number` |         | Y-axis coordinate of the end point.     |
-
-### CubicBezierCurve <a id="cubic-bezier-curve"></a>
-
-Utility class extending [Curve](#curve) for manipulating Cubic Bézier curves.
-
-- [new CubicBezierCurve(x1, y1, cp1x, cp1y, cp2x, cp2y x2, y2)](#cubic-bezier-curve)
-
-| Parameter | Type     | Default | Description                                    |
-| --------- | -------- | ------- | ---------------------------------------------- |
-| x1        | `number` |         | X-axis coordinate of the start point.          |
-| y1        | `number` |         | Y-axis coordinate of the start point.          |
-| cp1x      | `number` |         | X-axis coordinate of the first control point.  |
-| cp1y      | `number` |         | Y-axis coordinate of the first control point.  |
-| cp2x      | `number` |         | X-axis coordinate of the second control point. |
-| cp2y      | `number` |         | Y-axis coordinate of the second control point. |
-| x2        | `number` |         | X-axis coordinate of the end point.            |
-| y2        | `number` |         | Y-axis coordinate of the end point.            |
-
-### CatmullRomCurve <a id="catmull-rom-curve"></a>
-
-Utility class extending [Curve](#curve) for manipulating Catmull-Rom curves.
-
-- [new CatmullRomCurve(x1, y1, cp1x, cp1y, cp2x, cp2y x2, y2)](#catmull-rom-bezier-curve)
-
-| Parameter | Type     | Default | Description                                    |
-| --------- | -------- | ------- | ---------------------------------------------- |
-| x1        | `number` |         | X-axis coordinate of the start point.          |
-| y1        | `number` |         | Y-axis coordinate of the start point.          |
-| cp1x      | `number` |         | X-axis coordinate of the first control point.  |
-| cp1y      | `number` |         | Y-axis coordinate of the first control point.  |
-| cp2x      | `number` |         | X-axis coordinate of the second control point. |
-| cp2y      | `number` |         | Y-axis coordinate of the second control point. |
-| x2        | `number` |         | X-axis coordinate of the end point.            |
-| y2        | `number` |         | Y-axis coordinate of the end point.            |
-
-### SplineCurve <a id="spline-curve"></a>
-
-Utility class extending [Curve](#curve) for manipulating splines.
-
-- [new SplineCurve(points)](#spline-curve)
-
-| Parameter | Type                      | Default | Description                         |
-| --------- | ------------------------- | ------- | ----------------------------------- |
-| [points]  | `Array<[number, number]>` | `[]`    | Array of points defining the curve. |
-
-### EllipseCurve <a id="ellipse-curve"></a>
-
-Utility class extending [Curve](#curve) for manipulating ellipses.
-
-- [new EllipseCurve(cx, cy, rx, ry, rotation, startAngle, endAngle, counterclockwise)](#ellipse-curve)
-
-| Parameter          | Type      | Default | Description                                                                            |
-| ------------------ | --------- | ------- | -------------------------------------------------------------------------------------- |
-| cx                 | `number`  |         | X-axis coordinate of the center of the ellipse.                                        |
-| cy                 | `number`  |         | Y-axis coordinate of the center of the ellipse.                                        |
-| rx                 | `number`  |         | X-radius of the ellipse.                                                               |
-| ry                 | `number`  |         | Y-radius of the ellipse.                                                               |
-| [rotation]         | `number`  |         | Rotation angle of the ellipse (in radians), counterclockwise from the positive X-axis. |
-| [startAngle]       | `number`  |         | Rotation angle of the arc (in radians).                                                |
-| [endAngle]         | `number`  |         | Rotation angle of the arc (in radians).                                                |
-| [counterclockwise] | `boolean` |         | Flag indicating the direction of the arc.                                              |
-
-### ArcCurve <a id="arc-curve"></a>
-
-Utility class extending [Curve](#curve) for manipulating arcs.
-
-- [new ArcCurve(cx, cy, radius, startAngle, endAngle, counterclockwise)](#arc-curve)
-
-| Parameter          | Type      | Default | Description                                    |
-| ------------------ | --------- | ------- | ---------------------------------------------- |
-| cx                 | `number`  |         | X-axis coordinate of the center of the circle. |
-| cy                 | `number`  |         | Y-axis coordinate of the center of the circle. |
-| radius             | `number`  |         | X-radius of the circle.                        |
-| [startAngle]       | `number`  |         | Rotation angle of the arc (in radians).        |
-| [endAngle]         | `number`  |         | Rotation angle of the arc (in radians).        |
-| [counterclockwise] | `boolean` |         | Flag indicating the direction of the arc.      |
-
-### Path <a id="path"></a>
-
-Utility class extending [Curve](#curve) for manipulating connected curves.
-
-- [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-curves"></a>
-
-Array of curves composing the path.
-
-```ts
-Path.curves: Curve[];
-```
-
-##### points <a id="path-points"></a>
-
-Array of points composing the path.
-
-```ts
-Path.points: Array<[number, number]>;
-```
-
-##### autoClose <a id="path-auto-close"></a>
-
-```ts
-Path.autoClose: boolean;
-```
-
-#### Methods
-
-##### add <a id="path-add-method"></a>
-
-Add a curve to this curve path.
-
-- `curve`: Curve to add.
-
-```ts
-Path.add(curve: Curve): void;
-```
-
-##### getCurveLengths <a id="path-get-curve-lengths-method"></a>
-
-Compute the cumulative curve lengths of the curve path.
-
-```ts
-Path.getCurveLengths(): number[];
-```
-
-### PathContext <a id="path-context"></a>
-
-Utility class extending [Path](#path) providing methods similar to the 2D Canvas API.
-
-- [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-context-current-position"></a>
-
-Path current offset position.
-
-```ts
-PathContext.currentPosition: [number, number];
-```
-
-#### Methods
-
-##### setFromPoints(points) <a id="path-context-set-from-points-method"></a>
-
-Create a path from the given list of points.
-
-- `points`: Array of points defining the path.
-- `[type]`: Type of curve used for creating the path.
-
-```ts
-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;
-```
-
-##### 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`.
-
-- `x`: X-axis coordinate of the point.
-- `y`: Y-axis coordinate of the point.
-
-```ts
-PathContext.moveTo(x: number, y: number): this;
-```
-
-##### 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.
-
-- `x`: X-axis coordinate of the point.
-- `y`: Y-axis coordinate of the point.
-
-```ts
-PathContext.lineTo(x: number, y: number): this;
-```
-
-##### 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.
-
-- `points`: Array of points defining the curve.
-
-```ts
-PathContext.polylineTo(points: Array<[number, number]>): this;
-```
-
-##### 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.
-
-- `x1`: X-axis coordinate of the first control point.
-- `y1`: Y-axis coordinate of the first control point.
-- `x2`: X-axis coordinate of the second control point.
-- `y2`: Y-axis coordinate of the second control point.
-- `radius`: Arc radius (Must be non-negative).
-
-```ts
-PathContext.arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): this;
-```
-
-##### 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.
-
-- `cpx`: X-axis coordinate of the control point.
-- `cpy`: Y-axis coordinate of the control point.
-- `x2`: X-axis coordinate of the end point.
-- `y2`: Y-axis coordinate of the end point.
-
-```ts
-PathContext.quadraticCurveTo(cpx: number, cpy: number, x2: number, y2: number): this;
-```
-
-##### 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.
-
-- `cp1x`: X-axis coordinate of the first control point.
-- `cp1y`: Y-axis coordinate of the first control point.
-- `cp2x`: X-axis coordinate of the second control point.
-- `cp2y`: Y-axis coordinate of the second control point.
-- `x2`: X-axis coordinate of the end point.
-- `y2`: Y-axis coordinate of the end point.
-
-```ts
-PathContext.bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x2: number, y2: number): this;
-```
-
-##### catmullRomCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2) <a id="path-context-catmull-rom-curve-to-method"></a>
-
-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.
-- `cp2x`: X-axis coordinate of the second control point.
-- `cp2y`: Y-axis coordinate of the second control point.
-- `x2`: X-axis coordinate of the end point.
-- `y2`: Y-axis coordinate of the end point.
-
-```ts
-PathContext.catmullRomCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x2: number, y2: number): this;
-```
-
-##### 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.
-
-- `points`: Array of points defining the curve.
-
-```ts
-PathContext.splineTo(points: Array<[number, number]>): this;
-```
-
-##### 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.
-
-- `cx`: X-axis coordinate of the center of the ellipse.
-- `cy`: Y-axis coordinate of the center of the ellipse.
-- `rx`: X-radius of the ellipse.
-- `ry`: Y-radius of the ellipse.
-- `[rotation]`: Rotation angle of the ellipse (in radians), counterclockwise from the positive X-axis.
-- `[startAngle]`: Start angle of the arc (in radians).
-- `[endAngle]`: End angle of the arc (in radians).
-- `[counterclockwise]`: Flag indicating the direction of the arc.
-
-```ts
-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-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.
-
-- `cx`: X-axis coordinate of the center of the circle.
-- `cy`: Y-axis coordinate of the center of the circle.
-- `radius`: Radius of the circle.
-- `[startAngle]`: Start angle of the arc (in radians).
-- `[endAngle]`: End angle of the arc (in radians).
-- `[counterclockwise]`: Flag indicating the direction of the arc.
-
-```ts
-PathContext.arc(cx: number, cy: number, radius: number, startAngle?: number, endAngle?: number, counterclockwise?: boolean): this;
-```
-
-##### 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.
-
-- `x`: X-axis coordinate of the rectangle starting point.
-- `y`: Y-axis coordinate of the rectangle starting point.
-- `width`: Rectangle width (Positive values are to the right and negative to the left).
-- `height`: Rectangle height (Positive values are down, and negative are up).
-
-```ts
-PathContext.rect(x: number, y: number, width: number, height: number): this;
-```
-
-##### 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`.
-
-- `x`: X-axis coordinate of the rectangle starting point.
-- `y`: Y-axis coordinate of the rectangle starting point.
-- `width`: Rectangle width (Positive values are to the right and negative to the left).
-- `height`: Rectangle height (Positive values are down, and negative are up).
-- `radius`: Radius of the circular arc to be used for the corners of the rectangle.
-
-```ts
-PathContext.roundRect(x: number, y: number, width: number, height: number, radius: number | number[]): this;
-```
-
-### PathSVG <a id="path-svg"></a>
-
-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
-static PathSVG.serialize(curve: Curve, params: object): string;
-```
+### Geometry
 
-##### serializeLineCurve(curve) <a id="path-svg-static-serialize-line-curve-method"></a>
+See documentation [here](./docs/GEOMETRY.md).
 
-Serialize a [LineCurve](#line-curve)
+#### [Vector2](./docs//GEOMETRY.md#vector-2)
 
-```ts
-static PathSVG.serializeLineCurve(curve: LineCurve): string;
-```
+#### [Vector3](./docs//GEOMETRY.md#vector-3)
 
-##### serializePolylineCurve(curve) <a id="path-svg-static-serialize-polyline-method"></a>
+### Curves
 
-Serialize a [PolylineCurve](#polyline-curve).
+See documentation [here](./docs/CURVES.md).
 
-```ts
-static PathSVG.serializePolylineCurve(curve: PolylineCurve): string;
-```
+#### [Curve](./docs/CURVES.md#curve)
 
-##### serializeQuadraticBezierCurve(curve) <a id="path-svg-static-serialize-quadratic-bezier-method"></a>
+#### [LineCurve](./docs/CURVES.md#line-curve)
 
-Serialize a [QuadraticBezierCurve](#quadratic-bezier-curve).
+#### [LineCurve3](./docs/CURVES.md#line-curve-3)
 
-```ts
-static PathSVG.serializeQuadraticBezierCurve(curve: QuadraticBezierCurve): string;
-```
-
-##### serializeCubicBezierCurve(curve) <a id="path-svg-static-serialize-cubic-bezier-method"></a>
-
-Serialize a [CubicBezierCurve](#cubic-bezier-curve).
-
-```ts
-static PathSVG.serializeCubicBezierCurve(curve: CubicBezierCurve): string;
-```
+#### [PolylineCurve](./docs/CURVES.md#polyline-curve)
 
-##### serializeCatmullRomCurve(curve) <a id="path-svg-static-serialize-catmull-rom-method"></a>
+#### [PolylineCurve3](./docs/CURVES.md#polyline-curve-3)
 
-Serialize a [CatmullRomCurve](#catmull-rom-curve).
+#### [QuadraticBezierCurve](./docs/CURVES.md#quadratic-bezier-curve)
 
-```ts
-static PathSVG.serializeCatmullRomCurve(curve: CatmullRomCurve, params: object): string;
-```
+#### [QuadraticBezierCurve3](./docs/CURVES.md#quadratic-bezier-curve-3)
 
-##### serializeSplineCurve(curve) <a id="path-svg-static-serialize-spline-method"></a>
+#### [CubicBezierCurve](./docs/CURVES.md#cubic-bezier-curve)
 
-Serialize a [SplineCurve](#spline-curve).
+#### [CubicBezierCurve3](./docs/CURVES.md#cubic-bezier-curve-3)
 
-```ts
-static PathSVG.serializeSplineCurve(curve: SplineCurve, params: object): string;
-```
+#### [CatmullRomCurve](./docs/CURVES.md#catmull-rom-curve)
 
-##### serializeEllipseCurve(curve) <a id="path-svg-static-serialize-ellipse-method"></a>
+#### [CatmullRomCurve3](./docs/CURVES.md#catmull-rom-curve-3)
 
-Serialize a [EllipseCurve](#ellipse-curve).
+#### [SplineCurve](./docs/CURVES.md#spline-curve)
 
-```ts
-static PathSVG.serializeEllipseCurve(curve: EllipseCurve): string;
-```
+#### [SplineCurve3](./docs/CURVES.md#spline-curve-3)
 
-##### serializeArcCurve(curve) <a id="path-svg-static-serialize-arc-method"></a>
+#### [EllipseCurve](./docs/CURVES.md#ellipse-curve)
 
-Serialize a [ArcCurve](#arc-curve).
+#### [ArcCurve](./docs/CURVES.md#arc-curve)
 
-```ts
-static PathSVG.serializeArcCurve(curve: ArcCurve): string;
-```
+### Paths
 
-##### toString(params) <a id="path-svg-to-string-method"></a>
+See documentation [here](./docs/PATHS.md).
 
-Return SVG path data string.
+#### [Path](./docs/PATHS.md#path)
 
-- `[params]`
-- `[params.curveResolution=5]`: Resolution used for Catmull-Rom curves and Spline curves approximations.
+#### [PathContext](./docs/PATHS.md#path-context)
 
-```ts
-PathSVG.toString(params: object): string;
-```
+#### [PathSVG](./docs/PATHS.md#path-svg)
 
 ### Color scale
 
@@ -2065,7 +1281,7 @@ ColorScale.colors: Array<[number, number, number]>;
 
 ##### `static` generate(input, target, length) <a id="color-scale-static-generate-method"></a>
 
-Static method for generating a color scale.
+Generate a color scale.
 
 - `input`: Input color representation.
 - `target`: Target color representation.
@@ -2083,7 +1299,7 @@ static ColorScale.generate(
 
 ##### `static` interpolate(inputColor, targetColor, value) <a id="color-scale-static-interpolate-method"></a>
 
-Static method for interpolating between colors.
+Interpolate between colors.
 
 - `inputColor`: Input color.
 - `targetColor`: Target color.
@@ -2150,8 +1366,6 @@ FrameRate.update(): boolean;
 
 `QUARTER_PI`
 
-`TAU_EPSILON`
-
 ### Colors
 
 `W3CX11`
@@ -2159,5 +1373,3 @@ FrameRate.update(): boolean;
 ## License
 
 MIT License, see [LICENSE](https://github.com/toosoon-dev/toosoon-utils/tree/master/LICENSE) for details.
-
-[![NPM](https://nodei.co/npm/toosoon-utils.png)](https://nodei.co/npm/toosoon-utils/)