@valkyriestudios/utils 12.19.0 → 12.21.0

package/date/isFormat.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDateFormat = isDateFormat;
+exports.default = isDateFormat;
+const SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
+const TOKENS = [
+    ['YYYY', /\d{4}/.source, (raw, context) => {
+            context.year = parseInt(raw, 10);
+            return context.year > 0;
+        }],
+    ['MM', /(?:0[1-9]|1[0-2])/.source, (raw, context) => {
+            context.month = parseInt(raw, 10);
+            return context.month >= 1 && context.month <= 12;
+        }],
+    ['DD', /(?:0[1-9]|[12][0-9]|3[01])/.source, (raw, context) => {
+            context.day = parseInt(raw, 10);
+            return context.day >= 1 && context.day <= 31;
+        }],
+    ['HH', /(?:[01][0-9]|2[0-3])/.source, (raw, context) => {
+            context.hour = parseInt(raw, 10);
+            return context.hour >= 0 && context.hour <= 23;
+        }],
+    ['mm', /[0-5][0-9]/.source, () => true],
+    ['ss', /[0-5][0-9]/.source, () => true],
+    ['SSS', /\d{3}/.source, () => true],
+    ['Q', /[1-4]/.source, () => true],
+    ['A', /(?:AM|PM)/.source, (raw, context) => {
+            context.is12 = 1;
+            return raw === 'AM' || raw === 'PM';
+        }],
+    ['a', /(?:am|pm)/.source, (raw, context) => {
+            context.is12 = 1;
+            return raw === 'am' || raw === 'pm';
+        }],
+    ['Z', /Z|[+-](?:0[0-9]|1[0-4]):[0-5][0-9]/.source, raw => {
+            if (raw === 'Z')
+                return true;
+            let hour = parseInt(raw[1] + raw[2], 10);
+            if (raw[0] === '-')
+                hour = -hour;
+            const minutes = parseInt(raw[4] + raw[5], 10);
+            if (hour === 14 || hour === -12)
+                return minutes === 0;
+            return hour >= -11 && hour < 14 && [0, 15, 30, 45].indexOf(minutes) >= 0;
+        }],
+];
+const SPEC_ALIASES = {
+    ISO: 'YYYY-MM-DDTHH:mm:ss.SSSZ',
+};
+const spec_pat_cache = {};
+function compileSpec(spec) {
+    if (spec in spec_pat_cache)
+        return spec_pat_cache[spec];
+    const tokens = [];
+    let pat = '';
+    let cursor = 0;
+    while (cursor < spec.length) {
+        if (spec[cursor] === '[') {
+            const end_idx = spec.indexOf(']', cursor);
+            if (end_idx === -1)
+                throw new Error('isDateFormat: Unmatched [ in format string');
+            pat += spec.slice(cursor + 1, end_idx).replace(SPECIAL_CHARS, '\\$&');
+            cursor = end_idx + 1;
+        }
+        else {
+            const token_idx = TOKENS.findIndex(([token_key]) => spec.startsWith(token_key, cursor));
+            if (token_idx >= 0) {
+                const [token_key, token_rgx] = TOKENS[token_idx];
+                pat += '(' + token_rgx + ')';
+                tokens.push(token_idx);
+                cursor += token_key.length;
+            }
+            else {
+                pat += spec[cursor].replace(SPECIAL_CHARS, '\\$&');
+                cursor++;
+            }
+        }
+    }
+    spec_pat_cache[spec] = { rgx: RegExp('^' + pat + '$'), tokens };
+    return spec_pat_cache[spec];
+}
+function isDateFormat(input, spec) {
+    if (typeof input !== 'string' || input.trim().length === 0) {
+        throw new TypeError('isDateFormat: input must be a non-empty string');
+    }
+    if (typeof spec !== 'string') {
+        throw new TypeError('isDateFormat: spec must be a string');
+    }
+    const { tokens, rgx } = compileSpec(SPEC_ALIASES[spec] || spec);
+    if (!tokens.length)
+        return false;
+    const patMatch = rgx.exec(input);
+    if (!patMatch)
+        return false;
+    const matches = patMatch.slice(1);
+    const context = {};
+    for (let i = 0; i < matches.length; i++) {
+        if (!TOKENS[tokens[i]][2](matches[i], context))
+            return false;
+    }
+    const { is12, day, month, year } = context;
+    if (day && month) {
+        const date = new Date(year || 2024, month - 1, day);
+        if (date.getDate() !== day || date.getMonth() !== month - 1)
+            return false;
+    }
+    if (is12 && 'hour' in context && context.hour > 11)
+        return false;
+    return true;
+}

package/date/isLeap.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check whether or not a provided value is a leap year
+ *
+ * @param {Date} val - Value to verify
+ */
+declare function isLeap(val: Date): boolean;
+export { isLeap, isLeap as default };

package/date/isLeap.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLeap = isLeap;
+exports.default = isLeap;
+const is_1 = require("./is");
+function isLeap(val) {
+    if (!(0, is_1.isDate)(val))
+        return false;
+    const year = val.getUTCFullYear();
+    return (((year % 4) === 0) && ((year % 100) !== 0)) || ((year % 400) === 0);
+}

package/date/nowUnix.d.ts

@@ -1,7 +1,5 @@
 /**
  * Compute the current unix timestamp in seconds
- *
- * @returns Current unix timestamp in seconds
  */
 declare function nowUnix(): number;
 export { nowUnix, nowUnix as default };

package/date/nowUnixMs.d.ts

@@ -1,7 +1,5 @@
 /**
  * Compute the current unix timestamp in milliseconds
- *
- * @returns Current unix timestamp in milliseconds
  */
 declare function nowUnixMs(): number;
 export { nowUnixMs, nowUnixMs as default };

package/date/setTimeUTC.d.ts

@@ -8,8 +8,7 @@ export type TimeProps = {
  * Sets the time on a provided date object and returns it
  *
  * @param {Date} val - Date to set the time for
- * @param {Time} props - Time props to set the time to
- * @returns {Date} New date with provided amount of key added
+ * @param {TimeProps} props - Time props to set the time to
  */
 declare function setTimeUTC(val: Date, props: TimeProps): Date;
 export { setTimeUTC, setTimeUTC as default };

package/date/startOfUTC.d.ts

@@ -1,10 +1,9 @@
+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';
 /**
  * Sets the provided date to start of UTC of provided key
  *
- * @param val - Date to set to start of
- * @param key - (default='millisecond') Key to set
- *
- * @returns New date set to start of key
+ * @param {Date} val - Date to set to start of
+ * @param {StartOfUTCKey} key - (default='millisecond') Key to set
  */
-declare 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;
+declare function startOfUTC(val: Date, key?: StartOfUTCKey): Date;
 export { startOfUTC, startOfUTC as default };

package/date/toUTC.d.ts

@@ -1,9 +1,7 @@
 /**
  * Sets a passed date to UTC
  *
- * @param val - Date to set to UTC
- *
- * @returns New date object set to the UTC contents of the passed date
+ * @param {Date} val - Date to set to UTC
  */
 declare function toUTC(val: Date): Date;
 export { toUTC, toUTC as default };

package/date/toUnix.d.ts

@@ -1,9 +1,7 @@
 /**
  * Returns the unix time in seconds of the passed date
  *
- * @param val - Date to get the unix time for
- *
- * @returns Unix time in seconds
+ * @param {Date} val - Date to get the unix time for
  */
 declare function toUnix(val: Date): number;
 export { toUnix, toUnix as default };

package/deep/freeze.d.ts

@@ -9,9 +9,7 @@ type Frozen<T> = {
 /**
  * Recursively freezes all properties of an object
  *
- * @param obj - Object to deep freeze
- *
- * @returns Deeply frozen object
+ * @param {deepInput} obj - Object to deep freeze
  */
 declare function deepFreeze<T extends deepInput>(obj: T): Frozen<T>;
 export { deepFreeze, deepFreeze as default };

package/deep/get.d.ts

@@ -1,3 +1,8 @@
+type ObjectType = {
+    [key: string]: any;
+};
+type ArrayType = any[];
+type DeepGetResult<T extends ObjectType | ArrayType, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends ObjectType | ArrayType ? DeepGetResult<T[Key], Rest> : undefined : T extends ArrayType ? number extends keyof T ? DeepGetResult<T[number], Rest> : undefined : undefined : P extends `${infer Key}[${infer Index}]` ? Key extends keyof T ? T[Key] extends ArrayType ? Index extends `${number}` ? DeepGetResult<T[Key][number], ''> : undefined : undefined : T extends ArrayType ? number extends keyof T ? DeepGetResult<T[number], `[${Index}]`> : undefined : undefined : P extends keyof T ? T[P] : T extends ArrayType ? number extends keyof T ? T[number] : undefined : undefined;
 /**
  * Get a property's value deep inside the structure of an array/object
  *
@@ -16,14 +21,7 @@
  * @param val - Object/Array to get the value from
  * @param path - Path string to deeply get the value at
  * @param get_parent - If passed as true retrieves the parent of where the value lives
- *
- * @returns Value stored at property or undefined
  * @throws {TypeError}
  */
-type ObjectType = {
-    [key: string]: any;
-};
-type ArrayType = any[];
-type DeepGetResult<T extends ObjectType | ArrayType, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends ObjectType | ArrayType ? DeepGetResult<T[Key], Rest> : undefined : T extends ArrayType ? number extends keyof T ? DeepGetResult<T[number], Rest> : undefined : undefined : P extends `${infer Key}[${infer Index}]` ? Key extends keyof T ? T[Key] extends ArrayType ? Index extends `${number}` ? DeepGetResult<T[Key][number], ''> : undefined : undefined : T extends ArrayType ? number extends keyof T ? DeepGetResult<T[number], `[${Index}]`> : undefined : undefined : P extends keyof T ? T[P] : T extends ArrayType ? number extends keyof T ? T[number] : undefined : undefined;
 declare function deepGet<T extends ObjectType | ArrayType, P extends string>(obj: T, path: P, get_parent?: boolean): DeepGetResult<T, P> | undefined;
 export { deepGet, deepGet as default };

package/deep/seal.d.ts

@@ -9,9 +9,7 @@ type Sealed<T> = {
 /**
  * Recursively seals all properties of an object
  *
- * @param obj - Object to deep seal
- *
- * @returns Deeply sealed object
+ * @param {deepInput} obj - Object to deep seal
  */
 declare function deepSeal<T extends deepInput>(obj: T): Sealed<T>;
 export { deepSeal, deepSeal as default };

package/deep/set.d.ts

@@ -31,7 +31,6 @@
  * @param path - Path string to deeply set the value at
  * @param value - Value to set (if using defineProperty can be an accessor object)
  * @param define - Whether or not the property should be directly assigned or set using Object.defineProperty
- *
  * @returns True or false depending on whether or not the property was set correctly
  * @throws {TypeError}
  */

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,16 @@
+/**
+ * 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
+ */
+declare function toObject<T extends Record<string, unknown>>(form: FormData): T;
+export { toObject, toObject as default };

package/formdata/toObject.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toObject = toObject;
+exports.default = toObject;
+function toObject(form) {
+    if (!(form instanceof FormData))
+        throw new Error('formdata/toObject: Value is not an instance of FormData');
+    const acc = {};
+    form.forEach((value, key) => {
+        if (acc[key] !== undefined) {
+            if (Array.isArray(acc[key])) {
+                acc[key].push(value);
+            }
+            else {
+                acc[key] = [acc[key], value];
+            }
+        }
+        else {
+            acc[key] = value;
+        }
+    });
+    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/fnv1A.js

@@ -28,11 +28,11 @@ function fnv1A(data, offset = FNV_32) {
             if (data === null) {
                 sanitized = REPL_NULL;
             }
-            else if (Array.isArray(data) || data.toString() === '[object Object]') {
+            else if (Array.isArray(data) || Object.prototype.toString.call(data) === '[object Object]') {
                 sanitized = JSON.stringify(data);
             }
             else if (data instanceof RegExp) {
-                sanitized = data.toString();
+                sanitized = String(data);
             }
             else if (data instanceof Date) {
                 sanitized = String(data.getTime());

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,21 +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 };
@@ -170,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" {
@@ -186,22 +210,29 @@ declare module "date/index" {
     import { diff } from "date/diff";
     import { endOfUTC } from "date/endOfUTC";
     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, 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" {
+    function toObject<T extends Record<string, unknown>>(form: FormData): 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 };