atomic-fns 1.2.0 → 2.0.0

package/dist/object/parsePath.js

@@ -0,0 +1,111 @@
+/**
+ * The path grammar behind `get`, `set`, `has`, `unset`, `pick` and `omit`.
+ */
+import { assertNotHugeSparse } from '../internal/sparse.js';
+import { truncateForError } from '../internal/truncate.js';
+const MAX_PATH_LENGTH = 2 ** 20;
+/** Segments that lead to a prototype unless they are own data. */
+export const DANGEROUS_KEYS = new Set([
+    '__proto__',
+    'constructor',
+    'prototype'
+]);
+/**
+ * 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 function writeKey(target, key, value) {
+    if (typeof key === 'string' && !DANGEROUS_KEYS.has(key)) {
+        ;
+        target[key] = value;
+    }
+    else {
+        Object.defineProperty(target, key, {
+            value,
+            enumerable: true,
+            writable: true,
+            configurable: true
+        });
+    }
+}
+function malformed(path) {
+    return new TypeError(`malformed path ${truncateForError(path)}`);
+}
+/** Read the bracket segment at `path[i]` (`[0]`, `['key']`, `["key"]`); returns it and the end. */
+function readBracket(path, i) {
+    const quote = path[i + 1];
+    if (quote === "'" || quote === '"') {
+        let key = '';
+        let j = i + 2;
+        while (j < path.length && path[j] !== quote) {
+            if (path[j] === '\\' && j + 1 < path.length)
+                j++;
+            key += path[j++];
+        }
+        if (path[j] !== quote || path[j + 1] !== ']')
+            throw malformed(path);
+        return [key, j + 2];
+    }
+    const close = path.indexOf(']', i);
+    const index = close < 0 ? '' : path.slice(i + 1, close);
+    if (!/^(0|[1-9]\d*)$/.test(index))
+        throw malformed(path);
+    return [index, close + 1];
+}
+/** Split a string path: `a.b[0]['c.d']` is `a`, `b`, `0`, `c.d`. */
+function splitString(path) {
+    const out = [];
+    let i = 0;
+    let needName = path[0] !== '[';
+    for (;;) {
+        if (needName) {
+            let end = i;
+            while (end < path.length && path[end] !== '.' && path[end] !== '[') {
+                if (path[end] === ']')
+                    throw malformed(path);
+                end++;
+            }
+            out.push(path.slice(i, end));
+            i = end;
+        }
+        while (path[i] === '[') {
+            const [segment, end] = readBracket(path, i);
+            out.push(segment);
+            i = end;
+        }
+        if (i >= path.length)
+            return out;
+        if (path[i] !== '.')
+            throw malformed(path);
+        i++;
+        needName = path[i] !== '[';
+    }
+}
+/**
+ * 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 function parsePath(path) {
+    if (typeof path === 'string') {
+        if (path.length > MAX_PATH_LENGTH) {
+            throw new RangeError(`path longer than ${String(MAX_PATH_LENGTH)} characters`);
+        }
+        return path.includes('[') || path.includes(']') ? splitString(path) : path.split('.');
+    }
+    if (!Array.isArray(path)) {
+        throw new TypeError(`a path is a string or an array of keys, got ${typeof path}`);
+    }
+    assertNotHugeSparse(path);
+    return Array.from(path, (segment) => {
+        if (typeof segment === 'string' || typeof segment === 'symbol')
+            return segment;
+        if (typeof segment === 'number')
+            return String(segment);
+        throw new TypeError('path segments must be strings, numbers or symbols');
+    });
+}

package/dist/object/path.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Reading and writing by path: `get`, `set`, `has`, `unset`.
+ */
+import { type Path } from './parsePath.js';
+/**
+ * True when `key` would lead from `base` to a prototype: `__proto__`, `constructor` or
+ * `prototype`, unless it is an own data property of an object that is not a function.
+ */
+export declare function reachesPrototype(base: object, key: PropertyKey): boolean;
+/**
+ * The value at `path` in `obj`, or `defaultValue` when the path is missing or the value is
+ * `undefined`. Every segment reads a property as `obj[key]` does, own or inherited, and a string
+ * reads as its boxed form, so `get('abc', 'length')` is 3. A `__proto__`, `constructor` or
+ * `prototype` segment that is not own data of a non-function object reads as missing, so a path
+ * cannot reach a prototype. An empty path names no property and reads as missing.
+ * @param obj The object to read.
+ * @param path A dotted string with `[0]` and `['key']` segments, or an array of keys.
+ * @param defaultValue Returned when nothing is found.
+ * @returns The value found, or `defaultValue`.
+ * @throws {TypeError} for a malformed path.
+ * @example
+ * ```ts
+ * get({ a: [{ b: 1 }] }, 'a[0].b') // 1
+ * get({ 'a.b': 1 }, "['a.b']") // 1
+ * get({ 'a.b': 1 }, ['a.b']) // 1
+ * get({}, 'a.b', 'none') // 'none'
+ * ```
+ */
+export declare function get(obj: unknown, path: Path, defaultValue?: unknown): unknown;
+/**
+ * True when every segment of `path` is an own property along the way, as lodash's `has` checks.
+ * A `__proto__`, `constructor` or `prototype` segment that is not own data of a non-function
+ * object does not count. The terminal value is not read. An empty path names no property, so it
+ * is never present.
+ * @param obj The object to test.
+ * @param path A dotted string with `[0]` and `['key']` segments, or an array of keys.
+ * @returns Whether the path is present.
+ * @throws {TypeError} for a malformed path.
+ * @example
+ * ```ts
+ * has({ a: { b: undefined } }, 'a.b') // true
+ * has({ a: [1] }, ['a', 0]) // true
+ * has(Object.create({ a: 1 }), 'a') // false: inherited
+ * ```
+ */
+export declare function has(obj: unknown, path: Path): boolean;
+/**
+ * Set the value at `path` in `obj` and return `obj`, as lodash's `set` does. A missing or
+ * primitive step is replaced by a new array when the next segment is an index, and by a plain
+ * object otherwise. The last segment is assigned, so setters run, except a terminal
+ * `constructor` or `prototype` is written as own data. An empty path names no property, so `obj`
+ * is returned unchanged.
+ * @param obj The object to change. A `null`, `undefined` or primitive `obj` is returned as it is.
+ * @param path A dotted string with `[0]` and `['key']` segments, or an array of keys.
+ * @param value The value to store.
+ * @returns `obj`.
+ * @throws {TypeError} when a `__proto__` or non-terminal `constructor` or `prototype` segment is
+ * not own data of a plain object or array; a terminal `constructor` or `prototype` is an own
+ * accessor or non-writable property; or a step is inherited.
+ * @throws {RangeError} for an array index past the end, or a `length` that would grow an array,
+ * so a short path cannot allocate a huge array.
+ * @example
+ * ```ts
+ * set({}, 'a.b', 1) // { a: { b: 1 } }
+ * set({}, ['list', '0'], 'x') // { list: ['x'] }
+ * ```
+ */
+export declare function set<T>(obj: T, path: Path, value: unknown): T;
+/**
+ * Delete the property at `path` in `obj`, as lodash's `unset` does.
+ * @param obj The object to change.
+ * @param path A dotted string with `[0]` and `['key']` segments, or an array of keys.
+ * @returns `true` when the property is gone (or was never there), `false` when it could not be
+ * deleted or the path crosses a `__proto__`, `constructor` or `prototype` segment that is not own
+ * data of a plain object or array, or an inherited step. An empty path names no property, so
+ * nothing is deleted and the result is `true`.
+ * @throws {TypeError} for a malformed path.
+ * @example
+ * ```ts
+ * const obj = { a: { b: 1, c: 2 } }
+ * unset(obj, 'a.b') // true
+ * obj // { a: { c: 2 } }
+ * ```
+ */
+export declare function unset(obj: unknown, path: Path): boolean;

package/dist/object/path.js

@@ -0,0 +1,208 @@
+/**
+ * Reading and writing by path: `get`, `set`, `has`, `unset`.
+ */
+import { isCanonicalArrayIndex } from '../internal/sparse.js';
+import { isPlainObject } from '../is/isPlainObject.js';
+import { DANGEROUS_KEYS, parsePath, writeKey } from './parsePath.js';
+function isContainer(x) {
+    return (typeof x === 'object' && x !== null) || typeof x === 'function';
+}
+function isOwnData(base, key) {
+    const desc = Object.getOwnPropertyDescriptor(base, key);
+    return desc !== undefined && 'value' in desc;
+}
+/**
+ * True when `key` would lead from `base` to a prototype: `__proto__`, `constructor` or
+ * `prototype`, unless it is an own data property of an object that is not a function.
+ */
+export function reachesPrototype(base, key) {
+    return DANGEROUS_KEYS.has(key) && (typeof base === 'function' || !isOwnData(base, key));
+}
+function unsafeWrite(base, key) {
+    if (!DANGEROUS_KEYS.has(key))
+        return false;
+    return !((Array.isArray(base) || isPlainObject(base)) && isOwnData(base, key));
+}
+function refuse(key) {
+    return new TypeError(`refusing to write through "${String(key)}"`);
+}
+/**
+ * The value at `path` in `obj`, or `defaultValue` when the path is missing or the value is
+ * `undefined`. Every segment reads a property as `obj[key]` does, own or inherited, and a string
+ * reads as its boxed form, so `get('abc', 'length')` is 3. A `__proto__`, `constructor` or
+ * `prototype` segment that is not own data of a non-function object reads as missing, so a path
+ * cannot reach a prototype. An empty path names no property and reads as missing.
+ * @param obj The object to read.
+ * @param path A dotted string with `[0]` and `['key']` segments, or an array of keys.
+ * @param defaultValue Returned when nothing is found.
+ * @returns The value found, or `defaultValue`.
+ * @throws {TypeError} for a malformed path.
+ * @example
+ * ```ts
+ * get({ a: [{ b: 1 }] }, 'a[0].b') // 1
+ * get({ 'a.b': 1 }, "['a.b']") // 1
+ * get({ 'a.b': 1 }, ['a.b']) // 1
+ * get({}, 'a.b', 'none') // 'none'
+ * ```
+ */
+export function get(obj, path, defaultValue) {
+    const segments = parsePath(path);
+    if (segments.length === 0)
+        return defaultValue;
+    let cur = obj;
+    for (const key of segments) {
+        if (cur === null || cur === undefined)
+            return defaultValue;
+        const base = Object(cur);
+        if (reachesPrototype(base, key))
+            return defaultValue;
+        cur = base[key];
+    }
+    return cur === undefined ? defaultValue : cur;
+}
+/**
+ * True when every segment of `path` is an own property along the way, as lodash's `has` checks.
+ * A `__proto__`, `constructor` or `prototype` segment that is not own data of a non-function
+ * object does not count. The terminal value is not read. An empty path names no property, so it
+ * is never present.
+ * @param obj The object to test.
+ * @param path A dotted string with `[0]` and `['key']` segments, or an array of keys.
+ * @returns Whether the path is present.
+ * @throws {TypeError} for a malformed path.
+ * @example
+ * ```ts
+ * has({ a: { b: undefined } }, 'a.b') // true
+ * has({ a: [1] }, ['a', 0]) // true
+ * has(Object.create({ a: 1 }), 'a') // false: inherited
+ * ```
+ */
+export function has(obj, path) {
+    const segments = parsePath(path);
+    if (segments.length === 0)
+        return false;
+    let cur = obj;
+    for (let i = 0; i < segments.length; i++) {
+        const key = segments[i];
+        if (cur === null || cur === undefined)
+            return false;
+        const base = Object(cur);
+        if (reachesPrototype(base, key) || !Object.hasOwn(base, key))
+            return false;
+        if (i < segments.length - 1)
+            cur = base[key];
+    }
+    return true;
+}
+function growsArray(target, key, value) {
+    if (key === 'length')
+        return Object(value) === value || Number(value) > target.length;
+    return typeof key === 'string' && isCanonicalArrayIndex(key) && Number(key) > target.length;
+}
+function write(target, key, value, terminal) {
+    if (terminal && (key === 'constructor' || key === 'prototype')) {
+        const desc = Object.getOwnPropertyDescriptor(target, key);
+        if (desc && (!('value' in desc) || !desc.writable))
+            throw refuse(key);
+        if (desc === undefined) {
+            writeKey(target, key, value);
+            return;
+        }
+    }
+    else if (unsafeWrite(target, key))
+        throw refuse(key);
+    if (Array.isArray(target) && growsArray(target, key, value)) {
+        throw new RangeError(key === 'length'
+            ? 'array length can only shrink, to a primitive number'
+            : `array index ${String(key)} is past the end`);
+    }
+    ;
+    target[key] = value;
+}
+/**
+ * Set the value at `path` in `obj` and return `obj`, as lodash's `set` does. A missing or
+ * primitive step is replaced by a new array when the next segment is an index, and by a plain
+ * object otherwise. The last segment is assigned, so setters run, except a terminal
+ * `constructor` or `prototype` is written as own data. An empty path names no property, so `obj`
+ * is returned unchanged.
+ * @param obj The object to change. A `null`, `undefined` or primitive `obj` is returned as it is.
+ * @param path A dotted string with `[0]` and `['key']` segments, or an array of keys.
+ * @param value The value to store.
+ * @returns `obj`.
+ * @throws {TypeError} when a `__proto__` or non-terminal `constructor` or `prototype` segment is
+ * not own data of a plain object or array; a terminal `constructor` or `prototype` is an own
+ * accessor or non-writable property; or a step is inherited.
+ * @throws {RangeError} for an array index past the end, or a `length` that would grow an array,
+ * so a short path cannot allocate a huge array.
+ * @example
+ * ```ts
+ * set({}, 'a.b', 1) // { a: { b: 1 } }
+ * set({}, ['list', '0'], 'x') // { list: ['x'] }
+ * ```
+ */
+export function set(obj, path, value) {
+    const segments = parsePath(path);
+    if (!isContainer(obj) || segments.length === 0)
+        return obj;
+    const last = segments.length - 1;
+    let cur = obj;
+    let depth = 0;
+    for (; depth < last; depth++) {
+        const key = segments[depth];
+        if (unsafeWrite(cur, key))
+            throw refuse(key);
+        if (!Object.hasOwn(cur, key) && key in cur) {
+            throw new TypeError(`refusing to write through inherited "${String(key)}"`);
+        }
+        const next = cur[key];
+        if (!isContainer(next))
+            break;
+        cur = next;
+    }
+    let tail = value;
+    for (let i = last; i > depth; i--) {
+        const key = segments[i];
+        const fresh = typeof key === 'string' && isCanonicalArrayIndex(key) ? [] : {};
+        write(fresh, key, tail, i === last);
+        tail = fresh;
+    }
+    write(cur, segments[depth], tail, depth === last);
+    return obj;
+}
+/**
+ * Delete the property at `path` in `obj`, as lodash's `unset` does.
+ * @param obj The object to change.
+ * @param path A dotted string with `[0]` and `['key']` segments, or an array of keys.
+ * @returns `true` when the property is gone (or was never there), `false` when it could not be
+ * deleted or the path crosses a `__proto__`, `constructor` or `prototype` segment that is not own
+ * data of a plain object or array, or an inherited step. An empty path names no property, so
+ * nothing is deleted and the result is `true`.
+ * @throws {TypeError} for a malformed path.
+ * @example
+ * ```ts
+ * const obj = { a: { b: 1, c: 2 } }
+ * unset(obj, 'a.b') // true
+ * obj // { a: { c: 2 } }
+ * ```
+ */
+export function unset(obj, path) {
+    const segments = parsePath(path);
+    if (segments.length === 0)
+        return true;
+    let cur = obj;
+    for (let i = 0; i < segments.length - 1; i++) {
+        if (!isContainer(cur))
+            return true;
+        const key = segments[i];
+        if (unsafeWrite(cur, key))
+            return false;
+        if (!Object.hasOwn(cur, key))
+            return !(key in cur);
+        cur = cur[key];
+    }
+    if (!isContainer(cur))
+        return true;
+    const key = segments[segments.length - 1];
+    if (unsafeWrite(cur, key))
+        return false;
+    return Reflect.deleteProperty(cur, key);
+}

package/dist/object/pick.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Copies with some keys: `pick`, `omit`, `pickBy`, `omitBy`.
+ */
+import { type Path } from './parsePath.js';
+/** One path or a list of them; in a list, each entry is a path or a single key. */
+export type Paths = string | readonly (Path | PropertyKey)[];
+/**
+ * Keys for the precise {@link pick}/{@link omit} overloads, excluding arrays, index
+ * signatures, and string keys containing path syntax (`.`, `[` or `]`).
+ */
+export type PlainKey<T> = T extends readonly unknown[] ? never : string extends keyof T ? never : number extends keyof T ? never : symbol extends keyof T ? never : Exclude<keyof T, `${string}${'.' | '[' | ']'}${string}`>;
+/**
+ * What {@link pickBy} and {@link omitBy} return: a plain object, so an array's elements come back
+ * under their index keys.
+ */
+export type PickedBy<T> = T extends readonly unknown[] ? Record<string, T[number]> : Partial<T>;
+/**
+ * A new object with the values at `paths` in `obj`. Each path is read as {@link has} reads it:
+ * own properties only, never through a prototype-reaching segment, and a path that is missing is
+ * left out. The containers on the way are new, arrays where the source has an array and the next
+ * segment is an index; the values at the end of each path are the source's own, not copies.
+ * Tuples of individual plain keys have precise result types; union keys and index signatures
+ * keep partial results.
+ * @param obj The object to read.
+ * @param paths A path, or a list of paths or keys.
+ * @returns A new object.
+ * @throws {TypeError} for a malformed path.
+ * @example
+ * ```ts
+ * pick({ a: 1, b: 2, c: 3 }, ['a', 'c']) // { a: 1, c: 3 }
+ * pick({ a: { b: 1, c: 2 } }, 'a.b') // { a: { b: 1 } }
+ * pick({ list: [{ id: 1, x: 2 }] }, ['list[0].id']) // { list: [{ id: 1 }] }
+ * ```
+ */
+export declare function pick<T extends object, const P extends readonly PlainKey<T>[]>(obj: T & (T extends readonly unknown[] ? never : string extends keyof T ? never : number extends keyof T ? never : symbol extends keyof T ? never : unknown), paths: P): number extends P['length'] ? Partial<Pick<T, P[number]>> : true extends {
+    [I in keyof P]: P[I][] extends {
+        [K in P[I]]: K[];
+    }[P[I]] ? false : true;
+}[number] ? Partial<T> : Pick<T, P[number]>;
+/** {@link pick} with paths or keys that cannot determine an exact set of properties. */
+export declare function pick<T>(obj: T, paths: Paths): Partial<T>;
+/**
+ * A copy of `obj` without the values at `paths`. Copies own enumerable string and symbol keys
+ * of an object; the elements and own enumerable symbol keys of an array. The plain objects and
+ * arrays along each path are copied too, so `obj` is never changed; every other value is kept by
+ * reference. A null-prototype object copies to a null-prototype object.
+ * Tuples of individual plain keys have precise result types; union keys and index signatures
+ * keep partial results.
+ * @param obj A plain object or array.
+ * @param paths A path, or a list of paths or keys.
+ * @returns A new plain object or array.
+ * @throws {TypeError} when `obj`, or a value a path walks into, is not a plain object or array, or
+ * has its own `toJSON` function or accessor: copying a class instance into a plain object would
+ * lose its prototype, and a copy would lose or misbind any `toJSON` that hides fields.
+ * @throws {RangeError} for a path more than 1000 levels deep.
+ * @example
+ * ```ts
+ * omit({ a: 1, b: 2, c: 3 }, ['a', 'c']) // { b: 2 }
+ * omit({ user: { name: 'a', password: 'p' } }, 'user.password') // { user: { name: 'a' } }
+ * ```
+ */
+export declare function omit<T extends object, const P extends readonly PlainKey<T>[]>(obj: T & (T extends readonly unknown[] ? never : string extends keyof T ? never : number extends keyof T ? never : symbol extends keyof T ? never : unknown), paths: P): number extends P['length'] ? Partial<Omit<T, P[number]>> : true extends {
+    [I in keyof P]: P[I][] extends {
+        [K in P[I]]: K[];
+    }[P[I]] ? false : true;
+}[number] ? Partial<T> : Omit<T, P[number]>;
+/** {@link omit} with paths or keys that cannot determine an exact set of properties. */
+export declare function omit<T extends object>(obj: T | null | undefined, paths: Paths): Partial<T>;
+/**
+ * A new plain object with the own enumerable string keys of `obj` for which `predicate` is truthy.
+ * @param obj The object to read.
+ * @param predicate Called with `(value, key, obj)`.
+ * @returns A new object.
+ * @example
+ * ```ts
+ * pickBy({ a: 1, b: '2', c: 3 }, (value) => typeof value === 'number') // { a: 1, c: 3 }
+ * ```
+ */
+export declare function pickBy<T extends object>(obj: T | null | undefined, predicate: (value: T[keyof T], key: keyof T & string, obj: T) => unknown): PickedBy<T>;
+/**
+ * A new plain object with the own enumerable string keys of `obj` for which `predicate` is falsy:
+ * the complement of {@link pickBy}.
+ * @param obj The object to read.
+ * @param predicate Called with `(value, key, obj)`.
+ * @returns A new object.
+ * @example
+ * ```ts
+ * omitBy({ a: 1, b: undefined }, (value) => value === undefined) // { a: 1 }
+ * ```
+ */
+export declare function omitBy<T extends object>(obj: T | null | undefined, predicate: (value: T[keyof T], key: keyof T & string, obj: T) => unknown): PickedBy<T>;

package/dist/object/pick.js

@@ -0,0 +1,180 @@
+/**
+ * Copies with some keys: `pick`, `omit`, `pickBy`, `omitBy`.
+ */
+import { isPlainObject } from '../is/isPlainObject.js';
+import { enumerableKeys, isEnumerable } from '../internal/keys.js';
+import { assertNotHugeSparse, isCanonicalArrayIndex, walkArrayIndices } from '../internal/sparse.js';
+import { enterDepth, exitDepth, guardDepth } from '../internal/walk.js';
+import { parsePath, writeKey } from './parsePath.js';
+import { reachesPrototype } from './path.js';
+function toPathList(paths) {
+    if (typeof paths === 'string')
+        return [parsePath(paths)];
+    if (!Array.isArray(paths))
+        throw new TypeError(`expected a path or a list of paths, got ${typeof paths}`);
+    assertNotHugeSparse(paths);
+    return Array.from(paths, (path) => typeof path === 'string' || Array.isArray(path)
+        ? parsePath(path)
+        : parsePath([path]));
+}
+function nodeAt(root, parts) {
+    let node = root;
+    for (const part of parts) {
+        node.kids ??= new Map();
+        let next = node.kids.get(part);
+        if (next === undefined) {
+            next = {};
+            node.kids.set(part, next);
+        }
+        node = next;
+    }
+    return node;
+}
+export function pick(obj, paths) {
+    const list = toPathList(paths);
+    const root = { out: {} };
+    pathLoop: for (const parts of list) {
+        if (parts.length === 0)
+            continue;
+        let src = obj;
+        let node = root;
+        /** `nodes[i]` is the trie node for `parts[i]`, `sources[i]` the container it is read from. */
+        const nodes = [];
+        const sources = [];
+        for (const key of parts) {
+            sources.push(src);
+            node = nodeAt(node, [key]);
+            nodes.push(node);
+            if (node.leaf || src === null || src === undefined)
+                continue pathLoop;
+            const base = Object(src);
+            if (reachesPrototype(base, key) || !Object.hasOwn(base, key))
+                continue pathLoop;
+            src = base[key];
+        }
+        node.leaf = true;
+        let parent = root;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const child = nodes[i];
+            if (child.out === undefined) {
+                const next = parts[i + 1];
+                const index = typeof next === 'string' && isCanonicalArrayIndex(next);
+                child.out = Array.isArray(sources[i + 1]) && index ? [] : {};
+                writeKey(parent.out, parts[i], child.out);
+            }
+            parent = child;
+        }
+        writeKey(parent.out, parts[parts.length - 1], src);
+    }
+    return root.out;
+}
+/** An array whose prototype is `Array.prototype` of this realm or of another one: not a subclass. */
+function isUnsubclassedArray(x) {
+    if (!Array.isArray(x))
+        return false;
+    const proto = Object.getPrototypeOf(x);
+    return (proto === Array.prototype ||
+        (Array.isArray(proto) && isPlainObject(Object.getPrototypeOf(proto))));
+}
+/** An own `toJSON` function or accessor, which a copy would lose or keep bound to the source. */
+function hasOwnToJSON(x) {
+    const desc = Object.getOwnPropertyDescriptor(x, 'toJSON');
+    if (desc === undefined)
+        return false;
+    return desc.get !== undefined || desc.set !== undefined || typeof desc.value === 'function';
+}
+function isOmitContainer(x) {
+    return (isUnsubclassedArray(x) || isPlainObject(x)) && !hasOwnToJSON(x);
+}
+function omitIn(value, trie) {
+    enterDepth();
+    try {
+        let out;
+        let keys;
+        if (Array.isArray(value)) {
+            const array = [];
+            array.length = value.length;
+            walkArrayIndices(value, (event) => {
+                if (event.kind !== 'index')
+                    return;
+                const child = trie.kids?.get(String(event.index));
+                if (child?.leaf)
+                    return;
+                const element = value[event.index];
+                array[event.index] = child?.kids ? omitStep(element, child) : element;
+            });
+            out = array;
+            keys = Object.getOwnPropertySymbols(value).filter((key) => isEnumerable(value, key));
+        }
+        else {
+            out = Object.getPrototypeOf(value) === null ? Object.create(null) : {};
+            keys = enumerableKeys(value);
+        }
+        const record = value;
+        for (const key of keys) {
+            const child = trie.kids?.get(key);
+            if (child?.leaf)
+                continue;
+            writeKey(out, key, child?.kids ? omitStep(record[key], child) : record[key]);
+        }
+        return out;
+    }
+    finally {
+        exitDepth();
+    }
+}
+function omitStep(value, trie) {
+    if (value === null || (typeof value !== 'object' && typeof value !== 'function'))
+        return value;
+    if (!isOmitContainer(value))
+        throw new TypeError('omit cannot copy a non-plain object');
+    return omitIn(value, trie);
+}
+export function omit(obj, paths) {
+    const list = toPathList(paths);
+    if (obj === null || obj === undefined)
+        return {};
+    if (!isOmitContainer(obj))
+        throw new TypeError('omit takes a plain object or array');
+    const trie = {};
+    for (const parts of list)
+        if (parts.length > 0)
+            nodeAt(trie, parts).leaf = true;
+    return guardDepth(() => omitIn(obj, trie));
+}
+/**
+ * A new plain object with the own enumerable string keys of `obj` for which `predicate` is truthy.
+ * @param obj The object to read.
+ * @param predicate Called with `(value, key, obj)`.
+ * @returns A new object.
+ * @example
+ * ```ts
+ * pickBy({ a: 1, b: '2', c: 3 }, (value) => typeof value === 'number') // { a: 1, c: 3 }
+ * ```
+ */
+export function pickBy(obj, predicate) {
+    const out = {};
+    if (obj === null || obj === undefined)
+        return out;
+    const record = obj;
+    for (const key of Object.keys(record)) {
+        const value = record[key];
+        if (predicate(value, key, obj))
+            writeKey(out, key, value);
+    }
+    return out;
+}
+/**
+ * A new plain object with the own enumerable string keys of `obj` for which `predicate` is falsy:
+ * the complement of {@link pickBy}.
+ * @param obj The object to read.
+ * @param predicate Called with `(value, key, obj)`.
+ * @returns A new object.
+ * @example
+ * ```ts
+ * omitBy({ a: 1, b: undefined }, (value) => value === undefined) // { a: 1 }
+ * ```
+ */
+export function omitBy(obj, predicate) {
+    return pickBy(obj, (value, key, all) => !predicate(value, key, all));
+}