@valkyriestudios/utils 12.36.0 → 12.38.0

package/esm/array/groupBy.js

@@ -0,0 +1,43 @@
+import { isNotEmptyObject } from '../object/isNotEmpty';
+const FALLBACK = '_';
+const defaultHandler = () => FALLBACK;
+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
+        : typeof handler === 'string'
+            ? ((el) => el[handler])
+            : defaultHandler;
+    let key;
+    let el;
+    for (let i = 0; i < normalized.length; i++) {
+        el = normalized[i];
+        if (!isNotEmptyObject(el))
+            continue;
+        key = n_handler(el);
+        if (key === undefined || (typeof key === 'string' && !key.length))
+            key = FALLBACK;
+        if (!acc[key]) {
+            acc[key] = [el];
+        }
+        else {
+            acc[key].push(el);
+        }
+    }
+    return acc;
+}
+export { groupBy, groupBy as default };

package/esm/array/index.js

@@ -0,0 +1,14 @@
+export { dedupe } from './dedupe';
+export { join } from './join';
+export { mapFn } from './mapFn';
+export { mapFnAsMap } from './mapFnAsMap';
+export { mapKey } from './mapKey';
+export { mapKeyAsMap } from './mapKeyAsMap';
+export { mapPrimitive } from './mapPrimitive';
+export { groupBy } from './groupBy';
+export { shuffle } from './shuffle';
+export { split } from './split';
+export { sort } from './sort';
+export { isArray } from './is';
+export { isNotEmptyArray } from './isNotEmpty';
+export { isNotEmptyArray as isNeArray } from './isNotEmpty';

package/esm/array/is.js

@@ -0,0 +1,4 @@
+function isArray(val) {
+    return Array.isArray(val);
+}
+export { isArray, isArray as default };

package/esm/array/isNotEmpty.js

@@ -0,0 +1,4 @@
+function isNotEmptyArray(val) {
+    return Array.isArray(val) && val.length !== 0;
+}
+export { isNotEmptyArray, isNotEmptyArray as default };

package/esm/array/join.js

@@ -0,0 +1,58 @@
+import { round } from '../number/round';
+import { isIntegerAboveOrEqual } from '../number/isIntegerAboveOrEqual';
+const SPACE_RGX = /(\s)+/g;
+function join(val, opts) {
+    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;
+    const INNERTRIM = opts?.innertrim ?? false;
+    const VALROUND = isIntegerAboveOrEqual(opts?.valround, 0) ? opts.valround : false;
+    let result = '';
+    let has_val = false;
+    for (let i = 0; i < normalized.length; i++) {
+        const el = normalized[i];
+        let n_el;
+        if (typeof el === 'string') {
+            const trimmed = el.trim();
+            if (!trimmed)
+                continue;
+            n_el = VALTRIM ? trimmed : el;
+            if (INNERTRIM)
+                n_el = n_el.replace(SPACE_RGX, ' ');
+        }
+        else if (Number.isFinite(el)) {
+            n_el = '' + (VALROUND !== false ? round(el, VALROUND) : el);
+        }
+        else {
+            continue;
+        }
+        if (DEDUPE) {
+            if (DEDUPE.has(n_el))
+                continue;
+            DEDUPE.add(n_el);
+        }
+        if (has_val) {
+            result = result + DELIM + n_el;
+        }
+        else {
+            result = n_el;
+            has_val = true;
+        }
+    }
+    return opts?.trim ?? true ? result.trim() : result;
+}
+export { join, join as default };

package/esm/array/mapFn.js

@@ -0,0 +1,22 @@
+import { merge } from '../object/merge';
+function mapFn(arr, fn, opts) {
+    if ((!Array.isArray(arr) || !arr.length) ||
+        typeof fn !== 'function')
+        return {};
+    const MERGE = opts?.merge === true;
+    const TRANSFORM_FN = opts?.transform_fn;
+    const map = {};
+    for (let i = 0; i < arr.length; i++) {
+        const el = arr[i];
+        if (Object.prototype.toString.call(el) !== '[object Object]')
+            continue;
+        let hash = fn(el);
+        if (Number.isFinite(hash) || (typeof hash === 'string' && hash.length)) {
+            hash = hash + '';
+            const transformed = TRANSFORM_FN ? TRANSFORM_FN(el) : el;
+            map[hash] = MERGE && hash in map ? merge(map[hash], transformed, { union: true }) : transformed;
+        }
+    }
+    return map;
+}
+export { mapFn, mapFn as default };

package/esm/array/mapFnAsMap.js

@@ -0,0 +1,21 @@
+import { merge } from '../object/merge';
+function mapFnAsMap(arr, fn, opts) {
+    if ((!Array.isArray(arr) || !arr.length) ||
+        typeof fn !== 'function')
+        return new Map();
+    const MERGE = opts?.merge === true;
+    const TRANSFORM_FN = opts?.transform_fn;
+    const map = new Map();
+    for (let i = 0; i < arr.length; i++) {
+        const el = arr[i];
+        if (Object.prototype.toString.call(el) !== '[object Object]')
+            continue;
+        const hash = fn(el);
+        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) ? merge(map.get(hash), transformed, { union: true }) : transformed);
+        }
+    }
+    return map;
+}
+export { mapFnAsMap, mapFnAsMap as default };

package/esm/array/mapKey.js

@@ -0,0 +1,22 @@
+import { merge } from '../object/merge';
+function mapKey(arr, key, opts) {
+    if (!Array.isArray(arr) ||
+        !arr.length ||
+        typeof key !== 'string' ||
+        !key.length)
+        return {};
+    const FILTER_FN = opts?.filter_fn;
+    const MERGE = opts?.merge === true;
+    const TRANSFORMER = opts?.transform_fn;
+    const map = {};
+    for (let i = 0; i < arr.length; i++) {
+        const el = arr[i];
+        const el_key = el?.[key];
+        if (el_key !== undefined && (!FILTER_FN || FILTER_FN(el))) {
+            const transformed = TRANSFORMER ? TRANSFORMER(el) : el;
+            map[el_key] = MERGE && el_key in map ? merge(map[el_key], transformed, { union: true }) : transformed;
+        }
+    }
+    return map;
+}
+export { mapKey, mapKey as default };

package/esm/array/mapKeyAsMap.js

@@ -0,0 +1,22 @@
+import { merge } from '../object/merge';
+function mapKeyAsMap(arr, key, opts) {
+    if (!Array.isArray(arr) ||
+        !arr.length ||
+        typeof key !== 'string' ||
+        !key.length)
+        return new Map();
+    const FILTER_FN = opts?.filter_fn;
+    const MERGE = opts?.merge === true;
+    const TRANSFORMER = opts?.transform_fn;
+    const map = new Map();
+    for (let i = 0; i < arr.length; i++) {
+        const el = arr[i];
+        const el_key = el?.[key];
+        if (el_key !== undefined && (!FILTER_FN || FILTER_FN(el))) {
+            const transformed = (TRANSFORMER ? TRANSFORMER(el) : el);
+            map.set(el_key, MERGE && map.has(el_key) ? merge(map.get(el_key), transformed, { union: true }) : transformed);
+        }
+    }
+    return map;
+}
+export { mapKeyAsMap, mapKeyAsMap as default };

package/esm/array/mapPrimitive.js

@@ -0,0 +1,33 @@
+import { round } from '../number/round';
+import { isIntegerAboveOrEqual } from '../number/isIntegerAboveOrEqual';
+function mapPrimitive(arr, opts = {}) {
+    if (!Array.isArray(arr) || !arr.length)
+        return {};
+    const VALTRIM = opts?.valtrim === true;
+    const VALROUND = isIntegerAboveOrEqual(opts?.valround, 0)
+        ? opts?.valround
+        : opts?.valround === true
+            ? 0
+            : null;
+    const KEYROUND = opts?.keyround === true;
+    const FILTER_FN = opts?.filter_fn;
+    const map = {};
+    for (let i = 0; i < arr.length; i++) {
+        const el = arr[i];
+        if (FILTER_FN && !FILTER_FN(el))
+            continue;
+        if (typeof el === 'string') {
+            const trimmed = el.trim();
+            if (!trimmed)
+                continue;
+            map[trimmed] = VALTRIM ? trimmed : el;
+        }
+        else if (Number.isFinite(el)) {
+            map[`${KEYROUND ? Math.round(el) : el}`] = VALROUND === null
+                ? el
+                : round(el, VALROUND);
+        }
+    }
+    return map;
+}
+export { mapPrimitive, mapPrimitive as default };

package/esm/array/shuffle.js

@@ -0,0 +1,10 @@
+function shuffle(arr) {
+    if (!Array.isArray(arr))
+        return;
+    let j;
+    for (let i = arr.length - 1; i > 0; i--) {
+        j = (Math.random() * (i + 1)) | 0;
+        [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+}
+export { shuffle, shuffle as default };

package/esm/array/sort.js

@@ -0,0 +1,137 @@
+import { isObject } from '../object/is';
+const INSERTION_SORT_THRESHOLD = 10;
+function partitionAsc(arr, low, high) {
+    const pivot = arr[(low + high) >> 1][0];
+    let i = low;
+    let j = high;
+    while (i <= j) {
+        while (arr[i][0] < pivot)
+            i++;
+        while (arr[j][0] > pivot)
+            j--;
+        if (i <= j) {
+            [arr[i], arr[j]] = [arr[j], arr[i]];
+            i++;
+            j--;
+        }
+    }
+    return i;
+}
+function quickSortAsc(arr) {
+    const stack = [[0, arr.length - 1]];
+    while (stack.length) {
+        const [low, high] = stack.pop();
+        if (high - low <= INSERTION_SORT_THRESHOLD) {
+            for (let i = low + 1; i <= high; i++) {
+                const key = arr[i];
+                let j = i - 1;
+                while (j >= low && arr[j][0] > key[0]) {
+                    arr[j + 1] = arr[j];
+                    j--;
+                }
+                arr[j + 1] = key;
+            }
+        }
+        else {
+            const p = partitionAsc(arr, low, high);
+            if (p - 1 > low)
+                stack.push([low, p - 1]);
+            if (p < high)
+                stack.push([p, high]);
+        }
+    }
+}
+function partitionDesc(arr, low, high) {
+    const pivot = arr[(low + high) >> 1][0];
+    let i = low;
+    let j = high;
+    while (i <= j) {
+        while (arr[i][0] > pivot)
+            i++;
+        while (arr[j][0] < pivot)
+            j--;
+        if (i <= j) {
+            [arr[i], arr[j]] = [arr[j], arr[i]];
+            i++;
+            j--;
+        }
+    }
+    return i;
+}
+function quickSortDesc(arr) {
+    const stack = [[0, arr.length - 1]];
+    while (stack.length) {
+        const [low, high] = stack.pop();
+        if (high - low <= INSERTION_SORT_THRESHOLD) {
+            for (let i = low + 1; i <= high; i++) {
+                const key = arr[i];
+                let j = i - 1;
+                while (j >= low && arr[j][0] < key[0]) {
+                    arr[j + 1] = arr[j];
+                    j--;
+                }
+                arr[j + 1] = key;
+            }
+        }
+        else {
+            const p = partitionDesc(arr, low, high);
+            if (p - 1 > low)
+                stack.push([low, p - 1]);
+            if (p < high)
+                stack.push([p, high]);
+        }
+    }
+}
+function sort(arr, by, dir = 'asc', opts) {
+    if (!Array.isArray(arr))
+        return [];
+    const len = arr.length;
+    if (!len)
+        return [];
+    const NOKEY_HIDE = opts?.nokey_hide === true;
+    const NOKEY_AT_END = opts?.nokey_atend !== false;
+    let FILTER_FN = isObject;
+    if (typeof opts?.filter_fn === 'function') {
+        const fn = opts.filter_fn;
+        FILTER_FN = (el => isObject(el) && fn(el));
+    }
+    const by_type = typeof by;
+    let BY_FN;
+    switch (by_type) {
+        case 'function':
+            BY_FN = by;
+            break;
+        case 'string':
+            if (!by.length)
+                throw new Error('Sort by as string should contain content');
+            BY_FN = ((val) => val?.[by]);
+            break;
+        default:
+            throw new Error('Sort by should either be a string with content or a function');
+    }
+    const tosort_arr = [];
+    const noval_arr = [];
+    for (let i = 0; i < len; i++) {
+        const el = arr[i];
+        if (FILTER_FN(el)) {
+            const val = BY_FN(el);
+            if (val === undefined)
+                noval_arr.push(el);
+            else
+                tosort_arr.push([val, el]);
+        }
+    }
+    if (dir === 'desc')
+        quickSortDesc(tosort_arr);
+    else
+        quickSortAsc(tosort_arr);
+    const rslt = [];
+    if (!NOKEY_HIDE && !NOKEY_AT_END)
+        rslt.push(...noval_arr);
+    for (let i = 0; i < tosort_arr.length; i++)
+        rslt.push(tosort_arr[i][1]);
+    if (!NOKEY_HIDE && NOKEY_AT_END)
+        rslt.push(...noval_arr);
+    return rslt;
+}
+export { sort, sort as default };

package/esm/array/split.js

@@ -0,0 +1,43 @@
+function split(arr, size, opts) {
+    if (!Number.isInteger(size) ||
+        size <= 0)
+        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 = normalized.length;
+    if (FILTER_FN) {
+        for (let i = 0; i < len; i++) {
+            const el = normalized[i];
+            if (FILTER_FN && !FILTER_FN(el))
+                continue;
+            ticker++;
+            cursor.push(el);
+            if (ticker === size) {
+                result.push(cursor);
+                cursor = [];
+                ticker = 0;
+            }
+        }
+        if (ticker)
+            result.push(cursor);
+    }
+    else {
+        for (let i = 0; i < len; i += size) {
+            result.push(normalized.slice(i, i + size));
+        }
+    }
+    return result;
+}
+export { split, split as default };

package/esm/boolean/index.js

@@ -0,0 +1 @@
+export { isBoolean } from './is';

package/esm/boolean/is.js

@@ -0,0 +1,4 @@
+function isBoolean(val) {
+    return val === true || val === false;
+}
+export { isBoolean, isBoolean as default };

package/esm/caching/LRU.js

@@ -0,0 +1,116 @@
+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 _LRUCache_map, _LRUCache_head, _LRUCache_tail, _LRUCache_max_size, _LRUCache_size;
+import isObject from '../object/is';
+import isIntegerGt from '../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 } = isObject(opts) ? opts : {};
+        __classPrivateFieldSet(this, _LRUCache_map, Object.create(null), "f");
+        __classPrivateFieldSet(this, _LRUCache_max_size, isIntegerGt(max_size, 0) ? max_size : 100, "f");
+    }
+    get max_size() {
+        return __classPrivateFieldGet(this, _LRUCache_max_size, "f");
+    }
+    set max_size(max_size) {
+        if (!isIntegerGt(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");
+    }
+}
+_LRUCache_map = new WeakMap(), _LRUCache_head = new WeakMap(), _LRUCache_tail = new WeakMap(), _LRUCache_max_size = new WeakMap(), _LRUCache_size = new WeakMap();
+export { LRUCache, LRUCache as default };

package/esm/caching/index.js

@@ -0,0 +1,3 @@
+export { memoize } from './memoize';
+export { LRUCache } from './LRU';
+export { LRUCache as LRU } from './LRU';

package/esm/caching/memoize.js

@@ -0,0 +1,37 @@
+import isAsyncFunction from '../function/isAsync';
+import fnv1A from '../hash/fnv1A';
+import isIntegerGt from '../number/isIntegerAbove';
+import LRU from './LRU';
+function memoize(fn, resolver, cache_duration_ms = false, cache_max_size = 100) {
+    const cache_duration = isIntegerGt(cache_duration_ms, 0) ? cache_duration_ms : false;
+    const cache = new LRU({ max_size: cache_max_size });
+    const isResolverFn = typeof resolver === 'function';
+    const memoized = isAsyncFunction(fn)
+        ? async function (...args) {
+            let key = isResolverFn ? resolver(...args) : args[0];
+            key = typeof key === 'string' ? key : Number.isFinite(key) ? String(key) : String(fnv1A(key));
+            const cached_val = cache.get(key);
+            const now = Date.now();
+            if (cached_val !== undefined && (cache_duration === false || (now - cached_val.ts) < cache_duration)) {
+                return cached_val.r;
+            }
+            const result = await fn(...args);
+            cache.set(key, { r: result, ts: now });
+            return result;
+        }
+        : function (...args) {
+            let key = isResolverFn ? resolver(...args) : args[0];
+            key = typeof key === 'string' ? key : Number.isFinite(key) ? String(key) : String(fnv1A(key));
+            const cached_val = cache.get(key);
+            const now = Date.now();
+            if (cached_val !== undefined && (cache_duration === false || (now - cached_val.ts) < cache_duration)) {
+                return cached_val.r;
+            }
+            const result = fn(...args);
+            cache.set(key, { r: result, ts: now });
+            return result;
+        };
+    memoized.cache = cache;
+    return memoized;
+}
+export { memoize, memoize as default };

package/esm/date/addUTC.js

@@ -0,0 +1,41 @@
+import { convertToDate } from './convertToDate';
+function addUTC(val, amt = 0, key = 'millisecond') {
+    if (!Number.isInteger(amt))
+        throw new TypeError('Amount needs to be an integer');
+    const n_val = convertToDate(val);
+    if (n_val === null)
+        throw new TypeError('addUTC requires a date object');
+    const year = n_val.getUTCFullYear();
+    const month = n_val.getUTCMonth();
+    const date = n_val.getUTCDate();
+    const hour = n_val.getUTCHours();
+    const min = n_val.getUTCMinutes();
+    const sec = n_val.getUTCSeconds();
+    const ms = n_val.getUTCMilliseconds();
+    switch (key) {
+        case 'years':
+        case 'year':
+            return new Date(Date.UTC(year + amt, month, date, hour, min, sec, ms));
+        case 'months':
+        case 'month':
+            return new Date(Date.UTC(year, month + amt, date, hour, min, sec, ms));
+        case 'days':
+        case 'day':
+            return new Date(Date.UTC(year, month, date + amt, hour, min, sec, ms));
+        case 'hours':
+        case 'hour':
+            return new Date(Date.UTC(year, month, date, hour + amt, min, sec, ms));
+        case 'minutes':
+        case 'minute':
+            return new Date(Date.UTC(year, month, date, hour, min + amt, sec, ms));
+        case 'seconds':
+        case 'second':
+            return new Date(Date.UTC(year, month, date, hour, min, sec + amt, ms));
+        case 'milliseconds':
+        case 'millisecond':
+            return new Date(Date.UTC(year, month, date, hour, min, sec, ms + amt));
+        default:
+            return new Date(Date.UTC(year, month, date, hour, min, sec, ms));
+    }
+}
+export { addUTC, addUTC as default };

package/esm/date/convertToDate.js

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