@valkyriestudios/utils 12.46.0 → 12.48.0

package/esm/deep/set.js

@@ -5,46 +5,83 @@ 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;
 }
 export { deepSet, deepSet as default };

package/esm/formdata/toObject.js

@@ -1,94 +1,129 @@
 import { isDateFormat } from '../date/isFormat';
-const RGX_TOKENS = /[^.[\]]+/g;
+import { FORBIDDEN_KEYS } from '../string/forbiddenKeys';
 function assign(acc, rawkey, value, single) {
+    if (rawkey.indexOf('.') === -1 && rawkey.indexOf('[') === -1) {
+        if (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 (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' && 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 &&
+                isDateFormat(value, 'ISO')) {
+                assign(acc, key, new Date(value), single);
+                continue;
             }
         }
+        assign(acc, key, value, single);
     }
     return acc;
 }

package/esm/hash/djb2.js

@@ -6,6 +6,6 @@ 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();
 }
 export { djb2, djb2 as default };

package/esm/hash/fnv1A.js

@@ -1,13 +1,14 @@
 import { toString } from './utils';
 export const FNV_32 = 2166136261;
 export const FNV_64 = 1099511628211n;
+const FNV_PRIME = 16777619;
 function fnv1A(data, offset = FNV_32) {
     let hash = offset;
-    const normalized = toString(data);
-    const len = normalized.length;
+    const str = 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/esm/hash/guid.js

@@ -1,25 +1,37 @@
+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]]);
 }
 export { guid, guid as default };

package/esm/hash/hexId.js

@@ -1,25 +1,33 @@
+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;
 }
 export { hexId, hexId as default };

package/esm/hash/utils.js

@@ -1,37 +1,29 @@
 export function toString(raw) {
-    switch (typeof raw) {
-        case 'string':
-            return raw;
-        case 'number':
-            return Number.isFinite(raw) ? String(raw) : 'nan';
-        case 'bigint':
-            return raw.toString();
-        case 'boolean':
-            return raw ? 'true' : 'false';
-        case 'undefined':
-            return 'undefined';
-        case 'object':
-            if (raw === null) {
-                return 'null';
-            }
-            else if (Array.isArray(raw) || Object.prototype.toString.call(raw) === '[object Object]') {
-                return JSON.stringify(raw);
-            }
-            else if (raw instanceof RegExp) {
-                return String(raw);
-            }
-            else if (raw instanceof Date) {
-                return String(raw.getTime());
-            }
-            else if (raw instanceof Error) {
-                return raw.name + '|' + raw.message;
-            }
-            else {
-                throw new TypeError('A Hash could not be calculated for this datatype');
-            }
-        case 'symbol':
+    const type = typeof raw;
+    if (type === 'string')
+        return raw;
+    if (type === 'number')
+        return Number.isFinite(raw) ? String(raw) : 'nan';
+    if (type === 'boolean')
+        return raw ? 'true' : 'false';
+    if (type === 'undefined')
+        return 'undefined';
+    if (type === 'object') {
+        if (raw === null)
+            return 'null';
+        if (Array.isArray(raw) || Object.prototype.toString.call(raw) === '[object Object]')
+            return JSON.stringify(raw);
+        if (raw instanceof Date)
+            return String(raw.getTime());
+        if (raw instanceof RegExp)
             return String(raw);
-        default:
-            throw new TypeError('A Hash could not be calculated for this datatype');
+        if (raw instanceof Error)
+            return raw.name + '|' + raw.message;
+        throw new TypeError('A Hash could not be calculated for this datatype');
     }
+    if (type === 'bigint')
+        return raw.toString();
+    if (type === 'symbol')
+        return raw.toString();
+    throw new TypeError('A Hash could not be calculated for this datatype');
 }

package/esm/hash/uuidv7.js

@@ -1,39 +1,40 @@
+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 uuidv7() {
-    if (poolIdx + 10 > pool.length)
-        refill();
-    const rand = pool.subarray(poolIdx, poolIdx + 10);
+    if (poolIdx + 10 > POOL_SIZE) {
+        CRYPTO.getRandomValues(pool);
+        poolIdx = 0;
+    }
+    const p = poolIdx;
     poolIdx += 10;
-    const time = BigInt(Date.now());
-    return (HEX[Number((time >> 40n) & 0xffn)] +
-        HEX[Number((time >> 32n) & 0xffn)] +
-        HEX[Number((time >> 24n) & 0xffn)] +
-        HEX[Number((time >> 16n) & 0xffn)] +
+    const time = Date.now();
+    const timeHi = (time / 4294967296) | 0;
+    const timeLo = time >>> 0;
+    return (HEX[(timeHi >>> 8) & 0xff] +
+        HEX[timeHi & 0xff] +
+        HEX[(timeLo >>> 24) & 0xff] +
+        HEX[(timeLo >>> 16) & 0xff] +
         '-' +
-        HEX[Number((time >> 8n) & 0xffn)] +
-        HEX[Number(time & 0xffn)] +
+        HEX[(timeLo >>> 8) & 0xff] +
+        HEX[timeLo & 0xff] +
         '-' +
-        HEX[(rand[0] & 0x0f) | 0x70] +
-        HEX[rand[1]] +
+        HEX[(pool[p] & 0x0f) | 0x70] +
+        HEX[pool[p + 1]] +
         '-' +
-        HEX[(rand[2] & 0x3f) | 0x80] +
-        HEX[rand[3]] +
+        HEX[(pool[p + 2] & 0x3f) | 0x80] +
+        HEX[pool[p + 3]] +
         '-' +
-        HEX[rand[4]] +
-        HEX[rand[5]] +
-        HEX[rand[6]] +
-        HEX[rand[7]] +
-        HEX[rand[8]] +
-        HEX[rand[9]]);
+        HEX[pool[p + 4]] +
+        HEX[pool[p + 5]] +
+        HEX[pool[p + 6]] +
+        HEX[pool[p + 7]] +
+        HEX[pool[p + 8]] +
+        HEX[pool[p + 9]]);
 }
 export { uuidv7, uuidv7 as default };

package/esm/string/forbiddenKeys.js

@@ -0,0 +1,5 @@
+export const FORBIDDEN_KEYS = new Set([
+    '__proto__',
+    'constructor',
+    'prototype',
+]);

package/esm/string/humanizeNumber.js

@@ -5,6 +5,7 @@ function humanizeNumber(val, options = {}) {
     const SEPARATOR = typeof options?.separator === 'string' && options.separator.length ? options.separator : '.';
     const PRECISION = Number.isInteger(options?.precision) && options.precision >= 0 ? options.precision : 2;
     const DIVIDER = Number.isInteger(options?.divider) && options.divider >= 2 ? options.divider : 1000;
+    const INV_DIVIDER = 1.0 / DIVIDER;
     const REAL = options?.real === true;
     const UNITS = Array.isArray(options?.units) && options.units.length
         ? options.units
@@ -21,7 +22,7 @@ function humanizeNumber(val, options = {}) {
     let unit_ix = 0;
     if (UNITS) {
         while (normalized >= DIVIDER && unit_ix < UNITS.length - 1) {
-            normalized /= DIVIDER;
+            normalized *= INV_DIVIDER;
             unit_ix++;
         }
     }

package/index.d.ts

@@ -291,6 +291,9 @@ declare module "date/index" {
     export { isDateFormat } from "date/isFormat";
     export { isDate } from "date/is";
 }
+declare module "string/forbiddenKeys" {
+    export const FORBIDDEN_KEYS: Set<string>;
+}
 declare module "formdata/toObject" {
     type ToObjectConfig = {
         raw?: string[] | boolean;