umsizi 0.3.0 → 0.5.0

package/README.md

@@ -198,6 +198,68 @@ if (hasOwn(user, key)) {
 }
 ```
 
+#### `isPlainObject`
+
+```ts
+import { isPlainObject } from "umsizi";
+
+const payload: unknown = { id: "1" };
+
+if (isPlainObject(payload)) {
+	payload.id;
+}
+```
+
+#### `isRecord`
+
+```ts
+import { isRecord } from "umsizi";
+
+const payload: unknown = { id: "1" };
+
+if (isRecord(payload)) {
+	payload.id;
+}
+```
+
+#### `hasKeys`
+
+```ts
+import { hasKeys } from "umsizi";
+
+const user = { id: "1", role: "admin" } as const;
+
+if (hasKeys(user, "id", "role")) {
+	user.id;
+	user.role;
+}
+```
+
+#### `requireKeys`
+
+```ts
+import { requireKeys } from "umsizi";
+
+const user = { id: "1", role: "admin" } as const;
+const ensured = requireKeys(user, "id", "role");
+```
+
+#### `assertKeys`
+
+```ts
+import { assertKeys } from "umsizi";
+
+const user: { id?: string; role?: string } = {
+	id: "1",
+	role: "admin",
+};
+
+assertKeys(user, "id", "role");
+
+user.id;
+user.role;
+```
+
 #### `mapValues`
 
 ```ts

package/dist/index.d.ts

@@ -1,7 +1,21 @@
-import { t as normalizePathname } from "./index-rZiv1o95.js";
-import { t as hasFileExtension } from "./index-DtjbEW43.js";
-import { t as isRenderFunction } from "./index-dktuz4mv.js";
-
+//#region src/core/assert-keys.d.ts
+/**
+ * Asserts that a plain object has all of the requested own keys.
+ *
+ * Prefer the rest-key form for the strongest autocomplete and inference.
+ *
+ * @example
+ * ```ts
+ * const user = { id: "1", role: "admin" } as const;
+ *
+ * assertKeys(user, "id", "role");
+ * user.id; // "1"
+ * ```
+ */
+declare function assertKeys<T extends object, const FirstKey extends keyof T, const RestKeys extends readonly (keyof T)[]>(value: T, firstKey: FirstKey, ...restKeys: RestKeys): asserts value is T & Required<Pick<T, FirstKey | RestKeys[number]>>;
+declare function assertKeys<T extends object, const FirstKey extends keyof T, const RestKeys extends readonly (keyof T)[]>(value: T, keys: readonly [FirstKey, ...RestKeys]): asserts value is T & Required<Pick<T, FirstKey | RestKeys[number]>>;
+declare function assertKeys<T extends object>(value: T, keys: readonly (keyof T)[]): asserts value is T;
+//#endregion
 //#region src/core/types.d.ts
 type StringKeyOf<T extends object> = Extract<keyof T, string>;
 type ObjectEntry<T extends object> = { [K in StringKeyOf<T>]: readonly [K, T[K]] }[StringKeyOf<T>];
@@ -49,6 +63,24 @@ 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/has-keys.d.ts
+/**
+ * Checks whether a plain object has all of the requested own keys.
+ *
+ * Prefer the rest-key form for the strongest autocomplete and inference.
+ *
+ * @example
+ * ```ts
+ * const user = { id: "1", role: "admin" } as const;
+ *
+ * hasKeys(user, "id", "role"); // true
+ * hasKeys(user, ["id", "role"] as const); // true
+ * ```
+ */
+declare function hasKeys<T extends object, const FirstKey extends keyof T, const RestKeys extends readonly (keyof T)[]>(value: T, firstKey: FirstKey, ...restKeys: RestKeys): value is T & Required<Pick<T, FirstKey | RestKeys[number]>>;
+declare function hasKeys<T extends object, const FirstKey extends keyof T, const RestKeys extends readonly (keyof T)[]>(value: T, keys: readonly [FirstKey, ...RestKeys]): value is T & Required<Pick<T, FirstKey | RestKeys[number]>>;
+declare function hasKeys<T extends object>(value: T, keys: readonly (keyof T)[]): value is T;
+//#endregion
 //#region src/core/has-own.d.ts
 /**
  * Checks whether an object has the given property as its own key.
@@ -97,6 +129,25 @@ declare function identity<T>(value: T): T;
  */
 declare function isEmpty(object: object): boolean;
 //#endregion
+//#region src/core/is-plain-object.d.ts
+/**
+ * Checks whether a value is a plain object with a prototype of
+ * `Object.prototype` or `null`.
+ *
+ * Arrays, functions, boxed primitives, dates, maps, sets, and class instances
+ * all return `false`.
+ *
+ * @example
+ * ```ts
+ * const payload: unknown = { id: "1" };
+ *
+ * if (isPlainObject(payload)) {
+ * 	payload.id;
+ * }
+ * ```
+ */
+declare function isPlainObject(value: unknown): value is Record<PropertyKey, unknown>;
+//#endregion
 //#region src/core/map-values.d.ts
 /**
  * Maps the values of an object's own enumerable string-keyed properties while
@@ -148,6 +199,24 @@ 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/require-keys.d.ts
+/**
+ * Requires that a plain object has all of the requested own keys.
+ *
+ * Prefer the rest-key form for the strongest autocomplete and inference.
+ *
+ * @example
+ * ```ts
+ * const user = { id: "1", role: "admin" } as const;
+ * const result = requireKeys(user, "id", "role");
+ *
+ * result.id; // "1"
+ * ```
+ */
+declare function requireKeys<T extends object, const FirstKey extends keyof T, const RestKeys extends readonly (keyof T)[]>(value: T, firstKey: FirstKey, ...restKeys: RestKeys): T & Required<Pick<T, FirstKey | RestKeys[number]>>;
+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/typed-entries.d.ts
 /**
  * Returns the own enumerable string-keyed entries of an object with preserved
@@ -198,5 +267,5 @@ declare function typedFromEntries<const T extends EntryTuples>(entries: T): Obje
  */
 declare function typedKeys<T extends object>(object: T): Array<StringKeyOf<T>>;
 //#endregion
-export { compactObject, filterValues, hasFileExtension, hasOwn, identity, isEmpty, isRenderFunction, mapValues, normalizePathname, omit, pick, typedEntries, typedFromEntries, typedKeys };
+export { assertKeys, compactObject, filterValues, hasKeys, hasOwn, identity, isEmpty, isPlainObject, isPlainObject as isRecord, mapValues, omit, pick, requireKeys, typedEntries, typedFromEntries, typedKeys };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,7 +1,36 @@
-import { t as normalizePathname } from "./next-C3wp7UoQ.js";
-import { t as hasFileExtension } from "./node-D-nlzpmG.js";
-import { t as isRenderFunction } from "./react-BCidSnzT.js";
+//#region src/core/has-keys.ts
+function hasKeys(value, firstKeyOrKeys, ...restKeys) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return false;
+	const keys = Array.isArray(firstKeyOrKeys) ? firstKeyOrKeys : [firstKeyOrKeys, ...restKeys];
+	for (const key of keys) if (!Object.hasOwn(value, key)) return false;
+	return true;
+}
+
+//#endregion
+//#region src/core/require-keys.ts
+function requireKeys(value, firstKeyOrKeys, ...restKeys) {
+	const keys = Array.isArray(firstKeyOrKeys) ? firstKeyOrKeys : [firstKeyOrKeys, ...restKeys];
+	if (hasKeys(value, keys)) return value;
+	const missingKeys = [];
+	if (value !== null && typeof value === "object") {
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype === Object.prototype || prototype === null) {
+			for (const key of keys) if (!Object.hasOwn(value, key)) missingKeys.push(key);
+		}
+	}
+	if (missingKeys.length === 0) missingKeys.push(...keys);
+	throw new TypeError(`M:${missingKeys.map(String).join()}`);
+}
+
+//#endregion
+//#region src/core/assert-keys.ts
+function assertKeys(value, firstKeyOrKeys, ...restKeys) {
+	requireKeys(value, firstKeyOrKeys, ...restKeys);
+}
 
+//#endregion
 //#region src/core/typed-keys.ts
 /**
 * Returns the own enumerable string keys of an object with preserved key types.
@@ -112,6 +141,30 @@ function isEmpty(object) {
 	return true;
 }
 
+//#endregion
+//#region src/core/is-plain-object.ts
+/**
+* Checks whether a value is a plain object with a prototype of
+* `Object.prototype` or `null`.
+*
+* Arrays, functions, boxed primitives, dates, maps, sets, and class instances
+* all return `false`.
+*
+* @example
+* ```ts
+* const payload: unknown = { id: "1" };
+*
+* if (isPlainObject(payload)) {
+* 	payload.id;
+* }
+* ```
+*/
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+
 //#endregion
 //#region src/core/map-values.ts
 /**
@@ -193,5 +246,5 @@ function typedFromEntries(entries) {
 }
 
 //#endregion
-export { compactObject, filterValues, hasFileExtension, hasOwn, identity, isEmpty, isRenderFunction, mapValues, normalizePathname, omit, pick, typedEntries, typedFromEntries, typedKeys };
+export { assertKeys, compactObject, filterValues, hasKeys, hasOwn, identity, isEmpty, isPlainObject, isPlainObject as isRecord, mapValues, omit, pick, requireKeys, typedEntries, typedFromEntries, typedKeys };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["result: Partial<T>","result: Partial<T>"],"sources":["../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/map-values.ts","../src/core/omit.ts","../src/core/pick.ts","../src/core/typed-entries.ts","../src/core/typed-from-entries.ts"],"sourcesContent":["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","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":";;;;;;;;;;;;;;;;;AAcA,SAAgB,UAA4B,QAAkC;AAC7E,QAAO,OAAO,KAAK,OAAO;;;;;;;;;;;;;;;;;ACA3B,SAAgB,cAAgC,QAA+B;CAC9E,MAAM,SAAS,EAAE;AAEjB,MAAK,MAAM,OAAO,UAAU,OAAO,EAAE;EACpC,MAAM,QAAQ,OAAO;AAErB,MAAI,SAAS,KACZ,QAAO,OAAO;;AAIhB,QAAO;;;;;ACDR,SAAgB,aACf,QACA,WACiD;CACjD,MAAM,SAAS,EAAE;AAEjB,MAAK,MAAM,OAAO,UAAU,OAAO,EAAE;EACpC,MAAM,QAAQ,OAAO;AAErB,MAAI,UAAU,OAAO,KAAK,OAAO,CAChC,QAAO,OAAO;;AAIhB,QAAO;;;;;;;;;;;;;;;;;;;;;ACvBR,SAAgB,OACf,QACA,KAC6B;AAC7B,QAAO,OAAO,OAAO,QAAQ,IAAI;;;;;;;;;;;;;;;;ACTlC,SAAgB,SAAY,OAAa;AACxC,QAAO;;;;;;;;;;;;;;;;;ACAR,SAAgB,QAAQ,QAAyB;AAChD,KAAI,OAAO,KAAK,OAAO,CAAC,SAAS,EAChC,QAAO;AAGR,MAAK,MAAM,OAAO,OAAO,sBAAsB,OAAO,CACrD,KAAI,OAAO,UAAU,qBAAqB,KAAK,QAAQ,IAAI,CAC1D,QAAO;AAIT,QAAO;;;;;;;;;;;;;;;;;ACRR,SAAgB,UACf,QACA,QACqB;CACrB,MAAM,SAAS,EAAE;AAEjB,MAAK,MAAM,OAAO,UAAU,OAAO,CAClC,QAAO,OAAO,OAAO,OAAO,MAAM,KAAK,OAAO;AAG/C,QAAO;;;;;ACIR,SAAgB,KACf,QACA,gBACA,GAAG,UACU;CACb,MAAM,OACL,MAAM,QAAQ,eAAe,GAC1B,iBACA,CAAC,gBAAgB,GAAG,SAAS;CAEjC,MAAM,cAAc,IAAI,IAAiB,KAA+B;CACxE,MAAMA,SAAqB,EAAE;AAE7B,MAAK,MAAM,OAAO,QAAQ,QAAQ,OAAO,CACxC,KACC,OAAO,UAAU,qBAAqB,KAAK,QAAQ,IAAI,IACvD,CAAC,YAAY,IAAI,IAAI,CAErB,CAAC,OAAa,OAAO,OAAO;AAI9B,QAAO;;;;;ACpBR,SAAgB,KACf,QACA,gBACA,GAAG,UACU;CACb,MAAM,OACL,MAAM,QAAQ,eAAe,GAC1B,iBACA,CAAC,gBAAgB,GAAG,SAAS;CAEjC,MAAMC,SAAqB,EAAE;AAE7B,MAAK,MAAM,OAAO,KACjB,KAAI,OAAO,QAAQ,IAAI,CACtB,QAAO,OAAO,OAAO;AAIvB,QAAO;;;;;;;;;;;;;;;;;;AClCR,SAAgB,aAA+B,QAA6B;AAC3E,QAAO,OAAO,QAAQ,OAAO;;;;;;;;;;;;;;;;;;;;;ACE9B,SAAgB,iBACf,SACuB;AACvB,QAAO,OAAO,YAAY,QAAQ"}
+{"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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"}

package/dist/next.d.ts

@@ -1,2 +1,23 @@
-import { t as normalizePathname } from "./index-rZiv1o95.js";
-export { normalizePathname };
+//#region src/next/normalize-pathname.d.ts
+/**
+ * Normalizes a path-like string for routing/comparison purposes.
+ *
+ * - Ensures a leading slash.
+ * - Collapses consecutive slashes into one.
+ * - 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.
+ *
+ * @example
+ * ```ts
+ * normalizePathname("dashboard"); // "/dashboard"
+ * normalizePathname("//dashboard///settings/"); // "/dashboard/settings"
+ * normalizePathname(""); // "/"
+ * ```
+ */
+declare function normalizePathname(pathname: string): string;
+//#endregion
+export { normalizePathname };
+//# sourceMappingURL=next.d.ts.map

package/dist/next.js

@@ -1,3 +1,29 @@
-import { t as normalizePathname } from "./next-C3wp7UoQ.js";
+//#region src/next/normalize-pathname.ts
+/**
+* Normalizes a path-like string for routing/comparison purposes.
+*
+* - Ensures a leading slash.
+* - Collapses consecutive slashes into one.
+* - 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.
+*
+* @example
+* ```ts
+* normalizePathname("dashboard"); // "/dashboard"
+* normalizePathname("//dashboard///settings/"); // "/dashboard/settings"
+* normalizePathname(""); // "/"
+* ```
+*/
+function normalizePathname(pathname) {
+	if (pathname === "") return "/";
+	const normalized = pathname.replace(/\/{2,}/g, "/").replace(/\/$/, "");
+	if (normalized === "") return "/";
+	return normalized.startsWith("/") ? normalized : `/${normalized}`;
+}
 
-export { normalizePathname };
+//#endregion
+export { normalizePathname };
+//# sourceMappingURL=next.js.map

package/dist/next.js.map

@@ -0,0 +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"}

package/dist/node.d.ts

@@ -1,2 +1,19 @@
-import { t as hasFileExtension } from "./index-DtjbEW43.js";
-export { hasFileExtension };
+//#region src/node/has-file-extension.d.ts
+/**
+ * Checks whether a file path ends with the given extension.
+ *
+ * The leading dot on `extension` is optional — both `"ts"` and `".ts"` are
+ * accepted. The comparison is case-sensitive and is a plain `endsWith`
+ * check, so it does not validate that `filePath` is a well-formed path.
+ *
+ * @example
+ * ```ts
+ * hasFileExtension("src/index.ts", ".ts"); // true
+ * hasFileExtension("package.json", "json"); // true
+ * hasFileExtension("README.md", "ts"); // false
+ * ```
+ */
+declare function hasFileExtension(filePath: string, extension: string): boolean;
+//#endregion
+export { hasFileExtension };
+//# sourceMappingURL=node.d.ts.map

package/dist/node.js

@@ -1,3 +1,23 @@
-import { t as hasFileExtension } from "./node-D-nlzpmG.js";
+//#region src/node/has-file-extension.ts
+/**
+* Checks whether a file path ends with the given extension.
+*
+* The leading dot on `extension` is optional — both `"ts"` and `".ts"` are
+* accepted. The comparison is case-sensitive and is a plain `endsWith`
+* check, so it does not validate that `filePath` is a well-formed path.
+*
+* @example
+* ```ts
+* hasFileExtension("src/index.ts", ".ts"); // true
+* hasFileExtension("package.json", "json"); // true
+* hasFileExtension("README.md", "ts"); // false
+* ```
+*/
+function hasFileExtension(filePath, extension) {
+	const normalizedExtension = extension.startsWith(".") ? extension : `.${extension}`;
+	return filePath.endsWith(normalizedExtension);
+}
 
-export { hasFileExtension };
+//#endregion
+export { hasFileExtension };
+//# sourceMappingURL=node.js.map

package/dist/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","names":[],"sources":["../src/node/has-file-extension.ts"],"sourcesContent":["/**\n * Checks whether a file path ends with the given extension.\n *\n * The leading dot on `extension` is optional — both `\"ts\"` and `\".ts\"` are\n * accepted. The comparison is case-sensitive and is a plain `endsWith`\n * check, so it does not validate that `filePath` is a well-formed path.\n *\n * @example\n * ```ts\n * hasFileExtension(\"src/index.ts\", \".ts\"); // true\n * hasFileExtension(\"package.json\", \"json\"); // true\n * hasFileExtension(\"README.md\", \"ts\"); // false\n * ```\n */\nexport function hasFileExtension(filePath: string, extension: string): boolean {\n\tconst normalizedExtension = extension.startsWith(\".\")\n\t\t? extension\n\t\t: `.${extension}`;\n\n\treturn filePath.endsWith(normalizedExtension);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAcA,SAAgB,iBAAiB,UAAkB,WAA4B;CAC9E,MAAM,sBAAsB,UAAU,WAAW,IAAI,GAClD,YACA,IAAI;AAEP,QAAO,SAAS,SAAS,oBAAoB"}

package/dist/react.d.ts

@@ -1,2 +1,22 @@
-import { t as isRenderFunction } from "./index-dktuz4mv.js";
-export { isRenderFunction };
+//#region src/react/is-render-function.d.ts
+/**
+ * Type guard for values that are callable in render-oriented code paths
+ * (e.g. `children` passed as a render prop).
+ *
+ * Matches any callable value, including async functions, generator
+ * functions, and class constructors — it does not distinguish between
+ * function kinds, only "is this safe to call as a function".
+ *
+ * @example
+ * ```ts
+ * const children: unknown = () => "ready";
+ *
+ * if (isRenderFunction(children)) {
+ *   children();
+ * }
+ * ```
+ */
+declare function isRenderFunction(value: unknown): value is (...args: readonly unknown[]) => unknown;
+//#endregion
+export { isRenderFunction };
+//# sourceMappingURL=react.d.ts.map

package/dist/react.js

@@ -1,3 +1,25 @@
-import { t as isRenderFunction } from "./react-BCidSnzT.js";
+//#region src/react/is-render-function.ts
+/**
+* Type guard for values that are callable in render-oriented code paths
+* (e.g. `children` passed as a render prop).
+*
+* Matches any callable value, including async functions, generator
+* functions, and class constructors — it does not distinguish between
+* function kinds, only "is this safe to call as a function".
+*
+* @example
+* ```ts
+* const children: unknown = () => "ready";
+*
+* if (isRenderFunction(children)) {
+*   children();
+* }
+* ```
+*/
+function isRenderFunction(value) {
+	return typeof value === "function";
+}
 
-export { isRenderFunction };
+//#endregion
+export { isRenderFunction };
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","names":[],"sources":["../src/react/is-render-function.ts"],"sourcesContent":["/**\n * Type guard for values that are callable in render-oriented code paths\n * (e.g. `children` passed as a render prop).\n *\n * Matches any callable value, including async functions, generator\n * functions, and class constructors — it does not distinguish between\n * function kinds, only \"is this safe to call as a function\".\n *\n * @example\n * ```ts\n * const children: unknown = () => \"ready\";\n *\n * if (isRenderFunction(children)) {\n *   children();\n * }\n * ```\n */\nexport function isRenderFunction(\n\tvalue: unknown,\n): value is (...args: readonly unknown[]) => unknown {\n\treturn typeof value === \"function\";\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,SAAgB,iBACf,OACoD;AACpD,QAAO,OAAO,UAAU"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umsizi",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "A zero-dependency TypeScript utility library.",
   "license": "MIT",
   "author": "Jack-WebDev",

package/dist/index-DtjbEW43.d.ts

@@ -1,19 +0,0 @@
-//#region src/node/has-file-extension.d.ts
-/**
- * Checks whether a file path ends with the given extension.
- *
- * The leading dot on `extension` is optional — both `"ts"` and `".ts"` are
- * accepted. The comparison is case-sensitive and is a plain `endsWith`
- * check, so it does not validate that `filePath` is a well-formed path.
- *
- * @example
- * ```ts
- * hasFileExtension("src/index.ts", ".ts"); // true
- * hasFileExtension("package.json", "json"); // true
- * hasFileExtension("README.md", "ts"); // false
- * ```
- */
-declare function hasFileExtension(filePath: string, extension: string): boolean;
-//#endregion
-export { hasFileExtension as t };
-//# sourceMappingURL=index-DtjbEW43.d.ts.map

package/dist/index-dktuz4mv.d.ts

@@ -1,22 +0,0 @@
-//#region src/react/is-render-function.d.ts
-/**
- * Type guard for values that are callable in render-oriented code paths
- * (e.g. `children` passed as a render prop).
- *
- * Matches any callable value, including async functions, generator
- * functions, and class constructors — it does not distinguish between
- * function kinds, only "is this safe to call as a function".
- *
- * @example
- * ```ts
- * const children: unknown = () => "ready";
- *
- * if (isRenderFunction(children)) {
- *   children();
- * }
- * ```
- */
-declare function isRenderFunction(value: unknown): value is (...args: readonly unknown[]) => unknown;
-//#endregion
-export { isRenderFunction as t };
-//# sourceMappingURL=index-dktuz4mv.d.ts.map

package/dist/index-rZiv1o95.d.ts

@@ -1,23 +0,0 @@
-//#region src/next/normalize-pathname.d.ts
-/**
- * Normalizes a path-like string for routing/comparison purposes.
- *
- * - Ensures a leading slash.
- * - Collapses consecutive slashes into one.
- * - 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.
- *
- * @example
- * ```ts
- * normalizePathname("dashboard"); // "/dashboard"
- * normalizePathname("//dashboard///settings/"); // "/dashboard/settings"
- * normalizePathname(""); // "/"
- * ```
- */
-declare function normalizePathname(pathname: string): string;
-//#endregion
-export { normalizePathname as t };
-//# sourceMappingURL=index-rZiv1o95.d.ts.map

package/dist/next-C3wp7UoQ.js

@@ -1,29 +0,0 @@
-//#region src/next/normalize-pathname.ts
-/**
-* Normalizes a path-like string for routing/comparison purposes.
-*
-* - Ensures a leading slash.
-* - Collapses consecutive slashes into one.
-* - 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.
-*
-* @example
-* ```ts
-* normalizePathname("dashboard"); // "/dashboard"
-* normalizePathname("//dashboard///settings/"); // "/dashboard/settings"
-* normalizePathname(""); // "/"
-* ```
-*/
-function normalizePathname(pathname) {
-	if (pathname === "") return "/";
-	const normalized = pathname.replace(/\/{2,}/g, "/").replace(/\/$/, "");
-	if (normalized === "") return "/";
-	return normalized.startsWith("/") ? normalized : `/${normalized}`;
-}
-
-//#endregion
-export { normalizePathname as t };
-//# sourceMappingURL=next-C3wp7UoQ.js.map

package/dist/next-C3wp7UoQ.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"next-C3wp7UoQ.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"}

package/dist/node-D-nlzpmG.js

@@ -1,23 +0,0 @@
-//#region src/node/has-file-extension.ts
-/**
-* Checks whether a file path ends with the given extension.
-*
-* The leading dot on `extension` is optional — both `"ts"` and `".ts"` are
-* accepted. The comparison is case-sensitive and is a plain `endsWith`
-* check, so it does not validate that `filePath` is a well-formed path.
-*
-* @example
-* ```ts
-* hasFileExtension("src/index.ts", ".ts"); // true
-* hasFileExtension("package.json", "json"); // true
-* hasFileExtension("README.md", "ts"); // false
-* ```
-*/
-function hasFileExtension(filePath, extension) {
-	const normalizedExtension = extension.startsWith(".") ? extension : `.${extension}`;
-	return filePath.endsWith(normalizedExtension);
-}
-
-//#endregion
-export { hasFileExtension as t };
-//# sourceMappingURL=node-D-nlzpmG.js.map

package/dist/node-D-nlzpmG.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"node-D-nlzpmG.js","names":[],"sources":["../src/node/has-file-extension.ts"],"sourcesContent":["/**\n * Checks whether a file path ends with the given extension.\n *\n * The leading dot on `extension` is optional — both `\"ts\"` and `\".ts\"` are\n * accepted. The comparison is case-sensitive and is a plain `endsWith`\n * check, so it does not validate that `filePath` is a well-formed path.\n *\n * @example\n * ```ts\n * hasFileExtension(\"src/index.ts\", \".ts\"); // true\n * hasFileExtension(\"package.json\", \"json\"); // true\n * hasFileExtension(\"README.md\", \"ts\"); // false\n * ```\n */\nexport function hasFileExtension(filePath: string, extension: string): boolean {\n\tconst normalizedExtension = extension.startsWith(\".\")\n\t\t? extension\n\t\t: `.${extension}`;\n\n\treturn filePath.endsWith(normalizedExtension);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAcA,SAAgB,iBAAiB,UAAkB,WAA4B;CAC9E,MAAM,sBAAsB,UAAU,WAAW,IAAI,GAClD,YACA,IAAI;AAEP,QAAO,SAAS,SAAS,oBAAoB"}

package/dist/react-BCidSnzT.js

@@ -1,25 +0,0 @@
-//#region src/react/is-render-function.ts
-/**
-* Type guard for values that are callable in render-oriented code paths
-* (e.g. `children` passed as a render prop).
-*
-* Matches any callable value, including async functions, generator
-* functions, and class constructors — it does not distinguish between
-* function kinds, only "is this safe to call as a function".
-*
-* @example
-* ```ts
-* const children: unknown = () => "ready";
-*
-* if (isRenderFunction(children)) {
-*   children();
-* }
-* ```
-*/
-function isRenderFunction(value) {
-	return typeof value === "function";
-}
-
-//#endregion
-export { isRenderFunction as t };
-//# sourceMappingURL=react-BCidSnzT.js.map

package/dist/react-BCidSnzT.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-BCidSnzT.js","names":[],"sources":["../src/react/is-render-function.ts"],"sourcesContent":["/**\n * Type guard for values that are callable in render-oriented code paths\n * (e.g. `children` passed as a render prop).\n *\n * Matches any callable value, including async functions, generator\n * functions, and class constructors — it does not distinguish between\n * function kinds, only \"is this safe to call as a function\".\n *\n * @example\n * ```ts\n * const children: unknown = () => \"ready\";\n *\n * if (isRenderFunction(children)) {\n *   children();\n * }\n * ```\n */\nexport function isRenderFunction(\n\tvalue: unknown,\n): value is (...args: readonly unknown[]) => unknown {\n\treturn typeof value === \"function\";\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,SAAgB,iBACf,OACoD;AACpD,QAAO,OAAO,UAAU"}