@valkyriestudios/utils 10.0.0 → 11.1.0

package/dist/hash/fnv1A.js

@@ -0,0 +1,51 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const FNV_32 = 2166136261;
+const REPL_NAN = 'nan';
+const REPL_TRUE = 'true';
+const REPL_FALSE = 'false';
+const REPL_UNDEF = 'undefined';
+const REPL_NULL = 'null';
+function fnv1A(data, offset = FNV_32) {
+    let hash = offset;
+    let sanitized;
+    if (typeof data === 'string') {
+        sanitized = data;
+    }
+    else if (Number.isFinite(data)) {
+        sanitized = `${data}`;
+    }
+    else if (Array.isArray(data) || Object.prototype.toString.call(data) === '[object Object]') {
+        sanitized = JSON.stringify(data);
+    }
+    else if (Object.prototype.toString.call(data) === '[object RegExp]') {
+        sanitized = data.toString();
+    }
+    else if (data instanceof Date) {
+        sanitized = `${data.getTime()}`;
+    }
+    else if (Number.isNaN(data) || data === Infinity) {
+        sanitized = REPL_NAN;
+    }
+    else if (data === false) {
+        sanitized = REPL_FALSE;
+    }
+    else if (data === true) {
+        sanitized = REPL_TRUE;
+    }
+    else if (data === null) {
+        sanitized = REPL_NULL;
+    }
+    else if (data === undefined) {
+        sanitized = REPL_UNDEF;
+    }
+    else {
+        throw new TypeError('An FNV1A Hash could not be calculated for this datatype');
+    }
+    for (let i = 0; i < sanitized.length; i++) {
+        hash ^= sanitized.charCodeAt(i);
+        hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+    }
+    return hash >>> 0;
+}
+exports.default = fnv1A;

package/dist/hash/guid.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generate a unique identifier (guid) according to RFC4122
+ *
+ * @returns Generated guid string
+ */
+export default function guid(): string;

package/{src/hash/guid.mjs → dist/hash/guid.js}

@@ -1,20 +1,14 @@
 'use strict';
-
-/* eslint-disable no-bitwise, prefer-template */
-
-//  RFC4122 Compliant
-
-//  Generates a prebuilt hexmap from 0 to 255
+Object.defineProperty(exports, "__esModule", { value: true });
 const HEXMAP = [];
 for (let i = 0; i < 256; i++) {
     HEXMAP[i] = (i < 16 ? '0' : '') + i.toString(16);
 }
-
-export default function guid () {
-    const d0 = (Math.random()*0xffffffff) | 0;
-    const d1 = (Math.random()*0xffffffff) | 0;
-    const d2 = (Math.random()*0xffffffff) | 0;
-    const d3 = (Math.random()*0xffffffff) | 0;
+function guid() {
+    const d0 = (Math.random() * 0xffffffff) | 0;
+    const d1 = (Math.random() * 0xffffffff) | 0;
+    const d2 = (Math.random() * 0xffffffff) | 0;
+    const d3 = (Math.random() * 0xffffffff) | 0;
     return HEXMAP[d0 & 0xff] +
         HEXMAP[(d0 >> 8) & 0xff] +
         HEXMAP[(d0 >> 16) & 0xff] +
@@ -23,8 +17,8 @@ export default function guid () {
         HEXMAP[d1 & 0xff] +
         HEXMAP[(d1 >> 8) & 0xff] +
         '-' +
-        HEXMAP[((d1>>16) & 0x0f) | 0x40] +
-        HEXMAP[(d1>>24) & 0xff] +
+        HEXMAP[((d1 >> 16) & 0x0f) | 0x40] +
+        HEXMAP[(d1 >> 24) & 0xff] +
         '-' +
         HEXMAP[(d2 & 0x3f) | 0x80] +
         HEXMAP[(d2 >> 8) & 0xff] +
@@ -36,3 +30,4 @@ export default function guid () {
         HEXMAP[(d3 >> 16) & 0xff] +
         HEXMAP[(d3 >> 24) & 0xff];
 }
+exports.default = guid;

package/dist/index.d.ts

@@ -0,0 +1,358 @@
+declare module "number/isNumericalNaN" {
+    export default function isNumericalNaN(val: any): boolean;
+}
+declare module "equal" {
+    function equal(a: any, b: any): boolean;
+    export default equal;
+}
+declare module "array/isNotEmpty" {
+    export default function isNotEmptyArray(val: any): boolean;
+}
+declare module "array/is" {
+    export default function isArray(val: any): boolean;
+}
+declare module "boolean/is" {
+    export default function isBoolean(val: any): boolean;
+}
+declare module "date/is" {
+    export default function isDate(val: any): boolean;
+}
+declare module "function/is" {
+    export default function isFunction(val: any): boolean;
+}
+declare module "number/is" {
+    export default function isNumber(val: any): boolean;
+}
+declare module "number/isBetween" {
+    export default function isNumberBetween(val: any, min: number, max: number): boolean;
+}
+declare module "number/isBelow" {
+    export default function isNumberBelow(val: any, ref: number): boolean;
+}
+declare module "number/isBelowOrEqual" {
+    export default function isNumberBelowOrEqual(val: any, ref: number): boolean;
+}
+declare module "number/isAbove" {
+    export default function isNumberAbove(val: any, ref: number): boolean;
+}
+declare module "number/isAboveOrEqual" {
+    export default function isNumberAboveOrEqual(val: any, ref: number): boolean;
+}
+declare module "number/isInteger" {
+    export default function isInteger(val: any): boolean;
+}
+declare module "number/isIntegerBetween" {
+    export default function isIntegerBetween(val: any, min: number, max: number): boolean;
+}
+declare module "number/isIntegerBelow" {
+    export default function isIntegerBelow(val: any, ref: number): boolean;
+}
+declare module "number/isIntegerBelowOrEqual" {
+    export default function isIntegerBelowOrEqual(val: any, ref: number): boolean;
+}
+declare module "number/isIntegerAbove" {
+    export default function isIntegerAbove(val: any, ref: number): boolean;
+}
+declare module "number/isIntegerAboveOrEqual" {
+    export default function isIntegerAboveOrEqual(val: any, ref: number): boolean;
+}
+declare module "regexp/is" {
+    export default function isRegExp(val: any): boolean;
+}
+declare module "object/is" {
+    export default function isObject(val: any): boolean;
+}
+declare module "object/isNotEmpty" {
+    export default function isNotEmptyObject(val: any): boolean;
+}
+declare module "string/is" {
+    export default function isString(val: any): boolean;
+}
+declare module "string/isBetween" {
+    export default function isStringBetween(val: any, min: number, max: number, trimmed?: boolean): boolean;
+}
+declare module "string/isNotEmpty" {
+    export default function isNotEmptyString(val: any, trimmed?: boolean): boolean;
+}
+declare module "is" {
+    import equal from "equal";
+    import isNotEmptyArray from "array/isNotEmpty";
+    import isArray from "array/is";
+    import isBoolean from "boolean/is";
+    import isDate from "date/is";
+    import isFunction from "function/is";
+    import isNumber from "number/is";
+    import isNumberBetween from "number/isBetween";
+    import isNumberBelow from "number/isBelow";
+    import isNumberBelowOrEqual from "number/isBelowOrEqual";
+    import isNumberAbove from "number/isAbove";
+    import isNumberAboveOrEqual from "number/isAboveOrEqual";
+    import isInteger from "number/isInteger";
+    import isIntegerBetween from "number/isIntegerBetween";
+    import isIntegerBelow from "number/isIntegerBelow";
+    import isIntegerBelowOrEqual from "number/isIntegerBelowOrEqual";
+    import isIntegerAbove from "number/isIntegerAbove";
+    import isIntegerAboveOrEqual from "number/isIntegerAboveOrEqual";
+    import isRegExp from "regexp/is";
+    import isObject from "object/is";
+    import isNotEmptyObject from "object/isNotEmpty";
+    import isString from "string/is";
+    import isStringBetween from "string/isBetween";
+    import isNotEmptyString from "string/isNotEmpty";
+    const Is: Readonly<{
+        Array: typeof isArray;
+        NeArray: typeof isNotEmptyArray;
+        NotEmptyArray: typeof isNotEmptyArray;
+        Boolean: typeof isBoolean;
+        Date: typeof isDate;
+        Function: typeof isFunction;
+        Num: typeof isNumber;
+        NumBetween: typeof isNumberBetween;
+        NumAbove: typeof isNumberAbove;
+        NumAboveOrEqual: typeof isNumberAboveOrEqual;
+        NumBelow: typeof isNumberBelow;
+        NumBelowOrEqual: typeof isNumberBelowOrEqual;
+        NumGt: typeof isNumberAbove;
+        NumGte: typeof isNumberAboveOrEqual;
+        NumLt: typeof isNumberBelow;
+        NumLte: typeof isNumberBelowOrEqual;
+        Number: typeof isNumber;
+        NumberBetween: typeof isNumberBetween;
+        NumberAbove: typeof isNumberAbove;
+        NumberAboveOrEqual: typeof isNumberAboveOrEqual;
+        NumberBelow: typeof isNumberBelow;
+        NumberBelowOrEqual: typeof isNumberBelowOrEqual;
+        Int: typeof isInteger;
+        IntBetween: typeof isIntegerBetween;
+        IntAbove: typeof isIntegerAbove;
+        IntAboveOrEqual: typeof isIntegerAboveOrEqual;
+        IntBelow: typeof isIntegerBelow;
+        IntBelowOrEqual: typeof isIntegerBelowOrEqual;
+        IntGt: typeof isIntegerAbove;
+        IntGte: typeof isIntegerAboveOrEqual;
+        IntLt: typeof isIntegerBelow;
+        IntLte: typeof isIntegerBelowOrEqual;
+        Integer: typeof isInteger;
+        IntegerBetween: typeof isIntegerBetween;
+        IntegerBelow: typeof isIntegerBelow;
+        IntegerBelowOrEqual: typeof isIntegerBelowOrEqual;
+        IntegerAbove: typeof isIntegerAbove;
+        IntegerAboveOrEqual: typeof isIntegerAboveOrEqual;
+        RegExp: typeof isRegExp;
+        Object: typeof isObject;
+        NeObject: typeof isNotEmptyObject;
+        NotEmptyObject: typeof isNotEmptyObject;
+        String: typeof isString;
+        StringBetween: typeof isStringBetween;
+        NeString: typeof isNotEmptyString;
+        NotEmptyString: typeof isNotEmptyString;
+        Equal: typeof equal;
+        Eq: typeof equal;
+    }>;
+    export default Is;
+}
+declare module "hash/fnv1A" {
+    export default function fnv1A(data: any, offset?: number): number;
+}
+declare module "array/dedupe" {
+    export default function dedupe(val: any[]): any[];
+}
+declare module "number/round" {
+    export default function round(val: number, precision?: number): number;
+}
+declare module "array/join" {
+    interface joinOptions {
+        delim?: string;
+        trim?: boolean;
+        valtrim?: boolean;
+        valround?: number;
+    }
+    export default function join(val: any[], opts?: joinOptions): string;
+}
+declare module "array/mapFn" {
+    interface mapOptions {
+        merge?: boolean;
+    }
+    interface kvMap {
+        [key: string]: {
+            [key: string]: any;
+        };
+    }
+    export default function mapFn(arr: {
+        [key: string]: any;
+    }[], fn: (entry: {
+        [key: string]: any;
+    }) => (string | number | boolean), opts?: mapOptions): kvMap;
+}
+declare module "array/mapKey" {
+    interface mapOptions {
+        merge?: boolean;
+    }
+    interface kvMap {
+        [key: string]: {
+            [key: string]: any;
+        };
+    }
+    export default function mapKey(arr: {
+        [key: string]: any;
+    }[], key: string, opts?: mapOptions): kvMap;
+}
+declare module "array/mapPrimitive" {
+    interface mapOptions {
+        valtrim?: boolean;
+        valround?: boolean | number;
+        keyround?: boolean;
+    }
+    interface mapReturn {
+        [key: string]: string | number;
+    }
+    export default function mapPrimitive(arr: any[], opts?: mapOptions): mapReturn;
+}
+declare module "array/shuffle" {
+    export default function shuffle(arr: any[]): void;
+}
+declare module "array/sort" {
+    interface sortOptions {
+        filter_fn?: (el: any) => boolean;
+        nokey_hide?: boolean;
+        nokey_atend?: boolean;
+    }
+    interface sortObject {
+        [key: string]: any;
+    }
+    type sortByFunction = (el: sortObject) => string;
+    export default function sort(arr: sortObject[], by: string | sortByFunction, dir?: 'asc' | 'desc', opts?: sortOptions): sortObject[];
+}
+declare module "caching/memoize" {
+    export default function memoize(fn: Function, resolver?: Function): Function;
+}
+declare module "date/addUTC" {
+    export default function addUTC(val: Date, amount?: number, key?: 'years' | 'year' | 'months' | 'month' | 'days' | 'day' | 'hours' | 'hour' | 'minutes' | 'minute' | 'seconds' | 'second' | 'milliseconds' | 'millisecond'): Date;
+}
+declare module "date/diff" {
+    export default function diff(val_a: Date, val_b: Date, key?: 'week' | 'weeks' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds'): number;
+}
+declare module "date/endOfUTC" {
+    export default 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;
+}
+declare module "date/nowUnix" {
+    export default function nowUnix(): number;
+}
+declare module "date/nowUnixMs" {
+    export default function nowUnixMs(): number;
+}
+declare module "date/startOfUTC" {
+    export default 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 module "date/toUTC" {
+    export default function toUTC(val: Date): Date;
+}
+declare module "date/toUnix" {
+    export default function toUnix(val: Date): number;
+}
+declare module "deep/freeze" {
+    type deepInput = {
+        [key: string]: any;
+    } | {
+        [key: string]: any;
+    }[] | any[];
+    export default function deepFreeze(obj: deepInput): Readonly<deepInput>;
+}
+declare module "deep/get" {
+    export default function deepGet(obj: {
+        [key: string]: any;
+    } | {
+        [key: string]: any;
+    }[] | any[], path: string, get_parent?: boolean): any | undefined;
+}
+declare module "deep/seal" {
+    type deepInput = {
+        [key: string]: any;
+    } | {
+        [key: string]: any;
+    }[] | any[];
+    export default function deepSeal(obj: deepInput): deepInput;
+}
+declare module "deep/set" {
+    export default function deepSet(obj: {
+        [key: string]: any;
+    } | {
+        [key: string]: any;
+    }[] | any[], path: string, value: any, define?: boolean): boolean;
+}
+declare module "function/noop" {
+    export default function noop(): void;
+}
+declare module "function/noopresolve" {
+    export default function noopresolve(val?: any): Promise<any>;
+}
+declare module "function/noopreturn" {
+    export default function noopreturn(val?: any): any;
+}
+declare module "function/sleep" {
+    export default function sleep(ms?: number): Promise<void>;
+}
+declare module "hash/guid" {
+    export default function guid(): string;
+}
+declare module "number/randomBetween" {
+    export default function randomBetween(min?: number, max?: number): number;
+}
+declare module "number/randomIntBetween" {
+    export default function randomIntBetween(min?: number, max?: number): number;
+}
+declare module "number/toPercentage" {
+    export default function toPercentage(val: number, precision?: number, min?: number, max?: number): number;
+}
+declare module "object/define" {
+    export default function define(props: {
+        [key: string]: any;
+    }, obj?: {
+        [key: string]: any;
+    }): {
+        [key: string]: any;
+    };
+}
+declare module "object/merge" {
+    function merge(target: {
+        [key: string]: any;
+    }, source?: {
+        [key: string]: any;
+    }): {
+        [key: string]: any;
+    };
+    export default merge;
+}
+declare module "object/pick" {
+    export default function pick(obj: {
+        [key: string]: any;
+    }, keys: string[]): {
+        [key: string]: any;
+    };
+}
+declare module "regexp/sanitize" {
+    export default function sanitizeRegExp(val: string): string | false;
+}
+declare module "string/humanizeNumber" {
+    interface humanizeNumberOptions {
+        delim?: string;
+        separator?: string;
+        precision?: number;
+        units?: string[] | boolean;
+        divider?: number;
+        real?: boolean;
+    }
+    export default function humanizeNumber(val: number | string, options?: humanizeNumberOptions): string;
+}
+declare module "string/humanizeBytes" {
+    interface humanizeBytesOptions {
+        delim?: string;
+        separator?: string;
+        precision?: number;
+        units?: string[];
+    }
+    export default function humanizeBytes(val: number | string, options?: humanizeBytesOptions): string;
+}
+declare module "string/shorten" {
+    export default function shorten(val: string, length: number, postfix?: string): string;
+}

package/dist/is.d.ts

@@ -0,0 +1,75 @@
+import equal from './equal';
+import isNotEmptyArray from './array/isNotEmpty';
+import isArray from './array/is';
+import isBoolean from './boolean/is';
+import isDate from './date/is';
+import isFunction from './function/is';
+import isNumber from './number/is';
+import isNumberBetween from './number/isBetween';
+import isNumberBelow from './number/isBelow';
+import isNumberBelowOrEqual from './number/isBelowOrEqual';
+import isNumberAbove from './number/isAbove';
+import isNumberAboveOrEqual from './number/isAboveOrEqual';
+import isInteger from './number/isInteger';
+import isIntegerBetween from './number/isIntegerBetween';
+import isIntegerBelow from './number/isIntegerBelow';
+import isIntegerBelowOrEqual from './number/isIntegerBelowOrEqual';
+import isIntegerAbove from './number/isIntegerAbove';
+import isIntegerAboveOrEqual from './number/isIntegerAboveOrEqual';
+import isRegExp from './regexp/is';
+import isObject from './object/is';
+import isNotEmptyObject from './object/isNotEmpty';
+import isString from './string/is';
+import isStringBetween from './string/isBetween';
+import isNotEmptyString from './string/isNotEmpty';
+declare const Is: Readonly<{
+    Array: typeof isArray;
+    NeArray: typeof isNotEmptyArray;
+    NotEmptyArray: typeof isNotEmptyArray;
+    Boolean: typeof isBoolean;
+    Date: typeof isDate;
+    Function: typeof isFunction;
+    Num: typeof isNumber;
+    NumBetween: typeof isNumberBetween;
+    NumAbove: typeof isNumberAbove;
+    NumAboveOrEqual: typeof isNumberAboveOrEqual;
+    NumBelow: typeof isNumberBelow;
+    NumBelowOrEqual: typeof isNumberBelowOrEqual;
+    NumGt: typeof isNumberAbove;
+    NumGte: typeof isNumberAboveOrEqual;
+    NumLt: typeof isNumberBelow;
+    NumLte: typeof isNumberBelowOrEqual;
+    Number: typeof isNumber;
+    NumberBetween: typeof isNumberBetween;
+    NumberAbove: typeof isNumberAbove;
+    NumberAboveOrEqual: typeof isNumberAboveOrEqual;
+    NumberBelow: typeof isNumberBelow;
+    NumberBelowOrEqual: typeof isNumberBelowOrEqual;
+    Int: typeof isInteger;
+    IntBetween: typeof isIntegerBetween;
+    IntAbove: typeof isIntegerAbove;
+    IntAboveOrEqual: typeof isIntegerAboveOrEqual;
+    IntBelow: typeof isIntegerBelow;
+    IntBelowOrEqual: typeof isIntegerBelowOrEqual;
+    IntGt: typeof isIntegerAbove;
+    IntGte: typeof isIntegerAboveOrEqual;
+    IntLt: typeof isIntegerBelow;
+    IntLte: typeof isIntegerBelowOrEqual;
+    Integer: typeof isInteger;
+    IntegerBetween: typeof isIntegerBetween;
+    IntegerBelow: typeof isIntegerBelow;
+    IntegerBelowOrEqual: typeof isIntegerBelowOrEqual;
+    IntegerAbove: typeof isIntegerAbove;
+    IntegerAboveOrEqual: typeof isIntegerAboveOrEqual;
+    RegExp: typeof isRegExp;
+    Object: typeof isObject;
+    NeObject: typeof isNotEmptyObject;
+    NotEmptyObject: typeof isNotEmptyObject;
+    String: typeof isString;
+    StringBetween: typeof isStringBetween;
+    NeString: typeof isNotEmptyString;
+    NotEmptyString: typeof isNotEmptyString;
+    Equal: typeof equal;
+    Eq: typeof equal;
+}>;
+export default Is;

package/dist/is.js

@@ -0,0 +1,77 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const equal_1 = require("./equal");
+const isNotEmpty_1 = require("./array/isNotEmpty");
+const is_1 = require("./array/is");
+const is_2 = require("./boolean/is");
+const is_3 = require("./date/is");
+const is_4 = require("./function/is");
+const is_5 = require("./number/is");
+const isBetween_1 = require("./number/isBetween");
+const isBelow_1 = require("./number/isBelow");
+const isBelowOrEqual_1 = require("./number/isBelowOrEqual");
+const isAbove_1 = require("./number/isAbove");
+const isAboveOrEqual_1 = require("./number/isAboveOrEqual");
+const isInteger_1 = require("./number/isInteger");
+const isIntegerBetween_1 = require("./number/isIntegerBetween");
+const isIntegerBelow_1 = require("./number/isIntegerBelow");
+const isIntegerBelowOrEqual_1 = require("./number/isIntegerBelowOrEqual");
+const isIntegerAbove_1 = require("./number/isIntegerAbove");
+const isIntegerAboveOrEqual_1 = require("./number/isIntegerAboveOrEqual");
+const is_6 = require("./regexp/is");
+const is_7 = require("./object/is");
+const isNotEmpty_2 = require("./object/isNotEmpty");
+const is_8 = require("./string/is");
+const isBetween_2 = require("./string/isBetween");
+const isNotEmpty_3 = require("./string/isNotEmpty");
+const Is = Object.freeze({
+    Array: is_1.default,
+    NeArray: isNotEmpty_1.default,
+    NotEmptyArray: isNotEmpty_1.default,
+    Boolean: is_2.default,
+    Date: is_3.default,
+    Function: is_4.default,
+    Num: is_5.default,
+    NumBetween: isBetween_1.default,
+    NumAbove: isAbove_1.default,
+    NumAboveOrEqual: isAboveOrEqual_1.default,
+    NumBelow: isBelow_1.default,
+    NumBelowOrEqual: isBelowOrEqual_1.default,
+    NumGt: isAbove_1.default,
+    NumGte: isAboveOrEqual_1.default,
+    NumLt: isBelow_1.default,
+    NumLte: isBelowOrEqual_1.default,
+    Number: is_5.default,
+    NumberBetween: isBetween_1.default,
+    NumberAbove: isAbove_1.default,
+    NumberAboveOrEqual: isAboveOrEqual_1.default,
+    NumberBelow: isBelow_1.default,
+    NumberBelowOrEqual: isBelowOrEqual_1.default,
+    Int: isInteger_1.default,
+    IntBetween: isIntegerBetween_1.default,
+    IntAbove: isIntegerAbove_1.default,
+    IntAboveOrEqual: isIntegerAboveOrEqual_1.default,
+    IntBelow: isIntegerBelow_1.default,
+    IntBelowOrEqual: isIntegerBelowOrEqual_1.default,
+    IntGt: isIntegerAbove_1.default,
+    IntGte: isIntegerAboveOrEqual_1.default,
+    IntLt: isIntegerBelow_1.default,
+    IntLte: isIntegerBelowOrEqual_1.default,
+    Integer: isInteger_1.default,
+    IntegerBetween: isIntegerBetween_1.default,
+    IntegerBelow: isIntegerBelow_1.default,
+    IntegerBelowOrEqual: isIntegerBelowOrEqual_1.default,
+    IntegerAbove: isIntegerAbove_1.default,
+    IntegerAboveOrEqual: isIntegerAboveOrEqual_1.default,
+    RegExp: is_6.default,
+    Object: is_7.default,
+    NeObject: isNotEmpty_2.default,
+    NotEmptyObject: isNotEmpty_2.default,
+    String: is_8.default,
+    StringBetween: isBetween_2.default,
+    NeString: isNotEmpty_3.default,
+    NotEmptyString: isNotEmpty_3.default,
+    Equal: equal_1.default,
+    Eq: equal_1.default,
+});
+exports.default = Is;

package/dist/number/is.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check whether or not a provided value is a number
+ *
+ * @param val - Value to verify
+ *
+ * @returns Whether or not the value is a number
+ */
+export default function isNumber(val: any): boolean;

package/dist/number/is.js

@@ -0,0 +1,6 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function isNumber(val) {
+    return Number.isFinite(val);
+}
+exports.default = isNumber;

package/dist/number/isAbove.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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
+ */
+export default function isNumberAbove(val: any, ref: number): boolean;

package/dist/number/isAbove.js

@@ -0,0 +1,6 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function isNumberAbove(val, ref) {
+    return !Number.isFinite(val) || !Number.isFinite(ref) ? false : val > ref;
+}
+exports.default = isNumberAbove;

package/dist/number/isAboveOrEqual.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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
+ */
+export default function isNumberAboveOrEqual(val: any, ref: number): boolean;

package/dist/number/isAboveOrEqual.js

@@ -0,0 +1,6 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function isNumberAboveOrEqual(val, ref) {
+    return !Number.isFinite(val) || !Number.isFinite(ref) ? false : val >= ref;
+}
+exports.default = isNumberAboveOrEqual;

package/dist/number/isBelow.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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
+ */
+export default function isNumberBelow(val: any, ref: number): boolean;

package/dist/number/isBelow.js

@@ -0,0 +1,6 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function isNumberBelow(val, ref) {
+    return !Number.isFinite(val) || !Number.isFinite(ref) ? false : val < ref;
+}
+exports.default = isNumberBelow;