atomic-fns 1.1.7 → 2.0.0

package/dist/object/matches.js

@@ -0,0 +1,284 @@
+/**
+ * Partial deep matching: `isMatch`, `matches`.
+ */
+import { isPlainObject } from '../is/isPlainObject.js';
+import { enumerableKeys } from '../internal/keys.js';
+import { walkArray } from '../internal/sparse.js';
+import { enterDepth, exitDepth, guardDepth } from '../internal/walk.js';
+import { isEqual } from './isEqual.js';
+/** Steps one call may take before it throws, so no input can keep it running for long. */
+const MAX_MATCH_STEPS = 2 ** 25;
+/** Message of the `RangeError` a call throws past {@link MAX_MATCH_STEPS}. */
+const STEPS_ERROR = `matching took more than ${String(MAX_MATCH_STEPS)} steps`;
+/** Answers one call remembers; past this it stops remembering, so only time grows, not memory. */
+const MAX_REMEMBERED_PAIRS = 2 ** 20;
+function step(pending, count = 1) {
+    pending.steps += count;
+    if (pending.steps > MAX_MATCH_STEPS)
+        throw new RangeError(STEPS_ERROR);
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+function remember(pending, shape, target, answer) {
+    if (pending.remembered >= MAX_REMEMBERED_PAIRS)
+        return false;
+    let answers = pending.answers.get(shape);
+    if (answers === undefined)
+        pending.answers.set(shape, (answers = new WeakMap()));
+    answers.set(target, answer);
+    pending.remembered++;
+    return true;
+}
+/** Settle the answer of a pair that opened at `depth` when the tentative list was `mark` long. */
+function settle(pending, shape, target, ok, depth, mark, low) {
+    const { tentative } = pending;
+    if (!ok || low >= depth) {
+        for (let i = mark; i < tentative.length; i++) {
+            const entry = tentative[i];
+            const answers = pending.answers.get(entry.shape);
+            if (ok) {
+                answers?.set(entry.target, true);
+            }
+            else {
+                answers?.delete(entry.target);
+                pending.remembered--;
+            }
+        }
+        tentative.length = mark;
+        remember(pending, shape, target, ok);
+        return;
+    }
+    step(pending, tentative.length - mark);
+    for (let i = mark; i < tentative.length; i++)
+        tentative[i].low = low;
+    pending.low = Math.min(pending.low, low);
+    const entry = { shape, target, low };
+    if (remember(pending, shape, target, entry))
+        pending.tentative.push(entry);
+}
+/** Match a plain-object or array `shape` against an object `target` below the top. */
+function matchPair(target, shape, pending) {
+    const known = pending.answers.get(shape)?.get(target);
+    if (known !== undefined) {
+        if (typeof known === 'boolean')
+            return known;
+        pending.low = Math.min(pending.low, known.low);
+        return true;
+    }
+    let partners = pending.open.get(shape);
+    const openAt = partners?.get(target);
+    if (openAt !== undefined) {
+        pending.low = Math.min(pending.low, openAt);
+        return true;
+    }
+    if (partners === undefined)
+        pending.open.set(shape, (partners = new Map()));
+    const depth = ++pending.depth;
+    const outerLow = pending.low;
+    const mark = pending.tentative.length;
+    partners.set(target, depth);
+    pending.low = Number.POSITIVE_INFINITY;
+    enterDepth();
+    let ok;
+    try {
+        ok = Array.isArray(shape)
+            ? matchArray(target, shape, pending)
+            : matchObject(target, shape, pending, false);
+    }
+    finally {
+        exitDepth();
+        partners.delete(target);
+        pending.depth--;
+    }
+    const low = pending.low;
+    pending.low = outerLow;
+    settle(pending, shape, target, ok, depth, mark, low);
+    return ok;
+}
+/**
+ * Whether each shape in `wanted` can have a candidate of its own, by augmenting paths (Kuhn's
+ * algorithm), so the answer does not depend on the order of either array.
+ */
+function assign(candidates, wanted, pending) {
+    const owner = new Array(candidates.length).fill(-1);
+    const seenBy = new Array(candidates.length).fill(-1);
+    const fits = (shape, candidate) => matchValue(candidates[candidate], wanted[shape], pending, false);
+    const unplaced = [];
+    // First fit, where every candidate before `firstFree` is taken; augmenting paths repair the rest.
+    let firstFree = 0;
+    for (let shape = 0; shape < wanted.length; shape++) {
+        let placed = false;
+        for (let candidate = firstFree; candidate < candidates.length && !placed; candidate++) {
+            if (owner[candidate] >= 0)
+                step(pending);
+            else if (fits(shape, candidate)) {
+                owner[candidate] = shape;
+                placed = true;
+            }
+        }
+        while (firstFree < candidates.length && owner[firstFree] >= 0)
+            firstFree++;
+        if (!placed)
+            unplaced.push(shape);
+    }
+    for (const root of unplaced) {
+        const path = [{ shape: root, next: 0 }];
+        const taken = [];
+        let placed = false;
+        while (path.length > 0 && !placed) {
+            const frame = path[path.length - 1];
+            if (frame.next === candidates.length) {
+                path.pop();
+                taken.pop();
+                continue;
+            }
+            const candidate = frame.next++;
+            if (seenBy[candidate] === root) {
+                step(pending);
+                continue;
+            }
+            if (!fits(frame.shape, candidate))
+                continue;
+            seenBy[candidate] = root;
+            taken.push(candidate);
+            if (owner[candidate] < 0) {
+                for (let i = 0; i < path.length; i++)
+                    owner[taken[i]] = path[i].shape;
+                placed = true;
+            }
+            else {
+                path.push({ shape: owner[candidate], next: 0 });
+            }
+        }
+        if (!placed)
+            return false;
+    }
+    return true;
+}
+function matchArray(target, source, pending) {
+    const wantedValues = new Map();
+    const wantedShapes = [];
+    let unmet = 0;
+    walkArray(source, (event) => {
+        if (event.kind !== 'value')
+            return;
+        step(pending);
+        if (isObject(event.value)) {
+            wantedShapes.push(event.value);
+        }
+        else {
+            wantedValues.set(event.value, (wantedValues.get(event.value) ?? 0) + 1);
+            unmet++;
+        }
+    });
+    const candidates = [];
+    walkArray(target, (event) => {
+        if (event.kind !== 'value')
+            return;
+        step(pending);
+        if (isObject(event.value)) {
+            if (wantedShapes.length > 0)
+                candidates.push(event.value);
+            return;
+        }
+        const count = wantedValues.get(event.value);
+        if (count !== undefined && count > 0) {
+            wantedValues.set(event.value, count - 1);
+            unmet--;
+        }
+    });
+    if (unmet > 0 || wantedShapes.length > candidates.length)
+        return false;
+    return assign(candidates, wantedShapes, pending);
+}
+function matchObject(target, source, pending, top) {
+    const keys = enumerableKeys(source);
+    if (target === null || target === undefined)
+        return keys.length === 0;
+    if (!top && Array.isArray(target))
+        return false;
+    const base = Object(target);
+    for (const key of keys) {
+        const wanted = source[key];
+        if (wanted === undefined) {
+            if (!(key in base) || base[key] !== undefined)
+                return false;
+        }
+        else if (!matchValue(base[key], wanted, pending, false)) {
+            return false;
+        }
+    }
+    return true;
+}
+function matchValue(target, source, pending, top) {
+    step(pending);
+    const isArray = Array.isArray(source);
+    if (!isArray && !isPlainObject(source))
+        return isEqual(target, source);
+    if (isArray && !Array.isArray(target))
+        return false;
+    if (top) {
+        enterDepth();
+        try {
+            return isArray
+                ? matchArray(target, source, pending)
+                : matchObject(target, source, pending, true);
+        }
+        finally {
+            exitDepth();
+        }
+    }
+    if (!isObject(target))
+        return false;
+    return matchPair(target, source, pending);
+}
+/**
+ * True when `obj` has every key of `source`, deeply, with an {@link isEqual} value, as lodash's
+ * `isMatch` checks. A plain object in `source` matches an object with at least its own enumerable
+ * keys, symbols included, and a key whose source value is `undefined` must be present with the
+ * value `undefined`. An array in `source` matches an array that holds a match for each of its
+ * elements, each element of `obj` serving one, so arrays match as subsets in any order. A hole is
+ * not an element: it wants nothing in `source` and offers nothing in `obj`, as an absent key does.
+ * Anything else in `source`, a `Date` or `Map` included, must be {@link isEqual} to the value found.
+ * At the top, `obj` may be any value: a primitive is read as its boxed form, and `null` or
+ * `undefined` matches only a `source` with no keys.
+ *
+ * Cycles are assumed to match, and each pair of objects is answered once.
+ * @param obj The value to test.
+ * @param source The partial shape to look for.
+ * @returns Whether `obj` matches.
+ * @throws {RangeError} past 1000 levels of nesting, or past 33554432 steps of work.
+ * @example
+ * ```ts
+ * isMatch({ a: 1, b: { c: 2, d: 3 } }, { b: { c: 2 } }) // true
+ * isMatch({ tags: ['a', 'b', 'c'] }, { tags: ['c', 'a'] }) // true
+ * isMatch({ a: 1 }, { a: undefined }) // false
+ * isMatch({}, { a: {} }) // false
+ * ```
+ */
+export function isMatch(obj, source) {
+    return guardDepth(() => matchValue(obj, source, {
+        open: new Map(),
+        answers: new WeakMap(),
+        tentative: [],
+        remembered: 0,
+        depth: 0,
+        low: Number.POSITIVE_INFINITY,
+        steps: 0
+    }, true));
+}
+/**
+ * A predicate that tells whether a value matches `source`, by the rules of {@link isMatch}; it is
+ * lodash's `matches` shorthand as a function to pass to `filter`, `find` and the like.
+ * @param source The partial shape to look for.
+ * @returns `(obj) => isMatch(obj, source)`.
+ * @example
+ * ```ts
+ * const users = [{ name: 'a', active: true }, { name: 'b', active: false }]
+ * users.filter(matches({ active: true })) // [{ name: 'a', active: true }]
+ * ```
+ */
+export function matches(source) {
+    return (obj) => isMatch(obj, source);
+}

package/dist/object/merge.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Writing sources into a target: `merge`, `defaults`, `defaultsDeep`.
+ */
+/**
+ * Merge the own enumerable string and symbol keys of each source into `target`, deeply, and
+ * return `target`, as lodash's `merge` does. A plain object merges into a plain object and an array
+ * into an array; anything else, or a container of the other kind, is assigned in its place (a
+ * plain object or array from a source is copied first, with its prototype, so `target` never
+ * shares it). An `undefined` source value does not replace a key the target has. Keys are
+ * assigned, so setters run; `__proto__`, `constructor` and `prototype` are defined as own data.
+ * Replacing an own `constructor` function with an object is refused.
+ * Each key gets its own copy of a source object it shares with another key.
+ * @param target The object to change.
+ * @param sources Objects to merge in, left to right; sources that are not objects are skipped.
+ * @returns `target`.
+ * @throws {TypeError} when `target` is not an object, or for a key of it that is read-only or
+ * has only a getter.
+ * @throws {RangeError} past 1000 levels of nesting, for an array index or `length` that would
+ * grow an array past its end, for a huge sparse source array, or when shared objects would be
+ * copied past 500000 units of work.
+ * @example
+ * ```ts
+ * merge({ a: [{ b: 2 }], d: 1 }, { a: [{ c: 3 }] }) // { a: [{ b: 2, c: 3 }], d: 1 }
+ * ```
+ */
+export declare function merge<T extends object>(target: T, ...sources: unknown[]): T;
+/**
+ * Fill each key of `target` that reads `undefined` with the first source that has it, and return
+ * `target`, as lodash's `defaults` does. A string key only inherited from `Object.prototype`
+ * (such as `toString`) also counts as missing; one inherited from a class does not. A key `target`
+ * has only a getter for is left alone. Only the own enumerable string and symbol keys of each
+ * source are considered.
+ * Existing own symbol data properties keep their descriptors when filled.
+ * @param target The object to fill.
+ * @param sources Objects to read defaults from, left to right; sources that are not objects are
+ * skipped.
+ * @returns `target`.
+ * @throws {TypeError} when `target` is not an object.
+ * @throws {RangeError} for an array index past the end of an array `target`.
+ * @example
+ * ```ts
+ * defaults({ a: 1 }, { a: 3, b: 2 }) // { a: 1, b: 2 }
+ * ```
+ */
+export declare function defaults<T extends object>(target: T, ...sources: unknown[]): T;
+/**
+ * {@link defaults}, all the way down: where `target` and a source both hold a plain object (or
+ * both an array) at a key, the source fills the missing keys inside it. A filled plain object or
+ * array is copied, with its prototype, so `target` never shares it with a source; a cycle back to
+ * a source itself points at `target`.
+ * Filling `__proto__` is refused unless the target has a null prototype; `constructor` and
+ * `prototype` are filled as own data, and inherited values are never descended into.
+ * Only own enumerable string and symbol keys of each source are considered.
+ * @param target The object to fill.
+ * @param sources Objects to read defaults from, left to right; sources that are not objects are
+ * skipped.
+ * @returns `target`.
+ * @throws {TypeError} when `target` is not an object.
+ * @throws {RangeError} past 1000 levels of nesting, for an index past the end of an array, for a
+ * huge sparse source array, or when shared objects would be copied past 500000 units of work.
+ * @example
+ * ```ts
+ * defaultsDeep({ a: { b: 2 } }, { a: { b: 1, c: 3 } }) // { a: { b: 2, c: 3 } }
+ * ```
+ */
+export declare function defaultsDeep<T extends object>(target: T, ...sources: unknown[]): T;

package/dist/object/merge.js

@@ -0,0 +1,272 @@
+/**
+ * Writing sources into a target: `merge`, `defaults`, `defaultsDeep`.
+ */
+import { isPlainObject } from '../is/isPlainObject.js';
+import { enumerableKeys } from '../internal/keys.js';
+import { assertNotHugeSparse, isCanonicalArrayIndex } from '../internal/sparse.js';
+import { enterDepth, exitDepth, guardDepth, RevisitBudget } from '../internal/walk.js';
+import { writeKey } from './parsePath.js';
+const MERGE_BUDGET = 500_000;
+const BUDGET_ERROR = `input repeats shared objects past ${String(MERGE_BUDGET)} units of work`;
+/** An index or `length` write that would grow an array past its end. */
+function assertInRange(t, key, value) {
+    if (!Array.isArray(t) || typeof key !== 'string')
+        return;
+    const grows = key === 'length' && (Object(value) === value || Number(value) > t.length);
+    if (grows || (isCanonicalArrayIndex(key) && Number(key) > t.length)) {
+        throw new RangeError(`array index ${key} is past the end`);
+    }
+}
+function assertTarget(target, name) {
+    if (target === null || typeof target !== 'object') {
+        throw new TypeError(`${name} target must be an object`);
+    }
+}
+/** Record the (source, target) pair, and say whether it was recorded already. */
+function walkedBefore(state, s, t) {
+    let targets = state.pairs.get(s);
+    if (targets?.has(t))
+        return true;
+    if (targets === undefined) {
+        targets = new WeakSet();
+        state.pairs.set(s, targets);
+    }
+    targets.add(t);
+    return false;
+}
+/**
+ * Write each key of source `s` into target `t` with `writeEntry`, one level deeper. An `existing`
+ * target (one `target` already held, not a fresh copy) is walked once per source object. Charges
+ * the revisit budget and grows an array target to an array source's length.
+ */
+function walkInto(t, s, state, existing, writeEntry) {
+    if (existing && walkedBefore(state, s, t))
+        return;
+    const keys = enumerableKeys(s);
+    state.budget.note(s, keys.length);
+    enterDepth();
+    try {
+        if (Array.isArray(s) && Array.isArray(t)) {
+            assertNotHugeSparse(s);
+            if (t.length < s.length)
+                t.length = s.length;
+        }
+        for (const key of keys)
+            writeEntry(key);
+    }
+    finally {
+        exitDepth();
+    }
+}
+/**
+ * Copy `source` with `fill`, into an empty array or an object with the prototype of `source`.
+ * While `fill` runs, `source` maps to the copy, so a cycle in `source` points back at the copy.
+ */
+function copyWith(state, source, fill) {
+    const copy = Array.isArray(source)
+        ? []
+        : Object.create(Object.getPrototypeOf(source));
+    state.copies.set(source, copy);
+    try {
+        fill(copy);
+    }
+    finally {
+        state.copies.delete(source);
+    }
+    return copy;
+}
+function mergeKey(t, s, key, state) {
+    const sv = s[key];
+    assertInRange(t, key, sv);
+    const tv = Object.hasOwn(t, key) ? t[key] : undefined;
+    if (key === 'constructor' && typeof tv === 'function' && sv !== null && typeof sv === 'object') {
+        return;
+    }
+    if (sv === undefined && key in t)
+        return;
+    const svArray = Array.isArray(sv);
+    if (!svArray && !isPlainObject(sv)) {
+        writeKey(t, key, sv);
+        return;
+    }
+    const source = sv;
+    const same = svArray ? Array.isArray(tv) : isPlainObject(tv);
+    if (same) {
+        mergeInto(tv, source, state, true);
+        return;
+    }
+    const copy = state.copies.get(source) ??
+        copyWith(state, source, (fresh) => mergeInto(fresh, source, state, false));
+    writeKey(t, key, copy);
+}
+function mergeInto(t, s, state, existing) {
+    walkInto(t, s, state, existing, (key) => mergeKey(t, s, key, state));
+}
+/**
+ * Merge the own enumerable string and symbol keys of each source into `target`, deeply, and
+ * return `target`, as lodash's `merge` does. A plain object merges into a plain object and an array
+ * into an array; anything else, or a container of the other kind, is assigned in its place (a
+ * plain object or array from a source is copied first, with its prototype, so `target` never
+ * shares it). An `undefined` source value does not replace a key the target has. Keys are
+ * assigned, so setters run; `__proto__`, `constructor` and `prototype` are defined as own data.
+ * Replacing an own `constructor` function with an object is refused.
+ * Each key gets its own copy of a source object it shares with another key.
+ * @param target The object to change.
+ * @param sources Objects to merge in, left to right; sources that are not objects are skipped.
+ * @returns `target`.
+ * @throws {TypeError} when `target` is not an object, or for a key of it that is read-only or
+ * has only a getter.
+ * @throws {RangeError} past 1000 levels of nesting, for an array index or `length` that would
+ * grow an array past its end, for a huge sparse source array, or when shared objects would be
+ * copied past 500000 units of work.
+ * @example
+ * ```ts
+ * merge({ a: [{ b: 2 }], d: 1 }, { a: [{ c: 3 }] }) // { a: [{ b: 2, c: 3 }], d: 1 }
+ * ```
+ */
+export function merge(target, ...sources) {
+    assertTarget(target, 'merge');
+    const budget = new RevisitBudget(MERGE_BUDGET, BUDGET_ERROR);
+    return guardDepth(() => {
+        for (const source of sources) {
+            if (source === null || typeof source !== 'object')
+                continue;
+            mergeInto(target, source, { copies: new WeakMap(), pairs: new WeakMap(), budget }, true);
+        }
+        return target;
+    });
+}
+function descriptorAlongChain(obj, key) {
+    for (let cur = obj; cur; cur = Object.getPrototypeOf(cur)) {
+        const desc = Object.getOwnPropertyDescriptor(cur, key);
+        if (desc)
+            return desc;
+    }
+    return undefined;
+}
+/**
+ * Whether `defaults` fills `key` of `target`: it reads `undefined`, or it is a string key only
+ * `Object.prototype` has, and it is not a getter without a setter.
+ */
+function needsDefault(target, key, value) {
+    const fill = value === undefined ||
+        (typeof key !== 'symbol' &&
+            !Object.hasOwn(target, key) &&
+            value === Object.prototype[key]);
+    if (!fill)
+        return false;
+    if (key === '__proto__')
+        return Object.getPrototypeOf(target) === null;
+    const desc = descriptorAlongChain(target, key);
+    return !(desc && 'get' in desc && desc.set === undefined);
+}
+function writeDefault(target, key, value) {
+    const desc = typeof key === 'symbol' ? Object.getOwnPropertyDescriptor(target, key) : undefined;
+    if (desc && 'value' in desc) {
+        ;
+        target[key] = value;
+    }
+    else {
+        writeKey(target, key, value);
+    }
+}
+/**
+ * Fill each key of `target` that reads `undefined` with the first source that has it, and return
+ * `target`, as lodash's `defaults` does. A string key only inherited from `Object.prototype`
+ * (such as `toString`) also counts as missing; one inherited from a class does not. A key `target`
+ * has only a getter for is left alone. Only the own enumerable string and symbol keys of each
+ * source are considered.
+ * Existing own symbol data properties keep their descriptors when filled.
+ * @param target The object to fill.
+ * @param sources Objects to read defaults from, left to right; sources that are not objects are
+ * skipped.
+ * @returns `target`.
+ * @throws {TypeError} when `target` is not an object.
+ * @throws {RangeError} for an array index past the end of an array `target`.
+ * @example
+ * ```ts
+ * defaults({ a: 1 }, { a: 3, b: 2 }) // { a: 1, b: 2 }
+ * ```
+ */
+export function defaults(target, ...sources) {
+    assertTarget(target, 'defaults');
+    for (const source of sources) {
+        if (source === null || typeof source !== 'object')
+            continue;
+        const record = source;
+        for (const key of enumerableKeys(record)) {
+            if (!needsDefault(target, key, target[key]))
+                continue;
+            const value = record[key];
+            assertInRange(target, key, value);
+            writeDefault(target, key, value);
+        }
+    }
+    return target;
+}
+/** `value`, or a copy of it filled the way `defaultsDeep` fills, when it is a plain object or array. */
+function copyOf(value, state) {
+    if (!Array.isArray(value) && !isPlainObject(value))
+        return value;
+    return (state.copies.get(value) ?? copyWith(state, value, (copy) => fillInto(copy, value, state, false)));
+}
+function fillKey(t, s, key, state) {
+    const tv = t[key];
+    if (needsDefault(t, key, tv)) {
+        const sv = s[key];
+        if (sv === undefined)
+            return;
+        assertInRange(t, key, sv);
+        writeDefault(t, key, copyOf(sv, state));
+        return;
+    }
+    if (!Object.hasOwn(t, key))
+        return;
+    const tvArray = Array.isArray(tv);
+    if (!tvArray && !isPlainObject(tv))
+        return;
+    const sv = s[key];
+    const sameKind = tvArray ? Array.isArray(sv) : isPlainObject(sv);
+    if (sameKind)
+        fillInto(tv, sv, state, true);
+}
+function fillInto(t, s, state, existing) {
+    walkInto(t, s, state, existing, (key) => fillKey(t, s, key, state));
+}
+/**
+ * {@link defaults}, all the way down: where `target` and a source both hold a plain object (or
+ * both an array) at a key, the source fills the missing keys inside it. A filled plain object or
+ * array is copied, with its prototype, so `target` never shares it with a source; a cycle back to
+ * a source itself points at `target`.
+ * Filling `__proto__` is refused unless the target has a null prototype; `constructor` and
+ * `prototype` are filled as own data, and inherited values are never descended into.
+ * Only own enumerable string and symbol keys of each source are considered.
+ * @param target The object to fill.
+ * @param sources Objects to read defaults from, left to right; sources that are not objects are
+ * skipped.
+ * @returns `target`.
+ * @throws {TypeError} when `target` is not an object.
+ * @throws {RangeError} past 1000 levels of nesting, for an index past the end of an array, for a
+ * huge sparse source array, or when shared objects would be copied past 500000 units of work.
+ * @example
+ * ```ts
+ * defaultsDeep({ a: { b: 2 } }, { a: { b: 1, c: 3 } }) // { a: { b: 2, c: 3 } }
+ * ```
+ */
+export function defaultsDeep(target, ...sources) {
+    assertTarget(target, 'defaultsDeep');
+    const budget = new RevisitBudget(MERGE_BUDGET, BUDGET_ERROR);
+    return guardDepth(() => {
+        for (const source of sources) {
+            if (source === null || typeof source !== 'object')
+                continue;
+            const state = {
+                copies: new WeakMap([[source, target]]),
+                pairs: new WeakMap(),
+                budget
+            };
+            fillInto(target, source, state, true);
+        }
+        return target;
+    });
+}

package/dist/object/parsePath.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The path grammar behind `get`, `set`, `has`, `unset`, `pick` and `omit`.
+ */
+/** A dotted string with `[0]` and `['key']` segments, or an array of keys. */
+export type Path = string | readonly PropertyKey[];
+/** Segments that lead to a prototype unless they are own data. */
+export declare const DANGEROUS_KEYS: ReadonlySet<PropertyKey>;
+/**
+ * Write `value` under `key`: a plain assignment for an ordinary string key, so a setter on `target`
+ * runs, and an own data property for a symbol or one of {@link DANGEROUS_KEYS}, so `__proto__`
+ * stays a key and no write reaches a prototype.
+ */
+export declare function writeKey(target: object, key: PropertyKey, value: unknown): void;
+/**
+ * The segments of `path`. A string splits on `.`, on `[0]` index segments and on `['key']` or
+ * `["key"]` segments (with `\\` escaping a quote); an array is taken as its keys, a number segment
+ * as its string.
+ * @throws {TypeError} for a malformed string path or a segment that is not a string, number or
+ * symbol.
+ * @throws {RangeError} for a string path over 2^20 characters or a huge sparse array.
+ */
+export declare function parsePath(path: Path): PropertyKey[];