ts-data-forge 8.0.0 → 9.0.1

package/dist/functional/ternary-result/impl/variant-name.mjs

@@ -1,15 +1,14 @@
 import { ErrTypeTagName, WarnTypeTagName, OkTypeTagName } from './tag.mjs';
 
-/** @internal Returns the human readable variant label for the given tag. */
 const variantName = (tag) => {
-    switch (tag) {
-        case OkTypeTagName:
-            return 'Ok';
-        case WarnTypeTagName:
-            return 'Warn';
-        case ErrTypeTagName:
-            return 'Err';
-    }
+  switch (tag) {
+    case OkTypeTagName:
+      return "Ok";
+    case WarnTypeTagName:
+      return "Warn";
+    case ErrTypeTagName:
+      return "Err";
+  }
 };
 
 export { variantName };

package/dist/functional/ternary-result/impl/variant-name.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"variant-name.mjs","sources":["../../../../src/functional/ternary-result/impl/variant-name.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;AACO,MAAM,WAAW,GAAG,CACzB,GAAkC,KACT;IACzB,QAAQ,GAAG;AACT,QAAA,KAAK,aAAa;AAChB,YAAA,OAAO,IAAI;AAEb,QAAA,KAAK,eAAe;AAClB,YAAA,OAAO,MAAM;AAEf,QAAA,KAAK,cAAc;AACjB,YAAA,OAAO,KAAK;;AAElB;;;;"}
+{"version":3,"file":"variant-name.mjs","sources":["../../../../src/functional/ternary-result/impl/variant-name.mts"],"sourcesContent":["import { type UnknownTernaryResult } from '../ternary-result.mjs';\nimport { ErrTypeTagName, OkTypeTagName, WarnTypeTagName } from './tag.mjs';\n\n/** @internal Returns the human readable variant label for the given tag. */\nexport const variantName = (\n  tag: UnknownTernaryResult['$$tag'],\n): 'Ok' | 'Warn' | 'Err' => {\n  switch (tag) {\n    case OkTypeTagName:\n      return 'Ok';\n\n    case WarnTypeTagName:\n      return 'Warn';\n\n    case ErrTypeTagName:\n      return 'Err';\n  }\n};\n"],"names":[],"mappings":";;AAIO,MAAM,WAAA,GAAc,CACzB,GAAA,KAC0B;AAC1B,EAAA,QAAQ,GAAA;AAAK,IACX,KAAK,aAAA;AACH,MAAA,OAAO,IAAA;AAAA,IAET,KAAK,eAAA;AACH,MAAA,OAAO,MAAA;AAAA,IAET,KAAK,cAAA;AACH,MAAA,OAAO,KAAA;AAAA;AAEb;;;;"}

package/dist/functional/ternary-result/ternary-result.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result.d.mts","sourceRoot":"","sources":["../../../src/functional/ternary-result/ternary-result.mts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,QAAQ,CAAC;IAClC,yDAAyD;IACzD,KAAK,EAAE,0BAA0B,CAAC;IAElC,yBAAyB;IACzB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC;IACvC,2DAA2D;IAC3D,KAAK,EAAE,4BAA4B,CAAC;IAEpC,yBAAyB;IACzB,KAAK,EAAE,CAAC,CAAC;IAET,yBAAyB;IACzB,OAAO,EAAE,CAAC,CAAC;CACZ,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,QAAQ,CAAC;IACnC,0DAA0D;IAC1D,KAAK,EAAE,2BAA2B,CAAC;IAEnC,uBAAuB;IACvB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,IACjC,SAAS,CAAC,CAAC,CAAC,GACZ,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GACjB,UAAU,CAAC,CAAC,CAAC,CAAC;AAElB;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAC5B,SAAS,CAAC,OAAO,CAAC,GAClB,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAC7B,UAAU,CAAC,OAAO,CAAC,CAAC;AAExB,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"ternary-result.d.mts","sourceRoot":"","sources":["../../../src/functional/ternary-result/ternary-result.mts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,QAAQ,CAAC;IAClC,yDAAyD;IACzD,KAAK,EAAE,0BAA0B,CAAC;IAElC,yBAAyB;IACzB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC;IACvC,2DAA2D;IAC3D,KAAK,EAAE,4BAA4B,CAAC;IAEpC,yBAAyB;IACzB,KAAK,EAAE,CAAC,CAAC;IAET,yBAAyB;IACzB,OAAO,EAAE,CAAC,CAAC;CACZ,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,QAAQ,CAAC;IACnC,0DAA0D;IAC1D,KAAK,EAAE,2BAA2B,CAAC;IAEnC,uBAAuB;IACvB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,IACnC,SAAS,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAC9B,SAAS,CAAC,OAAO,CAAC,GAAG,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;AAE3E,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC"}

package/dist/guard/has-key.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"has-key.d.mts","sourceRoot":"","sources":["../../src/guard/has-key.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,MAAM,GACjB,KAAK,CAAC,CAAC,SAAS,aAAa,EAC7B,KAAK,CAAC,CAAC,SAAS,WAAW,EAE3B,KAAK,CAAC,EACN,KAAK,CAAC,KACL,GAAG,IAAI,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAA4B,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,aAAa,EACvB,CAAC,SAAS,WAAW,IACnB,CAAC,SAAS,CAAC,GACX,CAAC,SAAS,MAAM,CAAC,GACf,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,CAAC,GACP,KAAK,GACP,KAAK,CAAC"}
+{"version":3,"file":"has-key.d.mts","sourceRoot":"","sources":["../../src/guard/has-key.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,MAAM,GACjB,KAAK,CAAC,CAAC,SAAS,aAAa,EAC7B,KAAK,CAAC,CAAC,SAAS,WAAW,OAEtB,CAAC,OACD,CAAC,KACL,GAAG,IAAI,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAA4B,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,aAAa,EACvB,CAAC,SAAS,WAAW,IACnB,CAAC,SAAS,CAAC,GACX,CAAC,SAAS,MAAM,CAAC,GACf,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,CAAC,GACP,KAAK,GACP,KAAK,CAAC"}

package/dist/guard/has-key.mjs

@@ -1,44 +1,3 @@
-/**
- * Type guard function that checks if an object has a specific key as its own
- * property.
- *
- * This function uses `Object.hasOwn()` to check if the given object has the
- * specified key as its own property (not inherited). It acts as a type guard
- * that narrows the type of the object to guarantee the key exists, enabling
- * type-safe property access.
- *
- * **Type Narrowing Behavior:**
- *
- * - When the guard returns `true`, TypeScript narrows the object type to include
- *   the checked key
- * - For union types, only union members that contain the key are preserved
- * - The key's value type is preserved from the original object type when possible
- *
- * @example
- *
- * ```ts
- * const maybeUser: Readonly<{ id?: number; name?: string }> = {
- *   id: 42,
- * } as const;
- *
- * if (hasKey(maybeUser, 'id')) {
- *   // `maybeUser` is now known to have an `id` property.
- *   assert.isTrue(maybeUser.id === 42);
- * } else {
- *   assert.fail();
- * }
- * ```
- *
- * @template R - The type of the input object, must extend UnknownRecord
- * @template K - The type of the key to check for, must extend PropertyKey
- *   (string | number | symbol)
- * @param obj - The object to check for the presence of the key
- * @param key - The key to check for in the object
- * @returns `true` if the object has the specified key as its own property,
- *   `false` otherwise. When `true`, TypeScript narrows the object type to
- *   guarantee the key exists.
- * @see {@link keyIsIn} - Similar function that narrows the key type instead of the object type
- */
 const hasKey = (obj, key) => Object.hasOwn(obj, key);
 
 export { hasKey };

package/dist/guard/has-key.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"has-key.mjs","sources":["../../src/guard/has-key.mts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCG;AACI,MAAM,MAAM,GAAG,CAIpB,GAAM,EACN,GAAM,KAC4B,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG;;;;"}
+{"version":3,"file":"has-key.mjs","sources":["../../src/guard/has-key.mts"],"sourcesContent":["import { type ReadonlyRecord, type UnknownRecord } from 'ts-type-forge';\n\n/**\n * Type guard function that checks if an object has a specific key as its own\n * property.\n *\n * This function uses `Object.hasOwn()` to check if the given object has the\n * specified key as its own property (not inherited). It acts as a type guard\n * that narrows the type of the object to guarantee the key exists, enabling\n * type-safe property access.\n *\n * **Type Narrowing Behavior:**\n *\n * - When the guard returns `true`, TypeScript narrows the object type to include\n *   the checked key\n * - For union types, only union members that contain the key are preserved\n * - The key's value type is preserved from the original object type when possible\n *\n * @example\n *\n * ```ts\n * const maybeUser: Readonly<{ id?: number; name?: string }> = {\n *   id: 42,\n * } as const;\n *\n * if (hasKey(maybeUser, 'id')) {\n *   // `maybeUser` is now known to have an `id` property.\n *   assert.isTrue(maybeUser.id === 42);\n * } else {\n *   assert.fail();\n * }\n * ```\n *\n * @template R - The type of the input object, must extend UnknownRecord\n * @template K - The type of the key to check for, must extend PropertyKey\n *   (string | number | symbol)\n * @param obj - The object to check for the presence of the key\n * @param key - The key to check for in the object\n * @returns `true` if the object has the specified key as its own property,\n *   `false` otherwise. When `true`, TypeScript narrows the object type to\n *   guarantee the key exists.\n * @see {@link keyIsIn} - Similar function that narrows the key type instead of the object type\n */\nexport const hasKey = <\n  const R extends UnknownRecord,\n  const K extends PropertyKey,\n>(\n  obj: R,\n  key: K,\n): obj is HasKeyReturnType<R, K> => Object.hasOwn(obj, key);\n\n/**\n * @internal\n * When R is a union type (including the case with only one element), if any element in the union\n * contains K as a key, returns a type that narrows the union to only those elements that contain K as a key.\n * If none of the elements in the union contain K as a key, returns `ReadonlyRecord<K, unknown>`.\n * The result is made readonly.\n */\nexport type HasKeyReturnType<\n  R extends UnknownRecord,\n  K extends PropertyKey,\n> = R extends R // union distribution\n  ? K extends keyof R\n    ? string extends keyof R\n      ? ReadonlyRecord<K, R[keyof R]> & R\n      : number extends keyof R\n        ? ReadonlyRecord<K, R[keyof R]> & R\n        : symbol extends keyof R\n          ? ReadonlyRecord<K, R[keyof R]> & R\n          : R\n    : never // omit union member that does not have key K\n  : never; // dummy case for union distribution\n"],"names":[],"mappings":"AA2CO,MAAM,SAAS,CAIpB,GAAA,EACA,QACkC,MAAA,CAAO,MAAA,CAAO,KAAK,GAAG;;;;"}

package/dist/guard/index.d.mts

@@ -1,4 +1,5 @@
 export * from './has-key.mjs';
+export * from './is-length-bounded-string.mjs';
 export * from './is-non-empty-string.mjs';
 export * from './is-non-null-object.mjs';
 export * from './is-primitive.mjs';

package/dist/guard/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/guard/index.mts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/guard/index.mts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}

package/dist/guard/index.mjs

@@ -1,4 +1,5 @@
 export { hasKey } from './has-key.mjs';
+export { isBoundedLengthString, isFixedLengthString, isMaxLengthString, isMinLengthString } from './is-length-bounded-string.mjs';
 export { isNonEmptyString } from './is-non-empty-string.mjs';
 export { isNonNullObject } from './is-non-null-object.mjs';
 export { isPrimitive } from './is-primitive.mjs';

package/dist/guard/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}

package/dist/guard/is-length-bounded-string.d.mts

@@ -0,0 +1,164 @@
+import { type BoundedLengthString, type FixedLengthString, type MaxLengthString, type MinLengthString } from 'ts-type-forge';
+import { type SizeType } from '../types.mjs';
+/**
+ * Type guard that checks if a string has at least `minLength` characters.
+ *
+ * The length is measured in UTF-16 code units (the same unit as
+ * `String.prototype.length`), so characters outside the Basic Multilingual
+ * Plane (e.g. emoji) count as 2.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input to `MinLengthString<MinLength>` while preserving the
+ *   original string type (e.g. literal types) via intersection.
+ * - The result participates in the length-constraint subtyping relation: for
+ *   example, a value narrowed to `MinLengthString<3>` is assignable to
+ *   `MinLengthString<1>` (= `NonEmptyString`).
+ *
+ * @example
+ *
+ * ```ts
+ * const input: string = 'very-secret-password';
+ *
+ * assert.isTrue(isMinLengthString(input, 12));
+ *
+ * assert.isFalse(isMinLengthString('short', 12));
+ *
+ * if (isMinLengthString(input, 12)) {
+ *   const password: MinLengthString<12> = input;
+ *
+ *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)
+ * }
+ * ```
+ *
+ * @template S - The input string type (literal types are preserved).
+ * @template MinLength - The minimum number of characters (inclusive).
+ * @param s - The string to check.
+ * @param minLength - The minimum number of characters (inclusive).
+ * @returns `true` if `s.length >= minLength`, `false` otherwise. When `true`,
+ *   TypeScript narrows `s` to `MinLengthString<MinLength> & S`.
+ */
+export declare const isMinLengthString: <S extends string, MinLength extends SizeType.ArgStr>(s: S, minLength: MinLength) => s is MinLengthString<MinLength> & S;
+/**
+ * Type guard that checks if a string has at most `maxLength` characters.
+ *
+ * The length is measured in UTF-16 code units (the same unit as
+ * `String.prototype.length`), so characters outside the Basic Multilingual
+ * Plane (e.g. emoji) count as 2.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input to `MaxLengthString<MaxLength>` while preserving the
+ *   original string type (e.g. literal types) via intersection.
+ * - The result participates in the length-constraint subtyping relation: for
+ *   example, a value narrowed to `MaxLengthString<16>` is assignable to
+ *   `MaxLengthString<32>`.
+ *
+ * @example
+ *
+ * ```ts
+ * const input: string = 'noshiro';
+ *
+ * assert.isTrue(isMaxLengthString(input, 32));
+ *
+ * assert.isFalse(isMaxLengthString(input, 3));
+ *
+ * if (isMaxLengthString(input, 32)) {
+ *   const userName: MaxLengthString<32> = input;
+ *
+ *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)
+ * }
+ * ```
+ *
+ * @template S - The input string type (literal types are preserved).
+ * @template MaxLength - The maximum number of characters (inclusive).
+ * @param s - The string to check.
+ * @param maxLength - The maximum number of characters (inclusive).
+ * @returns `true` if `s.length <= maxLength`, `false` otherwise. When `true`,
+ *   TypeScript narrows `s` to `MaxLengthString<MaxLength> & S`.
+ */
+export declare const isMaxLengthString: <S extends string, MaxLength extends SizeType.ArgStr>(s: S, maxLength: MaxLength) => s is MaxLengthString<MaxLength> & S;
+/**
+ * Type guard that checks if a string's length is within the inclusive range
+ * `[minLength, maxLength]`.
+ *
+ * The length is measured in UTF-16 code units (the same unit as
+ * `String.prototype.length`), so characters outside the Basic Multilingual
+ * Plane (e.g. emoji) count as 2.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input to `BoundedLengthString<MinLength, MaxLength>` while
+ *   preserving the original string type (e.g. literal types) via intersection.
+ * - Since `BoundedLengthString` is the intersection of `MinLengthString` and
+ *   `MaxLengthString`, the narrowed value is assignable to both, and both
+ *   bounds can be weakened independently.
+ *
+ * @example
+ *
+ * ```ts
+ * const input: string = 'user-12345678';
+ *
+ * assert.isTrue(isBoundedLengthString(input, 8, 16));
+ *
+ * assert.isFalse(isBoundedLengthString('user', 8, 16));
+ *
+ * if (isBoundedLengthString(input, 8, 16)) {
+ *   const userId: BoundedLengthString<8, 16> = input;
+ *
+ *   const relaxed: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])
+ * }
+ * ```
+ *
+ * @template S - The input string type (literal types are preserved).
+ * @template MinLength - The minimum number of characters (inclusive).
+ * @template MaxLength - The maximum number of characters (inclusive).
+ * @param s - The string to check.
+ * @param minLength - The minimum number of characters (inclusive).
+ * @param maxLength - The maximum number of characters (inclusive).
+ * @returns `true` if `minLength <= s.length && s.length <= maxLength`, `false`
+ *   otherwise. When `true`, TypeScript narrows `s` to
+ *   `BoundedLengthString<MinLength, MaxLength> & S`.
+ */
+export declare const isBoundedLengthString: <S extends string, MinLength extends SizeType.ArgStr, MaxLength extends SizeType.ArgStr>(s: S, minLength: MinLength, maxLength: MaxLength) => s is BoundedLengthString<MinLength, MaxLength> & S;
+/**
+ * Type guard that checks if a string has exactly `length` characters.
+ *
+ * The length is measured in UTF-16 code units (the same unit as
+ * `String.prototype.length`), so characters outside the Basic Multilingual
+ * Plane (e.g. emoji) count as 2.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input to `FixedLengthString<Length>` while preserving the
+ *   original string type (e.g. literal types) via intersection.
+ * - Since `FixedLengthString<Length>` is defined as
+ *   `BoundedLengthString<Length, Length>`, the narrowed value is assignable to
+ *   any `MinLengthString<N>` with `N <= Length` and any `MaxLengthString<N>`
+ *   with `N >= Length`.
+ *
+ * @example
+ *
+ * ```ts
+ * const input: string = 'JP';
+ *
+ * assert.isTrue(isFixedLengthString(input, 2));
+ *
+ * assert.isFalse(isFixedLengthString(input, 3));
+ *
+ * if (isFixedLengthString(input, 2)) {
+ *   const countryCode: FixedLengthString<2> = input;
+ *
+ *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)
+ * }
+ * ```
+ *
+ * @template S - The input string type (literal types are preserved).
+ * @template Length - The exact number of characters.
+ * @param s - The string to check.
+ * @param length - The exact number of characters.
+ * @returns `true` if `s.length === length`, `false` otherwise. When `true`,
+ *   TypeScript narrows `s` to `FixedLengthString<Length> & S`.
+ */
+export declare const isFixedLengthString: <S extends string, Length extends SizeType.ArgStr>(s: S, length: Length) => s is FixedLengthString<Length> & S;
+//# sourceMappingURL=is-length-bounded-string.d.mts.map

package/dist/guard/is-length-bounded-string.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-length-bounded-string.d.mts","sourceRoot":"","sources":["../../src/guard/is-length-bounded-string.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,QAAQ,CAAC,MAAM,KAE9B,CAAC,aACO,SAAS,KACnB,CAAC,IAAI,eAAe,CAAC,SAAS,CAAC,GAAG,CAA0B,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,QAAQ,CAAC,MAAM,KAE9B,CAAC,aACO,SAAS,KACnB,CAAC,IAAI,eAAe,CAAC,SAAS,CAAC,GAAG,CAA0B,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,qBAAqB,GAChC,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,QAAQ,CAAC,MAAM,EACjC,SAAS,SAAS,QAAQ,CAAC,MAAM,KAE9B,CAAC,aACO,SAAS,aACT,SAAS,KACnB,CAAC,IAAI,mBAAmB,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,CACJ,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,mBAAmB,GAC9B,CAAC,SAAS,MAAM,EAChB,MAAM,SAAS,QAAQ,CAAC,MAAM,KAE3B,CAAC,UACI,MAAM,KACb,CAAC,IAAI,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAAwB,CAAC"}

package/dist/guard/is-length-bounded-string.mjs

@@ -0,0 +1,7 @@
+const isMinLengthString = (s, minLength) => s.length >= minLength;
+const isMaxLengthString = (s, maxLength) => s.length <= maxLength;
+const isBoundedLengthString = (s, minLength, maxLength) => s.length >= minLength && s.length <= maxLength;
+const isFixedLengthString = (s, length) => s.length === length;
+
+export { isBoundedLengthString, isFixedLengthString, isMaxLengthString, isMinLengthString };
+//# sourceMappingURL=is-length-bounded-string.mjs.map

package/dist/guard/is-length-bounded-string.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-length-bounded-string.mjs","sources":["../../src/guard/is-length-bounded-string.mts"],"sourcesContent":["import {\n  type BoundedLengthString,\n  type FixedLengthString,\n  type MaxLengthString,\n  type MinLengthString,\n} from 'ts-type-forge';\nimport { type SizeType } from '../types.mjs';\n\n/**\n * Type guard that checks if a string has at least `minLength` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MinLengthString<MinLength>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MinLengthString<3>` is assignable to\n *   `MinLengthString<1>` (= `NonEmptyString`).\n *\n * @example\n *\n * ```ts\n * const input: string = 'very-secret-password';\n *\n * assert.isTrue(isMinLengthString(input, 12));\n *\n * assert.isFalse(isMinLengthString('short', 12));\n *\n * if (isMinLengthString(input, 12)) {\n *   const password: MinLengthString<12> = input;\n *\n *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MinLength - The minimum number of characters (inclusive).\n * @param s - The string to check.\n * @param minLength - The minimum number of characters (inclusive).\n * @returns `true` if `s.length >= minLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `MinLengthString<MinLength> & S`.\n */\nexport const isMinLengthString = <\n  S extends string,\n  MinLength extends SizeType.ArgStr,\n>(\n  s: S,\n  minLength: MinLength,\n): s is MinLengthString<MinLength> & S => s.length >= minLength;\n\n/**\n * Type guard that checks if a string has at most `maxLength` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MaxLengthString<MaxLength>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MaxLengthString<16>` is assignable to\n *   `MaxLengthString<32>`.\n *\n * @example\n *\n * ```ts\n * const input: string = 'noshiro';\n *\n * assert.isTrue(isMaxLengthString(input, 32));\n *\n * assert.isFalse(isMaxLengthString(input, 3));\n *\n * if (isMaxLengthString(input, 32)) {\n *   const userName: MaxLengthString<32> = input;\n *\n *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MaxLength - The maximum number of characters (inclusive).\n * @param s - The string to check.\n * @param maxLength - The maximum number of characters (inclusive).\n * @returns `true` if `s.length <= maxLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `MaxLengthString<MaxLength> & S`.\n */\nexport const isMaxLengthString = <\n  S extends string,\n  MaxLength extends SizeType.ArgStr,\n>(\n  s: S,\n  maxLength: MaxLength,\n): s is MaxLengthString<MaxLength> & S => s.length <= maxLength;\n\n/**\n * Type guard that checks if a string's length is within the inclusive range\n * `[minLength, maxLength]`.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `BoundedLengthString<MinLength, MaxLength>` while\n *   preserving the original string type (e.g. literal types) via intersection.\n * - Since `BoundedLengthString` is the intersection of `MinLengthString` and\n *   `MaxLengthString`, the narrowed value is assignable to both, and both\n *   bounds can be weakened independently.\n *\n * @example\n *\n * ```ts\n * const input: string = 'user-12345678';\n *\n * assert.isTrue(isBoundedLengthString(input, 8, 16));\n *\n * assert.isFalse(isBoundedLengthString('user', 8, 16));\n *\n * if (isBoundedLengthString(input, 8, 16)) {\n *   const userId: BoundedLengthString<8, 16> = input;\n *\n *   const relaxed: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MinLength - The minimum number of characters (inclusive).\n * @template MaxLength - The maximum number of characters (inclusive).\n * @param s - The string to check.\n * @param minLength - The minimum number of characters (inclusive).\n * @param maxLength - The maximum number of characters (inclusive).\n * @returns `true` if `minLength <= s.length && s.length <= maxLength`, `false`\n *   otherwise. When `true`, TypeScript narrows `s` to\n *   `BoundedLengthString<MinLength, MaxLength> & S`.\n */\nexport const isBoundedLengthString = <\n  S extends string,\n  MinLength extends SizeType.ArgStr,\n  MaxLength extends SizeType.ArgStr,\n>(\n  s: S,\n  minLength: MinLength,\n  maxLength: MaxLength,\n): s is BoundedLengthString<MinLength, MaxLength> & S =>\n  s.length >= minLength && s.length <= maxLength;\n\n/**\n * Type guard that checks if a string has exactly `length` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `FixedLengthString<Length>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - Since `FixedLengthString<Length>` is defined as\n *   `BoundedLengthString<Length, Length>`, the narrowed value is assignable to\n *   any `MinLengthString<N>` with `N <= Length` and any `MaxLengthString<N>`\n *   with `N >= Length`.\n *\n * @example\n *\n * ```ts\n * const input: string = 'JP';\n *\n * assert.isTrue(isFixedLengthString(input, 2));\n *\n * assert.isFalse(isFixedLengthString(input, 3));\n *\n * if (isFixedLengthString(input, 2)) {\n *   const countryCode: FixedLengthString<2> = input;\n *\n *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template Length - The exact number of characters.\n * @param s - The string to check.\n * @param length - The exact number of characters.\n * @returns `true` if `s.length === length`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `FixedLengthString<Length> & S`.\n */\nexport const isFixedLengthString = <\n  S extends string,\n  Length extends SizeType.ArgStr,\n>(\n  s: S,\n  length: Length,\n): s is FixedLengthString<Length> & S => s.length === length;\n"],"names":[],"mappings":"AA8CO,MAAM,iBAAA,GAAoB,CAI/B,CAAA,EACA,SAAA,KACwC,EAAE,MAAA,IAAU;AAwC/C,MAAM,iBAAA,GAAoB,CAI/B,CAAA,EACA,SAAA,KACwC,EAAE,MAAA,IAAU;AA4C/C,MAAM,qBAAA,GAAwB,CAKnC,CAAA,EACA,SAAA,EACA,cAEA,CAAA,CAAE,MAAA,IAAU,SAAA,IAAa,CAAA,CAAE,MAAA,IAAU;AAyChC,MAAM,mBAAA,GAAsB,CAIjC,CAAA,EACA,MAAA,KACuC,EAAE,MAAA,KAAW;;;;"}

package/dist/guard/is-non-empty-string.d.mts

@@ -36,5 +36,5 @@ import { type NonEmptyString, type RelaxedExclude } from 'ts-type-forge';
  *   `true`, TypeScript narrows the type to exclude empty strings and nullish
  *   values.
  */
-export declare const isNonEmptyString: <S extends string | null | undefined>(s: S) => s is NonEmptyString & RelaxedExclude<NonNullable<S>, "">;
+export declare const isNonEmptyString: <S extends string | null | undefined>(s: S) => s is NonEmptyString & RelaxedExclude<NonNullable<S>, ''>;
 //# sourceMappingURL=is-non-empty-string.d.mts.map

package/dist/guard/is-non-empty-string.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-empty-string.d.mts","sourceRoot":"","sources":["../../src/guard/is-non-empty-string.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,MAAM,GAAG,IAAI,GAAG,SAAS,EAClE,GAAG,CAAC,KACH,CAAC,IAAI,cAAc,GAAG,cAAc,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,CACnB,CAAC"}
+{"version":3,"file":"is-non-empty-string.d.mts","sourceRoot":"","sources":["../../src/guard/is-non-empty-string.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,MAAM,GAAG,IAAI,GAAG,SAAS,KAC/D,CAAC,KACH,CAAC,IAAI,cAAc,GAAG,cAAc,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,CACnB,CAAC"}

package/dist/guard/is-non-empty-string.mjs

@@ -1,41 +1,4 @@
-/**
- * Type guard that checks if a value is a non-empty string.
- *
- * This function performs both a type check (ensuring the value is a string) and
- * a length check (ensuring the string is not empty). It acts as a type guard
- * that narrows the input type to exclude `null`, `undefined`, and empty
- * strings.
- *
- * **Type Narrowing Behavior:**
- *
- * - Eliminates `null` and `undefined` from the type
- * - Excludes empty string (`""`) from the type
- * - Preserves literal string types when possible
- * - Whitespace-only strings are considered non-empty
- *
- * @example
- *
- * ```ts
- * const words: readonly (string | undefined)[] = [
- *   'Ada',
- *   undefined,
- *   '',
- *   'Lovelace',
- * ] as const;
- *
- * const nonEmpty = words.filter(isNonEmptyString);
- *
- * assert.deepStrictEqual(nonEmpty, ['Ada', 'Lovelace']);
- * ```
- *
- * @template S - The input type, which can include `string`, `null`, or
- *   `undefined`
- * @param s - The value to check
- * @returns `true` if `s` is a string with length > 0, `false` otherwise. When
- *   `true`, TypeScript narrows the type to exclude empty strings and nullish
- *   values.
- */
-const isNonEmptyString = (s) => typeof s === 'string' && s.length > 0;
+const isNonEmptyString = (s) => typeof s === "string" && s.length > 0;
 
 export { isNonEmptyString };
 //# sourceMappingURL=is-non-empty-string.mjs.map

package/dist/guard/is-non-empty-string.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-empty-string.mjs","sources":["../../src/guard/is-non-empty-string.mts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCG;AACI,MAAM,gBAAgB,GAAG,CAC9B,CAAI,KAEJ,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,GAAG;;;;"}
+{"version":3,"file":"is-non-empty-string.mjs","sources":["../../src/guard/is-non-empty-string.mts"],"sourcesContent":["import { type NonEmptyString, type RelaxedExclude } from 'ts-type-forge';\n\n/**\n * Type guard that checks if a value is a non-empty string.\n *\n * This function performs both a type check (ensuring the value is a string) and\n * a length check (ensuring the string is not empty). It acts as a type guard\n * that narrows the input type to exclude `null`, `undefined`, and empty\n * strings.\n *\n * **Type Narrowing Behavior:**\n *\n * - Eliminates `null` and `undefined` from the type\n * - Excludes empty string (`\"\"`) from the type\n * - Preserves literal string types when possible\n * - Whitespace-only strings are considered non-empty\n *\n * @example\n *\n * ```ts\n * const words: readonly (string | undefined)[] = [\n *   'Ada',\n *   undefined,\n *   '',\n *   'Lovelace',\n * ] as const;\n *\n * const nonEmpty = words.filter(isNonEmptyString);\n *\n * assert.deepStrictEqual(nonEmpty, ['Ada', 'Lovelace']);\n * ```\n *\n * @template S - The input type, which can include `string`, `null`, or\n *   `undefined`\n * @param s - The value to check\n * @returns `true` if `s` is a string with length > 0, `false` otherwise. When\n *   `true`, TypeScript narrows the type to exclude empty strings and nullish\n *   values.\n */\nexport const isNonEmptyString = <S extends string | null | undefined>(\n  s: S,\n): s is NonEmptyString & RelaxedExclude<NonNullable<S>, ''> =>\n  typeof s === 'string' && s.length > 0;\n"],"names":[],"mappings":"AAuCO,MAAM,mBAAmB,CAC9B,CAAA,KAEA,OAAO,CAAA,KAAM,QAAA,IAAY,EAAE,MAAA,GAAS;;;;"}

package/dist/guard/is-non-null-object.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-null-object.d.mts","sourceRoot":"","sources":["../../src/guard/is-non-null-object.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,eAAO,MAAM,eAAe,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,MACb,CAAC"}
+{"version":3,"file":"is-non-null-object.d.mts","sourceRoot":"","sources":["../../src/guard/is-non-null-object.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,eAAO,MAAM,eAAe,MAAO,OAAO,KAAG,CAAC,IAAI,MACb,CAAC"}

package/dist/guard/is-non-null-object.mjs

@@ -1,38 +1,4 @@
-/**
- * Type guard that checks if a value is a non-null object.
- *
- * This function checks if a value has type `"object"` according to the `typeof`
- * operator and is not `null`. This includes all object types such as plain
- * objects, arrays, dates, regular expressions, and other object instances, but
- * excludes functions.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `object`
- * - Excludes `null`, `undefined`, and all primitive types
- * - Excludes functions (they have `typeof` === `"function"`, not `"object"`)
- * - Includes arrays, dates, regex, and other object instances
- *
- * **Note:** This function returns `true` for arrays. If you need
- * record-oriented narrowing that excludes arrays, use `isRecord()` instead.
- *
- * @example
- *
- * ```ts
- * const mixed: readonly unknown[] = [{ id: 1 }, null, 'Ada'] as const;
- *
- * const objects = mixed.filter(isNonNullObject);
- *
- * assert.deepStrictEqual(objects, [{ id: 1 }]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is an object and not `null`, `false` otherwise. When
- *   `true`, TypeScript narrows the type to `object`.
- * @see {@link isRecord} - For record-oriented type narrowing (excludes arrays)
- */
-// eslint-disable-next-line @typescript-eslint/no-restricted-types
-const isNonNullObject = (u) => typeof u === 'object' && u !== null;
+const isNonNullObject = (u) => typeof u === "object" && u !== null;
 
 export { isNonNullObject };
 //# sourceMappingURL=is-non-null-object.mjs.map

package/dist/guard/is-non-null-object.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-null-object.mjs","sources":["../../src/guard/is-non-null-object.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACH;AACO,MAAM,eAAe,GAAG,CAAC,CAAU,KACxC,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK;;;;"}
+{"version":3,"file":"is-non-null-object.mjs","sources":["../../src/guard/is-non-null-object.mts"],"sourcesContent":["/**\n * Type guard that checks if a value is a non-null object.\n *\n * This function checks if a value has type `\"object\"` according to the `typeof`\n * operator and is not `null`. This includes all object types such as plain\n * objects, arrays, dates, regular expressions, and other object instances, but\n * excludes functions.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `object`\n * - Excludes `null`, `undefined`, and all primitive types\n * - Excludes functions (they have `typeof` === `\"function\"`, not `\"object\"`)\n * - Includes arrays, dates, regex, and other object instances\n *\n * **Note:** This function returns `true` for arrays. If you need\n * record-oriented narrowing that excludes arrays, use `isRecord()` instead.\n *\n * @example\n *\n * ```ts\n * const mixed: readonly unknown[] = [{ id: 1 }, null, 'Ada'] as const;\n *\n * const objects = mixed.filter(isNonNullObject);\n *\n * assert.deepStrictEqual(objects, [{ id: 1 }]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is an object and not `null`, `false` otherwise. When\n *   `true`, TypeScript narrows the type to `object`.\n * @see {@link isRecord} - For record-oriented type narrowing (excludes arrays)\n */\n// eslint-disable-next-line @typescript-eslint/no-restricted-types\nexport const isNonNullObject = (u: unknown): u is object =>\n  typeof u === 'object' && u !== null;\n"],"names":[],"mappings":"AAkCO,MAAM,kBAAkB,CAAC,CAAA,KAC9B,OAAO,CAAA,KAAM,YAAY,CAAA,KAAM;;;;"}

package/dist/guard/is-primitive.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-primitive.d.mts","sourceRoot":"","sources":["../../src/guard/is-primitive.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAG/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,WAAW,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,SAa7C,CAAC"}
+{"version":3,"file":"is-primitive.d.mts","sourceRoot":"","sources":["../../src/guard/is-primitive.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAG/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,WAAW,MAAO,OAAO,KAAG,CAAC,IAAI,SAa7C,CAAC"}

package/dist/guard/is-primitive.mjs

@@ -1,47 +1,16 @@
-/**
- * Type guard that checks if a value is a primitive type.
- *
- * This function identifies JavaScript primitive types, which are immutable data
- * types that are not objects. The primitive types are: `string`, `number`,
- * `boolean`, `undefined`, `symbol`, `bigint`, and `null`.
- *
- * **Important Note:** Although `null` has `typeof null === "object"` due to a
- * historical JavaScript quirk, this function correctly identifies `null` as a
- * primitive value.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input type to `Primitive` (union of all primitive types)
- * - Excludes object types, arrays, functions, and other non-primitive values
- * - Includes `null` despite its misleading `typeof` result
- *
- * @example
- *
- * ```ts
- * const values: readonly unknown[] = [42, 'Ada', null, { id: 1 }] as const;
- *
- * const primitives = values.filter(isPrimitive);
- *
- * assert.deepStrictEqual(primitives, [42, 'Ada', null]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a primitive type, `false` otherwise. When `true`,
- *   TypeScript narrows the type to `Primitive`.
- */
 const isPrimitive = (u) => {
-    switch (typeof u) {
-        case 'string':
-        case 'number':
-        case 'boolean':
-        case 'undefined':
-        case 'symbol':
-        case 'bigint':
-            return true;
-        case 'function':
-        case 'object':
-            return u === null;
-    }
+  switch (typeof u) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "undefined":
+    case "symbol":
+    case "bigint":
+      return true;
+    case "function":
+    case "object":
+      return u === null;
+  }
 };
 
 export { isPrimitive };

package/dist/guard/is-primitive.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-primitive.mjs","sources":["../../src/guard/is-primitive.mts"],"sourcesContent":[null],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;AACI,MAAM,WAAW,GAAG,CAAC,CAAU,KAAoB;IACxD,QAAQ,OAAO,CAAC;AACd,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,SAAS;AACd,QAAA,KAAK,WAAW;AAChB,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,IAAI;AACb,QAAA,KAAK,UAAU;AACf,QAAA,KAAK,QAAQ;YACX,OAAO,CAAC,KAAK,IAAI;;AAEvB;;;;"}
+{"version":3,"file":"is-primitive.mjs","sources":["../../src/guard/is-primitive.mts"],"sourcesContent":["import { type Primitive } from 'ts-type-forge';\nimport { expectType } from '../expect-type.mjs';\n\n/**\n * Type guard that checks if a value is a primitive type.\n *\n * This function identifies JavaScript primitive types, which are immutable data\n * types that are not objects. The primitive types are: `string`, `number`,\n * `boolean`, `undefined`, `symbol`, `bigint`, and `null`.\n *\n * **Important Note:** Although `null` has `typeof null === \"object\"` due to a\n * historical JavaScript quirk, this function correctly identifies `null` as a\n * primitive value.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input type to `Primitive` (union of all primitive types)\n * - Excludes object types, arrays, functions, and other non-primitive values\n * - Includes `null` despite its misleading `typeof` result\n *\n * @example\n *\n * ```ts\n * const values: readonly unknown[] = [42, 'Ada', null, { id: 1 }] as const;\n *\n * const primitives = values.filter(isPrimitive);\n *\n * assert.deepStrictEqual(primitives, [42, 'Ada', null]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a primitive type, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `Primitive`.\n */\nexport const isPrimitive = (u: unknown): u is Primitive => {\n  switch (typeof u) {\n    case 'string':\n    case 'number':\n    case 'boolean':\n    case 'undefined':\n    case 'symbol':\n    case 'bigint':\n      return true;\n    case 'function':\n    case 'object':\n      return u === null;\n  }\n};\n\nexpectType<\n  bigint | boolean | number | string | symbol | undefined | null,\n  Primitive\n>('=');\n"],"names":[],"mappings":"AAkCO,MAAM,WAAA,GAAc,CAAC,CAAA,KAA+B;AACzD,EAAA,QAAQ,OAAO,CAAA;AAAG,IAChB,KAAK,QAAA;AAAA,IACL,KAAK,QAAA;AAAA,IACL,KAAK,SAAA;AAAA,IACL,KAAK,WAAA;AAAA,IACL,KAAK,QAAA;AAAA,IACL,KAAK,QAAA;AACH,MAAA,OAAO,IAAA;AAAA,IACT,KAAK,UAAA;AAAA,IACL,KAAK,QAAA;AACH,MAAA,OAAO,CAAA,KAAM,IAAA;AAAA;AAEnB;;;;"}

package/dist/guard/is-record.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-record.d.mts","sourceRoot":"","sources":["../../src/guard/is-record.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,aACF,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,eAAe,EAAE,CAC5B,CAAC,EAAE,OAAO,KACP,CAAC,IAAI,aAAa,CAAC,MAAM,EAAE,OAAO,CAAY,CAAC"}
+{"version":3,"file":"is-record.d.mts","sourceRoot":"","sources":["../../src/guard/is-record.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,QAAQ,MAAO,OAAO,KAAG,CAAC,IAAI,aACF,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,eAAe,EAAE,CAC5B,CAAC,EAAE,OAAO,KACP,CAAC,IAAI,aAAa,CAAC,MAAM,EAAE,OAAO,CAAY,CAAC"}

package/dist/guard/is-record.mjs

@@ -1,92 +1,6 @@
 import { isNonNullObject } from './is-non-null-object.mjs';
 
-/**
- * Type guard that checks if a value is a record — a non-null, non-array
- * object — and narrows it to `UnknownRecord` (= `ReadonlyRecord<string,
- * unknown>`).
- *
- * This function is designed to be combined with {@link hasKey} to probe
- * values of type `unknown` (e.g. parsed JSON, caught errors, external data)
- * in a type-safe way: `if (isRecord(u) && hasKey(u, 'some-key')) { ... }`.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `UnknownRecord` (= `ReadonlyRecord<string, unknown>`)
- * - Excludes `null`, `undefined`, primitives, and functions
- * - Excludes arrays: arrays have no string index signature, so they are not
- *   assignable to `UnknownRecord`; admitting them at runtime would be
- *   inconsistent with the narrowed type
- * - Returns `true` for every other non-null object, including dictionary
- *   objects created with `Object.create(null)` and instances such as `Date`,
- *   `RegExp`, `Map`, `Set`, `Error`, and user-defined classes
- *
- * **Why non-plain objects are included:** since every property of
- * `UnknownRecord` is typed `unknown`, reading properties from any object
- * through this narrowing is type-safe, and `hasKey` (backed by
- * `Object.hasOwn`) answers own-property questions correctly on any object
- * (e.g. `Map` entries are not own properties, so `hasKey` correctly returns
- * `false` for them). Restricting the guard to plain objects would require
- * prototype checks that misjudge cross-realm objects and would prevent
- * probing useful instances such as `Error` subclasses.
- *
- * **Implementation:** `isNonNullObject(u) && !Array.isArray(u)`.
- *
- * @example
- *
- * ```ts
- * const entries: readonly unknown[] = [
- *   { id: 1 },
- *   [1, 2],
- *   'str',
- *   0,
- *   null,
- * ] as const;
- *
- * const records = entries.filter(isRecord);
- *
- * assert.deepStrictEqual(records, [{ id: 1 }]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.
- *   When `true`, TypeScript narrows the type to `UnknownRecord`.
- * @see {@link isNonNullObject} - For checking any non-null object (includes arrays)
- * @see {@link hasKey} - For checking if a record has specific keys
- */
 const isRecord = (u) => isNonNullObject(u) && !Array.isArray(u);
-/**
- * Type guard that checks if a value is a mutable record.
- *
- * This function has the same runtime behavior as {@link isRecord} (non-null,
- * non-array object check), but narrows the type to `MutableRecord<string,
- * unknown>`, which is useful when you need to add or overwrite properties on
- * the narrowed object.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `MutableRecord<string, unknown>`
- * - Excludes `null`, `undefined`, primitives, functions, and arrays
- * - Returns `true` for every other non-null object (see {@link isRecord} for
- *   details on non-plain objects such as `Date`, `Map`, and `Set`)
- *
- * **Implementation:** This is a type alias for {@link isRecord}.
- *
- * @example
- *
- * ```ts
- * const obj: unknown = { foo: 1 } as const;
- *
- * if (isMutableRecord(obj)) {
- *   obj['bar'] = 2; // Safe: obj is now known to be a mutable record
- * }
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.
- *   When `true`, TypeScript narrows the type to `MutableRecord<string,
- *   unknown>`.
- * @see {@link isRecord} - For the underlying implementation and more details
- */
 const isMutableRecord = isRecord;
 
 export { isMutableRecord, isRecord };

package/dist/guard/is-record.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-record.mjs","sources":["../../src/guard/is-record.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDG;MACU,QAAQ,GAAG,CAAC,CAAU,KACjC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACI,MAAM,eAAe,GAEe;;;;"}
+{"version":3,"file":"is-record.mjs","sources":["../../src/guard/is-record.mts"],"sourcesContent":["import { type MutableRecord, type UnknownRecord } from 'ts-type-forge';\nimport { isNonNullObject } from './is-non-null-object.mjs';\n\n/**\n * Type guard that checks if a value is a record — a non-null, non-array\n * object — and narrows it to `UnknownRecord` (= `ReadonlyRecord<string,\n * unknown>`).\n *\n * This function is designed to be combined with {@link hasKey} to probe\n * values of type `unknown` (e.g. parsed JSON, caught errors, external data)\n * in a type-safe way: `if (isRecord(u) && hasKey(u, 'some-key')) { ... }`.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `UnknownRecord` (= `ReadonlyRecord<string, unknown>`)\n * - Excludes `null`, `undefined`, primitives, and functions\n * - Excludes arrays: arrays have no string index signature, so they are not\n *   assignable to `UnknownRecord`; admitting them at runtime would be\n *   inconsistent with the narrowed type\n * - Returns `true` for every other non-null object, including dictionary\n *   objects created with `Object.create(null)` and instances such as `Date`,\n *   `RegExp`, `Map`, `Set`, `Error`, and user-defined classes\n *\n * **Why non-plain objects are included:** since every property of\n * `UnknownRecord` is typed `unknown`, reading properties from any object\n * through this narrowing is type-safe, and `hasKey` (backed by\n * `Object.hasOwn`) answers own-property questions correctly on any object\n * (e.g. `Map` entries are not own properties, so `hasKey` correctly returns\n * `false` for them). Restricting the guard to plain objects would require\n * prototype checks that misjudge cross-realm objects and would prevent\n * probing useful instances such as `Error` subclasses.\n *\n * **Implementation:** `isNonNullObject(u) && !Array.isArray(u)`.\n *\n * @example\n *\n * ```ts\n * const entries: readonly unknown[] = [\n *   { id: 1 },\n *   [1, 2],\n *   'str',\n *   0,\n *   null,\n * ] as const;\n *\n * const records = entries.filter(isRecord);\n *\n * assert.deepStrictEqual(records, [{ id: 1 }]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.\n *   When `true`, TypeScript narrows the type to `UnknownRecord`.\n * @see {@link isNonNullObject} - For checking any non-null object (includes arrays)\n * @see {@link hasKey} - For checking if a record has specific keys\n */\nexport const isRecord = (u: unknown): u is UnknownRecord =>\n  isNonNullObject(u) && !Array.isArray(u);\n\n/**\n * Type guard that checks if a value is a mutable record.\n *\n * This function has the same runtime behavior as {@link isRecord} (non-null,\n * non-array object check), but narrows the type to `MutableRecord<string,\n * unknown>`, which is useful when you need to add or overwrite properties on\n * the narrowed object.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `MutableRecord<string, unknown>`\n * - Excludes `null`, `undefined`, primitives, functions, and arrays\n * - Returns `true` for every other non-null object (see {@link isRecord} for\n *   details on non-plain objects such as `Date`, `Map`, and `Set`)\n *\n * **Implementation:** This is a type alias for {@link isRecord}.\n *\n * @example\n *\n * ```ts\n * const obj: unknown = { foo: 1 } as const;\n *\n * if (isMutableRecord(obj)) {\n *   obj['bar'] = 2; // Safe: obj is now known to be a mutable record\n * }\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.\n *   When `true`, TypeScript narrows the type to `MutableRecord<string,\n *   unknown>`.\n * @see {@link isRecord} - For the underlying implementation and more details\n */\nexport const isMutableRecord: (\n  u: unknown,\n) => u is MutableRecord<string, unknown> = isRecord;\n"],"names":[],"mappings":";;AAwDO,MAAM,QAAA,GAAW,CAAC,CAAA,KACvB,eAAA,CAAgB,CAAC,CAAA,IAAK,CAAC,KAAA,CAAM,OAAA,CAAQ,CAAC;AAmCjC,MAAM,eAAA,GAE8B;;;;"}