@valkyriestudios/utils 12.47.0 → 12.48.0

package/cjs/array/join.js

@@ -4,7 +4,7 @@ exports.join = join;
 exports.default = join;
 const round_1 = require("../number/round");
 const isIntegerAboveOrEqual_1 = require("../number/isIntegerAboveOrEqual");
-const SPACE_RGX = /(\s)+/g;
+const SPACE_RGX = /\s+/g;
 function join(val, opts) {
     let normalized;
     if (Array.isArray(val)) {

package/cjs/date/diff.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.diff = diff;
 exports.default = diff;
 const convertToDate_1 = require("./convertToDate");
-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;
+const INV_SECOND_IN_MILLISECONDS = 1.0 / 1000;
+const INV_MINUTE_IN_MILLISECONDS = 1.0 / (60 * 1000);
+const INV_HOUR_IN_MILLISECONDS = 1.0 / (60 * 60 * 1000);
+const INV_DAY_IN_MILLISECONDS = 1.0 / (24 * 60 * 60 * 1000);
+const INV_WEEK_IN_MILLISECONDS = 1.0 / (7 * 24 * 60 * 60 * 1000);
 function diff(val_a, val_b, key = 'millisecond') {
     const n_val_a = (0, convertToDate_1.convertToDate)(val_a);
     const n_val_b = (0, convertToDate_1.convertToDate)(val_b);
@@ -18,19 +18,19 @@ function diff(val_a, val_b, key = 'millisecond') {
     switch (key) {
         case 'week':
         case 'weeks':
-            return diff_in_ms / WEEK_IN_MILLISECONDS;
+            return diff_in_ms * INV_WEEK_IN_MILLISECONDS;
         case 'day':
         case 'days':
-            return diff_in_ms / DAY_IN_MILLISECONDS;
+            return diff_in_ms * INV_DAY_IN_MILLISECONDS;
         case 'hour':
         case 'hours':
-            return diff_in_ms / HOUR_IN_MILLISECONDS;
+            return diff_in_ms * INV_HOUR_IN_MILLISECONDS;
         case 'minute':
         case 'minutes':
-            return diff_in_ms / MINUTE_IN_MILLISECONDS;
+            return diff_in_ms * INV_MINUTE_IN_MILLISECONDS;
         case 'second':
         case 'seconds':
-            return diff_in_ms / SECOND_IN_MILLISECONDS;
+            return diff_in_ms * INV_SECOND_IN_MILLISECONDS;
         default:
             return diff_in_ms;
     }

package/cjs/deep/get.js

@@ -3,87 +3,61 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deepGet = deepGet;
 exports.default = deepGet;
 function deepGet(obj, path, get_parent = false) {
-    if (Object.prototype.toString.call(obj) !== '[object Object]' &&
-        !Array.isArray(obj))
+    if (Object.prototype.toString.call(obj) !== '[object Object]' && !Array.isArray(obj)) {
         throw new TypeError('deepGet: Requires object or array');
-    if (typeof path !== 'string' ||
-        !path.length)
+    }
+    if (!path || typeof path !== 'string') {
         throw new TypeError('deepGet: Invalid path provided');
-    const nodes = [];
-    let node = obj;
-    let key = '';
-    for (let i = 0; i < path.length; i++) {
-        const char = path[i];
-        switch (char) {
-            case '[':
-            case ']':
-            case '.':
-                if (!key)
-                    break;
-                if (Array.isArray(node)) {
-                    let ix = Number(key);
-                    if (!isNaN(ix)) {
-                        ix = ix | 0;
-                        if (ix < 0 || ix > node.length - 1)
-                            return undefined;
-                        node = node[ix];
-                        nodes.push(node);
-                    }
-                    else {
-                        const extracted = [];
-                        for (let y = 0; y < node.length; y++) {
-                            const el = deepGet(node[y], key);
-                            if (el !== undefined) {
-                                extracted.push(...Array.isArray(el) ? el : [el]);
+    }
+    let cursor = obj;
+    let parent = obj;
+    let keyStart = 0;
+    const len = path.length;
+    for (let i = 0; i <= len; i++) {
+        const code = i === len ? 46 : path.charCodeAt(i);
+        if (code === 46 || code === 91 || code === 93) {
+            if (i === keyStart) {
+                keyStart = i + 1;
+                continue;
+            }
+            const key = path.substring(keyStart, i);
+            keyStart = i + 1;
+            parent = cursor;
+            if (Array.isArray(cursor)) {
+                const idx = +key;
+                if (idx === idx) {
+                    cursor = cursor[idx | 0];
+                }
+                else {
+                    const mapped = [];
+                    const cLen = cursor.length;
+                    for (let j = 0; j < cLen; j++) {
+                        const item = cursor[j];
+                        if (item && typeof item === 'object') {
+                            const val = item[key];
+                            if (val !== undefined) {
+                                if (Array.isArray(val)) {
+                                    const vLen = val.length;
+                                    for (let k = 0; k < vLen; k++)
+                                        mapped.push(val[k]);
+                                }
+                                else {
+                                    mapped.push(val);
+                                }
                             }
                         }
-                        node = extracted;
-                        nodes.push(node);
                     }
+                    if (mapped.length === 0)
+                        return undefined;
+                    cursor = mapped;
                 }
-                else if (typeof node === 'object' && node !== null) {
-                    node = node[key];
-                    nodes.push(node);
-                }
-                key = '';
-                break;
-            default:
-                key += char;
-                break;
-        }
-    }
-    if (key) {
-        if (Array.isArray(node)) {
-            let ix = Number(key);
-            if (!isNaN(ix)) {
-                ix = ix | 0;
-                if (ix < 0 || ix > node.length - 1)
-                    return undefined;
-                node = node[ix];
-                nodes.push(node);
             }
-            else {
-                const extracted = [];
-                for (let i = 0; i < node.length; i++) {
-                    const val = node[i]?.[key];
-                    if (val !== undefined)
-                        extracted.push(...Array.isArray(val) ? val : [val]);
-                }
-                node = extracted.length ? extracted : undefined;
-                nodes.push(node);
+            else if (cursor) {
+                cursor = cursor[key];
             }
-        }
-        else if (typeof node === 'object' && node !== null) {
-            node = node[key];
-            nodes.push(node);
-            if (node === undefined)
+            if (cursor === undefined)
                 return undefined;
         }
-        else {
-            return undefined;
-        }
     }
-    if (get_parent)
-        nodes.pop();
-    return nodes.length ? nodes.pop() : obj;
+    return get_parent ? parent : cursor;
 }

package/cjs/deep/set.js

@@ -9,45 +9,82 @@ function deepSet(obj, path, value, define = false) {
         throw new TypeError('Deepset is only supported for objects');
     if (typeof path !== 'string')
         throw new TypeError('No path was given');
-    if (RGX_MALICIOUS.test(path))
-        throw new TypeError('Malicious path provided');
-    const path_s = path.trim();
-    if (!path_s.length)
+    if (path.trim().length === 0) {
         throw new TypeError('No path was given');
-    const parts = path_s
-        .replace(/\[/g, '.')
-        .replace(/(\.){2,}/g, '.')
-        .replace(/(^\.|\.$|\])/g, '')
-        .split('.');
-    const last_part_ix = parts.length - 1;
-    for (let i = 0; i < last_part_ix; i++) {
-        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[last_part_ix], value);
-    }
-    else if (Array.isArray(obj)) {
-        const idx = parseInt(parts[last_part_ix]);
-        if (!Number.isInteger(idx) || idx < 0)
-            throw new TypeError('Invalid path provided');
-        obj[idx] = value;
+    if (RGX_MALICIOUS.test(path)) {
+        throw new TypeError('Malicious path provided');
     }
-    else {
-        obj[parts[last_part_ix]] = value;
+    let cursor = obj;
+    let keyStart = 0;
+    const len = path.length;
+    for (let i = 0; i <= len; i++) {
+        const code = i === len ? 46 : path.charCodeAt(i);
+        if (code === 46 || code === 91 || code === 93) {
+            if (i === keyStart) {
+                keyStart = i + 1;
+                continue;
+            }
+            const key = path.substring(keyStart, i);
+            keyStart = i + 1;
+            let isEnd = i === len;
+            if (!isEnd) {
+                let j = i + 1;
+                isEnd = true;
+                for (; j < len; j++) {
+                    const c = path.charCodeAt(j);
+                    if (c !== 46 && c !== 91 && c !== 93) {
+                        isEnd = false;
+                        break;
+                    }
+                }
+            }
+            if (isEnd) {
+                if (Array.isArray(cursor)) {
+                    const idx = +key;
+                    if (idx !== idx || (idx | 0) !== idx || idx < 0) {
+                        throw new TypeError('Invalid path provided');
+                    }
+                    if (define) {
+                        Object.defineProperty(cursor, key, value);
+                    }
+                    else {
+                        cursor[idx] = value;
+                    }
+                }
+                else if (define) {
+                    Object.defineProperty(cursor, key, value);
+                }
+                else {
+                    cursor[key] = value;
+                }
+                return true;
+            }
+            let nextCursor;
+            if (Array.isArray(cursor)) {
+                const idx = +key;
+                if (idx !== idx || (idx | 0) !== idx || idx < 0) {
+                    throw new TypeError('Invalid path provided');
+                }
+                nextCursor = cursor[idx];
+            }
+            else {
+                nextCursor = cursor[key];
+            }
+            if (nextCursor === undefined || nextCursor === null) {
+                nextCursor = {};
+                if (Array.isArray(cursor)) {
+                    cursor[+key] = nextCursor;
+                }
+                else {
+                    cursor[key] = nextCursor;
+                }
+            }
+            else if (typeof nextCursor !== 'object') {
+                return false;
+            }
+            cursor = nextCursor;
+        }
     }
-    return true;
+    return false;
 }

package/cjs/formdata/toObject.js

@@ -3,96 +3,131 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.toObject = toObject;
 exports.default = toObject;
 const isFormat_1 = require("../date/isFormat");
-const RGX_TOKENS = /[^.[\]]+/g;
+const forbiddenKeys_1 = require("../string/forbiddenKeys");
 function assign(acc, rawkey, value, single) {
+    if (rawkey.indexOf('.') === -1 && rawkey.indexOf('[') === -1) {
+        if (forbiddenKeys_1.FORBIDDEN_KEYS.has(rawkey))
+            return;
+        if (single?.has(rawkey)) {
+            acc[rawkey] = value;
+            return;
+        }
+        const existing = acc[rawkey];
+        if (existing === undefined) {
+            acc[rawkey] = value;
+        }
+        else if (Array.isArray(existing)) {
+            existing.push(value);
+        }
+        else {
+            acc[rawkey] = [existing, value];
+        }
+        return;
+    }
+    const keys = [];
+    let start = 0;
+    const len = rawkey.length;
+    for (let i = 0; i < len; i++) {
+        const code = rawkey.charCodeAt(i);
+        if (code === 46 || code === 91 || code === 93) {
+            if (i > start)
+                keys.push(rawkey.substring(start, i));
+            start = i + 1;
+        }
+    }
+    if (start < len)
+        keys.push(rawkey.substring(start));
     let cursor = acc;
-    const keys = rawkey.match(RGX_TOKENS);
     const keys_len = keys.length;
     for (let i = 0; i < keys_len; i++) {
         const key = keys[i];
-        switch (key) {
-            case '__proto__':
-            case 'constructor':
-            case 'prototype':
-                return;
-            default: {
-                if (i < (keys_len - 1)) {
-                    const n_key = Array.isArray(cursor) ? Number(key) : key;
-                    if (!cursor[n_key])
-                        cursor[n_key] = isNaN(Number(keys[i + 1])) ? {} : [];
-                    cursor = cursor[n_key];
-                }
-                else if (!(key in cursor) || (single && single.has(key))) {
-                    cursor[key] = value;
+        if (forbiddenKeys_1.FORBIDDEN_KEYS.has(key))
+            return;
+        const isLast = i === keys_len - 1;
+        const cursorKey = Array.isArray(cursor) ? +key : key;
+        if (isLast) {
+            if (cursor[cursorKey] === undefined || (single && single.has(key))) {
+                cursor[cursorKey] = value;
+            }
+            else {
+                const existing = cursor[cursorKey];
+                if (Array.isArray(existing)) {
+                    existing.push(value);
                 }
                 else {
-                    const cursor_val = cursor[key];
-                    if (Array.isArray(cursor_val)) {
-                        cursor_val.push(value);
-                    }
-                    else {
-                        cursor[key] = [cursor_val, value];
-                    }
+                    cursor[cursorKey] = [existing, value];
                 }
             }
         }
+        else {
+            if (cursor[cursorKey] === undefined) {
+                cursor[cursorKey] = isNaN(+keys[i + 1]) ? {} : [];
+            }
+            cursor = cursor[cursorKey];
+        }
     }
 }
 function toObject(form, config) {
     if (!(form instanceof FormData))
         throw new Error('formdata/toObject: Value is not an instance of FormData');
-    const set = config?.raw === true ? null : new Set(Array.isArray(config?.raw) ? config?.raw : []);
-    const set_guard = !!(set && set.size > 0);
-    const single = Array.isArray(config?.single) ? new Set(config.single) : null;
-    const nBool = config?.normalize_bool !== false;
-    const nNull = config?.normalize_null !== false;
-    const nDate = config?.normalize_date !== false;
-    const nNumber = config?.normalize_number !== false;
     const acc = {};
-    if (set === null) {
+    const single = Array.isArray(config?.single) ? new Set(config.single) : null;
+    if (config?.raw === true) {
         for (const [key, value] of form) {
             assign(acc, key, value, single);
         }
         return acc;
     }
+    const rawConfig = config?.raw;
+    const set = rawConfig ? new Set(Array.isArray(rawConfig) ? rawConfig : []) : null;
+    const hasSet = set !== null && set.size > 0;
+    const nBool = config?.normalize_bool !== false;
+    const nNull = config?.normalize_null !== false;
+    const nDate = config?.normalize_date !== false;
+    const nNumber = config?.normalize_number !== false;
     for (const [key, value] of form) {
-        if (set_guard && set.has(key)) {
+        if (hasSet && set.has(key)) {
             assign(acc, key, value, single);
             continue;
         }
-        switch (value) {
-            case 'true':
-            case 'TRUE':
-            case 'True':
-                assign(acc, key, nBool ? true : value, single);
-                continue;
-            case 'false':
-            case 'FALSE':
-            case 'False':
-                assign(acc, key, nBool ? false : value, single);
-                continue;
-            case 'null':
-            case 'NULL':
-            case 'Null':
-                assign(acc, key, nNull ? null : value, single);
+        if (typeof value === 'string') {
+            const len = value.length;
+            if (len === 0) {
+                assign(acc, key, value, single);
                 continue;
-            default: {
-                if (typeof value === 'string' && value) {
-                    if (nNumber && value[0] !== '0') {
-                        const nVal = Number(value);
-                        if (!isNaN(nVal)) {
-                            assign(acc, key, nVal, single);
-                            continue;
-                        }
-                    }
-                    if (nDate && value[4] === '-' && value[7] === '-' && value[10] === 'T' && (0, isFormat_1.isDateFormat)(value, 'ISO')) {
-                        assign(acc, key, new Date(value), single);
-                        continue;
-                    }
+            }
+            if (len === 4) {
+                if (nBool && (value === 'true' || value === 'TRUE' || value === 'True')) {
+                    assign(acc, key, true, single);
+                    continue;
                 }
-                assign(acc, key, value, single);
+                if (nNull && (value === 'null' || value === 'NULL' || value === 'Null')) {
+                    assign(acc, key, null, single);
+                    continue;
+                }
+            }
+            else if (len === 5) {
+                if (nBool && (value === 'false' || value === 'FALSE' || value === 'False')) {
+                    assign(acc, key, false, single);
+                    continue;
+                }
+            }
+            if (nNumber && value.charCodeAt(0) !== 48) {
+                const nVal = +value;
+                if (!isNaN(nVal)) {
+                    assign(acc, key, nVal, single);
+                    continue;
+                }
+            }
+            if (nDate && len >= 10 &&
+                value.charCodeAt(4) === 45 &&
+                value.charCodeAt(7) === 45 &&
+                (0, isFormat_1.isDateFormat)(value, 'ISO')) {
+                assign(acc, key, new Date(value), single);
+                continue;
             }
         }
+        assign(acc, key, value, single);
     }
     return acc;
 }

package/cjs/hash/djb2.js

@@ -10,5 +10,5 @@ function djb2(data) {
     for (let i = 0; i < len; i++) {
         hash = ((hash << 5) + hash) ^ normalized.charCodeAt(i);
     }
-    return String(hash >>> 0);
+    return (hash >>> 0).toString();
 }

package/cjs/hash/fnv1A.js

@@ -6,13 +6,14 @@ exports.default = fnv1A;
 const utils_1 = require("./utils");
 exports.FNV_32 = 2166136261;
 exports.FNV_64 = 1099511628211n;
+const FNV_PRIME = 16777619;
 function fnv1A(data, offset = exports.FNV_32) {
     let hash = offset;
-    const normalized = (0, utils_1.toString)(data);
-    const len = normalized.length;
+    const str = (0, utils_1.toString)(data);
+    const len = str.length;
     for (let i = 0; i < len; i++) {
-        hash ^= normalized.charCodeAt(i);
-        hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+        hash ^= str.charCodeAt(i);
+        hash = Math.imul(hash, FNV_PRIME);
     }
     return hash >>> 0;
 }

package/cjs/hash/guid.js

@@ -2,27 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.guid = guid;
 exports.default = guid;
+const CRYPTO = globalThis.crypto;
 const HEX = [];
 for (let i = 0; i < 256; i++) {
-    HEX[i] = (i < 16 ? '0' : '') + i.toString(16);
-}
-let pool = new Uint8Array(0);
-let poolIdx = 0;
-function refill(size = 16 * 1024) {
-    pool = new Uint8Array(size);
-    crypto.getRandomValues(pool);
-    poolIdx = 0;
+    HEX[i] = (i + 256).toString(16).substring(1);
 }
+const POOL_SIZE = 16 * 1024;
+const pool = new Uint8Array(POOL_SIZE);
+let poolIdx = POOL_SIZE;
 function guid() {
-    if (poolIdx + 16 > pool.length)
-        refill();
-    const buf = pool.subarray(poolIdx, poolIdx + 16);
+    if (poolIdx + 16 > POOL_SIZE) {
+        CRYPTO.getRandomValues(pool);
+        poolIdx = 0;
+    }
+    const p = poolIdx;
     poolIdx += 16;
-    buf[6] = (buf[6] & 0x0f) | 0x40;
-    buf[8] = (buf[8] & 0x3f) | 0x80;
-    return (HEX[buf[0]] + HEX[buf[1]] + HEX[buf[2]] + HEX[buf[3]] + '-' +
-        HEX[buf[4]] + HEX[buf[5]] + '-' +
-        HEX[buf[6]] + HEX[buf[7]] + '-' +
-        HEX[buf[8]] + HEX[buf[9]] + '-' +
-        HEX[buf[10]] + HEX[buf[11]] + HEX[buf[12]] + HEX[buf[13]] + HEX[buf[14]] + HEX[buf[15]]);
+    return (HEX[pool[p]] +
+        HEX[pool[p + 1]] +
+        HEX[pool[p + 2]] +
+        HEX[pool[p + 3]] +
+        '-' +
+        HEX[pool[p + 4]] +
+        HEX[pool[p + 5]] +
+        '-' +
+        HEX[(pool[p + 6] & 0x0f) | 0x40] +
+        HEX[pool[p + 7]] +
+        '-' +
+        HEX[(pool[p + 8] & 0x3f) | 0x80] +
+        HEX[pool[p + 9]] +
+        '-' +
+        HEX[pool[p + 10]] +
+        HEX[pool[p + 11]] +
+        HEX[pool[p + 12]] +
+        HEX[pool[p + 13]] +
+        HEX[pool[p + 14]] +
+        HEX[pool[p + 15]]);
 }

package/cjs/hash/hexId.js

@@ -2,27 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hexId = hexId;
 exports.default = hexId;
+const CRYPTO = globalThis.crypto;
 const HEX = [];
 for (let i = 0; i < 256; i++) {
-    HEX[i] = (i < 16 ? '0' : '') + i.toString(16);
-}
-let pool = new Uint8Array(0);
-let poolIdx = 0;
-function refill(size = 16 * 1024) {
-    pool = new Uint8Array(size);
-    crypto.getRandomValues(pool);
-    poolIdx = 0;
+    HEX[i] = (i + 256).toString(16).substring(1);
 }
+const POOL_SIZE = 16 * 1024;
+const pool = new Uint8Array(POOL_SIZE);
+let poolIdx = POOL_SIZE;
 function hexId(size) {
-    if (!Number.isInteger(size) || size <= 0)
+    if (typeof size !== 'number' || size <= 0)
         return '';
-    if (poolIdx + size > pool.length)
-        refill();
-    const buf = pool.subarray(poolIdx, poolIdx + size);
+    if (size > POOL_SIZE) {
+        const buf = new Uint8Array(size);
+        CRYPTO.getRandomValues(buf);
+        let out = '';
+        for (let i = 0; i < size; i++) {
+            out += HEX[buf[i]];
+        }
+        return out;
+    }
+    if (poolIdx + size > POOL_SIZE) {
+        CRYPTO.getRandomValues(pool);
+        poolIdx = 0;
+    }
+    let i = poolIdx;
+    const end = i + size;
     poolIdx += size;
     let out = '';
-    for (let i = 0; i < buf.length; i++) {
-        out += HEX[buf[i]];
-    }
+    while (i < end)
+        out += HEX[pool[i++]];
     return out;
 }