toosoon-utils 4.3.0 → 4.4.0

package/lib/extras/paths/Path.js

@@ -65,8 +65,7 @@ export default class Path extends Curve {
     getPoints(divisions = 40) {
         const points = [];
         let lastPoint = null;
-        for (let i = 0; i < this.curves.length; i++) {
-            const curve = this.curves[i];
+        for (const curve of this.curves) {
             let resolution = divisions;
             if (curve instanceof LineCurve || curve instanceof LineCurve3) {
                 resolution = 1;
@@ -80,9 +79,7 @@ export default class Path extends Curve {
             else if (curve instanceof EllipseCurve) {
                 resolution *= 2;
             }
-            const pts = this.curves[i].getPoints(resolution);
-            for (let j = 0; j < pts.length; j++) {
-                const point = pts[j];
+            for (const point of curve.getPoints(resolution)) {
                 if (point?.equals(lastPoint))
                     continue;
                 points.push(point);
@@ -132,8 +129,8 @@ export default class Path extends Curve {
         }
         const lengths = [];
         let sums = 0;
-        for (let i = 0, j = this.curves.length; i < j; i++) {
-            sums += this.curves[i].getLength();
+        for (const curve of this.curves) {
+            sums += curve.getLength();
             lengths.push(sums);
         }
         this._cacheArcLengths = lengths;

package/lib/extras/paths/PathContext.d.ts

@@ -13,6 +13,8 @@ export default class PathContext extends Path<Vector2> implements CanvasRenderin
     protected _currentPosition: Vector2;
     protected _currentTransform: DOMMatrix;
     private _transformStack;
+    readonly autoClose: false;
+    constructor();
     /**
      * Create a path from a given list of points
      *
@@ -111,7 +113,7 @@ export default class PathContext extends Path<Vector2> implements CanvasRenderin
      * @param {number} cy Y-axis coordinate of the center of the circle
      * @param {number} rx X-radius of the ellipse
      * @param {number} ry Y-radius of the ellipse
-     * @param {number} rotation 	Rotation angle of the ellipse (in radians), counterclockwise from the positive X-axis
+     * @param {number} rotation Rotation angle of the ellipse (in radians), counterclockwise from the positive X-axis
      * @param {number} startAngle Start angle of the arc (in radians)
      * @param {number} endAngle   End angle of the arc (in radians)
      * @param {boolean} [counterclockwise] Flag indicating the direction of the arc
@@ -147,9 +149,9 @@ export default class PathContext extends Path<Vector2> implements CanvasRenderin
      * 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 {@link PolylineCurve} to this path
      *
-     * @param {number} x 		  X-axis coordinate of the rectangle starting point
-     * @param {number} y      Y-axis coordinate of the rectangle starting point
-     * @param {number} width	Rectangle width (Positive values are to the right and negative to the left)
+     * @param {number} x X-axis coordinate of the rectangle starting point
+     * @param {number} y Y-axis coordinate of the rectangle starting point
+     * @param {number} width  Rectangle width (Positive values are to the right and negative to the left)
      * @param {number} height Rectangle height (Positive values are down, and negative are up)
      * @return {this}
      */
@@ -158,9 +160,9 @@ export default class PathContext extends Path<Vector2> implements CanvasRenderin
      * Draw a rounded rectangular path from the start position specified by `x` and `y` to the end position using `width` and `height`
      * Add an instance of {@link Path} to this path
      *
-     * @param {number} x 		  X-axis coordinate of the rectangle starting point
-     * @param {number} y      Y-axis coordinate of the rectangle starting point
-     * @param {number} width	Rectangle width (Positive values are to the right and negative to the left)
+     * @param {number} x X-axis coordinate of the rectangle starting point
+     * @param {number} y Y-axis coordinate of the rectangle starting point
+     * @param {number} width  Rectangle width (Positive values are to the right and negative to the left)
      * @param {number} height Rectangle height (Positive values are down, and negative are up)
      * @param {number|number[]} radius Radius of the circular arc to be used for the corners of the rectangle
      * @return {this}
@@ -204,7 +206,6 @@ export default class PathContext extends Path<Vector2> implements CanvasRenderin
     getLineDash: CanvasRenderingContext2D['getLineDash'];
     fillText: CanvasRenderingContext2D['fillText'];
     strokeText: CanvasRenderingContext2D['strokeText'];
-    miterLimit: CanvasRenderingContext2D['miterLimit'];
     fill: CanvasRenderingContext2D['fill'];
     stroke: CanvasRenderingContext2D['stroke'];
     clearRect: CanvasRenderingContext2D['clearRect'];
@@ -213,6 +214,7 @@ export default class PathContext extends Path<Vector2> implements CanvasRenderin
     drawImage: CanvasRenderingContext2D['drawImage'];
     clip: CanvasRenderingContext2D['clip'];
     filter: CanvasRenderingContext2D['filter'];
+    miterLimit: CanvasRenderingContext2D['miterLimit'];
     globalAlpha: CanvasRenderingContext2D['globalAlpha'];
     globalCompositeOperation: CanvasRenderingContext2D['globalCompositeOperation'];
     createLinearGradient: CanvasRenderingContext2D['createLinearGradient'];

package/lib/extras/paths/PathContext.js

@@ -15,6 +15,11 @@ export default class PathContext extends Path {
     _currentPosition = new Vector2(NaN, NaN);
     _currentTransform = new DOMMatrix();
     _transformStack = [];
+    autoClose;
+    constructor() {
+        super({ autoClose: false });
+        this.autoClose = false;
+    }
     /**
      * Create a path from a given list of points
      *
@@ -23,8 +28,8 @@ export default class PathContext extends Path {
      */
     setFromPoints(points) {
         this.moveTo(...points[0]);
-        for (let i = 1, l = points.length; i < l; i++) {
-            this.lineTo(...points[i]);
+        for (const point of points) {
+            this.lineTo(...point);
         }
         return this;
     }
@@ -187,7 +192,7 @@ export default class PathContext extends Path {
      * @param {number} cy Y-axis coordinate of the center of the circle
      * @param {number} rx X-radius of the ellipse
      * @param {number} ry Y-radius of the ellipse
-     * @param {number} rotation 	Rotation angle of the ellipse (in radians), counterclockwise from the positive X-axis
+     * @param {number} rotation Rotation angle of the ellipse (in radians), counterclockwise from the positive X-axis
      * @param {number} startAngle Start angle of the arc (in radians)
      * @param {number} endAngle   End angle of the arc (in radians)
      * @param {boolean} [counterclockwise] Flag indicating the direction of the arc
@@ -280,8 +285,7 @@ export default class PathContext extends Path {
         const c = t1.clone().add(n1.clone().multiplyScalar(normalLength));
         const startAngle = Math.atan2(t1.y - c.y, t1.x - c.x);
         const endAngle = Math.atan2(t2.y - c.y, t2.x - c.x);
-        const deltaAngle = endAngle - startAngle;
-        const counterclockwise = deltaAngle < 0;
+        const counterclockwise = (p0.y - p1.y) * (p2.x - p0.x) <= (p0.x - p1.x) * (p2.y - p0.y);
         t1.applyMatrix(this._currentTransform);
         t2.applyMatrix(this._currentTransform);
         c.applyMatrix(this._currentTransform);
@@ -299,9 +303,9 @@ export default class PathContext extends Path {
      * 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 {@link PolylineCurve} to this path
      *
-     * @param {number} x 		  X-axis coordinate of the rectangle starting point
-     * @param {number} y      Y-axis coordinate of the rectangle starting point
-     * @param {number} width	Rectangle width (Positive values are to the right and negative to the left)
+     * @param {number} x X-axis coordinate of the rectangle starting point
+     * @param {number} y Y-axis coordinate of the rectangle starting point
+     * @param {number} width  Rectangle width (Positive values are to the right and negative to the left)
      * @param {number} height Rectangle height (Positive values are down, and negative are up)
      * @return {this}
      */
@@ -320,9 +324,9 @@ export default class PathContext extends Path {
      * Draw a rounded rectangular path from the start position specified by `x` and `y` to the end position using `width` and `height`
      * Add an instance of {@link Path} to this path
      *
-     * @param {number} x 		  X-axis coordinate of the rectangle starting point
-     * @param {number} y      Y-axis coordinate of the rectangle starting point
-     * @param {number} width	Rectangle width (Positive values are to the right and negative to the left)
+     * @param {number} x X-axis coordinate of the rectangle starting point
+     * @param {number} y Y-axis coordinate of the rectangle starting point
+     * @param {number} width  Rectangle width (Positive values are to the right and negative to the left)
      * @param {number} height Rectangle height (Positive values are down, and negative are up)
      * @param {number|number[]} radius Radius of the circular arc to be used for the corners of the rectangle
      * @return {this}
@@ -338,7 +342,7 @@ export default class PathContext extends Path {
         topRightRadius = Math.min(topRightRadius, maxRadius);
         bottomRightRadius = Math.min(bottomRightRadius, maxRadius);
         bottomLeftRadius = Math.min(bottomLeftRadius, maxRadius);
-        const curve = new PathContext({ autoClose: true });
+        const curve = new PathContext();
         curve.setTransform(this.getTransform());
         // Top-Right corner
         if (topRightRadius > 0) {
@@ -372,7 +376,9 @@ export default class PathContext extends Path {
         else {
             curve.lineTo(x, y);
         }
+        curve.closePath();
         this.add(curve);
+        this.moveTo(x, y);
         return this;
     }
     setTransform(a, b, c, d, e, f) {
@@ -503,7 +509,6 @@ export default class PathContext extends Path {
     getLineDash;
     fillText;
     strokeText;
-    miterLimit;
     fill;
     stroke;
     clearRect;
@@ -512,6 +517,7 @@ export default class PathContext extends Path {
     drawImage;
     clip;
     filter;
+    miterLimit;
     globalAlpha;
     globalCompositeOperation;
     createLinearGradient;

package/lib/files.d.ts

@@ -1,14 +1,35 @@
+/**
+ * Load a file
+ *
+ * @param {File} file File to load
+ * @returns {Promise<string>} Data URL of the file
+ */
+export declare function load(file: File): Promise<string>;
 /**
  * Download a Blob object into user files
  *
- * @param {Blob} blob       Blob object to download
- * @param {string} filename Downloaded file name
+ * @param {Blob} blob Blob object to download
+ * @param {Object} params Download parameters
+ * @param {string} params.filename Downloaded file name
  */
-export declare function download(blob: Blob, filename: string): void;
+export declare function download(blob: Blob, { filename }: {
+    filename: string;
+}): void;
 /**
  * Upload a file from user files
  *
- * @param {Function} onLoad    Callback called once the file is loaded
+ * @param {Function} onLoad Callback called once the file is loaded
  * @param {string} [accept=''] MIME type the file input should accept
  */
 export declare function upload(onLoad: (dataUrl: string) => void, accept?: string): void;
+/**
+ * Share a Blob object with the user's device
+ *
+ * @param {Blob} blob Blob object to share
+ * @param {ShareData} params Share parameters
+ * @param {string} params.filename Shared file name
+ * @returns {Promise<void>}
+ */
+export declare function share(blob: Blob, { filename, ...data }: {
+    filename: string;
+} & ShareData): Promise<void>;

package/lib/files.js

@@ -1,10 +1,25 @@
+/**
+ * Load a file
+ *
+ * @param {File} file File to load
+ * @returns {Promise<string>} Data URL of the file
+ */
+export async function load(file) {
+    return await new Promise((resolve, reject) => {
+        const fileReader = new FileReader();
+        fileReader.addEventListener('load', () => resolve(URL.createObjectURL(file)));
+        fileReader.addEventListener('error', () => reject(new Error(`Failed to load file: ${file.name}`)));
+        fileReader.readAsDataURL(file);
+    });
+}
 /**
  * Download a Blob object into user files
  *
- * @param {Blob} blob       Blob object to download
- * @param {string} filename Downloaded file name
+ * @param {Blob} blob Blob object to download
+ * @param {Object} params Download parameters
+ * @param {string} params.filename Downloaded file name
  */
-export function download(blob, filename) {
+export function download(blob, { filename }) {
     const link = document.createElement('a');
     link.setAttribute('href', URL.createObjectURL(blob));
     link.setAttribute('download', filename);
@@ -15,7 +30,7 @@ export function download(blob, filename) {
 /**
  * Upload a file from user files
  *
- * @param {Function} onLoad    Callback called once the file is loaded
+ * @param {Function} onLoad Callback called once the file is loaded
  * @param {string} [accept=''] MIME type the file input should accept
  */
 export function upload(onLoad, accept = '') {
@@ -34,3 +49,27 @@ export function upload(onLoad, accept = '') {
     input.click();
     document.body.removeChild(input);
 }
+/**
+ * Share a Blob object with the user's device
+ *
+ * @param {Blob} blob Blob object to share
+ * @param {ShareData} params Share parameters
+ * @param {string} params.filename Shared file name
+ * @returns {Promise<void>}
+ */
+export async function share(blob, { filename, ...data }) {
+    const file = new File([blob], filename, { type: blob.type });
+    try {
+        if (!navigator?.canShare({ files: [file] })) {
+            const error = new Error(`Failed to share file: ${filename}`);
+            error.name = 'NotAllowedError';
+            throw error;
+        }
+        await navigator.share({ files: [file], ...data });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'NotAllowedError') {
+            download(blob, { filename });
+        }
+    }
+}

package/lib/functions.d.ts

@@ -14,7 +14,7 @@ export declare function wait(delay?: number): Promise<void>;
  * Create a debounced function that delays the execution of `callback` until a specified `delay` time has passed since the last call
  *
  * @param {Function} callback Function to debounce
- * @param {number} delay      Delay (in milliseconds)
+ * @param {number} delay Delay (in milliseconds)
  * @returns {Function} Debounced function
  */
 export declare function debounce<T extends (...args: any[]) => void>(callback: T, delay: number): (...args: Parameters<T>) => void;
@@ -29,7 +29,7 @@ export declare function isDefined<T>(value: T): value is Exclude<T, undefined |
  * Create a throttled function that limits the execution of `callback` to once every `limit` time
  *
  * @param {Function} callback Function to throttle
- * @param {number} limit      Minimum interval between two calls (in milliseconds)
+ * @param {number} limit Minimum interval between two calls (in milliseconds)
  * @returns {Function} Throttled function
  */
 export declare function throttle<T extends (...args: any[]) => void>(callback: T, limit: number): (...args: Parameters<T>) => void;

package/lib/functions.js

@@ -15,7 +15,7 @@ export function wait(delay = 0) {
  * Create a debounced function that delays the execution of `callback` until a specified `delay` time has passed since the last call
  *
  * @param {Function} callback Function to debounce
- * @param {number} delay      Delay (in milliseconds)
+ * @param {number} delay Delay (in milliseconds)
  * @returns {Function} Debounced function
  */
 export function debounce(callback, delay) {
@@ -41,7 +41,7 @@ export function isDefined(value) {
  * Create a throttled function that limits the execution of `callback` to once every `limit` time
  *
  * @param {Function} callback Function to throttle
- * @param {number} limit      Minimum interval between two calls (in milliseconds)
+ * @param {number} limit Minimum interval between two calls (in milliseconds)
  * @returns {Function} Throttled function
  */
 export function throttle(callback, limit) {

package/lib/geometry.d.ts

@@ -13,30 +13,30 @@ export declare function toDegrees(radians: number): number;
  */
 export declare function toRadians(degrees: number): number;
 /**
- * Calculate the angle from a point to another
+ * Calculate the angle (in radians) from a point to another
  *
  * @param  {number} x1 X-axis coordinate of the start point
  * @param  {number} y1 Y-axis coordinate of the start point
  * @param  {number} x2 X-axis coordinate of the end point
  * @param  {number} y2 Y-axis coordinate of the end point
- * @returns {number} Angle
+ * @returns {number} Angle (in radians)
  */
 export declare function angle(x1: number, y1: number, x2: number, y2: number): number;
 /**
- * Find the closest angle between to angles
+ * Find the closest angle (in radians) between two angles
  *
- * @param {number} source Source angle (in radians)
- * @param {number} target Target angle (in radians)
- * @returns {number} Closest angle
+ * @param {number} startAngle Start angle (in radians)
+ * @param {number} endAngle   End angle (in radians)
+ * @returns {number} Closest angle (in radians)
  */
-export declare function closestAngle(source: number, target: number): number;
+export declare function closestAngle(startAngle: number, endAngle: number): number;
 /**
  * Calculate the distance between two points
  *
- * @param {number} x1 X-axis coordinate of the first point
- * @param {number} y1 Y-axis coordinate of the first point
- * @param {number} x2 X-axis coordinate of the second point
- * @param {number} y2 Y-axis coordinate of the second point
+ * @param {number} x1 X-axis coordinate of the start point
+ * @param {number} y1 Y-axis coordinate of the start point
+ * @param {number} x2 X-axis coordinate of the end point
+ * @param {number} y2 Y-axis coordinate of the end point
  * @returns {number} Computed distance
  */
 export declare function distance(x1: number, y1: number, x2: number, y2: number): number;
@@ -62,7 +62,7 @@ export type FitOutput = {
 /**
  * Make a target fit a container (cover mode)
  *
- * @param {FitInput} target    Dimensions of the target
+ * @param {FitInput} target Dimensions of the target
  * @param {FitInput} container Dimensions of the container
  * @returns {FitOutput}
  */
@@ -70,7 +70,7 @@ export declare function cover(target: FitInput, container: FitInput): FitOutput;
 /**
  * Make a target fit a container (contain mode)
  *
- * @param {FitInput} target    Dimensions of the target
+ * @param {FitInput} target Dimensions of the target
  * @param {FitInput} container Dimensions of the container
  * @returns {FitOutput}
  */

package/lib/geometry.js

@@ -18,35 +18,35 @@ export function toRadians(degrees) {
     return (degrees * PI) / 180;
 }
 /**
- * Calculate the angle from a point to another
+ * Calculate the angle (in radians) from a point to another
  *
  * @param  {number} x1 X-axis coordinate of the start point
  * @param  {number} y1 Y-axis coordinate of the start point
  * @param  {number} x2 X-axis coordinate of the end point
  * @param  {number} y2 Y-axis coordinate of the end point
- * @returns {number} Angle
+ * @returns {number} Angle (in radians)
  */
 export function angle(x1, y1, x2, y2) {
     return Math.atan2(y2 - y1, x2 - x1);
 }
 /**
- * Find the closest angle between to angles
+ * Find the closest angle (in radians) between two angles
  *
- * @param {number} source Source angle (in radians)
- * @param {number} target Target angle (in radians)
- * @returns {number} Closest angle
+ * @param {number} startAngle Start angle (in radians)
+ * @param {number} endAngle   End angle (in radians)
+ * @returns {number} Closest angle (in radians)
  */
-export function closestAngle(source, target) {
-    const delta = target - source;
-    return delta > PI ? target - 2 * PI : target < -PI ? delta + 2 * PI : target;
+export function closestAngle(startAngle, endAngle) {
+    const delta = endAngle - startAngle;
+    return delta > PI ? endAngle - 2 * PI : endAngle < -PI ? delta + 2 * PI : endAngle;
 }
 /**
  * Calculate the distance between two points
  *
- * @param {number} x1 X-axis coordinate of the first point
- * @param {number} y1 Y-axis coordinate of the first point
- * @param {number} x2 X-axis coordinate of the second point
- * @param {number} y2 Y-axis coordinate of the second point
+ * @param {number} x1 X-axis coordinate of the start point
+ * @param {number} y1 Y-axis coordinate of the start point
+ * @param {number} x2 X-axis coordinate of the end point
+ * @param {number} y2 Y-axis coordinate of the end point
  * @returns {number} Computed distance
  */
 export function distance(x1, y1, x2, y2) {
@@ -67,10 +67,10 @@ export function diagonal(width, height) {
 /**
  * Make a target fit a container
  *
- * @param {object} target    Dimensions of the target
- * @param {object} container Dimensions of the container
- * @param {string} mode      Can be 'contain' | 'cover'
- * @returns {object}
+ * @param {FitInput} target Dimensions of the target
+ * @param {FitInput} container Dimensions of the container
+ * @param {string} mode Can be 'contain' | 'cover'
+ * @returns {FitOutput}
  */
 function fit(target, container, mode) {
     const ratioWidth = container.width / target.width;
@@ -93,7 +93,7 @@ function fit(target, container, mode) {
 /**
  * Make a target fit a container (cover mode)
  *
- * @param {FitInput} target    Dimensions of the target
+ * @param {FitInput} target Dimensions of the target
  * @param {FitInput} container Dimensions of the container
  * @returns {FitOutput}
  */
@@ -103,7 +103,7 @@ export function cover(target, container) {
 /**
  * Make a target fit a container (contain mode)
  *
- * @param {FitInput} target    Dimensions of the target
+ * @param {FitInput} target Dimensions of the target
  * @param {FitInput} container Dimensions of the container
  * @returns {FitOutput}
  */

package/lib/maths.d.ts

@@ -22,7 +22,7 @@ export declare function isPowerOf2(value: number): boolean;
 /**
  * Find closest power of 2 that fits a number
  *
- * @param {number} value         Incoming value
+ * @param {number} value Incoming value
  * @param {string} [mode='ceil'] Can be 'floor' | 'ceil' | 'round'
  * @returns {number} Computed power of 2
  */
@@ -37,7 +37,7 @@ export declare function sign(value: number): number;
 /**
  * Clamp a value between two bounds
  *
- * @param {number} value   Value to clamp
+ * @param {number} value Value to clamp
  * @param {number} [min=0] Minimum boundary
  * @param {number} [max=1] Maximum boundary
  * @returns {number} Clamped value
@@ -46,7 +46,7 @@ export declare function clamp(value: number, min?: number, max?: number): number
 /**
  * Round a number up to a nearest multiple
  *
- * @param {number} value        Value to round
+ * @param {number} value Value to round
  * @param {number} [multiple=1] Multiple to round to
  * @returns {number} Closest multiple
  */
@@ -54,7 +54,7 @@ export declare function snap(value: number, multiple?: number): number;
 /**
  * Interpolate a value between two values using Linear interpolation (lerping)
  *
- * @param {number} t   Normalized time value to interpolate
+ * @param {number} t Normalized time value to interpolate
  * @param {number} min Minimum value
  * @param {number} max Maximum value
  * @returns {number} Lerped value
@@ -64,28 +64,28 @@ export declare function lerp(t: number, min: number, max: number): number;
  * Normalize a value between two bounds
  *
  * @param {number} value Value to normalize
- * @param {number} min   Minimum boundary
- * @param {number} max   Maximum boundary
+ * @param {number} min Minimum boundary
+ * @param {number} max Maximum boundary
  * @returns {number} Normalized value
  */
 export declare function normalize(value: number, min: number, max: number): number;
 /**
  * Re-map a number from one range to another
  *
- * @param {number} value      Value to re-map
+ * @param {number} value Value to re-map
  * @param {number} currentMin Lower bound of the value's current range
  * @param {number} currentMax Upper bound of the value's current range
- * @param {number} targetMin  Lower bound of the value's target range
- * @param {number} targetMax  Upper bound of the value's target range
+ * @param {number} targetMin Lower bound of the value's target range
+ * @param {number} targetMax Upper bound of the value's target range
  * @returns {number} Re-mapped value
  */
 export declare function map(value: number, currentMin: number, currentMax: number, targetMin: number, targetMax: number): number;
 /**
  * Interpolate a value between two values using Triangular interpolation
  *
- * @param {number} t    Normalized time value to interpolate
- * @param {number} min  Minimum value
- * @param {number} max  Maximum value
+ * @param {number} t Normalized time value to interpolate
+ * @param {number} min Minimum value
+ * @param {number} max Maximum value
  * @param {number} peak Peak value controling the interpolation triangle shape
  *                        - peak <= min : linear (same as lerp)
  *                        - peak <= max : linear (same as lerp)
@@ -96,9 +96,9 @@ export declare function triLerp(t: number, min: number, max: number, peak: numbe
 /**
  * Interpolate a value using Exponential interpolation
  *
- * @param {number} t     Normalized time value to interpolate
- * @param {number} min   Minimum value
- * @param {number} max   Maximum value
+ * @param {number} t Normalized time value to interpolate
+ * @param {number} min Minimum value
+ * @param {number} max Maximum value
  * @param {number} power Exponent controling the interpolation curve shape
  *                         - power > 1 : ease-in
  *                         - power < 1 : ease-out
@@ -109,7 +109,7 @@ export declare function expLerp(t: number, min: number, max: number, power: numb
 /**
  * Interpolate a value using Quadratic Bézier interpolation
  *
- * @param {number} t  Normalized time value to interpolate
+ * @param {number} t Normalized time value to interpolate
  * @param {number} p1 Start point
  * @param {number} cp Control point
  * @param {number} p2 End point
@@ -119,7 +119,7 @@ export declare function quadraticBezier(t: number, p1: number, cp: number, p2: n
 /**
  * Interpolate a value using Cubic Bézier interpolation
  *
- * @param {number} t   Normalized time value to interpolate
+ * @param {number} t Normalized time value to interpolate
  * @param {number} p1  Start point
  * @param {number} cp1 First control point
  * @param {number} cp2 Second control point
@@ -130,7 +130,7 @@ export declare function cubicBezier(t: number, p1: number, cp1: number, cp2: num
 /**
  * Interpolate a value using Catmull-Rom interpolation
  *
- * @param {number} t   Normalized time value to interpolate
+ * @param {number} t Normalized time value to interpolate
  * @param {number} p1  Start point
  * @param {number} cp1 First control point
  * @param {number} cp2 Second control point
@@ -141,7 +141,7 @@ export declare function catmullRom(t: number, p1: number, cp1: number, cp2: numb
 /**
  * Modulo absolute a value based on a length
  *
- * @param {number} value  Value to modulate
+ * @param {number} value Value to modulate
  * @param {number} length Total length
  * @returns {number} Modulated value
  */
@@ -149,7 +149,7 @@ export declare function modAbs(value: number, length: number): number;
 /**
  * Move back and forth a value between 0 and length, so that it is never larger than length and never smaller than 0
  *
- * @param {number} value  Value to modulate
+ * @param {number} value Value to modulate
  * @param {number} length Total length
  * @returns {number} PingPonged value
  */
@@ -157,7 +157,7 @@ export declare function pingPong(value: number, length: number): number;
 /**
  * Smooth a value using cubic Hermite interpolation
  *
- * @param {number} value   Value to smooth
+ * @param {number} value Value to smooth
  * @param {number} [min=0] Minimum boundary
  * @param {number} [max=1] Maximum boundary
  * @returns {number} Normalized smoothed value
@@ -168,7 +168,7 @@ export declare function smoothstep(value: number, min?: number, max?: number): n
  *  - parabola(0) = parabola(1) = 0
  *  - parabola(0.5) = 1
  *
- * @param {number} x         Normalized coordinate on X axis
+ * @param {number} x Normalized coordinate on X axis
  * @param {number} [power=1] Parabola power
  * @returns {number} Normalized re-mapped value
  */
@@ -190,10 +190,10 @@ export declare function average(array: number[]): number;
 /**
  * Smoothly interpolate a number toward another
  *
- * @param {number} value   Value to interpolate
- * @param {number} target  Destination of the interpolation
+ * @param {number} value Value to interpolate
+ * @param {number} target Destination of the interpolation
  * @param {number} damping A higher value will make the movement more sudden, and a lower value will make the movement more gradual
- * @param {number} delta   Delta time (in seconds)
+ * @param {number} delta Delta time (in seconds)
  * @returns {number} Interpolated number
  */
 export declare function damp(value: number, target: number, damping: number, delta: number): number;