@valkyriestudios/utils 12.36.0 → 12.38.0

package/array/groupBy.d.ts

@@ -1,4 +1,4 @@
-type Handler<T> = (val: T) => string | number | boolean;
+type Handler<T> = (val: T) => string | number | boolean | undefined;
 /**
  * Return a grouped object from an array.
  * Take Note: This function will automatically filter out any non/empty objects from the array
@@ -15,8 +15,8 @@ type Handler<T> = (val: T) => string | number | boolean;
  *      true: [{tally: 20, name: 'Peter'}, {tally: 40, name: 'Jake'}],
  *  }
  *
- * @param {T[]} arr - Array to group
+ * @param {T[]} val - Array or Set to group
  * @param {Handler<T>|keyof T} handler - String or a function, determines what to group by
  */
-declare function groupBy<T extends Record<string, any>>(arr: T[], handler: Handler<T> | keyof T): Record<string, T[]>;
+declare function groupBy<T extends Record<string, any>>(val: T[] | Set<T>, handler: Handler<T> | keyof T): Record<string, T[]>;
 export { groupBy, groupBy as default };

package/array/join.d.ts

@@ -39,8 +39,8 @@ interface joinOptions {
 /**
  * Join an array of values while autofiltering any non-string/non-number elements
  *
- * @param {unknown[]} val - Array of values to join
+ * @param {T[]|Set<T>} val - Array or Set of values to join
  * @param {joinOptions?} opts - Join options
  */
-declare function join(val: unknown[], opts?: joinOptions): string;
+declare function join<T>(val: T[] | Set<T>, opts?: joinOptions): string;
 export { join, join as default };

package/array/split.d.ts

@@ -2,16 +2,16 @@ type SplitOptions<T> = {
     filter_fn?: (el: T) => boolean;
 };
 /**
- * Splits the provided array in a set of batches according to the provided size
+ * Splits the provided array or set in a set of batches according to the provided size
  * For Example:
  *  split([1, 2, 3, 4, 5], 2) -> [[1,2],[3,4],[5]]
  *
  * For Example w/ filter
  *  split([1, false, 3, 4, 5], 2, {filter_fn: el => isInteger(el)}) -> [[1, 3], [4, 5]]
  *
- * @param {Array} val - Array to split
+ * @param {T[]|Set<T>} val - Array or Set to split
  * @param {number} size - Size of batches
  * @param {SplitOptions?} opts - Split options
  */
-declare function split<T>(arr: T[], size: number, opts?: SplitOptions<T>): T[][];
+declare function split<T>(arr: T[] | Set<T>, size: number, opts?: SplitOptions<T>): T[][];
 export { split, split as default };

package/caching/LRU.d.ts

@@ -8,7 +8,7 @@ export type LRUCacheOptions = {
 /**
  * Least-Recently-Used (LRU) Cache
  */
-declare class LRUCache<K, V> {
+declare class LRUCache<V> {
     #private;
     constructor(opts?: LRUCacheOptions);
     /**
@@ -24,32 +24,38 @@ declare class LRUCache<K, V> {
     /**
      * Returns whether or not a key exists in cache
      *
-     * @param {K} key - Key to retrieve
+     * @param {string} key - Key to retrieve
      */
-    has(key: K): boolean;
+    has(key: string): boolean;
     /**
      * Retrieves a value from the cache
      *
-     * @param {K} key - Key to retrieve
-     * @returns {V | undefined} Either the found value or undefined
+     * @param {string} key - Key to retrieve
      */
-    get(key: K): V | undefined;
+    get(key: string): V | undefined;
     /**
      * Sets a value on to the cache
      *
-     * @param {K} key - Key to set
+     * @param {string} key - Key to set
      * @param {V} value - Value to set for the key
      */
-    set(key: K, value: V): void;
+    set(key: string, value: V): void;
     /**
      * Removes a single value from the cache
      *
-     * @param {K} key - Key to remove
+     * @param {string} key - Key to remove
      */
-    del(key: K): void;
+    del(key: string): void;
     /**
      * Clears all contents of the cache
      */
     clear(): void;
+    /**
+     * MARK: Private
+     */
+    private addToFront;
+    private removeNode;
+    private moveToFront;
+    private evictTail;
 }
 export { LRUCache, LRUCache as default };

package/{array → cjs/array}/groupBy.js

@@ -5,9 +5,21 @@ exports.default = groupBy;
 const isNotEmpty_1 = require("../object/isNotEmpty");
 const FALLBACK = '_';
 const defaultHandler = () => FALLBACK;
-function groupBy(arr, handler) {
-    if (!Array.isArray(arr))
+function groupBy(val, handler) {
+    let normalized;
+    if (Array.isArray(val)) {
+        if (!val.length)
+            return {};
+        normalized = val;
+    }
+    else if (val instanceof Set) {
+        if (!val.size)
+            return {};
+        normalized = [...val];
+    }
+    else {
         return {};
+    }
     const acc = {};
     const n_handler = typeof handler === 'function'
         ? handler
@@ -16,8 +28,8 @@ function groupBy(arr, handler) {
             : defaultHandler;
     let key;
     let el;
-    for (let i = 0; i < arr.length; i++) {
-        el = arr[i];
+    for (let i = 0; i < normalized.length; i++) {
+        el = normalized[i];
         if (!(0, isNotEmpty_1.isNotEmptyObject)(el))
             continue;
         key = n_handler(el);

package/{array → cjs/array}/join.js

@@ -6,8 +6,20 @@ const round_1 = require("../number/round");
 const isIntegerAboveOrEqual_1 = require("../number/isIntegerAboveOrEqual");
 const SPACE_RGX = /(\s)+/g;
 function join(val, opts) {
-    if (!Array.isArray(val) || !val.length)
+    let normalized;
+    if (Array.isArray(val)) {
+        if (!val.length)
+            return '';
+        normalized = val;
+    }
+    else if (val instanceof Set) {
+        if (!val.size)
+            return '';
+        normalized = [...val];
+    }
+    else {
         return '';
+    }
     const DELIM = typeof opts?.delim === 'string' ? opts.delim : ' ';
     const DEDUPE = opts?.dedupe === true ? new Set() : null;
     const VALTRIM = opts?.valtrim ?? true;
@@ -15,8 +27,8 @@ function join(val, opts) {
     const VALROUND = (0, isIntegerAboveOrEqual_1.isIntegerAboveOrEqual)(opts?.valround, 0) ? opts.valround : false;
     let result = '';
     let has_val = false;
-    for (let i = 0; i < val.length; i++) {
-        const el = val[i];
+    for (let i = 0; i < normalized.length; i++) {
+        const el = normalized[i];
         let n_el;
         if (typeof el === 'string') {
             const trimmed = el.trim();

package/{array → cjs/array}/mapFnAsMap.js

@@ -15,7 +15,7 @@ function mapFnAsMap(arr, fn, opts) {
         if (Object.prototype.toString.call(el) !== '[object Object]')
             continue;
         const hash = fn(el);
-        if (Number.isFinite(hash) || (typeof hash === 'string' && hash.trim().length)) {
+        if (Number.isFinite(hash) || (typeof hash === 'string' && hash.length > 0)) {
             const transformed = TRANSFORM_FN ? TRANSFORM_FN(el) : el;
             map.set(hash, MERGE && map.has(hash) ? (0, merge_1.merge)(map.get(hash), transformed, { union: true }) : transformed);
         }

package/{array → cjs/array}/split.js

@@ -3,18 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.split = split;
 exports.default = split;
 function split(arr, size, opts) {
-    if (!Array.isArray(arr) ||
-        !Number.isInteger(size) ||
+    if (!Number.isInteger(size) ||
         size <= 0)
-        throw new Error('split requires an array and positive integer size');
+        throw new Error('split requires a positive integer size');
+    let normalized;
+    if (Array.isArray(arr)) {
+        normalized = arr;
+    }
+    else if (arr instanceof Set) {
+        normalized = [...arr];
+    }
+    else {
+        throw new Error('split requires an array or set');
+    }
     const FILTER_FN = typeof opts?.filter_fn === 'function' ? opts?.filter_fn : false;
     const result = [];
     let cursor = [];
     let ticker = 0;
-    const len = arr.length;
+    const len = normalized.length;
     if (FILTER_FN) {
         for (let i = 0; i < len; i++) {
-            const el = arr[i];
+            const el = normalized[i];
             if (FILTER_FN && !FILTER_FN(el))
                 continue;
             ticker++;
@@ -29,8 +38,8 @@ function split(arr, size, opts) {
             result.push(cursor);
     }
     else {
-        for (let i = 0; i < arr.length; i += size) {
-            result.push(arr.slice(i, i + size));
+        for (let i = 0; i < len; i += size) {
+            result.push(normalized.slice(i, i + size));
         }
     }
     return result;

package/cjs/caching/LRU.js

@@ -0,0 +1,123 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _LRUCache_map, _LRUCache_head, _LRUCache_tail, _LRUCache_max_size, _LRUCache_size;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.LRUCache = void 0;
+const is_1 = __importDefault(require("../object/is"));
+const isIntegerAbove_1 = __importDefault(require("../number/isIntegerAbove"));
+class LRUCache {
+    constructor(opts = {}) {
+        _LRUCache_map.set(this, void 0);
+        _LRUCache_head.set(this, null);
+        _LRUCache_tail.set(this, null);
+        _LRUCache_max_size.set(this, void 0);
+        _LRUCache_size.set(this, 0);
+        const { max_size = 100 } = (0, is_1.default)(opts) ? opts : {};
+        __classPrivateFieldSet(this, _LRUCache_map, Object.create(null), "f");
+        __classPrivateFieldSet(this, _LRUCache_max_size, (0, isIntegerAbove_1.default)(max_size, 0) ? max_size : 100, "f");
+    }
+    get max_size() {
+        return __classPrivateFieldGet(this, _LRUCache_max_size, "f");
+    }
+    set max_size(max_size) {
+        if (!(0, isIntegerAbove_1.default)(max_size, 0))
+            throw new Error('max_size must be a positive integer');
+        __classPrivateFieldSet(this, _LRUCache_max_size, max_size, "f");
+        while (__classPrivateFieldGet(this, _LRUCache_size, "f") > max_size)
+            this.evictTail();
+    }
+    has(key) {
+        return key in __classPrivateFieldGet(this, _LRUCache_map, "f");
+    }
+    get(key) {
+        const node = __classPrivateFieldGet(this, _LRUCache_map, "f")[key];
+        if (!node)
+            return undefined;
+        this.moveToFront(node);
+        return node.value;
+    }
+    set(key, value) {
+        var _a;
+        let node = __classPrivateFieldGet(this, _LRUCache_map, "f")[key];
+        if (node !== undefined) {
+            node.value = value;
+            this.moveToFront(node);
+        }
+        else {
+            node = { key, value, prev: null, next: null };
+            __classPrivateFieldGet(this, _LRUCache_map, "f")[key] = node;
+            this.addToFront(node);
+            __classPrivateFieldSet(this, _LRUCache_size, (_a = __classPrivateFieldGet(this, _LRUCache_size, "f"), _a++, _a), "f");
+            if (__classPrivateFieldGet(this, _LRUCache_tail, "f") && __classPrivateFieldGet(this, _LRUCache_size, "f") > __classPrivateFieldGet(this, _LRUCache_max_size, "f")) {
+                this.evictTail();
+            }
+        }
+    }
+    del(key) {
+        var _a;
+        const node = __classPrivateFieldGet(this, _LRUCache_map, "f")[key];
+        if (!node)
+            return;
+        this.removeNode(node);
+        delete __classPrivateFieldGet(this, _LRUCache_map, "f")[key];
+        __classPrivateFieldSet(this, _LRUCache_size, (_a = __classPrivateFieldGet(this, _LRUCache_size, "f"), _a--, _a), "f");
+    }
+    clear() {
+        __classPrivateFieldSet(this, _LRUCache_map, Object.create(null), "f");
+        __classPrivateFieldSet(this, _LRUCache_head, null, "f");
+        __classPrivateFieldSet(this, _LRUCache_tail, null, "f");
+        __classPrivateFieldSet(this, _LRUCache_size, 0, "f");
+    }
+    addToFront(node) {
+        node.next = __classPrivateFieldGet(this, _LRUCache_head, "f");
+        node.prev = null;
+        if (__classPrivateFieldGet(this, _LRUCache_head, "f")) {
+            __classPrivateFieldGet(this, _LRUCache_head, "f").prev = node;
+        }
+        __classPrivateFieldSet(this, _LRUCache_head, node, "f");
+        if (!__classPrivateFieldGet(this, _LRUCache_tail, "f")) {
+            __classPrivateFieldSet(this, _LRUCache_tail, node, "f");
+        }
+    }
+    removeNode(node) {
+        if (node.prev)
+            node.prev.next = node.next;
+        else
+            __classPrivateFieldSet(this, _LRUCache_head, node.next, "f");
+        if (node.next)
+            node.next.prev = node.prev;
+        else
+            __classPrivateFieldSet(this, _LRUCache_tail, node.prev, "f");
+        node.prev = null;
+        node.next = null;
+    }
+    moveToFront(node) {
+        if (__classPrivateFieldGet(this, _LRUCache_head, "f") === node)
+            return;
+        this.removeNode(node);
+        this.addToFront(node);
+    }
+    evictTail() {
+        var _a;
+        const old_tail = __classPrivateFieldGet(this, _LRUCache_tail, "f");
+        this.removeNode(old_tail);
+        delete __classPrivateFieldGet(this, _LRUCache_map, "f")[old_tail.key];
+        __classPrivateFieldSet(this, _LRUCache_size, (_a = __classPrivateFieldGet(this, _LRUCache_size, "f"), _a--, _a), "f");
+    }
+}
+exports.LRUCache = LRUCache;
+exports.default = LRUCache;
+_LRUCache_map = new WeakMap(), _LRUCache_head = new WeakMap(), _LRUCache_tail = new WeakMap(), _LRUCache_max_size = new WeakMap(), _LRUCache_size = new WeakMap();

package/{caching → cjs/caching}/memoize.js

@@ -1,17 +1,22 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.memoize = memoize;
 exports.default = memoize;
-const isAsync_1 = require("../function/isAsync");
-const isIntegerAbove_1 = require("../number/isIntegerAbove");
-const LRU_1 = require("./LRU");
+const isAsync_1 = __importDefault(require("../function/isAsync"));
+const fnv1A_1 = __importDefault(require("../hash/fnv1A"));
+const isIntegerAbove_1 = __importDefault(require("../number/isIntegerAbove"));
+const LRU_1 = __importDefault(require("./LRU"));
 function memoize(fn, resolver, cache_duration_ms = false, cache_max_size = 100) {
     const cache_duration = (0, isIntegerAbove_1.default)(cache_duration_ms, 0) ? cache_duration_ms : false;
     const cache = new LRU_1.default({ max_size: cache_max_size });
     const isResolverFn = typeof resolver === 'function';
     const memoized = (0, isAsync_1.default)(fn)
         ? async function (...args) {
-            const key = isResolverFn ? resolver(...args) : args[0];
+            let key = isResolverFn ? resolver(...args) : args[0];
+            key = typeof key === 'string' ? key : Number.isFinite(key) ? String(key) : String((0, fnv1A_1.default)(key));
             const cached_val = cache.get(key);
             const now = Date.now();
             if (cached_val !== undefined && (cache_duration === false || (now - cached_val.ts) < cache_duration)) {
@@ -22,7 +27,8 @@ function memoize(fn, resolver, cache_duration_ms = false, cache_max_size = 100)
             return result;
         }
         : function (...args) {
-            const key = isResolverFn ? resolver(...args) : args[0];
+            let key = isResolverFn ? resolver(...args) : args[0];
+            key = typeof key === 'string' ? key : Number.isFinite(key) ? String(key) : String((0, fnv1A_1.default)(key));
             const cached_val = cache.get(key);
             const now = Date.now();
             if (cached_val !== undefined && (cache_duration === false || (now - cached_val.ts) < cache_duration)) {

package/{date → cjs/date}/format.js

@@ -1,9 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.format = format;
 exports.default = format;
 const convertToDate_1 = require("./convertToDate");
-const LRU_1 = require("../caching/LRU");
+const LRU_1 = __importDefault(require("../caching/LRU"));
 const WEEK_STARTS = {
     mon: 'mon',
     sun: 'sun',
@@ -17,10 +20,6 @@ try {
 }
 catch {
 }
-finally {
-    if (typeof DEFAULT_TZ !== 'string')
-        DEFAULT_TZ = 'UTC';
-}
 const ESCAPE_RGX = /\[[\s\S]+?]/g;
 const intl_formatters = new LRU_1.default({ max_size: 100 });
 const spec_cache = new LRU_1.default({ max_size: 100 });
@@ -218,9 +217,10 @@ format.getLocale = function () {
     return DEFAULT_LOCALE;
 };
 format.setLocale = function (locale) {
-    if (typeof locale !== 'string' || !locale.trim().length)
+    const normalized = typeof locale === 'string' ? locale.trim() : false;
+    if (!normalized)
         throw new Error('format/setLocale: locale should be a string');
-    DEFAULT_LOCALE = locale.trim();
+    DEFAULT_LOCALE = normalized;
 };
 format.getZone = function () {
     return DEFAULT_TZ;

package/{date → cjs/date}/isFormat.js

@@ -1,8 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDateFormat = isDateFormat;
 exports.default = isDateFormat;
-const LRU_1 = require("../caching/LRU");
+const LRU_1 = __importDefault(require("../caching/LRU"));
 const SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
 const TOKENS = [
     ['YYYY', /\d{4}/.source, (raw, context) => {
@@ -93,7 +96,7 @@ function compileSpec(spec, is_chunk = false) {
 }
 function isDateFormat(input, spec) {
     if (typeof input !== 'string')
-        throw new TypeError('isDateFormat: input must be a string');
+        return false;
     if (typeof spec !== 'string')
         throw new TypeError('isDateFormat: spec must be a string');
     const { tokens, rgx } = compileSpec(SPEC_ALIASES[spec] || spec);

package/cjs/formdata/toObject.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toObject = toObject;
+exports.default = toObject;
+const isFormat_1 = require("../date/isFormat");
+const RGX_TOKENS = /[^.[\]]+/g;
+function assign(acc, rawkey, value, single) {
+    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] = Number.isInteger(+keys[i + 1]) ? [] : {};
+                    cursor = cursor[n_key];
+                }
+                else if (!(key in cursor) || (single && single.has(key))) {
+                    cursor[key] = value;
+                }
+                else {
+                    const cursor_val = cursor[key];
+                    if (Array.isArray(cursor_val)) {
+                        cursor_val.push(value);
+                    }
+                    else {
+                        cursor[key] = [cursor_val, value];
+                    }
+                }
+            }
+        }
+    }
+}
+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) {
+        form.forEach((value, key) => assign(acc, key, value, single));
+    }
+    else {
+        form.forEach((value, key) => {
+            if (set_guard && set.has(key))
+                return assign(acc, key, value, single);
+            switch (value) {
+                case 'true':
+                case 'TRUE':
+                case 'True':
+                    assign(acc, key, nBool ? true : value, single);
+                    break;
+                case 'false':
+                case 'FALSE':
+                case 'False':
+                    assign(acc, key, nBool ? false : value, single);
+                    break;
+                case 'null':
+                case 'NULL':
+                case 'Null':
+                    assign(acc, key, nNull ? null : value, single);
+                    break;
+                default: {
+                    if (typeof value === 'string' && value.length) {
+                        if (nNumber) {
+                            const nVal = Number(value);
+                            if (!isNaN(nVal))
+                                return assign(acc, key, nVal, single);
+                        }
+                        if (nDate &&
+                            (0, isFormat_1.isDateFormat)(value, 'ISO'))
+                            return assign(acc, key, new Date(value), single);
+                    }
+                    assign(acc, key, value, single);
+                }
+            }
+        });
+    }
+    return acc;
+}

package/{object → cjs/object}/pick.js

@@ -21,12 +21,12 @@ function pick(obj, keys) {
             const parts_len = parts.length;
             let cursor = map;
             for (let y = 0; y < parts_len - 1; y++) {
-                const part = parts[y].trim();
+                const part = parts[y];
                 if (!(part in cursor))
                     cursor[part] = {};
                 cursor = cursor[part];
             }
-            cursor[parts[parts_len - 1].trim()] = val;
+            cursor[parts[parts_len - 1]] = val;
         }
         else if (key in obj) {
             map[key] = obj[key];

package/{string → cjs/string}/humanizeNumber.js

@@ -6,7 +6,7 @@ const round_1 = require("../number/round");
 const DEFAULT_UNITS = ['', 'k', 'm', 'b', 't', 'q'];
 function humanizeNumber(val, options = {}) {
     const DELIM = typeof options?.delim === 'string' ? options.delim : ',';
-    const SEPARATOR = typeof options?.separator === 'string' && options.separator.trim().length ? options.separator : '.';
+    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 REAL = options?.real === true;
@@ -15,7 +15,7 @@ function humanizeNumber(val, options = {}) {
         : options?.units === false
             ? false
             : DEFAULT_UNITS;
-    let normalized = typeof val === 'string' ? parseFloat(val.trim()) : val;
+    let normalized = typeof val === 'string' ? parseFloat(val) : val;
     if (!Number.isFinite(normalized) || normalized === 0)
         return UNITS ? '0' + UNITS[0] : '0';
     if (REAL)

package/cjs/string/isNotEmpty.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotEmptyString = isNotEmptyString;
+exports.default = isNotEmptyString;
+function isNotEmptyString(val, trimmed = true) {
+    if (typeof val !== 'string')
+        return false;
+    if (trimmed) {
+        for (let i = 0; i < val.length; i++) {
+            switch (val[i]) {
+                case ' ':
+                case '\t':
+                case '\n':
+                case '\r':
+                    break;
+                default:
+                    return true;
+            }
+        }
+        return false;
+    }
+    return val.length > 0;
+}

package/{string → cjs/string}/shorten.js

@@ -17,5 +17,5 @@ function shorten(val, length, postfix = '...', truncate_words = true) {
     while (end && sanitized[end] !== ' ' && sanitized[end - 1] !== ' ') {
         end--;
     }
-    return sanitized.substring(0, end).trim() + postfix;
+    return sanitized.substring(0, end).trimEnd() + postfix;
 }

package/esm/array/dedupe.js

@@ -0,0 +1,52 @@
+const REPL_NAN = 'nan';
+const REPL_TRUE = 'true';
+const REPL_FALSE = 'false';
+const REPL_UNDEF = 'undefined';
+const REPL_NULL = 'null';
+function getTypeString(el) {
+    switch (typeof el) {
+        case 'string':
+            return el;
+        case 'number':
+            return Number.isNaN(el) || !Number.isFinite(el) ? REPL_NAN : String(el);
+        case 'boolean':
+            return el ? REPL_TRUE : REPL_FALSE;
+        case 'undefined':
+            return REPL_UNDEF;
+        case 'object':
+            if (el === null) {
+                return REPL_NULL;
+            }
+            else if (Array.isArray(el) || el.toString() === '[object Object]') {
+                return JSON.stringify(el);
+            }
+            else if (el instanceof RegExp) {
+                return el.toString();
+            }
+            else if (el instanceof Date) {
+                return String(el.getTime());
+            }
+    }
+    return '';
+}
+function dedupe(val, opts) {
+    if (!Array.isArray(val))
+        return [];
+    const FILTER_FN = opts?.filter_fn;
+    const set = new Set();
+    const acc = [];
+    let hash;
+    const len = val.length;
+    for (let i = 0; i < len; i++) {
+        const el = val[i];
+        if (FILTER_FN && !FILTER_FN(el))
+            continue;
+        hash = getTypeString(el);
+        if (!set.has(hash)) {
+            set.add(hash);
+            acc.push(el);
+        }
+    }
+    return acc;
+}
+export { dedupe, dedupe as default };