@stackframe/stack-shared 2.8.8 → 2.8.11

package/dist/utils/objects.js

@@ -1,378 +1,228 @@
-import { StackAssertionError } from "./errors";
-import { identity } from "./functions";
-export function isNotNull(value) {
-    return value !== null && value !== undefined;
-}
-import.meta.vitest?.test("isNotNull", ({ expect }) => {
-    expect(isNotNull(null)).toBe(false);
-    expect(isNotNull(undefined)).toBe(false);
-    expect(isNotNull(0)).toBe(true);
-    expect(isNotNull("")).toBe(true);
-    expect(isNotNull(false)).toBe(true);
-    expect(isNotNull({})).toBe(true);
-    expect(isNotNull([])).toBe(true);
-});
-/**
- * Assumes both objects are primitives, arrays, or non-function plain objects, and compares them deeply.
- *
- * Note that since they are assumed to be plain objects, this function does not compare prototypes.
- */
-export function deepPlainEquals(obj1, obj2, options = {}) {
-    if (typeof obj1 !== typeof obj2)
-        return false;
-    if (obj1 === obj2)
-        return true;
-    switch (typeof obj1) {
-        case 'object': {
-            if (!obj1 || !obj2)
-                return false;
-            if (Array.isArray(obj1) || Array.isArray(obj2)) {
-                if (!Array.isArray(obj1) || !Array.isArray(obj2))
-                    return false;
-                if (obj1.length !== obj2.length)
-                    return false;
-                return obj1.every((v, i) => deepPlainEquals(v, obj2[i], options));
-            }
-            const entries1 = Object.entries(obj1).filter(([k, v]) => !options.ignoreUndefinedValues || v !== undefined);
-            const entries2 = Object.entries(obj2).filter(([k, v]) => !options.ignoreUndefinedValues || v !== undefined);
-            if (entries1.length !== entries2.length)
-                return false;
-            return entries1.every(([k, v1]) => {
-                const e2 = entries2.find(([k2]) => k === k2);
-                if (!e2)
-                    return false;
-                return deepPlainEquals(v1, e2[1], options);
-            });
-        }
-        case 'undefined':
-        case 'string':
-        case 'number':
-        case 'boolean':
-        case 'bigint':
-        case 'symbol':
-        case 'function': {
-            return false;
-        }
-        default: {
-            throw new Error("Unexpected typeof " + typeof obj1);
-        }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/objects.tsx
+var objects_exports = {};
+__export(objects_exports, {
+  deepFilterUndefined: () => deepFilterUndefined,
+  deepMerge: () => deepMerge,
+  deepPlainClone: () => deepPlainClone,
+  deepPlainEquals: () => deepPlainEquals,
+  deepSortKeys: () => deepSortKeys,
+  deleteKey: () => deleteKey,
+  filterUndefined: () => filterUndefined,
+  filterUndefinedOrNull: () => filterUndefinedOrNull,
+  get: () => get,
+  getOrUndefined: () => getOrUndefined,
+  has: () => has,
+  hasAndNotUndefined: () => hasAndNotUndefined,
+  isCloneable: () => isCloneable,
+  isNotNull: () => isNotNull,
+  isObjectLike: () => isObjectLike,
+  mapValues: () => mapValues,
+  omit: () => omit,
+  pick: () => pick,
+  set: () => set,
+  shallowClone: () => shallowClone,
+  sortKeys: () => sortKeys,
+  split: () => split,
+  typedAssign: () => typedAssign,
+  typedEntries: () => typedEntries,
+  typedFromEntries: () => typedFromEntries,
+  typedKeys: () => typedKeys,
+  typedValues: () => typedValues
+});
+module.exports = __toCommonJS(objects_exports);
+var import_errors = require("./errors");
+var import_functions = require("./functions");
+var import_strings = require("./strings");
+function isNotNull(value) {
+  return value !== null && value !== void 0;
+}
+function deepPlainEquals(obj1, obj2, options = {}) {
+  if (typeof obj1 !== typeof obj2) return false;
+  if (obj1 === obj2) return true;
+  switch (typeof obj1) {
+    case "object": {
+      if (!obj1 || !obj2) return false;
+      if (Array.isArray(obj1) || Array.isArray(obj2)) {
+        if (!Array.isArray(obj1) || !Array.isArray(obj2)) return false;
+        if (obj1.length !== obj2.length) return false;
+        return obj1.every((v, i) => deepPlainEquals(v, obj2[i], options));
+      }
+      const entries1 = Object.entries(obj1).filter(([k, v]) => !options.ignoreUndefinedValues || v !== void 0);
+      const entries2 = Object.entries(obj2).filter(([k, v]) => !options.ignoreUndefinedValues || v !== void 0);
+      if (entries1.length !== entries2.length) return false;
+      return entries1.every(([k, v1]) => {
+        const e2 = entries2.find(([k2]) => k === k2);
+        if (!e2) return false;
+        return deepPlainEquals(v1, e2[1], options);
+      });
     }
-}
-import.meta.vitest?.test("deepPlainEquals", ({ expect }) => {
-    // Simple values
-    expect(deepPlainEquals(1, 1)).toBe(true);
-    expect(deepPlainEquals("test", "test")).toBe(true);
-    expect(deepPlainEquals(1, 2)).toBe(false);
-    expect(deepPlainEquals("test", "other")).toBe(false);
-    // Arrays
-    expect(deepPlainEquals([1, 2, 3], [1, 2, 3])).toBe(true);
-    expect(deepPlainEquals([1, 2, 3], [1, 2, 4])).toBe(false);
-    expect(deepPlainEquals([1, 2, 3], [1, 2])).toBe(false);
-    // Objects
-    expect(deepPlainEquals({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true);
-    expect(deepPlainEquals({ a: 1, b: 2 }, { a: 1, b: 3 })).toBe(false);
-    expect(deepPlainEquals({ a: 1, b: 2 }, { a: 1 })).toBe(false);
-    // Nested structures
-    expect(deepPlainEquals({ a: 1, b: [1, 2, { c: 3 }] }, { a: 1, b: [1, 2, { c: 3 }] })).toBe(true);
-    expect(deepPlainEquals({ a: 1, b: [1, 2, { c: 3 }] }, { a: 1, b: [1, 2, { c: 4 }] })).toBe(false);
-    // With options
-    expect(deepPlainEquals({ a: 1, b: undefined }, { a: 1 }, { ignoreUndefinedValues: true })).toBe(true);
-    expect(deepPlainEquals({ a: 1, b: undefined }, { a: 1 })).toBe(false);
-});
-export function isCloneable(obj) {
-    return typeof obj !== 'symbol' && typeof obj !== 'function';
-}
-export function shallowClone(obj) {
-    if (!isCloneable(obj))
-        throw new StackAssertionError("shallowClone does not support symbols or functions", { obj });
-    if (Array.isArray(obj))
-        return obj.map(identity);
-    return { ...obj };
-}
-import.meta.vitest?.test("shallowClone", ({ expect }) => {
-    expect(shallowClone({ a: 1, b: 2 })).toEqual({ a: 1, b: 2 });
-    expect(shallowClone([1, 2, 3])).toEqual([1, 2, 3]);
-    expect(() => shallowClone(() => { })).toThrow();
-});
-export function deepPlainClone(obj) {
-    if (typeof obj === 'function')
-        throw new StackAssertionError("deepPlainClone does not support functions");
-    if (typeof obj === 'symbol')
-        throw new StackAssertionError("deepPlainClone does not support symbols");
-    if (typeof obj !== 'object' || !obj)
-        return obj;
-    if (Array.isArray(obj))
-        return obj.map(deepPlainClone);
-    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, deepPlainClone(v)]));
-}
-import.meta.vitest?.test("deepPlainClone", ({ expect }) => {
-    // Primitive values
-    expect(deepPlainClone(1)).toBe(1);
-    expect(deepPlainClone("test")).toBe("test");
-    expect(deepPlainClone(null)).toBe(null);
-    expect(deepPlainClone(undefined)).toBe(undefined);
-    // Arrays
-    const arr = [1, 2, 3];
-    const clonedArr = deepPlainClone(arr);
-    expect(clonedArr).toEqual(arr);
-    expect(clonedArr).not.toBe(arr); // Different reference
-    // Objects
-    const obj = { a: 1, b: 2 };
-    const clonedObj = deepPlainClone(obj);
-    expect(clonedObj).toEqual(obj);
-    expect(clonedObj).not.toBe(obj); // Different reference
-    // Nested structures
-    const nested = { a: 1, b: [1, 2, { c: 3 }] };
-    const clonedNested = deepPlainClone(nested);
-    expect(clonedNested).toEqual(nested);
-    expect(clonedNested).not.toBe(nested); // Different reference
-    expect(clonedNested.b).not.toBe(nested.b); // Different reference for nested array
-    expect(clonedNested.b[2]).not.toBe(nested.b[2]); // Different reference for nested object
-    // Error cases
-    expect(() => deepPlainClone(() => { })).toThrow();
-    expect(() => deepPlainClone(Symbol())).toThrow();
-});
-export function deepMerge(baseObj, mergeObj) {
-    if ([baseObj, mergeObj, ...Object.values(baseObj), ...Object.values(mergeObj)].some(o => !isCloneable(o)))
-        throw new StackAssertionError("deepMerge does not support functions or symbols", { baseObj, mergeObj });
-    const res = shallowClone(baseObj);
-    for (const [key, mergeValue] of Object.entries(mergeObj)) {
-        if (has(res, key)) {
-            const baseValue = get(res, key);
-            if (isObjectLike(baseValue) && isObjectLike(mergeValue)) {
-                set(res, key, deepMerge(baseValue, mergeValue));
-                continue;
-            }
-        }
-        set(res, key, mergeValue);
+    case "undefined":
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "symbol":
+    case "function": {
+      return false;
     }
-    return res;
-}
-import.meta.vitest?.test("deepMerge", ({ expect }) => {
-    // Test merging flat objects
-    expect(deepMerge({ a: 1 }, { b: 2 })).toEqual({ a: 1, b: 2 });
-    expect(deepMerge({ a: 1 }, { a: 2 })).toEqual({ a: 2 });
-    expect(deepMerge({ a: 1, b: 2 }, { b: 3, c: 4 })).toEqual({ a: 1, b: 3, c: 4 });
-    // Test with nested objects
-    expect(deepMerge({ a: { x: 1, y: 2 }, b: 3 }, { a: { y: 3, z: 4 }, c: 5 })).toEqual({ a: { x: 1, y: 3, z: 4 }, b: 3, c: 5 });
-    // Test with arrays
-    expect(deepMerge({ a: [1, 2], b: 3 }, { a: [3, 4], c: 5 })).toEqual({ a: [3, 4], b: 3, c: 5 });
-    // Test with null values
-    expect(deepMerge({ a: { x: 1 }, b: null }, { a: { y: 2 }, b: { z: 3 } })).toEqual({ a: { x: 1, y: 2 }, b: { z: 3 } });
-    // Test with undefined values
-    expect(deepMerge({ a: 1, b: undefined }, { b: 2, c: 3 })).toEqual({ a: 1, b: 2, c: 3 });
-    // Test deeply nested structures
-    expect(deepMerge({
-        a: {
-            x: { deep: 1 },
-            y: [1, 2]
-        },
-        b: 2
-    }, {
-        a: {
-            x: { deeper: 3 },
-            y: [3, 4]
-        },
-        c: 3
-    })).toEqual({
-        a: {
-            x: { deep: 1, deeper: 3 },
-            y: [3, 4]
-        },
-        b: 2,
-        c: 3
-    });
-    // Test with empty objects
-    expect(deepMerge({}, { a: 1 })).toEqual({ a: 1 });
-    expect(deepMerge({ a: 1 }, {})).toEqual({ a: 1 });
-    expect(deepMerge({}, {})).toEqual({});
-    // Test that original objects are not modified
-    const base = { a: { x: 1 }, b: 2 };
-    const merge = { a: { y: 2 }, c: 3 };
-    const baseClone = deepPlainClone(base);
-    const mergeClone = deepPlainClone(merge);
-    const result = deepMerge(base, merge);
-    expect(base).toEqual(baseClone);
-    expect(merge).toEqual(mergeClone);
-    expect(result).toEqual({ a: { x: 1, y: 2 }, b: 2, c: 3 });
-    // Test error cases
-    expect(() => deepMerge({ a: () => { } }, { b: 2 })).toThrow();
-    expect(() => deepMerge({ a: 1 }, { b: () => { } })).toThrow();
-    expect(() => deepMerge({ a: Symbol() }, { b: 2 })).toThrow();
-    expect(() => deepMerge({ a: 1 }, { b: Symbol() })).toThrow();
-});
-export function typedEntries(obj) {
-    return Object.entries(obj);
-}
-import.meta.vitest?.test("typedEntries", ({ expect }) => {
-    expect(typedEntries({})).toEqual([]);
-    expect(typedEntries({ a: 1, b: 2 })).toEqual([["a", 1], ["b", 2]]);
-    expect(typedEntries({ a: "hello", b: true, c: null })).toEqual([["a", "hello"], ["b", true], ["c", null]]);
-    // Test with object containing methods
-    const objWithMethod = { a: 1, b: () => "test" };
-    const entries = typedEntries(objWithMethod);
-    expect(entries.length).toBe(2);
-    expect(entries[0][0]).toBe("a");
-    expect(entries[0][1]).toBe(1);
-    expect(entries[1][0]).toBe("b");
-    expect(typeof entries[1][1]).toBe("function");
-});
-export function typedFromEntries(entries) {
-    return Object.fromEntries(entries);
-}
-import.meta.vitest?.test("typedFromEntries", ({ expect }) => {
-    expect(typedFromEntries([])).toEqual({});
-    expect(typedFromEntries([["a", 1], ["b", 2]])).toEqual({ a: 1, b: 2 });
-    // Test with mixed types (using type assertion)
-    const mixedEntries = [["a", "hello"], ["b", true], ["c", null]];
-    const mixedObj = typedFromEntries(mixedEntries);
-    expect(mixedObj).toEqual({ a: "hello", b: true, c: null });
-    // Test with function values
-    const fn = () => "test";
-    const fnEntries = [["a", 1], ["b", fn]];
-    const obj = typedFromEntries(fnEntries);
-    expect(obj.a).toBe(1);
-    expect(typeof obj.b).toBe("function");
-    // Type assertion needed for the function call
-    expect(obj.b()).toBe("test");
-});
-export function typedKeys(obj) {
-    return Object.keys(obj);
-}
-import.meta.vitest?.test("typedKeys", ({ expect }) => {
-    expect(typedKeys({})).toEqual([]);
-    expect(typedKeys({ a: 1, b: 2 })).toEqual(["a", "b"]);
-    expect(typedKeys({ a: "hello", b: true, c: null })).toEqual(["a", "b", "c"]);
-    // Test with object containing methods
-    const objWithMethod = { a: 1, b: () => "test" };
-    expect(typedKeys(objWithMethod)).toEqual(["a", "b"]);
-});
-export function typedValues(obj) {
-    return Object.values(obj);
-}
-import.meta.vitest?.test("typedValues", ({ expect }) => {
-    expect(typedValues({})).toEqual([]);
-    expect(typedValues({ a: 1, b: 2 })).toEqual([1, 2]);
-    const mixedObj = { a: "hello", b: true, c: null };
-    expect(typedValues(mixedObj)).toEqual(["hello", true, null]);
-    const fn = () => "test";
-    const objWithMethod = { a: 1, b: fn };
-    const values = typedValues(objWithMethod);
-    expect(values.length).toBe(2);
-    expect(values[0]).toBe(1);
-    expect(typeof values[1]).toBe("function");
-    // Need to cast to the correct type
-    const fnValue = values[1];
-    expect(fnValue()).toBe("test");
-});
-export function typedAssign(target, source) {
-    return Object.assign(target, source);
-}
-import.meta.vitest?.test("typedAssign", ({ expect }) => {
-    // Test with empty objects
-    const emptyTarget = {};
-    const emptyResult = typedAssign(emptyTarget, { a: 1 });
-    expect(emptyResult).toEqual({ a: 1 });
-    expect(emptyResult).toBe(emptyTarget); // Same reference
-    // Test with non-empty target
-    const target = { a: 1, b: 2 };
-    const result = typedAssign(target, { c: 3, d: 4 });
-    expect(result).toEqual({ a: 1, b: 2, c: 3, d: 4 });
-    expect(result).toBe(target); // Same reference
-    // Test with overlapping properties
-    const targetWithOverlap = { a: 1, b: 2 };
-    const resultWithOverlap = typedAssign(targetWithOverlap, { b: 3, c: 4 });
-    expect(resultWithOverlap).toEqual({ a: 1, b: 3, c: 4 });
-    expect(resultWithOverlap).toBe(targetWithOverlap); // Same reference
-});
-/**
- * Returns a new object with all undefined values removed. Useful when spreading optional parameters on an object, as
- * TypeScript's `Partial<XYZ>` type allows `undefined` values.
- */
-export function filterUndefined(obj) {
-    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
-}
-import.meta.vitest?.test("filterUndefined", ({ expect }) => {
-    expect(filterUndefined({})).toEqual({});
-    expect(filterUndefined({ a: 1, b: 2 })).toEqual({ a: 1, b: 2 });
-    expect(filterUndefined({ a: 1, b: undefined })).toEqual({ a: 1 });
-    expect(filterUndefined({ a: undefined, b: undefined })).toEqual({});
-    expect(filterUndefined({ a: null, b: undefined })).toEqual({ a: null });
-    expect(filterUndefined({ a: 0, b: "", c: false, d: undefined })).toEqual({ a: 0, b: "", c: false });
-});
-/**
- * Returns a new object with all undefined and null values removed. Useful when spreading optional parameters on an object, as
- * TypeScript's `Partial<XYZ>` type allows `undefined` values.
- */
-export function filterUndefinedOrNull(obj) {
-    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined && v !== null));
-}
-import.meta.vitest?.test("filterUndefinedOrNull", ({ expect }) => {
-    expect(filterUndefinedOrNull({})).toEqual({});
-    expect(filterUndefinedOrNull({ a: 1, b: 2 })).toEqual({ a: 1, b: 2 });
-});
-export function deepFilterUndefined(obj) {
-    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined).map(([k, v]) => [k, isObjectLike(v) ? deepFilterUndefined(v) : v]));
-}
-import.meta.vitest?.test("deepFilterUndefined", ({ expect }) => {
-    expect(deepFilterUndefined({ a: 1, b: undefined })).toEqual({ a: 1 });
-});
-export function pick(obj, keys) {
-    return Object.fromEntries(Object.entries(obj).filter(([k]) => keys.includes(k)));
-}
-import.meta.vitest?.test("pick", ({ expect }) => {
-    const obj = { a: 1, b: 2, c: 3, d: 4 };
-    expect(pick(obj, ["a", "c"])).toEqual({ a: 1, c: 3 });
-    expect(pick(obj, [])).toEqual({});
-    expect(pick(obj, ["a", "e"])).toEqual({ a: 1 });
-    // Use type assertion for empty object to avoid TypeScript error
-    expect(pick({}, ["a"])).toEqual({});
-});
-export function omit(obj, keys) {
-    return Object.fromEntries(Object.entries(obj).filter(([k]) => !keys.includes(k)));
-}
-import.meta.vitest?.test("omit", ({ expect }) => {
-    const obj = { a: 1, b: 2, c: 3, d: 4 };
-    expect(omit(obj, ["a", "c"])).toEqual({ b: 2, d: 4 });
-    expect(omit(obj, [])).toEqual(obj);
-    expect(omit(obj, ["a", "e"])).toEqual({ b: 2, c: 3, d: 4 });
-    // Use type assertion for empty object to avoid TypeScript error
-    expect(omit({}, ["a"])).toEqual({});
-});
-export function split(obj, keys) {
-    return [pick(obj, keys), omit(obj, keys)];
-}
-import.meta.vitest?.test("split", ({ expect }) => {
-    const obj = { a: 1, b: 2, c: 3, d: 4 };
-    expect(split(obj, ["a", "c"])).toEqual([{ a: 1, c: 3 }, { b: 2, d: 4 }]);
-    expect(split(obj, [])).toEqual([{}, obj]);
-    expect(split(obj, ["a", "e"])).toEqual([{ a: 1 }, { b: 2, c: 3, d: 4 }]);
-    // Use type assertion for empty object to avoid TypeScript error
-    expect(split({}, ["a"])).toEqual([{}, {}]);
-});
-export function set(obj, key, value) {
-    Object.defineProperty(obj, key, { value, writable: true, configurable: true, enumerable: true });
-}
-export function get(obj, key) {
-    const descriptor = Object.getOwnPropertyDescriptor(obj, key);
-    if (!descriptor)
-        throw new StackAssertionError(`get: key ${String(key)} does not exist`, { obj, key });
-    return descriptor.value;
-}
-export function has(obj, key) {
-    return Object.prototype.hasOwnProperty.call(obj, key);
-}
-export function hasAndNotUndefined(obj, key) {
-    return has(obj, key) && get(obj, key) !== undefined;
-}
-export function deleteKey(obj, key) {
-    if (has(obj, key)) {
-        Reflect.deleteProperty(obj, key);
+    default: {
+      throw new Error("Unexpected typeof " + typeof obj1);
     }
-    else {
-        throw new StackAssertionError(`deleteKey: key ${String(key)} does not exist`, { obj, key });
+  }
+}
+function isCloneable(obj) {
+  return typeof obj !== "symbol" && typeof obj !== "function";
+}
+function shallowClone(obj) {
+  if (!isCloneable(obj)) throw new import_errors.StackAssertionError("shallowClone does not support symbols or functions", { obj });
+  if (Array.isArray(obj)) return obj.map(import_functions.identity);
+  return { ...obj };
+}
+function deepPlainClone(obj) {
+  if (typeof obj === "function") throw new import_errors.StackAssertionError("deepPlainClone does not support functions");
+  if (typeof obj === "symbol") throw new import_errors.StackAssertionError("deepPlainClone does not support symbols");
+  if (typeof obj !== "object" || !obj) return obj;
+  if (Array.isArray(obj)) return obj.map(deepPlainClone);
+  return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, deepPlainClone(v)]));
+}
+function deepMerge(baseObj, mergeObj) {
+  if ([baseObj, mergeObj, ...Object.values(baseObj), ...Object.values(mergeObj)].some((o) => !isCloneable(o))) throw new import_errors.StackAssertionError("deepMerge does not support functions or symbols", { baseObj, mergeObj });
+  const res = shallowClone(baseObj);
+  for (const [key, mergeValue] of Object.entries(mergeObj)) {
+    if (has(res, key)) {
+      const baseValue = get(res, key);
+      if (isObjectLike(baseValue) && isObjectLike(mergeValue)) {
+        set(res, key, deepMerge(baseValue, mergeValue));
+        continue;
+      }
     }
-}
-export function isObjectLike(value) {
-    return (typeof value === 'object' || typeof value === 'function') && value !== null;
-}
+    set(res, key, mergeValue);
+  }
+  return res;
+}
+function typedEntries(obj) {
+  return Object.entries(obj);
+}
+function typedFromEntries(entries) {
+  return Object.fromEntries(entries);
+}
+function typedKeys(obj) {
+  return Object.keys(obj);
+}
+function typedValues(obj) {
+  return Object.values(obj);
+}
+function typedAssign(target, source) {
+  return Object.assign(target, source);
+}
+function filterUndefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+}
+function filterUndefinedOrNull(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0 && v !== null));
+}
+function deepFilterUndefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0).map(([k, v]) => [k, isObjectLike(v) ? deepFilterUndefined(v) : v]));
+}
+function pick(obj, keys) {
+  return Object.fromEntries(Object.entries(obj).filter(([k]) => keys.includes(k)));
+}
+function omit(obj, keys) {
+  if (!Array.isArray(keys)) throw new import_errors.StackAssertionError("omit: keys must be an array", { obj, keys });
+  return Object.fromEntries(Object.entries(obj).filter(([k]) => !keys.includes(k)));
+}
+function split(obj, keys) {
+  return [pick(obj, keys), omit(obj, keys)];
+}
+function mapValues(obj, fn) {
+  if (Array.isArray(obj)) {
+    return obj.map((v) => fn(v));
+  }
+  return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, fn(v)]));
+}
+function sortKeys(obj) {
+  if (Array.isArray(obj)) {
+    return [...obj];
+  }
+  return Object.fromEntries(Object.entries(obj).sort(([a], [b]) => (0, import_strings.stringCompare)(a, b)));
+}
+function deepSortKeys(obj) {
+  return sortKeys(mapValues(obj, (v) => isObjectLike(v) ? deepSortKeys(v) : v));
+}
+function set(obj, key, value) {
+  Object.defineProperty(obj, key, { value, writable: true, configurable: true, enumerable: true });
+}
+function get(obj, key) {
+  const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+  if (!descriptor) throw new import_errors.StackAssertionError(`get: key ${String(key)} does not exist`, { obj, key });
+  return descriptor.value;
+}
+function getOrUndefined(obj, key) {
+  return has(obj, key) ? get(obj, key) : void 0;
+}
+function has(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function hasAndNotUndefined(obj, key) {
+  return has(obj, key) && get(obj, key) !== void 0;
+}
+function deleteKey(obj, key) {
+  if (has(obj, key)) {
+    Reflect.deleteProperty(obj, key);
+  } else {
+    throw new import_errors.StackAssertionError(`deleteKey: key ${String(key)} does not exist`, { obj, key });
+  }
+}
+function isObjectLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deepFilterUndefined,
+  deepMerge,
+  deepPlainClone,
+  deepPlainEquals,
+  deepSortKeys,
+  deleteKey,
+  filterUndefined,
+  filterUndefinedOrNull,
+  get,
+  getOrUndefined,
+  has,
+  hasAndNotUndefined,
+  isCloneable,
+  isNotNull,
+  isObjectLike,
+  mapValues,
+  omit,
+  pick,
+  set,
+  shallowClone,
+  sortKeys,
+  split,
+  typedAssign,
+  typedEntries,
+  typedFromEntries,
+  typedKeys,
+  typedValues
+});
+//# sourceMappingURL=objects.js.map