toosoon-utils 4.3.1 → 4.4.0

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,21 +13,21 @@ 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} startAngle Start angle (in radians)
- * @param {number} endAngle End angle (in radians)
- * @returns {number} Closest angle
+ * @param {number} endAngle   End angle (in radians)
+ * @returns {number} Closest angle (in radians)
  */
 export declare function closestAngle(startAngle: number, endAngle: 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,23 +18,23 @@ 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} startAngle Start angle (in radians)
- * @param {number} endAngle End angle (in radians)
- * @returns {number} Closest angle
+ * @param {number} endAngle   End angle (in radians)
+ * @returns {number} Closest angle (in radians)
  */
 export function closestAngle(startAngle, endAngle) {
     const delta = endAngle - startAngle;
@@ -67,9 +67,9 @@ export function diagonal(width, height) {
 /**
  * Make a target fit a container
  *
- * @param {FitInput} target    Dimensions of the target
+ * @param {FitInput} target Dimensions of the target
  * @param {FitInput} container Dimensions of the container
- * @param {string} mode        Can be 'contain' | 'cover'
+ * @param {string} mode Can be 'contain' | 'cover'
  * @returns {FitOutput}
  */
 function fit(target, container, mode) {
@@ -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;

package/lib/maths.js

@@ -28,7 +28,7 @@ export function isPowerOf2(value) {
 /**
  * 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
  */
@@ -51,7 +51,7 @@ export function sign(value) {
 /**
  * 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
@@ -62,7 +62,7 @@ export function clamp(value, min = 0, max = 1) {
 /**
  * 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
  */
@@ -74,7 +74,7 @@ export function snap(value, multiple = 1) {
 /**
  * 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
@@ -86,8 +86,8 @@ export function lerp(t, min, max) {
  * 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 function normalize(value, min, max) {
@@ -96,11 +96,11 @@ export function normalize(value, min, max) {
 /**
  * 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 function map(value, currentMin, currentMax, targetMin, targetMax) {
@@ -109,9 +109,9 @@ export function map(value, currentMin, currentMax, targetMin, targetMax) {
 /**
  * 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)
@@ -125,9 +125,9 @@ export function triLerp(t, min, max, peak) {
 /**
  * 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
@@ -141,7 +141,7 @@ export function expLerp(t, min, max, power) {
 /**
  * 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
@@ -156,7 +156,7 @@ export function quadraticBezier(t, p1, cp, p2) {
 /**
  * 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
@@ -174,7 +174,7 @@ export function cubicBezier(t, p1, cp1, cp2, p2) {
 /**
  * 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
@@ -191,7 +191,7 @@ export function catmullRom(t, p1, cp1, cp2, p2) {
 /**
  * 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
  */
@@ -204,7 +204,7 @@ export function modAbs(value, length) {
 /**
  * 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
  */
@@ -215,7 +215,7 @@ export function pingPong(value, length) {
 /**
  * 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
@@ -229,7 +229,7 @@ export function smoothstep(value, min = 0, max = 1) {
  *  - 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
  */
@@ -257,10 +257,10 @@ export function average(array) {
 /**
  * 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 function damp(value, target, damping, delta) {

package/lib/prng.d.ts

@@ -74,9 +74,9 @@ export declare function randomSign(prng: PRNGParameters, probability?: number):
 /**
  * Generate a pseudo-random floating-point number within a specified range
  *
- * @param {PRNGParameters} prng  PRNG parameters
- * @param {number} [min=0]       Minimum boundary
- * @param {number} [max=1]       Maximum boundary
+ * @param {PRNGParameters} prng PRNG parameters
+ * @param {number} [min=0] Minimum boundary
+ * @param {number} [max=1] Maximum boundary
  * @param {number} [precision=2] Number of digits after the decimal point
  * @returns {number} Generated float
  */
@@ -85,8 +85,8 @@ export declare function randomFloat(prng: PRNGParameters, min?: number, max?: nu
  * Generate a pseudo-random integer number within a specified range
  *
  * @param {PRNGParameters} prng PRNG parameters
- * @param {number} min          Minimum boundary
- * @param {number} max          Maximum boundary
+ * @param {number} min Minimum boundary
+ * @param {number} max Maximum boundary
  * @returns {number} Generated integer
  */
 export declare function randomInt(prng: PRNGParameters, min: number, max: number): number;
@@ -101,7 +101,7 @@ export declare function randomHexColor(prng: PRNGParameters): string;
  * Pick a pseudo-random item from a given array
  *
  * @param {PRNGParameters} prng PRNG parameters
- * @param {unknown[]} array     Array to pick the item from
+ * @param {unknown[]} array Array to pick the item from
  * @returns {unknown|undefined} Random item picked
  */
 export declare function randomItem<T = unknown>(prng: PRNGParameters, array: T[]): T | undefined;
@@ -109,7 +109,7 @@ export declare function randomItem<T = unknown>(prng: PRNGParameters, array: T[]
  * Pick a pseudo-random property value from a given object
  *
  * @param {PRNGParameters} prng PRNG parameters
- * @param {object} object       Object to pick the property from
+ * @param {object} object Object to pick the property from
  * @returns {unknown|undefined} Random item picked
  */
 export declare function randomObjectProperty<T = unknown>(prng: PRNGParameters, object: Record<string, T>): T | undefined;
@@ -117,7 +117,7 @@ export declare function randomObjectProperty<T = unknown>(prng: PRNGParameters,
  * Select a pseudo-random index from an array of weighted items
  *
  * @param {PRNGParameters} prng PRNG parameters
- * @param {number[]} weights    Array of weights
+ * @param {number[]} weights Array of weights
  * @returns {number} Random index based on weights
  */
 export declare function randomIndex(prng: PRNGParameters, weights: number[]): number;
@@ -125,8 +125,8 @@ export declare function randomIndex(prng: PRNGParameters, weights: number[]): nu
  * Generate a pseudo-random number fitting a Gaussian (normal) distribution
  *
  * @param {PRNGParameters} prng PRNG parameters
- * @param {number} [mean=0]     Central value
- * @param {number} [spread=1]   Standard deviation
+ * @param {number} [mean=0] Central value
+ * @param {number} [spread=1] Standard deviation
  * @returns {number} Generated number
  */
 export declare function randomGaussian(prng: PRNGParameters, mean?: number, spread?: number): number;