@valkyriestudios/utils 12.46.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/date/format.js

@@ -16,7 +16,7 @@ const WEEK_STARTS = {
 let DEFAULT_LOCALE = 'en-US';
 let DEFAULT_TZ = Intl?.DateTimeFormat?.().resolvedOptions?.().timeZone || 'UTC';
 let DEFAULT_SOW = 'mon';
-const ESCAPE_RGX = /\[[\s\S]+?]/g;
+const ESCAPE_RGX = /\[([^\]]*)]/g;
 const intl_formatters = new LRU_1.default({ max_size: 100 });
 const spec_cache = new LRU_1.default({ max_size: 100 });
 const zone_offset_cache = new LRU_1.default({ max_size: 100 });
@@ -138,6 +138,10 @@ const Tokens = [
 ]
     .map(el => [el[0], el[1], el[0].length])
     .sort((a, b) => a[0].length > b[0].length ? -1 : 1);
+const token_map = {};
+for (const t of Tokens)
+    token_map[t[0]] = t;
+const TOKENS_RGX = new RegExp(Tokens.map(([tok]) => tok).join('|'), 'g');
 function getSpecChain(spec) {
     const cached = spec_cache.get(spec);
     if (cached !== undefined)
@@ -146,30 +150,29 @@ function getSpecChain(spec) {
     const repl = [];
     let repl_len = 0;
     if (base.indexOf('[') >= 0) {
-        base = base.replace(ESCAPE_RGX, match => {
+        base = base.replace(ESCAPE_RGX, (_, inner) => {
             const escape_token = '$' + repl_len++ + '$';
-            repl.push([escape_token, match.slice(1, -1)]);
+            repl.push([escape_token, inner]);
             return escape_token;
         });
     }
-    const chain = [];
-    const matched_positions = new Set();
-    for (let i = 0; i < Tokens.length; i++) {
-        const [token] = Tokens[i];
-        let pos = base.indexOf(token);
-        const token_len = token.length;
-        while (pos !== -1) {
-            if (!matched_positions.has(pos)) {
-                chain.push(Tokens[i]);
-                for (let j = 0; j < token_len; j++) {
-                    matched_positions.add(pos + j);
-                }
-            }
-            pos = base.indexOf(token, pos + 1);
+    TOKENS_RGX.lastIndex = 0;
+    const parts = [];
+    let last_idx = 0;
+    let has_token = false;
+    let m;
+    while (m = TOKENS_RGX.exec(base)) {
+        if (m.index > last_idx) {
+            parts.push({ literal: base.slice(last_idx, m.index) });
         }
+        parts.push({ token: token_map[m[0]] });
+        has_token = true;
+        last_idx = m.index + m[0].length;
     }
-    const chain_len = chain.length;
-    const result = chain_len ? { base, chain, chain_len, repl } : null;
+    if (last_idx < base.length) {
+        parts.push({ literal: base.slice(last_idx) });
+    }
+    const result = has_token ? { parts, repl } : null;
     spec_cache.set(spec, result);
     return result;
 }
@@ -190,24 +193,22 @@ function format(val, spec, locale = DEFAULT_LOCALE, zone = DEFAULT_TZ, sow = DEF
     if (!n_spec)
         return n_val.toISOString();
     const d = toZone(n_val, zone);
-    let base = n_spec.base;
-    const repl = [...n_spec.repl];
-    let repl_len = n_spec.repl.length;
-    for (let i = 0; i < n_spec.chain_len; i++) {
-        const el = n_spec.chain[i];
-        let pos = base.indexOf(el[0]);
-        const token_val = el[1](d, locale, sow);
-        while (pos !== -1) {
-            const key = '$' + repl_len++ + '$';
-            repl.push([key, token_val]);
-            base = base.slice(0, pos) + key + base.slice(pos + el[2]);
-            pos = base.indexOf(el[0], pos + el[2]);
+    const { parts, repl } = n_spec;
+    let out = '';
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if ('literal' in part) {
+            out += part.literal;
+        }
+        else {
+            out += part.token[1](d, locale, sow);
         }
     }
-    for (let i = 0; i < repl_len; i++) {
-        base = base.replace(repl[i][0], repl[i][1]);
+    let result = out;
+    for (let i = 0; i < repl.length; i++) {
+        result = result.replace(repl[i][0], repl[i][1]);
     }
-    return base;
+    return result;
 }
 format.getLocale = function () {
     return DEFAULT_LOCALE;

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;
 }