@valkyriestudios/utils 12.47.0 → 12.49.0

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 (nVal === 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 || (size | 0) !== size)
         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;
 }

package/cjs/hash/utils.js

@@ -2,39 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toString = toString;
 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/cjs/hash/uuidv7.js

@@ -2,41 +2,42 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uuidv7 = uuidv7;
 exports.default = uuidv7;
+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]]);
 }

package/cjs/number/round.js

@@ -6,7 +6,7 @@ const ROUND_EPSILON = 1 + Number.EPSILON;
 function round(val, precision = 0) {
     if (!Number.isFinite(val))
         throw new TypeError('Value should be numeric');
-    if (!Number.isInteger(precision) || precision <= 0)
+    if (typeof precision !== 'number' || precision <= 0 || (precision | 0) !== precision)
         return Math.round(val * ROUND_EPSILON);
     const exp = Math.pow(10, precision);
     return Math.round((val * exp) * ROUND_EPSILON) / exp;

package/cjs/string/forbiddenKeys.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORBIDDEN_KEYS = void 0;
+exports.FORBIDDEN_KEYS = new Set([
+    '__proto__',
+    'constructor',
+    'prototype',
+]);

package/cjs/string/humanizeNumber.js

@@ -9,6 +9,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
@@ -25,7 +26,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/esm/array/join.js

@@ -1,6 +1,6 @@
 import { round } from '../number/round';
 import { isIntegerAboveOrEqual } from '../number/isIntegerAboveOrEqual';
-const SPACE_RGX = /(\s)+/g;
+const SPACE_RGX = /\s+/g;
 function join(val, opts) {
     let normalized;
     if (Array.isArray(val)) {

package/esm/date/convertToDate.js

@@ -1,12 +1,19 @@
-import { isDate } from './is';
 function convertToDate(val) {
-    if (isDate(val)) {
-        return val;
+    switch (typeof val) {
+        case 'number': {
+            if (val !== val)
+                return null;
+            const d = new Date(val);
+            return d.getTime() === d.getTime() ? d : null;
+        }
+        case 'object':
+            return val instanceof Date && val.getTime() === val.getTime() ? val : null;
+        case 'string': {
+            const d = new Date(val);
+            return d.getTime() === d.getTime() ? d : null;
+        }
+        default:
+            return null;
     }
-    else if (typeof val === 'string') {
-        const date = new Date(val);
-        return Number.isNaN(date.getTime()) ? null : date;
-    }
-    return null;
 }
 export { convertToDate, convertToDate as default };

package/esm/date/diff.js

@@ -1,9 +1,9 @@
 import { convertToDate } from './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 = convertToDate(val_a);
     const n_val_b = convertToDate(val_b);
@@ -14,19 +14,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;
     }