@valkyriestudios/utils 12.20.0 → 12.22.0

package/equal.d.ts

@@ -1,10 +1,8 @@
 /**
  * Compute whether or not two provided values are deeply equal
  *
- * @param a - Value to compare against
- * @param b - Value to compare with
- *
- * @returns Whether or not they are equal
+ * @param {any} a - Value to compare against
+ * @param {any} b - Value to compare with
  */
 declare function equal(a: any, b: any): boolean;
 export { equal, equal as default };

package/formdata/index.d.ts

@@ -1,2 +1,3 @@
 import { isFormData } from './is';
-export { isFormData, isFormData as is };
+import { toObject } from './toObject';
+export { isFormData, isFormData as is, toObject };

package/formdata/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.is = exports.isFormData = void 0;
+exports.toObject = exports.is = exports.isFormData = void 0;
 const is_1 = require("./is");
 Object.defineProperty(exports, "isFormData", { enumerable: true, get: function () { return is_1.isFormData; } });
 Object.defineProperty(exports, "is", { enumerable: true, get: function () { return is_1.isFormData; } });
+const toObject_1 = require("./toObject");
+Object.defineProperty(exports, "toObject", { enumerable: true, get: function () { return toObject_1.toObject; } });

package/formdata/is.d.ts

@@ -1,9 +1,7 @@
 /**
  * Check whether or not a provided value is an instance of FormData
  *
- * @param val - Value to verify
- *
- * @returns Whether or not the value is an instance of FormData
+ * @param {unknown} val - Value to verify
  */
 declare function isFormData(val: unknown): val is FormData;
 export { isFormData, isFormData as default };

package/formdata/toObject.d.ts

@@ -0,0 +1,23 @@
+type toObjectConfig = {
+    /**
+     * Pass array of keys that should not be normalized into number/bool when seen
+     */
+    raw?: string[];
+};
+/**
+ * Converts a FormData instance to a json object
+ * Eg:
+ *  const form = new FormData();
+ *  form.append('name', 'Alice');
+ *  form.append('hobbies', 'reading');
+ *  form.append('hobbies', 'writing');
+ *  form.append('emptyField', '');
+ *  toObject(form);
+ *
+ *  {name: 'Alice', hobbies: ['reading', 'writing'], emptyField: ''}
+ *
+ * @param {FormData} val - FormData instance to convert to an object
+ * @param {}
+ */
+declare function toObject<T extends Record<string, unknown>>(form: FormData, config?: toObjectConfig): T;
+export { toObject, toObject as default };

package/formdata/toObject.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toObject = toObject;
+exports.default = toObject;
+const RGX_CLOSE = /\]/g;
+function assignValue(acc, rawkey, value) {
+    let cursor = acc;
+    const keys = rawkey.replace(RGX_CLOSE, '').split(/\[|\./);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (i === keys.length - 1) {
+            if (cursor[key] !== undefined) {
+                if (Array.isArray(cursor[key])) {
+                    cursor[key].push(value);
+                }
+                else {
+                    cursor[key] = [cursor[key], value];
+                }
+            }
+            else {
+                cursor[key] = value;
+            }
+            return;
+        }
+        if (Array.isArray(cursor)) {
+            const index = Number(key);
+            if (!cursor[index])
+                cursor[index] = isNaN(Number(keys[i + 1])) ? {} : [];
+            cursor = cursor[index];
+        }
+        else {
+            if (!cursor[key])
+                cursor[key] = isNaN(Number(keys[i + 1])) ? {} : [];
+            cursor = cursor[key];
+        }
+    }
+}
+function toObject(form, config) {
+    if (!(form instanceof FormData))
+        throw new Error('formdata/toObject: Value is not an instance of FormData');
+    const set = new Set(Array.isArray(config?.raw) ? config.raw : []);
+    const acc = {};
+    form.forEach((value, key) => {
+        let normalizedValue = value;
+        if (typeof value === 'string' && !set.has(key)) {
+            const lower = value.toLowerCase();
+            normalizedValue = (lower === 'true'
+                ? true
+                : lower === 'false'
+                    ? false
+                    : !isNaN(Number(value)) && value.trim() !== ''
+                        ? Number(value)
+                        : value);
+        }
+        assignValue(acc, key, normalizedValue);
+    });
+    return acc;
+}

package/function/is.d.ts

@@ -1,9 +1,7 @@
 /**
  * Check whether or not a provided value is a Function
  *
- * @param val - Value to verify
- *
- * @returns Whether or not the value is a Function
+ * @param {unknown} val - Value to verify
  */
 declare function isFunction(val: unknown): val is (...args: unknown[]) => unknown;
 export { isFunction, isFunction as default };

package/function/isAsync.d.ts

@@ -1,9 +1,7 @@
 /**
  * Chceck whether or not a provided value is an async function
  *
- * @param val - Value to verify
- *
- * @returns Whether or not the value is an async function
+ * @param {unknown} val - Value to verify
  */
 declare function isAsyncFunction(val: unknown): val is (...args: unknown[]) => Promise<unknown>;
 export { isAsyncFunction, isAsyncFunction as default };

package/function/noop.d.ts

@@ -1,7 +1,5 @@
 /**
  * No-Operation (noop) function that does nothing and simply returns.
- *
- * @returns Void
  */
 declare function noop(): void;
 export { noop, noop as default };

package/function/noop.js

@@ -2,5 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noop = noop;
 exports.default = noop;
-function noop() {
-}
+function noop() { }

package/function/noopresolve.d.ts

@@ -3,8 +3,6 @@
  * that resolves with the value that was passed to it
  *
  * @param val - Value to be resolved with
- *
- * @returns Promise that resolves with passed value
  */
 declare function noopresolve<T>(val?: T): Promise<T | undefined>;
 export { noopresolve, noopresolve as default };

package/function/noopreturn.d.ts

@@ -2,8 +2,6 @@
  * No-Operation (noop) function that returns the value passed to it when called.
  *
  * @param val - Value to return
- *
- * @returns Passed value
  */
 declare function noopreturn<T>(val?: T): T | undefined;
 export { noopreturn, noopreturn as default };

package/function/sleep.d.ts

@@ -2,9 +2,7 @@
  * Returns a promise that resolves after X milliseconds, useful in
  * async scenarios where we wish to wait for a specific periodic of time
  *
- * @param ms - (default=1000) Amount of milliseconds to wait for
- *
- * @returns Promise that resolves after X milliseconds
+ * @param {number} ms - (default=1000) Amount of milliseconds to wait for
  */
 declare function sleep(ms?: number): Promise<void>;
 export { sleep, sleep as default };

package/hash/fnv1A.d.ts

@@ -2,10 +2,8 @@
  * Convert a provided value into a Fowler-Noll-Vo 1A hash
  * For more info: https://tools.ietf.org/html/draft-eastlake-fnv-03
  *
- * @param data - Value to be converted
- * @param offset - (default=2166136261) FNV prime to use
- *
- * @returns FNV1A hash of provided value
+ * @param {unknown} data - Value to be converted
+ * @param {number} offset - (default=2166136261) FNV prime to use
  */
 declare function fnv1A(data: unknown, offset?: number): number;
 export { fnv1A, fnv1A as default };

package/hash/guid.d.ts

@@ -1,7 +1,5 @@
 /**
  * Generate a unique identifier (guid) according to RFC4122
- *
- * @returns Generated guid string
  */
 declare function guid(): string;
 export { guid, guid as default };

package/index.d.ts

@@ -66,9 +66,7 @@ declare module "array/mapPrimitive" {
     export { mapPrimitive, mapPrimitive as default };
 }
 declare module "object/isNotEmpty" {
-    function isNotEmptyObject(val: unknown): val is {
-        [key: string]: any;
-    };
+    function isNotEmptyObject(val: unknown): val is Record<string, any>;
     export { isNotEmptyObject, isNotEmptyObject as default };
 }
 declare module "array/groupBy" {
@@ -132,25 +130,46 @@ declare module "date/is" {
     export { isDate, isDate as default };
 }
 declare module "date/addUTC" {
-    function addUTC(val: Date, amt?: number, key?: 'years' | 'year' | 'months' | 'month' | 'days' | 'day' | 'hours' | 'hour' | 'minutes' | 'minute' | 'seconds' | 'second' | 'milliseconds' | 'millisecond'): Date;
+    export type AddUTCKey = 'years' | 'year' | 'months' | 'month' | 'days' | 'day' | 'hours' | 'hour' | 'minutes' | 'minute' | 'seconds' | 'second' | 'milliseconds' | 'millisecond';
+    function addUTC(val: Date, amt?: number, key?: AddUTCKey): Date;
     export { addUTC, addUTC as default };
 }
 declare module "date/diff" {
-    function diff(val_a: Date, val_b: Date, key?: 'week' | 'weeks' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds'): number;
+    export type DiffKey = 'week' | 'weeks' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds';
+    function diff(val_a: Date, val_b: Date, key?: DiffKey): number;
     export { diff, diff as default };
 }
 declare module "date/endOfUTC" {
-    function endOfUTC(val: Date, key?: 'year' | 'quarter' | 'month' | 'week' | 'week_sun' | 'week_mon' | 'week_tue' | 'week_wed' | 'week_thu' | 'week_fri' | 'week_sat' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond'): Date;
+    export type EndOfUTCKey = 'year' | 'quarter' | 'month' | 'week' | 'week_sun' | 'week_mon' | 'week_tue' | 'week_wed' | 'week_thu' | 'week_fri' | 'week_sat' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
+    function endOfUTC(val: Date, key?: EndOfUTCKey): Date;
     export { endOfUTC, endOfUTC as default };
 }
 declare module "date/format" {
-    function format(val: Date, spec: string, locale?: string, zone?: string): string;
+    const WEEK_STARTS: {
+        readonly mon: "mon";
+        readonly sun: "sun";
+        readonly sat: "sat";
+    };
+    export type WEEK_START = keyof typeof WEEK_STARTS;
+    function format(val: Date, spec: string, locale?: string, zone?: string, sow?: WEEK_START): string;
+    namespace format {
+        var getLocale: () => string;
+        var setLocale: (locale: string) => void;
+        var getZone: () => string;
+        var setZone: (zone: string) => void;
+        var getStartOfWeek: () => "mon" | "sun" | "sat";
+        var setStartOfWeek: (sow: WEEK_START) => void;
+    }
     export { format, format as default };
 }
 declare module "date/isFormat" {
     function isDateFormat(input: unknown, spec: string): input is string;
     export { isDateFormat, isDateFormat as default };
 }
+declare module "date/isLeap" {
+    function isLeap(val: Date): boolean;
+    export { isLeap, isLeap as default };
+}
 declare module "date/nowUnix" {
     function nowUnix(): number;
     export { nowUnix, nowUnix as default };
@@ -174,7 +193,8 @@ declare module "date/setTimeUTC" {
     export { setTimeUTC, setTimeUTC as default };
 }
 declare module "date/startOfUTC" {
-    function startOfUTC(val: Date, key?: 'year' | 'quarter' | 'month' | 'week' | 'week_sun' | 'week_mon' | 'week_tue' | 'week_wed' | 'week_thu' | 'week_fri' | 'week_sat' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond'): Date;
+    export type StartOfUTCKey = 'year' | 'quarter' | 'month' | 'week' | 'week_sun' | 'week_mon' | 'week_tue' | 'week_wed' | 'week_thu' | 'week_fri' | 'week_sat' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
+    function startOfUTC(val: Date, key?: StartOfUTCKey): Date;
     export { startOfUTC, startOfUTC as default };
 }
 declare module "date/toUnix" {
@@ -192,21 +212,30 @@ declare module "date/index" {
     import { format } from "date/format";
     import { isDateFormat } from "date/isFormat";
     import { isDate } from "date/is";
+    import { isLeap } from "date/isLeap";
     import { nowUnix } from "date/nowUnix";
     import { nowUnixMs } from "date/nowUnixMs";
     import { setTimeUTC } from "date/setTimeUTC";
     import { startOfUTC } from "date/startOfUTC";
     import { toUnix } from "date/toUnix";
     import { toUTC } from "date/toUTC";
-    export { addUTC, diff, endOfUTC, format, isDateFormat as isFormat, isDateFormat, isDate, isDate as is, nowUnix, nowUnixMs, setTimeUTC, startOfUTC, toUnix, toUTC };
+    export { addUTC, diff, endOfUTC, format, isDateFormat as isFormat, isDateFormat, isDate, isDate as is, isLeap, nowUnix, nowUnixMs, setTimeUTC, startOfUTC, toUnix, toUTC };
 }
 declare module "formdata/is" {
     function isFormData(val: unknown): val is FormData;
     export { isFormData, isFormData as default };
 }
+declare module "formdata/toObject" {
+    type toObjectConfig = {
+        raw?: string[];
+    };
+    function toObject<T extends Record<string, unknown>>(form: FormData, config?: toObjectConfig): T;
+    export { toObject, toObject as default };
+}
 declare module "formdata/index" {
     import { isFormData } from "formdata/is";
-    export { isFormData, isFormData as is };
+    import { toObject } from "formdata/toObject";
+    export { isFormData, isFormData as is, toObject };
 }
 declare module "function/is" {
     function isFunction(val: unknown): val is (...args: unknown[]) => unknown;

package/number/is.d.ts

@@ -1,9 +1,7 @@
 /**
  * Check whether or not a provided value is a number
  *
- * @param val - Value to verify
- *
- * @returns Whether or not the value is a number
+ * @param {unknown} val - Value to verify
  */
 declare function isNumber(val: unknown): val is number;
 export { isNumber, isNumber as default };

package/number/isAbove.d.ts

@@ -1,10 +1,8 @@
 /**
  * Check whether or not the provided value is a number above another value
  *
- * @param val - Value to verify
- * @param ref - Reference the provided value needs to be above
- *
- * @returns Whether or not the value is above the reference
+ * @param {unknown} val - Value to verify
+ * @param {number} ref - Reference the provided value needs to be above
  */
 declare function isNumberAbove(val: unknown, ref: number): val is number;
 export { isNumberAbove, isNumberAbove as default };

package/number/isAboveOrEqual.d.ts

@@ -1,10 +1,8 @@
 /**
  * Check whether or not the provided value is a number above or equal to another value
  *
- * @param val - Value to verify
- * @param ref - Reference the provided value needs to be above or equal to
- *
- * @returns Whether or not the value is above or equal to the reference
+ * @param {unknown} val - Value to verify
+ * @param {number} ref - Reference the provided value needs to be above or equal to
  */
 declare function isNumberAboveOrEqual(val: unknown, ref: number): val is number;
 export { isNumberAboveOrEqual, isNumberAboveOrEqual as default };

package/number/isBelow.d.ts

@@ -1,10 +1,8 @@
 /**
  * Check whether or not the provided value is a number below another value
  *
- * @param val - Value to verify
- * @param ref - Reference the provided value needs to be below
- *
- * @returns Whether or not the value is below the reference
+ * @param {unknown} val - Value to verify
+ * @param {number} ref - Reference the provided value needs to be below
  */
 declare function isNumberBelow(val: unknown, ref: number): val is number;
 export { isNumberBelow, isNumberBelow as default };

package/number/isBelowOrEqual.d.ts

@@ -2,10 +2,8 @@
  * Check whether or not the provided value is a number below or
  * equal to another value
  *
- * @param val - Value to verify
- * @param ref - Reference the provided value needs to be below or equal to
- *
- * @returns Whether or not the value is below or equal to the reference
+ * @param {unknown} val - Value to verify
+ * @param {number} ref - Reference the provided value needs to be below or equal to
  */
 declare function isNumberBelowOrEqual(val: unknown, ref: number): val is number;
 export { isNumberBelowOrEqual, isNumberBelowOrEqual as default };

package/number/isBetween.d.ts

@@ -3,11 +3,9 @@
  * inclusive of min and max
  * equal to another value
  *
- * @param val - Value to verify
- * @param min - Lower boundary
- * @param max - Upper boundary
- *
- * @returns Whether or not the value is a number between min and max inclusive
+ * @param {unknown} val - Value to verify
+ * @param {number} min - Lower boundary
+ * @param {number} max - Upper boundary
  */
 declare function isNumberBetween(val: unknown, min: number, max: number): val is number;
 export { isNumberBetween, isNumberBetween as default };

package/number/isBetween.js

@@ -3,10 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNumberBetween = isNumberBetween;
 exports.default = isNumberBetween;
 function isNumberBetween(val, min, max) {
-    if (!Number.isFinite(val) ||
-        !Number.isFinite(min) ||
-        !Number.isFinite(max) ||
-        min >= max)
-        return false;
-    return val >= min && val <= max;
+    return (Number.isFinite(val) &&
+        Number.isFinite(min) &&
+        Number.isFinite(max) &&
+        (val >= min && val <= max));
 }

package/number/isInteger.d.ts

@@ -1,9 +1,7 @@
 /**
  * Check whether or not a provided value is an integer
  *
- * @param val - Value to verify
- *
- * @returns Whether or not the value is an integer
+ * @param {unknown} val - Value to verify
  */
 declare function isInteger(val: unknown): val is number;
 export { isInteger, isInteger as default };

package/number/isIntegerAbove.d.ts

@@ -1,10 +1,8 @@
 /**
  * Check whether or not the provided value is an integer above another value
  *
- * @param val - Value to verify
- * @param ref - Reference the provided value needs to be above
- *
- * @returns Whether or not the value is above the reference
+ * @param {unknown} val - Value to verify
+ * @param {number} ref - Reference the provided value needs to be above
  */
 declare function isIntegerAbove(val: unknown, ref: number): val is number;
 export { isIntegerAbove, isIntegerAbove as default };

package/number/isIntegerAboveOrEqual.d.ts

@@ -2,10 +2,8 @@
  * Check whether or not the provided value is an integer above or equal
  * to another value
  *
- * @param val - Value to verify
- * @param ref - Reference the provided value needs to be above or equal to
- *
- * @returns Whether or not the value is above or equal to the reference
+ * @param {unknown} val - Value to verify
+ * @param {number} ref - Reference the provided value needs to be above or equal to
  */
 declare function isIntegerAboveOrEqual(val: unknown, ref: number): val is number;
 export { isIntegerAboveOrEqual, isIntegerAboveOrEqual as default };

package/number/isIntegerBelow.d.ts

@@ -1,10 +1,8 @@
 /**
  * Check whether or not the provided value is an integer below another value
  *
- * @param val - Value to verify
- * @param ref - Reference the provided value needs to be below
- *
- * @returns Whether or not the value is below the reference
+ * @param {unknown} val - Value to verify
+ * @param {number} ref - Reference the provided value needs to be below
  */
 declare function isIntegerBelow(val: unknown, ref: number): val is number;
 export { isIntegerBelow, isIntegerBelow as default };

package/number/isIntegerBelowOrEqual.d.ts

@@ -2,10 +2,8 @@
  * Check whether or not the provided value is an integer below or
  * equal to another value
  *
- * @param val - Value to verify
- * @param ref - Reference the provided value needs to be below or equal to
- *
- * @returns Whether or not the value is below or equal to the reference
+ * @param {unknown} val - Value to verify
+ * @param {number} ref - Reference the provided value needs to be below or equal to
  */
 declare function isIntegerBelowOrEqual(val: unknown, ref: number): val is number;
 export { isIntegerBelowOrEqual, isIntegerBelowOrEqual as default };

package/number/isIntegerBetween.d.ts

@@ -3,11 +3,9 @@
  * inclusive of min and max
  * equal to another value
  *
- * @param val - Value to verify
- * @param min - Lower boundary
- * @param max - Upper boundary
- *
- * @returns Whether or not the value is an integer between min and max inclusive
+ * @param {unknown} val - Value to verify
+ * @param {number} min - Lower boundary
+ * @param {number} max - Upper boundary
  */
 declare function isIntegerBetween(val: unknown, min: number, max: number): val is number;
 export { isIntegerBetween, isIntegerBetween as default };

package/number/isIntegerBetween.js

@@ -3,10 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isIntegerBetween = isIntegerBetween;
 exports.default = isIntegerBetween;
 function isIntegerBetween(val, min, max) {
-    if (!Number.isInteger(val) ||
-        !Number.isFinite(min) ||
-        !Number.isFinite(max) ||
-        min >= max)
-        return false;
-    return val >= min && val <= max;
+    return (Number.isInteger(val) &&
+        Number.isFinite(min) &&
+        Number.isFinite(max) &&
+        (val >= min && val <= max));
 }

package/number/isNumericalNaN.d.ts

@@ -1,9 +1,7 @@
 /**
  * Check whether or not the provided value is a numerical NaN
  *
- * @param val - Value to verify
- *
- * @returns Whether or not the value is a numerical NaN
+ * @param {unknown} val - Value to verify
  */
 declare function isNumericalNaN(val: unknown): boolean;
 export { isNumericalNaN, isNumericalNaN as default };

package/number/randomBetween.d.ts

@@ -1,10 +1,8 @@
 /**
  * Generates a random number between the provided lower and upper bound
  *
- * @param min - (default=0) Lower bound
- * @param max - (default=10) Upper bound
- *
- * @returns Random number between min and max
+ * @param {number} min - (default=0) Lower bound
+ * @param {number} max - (default=10) Upper bound
  */
 declare function randomBetween(min?: number, max?: number): number;
 export { randomBetween, randomBetween as default };

package/number/randomIntBetween.d.ts

@@ -2,10 +2,8 @@
  * Generates a random integer between the provided lower and upper bound,
  * not inclusive of the upper bound
  *
- * @param min - (default=0) Lower bound
- * @param max - (default=10) Upper bound
- *
- * @returns Random integer between min and max
+ * @param {number} min - (default=0) Lower bound
+ * @param {number} max - (default=10) Upper bound
  */
 declare function randomIntBetween(min?: number, max?: number): number;
 export { randomIntBetween, randomIntBetween as default };

package/number/round.d.ts

@@ -1,10 +1,8 @@
 /**
  * Rounds the provided value to a certain precision
  *
- * @param val - Value to round
- * @param precision - (default=0) Amount of decimals precision to round to
- *
- * @returns Rounded value according to decimal precision provided
+ * @param {number} val - Value to round
+ * @param {number} precision - (default=0) Amount of decimals precision to round to
  */
 declare function round(val: number, precision?: number): number;
 export { round, round as default };

package/number/round.js

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.round = round;
 exports.default = round;
+const ROUND_EPSILON = 1 + Number.EPSILON;
 function round(val, precision = 0) {
     if (!Number.isFinite(val))
         throw new TypeError('Value should be numeric');
-    const exp = Math.pow(10, Number.isInteger(precision) && precision > 0 ? precision : 0);
-    const num = (val * exp) * (1 + Number.EPSILON);
-    return Math.round(num) / exp;
+    if (!Number.isInteger(precision) || precision <= 0)
+        return Math.round(val * ROUND_EPSILON);
+    const exp = Math.pow(10, precision);
+    return Math.round((val * exp) * ROUND_EPSILON) / exp;
 }

package/number/toPercentage.d.ts

@@ -1,12 +1,10 @@
 /**
  * Converts a number into a percentage respective to a provided range
  *
- * @param val - Value to convert into a percentage for the provided range
- * @param precision - (default=0) Amount of decimals precision to use
- * @param min - (default=0) Lower bound of the range the value is to be converted to percentage for
- * @param max - (default=1) Upper bound of the range the value is to be converted to percentage for
- *
- * @returns Percentage value respective to the provided range
+ * @param {number} val - Value to convert into a percentage for the provided range
+ * @param {number} precision - (default=0) Amount of decimals precision to use
+ * @param {number} min - (default=0) Lower bound of the range the value is to be converted to percentage for
+ * @param {number} max - (default=1) Upper bound of the range the value is to be converted to percentage for
  */
 declare function toPercentage(val: number, precision?: number, min?: number, max?: number): number;
 export { toPercentage, toPercentage as default };

package/object/define.d.ts

@@ -3,8 +3,6 @@
  *
  * @param props - Object with properties to define
  * @param obj - (default={}) Object to define on top of
- *
- * @returns Object with the defined properties
  */
 declare function define(props: {
     [key: string]: any;

package/object/is.d.ts

@@ -1,9 +1,7 @@
 /**
  * Check whether or not a provided value is an object
  *
- * @param val - Value to verify
- *
- * @returns Whether or not the value is an object
+ * @param {unknown} val - Value to verify
  */
 declare function isObject(val: unknown): val is {
     [key: string]: any;