@valkyriestudios/utils 12.36.0 → 12.38.0

package/esm/modules/Scheduler.js

@@ -0,0 +1,343 @@
+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 _Scheduler_jobs, _Scheduler_name, _Scheduler_log, _Scheduler_timeZone, _Scheduler_parallel, _Scheduler_timer;
+import { format } from '../date/format';
+import { toUTC } from '../date/toUTC';
+import { isNotEmptyString } from '../string/isNotEmpty';
+import { isFunction } from '../function/is';
+import { isIntegerAbove, isIntegerBetween } from '../number';
+import { isObject, pick } from '../object';
+import { noop } from '../function';
+import { isBoolean } from '../boolean';
+import { split } from '../array';
+const RGX_DIGITS = /^\d+$/;
+const LIMITS = {
+    minute: [0, 59],
+    hour: [0, 23],
+    day_of_month: [1, 31],
+    month: [1, 12],
+    day_of_week: [0, 6],
+};
+function convertPart(part, min, max) {
+    if (part === '*')
+        return '*';
+    const set = new Set();
+    if (part.indexOf('/') > -1) {
+        const [base, raw_step] = part.split('/', 2);
+        const step = parseInt(raw_step, 10);
+        let start;
+        let end = max;
+        if (base === '*') {
+            start = min;
+        }
+        else if (base.indexOf('-') > -1) {
+            const chunks = base.split('-', 2);
+            start = parseInt(chunks[0], 10);
+            end = parseInt(chunks[1], 10);
+        }
+        else {
+            start = parseInt(base, 10);
+        }
+        for (let i = start; i <= end; i += step)
+            set.add(i);
+    }
+    else if (part.indexOf('-') > -1) {
+        const chunks = part.split('-', 2);
+        const start = parseInt(chunks[0], 10);
+        const end = parseInt(chunks[1], 10);
+        for (let i = start; i <= end; i++)
+            set.add(i);
+    }
+    else if (part.indexOf(',') > -1) {
+        const chunks = part.split(',');
+        for (let i = 0; i < chunks.length; i++)
+            set.add(parseInt(chunks[i], 10));
+    }
+    else {
+        set.add(parseInt(part, 10));
+    }
+    return set;
+}
+function isCronSubpart(part, min, max) {
+    if (!RGX_DIGITS.test(part))
+        return null;
+    const normalized = parseFloat(part);
+    if (!isIntegerBetween(normalized, min, max))
+        return null;
+    return normalized;
+}
+function isCronPart(part, min, max) {
+    if (part === '*') {
+        return true;
+    }
+    else if (part.indexOf('/') > -1) {
+        const [base, stepStr] = part.split('/', 2);
+        const step = parseFloat(stepStr);
+        if (!isIntegerAbove(step, 0) || !isIntegerBetween(step, min, max))
+            return false;
+        if (base === '*')
+            return true;
+        let start = min;
+        let end = max;
+        if (base.indexOf('-') > -1) {
+            const chunks = base.split('-');
+            if (chunks.length !== 2)
+                return false;
+            start = isCronSubpart(chunks[0], min, max);
+            end = isCronSubpart(chunks[1], min, max);
+        }
+        else {
+            start = isCronSubpart(base, min, max);
+        }
+        if (start === null || end === null)
+            return false;
+        if (start > end)
+            return false;
+        if (step > (end - start))
+            return false;
+        return true;
+    }
+    else if (part.indexOf('-') > -1) {
+        const chunks = part.split('-');
+        if (chunks.length !== 2)
+            return false;
+        const start = isCronSubpart(chunks[0], min, max);
+        const end = isCronSubpart(chunks[1], min, max);
+        if (start === null || end === null)
+            return false;
+        return start < end;
+    }
+    else if (part.indexOf(',') > -1) {
+        const chunks = part.split(',');
+        for (let i = 0; i < chunks.length; i++) {
+            if (isCronSubpart(chunks[i], min, max) === null)
+                return false;
+        }
+        return true;
+    }
+    else {
+        return isCronSubpart(part, min, max) !== null;
+    }
+}
+class Scheduler {
+    constructor(options = {}) {
+        _Scheduler_jobs.set(this, []);
+        _Scheduler_name.set(this, 'Scheduler');
+        _Scheduler_log.set(this, noop);
+        _Scheduler_timeZone.set(this, null);
+        _Scheduler_parallel.set(this, true);
+        _Scheduler_timer.set(this, null);
+        if (!isObject(options))
+            throw new Error('Scheduler@ctor: options should be an object');
+        if ('logger' in options) {
+            if (!isFunction(options.logger))
+                throw new Error('Scheduler@ctor: logger should be a function');
+            __classPrivateFieldSet(this, _Scheduler_log, options.logger, "f");
+        }
+        if ('name' in options) {
+            if (!isNotEmptyString(options.name))
+                throw new Error('Scheduler@ctor: name should be a non-empty string');
+            __classPrivateFieldSet(this, _Scheduler_name, options.name.trim(), "f");
+        }
+        if ('timeZone' in options) {
+            if (options.timeZone !== null &&
+                !isNotEmptyString(options.timeZone))
+                throw new Error('Scheduler@ctor: timeZone should be null or a non-empty string');
+            __classPrivateFieldSet(this, _Scheduler_timeZone, options.timeZone, "f");
+        }
+        if ('parallel' in options) {
+            if (!isBoolean(options.parallel) &&
+                !isIntegerAbove(options.parallel, 0))
+                throw new Error('Scheduler@ctor: parallel should be passed as a boolean or int above 0');
+            __classPrivateFieldSet(this, _Scheduler_parallel, options.parallel, "f");
+        }
+        if (options.auto === true)
+            this.startAutomaticRun();
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _Scheduler_name, "f");
+    }
+    get timeZone() {
+        return __classPrivateFieldGet(this, _Scheduler_timeZone, "f");
+    }
+    get parallel() {
+        return __classPrivateFieldGet(this, _Scheduler_parallel, "f");
+    }
+    get isAutomatic() {
+        return __classPrivateFieldGet(this, _Scheduler_timer, "f") !== null;
+    }
+    get jobs() {
+        const acc = [];
+        for (let i = 0; i < __classPrivateFieldGet(this, _Scheduler_jobs, "f").length; i++) {
+            const { name, schedule, timeZone, data = null } = __classPrivateFieldGet(this, _Scheduler_jobs, "f")[i];
+            acc.push({
+                name,
+                schedule,
+                timeZone,
+                ...data !== null && { data: { ...data } },
+            });
+        }
+        return acc;
+    }
+    add(job) {
+        try {
+            if (!Scheduler.isCronSchedule(job?.schedule))
+                throw new Error(`${__classPrivateFieldGet(this, _Scheduler_name, "f")}@add: Invalid cron schedule`);
+            if (!isFunction(job.fn))
+                throw new Error(`${__classPrivateFieldGet(this, _Scheduler_name, "f")}@add: Invalid function for job`);
+            if (!isNotEmptyString(job.name))
+                throw new Error(`${__classPrivateFieldGet(this, _Scheduler_name, "f")}@add: Invalid name for job`);
+            if ('data' in job && !isObject(job.data))
+                throw new Error(`${__classPrivateFieldGet(this, _Scheduler_name, "f")}@add: Job data should be an object`);
+            __classPrivateFieldGet(this, _Scheduler_jobs, "f").push({
+                name: job.name,
+                schedule: job.schedule,
+                fn: job.fn,
+                timeZone: isNotEmptyString(job.timeZone) ? job.timeZone : __classPrivateFieldGet(this, _Scheduler_timeZone, "f"),
+                map: Scheduler.convertToMap(job.schedule),
+                ...job.data ? { data: job.data } : {},
+            });
+            return true;
+        }
+        catch (err) {
+            __classPrivateFieldGet(this, _Scheduler_log, "f").call(this, {
+                name: __classPrivateFieldGet(this, _Scheduler_name, "f"),
+                msg: err.message,
+                on: new Date(),
+                data: job,
+                err: err,
+            });
+            return false;
+        }
+    }
+    remove(name) {
+        const names = new Set(isNotEmptyString(name) ? [name] : Array.isArray(name) ? name : []);
+        const jobs = [];
+        for (let i = 0; i < __classPrivateFieldGet(this, _Scheduler_jobs, "f").length; i++) {
+            const el = __classPrivateFieldGet(this, _Scheduler_jobs, "f")[i];
+            if (!names.has(el.name))
+                jobs.push(el);
+        }
+        __classPrivateFieldSet(this, _Scheduler_jobs, jobs, "f");
+    }
+    async run() {
+        const promises = [];
+        for (let i = 0; i < __classPrivateFieldGet(this, _Scheduler_jobs, "f").length; i++) {
+            const job = __classPrivateFieldGet(this, _Scheduler_jobs, "f")[i];
+            const time = Scheduler.getTimeParts(new Date(), job.timeZone);
+            if (Scheduler.checkTimeAgainstMap(job.map, time)) {
+                try {
+                    if (__classPrivateFieldGet(this, _Scheduler_parallel, "f")) {
+                        promises.push(job);
+                    }
+                    else {
+                        await job.fn(job.data);
+                    }
+                }
+                catch (err) {
+                    __classPrivateFieldGet(this, _Scheduler_log, "f").call(this, {
+                        name: __classPrivateFieldGet(this, _Scheduler_name, "f"),
+                        msg: `${job.name}: ${err.message}`,
+                        on: new Date(),
+                        data: pick(job, ['schedule', 'timeZone', 'name', 'data']),
+                        err,
+                    });
+                }
+            }
+        }
+        if (__classPrivateFieldGet(this, _Scheduler_parallel, "f") && promises.length) {
+            const batches = __classPrivateFieldGet(this, _Scheduler_parallel, "f") === true
+                ? [promises]
+                : split(promises, __classPrivateFieldGet(this, _Scheduler_parallel, "f"));
+            for (const batch of batches) {
+                await Promise.allSettled(batch.map(el => (async () => {
+                    try {
+                        await el.fn(el.data);
+                    }
+                    catch (err) {
+                        __classPrivateFieldGet(this, _Scheduler_log, "f").call(this, {
+                            name: __classPrivateFieldGet(this, _Scheduler_name, "f"),
+                            msg: `${el.name}: ${err.message}`,
+                            on: new Date(),
+                            data: pick(el, ['schedule', 'timeZone', 'name', 'data']),
+                            err: err,
+                        });
+                    }
+                })()));
+            }
+        }
+    }
+    stopAutomaticRun() {
+        if (!__classPrivateFieldGet(this, _Scheduler_timer, "f"))
+            return;
+        clearInterval(__classPrivateFieldGet(this, _Scheduler_timer, "f"));
+        __classPrivateFieldSet(this, _Scheduler_timer, null, "f");
+    }
+    startAutomaticRun() {
+        this.stopAutomaticRun();
+        __classPrivateFieldSet(this, _Scheduler_timer, setInterval(this.run.bind(this), 60000), "f");
+    }
+    static convertToMap(schedule) {
+        const parts = schedule.split(' ');
+        return {
+            minute: convertPart(parts[0], LIMITS.minute[0], LIMITS.minute[1]),
+            hour: convertPart(parts[1], LIMITS.hour[0], LIMITS.hour[1]),
+            day_of_month: convertPart(parts[2], LIMITS.day_of_month[0], LIMITS.day_of_month[1]),
+            month: convertPart(parts[3], LIMITS.month[0], LIMITS.month[1]),
+            day_of_week: convertPart(parts[4], LIMITS.day_of_week[0], LIMITS.day_of_week[1]),
+        };
+    }
+    static getTimeParts(date, timeZone) {
+        const now = toUTC(timeZone !== null
+            ? new Date(format(date, 'ISO', 'en-US', timeZone))
+            : date);
+        return {
+            minute: now.getUTCMinutes(),
+            hour: now.getUTCHours(),
+            day_of_month: now.getUTCDate(),
+            month: now.getUTCMonth() + 1,
+            day_of_week: now.getUTCDay(),
+        };
+    }
+    static checkTimeAgainstMap(map, time) {
+        const { minute, hour, day_of_month, month, day_of_week } = map;
+        if (minute !== '*' && !minute.has(time.minute))
+            return false;
+        if (hour !== '*' && !hour.has(time.hour))
+            return false;
+        if (day_of_month !== '*' && !day_of_month.has(time.day_of_month))
+            return false;
+        if (month !== '*' && !month.has(time.month))
+            return false;
+        if (day_of_week !== '*' && !day_of_week.has(time.day_of_week))
+            return false;
+        return true;
+    }
+    static isCronSchedule(raw) {
+        if (!isNotEmptyString(raw))
+            return false;
+        const parts = raw.split(' ');
+        return (parts.length === 5 &&
+            isCronPart(parts[0], LIMITS.minute[0], LIMITS.minute[1]) &&
+            isCronPart(parts[1], LIMITS.hour[0], LIMITS.hour[1]) &&
+            isCronPart(parts[2], LIMITS.day_of_month[0], LIMITS.day_of_month[1]) &&
+            isCronPart(parts[3], LIMITS.month[0], LIMITS.month[1]) &&
+            isCronPart(parts[4], LIMITS.day_of_week[0], LIMITS.day_of_week[1]));
+    }
+    static cronShouldRun(schedule, timeZone = null) {
+        if (!Scheduler.isCronSchedule(schedule))
+            return false;
+        return Scheduler.checkTimeAgainstMap(Scheduler.convertToMap(schedule), Scheduler.getTimeParts(new Date(), isNotEmptyString(timeZone) ? timeZone : null));
+    }
+}
+_Scheduler_jobs = new WeakMap(), _Scheduler_name = new WeakMap(), _Scheduler_log = new WeakMap(), _Scheduler_timeZone = new WeakMap(), _Scheduler_parallel = new WeakMap(), _Scheduler_timer = new WeakMap();
+export { Scheduler, Scheduler as default };

package/esm/modules/index.js

@@ -0,0 +1,2 @@
+export { PubSub } from './PubSub';
+export { Scheduler } from './Scheduler';

package/esm/number/index.js

@@ -0,0 +1,37 @@
+export { isNumber } from './is';
+export { isNumber as isNum } from './is';
+export { isNumberAbove } from './isAbove';
+export { isNumberAbove as isNumGt } from './isAbove';
+export { isNumberAbove as isGt } from './isAbove';
+export { isNumberAboveOrEqual } from './isAboveOrEqual';
+export { isNumberAboveOrEqual as isNumGte } from './isAboveOrEqual';
+export { isNumberAboveOrEqual as isGte } from './isAboveOrEqual';
+export { isNumberBelow } from './isBelow';
+export { isNumberBelow as isNumLt } from './isBelow';
+export { isNumberBelow as isLt } from './isBelow';
+export { isNumberBelowOrEqual } from './isBelowOrEqual';
+export { isNumberBelowOrEqual as isNumLte } from './isBelowOrEqual';
+export { isNumberBelowOrEqual as isLte } from './isBelowOrEqual';
+export { isNumberBetween } from './isBetween';
+export { isNumberBetween as isNumBetween } from './isBetween';
+export { isNumberBetween as isBetween } from './isBetween';
+export { isInteger } from './isInteger';
+export { isInteger as isInt } from './isInteger';
+export { isIntegerAbove } from './isIntegerAbove';
+export { isIntegerAbove as isIntGt } from './isIntegerAbove';
+export { isIntegerAboveOrEqual } from './isIntegerAboveOrEqual';
+export { isIntegerAboveOrEqual as isIntGte } from './isIntegerAboveOrEqual';
+export { isIntegerBelow } from './isIntegerBelow';
+export { isIntegerBelow as isIntLt } from './isIntegerBelow';
+export { isIntegerBelowOrEqual } from './isIntegerBelowOrEqual';
+export { isIntegerBelowOrEqual as isIntLte } from './isIntegerBelowOrEqual';
+export { isIntegerBetween } from './isIntegerBetween';
+export { isIntegerBetween as isIntBetween } from './isIntegerBetween';
+export { isNumericalNaN } from './isNumericalNaN';
+export { randomBetween } from './randomBetween';
+export { randomBetween as randBetween } from './randomBetween';
+export { randomIntBetween } from './randomIntBetween';
+export { randomIntBetween as randIntBetween } from './randomIntBetween';
+export { round } from './round';
+export { toPercentage } from './toPercentage';
+export { toPercentage as toPct } from './toPercentage';

package/esm/number/is.js

@@ -0,0 +1,4 @@
+function isNumber(val) {
+    return Number.isFinite(val);
+}
+export { isNumber, isNumber as default };

package/esm/number/isAbove.js

@@ -0,0 +1,4 @@
+function isNumberAbove(val, ref) {
+    return !Number.isFinite(val) || !Number.isFinite(ref) ? false : val > ref;
+}
+export { isNumberAbove, isNumberAbove as default };

package/esm/number/isAboveOrEqual.js

@@ -0,0 +1,4 @@
+function isNumberAboveOrEqual(val, ref) {
+    return !Number.isFinite(val) || !Number.isFinite(ref) ? false : val >= ref;
+}
+export { isNumberAboveOrEqual, isNumberAboveOrEqual as default };

package/esm/number/isBelow.js

@@ -0,0 +1,4 @@
+function isNumberBelow(val, ref) {
+    return !Number.isFinite(val) || !Number.isFinite(ref) ? false : val < ref;
+}
+export { isNumberBelow, isNumberBelow as default };

package/esm/number/isBelowOrEqual.js

@@ -0,0 +1,4 @@
+function isNumberBelowOrEqual(val, ref) {
+    return !Number.isFinite(val) || !Number.isFinite(ref) ? false : val <= ref;
+}
+export { isNumberBelowOrEqual, isNumberBelowOrEqual as default };

package/esm/number/isBetween.js

@@ -0,0 +1,7 @@
+function isNumberBetween(val, min, max) {
+    return (Number.isFinite(val) &&
+        Number.isFinite(min) &&
+        Number.isFinite(max) &&
+        (val >= min && val <= max));
+}
+export { isNumberBetween, isNumberBetween as default };

package/esm/number/isInteger.js

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

package/esm/number/isIntegerAbove.js

@@ -0,0 +1,4 @@
+function isIntegerAbove(val, ref) {
+    return !Number.isInteger(val) || !Number.isFinite(ref) ? false : val > ref;
+}
+export { isIntegerAbove, isIntegerAbove as default };

package/esm/number/isIntegerAboveOrEqual.js

@@ -0,0 +1,4 @@
+function isIntegerAboveOrEqual(val, ref) {
+    return !Number.isInteger(val) || !Number.isFinite(ref) ? false : val >= ref;
+}
+export { isIntegerAboveOrEqual, isIntegerAboveOrEqual as default };

package/esm/number/isIntegerBelow.js

@@ -0,0 +1,4 @@
+function isIntegerBelow(val, ref) {
+    return !Number.isInteger(val) || !Number.isFinite(ref) ? false : val < ref;
+}
+export { isIntegerBelow, isIntegerBelow as default };

package/esm/number/isIntegerBelowOrEqual.js

@@ -0,0 +1,4 @@
+function isIntegerBelowOrEqual(val, ref) {
+    return !Number.isInteger(val) || !Number.isFinite(ref) ? false : val <= ref;
+}
+export { isIntegerBelowOrEqual, isIntegerBelowOrEqual as default };

package/esm/number/isIntegerBetween.js

@@ -0,0 +1,7 @@
+function isIntegerBetween(val, min, max) {
+    return (Number.isInteger(val) &&
+        Number.isFinite(min) &&
+        Number.isFinite(max) &&
+        (val >= min && val <= max));
+}
+export { isIntegerBetween, isIntegerBetween as default };

package/esm/number/isNumericalNaN.js

@@ -0,0 +1,4 @@
+function isNumericalNaN(val) {
+    return Number.isNaN(val) || val === Infinity;
+}
+export { isNumericalNaN, isNumericalNaN as default };

package/esm/number/randomBetween.js

@@ -0,0 +1,7 @@
+function randomBetween(min = 0, max = 10) {
+    if (!Number.isFinite(min) ||
+        !Number.isFinite(max))
+        throw new TypeError('Min/Max should be numeric');
+    return (Math.random() * (max - min)) + min;
+}
+export { randomBetween, randomBetween as default };

package/esm/number/randomIntBetween.js

@@ -0,0 +1,7 @@
+function randomIntBetween(min = 0, max = 10) {
+    if (!Number.isFinite(min) ||
+        !Number.isFinite(max))
+        throw new TypeError('Min/Max should be numeric');
+    return ((Math.random() * (max - min)) + min) | 0;
+}
+export { randomIntBetween, randomIntBetween as default };

package/esm/number/round.js

@@ -0,0 +1,10 @@
+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)
+        return Math.round(val * ROUND_EPSILON);
+    const exp = Math.pow(10, precision);
+    return Math.round((val * exp) * ROUND_EPSILON) / exp;
+}
+export { round, round as default };

package/esm/number/toPercentage.js

@@ -0,0 +1,9 @@
+import { round } from './round';
+function toPercentage(val, precision = 0, min = 0, max = 1) {
+    if (!Number.isFinite(val) ||
+        !Number.isFinite(min) ||
+        !Number.isFinite(max))
+        throw new TypeError('value/min/max should be numeric');
+    return round(((val - min) / (max - min)) * 100, precision);
+}
+export { toPercentage, toPercentage as default };

package/esm/object/define.js

@@ -0,0 +1,7 @@
+function define(props, obj = {}) {
+    if (Object.prototype.toString.call(props) !== '[object Object]' ||
+        Object.prototype.toString.call(obj) !== '[object Object]')
+        throw new TypeError('Please pass an object as the value for props and obj');
+    return Object.defineProperties(obj, props);
+}
+export { define, define as default };

package/esm/object/index.js

@@ -0,0 +1,7 @@
+export { define } from './define';
+export { merge } from './merge';
+export { pick } from './pick';
+export { omit } from './omit';
+export { isObject } from './is';
+export { isNotEmptyObject } from './isNotEmpty';
+export { isNotEmptyObject as isNeObject } from './isNotEmpty';

package/esm/object/is.js

@@ -0,0 +1,4 @@
+function isObject(val) {
+    return Object.prototype.toString.call(val) === '[object Object]';
+}
+export { isObject, isObject as default };

package/esm/object/isNotEmpty.js

@@ -0,0 +1,9 @@
+function isNotEmptyObject(val) {
+    if (Object.prototype.toString.call(val) !== '[object Object]')
+        return false;
+    for (const _ in val) {
+        return true;
+    }
+    return false;
+}
+export { isNotEmptyObject, isNotEmptyObject as default };

package/esm/object/merge.js

@@ -0,0 +1,31 @@
+const PROTO_OBJ = '[object Object]';
+function innerMerge(target, source, UNION) {
+    const origin = UNION ? source : target;
+    for (const key in origin) {
+        const t_key = target[key];
+        const s_key = source[key];
+        if (Object.prototype.toString.call(t_key) === PROTO_OBJ &&
+            Object.prototype.toString.call(s_key) === PROTO_OBJ) {
+            target[key] = innerMerge({ ...t_key }, s_key, UNION);
+        }
+        else {
+            target[key] = s_key !== undefined ? s_key : t_key;
+        }
+    }
+    return target;
+}
+function merge(target, source, opts = {}) {
+    if (Object.prototype.toString.call(target) !== PROTO_OBJ)
+        throw new Error('object/merge: Please ensure valid target/source is passed');
+    const union = opts?.union === true;
+    const sources = Array.isArray(source) ? source : [source];
+    let acc = { ...target };
+    for (let i = 0; i < sources.length; i++) {
+        const el = sources[i];
+        if (!el || Object.prototype.toString.call(el) !== PROTO_OBJ)
+            continue;
+        acc = innerMerge(acc, el, union);
+    }
+    return acc;
+}
+export { merge, merge as default };

package/esm/object/omit.js

@@ -0,0 +1,30 @@
+function innerOmit(obj, keys) {
+    const result = { ...obj };
+    const groups = {};
+    for (let i = 0; i < keys.length; i++) {
+        if (typeof keys[i] === 'string') {
+            const [root, ...rest] = keys[i].split('.');
+            if (rest.length) {
+                if (!groups[root])
+                    groups[root] = [];
+                groups[root].push(rest.join('.'));
+            }
+            else {
+                delete result[root];
+            }
+        }
+    }
+    for (const root in groups) {
+        if (typeof result[root] === 'object' &&
+            result[root] !== null)
+            result[root] = innerOmit(result[root], groups[root]);
+    }
+    return result;
+}
+function omit(obj, keys) {
+    if (Object.prototype.toString.call(obj) !== '[object Object]' ||
+        !Array.isArray(keys))
+        throw new TypeError('Please pass an object to omit from and a keys array');
+    return innerOmit(obj, keys);
+}
+export { omit, omit as default };

package/esm/object/pick.js

@@ -0,0 +1,33 @@
+import { deepGet } from '../deep/get';
+function pick(obj, keys) {
+    if (Object.prototype.toString.call(obj) !== '[object Object]' ||
+        !Array.isArray(keys))
+        throw new TypeError('Please pass an object to pick from and a keys array');
+    const map = {};
+    let val;
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (typeof key !== 'string' || !key)
+            continue;
+        if (key.indexOf('.') >= 0) {
+            val = deepGet(obj, key);
+            if (val === undefined)
+                continue;
+            const parts = key.split('.');
+            const parts_len = parts.length;
+            let cursor = map;
+            for (let y = 0; y < parts_len - 1; y++) {
+                const part = parts[y];
+                if (!(part in cursor))
+                    cursor[part] = {};
+                cursor = cursor[part];
+            }
+            cursor[parts[parts_len - 1]] = val;
+        }
+        else if (key in obj) {
+            map[key] = obj[key];
+        }
+    }
+    return map;
+}
+export { pick, pick as default };

package/esm/regexp/index.js

@@ -0,0 +1,3 @@
+export { isRegExp } from './is';
+export { sanitizeRegExp } from './sanitize';
+export { sanitizeRegExp as sanitize } from './sanitize';

package/esm/regexp/is.js

@@ -0,0 +1,4 @@
+function isRegExp(val) {
+    return val instanceof RegExp;
+}
+export { isRegExp, isRegExp as default };

package/esm/regexp/sanitize.js

@@ -0,0 +1,7 @@
+const RGX = /[.*+\-?^${}()|[\]\\]/g;
+function sanitizeRegExp(val) {
+    if (typeof val !== 'string')
+        return false;
+    return val.trim().replace(RGX, '\\$&');
+}
+export { sanitizeRegExp, sanitizeRegExp as default };