@valkyriestudios/utils 12.47.0 → 12.49.0

package/cjs/array/join.js

@@ -4,7 +4,7 @@ exports.join = join;
 exports.default = join;
 const round_1 = require("../number/round");
 const isIntegerAboveOrEqual_1 = require("../number/isIntegerAboveOrEqual");
-const SPACE_RGX = /(\s)+/g;
+const SPACE_RGX = /\s+/g;
 function join(val, opts) {
     let normalized;
     if (Array.isArray(val)) {

package/cjs/date/convertToDate.js

@@ -2,14 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertToDate = convertToDate;
 exports.default = convertToDate;
-const is_1 = require("./is");
 function convertToDate(val) {
-    if ((0, is_1.isDate)(val)) {
-        return val;
+    switch (typeof val) {
+        case 'number': {
+            if (val !== val)
+                return null;
+            const d = new Date(val);
+            return d.getTime() === d.getTime() ? d : null;
+        }
+        case 'object':
+            return val instanceof Date && val.getTime() === val.getTime() ? val : null;
+        case 'string': {
+            const d = new Date(val);
+            return d.getTime() === d.getTime() ? d : null;
+        }
+        default:
+            return null;
     }
-    else if (typeof val === 'string') {
-        const date = new Date(val);
-        return Number.isNaN(date.getTime()) ? null : date;
-    }
-    return null;
 }

package/cjs/date/diff.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.diff = diff;
 exports.default = diff;
 const convertToDate_1 = require("./convertToDate");
-const SECOND_IN_MILLISECONDS = 1000;
-const MINUTE_IN_MILLISECONDS = SECOND_IN_MILLISECONDS * 60;
-const HOUR_IN_MILLISECONDS = MINUTE_IN_MILLISECONDS * 60;
-const DAY_IN_MILLISECONDS = HOUR_IN_MILLISECONDS * 24;
-const WEEK_IN_MILLISECONDS = DAY_IN_MILLISECONDS * 7;
+const INV_SECOND_IN_MILLISECONDS = 1.0 / 1000;
+const INV_MINUTE_IN_MILLISECONDS = 1.0 / (60 * 1000);
+const INV_HOUR_IN_MILLISECONDS = 1.0 / (60 * 60 * 1000);
+const INV_DAY_IN_MILLISECONDS = 1.0 / (24 * 60 * 60 * 1000);
+const INV_WEEK_IN_MILLISECONDS = 1.0 / (7 * 24 * 60 * 60 * 1000);
 function diff(val_a, val_b, key = 'millisecond') {
     const n_val_a = (0, convertToDate_1.convertToDate)(val_a);
     const n_val_b = (0, convertToDate_1.convertToDate)(val_b);
@@ -18,19 +18,19 @@ function diff(val_a, val_b, key = 'millisecond') {
     switch (key) {
         case 'week':
         case 'weeks':
-            return diff_in_ms / WEEK_IN_MILLISECONDS;
+            return diff_in_ms * INV_WEEK_IN_MILLISECONDS;
         case 'day':
         case 'days':
-            return diff_in_ms / DAY_IN_MILLISECONDS;
+            return diff_in_ms * INV_DAY_IN_MILLISECONDS;
         case 'hour':
         case 'hours':
-            return diff_in_ms / HOUR_IN_MILLISECONDS;
+            return diff_in_ms * INV_HOUR_IN_MILLISECONDS;
         case 'minute':
         case 'minutes':
-            return diff_in_ms / MINUTE_IN_MILLISECONDS;
+            return diff_in_ms * INV_MINUTE_IN_MILLISECONDS;
         case 'second':
         case 'seconds':
-            return diff_in_ms / SECOND_IN_MILLISECONDS;
+            return diff_in_ms * INV_SECOND_IN_MILLISECONDS;
         default:
             return diff_in_ms;
     }

package/cjs/date/format.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.format = format;
 exports.default = format;
 const convertToDate_1 = require("./convertToDate");
-const isFormat_1 = require("./isFormat");
 const LRU_1 = __importDefault(require("../caching/LRU"));
 const WEEK_STARTS = {
     mon: 'mon',
@@ -16,7 +15,6 @@ const WEEK_STARTS = {
 let DEFAULT_LOCALE = 'en-US';
 let DEFAULT_TZ = Intl?.DateTimeFormat?.().resolvedOptions?.().timeZone || 'UTC';
 let DEFAULT_SOW = 'mon';
-const ESCAPE_RGX = /\[([^\]]*)]/g;
 const intl_formatters = new LRU_1.default({ max_size: 100 });
 const spec_cache = new LRU_1.default({ max_size: 100 });
 const zone_offset_cache = new LRU_1.default({ max_size: 100 });
@@ -42,15 +40,8 @@ function WeekNr(d, sow) {
     }
 }
 function toZone(d, zone) {
-    const year = d.getUTCFullYear();
-    const month = d.getUTCMonth();
-    const day = d.getUTCDate();
     const time = d.getTime();
-    const daysInMonths = (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0) ? isFormat_1.MONTHS_LEAP : isFormat_1.MONTHS;
-    let doy = day;
-    for (let i = 0; i <= month; i++)
-        doy += daysInMonths[i];
-    const ckey = zone + ':' + year + ':' + doy;
+    const ckey = zone + ':' + Math.floor(time / 900000);
     const cached = zone_offset_cache.get(ckey);
     if (cached !== undefined)
         return new Date(time + cached);
@@ -80,54 +71,54 @@ function runIntl(loc, token, props, val) {
     return formatter.format(val);
 }
 const Tokens = [
-    ['YYYY', d => d.getFullYear()],
-    ['Q', d => ((d.getMonth() + 3) / 3) | 0],
+    ['YYYY', d => d.getFullYear().toString()],
+    ['Q', d => (((d.getMonth() + 3) / 3) | 0).toString()],
     ['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],
+    ['M', d => (d.getMonth() + 1).toString()],
     ['WW', (d, loc, sow) => {
             const val = WeekNr(d, sow);
             return (val < 10 ? '0' : '') + val;
         }],
-    ['W', (d, loc, sow) => WeekNr(d, sow)],
+    ['W', (d, loc, sow) => WeekNr(d, sow).toString()],
     ['DD', d => {
             const val = d.getDate();
             return (val < 10 ? '0' : '') + val;
         }],
-    ['D', d => d.getDate()],
+    ['D', d => d.getDate().toString()],
     ['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()],
+    ['H', d => d.getHours().toString()],
     ['hh', d => {
             const val = ((d.getHours() + 11) % 12) + 1;
             return (val < 10 ? '0' : '') + val;
         }],
-    ['h', d => ((d.getHours() + 11) % 12) + 1],
+    ['h', d => (((d.getHours() + 11) % 12) + 1).toString()],
     ['mm', d => {
             const val = d.getMinutes();
             return (val < 10 ? '0' : '') + val;
         }],
-    ['m', d => d.getMinutes()],
+    ['m', d => d.getMinutes().toString()],
     ['ss', d => {
             const val = d.getSeconds();
             return (val < 10 ? '0' : '') + val;
         }],
-    ['s', d => d.getSeconds()],
+    ['s', d => d.getSeconds().toString()],
     ['SSS', d => {
             const val = d.getMilliseconds();
             return val < 10
                 ? '00' + val
                 : val < 100
                     ? '0' + val
-                    : val;
+                    : val.toString();
         }],
     ['A', d => d.getHours() < 12 ? 'AM' : 'PM'],
     ['a', d => d.getHours() < 12 ? 'am' : 'pm'],
@@ -141,38 +132,35 @@ const Tokens = [
 const token_map = {};
 for (const t of Tokens)
     token_map[t[0]] = t;
-const TOKENS_RGX = new RegExp(Tokens.map(([tok]) => tok).join('|'), 'g');
+const PARSE_RGX = new RegExp('\\[[^\\]]*\\]|' + Tokens.map(([tok]) => tok).join('|'), 'g');
 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, (_, inner) => {
-            const escape_token = '$' + repl_len++ + '$';
-            repl.push([escape_token, inner]);
-            return escape_token;
-        });
-    }
-    TOKENS_RGX.lastIndex = 0;
     const parts = [];
+    PARSE_RGX.lastIndex = 0;
     let last_idx = 0;
     let has_token = false;
     let m;
-    while (m = TOKENS_RGX.exec(base)) {
-        if (m.index > last_idx) {
-            parts.push({ literal: base.slice(last_idx, m.index) });
+    while (m = PARSE_RGX.exec(spec)) {
+        const match = m[0];
+        const match_start = m.index;
+        if (match_start > last_idx) {
+            parts.push(spec.slice(last_idx, match_start));
+        }
+        if (match.charCodeAt(0) === 91) {
+            parts.push(match.slice(1, -1));
         }
-        parts.push({ token: token_map[m[0]] });
-        has_token = true;
-        last_idx = m.index + m[0].length;
+        else {
+            parts.push(token_map[match][1]);
+            has_token = true;
+        }
+        last_idx = match_start + match.length;
     }
-    if (last_idx < base.length) {
-        parts.push({ literal: base.slice(last_idx) });
+    if (last_idx < spec.length) {
+        parts.push(spec.slice(last_idx));
     }
-    const result = has_token ? { parts, repl } : null;
+    const result = has_token ? parts : null;
     spec_cache.set(spec, result);
     return result;
 }
@@ -189,26 +177,16 @@ function format(val, spec, locale = DEFAULT_LOCALE, zone = DEFAULT_TZ, sow = DEF
         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)
+    const parts = getSpecChain(SPEC_ALIASES[spec] || spec);
+    if (!parts)
         return n_val.toISOString();
     const d = toZone(n_val, zone);
-    const { parts, repl } = n_spec;
     let out = '';
     for (let i = 0; i < parts.length; i++) {
         const part = parts[i];
-        if ('literal' in part) {
-            out += part.literal;
-        }
-        else {
-            out += part.token[1](d, locale, sow);
-        }
+        out += typeof part === 'string' ? part : part(d, locale, sow);
     }
-    let result = out;
-    for (let i = 0; i < repl.length; i++) {
-        result = result.replace(repl[i][0], repl[i][1]);
-    }
-    return result;
+    return out;
 }
 format.getLocale = function () {
     return DEFAULT_LOCALE;

package/cjs/date/is.js

@@ -3,5 +3,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDate = isDate;
 exports.default = isDate;
 function isDate(val) {
-    return val instanceof Date && !isNaN(val);
+    return val instanceof Date && val.getTime() === val.getTime();
 }

package/cjs/date/isFormat.js

@@ -8,47 +8,49 @@ exports.isDateFormat = isDateFormat;
 exports.default = isDateFormat;
 const LRU_1 = __importDefault(require("../caching/LRU"));
 const SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
+const CTX = { year: 0, month: 0, day: 0, hour: -1, is12: 0 };
 const TOKENS = [
-    ['YYYY', /\d{4}/.source, (raw, context) => {
-            context.year = raw | 0;
-            return context.year > 0;
+    ['YYYY', /\d{4}/.source, raw => {
+            CTX.year = +raw;
+            return CTX.year > 0;
         }],
-    ['MM', /(?:0[1-9]|1[0-2])/.source, (raw, context) => {
-            context.month = raw | 0;
-            return context.month >= 1 && context.month <= 12;
+    ['MM', /(?:0[1-9]|1[0-2])/.source, raw => {
+            CTX.month = +raw;
+            return CTX.month >= 1 && CTX.month <= 12;
         }],
-    ['DD', /(?:0[1-9]|[12][0-9]|3[01])/.source, (raw, context) => {
-            context.day = raw | 0;
-            return context.day >= 1 && context.day <= 31;
+    ['DD', /(?:0[1-9]|[12][0-9]|3[01])/.source, raw => {
+            CTX.day = +raw;
+            return CTX.day >= 1 && CTX.day <= 31;
         }],
-    ['HH', /(?:[01][0-9]|2[0-3])/.source, (raw, context) => {
-            context.hour = raw | 0;
-            return context.hour >= 0 && context.hour <= 23;
+    ['HH', /(?:[01][0-9]|2[0-3])/.source, raw => {
+            CTX.hour = +raw;
+            return CTX.hour >= 0 && CTX.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;
+    ['A', /(?:AM|PM)/.source, raw => {
+            CTX.is12 = 1;
             return raw === 'AM' || raw === 'PM';
         }],
-    ['a', /(?:am|pm)/.source, (raw, context) => {
-            context.is12 = 1;
+    ['a', /(?:am|pm)/.source, raw => {
+            CTX.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 = (raw[1] + raw[2]) | 0;
-            if (raw[0] === '-')
+            let hour = +(raw[1] + raw[2]);
+            if (raw.charCodeAt(0) === 45)
                 hour = -hour;
-            const minutes = (raw[4] + raw[5]) | 0;
+            const minutes = +(raw[4] + raw[5]);
             if (hour === 14 || hour === -12)
                 return minutes === 0;
-            return hour >= -11 && hour < 14 && [0, 15, 30, 45].indexOf(minutes) >= 0;
+            return hour >= -11 && hour < 14 && (minutes === 0 || minutes === 15 || minutes === 30 || minutes === 45);
         }],
 ];
+TOKENS.sort((a, b) => b[0].length - a[0].length);
 const SPEC_ALIASES = {
     ISO: 'YYYY-MM-DDTHH:mm:ss{.SSS}Z',
 };
@@ -85,14 +87,18 @@ function compileSpec(spec, is_chunk = false) {
             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;
+            let matched = false;
+            for (let i = 0; i < TOKENS.length; i++) {
+                const [token_key, token_rgx] = TOKENS[i];
+                if (spec.startsWith(token_key, cursor)) {
+                    pat += '(' + token_rgx + ')';
+                    tokens.push(i);
+                    cursor += token_key.length;
+                    matched = true;
+                    break;
+                }
             }
-            else {
+            if (!matched) {
                 pat += spec[cursor].replace(SPECIAL_CHARS, '\\$&');
                 cursor++;
             }
@@ -107,23 +113,26 @@ function isDateFormat(input, spec) {
         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)
+    const compiled = compileSpec(SPEC_ALIASES[spec] || spec);
+    if (!compiled.tokens.length)
         return false;
-    const patMatch = rgx.exec(input);
+    const patMatch = compiled.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))
+    CTX.year = 0;
+    CTX.month = 0;
+    CTX.day = 0;
+    CTX.hour = -1;
+    CTX.is12 = 0;
+    const { tokens } = compiled;
+    for (let i = 0; i < tokens.length; i++) {
+        const match = patMatch[i + 1];
+        if (match !== undefined && !TOKENS[tokens[i]][2](match))
             return false;
     }
-    const { is12, day, month, year } = context;
-    if (day && month && !isValidDay(year || 2024, month, day))
+    if (CTX.day > 0 && CTX.month > 0 && !isValidDay(CTX.year || 2024, CTX.month, CTX.day))
         return false;
-    if (is12 && 'hour' in context && context.hour > 11)
+    if (CTX.is12 === 1 && CTX.hour > 11)
         return false;
     return true;
 }

package/cjs/deep/get.js

@@ -3,87 +3,61 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deepGet = deepGet;
 exports.default = deepGet;
 function deepGet(obj, path, get_parent = false) {
-    if (Object.prototype.toString.call(obj) !== '[object Object]' &&
-        !Array.isArray(obj))
+    if (Object.prototype.toString.call(obj) !== '[object Object]' && !Array.isArray(obj)) {
         throw new TypeError('deepGet: Requires object or array');
-    if (typeof path !== 'string' ||
-        !path.length)
+    }
+    if (!path || typeof path !== 'string') {
         throw new TypeError('deepGet: Invalid path provided');
-    const nodes = [];
-    let node = obj;
-    let key = '';
-    for (let i = 0; i < path.length; i++) {
-        const char = path[i];
-        switch (char) {
-            case '[':
-            case ']':
-            case '.':
-                if (!key)
-                    break;
-                if (Array.isArray(node)) {
-                    let ix = Number(key);
-                    if (!isNaN(ix)) {
-                        ix = ix | 0;
-                        if (ix < 0 || ix > node.length - 1)
-                            return undefined;
-                        node = node[ix];
-                        nodes.push(node);
-                    }
-                    else {
-                        const extracted = [];
-                        for (let y = 0; y < node.length; y++) {
-                            const el = deepGet(node[y], key);
-                            if (el !== undefined) {
-                                extracted.push(...Array.isArray(el) ? el : [el]);
+    }
+    let cursor = obj;
+    let parent = obj;
+    let keyStart = 0;
+    const len = path.length;
+    for (let i = 0; i <= len; i++) {
+        const code = i === len ? 46 : path.charCodeAt(i);
+        if (code === 46 || code === 91 || code === 93) {
+            if (i === keyStart) {
+                keyStart = i + 1;
+                continue;
+            }
+            const key = path.substring(keyStart, i);
+            keyStart = i + 1;
+            parent = cursor;
+            if (Array.isArray(cursor)) {
+                const idx = +key;
+                if (idx === idx) {
+                    cursor = cursor[idx | 0];
+                }
+                else {
+                    const mapped = [];
+                    const cLen = cursor.length;
+                    for (let j = 0; j < cLen; j++) {
+                        const item = cursor[j];
+                        if (item && typeof item === 'object') {
+                            const val = item[key];
+                            if (val !== undefined) {
+                                if (Array.isArray(val)) {
+                                    const vLen = val.length;
+                                    for (let k = 0; k < vLen; k++)
+                                        mapped.push(val[k]);
+                                }
+                                else {
+                                    mapped.push(val);
+                                }
                             }
                         }
-                        node = extracted;
-                        nodes.push(node);
                     }
+                    if (mapped.length === 0)
+                        return undefined;
+                    cursor = mapped;
                 }
-                else if (typeof node === 'object' && node !== null) {
-                    node = node[key];
-                    nodes.push(node);
-                }
-                key = '';
-                break;
-            default:
-                key += char;
-                break;
-        }
-    }
-    if (key) {
-        if (Array.isArray(node)) {
-            let ix = Number(key);
-            if (!isNaN(ix)) {
-                ix = ix | 0;
-                if (ix < 0 || ix > node.length - 1)
-                    return undefined;
-                node = node[ix];
-                nodes.push(node);
             }
-            else {
-                const extracted = [];
-                for (let i = 0; i < node.length; i++) {
-                    const val = node[i]?.[key];
-                    if (val !== undefined)
-                        extracted.push(...Array.isArray(val) ? val : [val]);
-                }
-                node = extracted.length ? extracted : undefined;
-                nodes.push(node);
+            else if (cursor) {
+                cursor = cursor[key];
             }
-        }
-        else if (typeof node === 'object' && node !== null) {
-            node = node[key];
-            nodes.push(node);
-            if (node === undefined)
+            if (cursor === undefined)
                 return undefined;
         }
-        else {
-            return undefined;
-        }
     }
-    if (get_parent)
-        nodes.pop();
-    return nodes.length ? nodes.pop() : obj;
+    return get_parent ? parent : cursor;
 }

package/cjs/deep/set.js

@@ -9,45 +9,82 @@ function deepSet(obj, path, value, define = false) {
         throw new TypeError('Deepset is only supported for objects');
     if (typeof path !== 'string')
         throw new TypeError('No path was given');
-    if (RGX_MALICIOUS.test(path))
-        throw new TypeError('Malicious path provided');
-    const path_s = path.trim();
-    if (!path_s.length)
+    if (path.trim().length === 0) {
         throw new TypeError('No path was given');
-    const parts = path_s
-        .replace(/\[/g, '.')
-        .replace(/(\.){2,}/g, '.')
-        .replace(/(^\.|\.$|\])/g, '')
-        .split('.');
-    const last_part_ix = parts.length - 1;
-    for (let i = 0; i < last_part_ix; i++) {
-        if (Array.isArray(obj)) {
-            const idx = parseInt(parts[i]);
-            if (!Number.isInteger(idx) || idx < 0)
-                throw new TypeError('Invalid path provided');
-            if (!obj[idx])
-                obj[idx] = {};
-            obj = obj[idx];
-        }
-        else {
-            if (!obj[parts[i]])
-                obj[parts[i]] = {};
-            obj = obj[parts[i]];
-        }
     }
-    if (!Array.isArray(obj) && Object.prototype.toString.call(obj) !== '[object Object]')
-        return false;
-    if (define) {
-        Object.defineProperty(obj, parts[last_part_ix], value);
-    }
-    else if (Array.isArray(obj)) {
-        const idx = parseInt(parts[last_part_ix]);
-        if (!Number.isInteger(idx) || idx < 0)
-            throw new TypeError('Invalid path provided');
-        obj[idx] = value;
+    if (RGX_MALICIOUS.test(path)) {
+        throw new TypeError('Malicious path provided');
     }
-    else {
-        obj[parts[last_part_ix]] = value;
+    let cursor = obj;
+    let keyStart = 0;
+    const len = path.length;
+    for (let i = 0; i <= len; i++) {
+        const code = i === len ? 46 : path.charCodeAt(i);
+        if (code === 46 || code === 91 || code === 93) {
+            if (i === keyStart) {
+                keyStart = i + 1;
+                continue;
+            }
+            const key = path.substring(keyStart, i);
+            keyStart = i + 1;
+            let isEnd = i === len;
+            if (!isEnd) {
+                let j = i + 1;
+                isEnd = true;
+                for (; j < len; j++) {
+                    const c = path.charCodeAt(j);
+                    if (c !== 46 && c !== 91 && c !== 93) {
+                        isEnd = false;
+                        break;
+                    }
+                }
+            }
+            if (isEnd) {
+                if (Array.isArray(cursor)) {
+                    const idx = +key;
+                    if (idx !== idx || (idx | 0) !== idx || idx < 0) {
+                        throw new TypeError('Invalid path provided');
+                    }
+                    if (define) {
+                        Object.defineProperty(cursor, key, value);
+                    }
+                    else {
+                        cursor[idx] = value;
+                    }
+                }
+                else if (define) {
+                    Object.defineProperty(cursor, key, value);
+                }
+                else {
+                    cursor[key] = value;
+                }
+                return true;
+            }
+            let nextCursor;
+            if (Array.isArray(cursor)) {
+                const idx = +key;
+                if (idx !== idx || (idx | 0) !== idx || idx < 0) {
+                    throw new TypeError('Invalid path provided');
+                }
+                nextCursor = cursor[idx];
+            }
+            else {
+                nextCursor = cursor[key];
+            }
+            if (nextCursor === undefined || nextCursor === null) {
+                nextCursor = {};
+                if (Array.isArray(cursor)) {
+                    cursor[+key] = nextCursor;
+                }
+                else {
+                    cursor[key] = nextCursor;
+                }
+            }
+            else if (typeof nextCursor !== 'object') {
+                return false;
+            }
+            cursor = nextCursor;
+        }
     }
-    return true;
+    return false;
 }