umsizi 0.5.0 → 0.7.0

package/README.md

@@ -150,6 +150,45 @@ const user = typedFromEntries([
 ] as const);
 ```
 
+#### `path`
+
+```ts
+import { path } from "umsizi";
+
+path("profile.addresses[0].city");
+// ["profile", "addresses", 0, "city"]
+```
+
+#### `get`
+
+```ts
+import { get } from "umsizi";
+
+get(
+	{ profile: { addresses: [{ city: "Durban" }] } },
+	"profile.addresses[0].city",
+);
+// "Durban"
+```
+
+#### `set`
+
+```ts
+import { set } from "umsizi";
+
+set({}, "profile.addresses[0].city", "Durban");
+// { profile: { addresses: [{ city: "Durban" }] } }
+```
+
+#### `hasPath`
+
+```ts
+import { hasPath } from "umsizi";
+
+hasPath({ profile: { nickname: undefined } }, ["profile", "nickname"]);
+// true
+```
+
 #### `pick`
 
 ```ts

package/dist/index.d.ts

@@ -18,17 +18,31 @@ declare function assertKeys<T extends object>(value: T, keys: readonly (keyof T)
 //#endregion
 //#region src/core/types.d.ts
 type StringKeyOf<T extends object> = Extract<keyof T, string>;
+type PathSegment = string | number;
+type ObjectPath = readonly PathSegment[];
+type PathInput = string | ObjectPath;
 type ObjectEntry<T extends object> = { [K in StringKeyOf<T>]: readonly [K, T[K]] }[StringKeyOf<T>];
 type ObjectEntries<T extends object> = Array<ObjectEntry<T>>;
 type EntryTuple = readonly [PropertyKey, unknown];
 type EntryTuples = ReadonlyArray<EntryTuple>;
 type ObjectFromEntries<T extends EntryTuples> = { [K in T[number] as K[0]]: K[1] };
 type ValueMapper<T extends object, R> = (value: T[StringKeyOf<T>], key: StringKeyOf<T>, object: T) => R;
+type KeyMapper<T extends object, R extends string> = (key: StringKeyOf<T>, value: T[StringKeyOf<T>], object: T) => R;
+type KeyPredicate<T extends object> = (key: StringKeyOf<T>, value: T[StringKeyOf<T>], object: T) => boolean;
+type KeyGuard<T extends object, S extends StringKeyOf<T>> = (key: StringKeyOf<T>, value: T[StringKeyOf<T>], object: T) => key is S;
 type ValuePredicate<T extends object> = (value: T[StringKeyOf<T>], key: StringKeyOf<T>, object: T) => boolean;
 type ValueGuard<T extends object, S extends T[StringKeyOf<T>]> = (value: T[StringKeyOf<T>], key: StringKeyOf<T>, object: T) => value is S;
 type MappedValues<T extends object, R> = { [K in StringKeyOf<T>]: R };
+type MappedKeys<T extends object, R extends string> = Record<R, T[StringKeyOf<T>]>;
+type RenamedKeys<T extends object, M extends Partial<Record<StringKeyOf<T>, string>>> = { [K in StringKeyOf<T> as K extends keyof M ? M[K] extends string ? M[K] : K : K]: T[K] };
 type FilteredValues<T extends object, S extends T[StringKeyOf<T>]> = Partial<{ [K in StringKeyOf<T>]: Extract<T[K], S> }>;
+type FilteredKeys<T extends object, S extends StringKeyOf<T>> = Partial<Pick<T, S>>;
+type PartitionedValues<T extends object, S extends T[StringKeyOf<T>]> = readonly [FilteredValues<T, S>, Partial<{ [K in StringKeyOf<T>]: Exclude<T[K], S> }>];
+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 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
 //#region src/core/compact-object.d.ts
 /**
@@ -45,6 +59,24 @@ type CompactedObject<T extends object> = Partial<{ [K in StringKeyOf<T>]: Exclud
  */
 declare function compactObject<T extends object>(object: T): CompactedObject<T>;
 //#endregion
+//#region src/core/filter-keys.d.ts
+/**
+ * Filters an object's own enumerable string-keyed properties by key.
+ *
+ * Supports both boolean predicates and key type guards. The result remains
+ * partial because any property may be removed at runtime.
+ *
+ * @example
+ * ```ts
+ * const metrics = { total: 5, temp_cache: 2, temp_jobs: 1 } as const;
+ *
+ * filterKeys(metrics, (key) => key.startsWith("temp_"));
+ * // { temp_cache: 2, temp_jobs: 1 }
+ * ```
+ */
+declare function filterKeys<T extends object, S extends Extract<keyof T, string>>(object: T, predicate: KeyGuard<T, S>): FilteredKeys<T, S>;
+declare function filterKeys<T extends object>(object: T, predicate: KeyPredicate<T>): FilteredKeys<T, Extract<keyof T, string>>;
+//#endregion
 //#region src/core/filter-values.d.ts
 /**
  * Filters an object's own enumerable string-keyed properties by value.
@@ -63,6 +95,23 @@ declare function compactObject<T extends object>(object: T): CompactedObject<T>;
 declare function filterValues<T extends object, S extends T[Extract<keyof T, string>]>(object: T, predicate: ValueGuard<T, S>): FilteredValues<T, S>;
 declare function filterValues<T extends object>(object: T, predicate: ValuePredicate<T>): FilteredValues<T, T[Extract<keyof T, string>]>;
 //#endregion
+//#region src/core/get.d.ts
+/**
+ * Reads a nested own property using a tuple path or dot/bracket notation.
+ *
+ * @example
+ * ```ts
+ * const user = { profile: { addresses: [{ city: "Durban" }] } } as const;
+ *
+ * get(user, ["profile", "addresses", 0, "city"]);
+ * get(user, "profile.addresses[0].city");
+ * ```
+ */
+declare function get<T, const P extends ObjectPath>(object: T, path: P): PathValue<T, P> | undefined;
+declare function get<T, const P extends ObjectPath, D>(object: T, path: P, defaultValue: D): Exclude<PathValue<T, P>, undefined> | D;
+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/has-keys.d.ts
 /**
  * Checks whether a plain object has all of the requested own keys.
@@ -100,6 +149,15 @@ declare function hasKeys<T extends object>(value: T, keys: readonly (keyof T)[])
  */
 declare function hasOwn<T extends object, K$1 extends PropertyKey>(object: T, key: K$1): key is Extract<K$1, keyof T>;
 //#endregion
+//#region src/core/has-path.d.ts
+/**
+ * Checks whether a nested own-property path exists.
+ *
+ * A resolved `undefined` value still counts as existing as long as every
+ * segment is present as an own property.
+ */
+declare function hasPath(object: unknown, pathInput: PathInput): boolean;
+//#endregion
 //#region src/core/identity.d.ts
 /**
  * Returns the given value unchanged.
@@ -114,6 +172,23 @@ declare function hasOwn<T extends object, K$1 extends PropertyKey>(object: T, ke
  */
 declare function identity<T>(value: T): T;
 //#endregion
+//#region src/core/invert-object.d.ts
+/**
+ * Inverts an object's own enumerable string-keyed properties.
+ *
+ * Source values must be valid property keys. When multiple source keys share
+ * the same value, the later assignment wins.
+ *
+ * @example
+ * ```ts
+ * const roles = { admin: "A", member: "M" } as const;
+ *
+ * invertObject(roles);
+ * // { A: "admin", M: "member" }
+ * ```
+ */
+declare function invertObject<T extends Record<string, PropertyKey>>(object: T): InvertedObject<T>;
+//#endregion
 //#region src/core/is-empty.d.ts
 /**
  * Returns `true` when an object has no own enumerable properties.
@@ -148,6 +223,23 @@ declare function isEmpty(object: object): boolean;
  */
 declare function isPlainObject(value: unknown): value is Record<PropertyKey, unknown>;
 //#endregion
+//#region src/core/map-keys.d.ts
+/**
+ * Maps an object's own enumerable string keys to new string keys.
+ *
+ * When multiple source keys map to the same target key, the later assignment
+ * wins.
+ *
+ * @example
+ * ```ts
+ * const user = { id: "1", active: true } as const;
+ *
+ * mapKeys(user, (key) => `user_${key}`);
+ * // { user_id: "1", user_active: true }
+ * ```
+ */
+declare function mapKeys<T extends object, R extends string>(object: T, mapper: KeyMapper<T, R>): MappedKeys<T, R>;
+//#endregion
 //#region src/core/map-values.d.ts
 /**
  * Maps the values of an object's own enumerable string-keyed properties while
@@ -181,6 +273,36 @@ 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/partition-object.d.ts
+/**
+ * Partitions an object's own enumerable string-keyed properties into matching
+ * and non-matching objects.
+ *
+ * Supports both boolean predicates and type-guard predicates.
+ *
+ * @example
+ * ```ts
+ * const settings = { retries: 3, label: "ok", timeout: null } as const;
+ *
+ * partitionObject(settings, (value) => value !== null);
+ * // [{ retries: 3, label: "ok" }, { timeout: null }]
+ * ```
+ */
+declare function partitionObject<T extends object, S extends T[Extract<keyof T, string>]>(object: T, predicate: ValueGuard<T, S>): PartitionedValues<T, S>;
+declare function partitionObject<T extends object>(object: T, predicate: ValuePredicate<T>): PartitionedObject<T>;
+//#endregion
+//#region src/core/path.d.ts
+/**
+ * Converts dot/bracket notation into a normalized object path array.
+ *
+ * @example
+ * ```ts
+ * path("profile.addresses[0].city");
+ * // ["profile", "addresses", 0, "city"]
+ * ```
+ */
+declare function path(input: PathInput): ObjectPath;
+//#endregion
 //#region src/core/pick.d.ts
 /**
  * Creates a new object containing only the selected own properties.
@@ -199,6 +321,23 @@ declare function pick<T extends object, const Keys extends readonly (keyof T)[]>
 declare function pick<T extends object, const FirstKey extends keyof T, const RestKeys extends readonly (keyof T)[]>(object: T, keys: readonly [FirstKey, ...RestKeys]): Pick<T, FirstKey | RestKeys[number]>;
 declare function pick<T extends object>(object: T, keys: readonly (keyof T)[]): Partial<T>;
 //#endregion
+//#region src/core/rename-keys.d.ts
+/**
+ * Renames selected own enumerable string-keyed properties using a key map.
+ *
+ * Unmapped keys are copied through unchanged. When multiple source keys resolve
+ * to the same target key, the later assignment wins.
+ *
+ * @example
+ * ```ts
+ * const user = { id: "1", givenName: "Umsizi" } as const;
+ *
+ * renameKeys(user, { givenName: "name" });
+ * // { id: "1", name: "Umsizi" }
+ * ```
+ */
+declare function renameKeys<T extends object, const M extends Partial<Record<Extract<keyof T, string>, string>>>(object: T, names: M): RenamedKeys<T, M>;
+//#endregion
 //#region src/core/require-keys.d.ts
 /**
  * Requires that a plain object has all of the requested own keys.
@@ -217,6 +356,15 @@ declare function requireKeys<T extends object, const FirstKey extends keyof T, c
 declare function requireKeys<T extends object, const FirstKey extends keyof T, const RestKeys extends readonly (keyof T)[]>(value: T, keys: readonly [FirstKey, ...RestKeys]): T & Required<Pick<T, FirstKey | RestKeys[number]>>;
 declare function requireKeys<T extends object>(value: T, keys: readonly (keyof T)[]): T;
 //#endregion
+//#region src/core/set.d.ts
+/**
+ * Returns a new object with the nested path set to the given value.
+ *
+ * Missing containers are created automatically. Only the updated path is
+ * cloned; untouched branches retain their existing references.
+ */
+declare function set<T extends object>(object: T, pathInput: PathInput, value: unknown): T;
+//#endregion
 //#region src/core/typed-entries.d.ts
 /**
  * Returns the own enumerable string-keyed entries of an object with preserved
@@ -267,5 +415,5 @@ 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, filterValues, hasKeys, hasOwn, identity, isEmpty, isPlainObject, isPlainObject as isRecord, mapValues, omit, pick, requireKeys, typedEntries, typedFromEntries, typedKeys };
+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 };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -21,7 +21,8 @@ function requireKeys(value, firstKeyOrKeys, ...restKeys) {
 		}
 	}
 	if (missingKeys.length === 0) missingKeys.push(...keys);
-	throw new TypeError(`M:${missingKeys.map(String).join()}`);
+	const label = missingKeys.length === 1 ? "key" : "keys";
+	throw new TypeError(`Missing required ${label}: ${missingKeys.map(String).join(", ")}`);
 }
 
 //#endregion
@@ -71,6 +72,14 @@ function compactObject(object) {
 	return result;
 }
 
+//#endregion
+//#region src/core/filter-keys.ts
+function filterKeys(object, predicate) {
+	const result = {};
+	for (const key of typedKeys(object)) if (predicate(key, object[key], object)) result[key] = object[key];
+	return result;
+}
+
 //#endregion
 //#region src/core/filter-values.ts
 function filterValues(object, predicate) {
@@ -104,6 +113,65 @@ function hasOwn(object, key) {
 	return Object.hasOwn(object, key);
 }
 
+//#endregion
+//#region src/core/path.ts
+const BRACKET_PATH_SEGMENT_PATTERN = /[^.[\]]+|\[(?:([^"'[\]]+)|(["'])(.*?)\2)\]/g;
+function toPathSegment(value) {
+	return /^\d+$/.test(value) ? Number(value) : value;
+}
+/**
+* Converts dot/bracket notation into a normalized object path array.
+*
+* @example
+* ```ts
+* path("profile.addresses[0].city");
+* // ["profile", "addresses", 0, "city"]
+* ```
+*/
+function path(input) {
+	if (typeof input !== "string") return [...input];
+	const source = input;
+	const segments = [];
+	for (const match of source.matchAll(BRACKET_PATH_SEGMENT_PATTERN)) {
+		const [, bareSegment, , quotedSegment] = match;
+		const segment = quotedSegment ?? bareSegment ?? match[0];
+		if (segment !== "") segments.push(toPathSegment(segment));
+	}
+	return segments;
+}
+
+//#endregion
+//#region src/core/get.ts
+function hasMissingPathSegment(value, segment) {
+	return value === null || value === void 0 || typeof value !== "object" && typeof value !== "function" || !hasOwn(value, segment);
+}
+function get(object, pathInput, defaultValue) {
+	const segments = path(pathInput);
+	let current = object;
+	for (const segment of segments) {
+		if (hasMissingPathSegment(current, segment)) return defaultValue;
+		current = current[segment];
+	}
+	return current;
+}
+
+//#endregion
+//#region src/core/has-path.ts
+/**
+* Checks whether a nested own-property path exists.
+*
+* A resolved `undefined` value still counts as existing as long as every
+* segment is present as an own property.
+*/
+function hasPath(object, pathInput) {
+	let current = object;
+	for (const segment of path(pathInput)) {
+		if (current === null || current === void 0 || typeof current !== "object" && typeof current !== "function" || !hasOwn(current, segment)) return false;
+		current = current[segment];
+	}
+	return true;
+}
+
 //#endregion
 //#region src/core/identity.ts
 /**
@@ -121,6 +189,31 @@ function identity(value) {
 	return value;
 }
 
+//#endregion
+//#region src/core/invert-object.ts
+/**
+* Inverts an object's own enumerable string-keyed properties.
+*
+* Source values must be valid property keys. When multiple source keys share
+* the same value, the later assignment wins.
+*
+* @example
+* ```ts
+* const roles = { admin: "A", member: "M" } as const;
+*
+* invertObject(roles);
+* // { A: "admin", M: "member" }
+* ```
+*/
+function invertObject(object) {
+	const result = {};
+	for (const key of typedKeys(object)) {
+		const value = object[key];
+		result[value] = key;
+	}
+	return result;
+}
+
 //#endregion
 //#region src/core/is-empty.ts
 /**
@@ -165,6 +258,31 @@ function isPlainObject(value) {
 	return prototype === Object.prototype || prototype === null;
 }
 
+//#endregion
+//#region src/core/map-keys.ts
+/**
+* Maps an object's own enumerable string keys to new string keys.
+*
+* When multiple source keys map to the same target key, the later assignment
+* wins.
+*
+* @example
+* ```ts
+* const user = { id: "1", active: true } as const;
+*
+* mapKeys(user, (key) => `user_${key}`);
+* // { user_id: "1", user_active: true }
+* ```
+*/
+function mapKeys(object, mapper) {
+	const result = {};
+	for (const key of typedKeys(object)) {
+		const mappedKey = mapper(key, object[key], object);
+		result[mappedKey] = object[key];
+	}
+	return result;
+}
+
 //#endregion
 //#region src/core/map-values.ts
 /**
@@ -195,6 +313,22 @@ function omit(object, firstKeyOrKeys, ...restKeys) {
 	return result;
 }
 
+//#endregion
+//#region src/core/partition-object.ts
+function partitionObject(object, predicate) {
+	const matching = {};
+	const rest = {};
+	for (const key of typedKeys(object)) {
+		const value = object[key];
+		if (predicate(value, key, object)) {
+			matching[key] = value;
+			continue;
+		}
+		rest[key] = value;
+	}
+	return [matching, rest];
+}
+
 //#endregion
 //#region src/core/pick.ts
 function pick(object, firstKeyOrKeys, ...restKeys) {
@@ -204,6 +338,63 @@ function pick(object, firstKeyOrKeys, ...restKeys) {
 	return result;
 }
 
+//#endregion
+//#region src/core/rename-keys.ts
+/**
+* Renames selected own enumerable string-keyed properties using a key map.
+*
+* Unmapped keys are copied through unchanged. When multiple source keys resolve
+* to the same target key, the later assignment wins.
+*
+* @example
+* ```ts
+* const user = { id: "1", givenName: "Umsizi" } as const;
+*
+* renameKeys(user, { givenName: "name" });
+* // { id: "1", name: "Umsizi" }
+* ```
+*/
+function renameKeys(object, names) {
+	const result = {};
+	for (const key of typedKeys(object)) {
+		const renamedKey = hasOwn(names, key) ? names[key] : key;
+		result[renamedKey] = object[key];
+	}
+	return result;
+}
+
+//#endregion
+//#region src/core/set.ts
+function isContainer(value) {
+	return typeof value === "object" && value !== null;
+}
+function createContainer(nextSegment) {
+	return typeof nextSegment === "number" ? [] : {};
+}
+function cloneContainer(value, nextSegment) {
+	if (Array.isArray(value)) return [...value];
+	if (isContainer(value)) return Object.assign(Object.create(Object.getPrototypeOf(value)), value);
+	return createContainer(nextSegment);
+}
+function setAtPath(current, segments, value) {
+	const [segment, ...rest] = segments;
+	const clone = cloneContainer(current, segment);
+	const existingValue = isContainer(current) || Array.isArray(current) ? current[segment] : void 0;
+	clone[segment] = rest.length === 0 ? value : setAtPath(existingValue, rest, value);
+	return clone;
+}
+/**
+* Returns a new object with the nested path set to the given value.
+*
+* Missing containers are created automatically. Only the updated path is
+* cloned; untouched branches retain their existing references.
+*/
+function set(object, pathInput, value) {
+	const segments = path(pathInput);
+	if (segments.length === 0) return object;
+	return setAtPath(object, segments, value);
+}
+
 //#endregion
 //#region src/core/typed-entries.ts
 /**
@@ -246,5 +437,5 @@ function typedFromEntries(entries) {
 }
 
 //#endregion
-export { assertKeys, compactObject, filterValues, hasKeys, hasOwn, identity, isEmpty, isPlainObject, isPlainObject as isRecord, mapValues, omit, pick, requireKeys, typedEntries, typedFromEntries, typedKeys };
+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 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["missingKeys: Array<keyof T>","result: Partial<T>","result: Partial<T>"],"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-values.ts","../src/core/has-own.ts","../src/core/identity.ts","../src/core/is-empty.ts","../src/core/is-plain-object.ts","../src/core/map-values.ts","../src/core/omit.ts","../src/core/pick.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\tthrow new TypeError(`M:${missingKeys.map(String).join()}`);\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 { 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","/**\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","/**\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 { 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 { 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 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","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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"}

package/dist/next.d.ts

@@ -7,14 +7,15 @@
  * - Strips a trailing slash (except for the root path).
  * - An empty string normalizes to `"/"`.
  *
- * Query strings and fragments are treated as opaque path characters and are
- * not parsed or stripped — pass only the pathname segment of a URL.
+ * A query string or fragment, if present, is left untouched — only the
+ * pathname segment preceding the first `?` or `#` is normalized.
  *
  * @example
  * ```ts
  * normalizePathname("dashboard"); // "/dashboard"
  * normalizePathname("//dashboard///settings/"); // "/dashboard/settings"
  * normalizePathname(""); // "/"
+ * normalizePathname("dashboard?redirect=//evil.com"); // "/dashboard?redirect=//evil.com"
  * ```
  */
 declare function normalizePathname(pathname: string): string;

package/dist/next.js

@@ -7,21 +7,25 @@
 * - Strips a trailing slash (except for the root path).
 * - An empty string normalizes to `"/"`.
 *
-* Query strings and fragments are treated as opaque path characters and are
-* not parsed or stripped — pass only the pathname segment of a URL.
+* A query string or fragment, if present, is left untouched — only the
+* pathname segment preceding the first `?` or `#` is normalized.
 *
 * @example
 * ```ts
 * normalizePathname("dashboard"); // "/dashboard"
 * normalizePathname("//dashboard///settings/"); // "/dashboard/settings"
 * normalizePathname(""); // "/"
+* normalizePathname("dashboard?redirect=//evil.com"); // "/dashboard?redirect=//evil.com"
 * ```
 */
 function normalizePathname(pathname) {
-	if (pathname === "") return "/";
-	const normalized = pathname.replace(/\/{2,}/g, "/").replace(/\/$/, "");
-	if (normalized === "") return "/";
-	return normalized.startsWith("/") ? normalized : `/${normalized}`;
+	const suffixIndex = pathname.search(/[?#]/);
+	const path = suffixIndex === -1 ? pathname : pathname.slice(0, suffixIndex);
+	const suffix = suffixIndex === -1 ? "" : pathname.slice(suffixIndex);
+	if (path === "") return `/${suffix}`;
+	const normalized = path.replace(/\/{2,}/g, "/").replace(/\/$/, "");
+	if (normalized === "") return `/${suffix}`;
+	return (normalized.startsWith("/") ? normalized : `/${normalized}`) + suffix;
 }
 
 //#endregion

package/dist/next.js.map

@@ -1 +1 @@
-{"version":3,"file":"next.js","names":[],"sources":["../src/next/normalize-pathname.ts"],"sourcesContent":["/**\n * Normalizes a path-like string for routing/comparison purposes.\n *\n * - Ensures a leading slash.\n * - Collapses consecutive slashes into one.\n * - Strips a trailing slash (except for the root path).\n * - An empty string normalizes to `\"/\"`.\n *\n * Query strings and fragments are treated as opaque path characters and are\n * not parsed or stripped — pass only the pathname segment of a URL.\n *\n * @example\n * ```ts\n * normalizePathname(\"dashboard\"); // \"/dashboard\"\n * normalizePathname(\"//dashboard///settings/\"); // \"/dashboard/settings\"\n * normalizePathname(\"\"); // \"/\"\n * ```\n */\nexport function normalizePathname(pathname: string): string {\n\tif (pathname === \"\") {\n\t\treturn \"/\";\n\t}\n\n\tconst normalized = pathname.replace(/\\/{2,}/g, \"/\").replace(/\\/$/, \"\");\n\n\tif (normalized === \"\") {\n\t\treturn \"/\";\n\t}\n\n\treturn normalized.startsWith(\"/\") ? normalized : `/${normalized}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkBA,SAAgB,kBAAkB,UAA0B;AAC3D,KAAI,aAAa,GAChB,QAAO;CAGR,MAAM,aAAa,SAAS,QAAQ,WAAW,IAAI,CAAC,QAAQ,OAAO,GAAG;AAEtE,KAAI,eAAe,GAClB,QAAO;AAGR,QAAO,WAAW,WAAW,IAAI,GAAG,aAAa,IAAI"}
+{"version":3,"file":"next.js","names":[],"sources":["../src/next/normalize-pathname.ts"],"sourcesContent":["/**\n * Normalizes a path-like string for routing/comparison purposes.\n *\n * - Ensures a leading slash.\n * - Collapses consecutive slashes into one.\n * - Strips a trailing slash (except for the root path).\n * - An empty string normalizes to `\"/\"`.\n *\n * A query string or fragment, if present, is left untouched — only the\n * pathname segment preceding the first `?` or `#` is normalized.\n *\n * @example\n * ```ts\n * normalizePathname(\"dashboard\"); // \"/dashboard\"\n * normalizePathname(\"//dashboard///settings/\"); // \"/dashboard/settings\"\n * normalizePathname(\"\"); // \"/\"\n * normalizePathname(\"dashboard?redirect=//evil.com\"); // \"/dashboard?redirect=//evil.com\"\n * ```\n */\nexport function normalizePathname(pathname: string): string {\n\tconst suffixIndex = pathname.search(/[?#]/);\n\tconst path = suffixIndex === -1 ? pathname : pathname.slice(0, suffixIndex);\n\tconst suffix = suffixIndex === -1 ? \"\" : pathname.slice(suffixIndex);\n\n\tif (path === \"\") {\n\t\treturn `/${suffix}`;\n\t}\n\n\tconst normalized = path.replace(/\\/{2,}/g, \"/\").replace(/\\/$/, \"\");\n\n\tif (normalized === \"\") {\n\t\treturn `/${suffix}`;\n\t}\n\n\treturn (normalized.startsWith(\"/\") ? normalized : `/${normalized}`) + suffix;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,kBAAkB,UAA0B;CAC3D,MAAM,cAAc,SAAS,OAAO,OAAO;CAC3C,MAAM,OAAO,gBAAgB,KAAK,WAAW,SAAS,MAAM,GAAG,YAAY;CAC3E,MAAM,SAAS,gBAAgB,KAAK,KAAK,SAAS,MAAM,YAAY;AAEpE,KAAI,SAAS,GACZ,QAAO,IAAI;CAGZ,MAAM,aAAa,KAAK,QAAQ,WAAW,IAAI,CAAC,QAAQ,OAAO,GAAG;AAElE,KAAI,eAAe,GAClB,QAAO,IAAI;AAGZ,SAAQ,WAAW,WAAW,IAAI,GAAG,aAAa,IAAI,gBAAgB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umsizi",
-  "version": "0.5.0",
+  "version": "0.7.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": "512 B"
+      "limit": "1 KB"
     },
     {
       "name": "umsizi/react",