umsizi 0.7.0 → 0.9.0

package/dist/index.d.ts

@@ -41,6 +41,22 @@ type PartitionedValues<T extends object, S extends T[StringKeyOf<T>]> = readonly
 type PartitionedObject<T extends object> = readonly [Partial<{ [K in StringKeyOf<T>]: T[K] }>, Partial<{ [K in StringKeyOf<T>]: T[K] }>];
 type CompactedObject<T extends object> = Partial<{ [K in StringKeyOf<T>]: Exclude<T[K], null | undefined> }>;
 type InvertedObject<T extends Record<string, PropertyKey>> = { [K in StringKeyOf<T> as T[K]]: K };
+type Validator<T> = (value: unknown) => value is T;
+type ObjectSchema = Record<string, Validator<unknown>>;
+type SchemaValue<T> = T extends Validator<infer U> ? U : never;
+type InferSchema<T extends ObjectSchema> = { [K in keyof T]: SchemaValue<T[K]> };
+type GroupedByKey<T extends object, K$1 extends keyof T> = Partial<Record<Extract<T[K$1], PropertyKey>, Array<T>>>;
+type IndexedByKey<T extends object, K$1 extends keyof T> = Partial<Record<Extract<T[K$1], PropertyKey>, T>>;
+type KeyMatch<K$1 extends PropertyKey, L, R> = {
+  key: K$1;
+  left: L;
+  right: R;
+};
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+type WithDefault<T, D> = undefined extends T ? Exclude<T, undefined> | D : T;
+type MergeDefaultValue<T, D> = T extends readonly unknown[] ? WithDefault<T, D> : T extends object ? D extends object ? MergeDefaulted<T, D> : WithDefault<T, D> : WithDefault<T, D>;
+type Defaulted<T extends object, D extends object> = Simplify<{ [K in keyof T | keyof D]: K extends keyof T ? K extends keyof D ? WithDefault<T[K], D[K]> : T[K] : K extends keyof D ? D[K] : never }>;
+type MergeDefaulted<T extends object, D extends object> = Simplify<{ [K in keyof T | keyof D]: K extends keyof T ? K extends keyof D ? MergeDefaultValue<T[K], D[K]> : T[K] : K extends keyof D ? D[K] : never }>;
 type PathValueAtSegment<T, K$1 extends PathSegment> = K$1 extends keyof T ? T[K$1] : K$1 extends number ? T extends readonly (infer U)[] ? U : T extends (infer U)[] ? U : never : never;
 type PathValue<T, P extends ObjectPath> = P extends readonly [] ? T : P extends readonly [infer Head extends PathSegment, ...infer Tail extends ObjectPath] ? PathValueAtSegment<T, Head> extends never ? never : PathValue<PathValueAtSegment<T, Head>, Tail> : never;
 //#endregion
@@ -59,6 +75,15 @@ type PathValue<T, P extends ObjectPath> = P extends readonly [] ? T : P extends
  */
 declare function compactObject<T extends object>(object: T): CompactedObject<T>;
 //#endregion
+//#region src/core/defaults.d.ts
+/**
+ * Creates a new object by filling missing or `undefined` properties from a
+ * defaults object.
+ *
+ * `null`, `false`, `0`, and other defined values are preserved as-is.
+ */
+declare function defaults<T extends object, D extends object>(object: T, defaultValues: D): Defaulted<T, D>;
+//#endregion
 //#region src/core/filter-keys.d.ts
 /**
  * Filters an object's own enumerable string-keyed properties by key.
@@ -112,6 +137,25 @@ declare function get<T, const P extends ObjectPath, D>(object: T, path: P, defau
 declare function get<T>(object: T, path: string): unknown;
 declare function get<T, D>(object: T, path: string, defaultValue: D): D | unknown;
 //#endregion
+//#region src/core/group-by-key.d.ts
+/**
+ * Groups items by a property whose value can be used as an object key.
+ *
+ * @example
+ * ```ts
+ * groupByKey(
+ *   [
+ *     { id: "1", role: "admin" },
+ *     { id: "2", role: "member" },
+ *     { id: "3", role: "admin" },
+ *   ],
+ *   "role",
+ * );
+ * // { admin: [...], member: [...] }
+ * ```
+ */
+declare function groupByKey<T extends object, K$1 extends keyof T>(items: ReadonlyArray<T>, key: K$1): GroupedByKey<T, K$1>;
+//#endregion
 //#region src/core/has-keys.d.ts
 /**
  * Checks whether a plain object has all of the requested own keys.
@@ -172,6 +216,26 @@ declare function hasPath(object: unknown, pathInput: PathInput): boolean;
  */
 declare function identity<T>(value: T): T;
 //#endregion
+//#region src/core/index-by-key.d.ts
+/**
+ * Indexes items by a property whose value can be used as an object key.
+ *
+ * Later items overwrite earlier items with the same key.
+ *
+ * @example
+ * ```ts
+ * indexByKey(
+ *   [
+ *     { id: "1", name: "Ada" },
+ *     { id: "2", name: "Linus" },
+ *   ],
+ *   "id",
+ * );
+ * // { 1: { ... }, 2: { ... } }
+ * ```
+ */
+declare function indexByKey<T extends object, K$1 extends keyof T>(items: ReadonlyArray<T>, key: K$1): IndexedByKey<T, K$1>;
+//#endregion
 //#region src/core/invert-object.d.ts
 /**
  * Inverts an object's own enumerable string-keyed properties.
@@ -255,6 +319,35 @@ declare function mapKeys<T extends object, R extends string>(object: T, mapper:
  */
 declare function mapValues<T extends object, R>(object: T, mapper: ValueMapper<T, R>): MappedValues<T, R>;
 //#endregion
+//#region src/core/match-by-key.d.ts
+/**
+ * Matches items from two arrays when their key values are equal.
+ *
+ * Supports either the same key on both sides or separate left/right keys.
+ *
+ * @example
+ * ```ts
+ * matchByKey(
+ *   [{ id: "1", name: "Ada" }],
+ *   [{ userId: "1", status: "active" }],
+ *   "id",
+ *   "userId",
+ * );
+ * // [{ key: "1", left: { ... }, right: { ... } }]
+ * ```
+ */
+declare function matchByKey<L extends object, R extends object, K$1 extends keyof L & keyof R>(leftItems: ReadonlyArray<L>, rightItems: ReadonlyArray<R>, key: K$1): Array<KeyMatch<Extract<L[K$1] & R[K$1], PropertyKey>, L, R>>;
+declare function matchByKey<L extends object, R extends object, LK extends keyof L, RK extends keyof R>(leftItems: ReadonlyArray<L>, rightItems: ReadonlyArray<R>, leftKey: LK, rightKey: RK): Array<KeyMatch<Extract<L[LK] & R[RK], PropertyKey>, L, R>>;
+//#endregion
+//#region src/core/merge-defaults.d.ts
+/**
+ * Recursively fills missing or `undefined` properties from a defaults object.
+ *
+ * Only plain objects are merged deeply. Arrays and other object-like values are
+ * treated as leaf values.
+ */
+declare function mergeDefaults<T extends object, D extends object>(object: T, defaultValues: D): MergeDefaulted<T, D>;
+//#endregion
 //#region src/core/omit.d.ts
 /**
  * Creates a new object excluding the selected own enumerable properties.
@@ -273,6 +366,22 @@ declare function omit<T extends object, const Keys extends readonly (keyof T)[]>
 declare function omit<T extends object, const FirstKey extends keyof T, const RestKeys extends readonly (keyof T)[]>(object: T, keys: readonly [FirstKey, ...RestKeys]): Omit<T, FirstKey | RestKeys[number]>;
 declare function omit<T extends object>(object: T, keys: readonly (keyof T)[]): Partial<T>;
 //#endregion
+//#region src/core/parse-object.d.ts
+/**
+ * Parses an unknown value as a typed object by validating it against a schema.
+ *
+ * Throws a `TypeError` when validation fails.
+ *
+ * @example
+ * ```ts
+ * const user = parseObject(payload, schema({
+ *   id: (value): value is string => typeof value === "string",
+ *   active: (value): value is boolean => typeof value === "boolean",
+ * }));
+ * ```
+ */
+declare function parseObject<const T extends ObjectSchema>(value: unknown, definition: T): InferSchema<T>;
+//#endregion
 //#region src/core/partition-object.d.ts
 /**
  * Partitions an object's own enumerable string-keyed properties into matching
@@ -415,5 +524,32 @@ declare function typedFromEntries<const T extends EntryTuples>(entries: T): Obje
  */
 declare function typedKeys<T extends object>(object: T): Array<StringKeyOf<T>>;
 //#endregion
-export { assertKeys, compactObject, filterKeys, filterValues, get, hasKeys, hasOwn, hasPath, identity, invertObject, isEmpty, isPlainObject, isPlainObject as isRecord, mapKeys, mapValues, omit, partitionObject, path, pick, renameKeys, requireKeys, set, typedEntries, typedFromEntries, typedKeys };
+//#region src/core/validate-object.d.ts
+/**
+ * Validates an unknown value against a schema of field validators.
+ *
+ * All schema keys must exist as own properties on the input object and every
+ * field validator must accept its corresponding value.
+ *
+ * @example
+ * ```ts
+ * const isUser = validateObject(
+ *   { id: "usr_1", active: true },
+ *   schema({
+ *     id: (value): value is string => typeof value === "string",
+ *     active: (value): value is boolean => typeof value === "boolean",
+ *   }),
+ * );
+ * ```
+ */
+declare function validateObject<const T extends ObjectSchema>(value: unknown, definition: T): value is InferSchema<T>;
+//#endregion
+//#region src/core/with-defaults.d.ts
+type DefaultsApplicator<D extends object> = <T extends object>(object: T) => MergeDefaulted<T, D>;
+/**
+ * Creates a reusable function that applies the provided defaults.
+ */
+declare function withDefaults<D extends object>(defaultValues: D): DefaultsApplicator<D>;
+//#endregion
+export { assertKeys, compactObject, defaults, filterKeys, filterValues, get, groupByKey, hasKeys, hasOwn, hasPath, identity, identity as schema, indexByKey, invertObject, isEmpty, isPlainObject, isPlainObject as isRecord, mapKeys, mapValues, matchByKey, mergeDefaults, omit, parseObject, partitionObject, path, pick, renameKeys, requireKeys, set, typedEntries, typedFromEntries, typedKeys, validateObject, withDefaults };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -72,6 +72,20 @@ function compactObject(object) {
 	return result;
 }
 
+//#endregion
+//#region src/core/defaults.ts
+/**
+* Creates a new object by filling missing or `undefined` properties from a
+* defaults object.
+*
+* `null`, `false`, `0`, and other defined values are preserved as-is.
+*/
+function defaults(object, defaultValues) {
+	const result = { ...object };
+	for (const key of typedKeys(defaultValues)) if (result[key] === void 0) result[key] = defaultValues[key];
+	return result;
+}
+
 //#endregion
 //#region src/core/filter-keys.ts
 function filterKeys(object, predicate) {
@@ -155,6 +169,38 @@ function get(object, pathInput, defaultValue) {
 	return current;
 }
 
+//#endregion
+//#region src/core/group-by-key.ts
+/**
+* Groups items by a property whose value can be used as an object key.
+*
+* @example
+* ```ts
+* groupByKey(
+*   [
+*     { id: "1", role: "admin" },
+*     { id: "2", role: "member" },
+*     { id: "3", role: "admin" },
+*   ],
+*   "role",
+* );
+* // { admin: [...], member: [...] }
+* ```
+*/
+function groupByKey(items, key) {
+	const result = {};
+	for (const item of items) {
+		const groupKey = item[key];
+		const existing = result[groupKey];
+		if (existing) {
+			existing.push(item);
+			continue;
+		}
+		result[groupKey] = [item];
+	}
+	return result;
+}
+
 //#endregion
 //#region src/core/has-path.ts
 /**
@@ -189,6 +235,31 @@ function identity(value) {
 	return value;
 }
 
+//#endregion
+//#region src/core/index-by-key.ts
+/**
+* Indexes items by a property whose value can be used as an object key.
+*
+* Later items overwrite earlier items with the same key.
+*
+* @example
+* ```ts
+* indexByKey(
+*   [
+*     { id: "1", name: "Ada" },
+*     { id: "2", name: "Linus" },
+*   ],
+*   "id",
+* );
+* // { 1: { ... }, 2: { ... } }
+* ```
+*/
+function indexByKey(items, key) {
+	const result = {};
+	for (const item of items) result[item[key]] = item;
+	return result;
+}
+
 //#endregion
 //#region src/core/invert-object.ts
 /**
@@ -303,6 +374,42 @@ function mapValues(object, mapper) {
 	return result;
 }
 
+//#endregion
+//#region src/core/match-by-key.ts
+function matchByKey(leftItems, rightItems, leftKey, rightKey) {
+	const rightIndex = groupByKey(rightItems, rightKey ?? leftKey);
+	const matches = [];
+	for (const left of leftItems) {
+		const key = left[leftKey];
+		const matchingRights = rightIndex[key];
+		if (!matchingRights) continue;
+		for (const right of matchingRights) matches.push({
+			key,
+			left,
+			right
+		});
+	}
+	return matches;
+}
+
+//#endregion
+//#region src/core/merge-defaults.ts
+/**
+* Recursively fills missing or `undefined` properties from a defaults object.
+*
+* Only plain objects are merged deeply. Arrays and other object-like values are
+* treated as leaf values.
+*/
+function mergeDefaults(object, defaultValues) {
+	const result = { ...object };
+	for (const key of typedKeys(defaultValues)) {
+		const value = result[key];
+		const fallback = defaultValues[key];
+		result[key] = value === void 0 ? fallback : isPlainObject(value) && isPlainObject(fallback) ? mergeDefaults(value, fallback) : value;
+	}
+	return result;
+}
+
 //#endregion
 //#region src/core/omit.ts
 function omit(object, firstKeyOrKeys, ...restKeys) {
@@ -313,6 +420,54 @@ function omit(object, firstKeyOrKeys, ...restKeys) {
 	return result;
 }
 
+//#endregion
+//#region src/core/validate-object.ts
+/**
+* Validates an unknown value against a schema of field validators.
+*
+* All schema keys must exist as own properties on the input object and every
+* field validator must accept its corresponding value.
+*
+* @example
+* ```ts
+* const isUser = validateObject(
+*   { id: "usr_1", active: true },
+*   schema({
+*     id: (value): value is string => typeof value === "string",
+*     active: (value): value is boolean => typeof value === "boolean",
+*   }),
+* );
+* ```
+*/
+function validateObject(value, definition) {
+	if (!isPlainObject(value)) return false;
+	for (const key of typedKeys(definition)) {
+		if (!hasOwn(value, key)) return false;
+		if (!definition[key](value[key])) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/core/parse-object.ts
+/**
+* Parses an unknown value as a typed object by validating it against a schema.
+*
+* Throws a `TypeError` when validation fails.
+*
+* @example
+* ```ts
+* const user = parseObject(payload, schema({
+*   id: (value): value is string => typeof value === "string",
+*   active: (value): value is boolean => typeof value === "boolean",
+* }));
+* ```
+*/
+function parseObject(value, definition) {
+	if (validateObject(value, definition)) return value;
+	throw new TypeError("Invalid object.");
+}
+
 //#endregion
 //#region src/core/partition-object.ts
 function partitionObject(object, predicate) {
@@ -437,5 +592,14 @@ function typedFromEntries(entries) {
 }
 
 //#endregion
-export { assertKeys, compactObject, filterKeys, filterValues, get, hasKeys, hasOwn, hasPath, identity, invertObject, isEmpty, isPlainObject, isPlainObject as isRecord, mapKeys, mapValues, omit, partitionObject, path, pick, renameKeys, requireKeys, set, typedEntries, typedFromEntries, typedKeys };
+//#region src/core/with-defaults.ts
+/**
+* Creates a reusable function that applies the provided defaults.
+*/
+function withDefaults(defaultValues) {
+	return (object) => mergeDefaults(object, defaultValues);
+}
+
+//#endregion
+export { assertKeys, compactObject, defaults, filterKeys, filterValues, get, groupByKey, hasKeys, hasOwn, hasPath, identity, identity as schema, indexByKey, invertObject, isEmpty, isPlainObject, isPlainObject as isRecord, mapKeys, mapValues, matchByKey, mergeDefaults, omit, parseObject, partitionObject, path, pick, renameKeys, requireKeys, set, typedEntries, typedFromEntries, typedKeys, validateObject, withDefaults };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["missingKeys: Array<keyof T>","segments: PathSegment[]","toPath","current: unknown","toPath","result: Partial<T>","result: Partial<T>","toPath"],"sources":["../src/core/has-keys.ts","../src/core/require-keys.ts","../src/core/assert-keys.ts","../src/core/typed-keys.ts","../src/core/compact-object.ts","../src/core/filter-keys.ts","../src/core/filter-values.ts","../src/core/has-own.ts","../src/core/path.ts","../src/core/get.ts","../src/core/has-path.ts","../src/core/identity.ts","../src/core/invert-object.ts","../src/core/is-empty.ts","../src/core/is-plain-object.ts","../src/core/map-keys.ts","../src/core/map-values.ts","../src/core/omit.ts","../src/core/partition-object.ts","../src/core/pick.ts","../src/core/rename-keys.ts","../src/core/set.ts","../src/core/typed-entries.ts","../src/core/typed-from-entries.ts"],"sourcesContent":["/**\n * Checks whether a plain object has all of the requested own keys.\n *\n * Prefer the rest-key form for the strongest autocomplete and inference.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", role: \"admin\" } as const;\n *\n * hasKeys(user, \"id\", \"role\"); // true\n * hasKeys(user, [\"id\", \"role\"] as const); // true\n * ```\n */\nexport function hasKeys<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tvalue: T,\n\tfirstKey: FirstKey,\n\t...restKeys: RestKeys\n): value is T & Required<Pick<T, FirstKey | RestKeys[number]>>;\nexport function hasKeys<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tvalue: T,\n\tkeys: readonly [FirstKey, ...RestKeys],\n): value is T & Required<Pick<T, FirstKey | RestKeys[number]>>;\nexport function hasKeys<T extends object>(\n\tvalue: T,\n\tkeys: readonly (keyof T)[],\n): value is T;\nexport function hasKeys<T extends object>(\n\tvalue: T,\n\tfirstKeyOrKeys: keyof T | readonly (keyof T)[],\n\t...restKeys: readonly (keyof T)[]\n): boolean {\n\tif (value === null || typeof value !== \"object\") {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\n\tif (prototype !== Object.prototype && prototype !== null) {\n\t\treturn false;\n\t}\n\n\tconst keys = Array.isArray(firstKeyOrKeys)\n\t\t? firstKeyOrKeys\n\t\t: ([firstKeyOrKeys, ...restKeys] as readonly (keyof T)[]);\n\n\tfor (const key of keys) {\n\t\tif (!Object.hasOwn(value, key)) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n","import { hasKeys } from \"./has-keys\";\n\n/**\n * Requires that a plain object has all of the requested own keys.\n *\n * Prefer the rest-key form for the strongest autocomplete and inference.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", role: \"admin\" } as const;\n * const result = requireKeys(user, \"id\", \"role\");\n *\n * result.id; // \"1\"\n * ```\n */\nexport function requireKeys<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tvalue: T,\n\tfirstKey: FirstKey,\n\t...restKeys: RestKeys\n): T & Required<Pick<T, FirstKey | RestKeys[number]>>;\nexport function requireKeys<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tvalue: T,\n\tkeys: readonly [FirstKey, ...RestKeys],\n): T & Required<Pick<T, FirstKey | RestKeys[number]>>;\nexport function requireKeys<T extends object>(\n\tvalue: T,\n\tkeys: readonly (keyof T)[],\n): T;\nexport function requireKeys<T extends object>(\n\tvalue: T,\n\tfirstKeyOrKeys: keyof T | readonly (keyof T)[],\n\t...restKeys: readonly (keyof T)[]\n): T {\n\tconst keys = Array.isArray(firstKeyOrKeys)\n\t\t? firstKeyOrKeys\n\t\t: ([firstKeyOrKeys, ...restKeys] as readonly (keyof T)[]);\n\n\tif (hasKeys(value, keys)) {\n\t\treturn value;\n\t}\n\n\tconst missingKeys: Array<keyof T> = [];\n\n\tif (value !== null && typeof value === \"object\") {\n\t\tconst prototype = Object.getPrototypeOf(value);\n\n\t\tif (prototype === Object.prototype || prototype === null) {\n\t\t\tfor (const key of keys) {\n\t\t\t\tif (!Object.hasOwn(value, key)) {\n\t\t\t\t\tmissingKeys.push(key);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tif (missingKeys.length === 0) {\n\t\tmissingKeys.push(...keys);\n\t}\n\n\tconst label = missingKeys.length === 1 ? \"key\" : \"keys\";\n\n\tthrow new TypeError(\n\t\t`Missing required ${label}: ${missingKeys.map(String).join(\", \")}`,\n\t);\n}\n","import { requireKeys } from \"./require-keys\";\n\n/**\n * Asserts that a plain object has all of the requested own keys.\n *\n * Prefer the rest-key form for the strongest autocomplete and inference.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", role: \"admin\" } as const;\n *\n * assertKeys(user, \"id\", \"role\");\n * user.id; // \"1\"\n * ```\n */\nexport function assertKeys<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tvalue: T,\n\tfirstKey: FirstKey,\n\t...restKeys: RestKeys\n): asserts value is T & Required<Pick<T, FirstKey | RestKeys[number]>>;\nexport function assertKeys<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tvalue: T,\n\tkeys: readonly [FirstKey, ...RestKeys],\n): asserts value is T & Required<Pick<T, FirstKey | RestKeys[number]>>;\nexport function assertKeys<T extends object>(\n\tvalue: T,\n\tkeys: readonly (keyof T)[],\n): asserts value is T;\nexport function assertKeys<T extends object>(\n\tvalue: T,\n\tfirstKeyOrKeys: keyof T | readonly (keyof T)[],\n\t...restKeys: readonly (keyof T)[]\n): void {\n\trequireKeys(value, firstKeyOrKeys as keyof T, ...restKeys);\n}\n","import type { StringKeyOf } from \"./types\";\n\n/**\n * Returns the own enumerable string keys of an object with preserved key types.\n *\n * This is a typed wrapper around `Object.keys`.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", name: \"Umsizi\" } as const;\n *\n * typedKeys(user); // [\"id\", \"name\"]\n * ```\n */\nexport function typedKeys<T extends object>(object: T): Array<StringKeyOf<T>> {\n\treturn Object.keys(object) as Array<StringKeyOf<T>>;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { CompactedObject } from \"./types\";\n\n/**\n * Creates a new object with all `null` and `undefined` values removed.\n *\n * Other falsy values such as `0`, `false`, `\"\"`, and `NaN` are preserved.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", nickname: null, active: false } as const;\n *\n * compactObject(user); // { id: \"1\", active: false }\n * ```\n */\nexport function compactObject<T extends object>(object: T): CompactedObject<T> {\n\tconst result = {} as CompactedObject<T>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tconst value = object[key];\n\n\t\tif (value != null) {\n\t\t\tresult[key] = value as Exclude<T[typeof key], null | undefined>;\n\t\t}\n\t}\n\n\treturn result;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { FilteredKeys, KeyGuard, KeyPredicate } from \"./types\";\n\n/**\n * Filters an object's own enumerable string-keyed properties by key.\n *\n * Supports both boolean predicates and key type guards. The result remains\n * partial because any property may be removed at runtime.\n *\n * @example\n * ```ts\n * const metrics = { total: 5, temp_cache: 2, temp_jobs: 1 } as const;\n *\n * filterKeys(metrics, (key) => key.startsWith(\"temp_\"));\n * // { temp_cache: 2, temp_jobs: 1 }\n * ```\n */\nexport function filterKeys<\n\tT extends object,\n\tS extends Extract<keyof T, string>,\n>(object: T, predicate: KeyGuard<T, S>): FilteredKeys<T, S>;\nexport function filterKeys<T extends object>(\n\tobject: T,\n\tpredicate: KeyPredicate<T>,\n): FilteredKeys<T, Extract<keyof T, string>>;\nexport function filterKeys<T extends object>(\n\tobject: T,\n\tpredicate: KeyPredicate<T>,\n): FilteredKeys<T, Extract<keyof T, string>> {\n\tconst result = {} as FilteredKeys<T, Extract<keyof T, string>>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tif (predicate(key, object[key], object)) {\n\t\t\tresult[key] = object[key];\n\t\t}\n\t}\n\n\treturn result;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { FilteredValues, ValueGuard, ValuePredicate } from \"./types\";\n\n/**\n * Filters an object's own enumerable string-keyed properties by value.\n *\n * Supports both boolean predicates and type-guard predicates. The result type\n * remains partial because any property may be removed at runtime.\n *\n * @example\n * ```ts\n * const settings = { retries: 3, label: \"\", timeout: null } as const;\n *\n * filterValues(settings, (value) => value !== null);\n * // { retries: 3, label: \"\" }\n * ```\n */\nexport function filterValues<\n\tT extends object,\n\tS extends T[Extract<keyof T, string>],\n>(object: T, predicate: ValueGuard<T, S>): FilteredValues<T, S>;\nexport function filterValues<T extends object>(\n\tobject: T,\n\tpredicate: ValuePredicate<T>,\n): FilteredValues<T, T[Extract<keyof T, string>]>;\nexport function filterValues<T extends object>(\n\tobject: T,\n\tpredicate: ValuePredicate<T>,\n): FilteredValues<T, T[Extract<keyof T, string>]> {\n\tconst result = {} as FilteredValues<T, T[Extract<keyof T, string>]>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tconst value = object[key];\n\n\t\tif (predicate(value, key, object)) {\n\t\t\tresult[key] = value;\n\t\t}\n\t}\n\n\treturn result;\n}\n","/**\n * Checks whether an object has the given property as its own key.\n *\n * This is a typed wrapper around `Object.hasOwn` that narrows the provided key\n * when the check succeeds.\n *\n * @example\n * ```ts\n * const user = { id: \"1\" };\n * const key: string = \"id\";\n *\n * if (hasOwn(user, key)) {\n *   user[key]; // key is narrowed to \"id\"\n * }\n * ```\n */\nexport function hasOwn<T extends object, K extends PropertyKey>(\n\tobject: T,\n\tkey: K,\n): key is Extract<K, keyof T> {\n\treturn Object.hasOwn(object, key);\n}\n","import type { ObjectPath, PathInput, PathSegment } from \"./types\";\n\nconst BRACKET_PATH_SEGMENT_PATTERN =\n\t/[^.[\\]]+|\\[(?:([^\"'[\\]]+)|([\"'])(.*?)\\2)\\]/g;\n\nfunction toPathSegment(value: string): PathSegment {\n\treturn /^\\d+$/.test(value) ? Number(value) : value;\n}\n\n/**\n * Converts dot/bracket notation into a normalized object path array.\n *\n * @example\n * ```ts\n * path(\"profile.addresses[0].city\");\n * // [\"profile\", \"addresses\", 0, \"city\"]\n * ```\n */\nexport function path(input: PathInput): ObjectPath {\n\tif (typeof input !== \"string\") {\n\t\treturn [...input];\n\t}\n\n\tconst source = input;\n\tconst segments: PathSegment[] = [];\n\n\tfor (const match of source.matchAll(BRACKET_PATH_SEGMENT_PATTERN)) {\n\t\tconst [, bareSegment, , quotedSegment] = match;\n\t\tconst segment = quotedSegment ?? bareSegment ?? match[0];\n\n\t\tif (segment !== \"\") {\n\t\t\tsegments.push(toPathSegment(segment));\n\t\t}\n\t}\n\n\treturn segments;\n}\n","import { hasOwn } from \"./has-own\";\nimport { path as toPath } from \"./path\";\nimport type { ObjectPath, PathInput, PathValue } from \"./types\";\n\nfunction hasMissingPathSegment(\n\tvalue: unknown,\n\tsegment: string | number,\n): boolean {\n\treturn (\n\t\tvalue === null ||\n\t\tvalue === undefined ||\n\t\t(typeof value !== \"object\" && typeof value !== \"function\") ||\n\t\t!hasOwn(value, segment)\n\t);\n}\n\n/**\n * Reads a nested own property using a tuple path or dot/bracket notation.\n *\n * @example\n * ```ts\n * const user = { profile: { addresses: [{ city: \"Durban\" }] } } as const;\n *\n * get(user, [\"profile\", \"addresses\", 0, \"city\"]);\n * get(user, \"profile.addresses[0].city\");\n * ```\n */\nexport function get<T, const P extends ObjectPath>(\n\tobject: T,\n\tpath: P,\n): PathValue<T, P> | undefined;\nexport function get<T, const P extends ObjectPath, D>(\n\tobject: T,\n\tpath: P,\n\tdefaultValue: D,\n): Exclude<PathValue<T, P>, undefined> | D;\nexport function get<T>(object: T, path: string): unknown;\nexport function get<T, D>(\n\tobject: T,\n\tpath: string,\n\tdefaultValue: D,\n): D | unknown;\nexport function get<T, D>(\n\tobject: T,\n\tpathInput: PathInput,\n\tdefaultValue?: D,\n): D | unknown {\n\tconst segments = toPath(pathInput);\n\tlet current: unknown = object;\n\n\tfor (const segment of segments) {\n\t\tif (hasMissingPathSegment(current, segment)) {\n\t\t\treturn defaultValue;\n\t\t}\n\n\t\tcurrent = (current as Record<string | number, unknown>)[segment];\n\t}\n\n\treturn current;\n}\n","import { hasOwn } from \"./has-own\";\nimport { path as toPath } from \"./path\";\nimport type { PathInput } from \"./types\";\n\n/**\n * Checks whether a nested own-property path exists.\n *\n * A resolved `undefined` value still counts as existing as long as every\n * segment is present as an own property.\n */\nexport function hasPath(object: unknown, pathInput: PathInput): boolean {\n\tlet current = object;\n\n\tfor (const segment of toPath(pathInput)) {\n\t\tif (\n\t\t\tcurrent === null ||\n\t\t\tcurrent === undefined ||\n\t\t\t(typeof current !== \"object\" && typeof current !== \"function\") ||\n\t\t\t!hasOwn(current, segment)\n\t\t) {\n\t\t\treturn false;\n\t\t}\n\n\t\tcurrent = (current as Record<string | number, unknown>)[segment];\n\t}\n\n\treturn true;\n}\n","/**\n * Returns the given value unchanged.\n *\n * Useful as a default callback, a type-inference anchor, or a no-op\n * placeholder where a transform function is expected.\n *\n * @example\n * ```ts\n * identity(\"umsizi\"); // \"umsizi\"\n * ```\n */\nexport function identity<T>(value: T): T {\n\treturn value;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { InvertedObject } from \"./types\";\n\n/**\n * Inverts an object's own enumerable string-keyed properties.\n *\n * Source values must be valid property keys. When multiple source keys share\n * the same value, the later assignment wins.\n *\n * @example\n * ```ts\n * const roles = { admin: \"A\", member: \"M\" } as const;\n *\n * invertObject(roles);\n * // { A: \"admin\", M: \"member\" }\n * ```\n */\nexport function invertObject<T extends Record<string, PropertyKey>>(\n\tobject: T,\n): InvertedObject<T> {\n\tconst result = {} as InvertedObject<T>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tconst value = object[key] as PropertyKey;\n\n\t\t(result as Record<PropertyKey, string>)[value] = key;\n\t}\n\n\treturn result;\n}\n","/**\n * Returns `true` when an object has no own enumerable properties.\n *\n * Both string keys and symbol keys are considered. Non-enumerable properties\n * are ignored.\n *\n * @example\n * ```ts\n * isEmpty({}); // true\n * isEmpty({ id: \"1\" }); // false\n * ```\n */\nexport function isEmpty(object: object): boolean {\n\tif (Object.keys(object).length > 0) {\n\t\treturn false;\n\t}\n\n\tfor (const key of Object.getOwnPropertySymbols(object)) {\n\t\tif (Object.prototype.propertyIsEnumerable.call(object, key)) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n","/**\n * Checks whether a value is a plain object with a prototype of\n * `Object.prototype` or `null`.\n *\n * Arrays, functions, boxed primitives, dates, maps, sets, and class instances\n * all return `false`.\n *\n * @example\n * ```ts\n * const payload: unknown = { id: \"1\" };\n *\n * if (isPlainObject(payload)) {\n * \tpayload.id;\n * }\n * ```\n */\nexport function isPlainObject(\n\tvalue: unknown,\n): value is Record<PropertyKey, unknown> {\n\tif (value === null || typeof value !== \"object\") {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\n\treturn prototype === Object.prototype || prototype === null;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { KeyMapper, MappedKeys } from \"./types\";\n\n/**\n * Maps an object's own enumerable string keys to new string keys.\n *\n * When multiple source keys map to the same target key, the later assignment\n * wins.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", active: true } as const;\n *\n * mapKeys(user, (key) => `user_${key}`);\n * // { user_id: \"1\", user_active: true }\n * ```\n */\nexport function mapKeys<T extends object, R extends string>(\n\tobject: T,\n\tmapper: KeyMapper<T, R>,\n): MappedKeys<T, R> {\n\tconst result = {} as MappedKeys<T, R>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tconst mappedKey = mapper(key, object[key], object);\n\n\t\tresult[mappedKey] = object[key];\n\t}\n\n\treturn result;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { MappedValues, ValueMapper } from \"./types\";\n\n/**\n * Maps the values of an object's own enumerable string-keyed properties while\n * preserving the original enumerable string-key set.\n *\n * @example\n * ```ts\n * const counts = { draft: 1, published: 2 };\n *\n * mapValues(counts, (value) => value * 2);\n * // { draft: 2, published: 4 }\n * ```\n */\nexport function mapValues<T extends object, R>(\n\tobject: T,\n\tmapper: ValueMapper<T, R>,\n): MappedValues<T, R> {\n\tconst result = {} as MappedValues<T, R>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tresult[key] = mapper(object[key], key, object);\n\t}\n\n\treturn result;\n}\n","/**\n * Creates a new object excluding the selected own enumerable properties.\n *\n * Prefer the rest-key form for the strongest autocomplete and inference.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", name: \"Umsizi\", role: \"admin\" } as const;\n *\n * omit(user, \"id\", \"name\"); // { role: \"admin\" }\n * omit(user, [\"role\"] as const); // { id: \"1\", name: \"Umsizi\" }\n * ```\n */\nexport function omit<T extends object, const Keys extends readonly (keyof T)[]>(\n\tobject: T,\n\t...keys: Keys\n): Omit<T, Keys[number]>;\nexport function omit<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tobject: T,\n\tkeys: readonly [FirstKey, ...RestKeys],\n): Omit<T, FirstKey | RestKeys[number]>;\nexport function omit<T extends object>(\n\tobject: T,\n\tkeys: readonly (keyof T)[],\n): Partial<T>;\nexport function omit<T extends object>(\n\tobject: T,\n\tfirstKeyOrKeys: keyof T | readonly (keyof T)[],\n\t...restKeys: readonly (keyof T)[]\n): Partial<T> {\n\tconst keys = (\n\t\tArray.isArray(firstKeyOrKeys)\n\t\t\t? firstKeyOrKeys\n\t\t\t: [firstKeyOrKeys, ...restKeys]\n\t) as readonly (keyof T)[];\n\tconst omittedKeys = new Set<PropertyKey>(keys as readonly PropertyKey[]);\n\tconst result: Partial<T> = {};\n\n\tfor (const key of Reflect.ownKeys(object) as (keyof T)[]) {\n\t\tif (\n\t\t\tObject.prototype.propertyIsEnumerable.call(object, key) &&\n\t\t\t!omittedKeys.has(key)\n\t\t) {\n\t\t\t(result as T)[key] = object[key];\n\t\t}\n\t}\n\n\treturn result;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type {\n\tPartitionedObject,\n\tPartitionedValues,\n\tValueGuard,\n\tValuePredicate,\n} from \"./types\";\n\n/**\n * Partitions an object's own enumerable string-keyed properties into matching\n * and non-matching objects.\n *\n * Supports both boolean predicates and type-guard predicates.\n *\n * @example\n * ```ts\n * const settings = { retries: 3, label: \"ok\", timeout: null } as const;\n *\n * partitionObject(settings, (value) => value !== null);\n * // [{ retries: 3, label: \"ok\" }, { timeout: null }]\n * ```\n */\nexport function partitionObject<\n\tT extends object,\n\tS extends T[Extract<keyof T, string>],\n>(object: T, predicate: ValueGuard<T, S>): PartitionedValues<T, S>;\nexport function partitionObject<T extends object>(\n\tobject: T,\n\tpredicate: ValuePredicate<T>,\n): PartitionedObject<T>;\nexport function partitionObject<T extends object>(\n\tobject: T,\n\tpredicate: ValuePredicate<T>,\n): PartitionedObject<T> {\n\tconst matching = {} as PartitionedObject<T>[0];\n\tconst rest = {} as PartitionedObject<T>[1];\n\n\tfor (const key of typedKeys(object)) {\n\t\tconst value = object[key];\n\n\t\tif (predicate(value, key, object)) {\n\t\t\t(matching as Record<string, T[Extract<keyof T, string>]>)[key] = value;\n\t\t\tcontinue;\n\t\t}\n\n\t\t(rest as Record<string, T[Extract<keyof T, string>]>)[key] = value;\n\t}\n\n\treturn [matching, rest];\n}\n","import { hasOwn } from \"./has-own\";\n\n/**\n * Creates a new object containing only the selected own properties.\n *\n * Prefer the rest-key form for the strongest autocomplete and inference.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", name: \"Umsizi\", role: \"admin\" } as const;\n *\n * pick(user, \"name\"); // { name: \"Umsizi\" }\n * pick(user, [\"id\", \"role\"] as const); // { id: \"1\", role: \"admin\" }\n * ```\n */\nexport function pick<T extends object, const Keys extends readonly (keyof T)[]>(\n\tobject: T,\n\t...keys: Keys\n): Pick<T, Keys[number]>;\nexport function pick<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tobject: T,\n\tkeys: readonly [FirstKey, ...RestKeys],\n): Pick<T, FirstKey | RestKeys[number]>;\nexport function pick<T extends object>(\n\tobject: T,\n\tkeys: readonly (keyof T)[],\n): Partial<T>;\nexport function pick<T extends object>(\n\tobject: T,\n\tfirstKeyOrKeys: keyof T | readonly (keyof T)[],\n\t...restKeys: readonly (keyof T)[]\n): Partial<T> {\n\tconst keys = (\n\t\tArray.isArray(firstKeyOrKeys)\n\t\t\t? firstKeyOrKeys\n\t\t\t: [firstKeyOrKeys, ...restKeys]\n\t) as readonly (keyof T)[];\n\tconst result: Partial<T> = {};\n\n\tfor (const key of keys) {\n\t\tif (hasOwn(object, key)) {\n\t\t\tresult[key] = object[key];\n\t\t}\n\t}\n\n\treturn result;\n}\n","import { hasOwn } from \"./has-own\";\nimport { typedKeys } from \"./typed-keys\";\nimport type { RenamedKeys } from \"./types\";\n\n/**\n * Renames selected own enumerable string-keyed properties using a key map.\n *\n * Unmapped keys are copied through unchanged. When multiple source keys resolve\n * to the same target key, the later assignment wins.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", givenName: \"Umsizi\" } as const;\n *\n * renameKeys(user, { givenName: \"name\" });\n * // { id: \"1\", name: \"Umsizi\" }\n * ```\n */\nexport function renameKeys<\n\tT extends object,\n\tconst M extends Partial<Record<Extract<keyof T, string>, string>>,\n>(object: T, names: M): RenamedKeys<T, M> {\n\tconst result = {} as RenamedKeys<T, M>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tconst renamedKey = (hasOwn(names, key) ? names[key] : key) as string;\n\n\t\t(result as Record<string, T[Extract<keyof T, string>]>)[renamedKey] =\n\t\t\tobject[key];\n\t}\n\n\treturn result;\n}\n","import { path as toPath } from \"./path\";\nimport type { PathInput, PathSegment } from \"./types\";\n\nfunction isContainer(value: unknown): value is object {\n\treturn typeof value === \"object\" && value !== null;\n}\n\nfunction createContainer(\n\tnextSegment: PathSegment | undefined,\n): unknown[] | Record<string, unknown> {\n\treturn typeof nextSegment === \"number\" ? [] : {};\n}\n\nfunction cloneContainer(value: unknown, nextSegment: PathSegment | undefined) {\n\tif (Array.isArray(value)) {\n\t\treturn [...value];\n\t}\n\n\tif (isContainer(value)) {\n\t\treturn Object.assign(\n\t\t\tObject.create(Object.getPrototypeOf(value)),\n\t\t\tvalue,\n\t\t) as Record<string | number, unknown>;\n\t}\n\n\treturn createContainer(nextSegment);\n}\n\nfunction setAtPath(\n\tcurrent: unknown,\n\tsegments: readonly PathSegment[],\n\tvalue: unknown,\n): unknown {\n\tconst [segment, ...rest] = segments as readonly [\n\t\tPathSegment,\n\t\t...PathSegment[],\n\t];\n\n\tconst clone = cloneContainer(current, segment) as Record<\n\t\tPropertyKey,\n\t\tunknown\n\t>;\n\tconst existingValue =\n\t\tisContainer(current) || Array.isArray(current)\n\t\t\t? (current as Record<string | number, unknown>)[segment]\n\t\t\t: undefined;\n\n\tclone[segment] =\n\t\trest.length === 0 ? value : setAtPath(existingValue, rest, value);\n\n\treturn clone;\n}\n\n/**\n * Returns a new object with the nested path set to the given value.\n *\n * Missing containers are created automatically. Only the updated path is\n * cloned; untouched branches retain their existing references.\n */\nexport function set<T extends object>(\n\tobject: T,\n\tpathInput: PathInput,\n\tvalue: unknown,\n): T {\n\tconst segments = toPath(pathInput);\n\n\tif (segments.length === 0) {\n\t\treturn object;\n\t}\n\n\treturn setAtPath(object, segments, value) as T;\n}\n","import type { ObjectEntries } from \"./types\";\n\n/**\n * Returns the own enumerable string-keyed entries of an object with preserved\n * key/value pairing.\n *\n * This is a typed wrapper around `Object.entries`.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", active: true } as const;\n *\n * typedEntries(user); // [[\"id\", \"1\"], [\"active\", true]]\n * ```\n */\nexport function typedEntries<T extends object>(object: T): ObjectEntries<T> {\n\treturn Object.entries(object) as unknown as ObjectEntries<T>;\n}\n","import type { EntryTuples, ObjectFromEntries } from \"./types\";\n\n/**\n * Creates an object from entries while preserving the key and value types from\n * the input tuple array.\n *\n * This is a typed wrapper around `Object.fromEntries`.\n *\n * @example\n * ```ts\n * const status = typedFromEntries([\n *   [\"id\", \"1\"],\n *   [\"active\", true],\n * ] as const);\n *\n * // inferred as: { id: \"1\"; active: true }\n * ```\n */\nexport function typedFromEntries<const T extends EntryTuples>(\n\tentries: T,\n): ObjectFromEntries<T> {\n\treturn Object.fromEntries(entries) as ObjectFromEntries<T>;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["missingKeys: Array<keyof T>","segments: PathSegment[]","toPath","current: unknown","toPath","matches: Array<KeyMatch<PropertyKey, L, R>>","result: Partial<T>","isRecord","result: Partial<T>","toPath"],"sources":["../src/core/has-keys.ts","../src/core/require-keys.ts","../src/core/assert-keys.ts","../src/core/typed-keys.ts","../src/core/compact-object.ts","../src/core/defaults.ts","../src/core/filter-keys.ts","../src/core/filter-values.ts","../src/core/has-own.ts","../src/core/path.ts","../src/core/get.ts","../src/core/group-by-key.ts","../src/core/has-path.ts","../src/core/identity.ts","../src/core/index-by-key.ts","../src/core/invert-object.ts","../src/core/is-empty.ts","../src/core/is-plain-object.ts","../src/core/map-keys.ts","../src/core/map-values.ts","../src/core/match-by-key.ts","../src/core/merge-defaults.ts","../src/core/omit.ts","../src/core/validate-object.ts","../src/core/parse-object.ts","../src/core/partition-object.ts","../src/core/pick.ts","../src/core/rename-keys.ts","../src/core/set.ts","../src/core/typed-entries.ts","../src/core/typed-from-entries.ts","../src/core/with-defaults.ts"],"sourcesContent":["/**\n * Checks whether a plain object has all of the requested own keys.\n *\n * Prefer the rest-key form for the strongest autocomplete and inference.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", role: \"admin\" } as const;\n *\n * hasKeys(user, \"id\", \"role\"); // true\n * hasKeys(user, [\"id\", \"role\"] as const); // true\n * ```\n */\nexport function hasKeys<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tvalue: T,\n\tfirstKey: FirstKey,\n\t...restKeys: RestKeys\n): value is T & Required<Pick<T, FirstKey | RestKeys[number]>>;\nexport function hasKeys<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tvalue: T,\n\tkeys: readonly [FirstKey, ...RestKeys],\n): value is T & Required<Pick<T, FirstKey | RestKeys[number]>>;\nexport function hasKeys<T extends object>(\n\tvalue: T,\n\tkeys: readonly (keyof T)[],\n): value is T;\nexport function hasKeys<T extends object>(\n\tvalue: T,\n\tfirstKeyOrKeys: keyof T | readonly (keyof T)[],\n\t...restKeys: readonly (keyof T)[]\n): boolean {\n\tif (value === null || typeof value !== \"object\") {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\n\tif (prototype !== Object.prototype && prototype !== null) {\n\t\treturn false;\n\t}\n\n\tconst keys = Array.isArray(firstKeyOrKeys)\n\t\t? firstKeyOrKeys\n\t\t: ([firstKeyOrKeys, ...restKeys] as readonly (keyof T)[]);\n\n\tfor (const key of keys) {\n\t\tif (!Object.hasOwn(value, key)) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n","import { hasKeys } from \"./has-keys\";\n\n/**\n * Requires that a plain object has all of the requested own keys.\n *\n * Prefer the rest-key form for the strongest autocomplete and inference.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", role: \"admin\" } as const;\n * const result = requireKeys(user, \"id\", \"role\");\n *\n * result.id; // \"1\"\n * ```\n */\nexport function requireKeys<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tvalue: T,\n\tfirstKey: FirstKey,\n\t...restKeys: RestKeys\n): T & Required<Pick<T, FirstKey | RestKeys[number]>>;\nexport function requireKeys<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tvalue: T,\n\tkeys: readonly [FirstKey, ...RestKeys],\n): T & Required<Pick<T, FirstKey | RestKeys[number]>>;\nexport function requireKeys<T extends object>(\n\tvalue: T,\n\tkeys: readonly (keyof T)[],\n): T;\nexport function requireKeys<T extends object>(\n\tvalue: T,\n\tfirstKeyOrKeys: keyof T | readonly (keyof T)[],\n\t...restKeys: readonly (keyof T)[]\n): T {\n\tconst keys = Array.isArray(firstKeyOrKeys)\n\t\t? firstKeyOrKeys\n\t\t: ([firstKeyOrKeys, ...restKeys] as readonly (keyof T)[]);\n\n\tif (hasKeys(value, keys)) {\n\t\treturn value;\n\t}\n\n\tconst missingKeys: Array<keyof T> = [];\n\n\tif (value !== null && typeof value === \"object\") {\n\t\tconst prototype = Object.getPrototypeOf(value);\n\n\t\tif (prototype === Object.prototype || prototype === null) {\n\t\t\tfor (const key of keys) {\n\t\t\t\tif (!Object.hasOwn(value, key)) {\n\t\t\t\t\tmissingKeys.push(key);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tif (missingKeys.length === 0) {\n\t\tmissingKeys.push(...keys);\n\t}\n\n\tconst label = missingKeys.length === 1 ? \"key\" : \"keys\";\n\n\tthrow new TypeError(\n\t\t`Missing required ${label}: ${missingKeys.map(String).join(\", \")}`,\n\t);\n}\n","import { requireKeys } from \"./require-keys\";\n\n/**\n * Asserts that a plain object has all of the requested own keys.\n *\n * Prefer the rest-key form for the strongest autocomplete and inference.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", role: \"admin\" } as const;\n *\n * assertKeys(user, \"id\", \"role\");\n * user.id; // \"1\"\n * ```\n */\nexport function assertKeys<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tvalue: T,\n\tfirstKey: FirstKey,\n\t...restKeys: RestKeys\n): asserts value is T & Required<Pick<T, FirstKey | RestKeys[number]>>;\nexport function assertKeys<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tvalue: T,\n\tkeys: readonly [FirstKey, ...RestKeys],\n): asserts value is T & Required<Pick<T, FirstKey | RestKeys[number]>>;\nexport function assertKeys<T extends object>(\n\tvalue: T,\n\tkeys: readonly (keyof T)[],\n): asserts value is T;\nexport function assertKeys<T extends object>(\n\tvalue: T,\n\tfirstKeyOrKeys: keyof T | readonly (keyof T)[],\n\t...restKeys: readonly (keyof T)[]\n): void {\n\trequireKeys(value, firstKeyOrKeys as keyof T, ...restKeys);\n}\n","import type { StringKeyOf } from \"./types\";\n\n/**\n * Returns the own enumerable string keys of an object with preserved key types.\n *\n * This is a typed wrapper around `Object.keys`.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", name: \"Umsizi\" } as const;\n *\n * typedKeys(user); // [\"id\", \"name\"]\n * ```\n */\nexport function typedKeys<T extends object>(object: T): Array<StringKeyOf<T>> {\n\treturn Object.keys(object) as Array<StringKeyOf<T>>;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { CompactedObject } from \"./types\";\n\n/**\n * Creates a new object with all `null` and `undefined` values removed.\n *\n * Other falsy values such as `0`, `false`, `\"\"`, and `NaN` are preserved.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", nickname: null, active: false } as const;\n *\n * compactObject(user); // { id: \"1\", active: false }\n * ```\n */\nexport function compactObject<T extends object>(object: T): CompactedObject<T> {\n\tconst result = {} as CompactedObject<T>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tconst value = object[key];\n\n\t\tif (value != null) {\n\t\t\tresult[key] = value as Exclude<T[typeof key], null | undefined>;\n\t\t}\n\t}\n\n\treturn result;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { Defaulted } from \"./types\";\n\n/**\n * Creates a new object by filling missing or `undefined` properties from a\n * defaults object.\n *\n * `null`, `false`, `0`, and other defined values are preserved as-is.\n */\nexport function defaults<T extends object, D extends object>(\n\tobject: T,\n\tdefaultValues: D,\n): Defaulted<T, D> {\n\tconst result = { ...object } as Record<string, unknown>;\n\n\tfor (const key of typedKeys(defaultValues)) {\n\t\tif (result[key] === undefined) {\n\t\t\tresult[key] = defaultValues[key];\n\t\t}\n\t}\n\n\treturn result as Defaulted<T, D>;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { FilteredKeys, KeyGuard, KeyPredicate } from \"./types\";\n\n/**\n * Filters an object's own enumerable string-keyed properties by key.\n *\n * Supports both boolean predicates and key type guards. The result remains\n * partial because any property may be removed at runtime.\n *\n * @example\n * ```ts\n * const metrics = { total: 5, temp_cache: 2, temp_jobs: 1 } as const;\n *\n * filterKeys(metrics, (key) => key.startsWith(\"temp_\"));\n * // { temp_cache: 2, temp_jobs: 1 }\n * ```\n */\nexport function filterKeys<\n\tT extends object,\n\tS extends Extract<keyof T, string>,\n>(object: T, predicate: KeyGuard<T, S>): FilteredKeys<T, S>;\nexport function filterKeys<T extends object>(\n\tobject: T,\n\tpredicate: KeyPredicate<T>,\n): FilteredKeys<T, Extract<keyof T, string>>;\nexport function filterKeys<T extends object>(\n\tobject: T,\n\tpredicate: KeyPredicate<T>,\n): FilteredKeys<T, Extract<keyof T, string>> {\n\tconst result = {} as FilteredKeys<T, Extract<keyof T, string>>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tif (predicate(key, object[key], object)) {\n\t\t\tresult[key] = object[key];\n\t\t}\n\t}\n\n\treturn result;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { FilteredValues, ValueGuard, ValuePredicate } from \"./types\";\n\n/**\n * Filters an object's own enumerable string-keyed properties by value.\n *\n * Supports both boolean predicates and type-guard predicates. The result type\n * remains partial because any property may be removed at runtime.\n *\n * @example\n * ```ts\n * const settings = { retries: 3, label: \"\", timeout: null } as const;\n *\n * filterValues(settings, (value) => value !== null);\n * // { retries: 3, label: \"\" }\n * ```\n */\nexport function filterValues<\n\tT extends object,\n\tS extends T[Extract<keyof T, string>],\n>(object: T, predicate: ValueGuard<T, S>): FilteredValues<T, S>;\nexport function filterValues<T extends object>(\n\tobject: T,\n\tpredicate: ValuePredicate<T>,\n): FilteredValues<T, T[Extract<keyof T, string>]>;\nexport function filterValues<T extends object>(\n\tobject: T,\n\tpredicate: ValuePredicate<T>,\n): FilteredValues<T, T[Extract<keyof T, string>]> {\n\tconst result = {} as FilteredValues<T, T[Extract<keyof T, string>]>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tconst value = object[key];\n\n\t\tif (predicate(value, key, object)) {\n\t\t\tresult[key] = value;\n\t\t}\n\t}\n\n\treturn result;\n}\n","/**\n * Checks whether an object has the given property as its own key.\n *\n * This is a typed wrapper around `Object.hasOwn` that narrows the provided key\n * when the check succeeds.\n *\n * @example\n * ```ts\n * const user = { id: \"1\" };\n * const key: string = \"id\";\n *\n * if (hasOwn(user, key)) {\n *   user[key]; // key is narrowed to \"id\"\n * }\n * ```\n */\nexport function hasOwn<T extends object, K extends PropertyKey>(\n\tobject: T,\n\tkey: K,\n): key is Extract<K, keyof T> {\n\treturn Object.hasOwn(object, key);\n}\n","import type { ObjectPath, PathInput, PathSegment } from \"./types\";\n\nconst BRACKET_PATH_SEGMENT_PATTERN =\n\t/[^.[\\]]+|\\[(?:([^\"'[\\]]+)|([\"'])(.*?)\\2)\\]/g;\n\nfunction toPathSegment(value: string): PathSegment {\n\treturn /^\\d+$/.test(value) ? Number(value) : value;\n}\n\n/**\n * Converts dot/bracket notation into a normalized object path array.\n *\n * @example\n * ```ts\n * path(\"profile.addresses[0].city\");\n * // [\"profile\", \"addresses\", 0, \"city\"]\n * ```\n */\nexport function path(input: PathInput): ObjectPath {\n\tif (typeof input !== \"string\") {\n\t\treturn [...input];\n\t}\n\n\tconst source = input;\n\tconst segments: PathSegment[] = [];\n\n\tfor (const match of source.matchAll(BRACKET_PATH_SEGMENT_PATTERN)) {\n\t\tconst [, bareSegment, , quotedSegment] = match;\n\t\tconst segment = quotedSegment ?? bareSegment ?? match[0];\n\n\t\tif (segment !== \"\") {\n\t\t\tsegments.push(toPathSegment(segment));\n\t\t}\n\t}\n\n\treturn segments;\n}\n","import { hasOwn } from \"./has-own\";\nimport { path as toPath } from \"./path\";\nimport type { ObjectPath, PathInput, PathValue } from \"./types\";\n\nfunction hasMissingPathSegment(\n\tvalue: unknown,\n\tsegment: string | number,\n): boolean {\n\treturn (\n\t\tvalue === null ||\n\t\tvalue === undefined ||\n\t\t(typeof value !== \"object\" && typeof value !== \"function\") ||\n\t\t!hasOwn(value, segment)\n\t);\n}\n\n/**\n * Reads a nested own property using a tuple path or dot/bracket notation.\n *\n * @example\n * ```ts\n * const user = { profile: { addresses: [{ city: \"Durban\" }] } } as const;\n *\n * get(user, [\"profile\", \"addresses\", 0, \"city\"]);\n * get(user, \"profile.addresses[0].city\");\n * ```\n */\nexport function get<T, const P extends ObjectPath>(\n\tobject: T,\n\tpath: P,\n): PathValue<T, P> | undefined;\nexport function get<T, const P extends ObjectPath, D>(\n\tobject: T,\n\tpath: P,\n\tdefaultValue: D,\n): Exclude<PathValue<T, P>, undefined> | D;\nexport function get<T>(object: T, path: string): unknown;\nexport function get<T, D>(\n\tobject: T,\n\tpath: string,\n\tdefaultValue: D,\n): D | unknown;\nexport function get<T, D>(\n\tobject: T,\n\tpathInput: PathInput,\n\tdefaultValue?: D,\n): D | unknown {\n\tconst segments = toPath(pathInput);\n\tlet current: unknown = object;\n\n\tfor (const segment of segments) {\n\t\tif (hasMissingPathSegment(current, segment)) {\n\t\t\treturn defaultValue;\n\t\t}\n\n\t\tcurrent = (current as Record<string | number, unknown>)[segment];\n\t}\n\n\treturn current;\n}\n","import type { GroupedByKey } from \"./types\";\n\n/**\n * Groups items by a property whose value can be used as an object key.\n *\n * @example\n * ```ts\n * groupByKey(\n *   [\n *     { id: \"1\", role: \"admin\" },\n *     { id: \"2\", role: \"member\" },\n *     { id: \"3\", role: \"admin\" },\n *   ],\n *   \"role\",\n * );\n * // { admin: [...], member: [...] }\n * ```\n */\nexport function groupByKey<T extends object, K extends keyof T>(\n\titems: ReadonlyArray<T>,\n\tkey: K,\n): GroupedByKey<T, K> {\n\tconst result = {} as GroupedByKey<T, K>;\n\n\tfor (const item of items) {\n\t\tconst groupKey = item[key] as Extract<T[K], PropertyKey>;\n\t\tconst existing = result[groupKey];\n\n\t\tif (existing) {\n\t\t\texisting.push(item);\n\t\t\tcontinue;\n\t\t}\n\n\t\tresult[groupKey] = [item];\n\t}\n\n\treturn result;\n}\n","import { hasOwn } from \"./has-own\";\nimport { path as toPath } from \"./path\";\nimport type { PathInput } from \"./types\";\n\n/**\n * Checks whether a nested own-property path exists.\n *\n * A resolved `undefined` value still counts as existing as long as every\n * segment is present as an own property.\n */\nexport function hasPath(object: unknown, pathInput: PathInput): boolean {\n\tlet current = object;\n\n\tfor (const segment of toPath(pathInput)) {\n\t\tif (\n\t\t\tcurrent === null ||\n\t\t\tcurrent === undefined ||\n\t\t\t(typeof current !== \"object\" && typeof current !== \"function\") ||\n\t\t\t!hasOwn(current, segment)\n\t\t) {\n\t\t\treturn false;\n\t\t}\n\n\t\tcurrent = (current as Record<string | number, unknown>)[segment];\n\t}\n\n\treturn true;\n}\n","/**\n * Returns the given value unchanged.\n *\n * Useful as a default callback, a type-inference anchor, or a no-op\n * placeholder where a transform function is expected.\n *\n * @example\n * ```ts\n * identity(\"umsizi\"); // \"umsizi\"\n * ```\n */\nexport function identity<T>(value: T): T {\n\treturn value;\n}\n","import type { IndexedByKey } from \"./types\";\n\n/**\n * Indexes items by a property whose value can be used as an object key.\n *\n * Later items overwrite earlier items with the same key.\n *\n * @example\n * ```ts\n * indexByKey(\n *   [\n *     { id: \"1\", name: \"Ada\" },\n *     { id: \"2\", name: \"Linus\" },\n *   ],\n *   \"id\",\n * );\n * // { 1: { ... }, 2: { ... } }\n * ```\n */\nexport function indexByKey<T extends object, K extends keyof T>(\n\titems: ReadonlyArray<T>,\n\tkey: K,\n): IndexedByKey<T, K> {\n\tconst result = {} as IndexedByKey<T, K>;\n\n\tfor (const item of items) {\n\t\tresult[item[key] as Extract<T[K], PropertyKey>] = item;\n\t}\n\n\treturn result;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { InvertedObject } from \"./types\";\n\n/**\n * Inverts an object's own enumerable string-keyed properties.\n *\n * Source values must be valid property keys. When multiple source keys share\n * the same value, the later assignment wins.\n *\n * @example\n * ```ts\n * const roles = { admin: \"A\", member: \"M\" } as const;\n *\n * invertObject(roles);\n * // { A: \"admin\", M: \"member\" }\n * ```\n */\nexport function invertObject<T extends Record<string, PropertyKey>>(\n\tobject: T,\n): InvertedObject<T> {\n\tconst result = {} as InvertedObject<T>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tconst value = object[key] as PropertyKey;\n\n\t\t(result as Record<PropertyKey, string>)[value] = key;\n\t}\n\n\treturn result;\n}\n","/**\n * Returns `true` when an object has no own enumerable properties.\n *\n * Both string keys and symbol keys are considered. Non-enumerable properties\n * are ignored.\n *\n * @example\n * ```ts\n * isEmpty({}); // true\n * isEmpty({ id: \"1\" }); // false\n * ```\n */\nexport function isEmpty(object: object): boolean {\n\tif (Object.keys(object).length > 0) {\n\t\treturn false;\n\t}\n\n\tfor (const key of Object.getOwnPropertySymbols(object)) {\n\t\tif (Object.prototype.propertyIsEnumerable.call(object, key)) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n","/**\n * Checks whether a value is a plain object with a prototype of\n * `Object.prototype` or `null`.\n *\n * Arrays, functions, boxed primitives, dates, maps, sets, and class instances\n * all return `false`.\n *\n * @example\n * ```ts\n * const payload: unknown = { id: \"1\" };\n *\n * if (isPlainObject(payload)) {\n * \tpayload.id;\n * }\n * ```\n */\nexport function isPlainObject(\n\tvalue: unknown,\n): value is Record<PropertyKey, unknown> {\n\tif (value === null || typeof value !== \"object\") {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\n\treturn prototype === Object.prototype || prototype === null;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { KeyMapper, MappedKeys } from \"./types\";\n\n/**\n * Maps an object's own enumerable string keys to new string keys.\n *\n * When multiple source keys map to the same target key, the later assignment\n * wins.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", active: true } as const;\n *\n * mapKeys(user, (key) => `user_${key}`);\n * // { user_id: \"1\", user_active: true }\n * ```\n */\nexport function mapKeys<T extends object, R extends string>(\n\tobject: T,\n\tmapper: KeyMapper<T, R>,\n): MappedKeys<T, R> {\n\tconst result = {} as MappedKeys<T, R>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tconst mappedKey = mapper(key, object[key], object);\n\n\t\tresult[mappedKey] = object[key];\n\t}\n\n\treturn result;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { MappedValues, ValueMapper } from \"./types\";\n\n/**\n * Maps the values of an object's own enumerable string-keyed properties while\n * preserving the original enumerable string-key set.\n *\n * @example\n * ```ts\n * const counts = { draft: 1, published: 2 };\n *\n * mapValues(counts, (value) => value * 2);\n * // { draft: 2, published: 4 }\n * ```\n */\nexport function mapValues<T extends object, R>(\n\tobject: T,\n\tmapper: ValueMapper<T, R>,\n): MappedValues<T, R> {\n\tconst result = {} as MappedValues<T, R>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tresult[key] = mapper(object[key], key, object);\n\t}\n\n\treturn result;\n}\n","import { groupByKey } from \"./group-by-key\";\nimport type { KeyMatch } from \"./types\";\n\n/**\n * Matches items from two arrays when their key values are equal.\n *\n * Supports either the same key on both sides or separate left/right keys.\n *\n * @example\n * ```ts\n * matchByKey(\n *   [{ id: \"1\", name: \"Ada\" }],\n *   [{ userId: \"1\", status: \"active\" }],\n *   \"id\",\n *   \"userId\",\n * );\n * // [{ key: \"1\", left: { ... }, right: { ... } }]\n * ```\n */\nexport function matchByKey<\n\tL extends object,\n\tR extends object,\n\tK extends keyof L & keyof R,\n>(\n\tleftItems: ReadonlyArray<L>,\n\trightItems: ReadonlyArray<R>,\n\tkey: K,\n): Array<KeyMatch<Extract<L[K] & R[K], PropertyKey>, L, R>>;\nexport function matchByKey<\n\tL extends object,\n\tR extends object,\n\tLK extends keyof L,\n\tRK extends keyof R,\n>(\n\tleftItems: ReadonlyArray<L>,\n\trightItems: ReadonlyArray<R>,\n\tleftKey: LK,\n\trightKey: RK,\n): Array<KeyMatch<Extract<L[LK] & R[RK], PropertyKey>, L, R>>;\nexport function matchByKey<\n\tL extends object,\n\tR extends object,\n\tLK extends keyof L,\n\tRK extends keyof R,\n>(\n\tleftItems: ReadonlyArray<L>,\n\trightItems: ReadonlyArray<R>,\n\tleftKey: LK,\n\trightKey?: RK,\n): Array<KeyMatch<PropertyKey, L, R>> {\n\tconst resolvedRightKey = (rightKey ?? leftKey) as keyof R;\n\tconst rightIndex = groupByKey(rightItems, resolvedRightKey) as Record<\n\t\tPropertyKey,\n\t\tArray<R> | undefined\n\t>;\n\n\tconst matches: Array<KeyMatch<PropertyKey, L, R>> = [];\n\n\tfor (const left of leftItems) {\n\t\tconst key = left[leftKey] as PropertyKey;\n\t\tconst matchingRights = rightIndex[key];\n\n\t\tif (!matchingRights) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tfor (const right of matchingRights) {\n\t\t\tmatches.push({ key, left, right });\n\t\t}\n\t}\n\n\treturn matches;\n}\n","import { isPlainObject } from \"./is-plain-object\";\nimport { typedKeys } from \"./typed-keys\";\nimport type { MergeDefaulted } from \"./types\";\n\n/**\n * Recursively fills missing or `undefined` properties from a defaults object.\n *\n * Only plain objects are merged deeply. Arrays and other object-like values are\n * treated as leaf values.\n */\nexport function mergeDefaults<T extends object, D extends object>(\n\tobject: T,\n\tdefaultValues: D,\n): MergeDefaulted<T, D> {\n\tconst result = { ...object } as Record<string, unknown>;\n\n\tfor (const key of typedKeys(defaultValues)) {\n\t\tconst value = result[key];\n\t\tconst fallback = defaultValues[key];\n\n\t\tresult[key] =\n\t\t\tvalue === undefined\n\t\t\t\t? fallback\n\t\t\t\t: isPlainObject(value) && isPlainObject(fallback)\n\t\t\t\t\t? mergeDefaults(value, fallback)\n\t\t\t\t\t: value;\n\t}\n\n\treturn result as MergeDefaulted<T, D>;\n}\n","/**\n * Creates a new object excluding the selected own enumerable properties.\n *\n * Prefer the rest-key form for the strongest autocomplete and inference.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", name: \"Umsizi\", role: \"admin\" } as const;\n *\n * omit(user, \"id\", \"name\"); // { role: \"admin\" }\n * omit(user, [\"role\"] as const); // { id: \"1\", name: \"Umsizi\" }\n * ```\n */\nexport function omit<T extends object, const Keys extends readonly (keyof T)[]>(\n\tobject: T,\n\t...keys: Keys\n): Omit<T, Keys[number]>;\nexport function omit<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tobject: T,\n\tkeys: readonly [FirstKey, ...RestKeys],\n): Omit<T, FirstKey | RestKeys[number]>;\nexport function omit<T extends object>(\n\tobject: T,\n\tkeys: readonly (keyof T)[],\n): Partial<T>;\nexport function omit<T extends object>(\n\tobject: T,\n\tfirstKeyOrKeys: keyof T | readonly (keyof T)[],\n\t...restKeys: readonly (keyof T)[]\n): Partial<T> {\n\tconst keys = (\n\t\tArray.isArray(firstKeyOrKeys)\n\t\t\t? firstKeyOrKeys\n\t\t\t: [firstKeyOrKeys, ...restKeys]\n\t) as readonly (keyof T)[];\n\tconst omittedKeys = new Set<PropertyKey>(keys as readonly PropertyKey[]);\n\tconst result: Partial<T> = {};\n\n\tfor (const key of Reflect.ownKeys(object) as (keyof T)[]) {\n\t\tif (\n\t\t\tObject.prototype.propertyIsEnumerable.call(object, key) &&\n\t\t\t!omittedKeys.has(key)\n\t\t) {\n\t\t\t(result as T)[key] = object[key];\n\t\t}\n\t}\n\n\treturn result;\n}\n","import { hasOwn } from \"./has-own\";\nimport { isRecord } from \"./is-record\";\nimport { typedKeys } from \"./typed-keys\";\nimport type { InferSchema, ObjectSchema } from \"./types\";\n\n/**\n * Validates an unknown value against a schema of field validators.\n *\n * All schema keys must exist as own properties on the input object and every\n * field validator must accept its corresponding value.\n *\n * @example\n * ```ts\n * const isUser = validateObject(\n *   { id: \"usr_1\", active: true },\n *   schema({\n *     id: (value): value is string => typeof value === \"string\",\n *     active: (value): value is boolean => typeof value === \"boolean\",\n *   }),\n * );\n * ```\n */\nexport function validateObject<const T extends ObjectSchema>(\n\tvalue: unknown,\n\tdefinition: T,\n): value is InferSchema<T> {\n\tif (!isRecord(value)) return false;\n\n\tfor (const key of typedKeys(definition)) {\n\t\tif (!hasOwn(value, key)) return false;\n\t\tif (!(definition[key] as T[typeof key])(value[key])) return false;\n\t}\n\n\treturn true;\n}\n","import type { InferSchema, ObjectSchema } from \"./types\";\nimport { validateObject } from \"./validate-object\";\n\n/**\n * Parses an unknown value as a typed object by validating it against a schema.\n *\n * Throws a `TypeError` when validation fails.\n *\n * @example\n * ```ts\n * const user = parseObject(payload, schema({\n *   id: (value): value is string => typeof value === \"string\",\n *   active: (value): value is boolean => typeof value === \"boolean\",\n * }));\n * ```\n */\nexport function parseObject<const T extends ObjectSchema>(\n\tvalue: unknown,\n\tdefinition: T,\n): InferSchema<T> {\n\tif (validateObject(value, definition)) return value;\n\n\tthrow new TypeError(\"Invalid object.\");\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type {\n\tPartitionedObject,\n\tPartitionedValues,\n\tValueGuard,\n\tValuePredicate,\n} from \"./types\";\n\n/**\n * Partitions an object's own enumerable string-keyed properties into matching\n * and non-matching objects.\n *\n * Supports both boolean predicates and type-guard predicates.\n *\n * @example\n * ```ts\n * const settings = { retries: 3, label: \"ok\", timeout: null } as const;\n *\n * partitionObject(settings, (value) => value !== null);\n * // [{ retries: 3, label: \"ok\" }, { timeout: null }]\n * ```\n */\nexport function partitionObject<\n\tT extends object,\n\tS extends T[Extract<keyof T, string>],\n>(object: T, predicate: ValueGuard<T, S>): PartitionedValues<T, S>;\nexport function partitionObject<T extends object>(\n\tobject: T,\n\tpredicate: ValuePredicate<T>,\n): PartitionedObject<T>;\nexport function partitionObject<T extends object>(\n\tobject: T,\n\tpredicate: ValuePredicate<T>,\n): PartitionedObject<T> {\n\tconst matching = {} as PartitionedObject<T>[0];\n\tconst rest = {} as PartitionedObject<T>[1];\n\n\tfor (const key of typedKeys(object)) {\n\t\tconst value = object[key];\n\n\t\tif (predicate(value, key, object)) {\n\t\t\t(matching as Record<string, T[Extract<keyof T, string>]>)[key] = value;\n\t\t\tcontinue;\n\t\t}\n\n\t\t(rest as Record<string, T[Extract<keyof T, string>]>)[key] = value;\n\t}\n\n\treturn [matching, rest];\n}\n","import { hasOwn } from \"./has-own\";\n\n/**\n * Creates a new object containing only the selected own properties.\n *\n * Prefer the rest-key form for the strongest autocomplete and inference.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", name: \"Umsizi\", role: \"admin\" } as const;\n *\n * pick(user, \"name\"); // { name: \"Umsizi\" }\n * pick(user, [\"id\", \"role\"] as const); // { id: \"1\", role: \"admin\" }\n * ```\n */\nexport function pick<T extends object, const Keys extends readonly (keyof T)[]>(\n\tobject: T,\n\t...keys: Keys\n): Pick<T, Keys[number]>;\nexport function pick<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tobject: T,\n\tkeys: readonly [FirstKey, ...RestKeys],\n): Pick<T, FirstKey | RestKeys[number]>;\nexport function pick<T extends object>(\n\tobject: T,\n\tkeys: readonly (keyof T)[],\n): Partial<T>;\nexport function pick<T extends object>(\n\tobject: T,\n\tfirstKeyOrKeys: keyof T | readonly (keyof T)[],\n\t...restKeys: readonly (keyof T)[]\n): Partial<T> {\n\tconst keys = (\n\t\tArray.isArray(firstKeyOrKeys)\n\t\t\t? firstKeyOrKeys\n\t\t\t: [firstKeyOrKeys, ...restKeys]\n\t) as readonly (keyof T)[];\n\tconst result: Partial<T> = {};\n\n\tfor (const key of keys) {\n\t\tif (hasOwn(object, key)) {\n\t\t\tresult[key] = object[key];\n\t\t}\n\t}\n\n\treturn result;\n}\n","import { hasOwn } from \"./has-own\";\nimport { typedKeys } from \"./typed-keys\";\nimport type { RenamedKeys } from \"./types\";\n\n/**\n * Renames selected own enumerable string-keyed properties using a key map.\n *\n * Unmapped keys are copied through unchanged. When multiple source keys resolve\n * to the same target key, the later assignment wins.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", givenName: \"Umsizi\" } as const;\n *\n * renameKeys(user, { givenName: \"name\" });\n * // { id: \"1\", name: \"Umsizi\" }\n * ```\n */\nexport function renameKeys<\n\tT extends object,\n\tconst M extends Partial<Record<Extract<keyof T, string>, string>>,\n>(object: T, names: M): RenamedKeys<T, M> {\n\tconst result = {} as RenamedKeys<T, M>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tconst renamedKey = (hasOwn(names, key) ? names[key] : key) as string;\n\n\t\t(result as Record<string, T[Extract<keyof T, string>]>)[renamedKey] =\n\t\t\tobject[key];\n\t}\n\n\treturn result;\n}\n","import { path as toPath } from \"./path\";\nimport type { PathInput, PathSegment } from \"./types\";\n\nfunction isContainer(value: unknown): value is object {\n\treturn typeof value === \"object\" && value !== null;\n}\n\nfunction createContainer(\n\tnextSegment: PathSegment | undefined,\n): unknown[] | Record<string, unknown> {\n\treturn typeof nextSegment === \"number\" ? [] : {};\n}\n\nfunction cloneContainer(value: unknown, nextSegment: PathSegment | undefined) {\n\tif (Array.isArray(value)) {\n\t\treturn [...value];\n\t}\n\n\tif (isContainer(value)) {\n\t\treturn Object.assign(\n\t\t\tObject.create(Object.getPrototypeOf(value)),\n\t\t\tvalue,\n\t\t) as Record<string | number, unknown>;\n\t}\n\n\treturn createContainer(nextSegment);\n}\n\nfunction setAtPath(\n\tcurrent: unknown,\n\tsegments: readonly PathSegment[],\n\tvalue: unknown,\n): unknown {\n\tconst [segment, ...rest] = segments as readonly [\n\t\tPathSegment,\n\t\t...PathSegment[],\n\t];\n\n\tconst clone = cloneContainer(current, segment) as Record<\n\t\tPropertyKey,\n\t\tunknown\n\t>;\n\tconst existingValue =\n\t\tisContainer(current) || Array.isArray(current)\n\t\t\t? (current as Record<string | number, unknown>)[segment]\n\t\t\t: undefined;\n\n\tclone[segment] =\n\t\trest.length === 0 ? value : setAtPath(existingValue, rest, value);\n\n\treturn clone;\n}\n\n/**\n * Returns a new object with the nested path set to the given value.\n *\n * Missing containers are created automatically. Only the updated path is\n * cloned; untouched branches retain their existing references.\n */\nexport function set<T extends object>(\n\tobject: T,\n\tpathInput: PathInput,\n\tvalue: unknown,\n): T {\n\tconst segments = toPath(pathInput);\n\n\tif (segments.length === 0) {\n\t\treturn object;\n\t}\n\n\treturn setAtPath(object, segments, value) as T;\n}\n","import type { ObjectEntries } from \"./types\";\n\n/**\n * Returns the own enumerable string-keyed entries of an object with preserved\n * key/value pairing.\n *\n * This is a typed wrapper around `Object.entries`.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", active: true } as const;\n *\n * typedEntries(user); // [[\"id\", \"1\"], [\"active\", true]]\n * ```\n */\nexport function typedEntries<T extends object>(object: T): ObjectEntries<T> {\n\treturn Object.entries(object) as unknown as ObjectEntries<T>;\n}\n","import type { EntryTuples, ObjectFromEntries } from \"./types\";\n\n/**\n * Creates an object from entries while preserving the key and value types from\n * the input tuple array.\n *\n * This is a typed wrapper around `Object.fromEntries`.\n *\n * @example\n * ```ts\n * const status = typedFromEntries([\n *   [\"id\", \"1\"],\n *   [\"active\", true],\n * ] as const);\n *\n * // inferred as: { id: \"1\"; active: true }\n * ```\n */\nexport function typedFromEntries<const T extends EntryTuples>(\n\tentries: T,\n): ObjectFromEntries<T> {\n\treturn Object.fromEntries(entries) as ObjectFromEntries<T>;\n}\n","import { mergeDefaults } from \"./merge-defaults\";\nimport type { MergeDefaulted } from \"./types\";\n\ntype DefaultsApplicator<D extends object> = <T extends object>(\n\tobject: T,\n) => MergeDefaulted<T, D>;\n\n/**\n * Creates a reusable function that applies the provided defaults.\n */\nexport function withDefaults<D extends object>(\n\tdefaultValues: D,\n): DefaultsApplicator<D> {\n\treturn <T extends object>(object: T): MergeDefaulted<T, D> =>\n\t\tmergeDefaults(object, defaultValues);\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umsizi",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "A zero-dependency TypeScript utility library.",
   "license": "MIT",
   "author": "Jack-WebDev",
@@ -72,7 +72,7 @@
     {
       "name": "umsizi (core)",
       "path": "dist/index.js",
-      "limit": "1 KB"
+      "limit": "1.25 KB"
     },
     {
       "name": "umsizi/react",