@gtkx/utils 0.21.0 → 1.0.0-rc.2

package/dist/map/get-or-insert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-or-insert.js","sourceRoot":"","sources":["../../src/map/get-or-insert.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,SAAS,WAAW,CAAO,GAAiB,EAAE,GAAM,EAAE,OAAsB;IACxE,IAAI,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QACf,OAAO,GAAG,CAAC,GAAG,CAAC,GAAG,CAAM,CAAC;IAC7B,CAAC;IAED,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAC3B,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAEpB,OAAO,KAAK,CAAC;AACjB,CAAC;AAED,OAAO,EAAE,WAAW,EAAe,CAAC","sourcesContent":["type GetSet<K, V> = {\n    get(key: K): V | undefined;\n    set(key: K, value: V): unknown;\n    has(key: K): boolean;\n};\n\n/**\n * Returns the value stored under `key`, or inserts and returns the value produced by `factory` when\n * the key is absent. Works with both `Map` and `WeakMap`, and caches a computed `undefined` value.\n *\n * @template K - The key type.\n * @template V - The value type.\n * @param map - The `Map` or `WeakMap` to read from and populate.\n * @param key - The key to look up.\n * @param factory - Produces the value to insert when `key` is absent; called at most once.\n * @returns The existing or newly-inserted value.\n *\n * @example\n * const counts = new Map<string, number[]>();\n * getOrInsert(counts, \"a\", () => []).push(1); // counts is Map { \"a\" => [1] }\n */\nfunction getOrInsert<K, V>(map: GetSet<K, V>, key: K, factory: (key: K) => V): V {\n    if (map.has(key)) {\n        return map.get(key) as V;\n    }\n\n    const value = factory(key);\n    map.set(key, value);\n\n    return value;\n}\n\nexport { getOrInsert, type GetSet };\n"]}

package/dist/map/index.d.ts

@@ -0,0 +1,2 @@
+export { getOrInsert } from "./get-or-insert.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/map/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/map/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/map/index.js

@@ -0,0 +1,2 @@
+export { getOrInsert } from "./get-or-insert.js";
+//# sourceMappingURL=index.js.map

package/dist/map/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/map/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC","sourcesContent":["export { getOrInsert } from \"./get-or-insert.js\";\n"]}

package/dist/object/index.d.ts

@@ -0,0 +1,4 @@
+export { omit } from "./omit.js";
+export { pickBy } from "./pick-by.js";
+export { structuredClone } from "./structured-clone.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/object/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/object/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/object/index.js

@@ -0,0 +1,4 @@
+export { omit } from "./omit.js";
+export { pickBy } from "./pick-by.js";
+export { structuredClone } from "./structured-clone.js";
+//# sourceMappingURL=index.js.map

package/dist/object/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/object/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC","sourcesContent":["export { omit } from \"./omit.js\";\nexport { pickBy } from \"./pick-by.js\";\nexport { structuredClone } from \"./structured-clone.js\";\n"]}

package/dist/object/omit.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Creates a new object holding every entry of `obj` except the named keys.
+ *
+ * @template T - The type of the source object.
+ * @template K - The keys to leave out.
+ * @param obj - The object to copy entries from.
+ * @param keys - The keys to leave out of the result.
+ * @returns A new object without the named keys.
+ *
+ * @example
+ * omit({ a: 1, b: 2 }, ["a"]); // { b: 2 }
+ */
+declare function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+export { omit };
+//# sourceMappingURL=omit.d.ts.map

package/dist/object/omit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit.d.ts","sourceRoot":"","sources":["../../src/object/omit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,iBAAS,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAWhF;AAED,OAAO,EAAE,IAAI,EAAE,CAAC"}

package/dist/object/omit.js

@@ -0,0 +1,24 @@
+/**
+ * Creates a new object holding every entry of `obj` except the named keys.
+ *
+ * @template T - The type of the source object.
+ * @template K - The keys to leave out.
+ * @param obj - The object to copy entries from.
+ * @param keys - The keys to leave out of the result.
+ * @returns A new object without the named keys.
+ *
+ * @example
+ * omit({ a: 1, b: 2 }, ["a"]); // { b: 2 }
+ */
+function omit(obj, keys) {
+    const excluded = new Set(keys);
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (!excluded.has(key)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+export { omit };
+//# sourceMappingURL=omit.js.map

package/dist/object/omit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit.js","sourceRoot":"","sources":["../../src/object/omit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,SAAS,IAAI,CAAsC,GAAM,EAAE,IAAS;IAChE,MAAM,QAAQ,GAAqB,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC;IACjD,MAAM,MAAM,GAA4B,EAAE,CAAC;IAE3C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QAC7C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACrB,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACxB,CAAC;IACL,CAAC;IAED,OAAO,MAAoB,CAAC;AAChC,CAAC;AAED,OAAO,EAAE,IAAI,EAAE,CAAC","sourcesContent":["/**\n * Creates a new object holding every entry of `obj` except the named keys.\n *\n * @template T - The type of the source object.\n * @template K - The keys to leave out.\n * @param obj - The object to copy entries from.\n * @param keys - The keys to leave out of the result.\n * @returns A new object without the named keys.\n *\n * @example\n * omit({ a: 1, b: 2 }, [\"a\"]); // { b: 2 }\n */\nfunction omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {\n    const excluded: Set<PropertyKey> = new Set(keys);\n    const result: Record<string, unknown> = {};\n\n    for (const [key, value] of Object.entries(obj)) {\n        if (!excluded.has(key)) {\n            result[key] = value;\n        }\n    }\n\n    return result as Omit<T, K>;\n}\n\nexport { omit };\n"]}

package/dist/object/pick-by.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Creates a new object of the entries of `obj` that satisfy the predicate.
+ *
+ * @template T - The type of the source object.
+ * @param obj - The object to pick entries from.
+ * @param shouldPick - Called with each value and key; return `true` to keep the entry.
+ * @returns A new object holding only the entries the predicate kept.
+ *
+ * @example
+ * pickBy({ a: 1, b: 2 }, (value) => value > 1); // { b: 2 }
+ * pickBy({ a: 1, b: 2 }, (_value, key) => key !== "a"); // { b: 2 }
+ */
+declare function pickBy<T extends Record<string, unknown>>(obj: T, shouldPick: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
+export { pickBy };
+//# sourceMappingURL=pick-by.d.ts.map

package/dist/object/pick-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick-by.d.ts","sourceRoot":"","sources":["../../src/object/pick-by.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,iBAAS,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7C,GAAG,EAAE,CAAC,EACN,UAAU,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,KAAK,OAAO,GACzD,OAAO,CAAC,CAAC,CAAC,CAYZ;AAED,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/dist/object/pick-by.js

@@ -0,0 +1,24 @@
+/**
+ * Creates a new object of the entries of `obj` that satisfy the predicate.
+ *
+ * @template T - The type of the source object.
+ * @param obj - The object to pick entries from.
+ * @param shouldPick - Called with each value and key; return `true` to keep the entry.
+ * @returns A new object holding only the entries the predicate kept.
+ *
+ * @example
+ * pickBy({ a: 1, b: 2 }, (value) => value > 1); // { b: 2 }
+ * pickBy({ a: 1, b: 2 }, (_value, key) => key !== "a"); // { b: 2 }
+ */
+function pickBy(obj, shouldPick) {
+    const result = {};
+    for (const key of Object.keys(obj)) {
+        const value = obj[key];
+        if (shouldPick(value, key)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+export { pickBy };
+//# sourceMappingURL=pick-by.js.map

package/dist/object/pick-by.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick-by.js","sourceRoot":"","sources":["../../src/object/pick-by.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,SAAS,MAAM,CACX,GAAM,EACN,UAAwD;IAExD,MAAM,MAAM,GAAe,EAAE,CAAC;IAE9B,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAgB,EAAE,CAAC;QAChD,MAAM,KAAK,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;QAEvB,IAAI,UAAU,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,CAAC;YACzB,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACxB,CAAC;IACL,CAAC;IAED,OAAO,MAAM,CAAC;AAClB,CAAC;AAED,OAAO,EAAE,MAAM,EAAE,CAAC","sourcesContent":["/**\n * Creates a new object of the entries of `obj` that satisfy the predicate.\n *\n * @template T - The type of the source object.\n * @param obj - The object to pick entries from.\n * @param shouldPick - Called with each value and key; return `true` to keep the entry.\n * @returns A new object holding only the entries the predicate kept.\n *\n * @example\n * pickBy({ a: 1, b: 2 }, (value) => value > 1); // { b: 2 }\n * pickBy({ a: 1, b: 2 }, (_value, key) => key !== \"a\"); // { b: 2 }\n */\nfunction pickBy<T extends Record<string, unknown>>(\n    obj: T,\n    shouldPick: (value: T[keyof T], key: keyof T) => boolean,\n): Partial<T> {\n    const result: Partial<T> = {};\n\n    for (const key of Object.keys(obj) as (keyof T)[]) {\n        const value = obj[key];\n\n        if (shouldPick(value, key)) {\n            result[key] = value;\n        }\n    }\n\n    return result;\n}\n\nexport { pickBy };\n"]}

package/dist/object/structured-clone.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Recursively copies arrays and plain objects, sharing every other value by reference. The result
+ * mirrors exactly the structure `isDeepEqual` traverses, so comparing a value against its earlier
+ * clone detects in-place mutations of the original. Unlike the global of the same name, class
+ * instances such as `Date` and `Map` are shared rather than copied, and no value is ever rejected.
+ *
+ * @template T - The type of the value.
+ * @param value - The value to clone.
+ * @returns A clone whose arrays and plain objects are fresh and whose other values are shared.
+ *
+ * @example
+ * const source = { a: [{ b: 1 }] };
+ * const copy = structuredClone(source);
+ * source.a[0].b = 2;
+ * copy.a[0].b; // 1
+ */
+declare function structuredClone<T>(value: T): T;
+export { structuredClone };
+//# sourceMappingURL=structured-clone.d.ts.map

package/dist/object/structured-clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured-clone.d.ts","sourceRoot":"","sources":["../../src/object/structured-clone.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,iBAAS,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAUvC;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/object/structured-clone.js

@@ -0,0 +1,28 @@
+import { isPlainObject } from "../predicate/is-plain-object.js";
+/**
+ * Recursively copies arrays and plain objects, sharing every other value by reference. The result
+ * mirrors exactly the structure `isDeepEqual` traverses, so comparing a value against its earlier
+ * clone detects in-place mutations of the original. Unlike the global of the same name, class
+ * instances such as `Date` and `Map` are shared rather than copied, and no value is ever rejected.
+ *
+ * @template T - The type of the value.
+ * @param value - The value to clone.
+ * @returns A clone whose arrays and plain objects are fresh and whose other values are shared.
+ *
+ * @example
+ * const source = { a: [{ b: 1 }] };
+ * const copy = structuredClone(source);
+ * source.a[0].b = 2;
+ * copy.a[0].b; // 1
+ */
+function structuredClone(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => structuredClone(item));
+    }
+    if (isPlainObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, structuredClone(entry)]));
+    }
+    return value;
+}
+export { structuredClone };
+//# sourceMappingURL=structured-clone.js.map

package/dist/object/structured-clone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured-clone.js","sourceRoot":"","sources":["../../src/object/structured-clone.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAEhE;;;;;;;;;;;;;;;GAeG;AACH,SAAS,eAAe,CAAI,KAAQ;IAChC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAa,EAAE,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,CAAM,CAAC;IACpE,CAAC;IAED,IAAI,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAM,CAAC;IAC/G,CAAC;IAED,OAAO,KAAK,CAAC;AACjB,CAAC;AAED,OAAO,EAAE,eAAe,EAAE,CAAC","sourcesContent":["import { isPlainObject } from \"../predicate/is-plain-object.js\";\n\n/**\n * Recursively copies arrays and plain objects, sharing every other value by reference. The result\n * mirrors exactly the structure `isDeepEqual` traverses, so comparing a value against its earlier\n * clone detects in-place mutations of the original. Unlike the global of the same name, class\n * instances such as `Date` and `Map` are shared rather than copied, and no value is ever rejected.\n *\n * @template T - The type of the value.\n * @param value - The value to clone.\n * @returns A clone whose arrays and plain objects are fresh and whose other values are shared.\n *\n * @example\n * const source = { a: [{ b: 1 }] };\n * const copy = structuredClone(source);\n * source.a[0].b = 2;\n * copy.a[0].b; // 1\n */\nfunction structuredClone<T>(value: T): T {\n    if (Array.isArray(value)) {\n        return value.map((item: unknown) => structuredClone(item)) as T;\n    }\n\n    if (isPlainObject(value)) {\n        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, structuredClone(entry)])) as T;\n    }\n\n    return value;\n}\n\nexport { structuredClone };\n"]}

package/dist/predicate/are-object-keys-equal.d.ts

@@ -0,0 +1,3 @@
+declare const areObjectKeysEqual: (a: Record<string, unknown>, b: Record<string, unknown>, isValueEqual: (a: unknown, b: unknown) => boolean) => boolean;
+export { areObjectKeysEqual };
+//# sourceMappingURL=are-object-keys-equal.d.ts.map

package/dist/predicate/are-object-keys-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"are-object-keys-equal.d.ts","sourceRoot":"","sources":["../../src/predicate/are-object-keys-equal.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,kBAAkB,GACpB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1B,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,KAAK,OAAO,KAClD,OAQF,CAAC;AAEF,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/predicate/are-object-keys-equal.js

@@ -0,0 +1,9 @@
+const areObjectKeysEqual = (a, b, isValueEqual) => {
+    const keysA = Object.keys(a);
+    if (keysA.length !== Object.keys(b).length) {
+        return false;
+    }
+    return keysA.every((key) => Object.hasOwn(b, key) && isValueEqual(a[key], b[key]));
+};
+export { areObjectKeysEqual };
+//# sourceMappingURL=are-object-keys-equal.js.map

package/dist/predicate/are-object-keys-equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"are-object-keys-equal.js","sourceRoot":"","sources":["../../src/predicate/are-object-keys-equal.ts"],"names":[],"mappings":"AAAA,MAAM,kBAAkB,GAAG,CACvB,CAA0B,EAC1B,CAA0B,EAC1B,YAAiD,EAC1C,EAAE;IACT,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAE7B,IAAI,KAAK,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QACzC,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AACvF,CAAC,CAAC;AAEF,OAAO,EAAE,kBAAkB,EAAE,CAAC","sourcesContent":["const areObjectKeysEqual = (\n    a: Record<string, unknown>,\n    b: Record<string, unknown>,\n    isValueEqual: (a: unknown, b: unknown) => boolean,\n): boolean => {\n    const keysA = Object.keys(a);\n\n    if (keysA.length !== Object.keys(b).length) {\n        return false;\n    }\n\n    return keysA.every((key) => Object.hasOwn(b, key) && isValueEqual(a[key], b[key]));\n};\n\nexport { areObjectKeysEqual };\n"]}

package/dist/predicate/index.d.ts

@@ -0,0 +1,7 @@
+export { isDeepEqual } from "./is-deep-equal.js";
+export { isPlainObject } from "./is-plain-object.js";
+export { isRecord } from "./is-record.js";
+export { isSameArrayBy } from "./is-same-array-by.js";
+export { isSameArray } from "./is-same-array.js";
+export { isShallowEqual } from "./is-shallow-equal.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/predicate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/predicate/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/predicate/index.js

@@ -0,0 +1,7 @@
+export { isDeepEqual } from "./is-deep-equal.js";
+export { isPlainObject } from "./is-plain-object.js";
+export { isRecord } from "./is-record.js";
+export { isSameArrayBy } from "./is-same-array-by.js";
+export { isSameArray } from "./is-same-array.js";
+export { isShallowEqual } from "./is-shallow-equal.js";
+//# sourceMappingURL=index.js.map

package/dist/predicate/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/predicate/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC","sourcesContent":["export { isDeepEqual } from \"./is-deep-equal.js\";\nexport { isPlainObject } from \"./is-plain-object.js\";\nexport { isRecord } from \"./is-record.js\";\nexport { isSameArrayBy } from \"./is-same-array-by.js\";\nexport { isSameArray } from \"./is-same-array.js\";\nexport { isShallowEqual } from \"./is-shallow-equal.js\";\n"]}

package/dist/predicate/is-deep-equal.d.ts

@@ -0,0 +1,3 @@
+declare function isDeepEqual(a: unknown, b: unknown): boolean;
+export { isDeepEqual };
+//# sourceMappingURL=is-deep-equal.d.ts.map

package/dist/predicate/is-deep-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-deep-equal.d.ts","sourceRoot":"","sources":["../../src/predicate/is-deep-equal.ts"],"names":[],"mappings":"AAwBA,iBAAS,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAcpD;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/predicate/is-deep-equal.js

@@ -0,0 +1,35 @@
+import { areObjectKeysEqual } from "./are-object-keys-equal.js";
+import { isPlainObject } from "./is-plain-object.js";
+/**
+ * Checks whether two values are deeply equal: identical, arrays of the same length whose elements
+ * are deeply equal in order, or plain objects with the same own enumerable keys and deeply equal
+ * values. Values that are neither both arrays nor both plain objects are equal only when identical.
+ *
+ * @param a - The first value.
+ * @param b - The second value.
+ * @returns `true` when the values are deeply equal.
+ *
+ * @example
+ * isDeepEqual({ a: [1, { b: 2 }] }, { a: [1, { b: 2 }] }); // true
+ * isDeepEqual({ a: [1] }, { a: [2] }); // false
+ */
+const isDeepArrayEqual = (a, b) => {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
+        return false;
+    }
+    return a.every((item, index) => isDeepEqual(item, b[index]));
+};
+function isDeepEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (Array.isArray(a) || Array.isArray(b)) {
+        return isDeepArrayEqual(a, b);
+    }
+    if (isPlainObject(a) && isPlainObject(b)) {
+        return areObjectKeysEqual(a, b, isDeepEqual);
+    }
+    return false;
+}
+export { isDeepEqual };
+//# sourceMappingURL=is-deep-equal.js.map

package/dist/predicate/is-deep-equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-deep-equal.js","sourceRoot":"","sources":["../../src/predicate/is-deep-equal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;;;;;;;;;;GAYG;AACH,MAAM,gBAAgB,GAAG,CAAC,CAAU,EAAE,CAAU,EAAW,EAAE;IACzD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;QAClE,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACjE,CAAC,CAAC;AAEF,SAAS,WAAW,CAAC,CAAU,EAAE,CAAU;IACvC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACV,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;QACvC,OAAO,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAClC,CAAC;IAED,IAAI,aAAa,CAAC,CAAC,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC;QACvC,OAAO,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC;IACjD,CAAC;IAED,OAAO,KAAK,CAAC;AACjB,CAAC;AAED,OAAO,EAAE,WAAW,EAAE,CAAC","sourcesContent":["import { areObjectKeysEqual } from \"./are-object-keys-equal.js\";\nimport { isPlainObject } from \"./is-plain-object.js\";\n\n/**\n * Checks whether two values are deeply equal: identical, arrays of the same length whose elements\n * are deeply equal in order, or plain objects with the same own enumerable keys and deeply equal\n * values. Values that are neither both arrays nor both plain objects are equal only when identical.\n *\n * @param a - The first value.\n * @param b - The second value.\n * @returns `true` when the values are deeply equal.\n *\n * @example\n * isDeepEqual({ a: [1, { b: 2 }] }, { a: [1, { b: 2 }] }); // true\n * isDeepEqual({ a: [1] }, { a: [2] }); // false\n */\nconst isDeepArrayEqual = (a: unknown, b: unknown): boolean => {\n    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {\n        return false;\n    }\n\n    return a.every((item, index) => isDeepEqual(item, b[index]));\n};\n\nfunction isDeepEqual(a: unknown, b: unknown): boolean {\n    if (a === b) {\n        return true;\n    }\n\n    if (Array.isArray(a) || Array.isArray(b)) {\n        return isDeepArrayEqual(a, b);\n    }\n\n    if (isPlainObject(a) && isPlainObject(b)) {\n        return areObjectKeysEqual(a, b, isDeepEqual);\n    }\n\n    return false;\n}\n\nexport { isDeepEqual };\n"]}

package/dist/predicate/is-plain-object.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Checks whether a value is a plain object, i.e. one whose prototype is `Object.prototype` or `null`.
+ *
+ * Class instances, arrays, and other exotic objects return `false`.
+ *
+ * @param value - The value to test.
+ * @returns `true` when `value` is a plain object.
+ *
+ * @example
+ * isPlainObject({ a: 1 }); // true
+ * isPlainObject(Object.create(null)); // true
+ * isPlainObject([1, 2]); // false
+ * isPlainObject(new Date()); // false
+ */
+declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export { isPlainObject };
+//# sourceMappingURL=is-plain-object.d.ts.map

package/dist/predicate/is-plain-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-plain-object.d.ts","sourceRoot":"","sources":["../../src/predicate/is-plain-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,iBAAS,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQvE;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/predicate/is-plain-object.js

@@ -0,0 +1,23 @@
+/**
+ * Checks whether a value is a plain object, i.e. one whose prototype is `Object.prototype` or `null`.
+ *
+ * Class instances, arrays, and other exotic objects return `false`.
+ *
+ * @param value - The value to test.
+ * @returns `true` when `value` is a plain object.
+ *
+ * @example
+ * isPlainObject({ a: 1 }); // true
+ * isPlainObject(Object.create(null)); // true
+ * isPlainObject([1, 2]); // false
+ * isPlainObject(new Date()); // false
+ */
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+export { isPlainObject };
+//# sourceMappingURL=is-plain-object.js.map

package/dist/predicate/is-plain-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-plain-object.js","sourceRoot":"","sources":["../../src/predicate/is-plain-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,SAAS,aAAa,CAAC,KAAc;IACjC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAC9C,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,MAAM,KAAK,GAAY,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAEpD,OAAO,KAAK,KAAK,MAAM,CAAC,SAAS,IAAI,KAAK,KAAK,IAAI,CAAC;AACxD,CAAC;AAED,OAAO,EAAE,aAAa,EAAE,CAAC","sourcesContent":["/**\n * Checks whether a value is a plain object, i.e. one whose prototype is `Object.prototype` or `null`.\n *\n * Class instances, arrays, and other exotic objects return `false`.\n *\n * @param value - The value to test.\n * @returns `true` when `value` is a plain object.\n *\n * @example\n * isPlainObject({ a: 1 }); // true\n * isPlainObject(Object.create(null)); // true\n * isPlainObject([1, 2]); // false\n * isPlainObject(new Date()); // false\n */\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) {\n        return false;\n    }\n\n    const proto: unknown = Object.getPrototypeOf(value);\n\n    return proto === Object.prototype || proto === null;\n}\n\nexport { isPlainObject };\n"]}

package/dist/predicate/is-record.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Checks whether a value is a non-null object (including arrays and class instances, excluding `null`).
+ *
+ * @param value - The value to test.
+ * @returns `true` when `value` is a non-null object.
+ *
+ * @example
+ * isRecord({ a: 1 }); // true
+ * isRecord(null); // false
+ * isRecord("x"); // false
+ */
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+export { isRecord };
+//# sourceMappingURL=is-record.d.ts.map

package/dist/predicate/is-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-record.d.ts","sourceRoot":"","sources":["../../src/predicate/is-record.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,iBAAS,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAElE;AAED,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/dist/predicate/is-record.js

@@ -0,0 +1,16 @@
+/**
+ * Checks whether a value is a non-null object (including arrays and class instances, excluding `null`).
+ *
+ * @param value - The value to test.
+ * @returns `true` when `value` is a non-null object.
+ *
+ * @example
+ * isRecord({ a: 1 }); // true
+ * isRecord(null); // false
+ * isRecord("x"); // false
+ */
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export { isRecord };
+//# sourceMappingURL=is-record.js.map

package/dist/predicate/is-record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-record.js","sourceRoot":"","sources":["../../src/predicate/is-record.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,SAAS,QAAQ,CAAC,KAAc;IAC5B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AACvD,CAAC;AAED,OAAO,EAAE,QAAQ,EAAE,CAAC","sourcesContent":["/**\n * Checks whether a value is a non-null object (including arrays and class instances, excluding `null`).\n *\n * @param value - The value to test.\n * @returns `true` when `value` is a non-null object.\n *\n * @example\n * isRecord({ a: 1 }); // true\n * isRecord(null); // false\n * isRecord(\"x\"); // false\n */\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n    return typeof value === \"object\" && value !== null;\n}\n\nexport { isRecord };\n"]}

package/dist/predicate/is-same-array-by.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Checks whether two arrays have the same length and elements the comparator treats as equal, in order.
+ *
+ * @template T - The type of the array elements.
+ * @param a - The first array.
+ * @param b - The second array.
+ * @param isEqual - Compares elements at the same index; return `true` when they are equal.
+ * @returns `true` when the arrays are element-wise equal under `isEqual`.
+ *
+ * @example
+ * isSameArrayBy([{ id: 1 }], [{ id: 1 }], (x, y) => x.id === y.id); // true
+ */
+declare function isSameArrayBy<T>(a: T[], b: T[], isEqual: (x: T, y: T) => boolean): boolean;
+export { isSameArrayBy };
+//# sourceMappingURL=is-same-array-by.d.ts.map

package/dist/predicate/is-same-array-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-same-array-by.d.ts","sourceRoot":"","sources":["../../src/predicate/is-same-array-by.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,iBAAS,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAMnF;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/predicate/is-same-array-by.js

@@ -0,0 +1,20 @@
+/**
+ * Checks whether two arrays have the same length and elements the comparator treats as equal, in order.
+ *
+ * @template T - The type of the array elements.
+ * @param a - The first array.
+ * @param b - The second array.
+ * @param isEqual - Compares elements at the same index; return `true` when they are equal.
+ * @returns `true` when the arrays are element-wise equal under `isEqual`.
+ *
+ * @example
+ * isSameArrayBy([{ id: 1 }], [{ id: 1 }], (x, y) => x.id === y.id); // true
+ */
+function isSameArrayBy(a, b, isEqual) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    return a.every((item, index) => isEqual(item, b[index]));
+}
+export { isSameArrayBy };
+//# sourceMappingURL=is-same-array-by.js.map

package/dist/predicate/is-same-array-by.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-same-array-by.js","sourceRoot":"","sources":["../../src/predicate/is-same-array-by.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,SAAS,aAAa,CAAI,CAAM,EAAE,CAAM,EAAE,OAAgC;IACtE,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;QACxB,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAM,CAAC,CAAC,CAAC;AAClE,CAAC;AAED,OAAO,EAAE,aAAa,EAAE,CAAC","sourcesContent":["/**\n * Checks whether two arrays have the same length and elements the comparator treats as equal, in order.\n *\n * @template T - The type of the array elements.\n * @param a - The first array.\n * @param b - The second array.\n * @param isEqual - Compares elements at the same index; return `true` when they are equal.\n * @returns `true` when the arrays are element-wise equal under `isEqual`.\n *\n * @example\n * isSameArrayBy([{ id: 1 }], [{ id: 1 }], (x, y) => x.id === y.id); // true\n */\nfunction isSameArrayBy<T>(a: T[], b: T[], isEqual: (x: T, y: T) => boolean): boolean {\n    if (a.length !== b.length) {\n        return false;\n    }\n\n    return a.every((item, index) => isEqual(item, b[index] as T));\n}\n\nexport { isSameArrayBy };\n"]}

package/dist/predicate/is-same-array.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Checks whether two arrays have the same length and strictly equal (`===`) elements in order.
+ *
+ * @template T - The type of the array elements.
+ * @param a - The first array.
+ * @param b - The second array.
+ * @returns `true` when the arrays are element-wise strictly equal.
+ *
+ * @example
+ * isSameArray([1, 2], [1, 2]); // true
+ * isSameArray([1, 2], [2, 1]); // false
+ */
+declare function isSameArray<T>(a: T[], b: T[]): boolean;
+export { isSameArray };
+//# sourceMappingURL=is-same-array.d.ts.map

package/dist/predicate/is-same-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-same-array.d.ts","sourceRoot":"","sources":["../../src/predicate/is-same-array.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,iBAAS,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,OAAO,CAE/C;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/predicate/is-same-array.js

@@ -0,0 +1,18 @@
+import { isSameArrayBy } from "./is-same-array-by.js";
+/**
+ * Checks whether two arrays have the same length and strictly equal (`===`) elements in order.
+ *
+ * @template T - The type of the array elements.
+ * @param a - The first array.
+ * @param b - The second array.
+ * @returns `true` when the arrays are element-wise strictly equal.
+ *
+ * @example
+ * isSameArray([1, 2], [1, 2]); // true
+ * isSameArray([1, 2], [2, 1]); // false
+ */
+function isSameArray(a, b) {
+    return isSameArrayBy(a, b, (x, y) => x === y);
+}
+export { isSameArray };
+//# sourceMappingURL=is-same-array.js.map

package/dist/predicate/is-same-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-same-array.js","sourceRoot":"","sources":["../../src/predicate/is-same-array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD;;;;;;;;;;;GAWG;AACH,SAAS,WAAW,CAAI,CAAM,EAAE,CAAM;IAClC,OAAO,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;AAClD,CAAC;AAED,OAAO,EAAE,WAAW,EAAE,CAAC","sourcesContent":["import { isSameArrayBy } from \"./is-same-array-by.js\";\n\n/**\n * Checks whether two arrays have the same length and strictly equal (`===`) elements in order.\n *\n * @template T - The type of the array elements.\n * @param a - The first array.\n * @param b - The second array.\n * @returns `true` when the arrays are element-wise strictly equal.\n *\n * @example\n * isSameArray([1, 2], [1, 2]); // true\n * isSameArray([1, 2], [2, 1]); // false\n */\nfunction isSameArray<T>(a: T[], b: T[]): boolean {\n    return isSameArrayBy(a, b, (x, y) => x === y);\n}\n\nexport { isSameArray };\n"]}

package/dist/predicate/is-shallow-equal.d.ts

@@ -0,0 +1,3 @@
+declare function isShallowEqual(a: unknown, b: unknown): boolean;
+export { isShallowEqual };
+//# sourceMappingURL=is-shallow-equal.d.ts.map

package/dist/predicate/is-shallow-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-shallow-equal.d.ts","sourceRoot":"","sources":["../../src/predicate/is-shallow-equal.ts"],"names":[],"mappings":"AAmBA,iBAAS,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAUvD;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/predicate/is-shallow-equal.js

@@ -0,0 +1,28 @@
+import { areObjectKeysEqual } from "./are-object-keys-equal.js";
+import { isPlainObject } from "./is-plain-object.js";
+/**
+ * Checks whether two values are shallowly equal: identical, or plain objects with the same own
+ * enumerable keys and strictly equal (`===`) values. Values that are not both plain objects are
+ * equal only when identical.
+ *
+ * @param a - The first value.
+ * @param b - The second value.
+ * @returns `true` when the values are shallowly equal.
+ *
+ * @example
+ * isShallowEqual({ a: 1 }, { a: 1 }); // true
+ * isShallowEqual({ a: 1 }, { a: 2 }); // false
+ * isShallowEqual(3, 3); // true
+ */
+const isStrictEqual = (a, b) => a === b;
+function isShallowEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (isPlainObject(a) && isPlainObject(b)) {
+        return areObjectKeysEqual(a, b, isStrictEqual);
+    }
+    return false;
+}
+export { isShallowEqual };
+//# sourceMappingURL=is-shallow-equal.js.map

package/dist/predicate/is-shallow-equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-shallow-equal.js","sourceRoot":"","sources":["../../src/predicate/is-shallow-equal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;;;;;;;;;;;GAaG;AACH,MAAM,aAAa,GAAG,CAAC,CAAU,EAAE,CAAU,EAAW,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;AAEnE,SAAS,cAAc,CAAC,CAAU,EAAE,CAAU;IAC1C,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACV,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,IAAI,aAAa,CAAC,CAAC,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC;QACvC,OAAO,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC,CAAC;IACnD,CAAC;IAED,OAAO,KAAK,CAAC;AACjB,CAAC;AAED,OAAO,EAAE,cAAc,EAAE,CAAC","sourcesContent":["import { areObjectKeysEqual } from \"./are-object-keys-equal.js\";\nimport { isPlainObject } from \"./is-plain-object.js\";\n\n/**\n * Checks whether two values are shallowly equal: identical, or plain objects with the same own\n * enumerable keys and strictly equal (`===`) values. Values that are not both plain objects are\n * equal only when identical.\n *\n * @param a - The first value.\n * @param b - The second value.\n * @returns `true` when the values are shallowly equal.\n *\n * @example\n * isShallowEqual({ a: 1 }, { a: 1 }); // true\n * isShallowEqual({ a: 1 }, { a: 2 }); // false\n * isShallowEqual(3, 3); // true\n */\nconst isStrictEqual = (a: unknown, b: unknown): boolean => a === b;\n\nfunction isShallowEqual(a: unknown, b: unknown): boolean {\n    if (a === b) {\n        return true;\n    }\n\n    if (isPlainObject(a) && isPlainObject(b)) {\n        return areObjectKeysEqual(a, b, isStrictEqual);\n    }\n\n    return false;\n}\n\nexport { isShallowEqual };\n"]}

package/dist/process/exit-code-for-signal.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Maps a terminating signal to its conventional process exit code (130 for `SIGINT`, 143 otherwise),
+ * or 0 when no signal is given.
+ *
+ * @param signal - The signal that triggered termination, or `null`.
+ * @returns The conventional exit code for the signal.
+ *
+ * @example
+ * exitCodeForSignal("SIGINT"); // 130
+ * exitCodeForSignal(null); // 0
+ */
+declare function exitCodeForSignal(signal: NodeJS.Signals | null): number;
+export { exitCodeForSignal };
+//# sourceMappingURL=exit-code-for-signal.d.ts.map

package/dist/process/exit-code-for-signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit-code-for-signal.d.ts","sourceRoot":"","sources":["../../src/process/exit-code-for-signal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,iBAAS,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,GAAG,MAAM,CAMhE;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/process/exit-code-for-signal.js

@@ -0,0 +1,19 @@
+/**
+ * Maps a terminating signal to its conventional process exit code (130 for `SIGINT`, 143 otherwise),
+ * or 0 when no signal is given.
+ *
+ * @param signal - The signal that triggered termination, or `null`.
+ * @returns The conventional exit code for the signal.
+ *
+ * @example
+ * exitCodeForSignal("SIGINT"); // 130
+ * exitCodeForSignal(null); // 0
+ */
+function exitCodeForSignal(signal) {
+    if (!signal) {
+        return 0;
+    }
+    return signal === "SIGINT" ? 130 : 143;
+}
+export { exitCodeForSignal };
+//# sourceMappingURL=exit-code-for-signal.js.map

package/dist/process/exit-code-for-signal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit-code-for-signal.js","sourceRoot":"","sources":["../../src/process/exit-code-for-signal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,SAAS,iBAAiB,CAAC,MAA6B;IACpD,IAAI,CAAC,MAAM,EAAE,CAAC;QACV,OAAO,CAAC,CAAC;IACb,CAAC;IAED,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;AAC3C,CAAC;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC","sourcesContent":["/**\n * Maps a terminating signal to its conventional process exit code (130 for `SIGINT`, 143 otherwise),\n * or 0 when no signal is given.\n *\n * @param signal - The signal that triggered termination, or `null`.\n * @returns The conventional exit code for the signal.\n *\n * @example\n * exitCodeForSignal(\"SIGINT\"); // 130\n * exitCodeForSignal(null); // 0\n */\nfunction exitCodeForSignal(signal: NodeJS.Signals | null): number {\n    if (!signal) {\n        return 0;\n    }\n\n    return signal === \"SIGINT\" ? 130 : 143;\n}\n\nexport { exitCodeForSignal };\n"]}

package/dist/process/index.d.ts

@@ -0,0 +1,4 @@
+export { exitCodeForSignal } from "./exit-code-for-signal.js";
+export { installGracefulShutdown } from "./install-graceful-shutdown.js";
+export { resolveExecutable } from "./resolve-executable.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/process/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/process/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/process/index.js

@@ -0,0 +1,4 @@
+export { exitCodeForSignal } from "./exit-code-for-signal.js";
+export { installGracefulShutdown } from "./install-graceful-shutdown.js";
+export { resolveExecutable } from "./resolve-executable.js";
+//# sourceMappingURL=index.js.map

package/dist/process/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/process/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC","sourcesContent":["export { exitCodeForSignal } from \"./exit-code-for-signal.js\";\nexport { installGracefulShutdown } from \"./install-graceful-shutdown.js\";\nexport { resolveExecutable } from \"./resolve-executable.js\";\n"]}