@valkyriestudios/utils 12.37.0 → 12.38.0

package/esm/date/format.js

@@ -0,0 +1,241 @@
+import { convertToDate } from './convertToDate';
+import LRU from '../caching/LRU';
+const WEEK_STARTS = {
+    mon: 'mon',
+    sun: 'sun',
+    sat: 'sat',
+};
+let DEFAULT_LOCALE = 'en-US';
+let DEFAULT_TZ = 'UTC';
+let DEFAULT_SOW = 'mon';
+try {
+    DEFAULT_TZ = Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+catch {
+}
+const ESCAPE_RGX = /\[[\s\S]+?]/g;
+const intl_formatters = new LRU({ max_size: 100 });
+const spec_cache = new LRU({ max_size: 100 });
+const zone_offset_cache = new LRU({ max_size: 100 });
+function WeekNr(d, sow) {
+    switch (sow) {
+        case 'sun':
+        case 'sat': {
+            const OFFSET = sow === 'sat' ? 1 : 0;
+            const jan1 = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+            const near = new Date(d.getTime() - (((d.getDay() + OFFSET) % 7) * 86400000));
+            const first = new Date(jan1.getTime() - (((jan1.getDay() + OFFSET) % 7) * 86400000));
+            return 1 + Math.floor((near.valueOf() - first.valueOf()) / 604800000);
+        }
+        default: {
+            const date = new Date(d.valueOf());
+            date.setDate(date.getDate() - ((d.getDay() + 6) % 7) + 3);
+            const date_thu = date.valueOf();
+            date.setMonth(0, 1);
+            if (date.getDay() !== 4)
+                date.setMonth(0, (1 + ((4 - date.getDay()) + 7)) % 7);
+            return 1 + Math.ceil((date_thu - date.valueOf()) / 604800000);
+        }
+    }
+}
+function toZone(d, zone) {
+    const year = d.getUTCFullYear();
+    const month = d.getUTCMonth();
+    const day = d.getUTCDate();
+    const time = d.getTime();
+    const daysInMonths = [31, (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    let doy = day;
+    for (let i = 0; i <= month; i++)
+        doy += daysInMonths[i];
+    const ckey = zone + ':' + year + ':' + doy;
+    const cached = zone_offset_cache.get(ckey);
+    if (cached !== undefined)
+        return new Date(time + cached);
+    let zone_time = null;
+    try {
+        zone_time = new Date(d.toLocaleString(DEFAULT_LOCALE, { timeZone: zone })).getTime() + d.getMilliseconds();
+    }
+    catch {
+        throw new Error(`format: Invalid zone passed - ${zone}`);
+    }
+    const offset = zone_time - time;
+    zone_offset_cache.set(ckey, offset);
+    return new Date(time + offset);
+}
+function runIntl(loc, token, props, val) {
+    const hash = loc + ':' + token;
+    let formatter = intl_formatters.get(hash);
+    if (!formatter) {
+        try {
+            formatter = new Intl.DateTimeFormat(loc, props);
+            intl_formatters.set(hash, formatter);
+        }
+        catch {
+            throw new Error(`format: Failed to run conversion for ${token} with locale ${loc}`);
+        }
+    }
+    return formatter.format(val);
+}
+const Tokens = [
+    ['YYYY', d => d.getFullYear()],
+    ['Q', d => ((d.getMonth() + 3) / 3) | 0],
+    ['MMMM', (d, loc) => runIntl(loc, 'MMMM', { month: 'long' }, d)],
+    ['MMM', (d, loc) => runIntl(loc, 'MMM', { month: 'short' }, d)],
+    ['MM', d => {
+            const val = d.getMonth() + 1;
+            return (val < 10 ? '0' : '') + val;
+        }],
+    ['M', d => d.getMonth() + 1],
+    ['WW', (d, loc, sow) => {
+            const val = WeekNr(d, sow);
+            return (val < 10 ? '0' : '') + val;
+        }],
+    ['W', (d, loc, sow) => WeekNr(d, sow)],
+    ['DD', d => {
+            const val = d.getDate();
+            return (val < 10 ? '0' : '') + val;
+        }],
+    ['D', d => d.getDate()],
+    ['dddd', (d, loc) => runIntl(loc, 'dddd', { weekday: 'long' }, d)],
+    ['ddd', (d, loc) => runIntl(loc, 'ddd', { weekday: 'short' }, d)],
+    ['HH', d => {
+            const val = d.getHours();
+            return (val < 10 ? '0' : '') + val;
+        }],
+    ['H', d => d.getHours()],
+    ['hh', d => {
+            const val = ((d.getHours() + 11) % 12) + 1;
+            return (val < 10 ? '0' : '') + val;
+        }],
+    ['h', d => ((d.getHours() + 11) % 12) + 1],
+    ['mm', d => {
+            const val = d.getMinutes();
+            return (val < 10 ? '0' : '') + val;
+        }],
+    ['m', d => d.getMinutes()],
+    ['ss', d => {
+            const val = d.getSeconds();
+            return (val < 10 ? '0' : '') + val;
+        }],
+    ['s', d => d.getSeconds()],
+    ['SSS', d => {
+            const val = d.getMilliseconds();
+            return val < 10
+                ? '00' + val
+                : val < 100
+                    ? '0' + val
+                    : val;
+        }],
+    ['A', d => d.getHours() < 12 ? 'AM' : 'PM'],
+    ['a', d => d.getHours() < 12 ? 'am' : 'pm'],
+    ['l', (d, loc) => runIntl(loc, 'l', { dateStyle: 'short' }, d)],
+    ['L', (d, loc) => runIntl(loc, 'L', { dateStyle: 'medium' }, d)],
+    ['t', (d, loc) => runIntl(loc, 't', { timeStyle: 'short' }, d)],
+    ['T', (d, loc) => runIntl(loc, 'T', { timeStyle: 'medium' }, d)],
+]
+    .map(el => [el[0], el[1], el[0].length])
+    .sort((a, b) => a[0].length > b[0].length ? -1 : 1);
+function getSpecChain(spec) {
+    const cached = spec_cache.get(spec);
+    if (cached !== undefined)
+        return cached;
+    let base = spec;
+    const repl = [];
+    let repl_len = 0;
+    if (base.indexOf('[') >= 0) {
+        base = base.replace(ESCAPE_RGX, match => {
+            const escape_token = '$' + repl_len++ + '$';
+            repl.push([escape_token, match.slice(1, -1)]);
+            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);
+        }
+    }
+    const chain_len = chain.length;
+    const result = chain_len ? { base, chain, chain_len, repl } : null;
+    spec_cache.set(spec, result);
+    return result;
+}
+const SPEC_ALIASES = {
+    ISO: 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]',
+};
+function format(val, spec, locale = DEFAULT_LOCALE, zone = DEFAULT_TZ, sow = DEFAULT_SOW) {
+    const n_val = convertToDate(val);
+    if (n_val === null)
+        throw new TypeError('format: val must be a Date');
+    if (typeof spec !== 'string')
+        throw new TypeError('format: spec must be a string');
+    if (typeof locale !== 'string')
+        throw new TypeError('format: locale must be a string');
+    if (typeof zone !== 'string')
+        throw new TypeError('format: zone must be a string');
+    const n_spec = getSpecChain(SPEC_ALIASES[spec] || spec);
+    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]);
+        }
+    }
+    for (let i = 0; i < repl_len; i++) {
+        base = base.replace(repl[i][0], repl[i][1]);
+    }
+    return base;
+}
+format.getLocale = function () {
+    return DEFAULT_LOCALE;
+};
+format.setLocale = function (locale) {
+    const normalized = typeof locale === 'string' ? locale.trim() : false;
+    if (!normalized)
+        throw new Error('format/setLocale: locale should be a string');
+    DEFAULT_LOCALE = normalized;
+};
+format.getZone = function () {
+    return DEFAULT_TZ;
+};
+format.setZone = function (zone) {
+    if (typeof zone !== 'string')
+        throw new Error('format/setZone: zone should be a string');
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: zone });
+        DEFAULT_TZ = zone;
+    }
+    catch {
+        throw new Error(`format/setZone: '${zone}' is not a valid zone`);
+    }
+};
+format.getStartOfWeek = function () {
+    return DEFAULT_SOW;
+};
+format.setStartOfWeek = function (sow) {
+    if (typeof sow !== 'string' ||
+        !Object.values(WEEK_STARTS).includes(sow))
+        throw new Error('format/setStartOfWeek: sow should be a valid start of week');
+    DEFAULT_SOW = sow;
+};
+export { format, format as default };

package/esm/date/index.js

@@ -0,0 +1,15 @@
+export { addUTC } from './addUTC';
+export { convertToDate } from './convertToDate';
+export { diff } from './diff';
+export { endOfUTC } from './endOfUTC';
+export { format } from './format';
+export { isLeap } from './isLeap';
+export { nowUnix } from './nowUnix';
+export { nowUnixMs } from './nowUnixMs';
+export { setTimeUTC } from './setTimeUTC';
+export { startOfUTC } from './startOfUTC';
+export { toUnix } from './toUnix';
+export { toUTC } from './toUTC';
+export { isDateFormat as isFormat } from './isFormat';
+export { isDateFormat } from './isFormat';
+export { isDate } from './is';

package/esm/date/is.js

@@ -0,0 +1,4 @@
+function isDate(val) {
+    return val instanceof Date && !isNaN(val);
+}
+export { isDate, isDate as default };

package/esm/date/isFormat.js

@@ -0,0 +1,118 @@
+import LRU from '../caching/LRU';
+const SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
+const TOKENS = [
+    ['YYYY', /\d{4}/.source, (raw, context) => {
+            context.year = parseInt(raw, 10);
+            return context.year > 0;
+        }],
+    ['MM', /(?:0[1-9]|1[0-2])/.source, (raw, context) => {
+            context.month = parseInt(raw, 10);
+            return context.month >= 1 && context.month <= 12;
+        }],
+    ['DD', /(?:0[1-9]|[12][0-9]|3[01])/.source, (raw, context) => {
+            context.day = parseInt(raw, 10);
+            return context.day >= 1 && context.day <= 31;
+        }],
+    ['HH', /(?:[01][0-9]|2[0-3])/.source, (raw, context) => {
+            context.hour = parseInt(raw, 10);
+            return context.hour >= 0 && context.hour <= 23;
+        }],
+    ['mm', /[0-5][0-9]/.source, () => true],
+    ['ss', /[0-5][0-9]/.source, () => true],
+    ['SSS', /\d{3}/.source, () => true],
+    ['Q', /[1-4]/.source, () => true],
+    ['A', /(?:AM|PM)/.source, (raw, context) => {
+            context.is12 = 1;
+            return raw === 'AM' || raw === 'PM';
+        }],
+    ['a', /(?:am|pm)/.source, (raw, context) => {
+            context.is12 = 1;
+            return raw === 'am' || raw === 'pm';
+        }],
+    ['Z', /Z|[+-](?:0[0-9]|1[0-4]):[0-5][0-9]/.source, raw => {
+            if (raw === 'Z')
+                return true;
+            let hour = parseInt(raw[1] + raw[2], 10);
+            if (raw[0] === '-')
+                hour = -hour;
+            const minutes = parseInt(raw[4] + raw[5], 10);
+            if (hour === 14 || hour === -12)
+                return minutes === 0;
+            return hour >= -11 && hour < 14 && [0, 15, 30, 45].indexOf(minutes) >= 0;
+        }],
+];
+const SPEC_ALIASES = {
+    ISO: 'YYYY-MM-DDTHH:mm:ss{.SSS}Z',
+};
+const spec_pat_cache = new LRU({ max_size: 100 });
+function compileSpec(spec, is_chunk = false) {
+    let cached = spec_pat_cache.get(spec);
+    if (cached !== undefined)
+        return cached;
+    const tokens = [];
+    let pat = '';
+    let cursor = 0;
+    while (cursor < spec.length) {
+        if (spec[cursor] === '[') {
+            const end_idx = spec.indexOf(']', cursor);
+            if (end_idx === -1)
+                throw new Error('isDateFormat: Unmatched [ in format string');
+            pat += spec.slice(cursor + 1, end_idx).replace(SPECIAL_CHARS, '\\$&');
+            cursor = end_idx + 1;
+        }
+        else if (spec[cursor] === '{') {
+            const end_idx = spec.indexOf('}', cursor);
+            if (end_idx === -1)
+                throw new Error('isDateFormat: Unmatched { in format string');
+            const compiled = compileSpec(spec.slice(cursor + 1, end_idx), true);
+            pat += '(?:' + compiled.rgx.source + ')?';
+            tokens.push(...compiled.tokens);
+            cursor = end_idx + 1;
+        }
+        else {
+            const token_idx = TOKENS.findIndex(([token_key]) => spec.startsWith(token_key, cursor));
+            if (token_idx >= 0) {
+                const [token_key, token_rgx] = TOKENS[token_idx];
+                pat += '(' + token_rgx + ')';
+                tokens.push(token_idx);
+                cursor += token_key.length;
+            }
+            else {
+                pat += spec[cursor].replace(SPECIAL_CHARS, '\\$&');
+                cursor++;
+            }
+        }
+    }
+    cached = { rgx: is_chunk ? RegExp(pat) : RegExp('^' + pat + '$'), tokens };
+    spec_pat_cache.set(spec, cached);
+    return cached;
+}
+function isDateFormat(input, spec) {
+    if (typeof input !== 'string')
+        return false;
+    if (typeof spec !== 'string')
+        throw new TypeError('isDateFormat: spec must be a string');
+    const { tokens, rgx } = compileSpec(SPEC_ALIASES[spec] || spec);
+    if (!tokens.length)
+        return false;
+    const patMatch = rgx.exec(input);
+    if (!patMatch)
+        return false;
+    const matches = patMatch.slice(1);
+    const context = {};
+    for (let i = 0; i < matches.length; i++) {
+        const match = matches[i];
+        if (match !== undefined && !TOKENS[tokens[i]][2](match, context))
+            return false;
+    }
+    const { is12, day, month, year } = context;
+    if (day && month) {
+        const date = new Date(year || 2024, month - 1, day);
+        if (date.getDate() !== day || date.getMonth() !== month - 1)
+            return false;
+    }
+    if (is12 && 'hour' in context && context.hour > 11)
+        return false;
+    return true;
+}
+export { isDateFormat, isDateFormat as default };

package/esm/date/isLeap.js

@@ -0,0 +1,9 @@
+import { convertToDate } from './convertToDate';
+function isLeap(val) {
+    const n_val = convertToDate(val);
+    if (n_val === null)
+        return false;
+    const year = n_val.getUTCFullYear();
+    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+}
+export { isLeap, isLeap as default };

package/esm/date/nowUnix.js

@@ -0,0 +1,4 @@
+function nowUnix() {
+    return (Date.now() / 1000) | 0;
+}
+export { nowUnix, nowUnix as default };

package/esm/date/nowUnixMs.js

@@ -0,0 +1,4 @@
+function nowUnixMs() {
+    return Date.now();
+}
+export { nowUnixMs, nowUnixMs as default };

package/esm/date/setTimeUTC.js

@@ -0,0 +1,10 @@
+import { convertToDate } from './convertToDate';
+import { isIntegerBetween } from '../number/isIntegerBetween';
+function setTimeUTC(val, props) {
+    const n_val = convertToDate(val);
+    if (n_val === null)
+        throw new TypeError('setTimeUTC requires a date object');
+    const { hour, minute, second, millisecond } = props || {};
+    return new Date(Date.UTC(n_val.getUTCFullYear(), n_val.getUTCMonth(), n_val.getUTCDate(), isIntegerBetween(hour, 0, 23) ? hour : n_val.getUTCHours(), isIntegerBetween(minute, 0, 59) ? minute : n_val.getUTCMinutes(), isIntegerBetween(second, 0, 59) ? second : n_val.getUTCSeconds(), isIntegerBetween(millisecond, 0, 999) ? millisecond : n_val.getUTCMilliseconds()));
+}
+export { setTimeUTC, setTimeUTC as default };

package/esm/date/startOfUTC.js

@@ -0,0 +1,50 @@
+import { convertToDate } from './convertToDate';
+const WEEK_START = new Map([
+    ['week', 1],
+    ['week_sun', 0],
+    ['week_mon', 1],
+    ['week_tue', 2],
+    ['week_wed', 3],
+    ['week_thu', 4],
+    ['week_fri', 5],
+    ['week_sat', 6],
+]);
+function startOfUTC(val, key = 'millisecond') {
+    const n_val = convertToDate(val);
+    if (n_val === null)
+        throw new TypeError('startOfUTC requires a date object');
+    const year = n_val.getUTCFullYear();
+    switch (key) {
+        case 'year':
+            return new Date(Date.UTC(year, 0));
+        case 'quarter': {
+            const UTC_MONTH = n_val.getUTCMonth();
+            return new Date(Date.UTC(year, UTC_MONTH - (UTC_MONTH % 3)));
+        }
+        case 'month':
+            return new Date(Date.UTC(year, n_val.getUTCMonth()));
+        case 'week':
+        case 'week_sun':
+        case 'week_mon':
+        case 'week_tue':
+        case 'week_wed':
+        case 'week_thu':
+        case 'week_fri':
+        case 'week_sat': {
+            const UTC_DAY = n_val.getUTCDay();
+            const UTC_SOD = WEEK_START.get(key);
+            return new Date(Date.UTC(year, n_val.getUTCMonth(), n_val.getUTCDate() - (UTC_DAY < UTC_SOD ? (7 - UTC_SOD) + UTC_DAY : UTC_DAY - UTC_SOD)));
+        }
+        case 'day':
+            return new Date(Date.UTC(year, n_val.getUTCMonth(), n_val.getUTCDate()));
+        case 'hour':
+            return new Date(Date.UTC(year, n_val.getUTCMonth(), n_val.getUTCDate(), n_val.getUTCHours()));
+        case 'minute':
+            return new Date(Date.UTC(year, n_val.getUTCMonth(), n_val.getUTCDate(), n_val.getUTCHours(), n_val.getUTCMinutes()));
+        case 'second':
+            return new Date(Date.UTC(year, n_val.getUTCMonth(), n_val.getUTCDate(), n_val.getUTCHours(), n_val.getUTCMinutes(), n_val.getUTCSeconds()));
+        default:
+            return new Date(Date.UTC(year, n_val.getUTCMonth(), n_val.getUTCDate(), n_val.getUTCHours(), n_val.getUTCMinutes(), n_val.getUTCSeconds(), n_val.getUTCMilliseconds()));
+    }
+}
+export { startOfUTC, startOfUTC as default };

package/esm/date/toUTC.js

@@ -0,0 +1,7 @@
+import { isDate } from './is';
+function toUTC(val) {
+    if (!isDate(val))
+        throw new TypeError('toUTC requires a date object');
+    return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), val.getUTCHours(), val.getUTCMinutes(), val.getUTCSeconds(), val.getUTCMilliseconds()));
+}
+export { toUTC, toUTC as default };

package/esm/date/toUnix.js

@@ -0,0 +1,7 @@
+import { isDate } from './is';
+function toUnix(val) {
+    if (!isDate(val))
+        throw new TypeError('toUnix requires a date object');
+    return (val.valueOf() / 1000) | 0;
+}
+export { toUnix, toUnix as default };

package/esm/deep/freeze.js

@@ -0,0 +1,21 @@
+function deep(obj) {
+    if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++)
+            deep(obj[i]);
+    }
+    else {
+        for (const key in obj) {
+            if (Object.prototype.toString.call(obj[key]) === '[object Object]' ||
+                Array.isArray(obj[key]))
+                deep(obj[key]);
+        }
+    }
+    return Object.freeze(obj);
+}
+function deepFreeze(obj) {
+    if (Object.prototype.toString.call(obj) !== '[object Object]' &&
+        !Array.isArray(obj))
+        throw new TypeError('Only objects/arrays can be frozen');
+    return deep(obj);
+}
+export { deepFreeze, deepFreeze as default };

package/esm/deep/get.js

@@ -0,0 +1,84 @@
+function deepGet(obj, path, get_parent = false) {
+    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)
+        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)) {
+                    if (!isNaN(Number(key))) {
+                        const ix = parseInt(key, 10);
+                        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]);
+                            }
+                        }
+                        node = extracted;
+                        nodes.push(node);
+                    }
+                }
+                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)) {
+            if (!isNaN(Number(key))) {
+                const ix = parseInt(key, 10);
+                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 (typeof node === 'object' && node !== null) {
+            node = node[key];
+            nodes.push(node);
+            if (node === undefined)
+                return undefined;
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (get_parent)
+        nodes.pop();
+    return nodes.length ? nodes.pop() : obj;
+}
+export { deepGet, deepGet as default };

package/esm/deep/index.js

@@ -0,0 +1,8 @@
+export { deepFreeze as freeze } from './freeze';
+export { deepFreeze } from './freeze';
+export { deepGet as get } from './get';
+export { deepGet } from './get';
+export { deepSeal as seal } from './seal';
+export { deepSeal } from './seal';
+export { deepSet as set } from './set';
+export { deepSet } from './set';

package/esm/deep/seal.js

@@ -0,0 +1,21 @@
+function deep(obj) {
+    if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++)
+            deep(obj[i]);
+    }
+    else {
+        for (const key in obj) {
+            if (Object.prototype.toString.call(obj[key]) === '[object Object]' ||
+                Array.isArray(obj[key]))
+                deep(obj[key]);
+        }
+    }
+    return Object.seal(obj);
+}
+function deepSeal(obj) {
+    if (Object.prototype.toString.call(obj) !== '[object Object]' &&
+        !Array.isArray(obj))
+        throw new TypeError('Only objects/arrays can be sealed');
+    return deep(obj);
+}
+export { deepSeal, deepSeal as default };

package/esm/deep/set.js

@@ -0,0 +1,50 @@
+const RGX_MALICIOUS = /__proto__|constructor|prototype/;
+function deepSet(obj, path, value, define = false) {
+    if (Object.prototype.toString.call(obj) !== '[object Object]' &&
+        !Array.isArray(obj))
+        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)
+        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;
+    }
+    else {
+        obj[parts[last_part_ix]] = value;
+    }
+    return true;
+}
+export { deepSet, deepSet as default };