@valkyriestudios/utils 10.0.0 → 11.1.0

package/dist/date/diff.js

@@ -0,0 +1,38 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = require("./is");
+const SECOND_IN_MILLISECONDS = 1000;
+const MINUTE_IN_MILLISECONDS = SECOND_IN_MILLISECONDS * 60;
+const HOUR_IN_MILLISECONDS = MINUTE_IN_MILLISECONDS * 60;
+const DAY_IN_MILLISECONDS = HOUR_IN_MILLISECONDS * 24;
+const WEEK_IN_MILLISECONDS = DAY_IN_MILLISECONDS * 7;
+function diff(val_a, val_b, key = 'millisecond') {
+    if (!(0, is_1.default)(val_a) ||
+        !(0, is_1.default)(val_b))
+        throw new TypeError('Diff requires date objects for both values');
+    if (typeof key !== 'string')
+        throw new TypeError('Key needs to be a string');
+    const diff_in_ms = val_a.valueOf() - val_b.valueOf();
+    switch (key) {
+        case 'week':
+        case 'weeks':
+            return diff_in_ms / WEEK_IN_MILLISECONDS;
+        case 'day':
+        case 'days':
+            return diff_in_ms / DAY_IN_MILLISECONDS;
+        case 'hour':
+        case 'hours':
+            return diff_in_ms / HOUR_IN_MILLISECONDS;
+        case 'minute':
+        case 'minutes':
+            return diff_in_ms / MINUTE_IN_MILLISECONDS;
+        case 'second':
+        case 'seconds':
+            return diff_in_ms / SECOND_IN_MILLISECONDS;
+        case 'millisecond':
+        case 'milliseconds':
+        default:
+            return diff_in_ms;
+    }
+}
+exports.default = diff;

package/dist/date/endOfUTC.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Sets the provided date to end of UTC of provided key
+ *
+ * @param val - Date to set to end of
+ * @param key - (default='millisecond') Key to set
+ *
+ * @returns New date set to end of key
+ */
+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;

package/dist/date/endOfUTC.js

@@ -0,0 +1,52 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = require("./is");
+const WEEK_END = {
+    week: 0,
+    week_sun: 6,
+    week_mon: 0,
+    week_tue: 1,
+    week_wed: 2,
+    week_thu: 3,
+    week_fri: 4,
+    week_sat: 5,
+};
+function endOfUTC(val, key = 'millisecond') {
+    if (!(0, is_1.default)(val))
+        throw new TypeError('endOfUTC requires a date object');
+    if (typeof key !== 'string')
+        throw new TypeError('Key needs to be a string with content');
+    switch (key) {
+        case 'year':
+            return new Date(Date.UTC(val.getUTCFullYear(), 11, 31, 23, 59, 59, 999));
+        case 'quarter': {
+            return new Date(Date.UTC(val.getUTCFullYear(), (val.getUTCMonth() - (val.getUTCMonth() % 3)) + 3, 0, 23, 59, 59, 999));
+        }
+        case 'month':
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth() + 1, 0, 23, 59, 59, 999));
+        case 'week':
+        case 'week_sun':
+        case 'week_mon':
+        case 'week_tue':
+        case 'week_wed':
+        case 'week_thu':
+        case 'week_fri':
+        case 'week_sat': {
+            const UTC_DAY = val.getUTCDay();
+            const UTC_EOD = WEEK_END[key];
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate() + (UTC_DAY <= UTC_EOD ? UTC_EOD - UTC_DAY : (7 - UTC_DAY) + UTC_EOD), 23, 59, 59, 999));
+        }
+        case 'day':
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), 23, 59, 59, 999));
+        case 'hour':
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), val.getUTCHours(), 59, 59, 999));
+        case 'minute':
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), val.getUTCHours(), val.getUTCMinutes(), 59, 999));
+        case 'second':
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), val.getUTCHours(), val.getUTCMinutes(), val.getUTCSeconds(), 999));
+        case 'millisecond':
+        default:
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), val.getUTCHours(), val.getUTCMinutes(), val.getUTCSeconds(), val.getUTCMilliseconds()));
+    }
+}
+exports.default = endOfUTC;

package/dist/date/is.d.ts

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

package/dist/date/is.js

@@ -0,0 +1,6 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function isDate(val) {
+    return Object.prototype.toString.call(val) === '[object Date]' && !isNaN(val);
+}
+exports.default = isDate;

package/dist/date/nowUnix.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Compute the current unix timestamp in seconds
+ *
+ * @returns Current unix timestamp in seconds
+ */
+export default function nowUnix(): number;

package/dist/date/nowUnix.js

@@ -0,0 +1,6 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function nowUnix() {
+    return Math.floor(Date.now() / 1000);
+}
+exports.default = nowUnix;

package/dist/date/nowUnixMs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Compute the current unix timestamp in milliseconds
+ *
+ * @returns Current unix timestamp in milliseconds
+ */
+export default function nowUnixMs(): number;

package/dist/date/nowUnixMs.js

@@ -0,0 +1,6 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function nowUnixMs() {
+    return Math.floor(Date.now());
+}
+exports.default = nowUnixMs;

package/dist/date/startOfUTC.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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
+ */
+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;

package/dist/date/startOfUTC.js

@@ -0,0 +1,52 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = require("./is");
+const WEEK_START = {
+    week: 1,
+    week_sun: 0,
+    week_mon: 1,
+    week_tue: 2,
+    week_wed: 3,
+    week_thu: 4,
+    week_fri: 5,
+    week_sat: 6,
+};
+function startOfUTC(val, key = 'millisecond') {
+    if (!(0, is_1.default)(val))
+        throw new TypeError('startOfUTC requires a date object');
+    if (typeof key !== 'string')
+        throw new TypeError('Key needs to be a string with content');
+    switch (key) {
+        case 'year':
+            return new Date(Date.UTC(val.getUTCFullYear(), 0, 1, 0, 0, 0, 0));
+        case 'quarter': {
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth() - (val.getUTCMonth() % 3), 1, 0, 0, 0, 0));
+        }
+        case 'month':
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), 1, 0, 0, 0, 0));
+        case 'week':
+        case 'week_sun':
+        case 'week_mon':
+        case 'week_tue':
+        case 'week_wed':
+        case 'week_thu':
+        case 'week_fri':
+        case 'week_sat': {
+            const UTC_DAY = val.getUTCDay();
+            const UTC_SOD = WEEK_START[key];
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate() - (UTC_DAY < UTC_SOD ? (7 - UTC_SOD) + UTC_DAY : UTC_DAY - UTC_SOD), 0, 0, 0, 0));
+        }
+        case 'day':
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), 0, 0, 0, 0));
+        case 'hour':
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), val.getUTCHours(), 0, 0, 0));
+        case 'minute':
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), val.getUTCHours(), val.getUTCMinutes(), 0, 0));
+        case 'second':
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), val.getUTCHours(), val.getUTCMinutes(), val.getUTCSeconds(), 0));
+        case 'millisecond':
+        default:
+            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), val.getUTCHours(), val.getUTCMinutes(), val.getUTCSeconds(), val.getUTCMilliseconds()));
+    }
+}
+exports.default = startOfUTC;

package/dist/date/toUTC.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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
+ */
+export default function toUTC(val: Date): Date;

package/dist/date/toUTC.js

@@ -0,0 +1,9 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = require("./is");
+function toUTC(val) {
+    if (!(0, is_1.default)(val))
+        throw new TypeError('toUTC requires a date object');
+    return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), val.getUTCHours(), val.getUTCMinutes(), val.getUTCSeconds(), val.getUTCMilliseconds()));
+}
+exports.default = toUTC;

package/dist/date/toUnix.d.ts

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

package/dist/date/toUnix.js

@@ -0,0 +1,9 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = require("./is");
+function toUnix(val) {
+    if (!(0, is_1.default)(val))
+        throw new TypeError('toUnix requires a date object');
+    return Math.floor(val.valueOf() / 1000);
+}
+exports.default = toUnix;

package/dist/deep/freeze.d.ts

@@ -0,0 +1,14 @@
+type deepInput = {
+    [key: string]: any;
+} | {
+    [key: string]: any;
+}[] | any[];
+/**
+ * Recursively freezes all properties of an object
+ *
+ * @param obj - Object to deep freeze
+ *
+ * @returns Deeply frozen object
+ */
+export default function deepFreeze(obj: deepInput): Readonly<deepInput>;
+export {};

package/dist/deep/freeze.js

@@ -0,0 +1,23 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function deep(obj) {
+    if (Array.isArray(obj)) {
+        for (const el of obj)
+            deep(el);
+    }
+    else {
+        for (const key of Object.keys(obj)) {
+            if (Object.prototype.toString.call(obj[key]) === '[object Object]' ||
+                Array.isArray(obj[key]))
+                deep(obj[key]);
+        }
+    }
+    return Object.freeze(obj);
+}
+function deepFreeze(obj) {
+    if (Object.prototype.toString.call(obj) !== '[object Object]' &&
+        !Array.isArray(obj))
+        throw new TypeError('Only objects/arrays can be frozen');
+    return deep(obj);
+}
+exports.default = deepFreeze;

package/dist/deep/get.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Get a property's value deep inside the structure of an array/object
+ *
+ * Example:
+ *  const myObj = {
+ *      a: 2,
+ *      b: [
+ *          {price : 2},
+ *          {price : 4},
+ *      ],
+ *  };
+ *  deepGet(myObj, 'b[0].price');
+ * Output:
+ *  2
+ *
+ * @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}
+ */
+export default function deepGet(obj: {
+    [key: string]: any;
+} | {
+    [key: string]: any;
+}[] | any[], path: string, get_parent?: boolean): any | undefined;

package/dist/deep/get.js

@@ -0,0 +1,41 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function deepGet(obj, path, get_parent = false) {
+    if (Object.prototype.toString.call(obj) !== '[object Object]' &&
+        !Array.isArray(obj))
+        throw new TypeError('Deepget is only supported for objects');
+    if (typeof path !== 'string')
+        throw new TypeError('No path was given');
+    const path_s = path.trim();
+    if (path_s.length === 0)
+        throw new TypeError('No path was given');
+    const parts = path_s
+        .replace(/\[/g, '.')
+        .replace(/(\.){2,}/g, '.')
+        .replace(/(^\.|\.$|\])/g, '')
+        .split('.');
+    if (parts.length === 0 || (parts.length === 1 && get_parent))
+        return obj;
+    if (get_parent)
+        parts.pop();
+    let cursor = obj;
+    while (parts.length > 0) {
+        if (Array.isArray(cursor)) {
+            const ix = parseInt(parts.shift());
+            if (!Number.isInteger(ix) || ix < 0 || ix > (cursor.length - 1))
+                return undefined;
+            cursor = cursor[ix];
+        }
+        else if (Object.prototype.toString.call(cursor) === '[object Object]') {
+            const key = parts.shift();
+            if (!Object.prototype.hasOwnProperty.call(cursor, key))
+                return undefined;
+            cursor = cursor[key];
+        }
+        if ((!Array.isArray(cursor) && Object.prototype.toString.call(cursor) !== '[object Object]') &&
+            parts.length > 0)
+            return undefined;
+    }
+    return cursor;
+}
+exports.default = deepGet;

package/dist/deep/seal.d.ts

@@ -0,0 +1,14 @@
+type deepInput = {
+    [key: string]: any;
+} | {
+    [key: string]: any;
+}[] | any[];
+/**
+ * Recursively seals all properties of an object
+ *
+ * @param obj - Object to deep seal
+ *
+ * @returns Deeply sealed object
+ */
+export default function deepSeal(obj: deepInput): deepInput;
+export {};

package/dist/deep/seal.js

@@ -0,0 +1,23 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function deep(obj) {
+    if (Array.isArray(obj)) {
+        for (const el of obj)
+            deep(el);
+    }
+    else {
+        for (const key of Object.keys(obj)) {
+            if (Object.prototype.toString.call(obj[key]) === '[object Object]' ||
+                Array.isArray(obj[key]))
+                deep(obj[key]);
+        }
+    }
+    return Object.seal(obj);
+}
+function deepSeal(obj) {
+    if (Object.prototype.toString.call(obj) !== '[object Object]' &&
+        !Array.isArray(obj))
+        throw new TypeError('Only objects/arrays can be sealed');
+    return deep(obj);
+}
+exports.default = deepSeal;

package/dist/deep/set.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Sets a property and its value deep in the structure of an object
+ *
+ * Example:
+ *  const myObj = {a: 2};
+ *  deepSet(myObj, 'b.c.d.e', 4);
+ * Output:
+ *  {
+ *      a: 2,
+ *      b: {
+ *          c: {
+ *              d: {
+ *                  e: 4
+ *              }
+ *          }
+ *      }
+ *  }
+ *
+ * Example:
+ *  const myObj = {a: 2, b: [{price: 2}]};
+ *  deepSet(myObj, 'b[0].price', 4);
+ * Output:
+ *  {
+ *      a: 2,
+ *      b: [
+ *          {price: 4}
+ *      ]
+ *  }
+ *
+ * @param val - Object to set the value on
+ * @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}
+ */
+export default function deepSet(obj: {
+    [key: string]: any;
+} | {
+    [key: string]: any;
+}[] | any[], path: string, value: any, define?: boolean): boolean;

package/dist/deep/set.js

@@ -0,0 +1,52 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function deepSet(obj, path, value, define = false) {
+    if (Object.prototype.toString.call(obj) !== '[object Object]' &&
+        !Array.isArray(obj))
+        throw new TypeError('Deepset is only supported for objects');
+    if (typeof path !== 'string')
+        throw new TypeError('No path was given');
+    if (/__proto__|constructor|prototype/.test(path))
+        throw new TypeError('Malicious path provided');
+    const path_s = path.trim();
+    if (path_s.length === 0)
+        throw new TypeError('No path was given');
+    const parts = path_s
+        .replace(/\[/g, '.')
+        .replace(/(\.){2,}/g, '.')
+        .replace(/(^\.|\.$|\])/g, '')
+        .split('.');
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (parts[i] === '')
+            continue;
+        if (Array.isArray(obj)) {
+            const idx = parseInt(parts[i]);
+            if (!Number.isInteger(idx) || idx < 0)
+                throw new TypeError('Invalid path provided');
+            if (!obj[idx])
+                obj[idx] = {};
+            obj = obj[idx];
+        }
+        else {
+            if (!obj[parts[i]])
+                obj[parts[i]] = {};
+            obj = obj[parts[i]];
+        }
+    }
+    if (!Array.isArray(obj) && Object.prototype.toString.call(obj) !== '[object Object]')
+        return false;
+    if (define) {
+        Object.defineProperty(obj, parts[parts.length - 1], value);
+    }
+    else if (Array.isArray(obj)) {
+        const idx = parseInt(parts[parts.length - 1]);
+        if (!Number.isInteger(idx) || idx < 0)
+            throw new TypeError('Invalid path provided');
+        obj[idx] = value;
+    }
+    else {
+        obj[parts[parts.length - 1]] = value;
+    }
+    return true;
+}
+exports.default = deepSet;

package/dist/equal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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
+ */
+declare function equal(a: any, b: any): boolean;
+export default equal;

package/dist/equal.js

@@ -0,0 +1,43 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const isNumericalNaN_1 = require("./number/isNumericalNaN");
+function isArrayEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = a.length - 1; i >= 0; i--) {
+        if (equal(a[i], b[i]))
+            continue;
+        return false;
+    }
+    return true;
+}
+function isObjectEqual(a, b) {
+    const keys_a = Object.keys(a);
+    if (keys_a.length !== Object.keys(b).length)
+        return false;
+    for (let i = keys_a.length - 1; i >= 0; i--) {
+        if (equal(a[keys_a[i]], b[keys_a[i]]))
+            continue;
+        return false;
+    }
+    return true;
+}
+function equal(a, b) {
+    if (a instanceof Date &&
+        b instanceof Date)
+        return a.valueOf() === b.valueOf();
+    if (Object.prototype.toString.call(a) === '[object RegExp]' &&
+        Object.prototype.toString.call(b) === '[object RegExp]')
+        return String(a) === String(b);
+    if (Array.isArray(a) &&
+        Array.isArray(b))
+        return isArrayEqual(a, b);
+    if (Object.prototype.toString.call(a) === '[object Object]' &&
+        Object.prototype.toString.call(b) === '[object Object]')
+        return isObjectEqual(a, b);
+    if ((0, isNumericalNaN_1.default)(a)) {
+        return (0, isNumericalNaN_1.default)(b);
+    }
+    return a === b;
+}
+exports.default = equal;

package/dist/function/is.d.ts

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

package/dist/function/is.js

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

package/dist/function/noop.d.ts

@@ -0,0 +1,6 @@
+/**
+ * No-Operation (noop) function that does nothing and simply returns.
+ *
+ * @returns Void
+ */
+export default function noop(): void;

package/dist/function/noop.js

@@ -0,0 +1,5 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function noop() {
+}
+exports.default = noop;

package/dist/function/noopresolve.d.ts

@@ -0,0 +1,9 @@
+/**
+ * No-Operation (noop) resolver that simply returns a promise
+ * that resolves with the value that was passed to it
+ *
+ * @param val - Value to be resolved with
+ *
+ * @returns Promise that resolves with passed value
+ */
+export default function noopresolve(val?: any): Promise<any>;

package/dist/function/noopresolve.js

@@ -0,0 +1,6 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function noopresolve(val) {
+    return new Promise(resolve => resolve(val));
+}
+exports.default = noopresolve;

package/dist/function/noopreturn.d.ts

@@ -0,0 +1,8 @@
+/**
+ * No-Operation (noop) function that returns the value passed to it when called.
+ *
+ * @param val - Value to return
+ *
+ * @returns Passed value
+ */
+export default function noopreturn(val?: any): any;

package/dist/function/noopreturn.js

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

package/dist/function/sleep.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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
+ */
+export default function sleep(ms?: number): Promise<void>;

package/dist/function/sleep.js

@@ -0,0 +1,8 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function sleep(ms = 1000) {
+    return new Promise(resolve => {
+        setTimeout(() => resolve(), Number.isFinite(ms) && ms > 0 ? Math.round(ms) : 0);
+    });
+}
+exports.default = sleep;

package/dist/hash/fnv1A.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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
+ */
+export default function fnv1A(data: any, offset?: number): number;