ts-data-forge 12.2.1 → 12.2.2

package/dist/number/branded-types/non-zero-finite-number.d.mts

@@ -2,6 +2,9 @@ import { type NonZeroFiniteNumber as TtfImported_NonZeroFiniteNumber } from 'ts-
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type NonZeroFiniteNumber = TtfImported_NonZeroFiniteNumber;
 type ElementType = NonZeroFiniteNumber;
+declare const floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+declare const ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+declare const round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
 /**
  * Type guard that checks if a value is a non-zero finite number.
  *
@@ -74,7 +77,7 @@ export declare const NonZeroFiniteNumber: {
      * @param a - The non-zero finite number value
      * @returns The floored value as an integer
      */
-    readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly floor: typeof floor;
     /**
      * Returns the smallest integer greater than or equal to a non-zero finite
      * number.
@@ -82,7 +85,7 @@ export declare const NonZeroFiniteNumber: {
      * @param a - The non-zero finite number value
      * @returns The ceiled value as an integer
      */
-    readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly ceil: typeof ceil;
     /**
      * Returns the value of a non-zero finite number rounded to the nearest
      * integer.
@@ -90,7 +93,7 @@ export declare const NonZeroFiniteNumber: {
      * @param a - The non-zero finite number value
      * @returns The rounded value as an integer
      */
-    readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly round: typeof round;
     /**
      * Generates a random `NonZeroFiniteNumber` within the given range.
      *

package/dist/number/branded-types/non-zero-finite-number.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"non-zero-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,IAAI,+BAA+B,EAC5D,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,mBAAmB,GAAG,+BAA+B,CAAC;AAElE,KAAK,WAAW,GAAG,mBAAmB,CAAC;AAuDvC;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,qDAAK,CAAC;AAExC;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB;;;;;;MAAW,CAAC;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;wBApGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAsG3D;;;;;;OAMG;uBAvGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAyG3D;;;;;;OAMG;wBA1GA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA4G3D;;;;;;;;OAQG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;;;;OAWG;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,IAAI,+BAA+B,EAC5D,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,mBAAmB,GAAG,+BAA+B,CAAC;AAElE,KAAK,WAAW,GAAG,mBAAmB,CAAC;AAyBvC,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAE9E,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEgB,CAAC;AAE7E,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAc9E;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,qDAAK,CAAC;AAExC;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB;;;;;;MAAW,CAAC;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;;;;OAWG;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/positive-finite-number.d.mts

@@ -2,6 +2,9 @@ import { type PositiveFiniteNumber as TtfImported_PositiveFiniteNumber } from 't
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type PositiveFiniteNumber = TtfImported_PositiveFiniteNumber;
 type ElementType = PositiveFiniteNumber;
+declare const floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
+declare const ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+declare const round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
 /**
  * Type guard that checks if a value is a positive finite number.
  *
@@ -90,7 +93,7 @@ export declare const PositiveFiniteNumber: {
      * @param a - The positive finite number value
      * @returns The floored value as an integer
      */
-    readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
+    readonly floor: typeof floor;
     /**
      * Returns the smallest integer greater than or equal to a positive finite
      * number.
@@ -98,7 +101,7 @@ export declare const PositiveFiniteNumber: {
      * @param a - The positive finite number value
      * @returns The ceiled value as an integer
      */
-    readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly ceil: typeof ceil;
     /**
      * Returns the value of a positive finite number rounded to the nearest
      * integer.
@@ -106,7 +109,7 @@ export declare const PositiveFiniteNumber: {
      * @param a - The positive finite number value
      * @returns The rounded value as an integer
      */
-    readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
+    readonly round: typeof round;
     /**
      * Generates a random `PositiveFiniteNumber` within the given range.
      *

package/dist/number/branded-types/positive-finite-number.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"positive-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,oBAAoB,IAAI,gCAAgC,EAE9D,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,oBAAoB,GAAG,gCAAgC,CAAC;AAEpE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AAqExC;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,sDAAK,CAAC;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;MAAW,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;wBA3HA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IA2HC;;;;;;OAMG;uBAxHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA0H3D;;;;;;OAMG;wBA3HA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IA2HC;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,oBAAoB,IAAI,gCAAgC,EAE9D,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,oBAAoB,GAAG,gCAAgC,CAAC;AAEpE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AA2BxC,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAEJ,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEgB,CAAC;AAE7E,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAcJ;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,sDAAK,CAAC;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;MAAW,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/enum/int8.d.mts

@@ -1,5 +1,17 @@
 import { type AbsoluteValue, type Int8 as TtfImported_Int8 } from 'ts-type-forge';
 export type Int8 = TtfImported_Int8;
+declare const is: (x: number) => x is Int8;
+declare const castType: (x: number) => Int8;
+declare const fromNumber: (a: number) => Int8;
+declare const abs: <N extends Int8>(x: N) => AbsoluteValue<N>;
+declare const min_: (...values: readonly Int8[]) => Int8;
+declare const max_: (...values: readonly Int8[]) => Int8;
+declare const pow: (x: Int8, y: Int8) => Int8;
+declare const add: (x: Int8, y: Int8) => Int8;
+declare const sub: (x: Int8, y: Int8) => Int8;
+declare const mul: (x: Int8, y: Int8) => Int8;
+declare const div: (x: Int8, y: Exclude<Int8, 0>) => Int8;
+declare const random: (min: Int8, max: Int8) => Int8;
 /**
  * Type guard that checks if a value is an integer in [-128, 127].
  *
@@ -9,7 +21,7 @@ export type Int8 = TtfImported_Int8;
  * @param value - The value to check
  * @returns `true` if the value is an integer in [-128, 127], `false` otherwise
  */
-export declare const isInt8: (x: number) => x is Int8;
+export declare const isInt8: typeof is;
 /**
  * Casts a `number` to the `Int8` branded type.
  *
@@ -20,7 +32,7 @@ export declare const isInt8: (x: number) => x is Int8;
  * @returns The value as an `Int8`
  * @throws {TypeError} If the value is not an integer in [-128, 127]
  */
-export declare const asInt8: (x: number) => Int8;
+export declare const asInt8: typeof castType;
 /**
  * Namespace providing type-safe operations for the `Int8` branded type.
  *
@@ -35,7 +47,7 @@ export declare const Int8: {
      * @returns `true` if the value is an integer in [-128, 127], `false` otherwise
      * @see {@link isInt8} for usage examples
      */
-    readonly is: (x: number) => x is Int8;
+    readonly is: typeof is;
     /**
      * The smallest value representable as `Int8` (the lower saturation target of
      * `fromNumber`).
@@ -52,14 +64,14 @@ export declare const Int8: {
      * @param values - The integers to compare (at least one required)
      * @returns The smallest value as an `Int8`
      */
-    readonly min: (...values: readonly Int8[]) => Int8;
+    readonly min: typeof min_;
     /**
      * Returns the largest of the given integers.
      *
      * @param values - The integers to compare (at least one required)
      * @returns The largest value as an `Int8`
      */
-    readonly max: (...values: readonly Int8[]) => Int8;
+    readonly max: typeof max_;
     /**
      * Converts an arbitrary `number` into an `Int8`, rounding to the nearest
      * integer and saturating the result into the range `[MIN_VALUE, MAX_VALUE]`.
@@ -70,7 +82,7 @@ export declare const Int8: {
      * @param value - The value to convert
      * @returns The value as an `Int8`
      */
-    readonly fromNumber: (a: number) => Int8;
+    readonly fromNumber: typeof fromNumber;
     /**
      * Returns the absolute value of an integer in [-128, 127].
      *
@@ -79,7 +91,7 @@ export declare const Int8: {
      * @param a - The integer value
      * @returns The absolute value as a non-negative `Int8`
      */
-    readonly abs: <N extends Int8>(x: N) => AbsoluteValue<N>;
+    readonly abs: typeof abs;
     /**
      * Generates a random `Int8` within the given range.
      *
@@ -89,7 +101,7 @@ export declare const Int8: {
      * @param max - The maximum value (inclusive)
      * @returns A random `Int8` in `[min, max]`
      */
-    readonly random: (min: Int8, max: Int8) => Int8;
+    readonly random: typeof random;
     /**
      * Raises `a` to the power `b`, returning `a ** b` as an `Int8` (floored to an
      * integer).
@@ -98,7 +110,7 @@ export declare const Int8: {
      * @param b - The exponent integer
      * @returns `a ** b` as an `Int8`
      */
-    readonly pow: (x: Int8, y: Int8) => Int8;
+    readonly pow: typeof pow;
     /**
      * Adds two integers, returning `a + b` as an `Int8`.
      *
@@ -106,7 +118,7 @@ export declare const Int8: {
      * @param b - The second integer
      * @returns The sum of `a` and `b` as an `Int8`
      */
-    readonly add: (x: Int8, y: Int8) => Int8;
+    readonly add: typeof add;
     /**
      * Subtracts two integers, returning `a - b` as an `Int8`.
      *
@@ -114,7 +126,7 @@ export declare const Int8: {
      * @param b - The second integer
      * @returns The difference of `a` and `b` as an `Int8`
      */
-    readonly sub: (x: Int8, y: Int8) => Int8;
+    readonly sub: typeof sub;
     /**
      * Multiplies two integers, returning `a * b` as an `Int8`.
      *
@@ -122,7 +134,7 @@ export declare const Int8: {
      * @param b - The second integer
      * @returns The product of `a` and `b` as an `Int8`
      */
-    readonly mul: (x: Int8, y: Int8) => Int8;
+    readonly mul: typeof mul;
     /**
      * Divides two integers using floor division (`⌊a / b⌋`): the result is `a /
      * b` rounded toward negative infinity, as an `Int8`.
@@ -131,6 +143,7 @@ export declare const Int8: {
      * @param b - The divisor (must be non-zero)
      * @returns The floored quotient as an `Int8`
      */
-    readonly div: (x: Int8, y: Exclude<Int8, 0>) => Int8;
+    readonly div: typeof div;
 };
+export {};
 //# sourceMappingURL=int8.d.mts.map

package/dist/number/enum/int8.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"int8.d.mts","sourceRoot":"","sources":["../../../src/number/enum/int8.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,IAAI,IAAI,gBAAgB,EAC9B,MAAM,eAAe,CAAC;AAIvB,MAAM,MAAM,IAAI,GAAG,gBAAgB,CAAC;AAsDpC;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,MAzCJ,MAAM,KAAG,CAAC,IAAI,IAyCL,CAAC;AAEzB;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,MAnDE,MAAM,KAAG,IAmDA,CAAC;AAE/B;;;;;GAKG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;OAMG;qBApEU,MAAM,KAAG,CAAC,IAAI,IAAI;IAuE/B;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;8BA5EoB,SAAS,IAAI,EAAE,KAAG,IAAI;IA+E7C;;;;;OAKG;8BAjFoB,SAAS,IAAI,EAAE,KAAG,IAAI;IAoF7C;;;;;;;;;OASG;6BAtGkB,MAAM,KAAG,IAAI;IAyGlC;;;;;;;OAOG;mBA9GQ,CAAC,SAAS,IAAI,KAAK,CAAC,KAAG,aAAa,CAAC,CAAC,CAAC;IAiHlD;;;;;;;;OAQG;2BApGgB,IAAI,OAAO,IAAI,KAAG,IAAI;IAuGzC;;;;;;;OAOG;sBAzHW,IAAI,KAAK,IAAI,KAAG,IAAI;IA4HlC;;;;;;OAMG;sBAhIW,IAAI,KAAK,IAAI,KAAG,IAAI;IAmIlC;;;;;;OAMG;sBAvIW,IAAI,KAAK,IAAI,KAAG,IAAI;IA0IlC;;;;;;OAMG;sBA9IW,IAAI,KAAK,IAAI,KAAG,IAAI;IAiJlC;;;;;;;OAOG;sBAtJW,IAAI,KAAK,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,KAAG,IAAI;CAwJtC,CAAC"}
+{"version":3,"file":"int8.d.mts","sourceRoot":"","sources":["../../../src/number/enum/int8.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,IAAI,IAAI,gBAAgB,EAC9B,MAAM,eAAe,CAAC;AAIvB,MAAM,MAAM,IAAI,GAAG,gBAAgB,CAAC;AAsBpC,QAAA,MAAM,EAAE,MAAO,MAAM,KAAG,CAAC,IAAI,IAAiB,CAAC;AAE/C,QAAA,MAAM,QAAQ,MAAO,MAAM,KAAG,IAEL,CAAC;AAE1B,QAAA,MAAM,UAAU,MAAO,MAAM,KAAG,IAAmC,CAAC;AAEpE,QAAA,MAAM,GAAG,GAAI,CAAC,SAAS,IAAI,KAAK,CAAC,KAAG,aAAa,CAAC,CAAC,CAEP,CAAC;AAE7C,QAAA,MAAM,IAAI,cAAe,SAAS,IAAI,EAAE,KAAG,IACZ,CAAC;AAEhC,QAAA,MAAM,IAAI,cAAe,SAAS,IAAI,EAAE,KAAG,IACZ,CAAC;AAEhC,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,IAAI,KAAG,IAA0B,CAAC;AAE3D,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,IAAI,KAAG,IAAyB,CAAC;AAE1D,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,IAAI,KAAG,IAAyB,CAAC;AAE1D,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,IAAI,KAAG,IAAyB,CAAC;AAE1D,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,KAAG,IACb,CAAC;AAEhC,QAAA,MAAM,MAAM,QAAS,IAAI,OAAO,IAAI,KAAG,IACqB,CAAC;AAE7D;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,WAAK,CAAC;AAEzB;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,iBAAW,CAAC;AAE/B;;;;;GAKG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}

package/dist/number/enum/uint8.d.mts

@@ -1,5 +1,16 @@
 import { type Uint8 as TtfImported_Uint8 } from 'ts-type-forge';
 export type Uint8 = TtfImported_Uint8;
+declare const is: (x: number) => x is Uint8;
+declare const castType: (x: number) => Uint8;
+declare const fromNumber: (a: number) => Uint8;
+declare const min_: (...values: readonly Uint8[]) => Uint8;
+declare const max_: (...values: readonly Uint8[]) => Uint8;
+declare const pow: (x: Uint8, y: Uint8) => Uint8;
+declare const add: (x: Uint8, y: Uint8) => Uint8;
+declare const sub: (x: Uint8, y: Uint8) => Uint8;
+declare const mul: (x: Uint8, y: Uint8) => Uint8;
+declare const div: (x: Uint8, y: Exclude<Uint8, 0>) => Uint8;
+declare const random: (min: Uint8, max: Uint8) => Uint8;
 /**
  * Type guard that checks if a value is an non-negative integer less than 256.
  *
@@ -9,7 +20,7 @@ export type Uint8 = TtfImported_Uint8;
  * @param value - The value to check
  * @returns `true` if the value is an non-negative integer less than 256, `false` otherwise
  */
-export declare const isUint8: (x: number) => x is Uint8;
+export declare const isUint8: typeof is;
 /**
  * Casts a `number` to the `Uint8` branded type.
  *
@@ -20,7 +31,7 @@ export declare const isUint8: (x: number) => x is Uint8;
  * @returns The value as an `Uint8`
  * @throws {TypeError} If the value is not an non-negative integer less than 256
  */
-export declare const asUint8: (x: number) => Uint8;
+export declare const asUint8: typeof castType;
 /**
  * Namespace providing type-safe operations for the `Uint8` branded type.
  *
@@ -35,7 +46,7 @@ export declare const Uint8: {
      * @returns `true` if the value is an non-negative integer less than 256, `false` otherwise
      * @see {@link isUint8} for usage examples
      */
-    readonly is: (x: number) => x is Uint8;
+    readonly is: typeof is;
     /**
      * The smallest value representable as `Uint8` (the lower saturation target of
      * `fromNumber`).
@@ -52,14 +63,14 @@ export declare const Uint8: {
      * @param values - The non-negative integers to compare (at least one required)
      * @returns The largest value as an `Uint8`
      */
-    readonly max: (...values: readonly Uint8[]) => Uint8;
+    readonly max: typeof max_;
     /**
      * Returns the smallest of the given non-negative integers.
      *
      * @param values - The non-negative integers to compare (at least one required)
      * @returns The smallest value as an `Uint8`
      */
-    readonly min: (...values: readonly Uint8[]) => Uint8;
+    readonly min: typeof min_;
     /**
      * Converts an arbitrary `number` into an `Uint8`, rounding to the nearest
      * integer and saturating the result into the range `[MIN_VALUE, MAX_VALUE]`.
@@ -70,7 +81,7 @@ export declare const Uint8: {
      * @param value - The value to convert
      * @returns The value as an `Uint8`
      */
-    readonly fromNumber: (a: number) => Uint8;
+    readonly fromNumber: typeof fromNumber;
     /**
      * Generates a random `Uint8` within the given range.
      *
@@ -80,7 +91,7 @@ export declare const Uint8: {
      * @param max - The maximum value (inclusive)
      * @returns A random `Uint8` in `[min, max]`
      */
-    readonly random: (min: Uint8, max: Uint8) => Uint8;
+    readonly random: typeof random;
     /**
      * Raises `a` to the power `b`, returning `a ** b` as an `Uint8` (floored to
      * an integer).
@@ -89,7 +100,7 @@ export declare const Uint8: {
      * @param b - The exponent non-negative integer
      * @returns `a ** b` as an `Uint8`
      */
-    readonly pow: (x: Uint8, y: Uint8) => Uint8;
+    readonly pow: typeof pow;
     /**
      * Adds two non-negative integers, returning `a + b` as an `Uint8`.
      *
@@ -97,7 +108,7 @@ export declare const Uint8: {
      * @param b - The second non-negative integer
      * @returns The sum of `a` and `b` as an `Uint8`
      */
-    readonly add: (x: Uint8, y: Uint8) => Uint8;
+    readonly add: typeof add;
     /**
      * Subtracts two non-negative integers, returning `a - b` as an `Uint8`.
      *
@@ -105,7 +116,7 @@ export declare const Uint8: {
      * @param b - The second non-negative integer
      * @returns The difference of `a` and `b` as an `Uint8`
      */
-    readonly sub: (x: Uint8, y: Uint8) => Uint8;
+    readonly sub: typeof sub;
     /**
      * Multiplies two non-negative integers, returning `a * b` as an `Uint8`.
      *
@@ -113,7 +124,7 @@ export declare const Uint8: {
      * @param b - The second non-negative integer
      * @returns The product of `a` and `b` as an `Uint8`
      */
-    readonly mul: (x: Uint8, y: Uint8) => Uint8;
+    readonly mul: typeof mul;
     /**
      * Divides two non-negative integers using floor division (`⌊a / b⌋`): the
      * result is `a / b` rounded toward negative infinity, as an `Uint8`.
@@ -122,6 +133,7 @@ export declare const Uint8: {
      * @param b - The divisor (must be non-zero)
      * @returns The floored quotient as an `Uint8`
      */
-    readonly div: (x: Uint8, y: Exclude<Uint8, 0>) => Uint8;
+    readonly div: typeof div;
 };
+export {};
 //# sourceMappingURL=uint8.d.mts.map

package/dist/number/enum/uint8.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"uint8.d.mts","sourceRoot":"","sources":["../../../src/number/enum/uint8.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,IAAI,iBAAiB,EAAe,MAAM,eAAe,CAAC;AAI7E,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAgDtC;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,MArCL,MAAM,KAAG,CAAC,IAAI,KAqCJ,CAAC;AAE1B;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,MA/CC,MAAM,KAAG,KA+CC,CAAC;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;;OAMG;qBAhEU,MAAM,KAAG,CAAC,IAAI,KAAK;IAmEhC;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;8BAzEoB,SAAS,KAAK,EAAE,KAAG,KAAK;IA4E/C;;;;;OAKG;8BApFoB,SAAS,KAAK,EAAE,KAAG,KAAK;IAuF/C;;;;;;;;;OASG;6BAlGkB,MAAM,KAAG,KAAK;IAqGnC;;;;;;;;OAQG;2BA1FgB,KAAK,OAAO,KAAK,KAAG,KAAK;IA6F5C;;;;;;;OAOG;sBA/GW,KAAK,KAAK,KAAK,KAAG,KAAK;IAkHrC;;;;;;OAMG;sBAtHW,KAAK,KAAK,KAAK,KAAG,KAAK;IAyHrC;;;;;;OAMG;sBA7HW,KAAK,KAAK,KAAK,KAAG,KAAK;IAgIrC;;;;;;OAMG;sBApIW,KAAK,KAAK,KAAK,KAAG,KAAK;IAuIrC;;;;;;;OAOG;sBA5IW,KAAK,KAAK,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,KAAG,KAAK;CA8IzC,CAAC"}
+{"version":3,"file":"uint8.d.mts","sourceRoot":"","sources":["../../../src/number/enum/uint8.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,IAAI,iBAAiB,EAAe,MAAM,eAAe,CAAC;AAI7E,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAoBtC,QAAA,MAAM,EAAE,MAAO,MAAM,KAAG,CAAC,IAAI,KAAkB,CAAC;AAEhD,QAAA,MAAM,QAAQ,MAAO,MAAM,KAAG,KAEJ,CAAC;AAE3B,QAAA,MAAM,UAAU,MAAO,MAAM,KAAG,KAAoC,CAAC;AAErE,QAAA,MAAM,IAAI,cAAe,SAAS,KAAK,EAAE,KAAG,KACb,CAAC;AAEhC,QAAA,MAAM,IAAI,cAAe,SAAS,KAAK,EAAE,KAAG,KACb,CAAC;AAEhC,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,KAAK,KAAG,KAA2B,CAAC;AAE9D,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,KAAK,KAAG,KAA0B,CAAC;AAE7D,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,KAAK,KAAG,KAA0B,CAAC;AAE7D,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,KAAK,KAAG,KAA0B,CAAC;AAE7D,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,KAAG,KACf,CAAC;AAEhC,QAAA,MAAM,MAAM,QAAS,KAAK,OAAO,KAAK,KAAG,KACmB,CAAC;AAE7D;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,WAAK,CAAC;AAE1B;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,iBAAW,CAAC;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}

package/dist/others/if-then.d.mts

@@ -28,5 +28,5 @@ export declare const ifThen: (antecedent: boolean, consequent: boolean) => boole
  *   (then part)
  * @returns `true` if the implication holds, `false` otherwise
  */
-export declare const implies: (antecedent: boolean, consequent: boolean) => boolean;
+export declare const implies: typeof ifThen;
 //# sourceMappingURL=if-then.d.mts.map

package/dist/others/if-then.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"if-then.d.mts","sourceRoot":"","sources":["../../src/others/if-then.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,eAAgB,OAAO,cAAc,OAAO,KAAG,OACvC,CAAC;AAE5B;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,eAbe,OAAO,cAAc,OAAO,KAAG,OAarC,CAAC"}
+{"version":3,"file":"if-then.d.mts","sourceRoot":"","sources":["../../src/others/if-then.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,eAAgB,OAAO,cAAc,OAAO,KAAG,OACvC,CAAC;AAE5B;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,eAAS,CAAC"}

package/dist/string/str.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"str.d.mts","sourceRoot":"","sources":["../../src/string/str.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"str.d.mts","sourceRoot":"","sources":["../../src/string/str.mts"],"names":[],"mappings":"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"}

package/dist/string/str.mjs

@@ -6,76 +6,76 @@ var Str;
   Str2.isFixedLengthString = (s, length) => s.length === length;
   function asMinLengthString(...args) {
     switch (args.length) {
-      case 2: {
-        const [s, minLength] = args;
-        if (!(0, Str2.isMinLengthString)(s, minLength)) {
-          throw new TypeError(
-            `Expected a string of length >= ${minLength}, got a string of length ${s.length}`
-          );
-        }
-        return s;
-      }
-      case 1: {
-        const [minLength] = args;
-        return (s) => asMinLengthString(s, minLength);
-      }
+      case 2:
+        return asMinLengthStringImpl(...args);
+      case 1:
+        return (s) => asMinLengthStringImpl(s, ...args);
     }
   }
   Str2.asMinLengthString = asMinLengthString;
+  const asMinLengthStringImpl = (s, minLength) => {
+    const actualLength = s.length;
+    if (!(0, Str2.isMinLengthString)(s, minLength)) {
+      throw new TypeError(
+        `Expected a string of length >= ${minLength}, got a string of length ${actualLength}`
+      );
+    }
+    return s;
+  };
   function asMaxLengthString(...args) {
     switch (args.length) {
-      case 2: {
-        const [s, maxLength] = args;
-        if (!(0, Str2.isMaxLengthString)(s, maxLength)) {
-          throw new TypeError(
-            `Expected a string of length <= ${maxLength}, got a string of length ${s.length}`
-          );
-        }
-        return s;
-      }
-      case 1: {
-        const [maxLength] = args;
-        return (s) => asMaxLengthString(s, maxLength);
-      }
+      case 2:
+        return asMaxLengthStringImpl(...args);
+      case 1:
+        return (s) => asMaxLengthStringImpl(s, ...args);
     }
   }
   Str2.asMaxLengthString = asMaxLengthString;
+  const asMaxLengthStringImpl = (s, maxLength) => {
+    const actualLength = s.length;
+    if (!(0, Str2.isMaxLengthString)(s, maxLength)) {
+      throw new TypeError(
+        `Expected a string of length <= ${maxLength}, got a string of length ${actualLength}`
+      );
+    }
+    return s;
+  };
   function asBoundedLengthString(...args) {
     switch (args.length) {
-      case 3: {
-        const [s, minLength, maxLength] = args;
-        if (!(0, Str2.isBoundedLengthString)(s, minLength, maxLength)) {
-          throw new TypeError(
-            `Expected a string of length in [${minLength}, ${maxLength}], got a string of length ${s.length}`
-          );
-        }
-        return s;
-      }
-      case 2: {
-        const [minLength, maxLength] = args;
-        return (s) => asBoundedLengthString(s, minLength, maxLength);
-      }
+      case 3:
+        return asBoundedLengthStringImpl(...args);
+      case 2:
+        return (s) => asBoundedLengthStringImpl(s, ...args);
     }
   }
   Str2.asBoundedLengthString = asBoundedLengthString;
+  const asBoundedLengthStringImpl = (s, minLength, maxLength) => {
+    const actualLength = s.length;
+    if (!(0, Str2.isBoundedLengthString)(s, minLength, maxLength)) {
+      throw new TypeError(
+        `Expected a string of length in [${minLength}, ${maxLength}], got a string of length ${actualLength}`
+      );
+    }
+    return s;
+  };
   function asFixedLengthString(...args) {
     switch (args.length) {
-      case 2: {
-        const [s, length] = args;
-        if (!(0, Str2.isFixedLengthString)(s, length)) {
-          throw new TypeError(
-            `Expected a string of length ${length}, got a string of length ${s.length}`
-          );
-        }
-        return s;
-      }
-      case 1: {
-        const [length] = args;
-        return (s) => asFixedLengthString(s, length);
-      }
+      case 2:
+        return asFixedLengthStringImpl(...args);
+      case 1:
+        return (s) => asFixedLengthStringImpl(s, ...args);
     }
   }
   Str2.asFixedLengthString = asFixedLengthString;
+  const asFixedLengthStringImpl = (s, length) => {
+    const actualLength = s.length;
+    if (!(0, Str2.isFixedLengthString)(s, length)) {
+      throw new TypeError(
+        `Expected a string of length ${length}, got a string of length ${actualLength}`
+      );
+    }
+    return s;
+  };
   Str2.asNonEmptyString = (s) => {
     if (!(0, Str2.isMinLengthString)(s, 1)) {
       throw new TypeError("Expected a non-empty string, got an empty string");

package/dist/string/str.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"str.mjs","sources":["../../src/string/str.mts"],"sourcesContent":["import {\n  type BoundedLengthString,\n  type FixedLengthString,\n  type MaxLengthString,\n  type MinLengthString,\n  type NonEmptyString,\n  type SupportedLength,\n} from 'ts-type-forge';\n\n/**\n * Namespace providing type guards and runtime-checked casts for the branded\n * length-constrained string types (`MinLengthString`, `MaxLengthString`,\n * `BoundedLengthString`, `FixedLengthString`).\n *\n * Lengths are 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 */\nexport namespace Str {\n  /**\n   * Type guard that checks if a string has at least `minLength` characters.\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(Str.isMinLengthString(input, 12));\n   *\n   * assert.isFalse(Str.isMinLengthString('short', 12));\n   *\n   * if (Str.isMinLengthString(input, 12)) {\n   *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)\n   *\n   *   assert.isTrue(nonEmpty.length >= 12);\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   */\n  export const isMinLengthString = <\n    S extends string,\n    MinLength extends SupportedLength,\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   * **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(Str.isMaxLengthString(input, 32));\n   *\n   * assert.isFalse(Str.isMaxLengthString(input, 3));\n   *\n   * if (Str.isMaxLengthString(input, 32)) {\n   *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)\n   *\n   *   assert.isTrue(relaxed.length <= 32);\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   */\n  export const isMaxLengthString = <\n    S extends string,\n    MaxLength extends SupportedLength,\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   * **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(Str.isBoundedLengthString(input, 8, 16));\n   *\n   * assert.isFalse(Str.isBoundedLengthString('user', 8, 16));\n   *\n   * if (Str.isBoundedLengthString(input, 8, 16)) {\n   *   const userId: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])\n   *\n   *   assert.isTrue(userId.length >= 8 && userId.length <= 16);\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   */\n  export const isBoundedLengthString = <\n    S extends string,\n    MinLength extends SupportedLength,\n    MaxLength extends SupportedLength,\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   * **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(Str.isFixedLengthString(input, 2));\n   *\n   * assert.isFalse(Str.isFixedLengthString(input, 3));\n   *\n   * if (Str.isFixedLengthString(input, 2)) {\n   *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)\n   *\n   *   assert.isTrue(atMost5.length === 2);\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   */\n  export const isFixedLengthString = <\n    S extends string,\n    Length extends SupportedLength,\n  >(\n    s: S,\n    length: Length,\n  ): s is FixedLengthString<Length> & S => s.length === length;\n\n  /**\n   * Casts a string to `MinLengthString<MinLength>` after checking that it has\n   * at least `minLength` characters.\n   *\n   * Use this instead of writing `s as unknown as MinLengthString<N>`: the\n   * length is verified at runtime, and the original string type (e.g. literal\n   * types) is preserved via intersection.\n   *\n   * Supports a curried overload: calling it with only `minLength` returns a\n   * function that casts a string, which is convenient for `pipe`/`map`.\n   *\n   * @example\n   *\n   * ```ts\n   * const password = Str.asMinLengthString('very-secret-password', 12);\n   *\n   * const nonEmpty: NonEmptyString = password; // OK (>= 1)\n   *\n   * assert.isTrue(nonEmpty.length >= 12);\n   *\n   * // curried version\n   * const asPassword = Str.asMinLengthString(12);\n   *\n   * assert.strictEqual(asPassword('another-secret'), 'another-secret');\n   *\n   * assert.throws(() => Str.asMinLengthString('short', 12)); // length 5 < 12\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 cast.\n   * @param minLength - The minimum number of characters (inclusive).\n   * @returns `s` typed as `MinLengthString<MinLength> & S`.\n   * @throws {TypeError} If `s.length < minLength`.\n   */\n  export function asMinLengthString<\n    S extends string,\n    MinLength extends SupportedLength,\n  >(s: S, minLength: MinLength): MinLengthString<MinLength> & S;\n\n  // Curried version\n  export function asMinLengthString<MinLength extends SupportedLength>(\n    minLength: MinLength,\n  ): <S extends string>(s: S) => MinLengthString<MinLength> & S;\n\n  export function asMinLengthString(\n    ...args:\n      | readonly [s: string, minLength: SupportedLength]\n      | readonly [minLength: SupportedLength]\n  ): string | ((s: string) => string) {\n    switch (args.length) {\n      case 2: {\n        const [s, minLength] = args;\n\n        if (!isMinLengthString(s, minLength)) {\n          throw new TypeError(\n            `Expected a string of length >= ${minLength}, got a string of length ${s.length}`,\n          );\n        }\n\n        return s;\n      }\n\n      case 1: {\n        const [minLength] = args;\n\n        return (s) => asMinLengthString(s, minLength);\n      }\n    }\n  }\n\n  /**\n   * Casts a string to `MaxLengthString<MaxLength>` after checking that it has\n   * at most `maxLength` characters.\n   *\n   * Use this instead of writing `s as unknown as MaxLengthString<N>`: the\n   * length is verified at runtime, and the original string type (e.g. literal\n   * types) is preserved via intersection.\n   *\n   * Supports a curried overload: calling it with only `maxLength` returns a\n   * function that casts a string, which is convenient for `pipe`/`map`.\n   *\n   * @example\n   *\n   * ```ts\n   * const userName = Str.asMaxLengthString('noshiro', 32);\n   *\n   * const relaxed: MaxLengthString<64> = userName; // OK (32 <= 64)\n   *\n   * assert.isTrue(relaxed.length <= 32);\n   *\n   * // curried version\n   * const asUserName = Str.asMaxLengthString(32);\n   *\n   * assert.strictEqual(asUserName('another-user'), 'another-user');\n   *\n   * assert.throws(() => Str.asMaxLengthString('noshiro', 3)); // length 7 > 3\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 cast.\n   * @param maxLength - The maximum number of characters (inclusive).\n   * @returns `s` typed as `MaxLengthString<MaxLength> & S`.\n   * @throws {TypeError} If `s.length > maxLength`.\n   */\n  export function asMaxLengthString<\n    S extends string,\n    MaxLength extends SupportedLength,\n  >(s: S, maxLength: MaxLength): MaxLengthString<MaxLength> & S;\n\n  // Curried version\n  export function asMaxLengthString<MaxLength extends SupportedLength>(\n    maxLength: MaxLength,\n  ): <S extends string>(s: S) => MaxLengthString<MaxLength> & S;\n\n  export function asMaxLengthString(\n    ...args:\n      | readonly [s: string, maxLength: SupportedLength]\n      | readonly [maxLength: SupportedLength]\n  ): string | ((s: string) => string) {\n    switch (args.length) {\n      case 2: {\n        const [s, maxLength] = args;\n\n        if (!isMaxLengthString(s, maxLength)) {\n          throw new TypeError(\n            `Expected a string of length <= ${maxLength}, got a string of length ${s.length}`,\n          );\n        }\n\n        return s;\n      }\n\n      case 1: {\n        const [maxLength] = args;\n\n        return (s) => asMaxLengthString(s, maxLength);\n      }\n    }\n  }\n\n  /**\n   * Casts a string to `BoundedLengthString<MinLength, MaxLength>` after\n   * checking that its length is within the inclusive range\n   * `[minLength, maxLength]`.\n   *\n   * Use this instead of writing `s as unknown as BoundedLengthString<M, N>`:\n   * the length is verified at runtime, and the original string type (e.g.\n   * literal types) is preserved via intersection.\n   *\n   * Supports a curried overload: calling it with only `minLength` and\n   * `maxLength` returns a function that casts a string, which is convenient for\n   * `pipe`/`map`.\n   *\n   * @example\n   *\n   * ```ts\n   * const userId = Str.asBoundedLengthString('user-12345678', 8, 16);\n   *\n   * const relaxed: BoundedLengthString<1, 255> = userId; // OK ([8, 16] ⊆ [1, 255])\n   *\n   * assert.isTrue(relaxed.length >= 8 && relaxed.length <= 16);\n   *\n   * // curried version\n   * const asUserId = Str.asBoundedLengthString(8, 16);\n   *\n   * assert.strictEqual(asUserId('user-87654321'), 'user-87654321');\n   *\n   * assert.throws(() => Str.asBoundedLengthString('user', 8, 16)); // length 4 < 8\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 cast.\n   * @param minLength - The minimum number of characters (inclusive).\n   * @param maxLength - The maximum number of characters (inclusive).\n   * @returns `s` typed as `BoundedLengthString<MinLength, MaxLength> & S`.\n   * @throws {TypeError} If `s.length < minLength` or `s.length > maxLength`.\n   */\n  export function asBoundedLengthString<\n    S extends string,\n    MinLength extends SupportedLength,\n    MaxLength extends SupportedLength,\n  >(\n    s: S,\n    minLength: MinLength,\n    maxLength: MaxLength,\n  ): BoundedLengthString<MinLength, MaxLength> & S;\n\n  // Curried version\n  export function asBoundedLengthString<\n    MinLength extends SupportedLength,\n    MaxLength extends SupportedLength,\n  >(\n    minLength: MinLength,\n    maxLength: MaxLength,\n  ): <S extends string>(s: S) => BoundedLengthString<MinLength, MaxLength> & S;\n\n  export function asBoundedLengthString(\n    ...args:\n      | readonly [\n          s: string,\n          minLength: SupportedLength,\n          maxLength: SupportedLength,\n        ]\n      | readonly [minLength: SupportedLength, maxLength: SupportedLength]\n  ): string | ((s: string) => string) {\n    switch (args.length) {\n      case 3: {\n        const [s, minLength, maxLength] = args;\n\n        if (!isBoundedLengthString(s, minLength, maxLength)) {\n          throw new TypeError(\n            `Expected a string of length in [${minLength}, ${maxLength}], got a string of length ${s.length}`,\n          );\n        }\n\n        return s;\n      }\n\n      case 2: {\n        const [minLength, maxLength] = args;\n\n        return (s) => asBoundedLengthString(s, minLength, maxLength);\n      }\n    }\n  }\n\n  /**\n   * Casts a string to `FixedLengthString<Length>` after checking that it has\n   * exactly `length` characters.\n   *\n   * Use this instead of writing `s as unknown as FixedLengthString<N>`: the\n   * length is verified at runtime, and the original string type (e.g. literal\n   * types) is preserved via intersection.\n   *\n   * Supports a curried overload: calling it with only `length` returns a\n   * function that casts a string, which is convenient for `pipe`/`map`.\n   *\n   * @example\n   *\n   * ```ts\n   * const countryCode = Str.asFixedLengthString('JP', 2);\n   *\n   * const atMost5: MaxLengthString<5> = countryCode; // OK (2 <= 5)\n   *\n   * assert.isTrue(atMost5.length === 2);\n   *\n   * // curried version\n   * const asCountryCode = Str.asFixedLengthString(2);\n   *\n   * assert.strictEqual(asCountryCode('US'), 'US');\n   *\n   * assert.throws(() => Str.asFixedLengthString('JP', 3)); // length 2 !== 3\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 cast.\n   * @param length - The exact number of characters.\n   * @returns `s` typed as `FixedLengthString<Length> & S`.\n   * @throws {TypeError} If `s.length !== length`.\n   */\n  export function asFixedLengthString<\n    S extends string,\n    Length extends SupportedLength,\n  >(s: S, length: Length): FixedLengthString<Length> & S;\n\n  // Curried version\n  export function asFixedLengthString<Length extends SupportedLength>(\n    length: Length,\n  ): <S extends string>(s: S) => FixedLengthString<Length> & S;\n\n  export function asFixedLengthString(\n    ...args:\n      | readonly [s: string, length: SupportedLength]\n      | readonly [length: SupportedLength]\n  ): string | ((s: string) => string) {\n    switch (args.length) {\n      case 2: {\n        const [s, length] = args;\n\n        if (!isFixedLengthString(s, length)) {\n          throw new TypeError(\n            `Expected a string of length ${length}, got a string of length ${s.length}`,\n          );\n        }\n\n        return s;\n      }\n\n      case 1: {\n        const [length] = args;\n\n        return (s) => asFixedLengthString(s, length);\n      }\n    }\n  }\n\n  /**\n   * Casts a string to `NonEmptyString` after checking that it has at least one\n   * character.\n   *\n   * `NonEmptyString` is an alias of `MinLengthString<1>`, so this is the\n   * length-1 specialization of {@link asMinLengthString}. Use this instead of\n   * writing `s as unknown as NonEmptyString`: the length is verified at\n   * runtime, and the original string type (e.g. literal types) is preserved\n   * via intersection.\n   *\n   * @example\n   *\n   * ```ts\n   * const name = Str.asNonEmptyString('noshiro');\n   *\n   * const nonEmpty: NonEmptyString = name; // OK\n   *\n   * assert.isTrue(nonEmpty.length >= 1);\n   *\n   * assert.throws(() => Str.asNonEmptyString('')); // length 0 < 1\n   * ```\n   *\n   * @template S - The input string type (literal types are preserved).\n   * @param s - The string to cast.\n   * @returns `s` typed as `NonEmptyString & S`.\n   * @throws {TypeError} If `s` is empty.\n   */\n  export const asNonEmptyString = <S extends string>(\n    s: S,\n  ): NonEmptyString & S => {\n    if (!isMinLengthString(s, 1)) {\n      throw new TypeError('Expected a non-empty string, got an empty string');\n    }\n\n    return s;\n  };\n}\n"],"names":["Str"],"mappings":"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"}
+{"version":3,"file":"str.mjs","sources":["../../src/string/str.mts"],"sourcesContent":["import {\n  type BoundedLengthString,\n  type FixedLengthString,\n  type MaxLengthString,\n  type MinLengthString,\n  type NonEmptyString,\n  type SupportedLength,\n} from 'ts-type-forge';\n\n/**\n * Namespace providing type guards and runtime-checked casts for the branded\n * length-constrained string types (`MinLengthString`, `MaxLengthString`,\n * `BoundedLengthString`, `FixedLengthString`).\n *\n * Lengths are 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 */\nexport namespace Str {\n  /**\n   * Type guard that checks if a string has at least `minLength` characters.\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(Str.isMinLengthString(input, 12));\n   *\n   * assert.isFalse(Str.isMinLengthString('short', 12));\n   *\n   * if (Str.isMinLengthString(input, 12)) {\n   *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)\n   *\n   *   assert.isTrue(nonEmpty.length >= 12);\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   */\n  export const isMinLengthString = <\n    S extends string,\n    MinLength extends SupportedLength,\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   * **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(Str.isMaxLengthString(input, 32));\n   *\n   * assert.isFalse(Str.isMaxLengthString(input, 3));\n   *\n   * if (Str.isMaxLengthString(input, 32)) {\n   *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)\n   *\n   *   assert.isTrue(relaxed.length <= 32);\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   */\n  export const isMaxLengthString = <\n    S extends string,\n    MaxLength extends SupportedLength,\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   * **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(Str.isBoundedLengthString(input, 8, 16));\n   *\n   * assert.isFalse(Str.isBoundedLengthString('user', 8, 16));\n   *\n   * if (Str.isBoundedLengthString(input, 8, 16)) {\n   *   const userId: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])\n   *\n   *   assert.isTrue(userId.length >= 8 && userId.length <= 16);\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   */\n  export const isBoundedLengthString = <\n    S extends string,\n    MinLength extends SupportedLength,\n    MaxLength extends SupportedLength,\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   * **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(Str.isFixedLengthString(input, 2));\n   *\n   * assert.isFalse(Str.isFixedLengthString(input, 3));\n   *\n   * if (Str.isFixedLengthString(input, 2)) {\n   *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)\n   *\n   *   assert.isTrue(atMost5.length === 2);\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   */\n  export const isFixedLengthString = <\n    S extends string,\n    Length extends SupportedLength,\n  >(\n    s: S,\n    length: Length,\n  ): s is FixedLengthString<Length> & S => s.length === length;\n\n  /**\n   * Casts a string to `MinLengthString<MinLength>` after checking that it has\n   * at least `minLength` characters.\n   *\n   * Use this instead of writing `s as unknown as MinLengthString<N>`: the\n   * length is verified at runtime, and the original string type (e.g. literal\n   * types) is preserved via intersection.\n   *\n   * Supports a curried overload: calling it with only `minLength` returns a\n   * function that casts a string, which is convenient for `pipe`/`map`.\n   *\n   * @example\n   *\n   * ```ts\n   * const password = Str.asMinLengthString('very-secret-password', 12);\n   *\n   * const nonEmpty: NonEmptyString = password; // OK (>= 1)\n   *\n   * assert.isTrue(nonEmpty.length >= 12);\n   *\n   * // curried version\n   * const asPassword = Str.asMinLengthString(12);\n   *\n   * assert.strictEqual(asPassword('another-secret'), 'another-secret');\n   *\n   * assert.throws(() => Str.asMinLengthString('short', 12)); // length 5 < 12\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 cast.\n   * @param minLength - The minimum number of characters (inclusive).\n   * @returns `s` typed as `MinLengthString<MinLength> & S`.\n   * @throws {TypeError} If `s.length < minLength`.\n   */\n  export function asMinLengthString<\n    S extends string,\n    MinLength extends SupportedLength,\n  >(s: S, minLength: MinLength): MinLengthString<MinLength> & S;\n\n  // Curried version\n  export function asMinLengthString<MinLength extends SupportedLength>(\n    minLength: MinLength,\n  ): <S extends string>(s: S) => MinLengthString<MinLength> & S;\n\n  export function asMinLengthString(\n    ...args:\n      | readonly [s: string, minLength: SupportedLength]\n      | readonly [minLength: SupportedLength]\n  ): string | ((s: string) => string) {\n    switch (args.length) {\n      case 2:\n        return asMinLengthStringImpl(...args);\n\n      case 1:\n        return (s) => asMinLengthStringImpl(s, ...args);\n    }\n  }\n\n  const asMinLengthStringImpl = (\n    s: string,\n    minLength: SupportedLength,\n  ): string => {\n    const actualLength = s.length;\n\n    if (!isMinLengthString(s, minLength)) {\n      throw new TypeError(\n        `Expected a string of length >= ${minLength}, got a string of length ${actualLength}`,\n      );\n    }\n\n    return s;\n  };\n\n  /**\n   * Casts a string to `MaxLengthString<MaxLength>` after checking that it has\n   * at most `maxLength` characters.\n   *\n   * Use this instead of writing `s as unknown as MaxLengthString<N>`: the\n   * length is verified at runtime, and the original string type (e.g. literal\n   * types) is preserved via intersection.\n   *\n   * Supports a curried overload: calling it with only `maxLength` returns a\n   * function that casts a string, which is convenient for `pipe`/`map`.\n   *\n   * @example\n   *\n   * ```ts\n   * const userName = Str.asMaxLengthString('noshiro', 32);\n   *\n   * const relaxed: MaxLengthString<64> = userName; // OK (32 <= 64)\n   *\n   * assert.isTrue(relaxed.length <= 32);\n   *\n   * // curried version\n   * const asUserName = Str.asMaxLengthString(32);\n   *\n   * assert.strictEqual(asUserName('another-user'), 'another-user');\n   *\n   * assert.throws(() => Str.asMaxLengthString('noshiro', 3)); // length 7 > 3\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 cast.\n   * @param maxLength - The maximum number of characters (inclusive).\n   * @returns `s` typed as `MaxLengthString<MaxLength> & S`.\n   * @throws {TypeError} If `s.length > maxLength`.\n   */\n  export function asMaxLengthString<\n    S extends string,\n    MaxLength extends SupportedLength,\n  >(s: S, maxLength: MaxLength): MaxLengthString<MaxLength> & S;\n\n  // Curried version\n  export function asMaxLengthString<MaxLength extends SupportedLength>(\n    maxLength: MaxLength,\n  ): <S extends string>(s: S) => MaxLengthString<MaxLength> & S;\n\n  export function asMaxLengthString(\n    ...args:\n      | readonly [s: string, maxLength: SupportedLength]\n      | readonly [maxLength: SupportedLength]\n  ): string | ((s: string) => string) {\n    switch (args.length) {\n      case 2:\n        return asMaxLengthStringImpl(...args);\n\n      case 1:\n        return (s) => asMaxLengthStringImpl(s, ...args);\n    }\n  }\n\n  const asMaxLengthStringImpl = (\n    s: string,\n    maxLength: SupportedLength,\n  ): string => {\n    const actualLength = s.length;\n\n    if (!isMaxLengthString(s, maxLength)) {\n      throw new TypeError(\n        `Expected a string of length <= ${maxLength}, got a string of length ${actualLength}`,\n      );\n    }\n\n    return s;\n  };\n\n  /**\n   * Casts a string to `BoundedLengthString<MinLength, MaxLength>` after\n   * checking that its length is within the inclusive range\n   * `[minLength, maxLength]`.\n   *\n   * Use this instead of writing `s as unknown as BoundedLengthString<M, N>`:\n   * the length is verified at runtime, and the original string type (e.g.\n   * literal types) is preserved via intersection.\n   *\n   * Supports a curried overload: calling it with only `minLength` and\n   * `maxLength` returns a function that casts a string, which is convenient for\n   * `pipe`/`map`.\n   *\n   * @example\n   *\n   * ```ts\n   * const userId = Str.asBoundedLengthString('user-12345678', 8, 16);\n   *\n   * const relaxed: BoundedLengthString<1, 255> = userId; // OK ([8, 16] ⊆ [1, 255])\n   *\n   * assert.isTrue(relaxed.length >= 8 && relaxed.length <= 16);\n   *\n   * // curried version\n   * const asUserId = Str.asBoundedLengthString(8, 16);\n   *\n   * assert.strictEqual(asUserId('user-87654321'), 'user-87654321');\n   *\n   * assert.throws(() => Str.asBoundedLengthString('user', 8, 16)); // length 4 < 8\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 cast.\n   * @param minLength - The minimum number of characters (inclusive).\n   * @param maxLength - The maximum number of characters (inclusive).\n   * @returns `s` typed as `BoundedLengthString<MinLength, MaxLength> & S`.\n   * @throws {TypeError} If `s.length < minLength` or `s.length > maxLength`.\n   */\n  export function asBoundedLengthString<\n    S extends string,\n    MinLength extends SupportedLength,\n    MaxLength extends SupportedLength,\n  >(\n    s: S,\n    minLength: MinLength,\n    maxLength: MaxLength,\n  ): BoundedLengthString<MinLength, MaxLength> & S;\n\n  // Curried version\n  export function asBoundedLengthString<\n    MinLength extends SupportedLength,\n    MaxLength extends SupportedLength,\n  >(\n    minLength: MinLength,\n    maxLength: MaxLength,\n  ): <S extends string>(s: S) => BoundedLengthString<MinLength, MaxLength> & S;\n\n  export function asBoundedLengthString(\n    ...args:\n      | readonly [\n          s: string,\n          minLength: SupportedLength,\n          maxLength: SupportedLength,\n        ]\n      | readonly [minLength: SupportedLength, maxLength: SupportedLength]\n  ): string | ((s: string) => string) {\n    switch (args.length) {\n      case 3:\n        return asBoundedLengthStringImpl(...args);\n\n      case 2:\n        return (s) => asBoundedLengthStringImpl(s, ...args);\n    }\n  }\n\n  const asBoundedLengthStringImpl = (\n    s: string,\n    minLength: SupportedLength,\n    maxLength: SupportedLength,\n  ): string => {\n    const actualLength = s.length;\n\n    if (!isBoundedLengthString(s, minLength, maxLength)) {\n      throw new TypeError(\n        `Expected a string of length in [${minLength}, ${maxLength}], got a string of length ${actualLength}`,\n      );\n    }\n\n    return s;\n  };\n\n  /**\n   * Casts a string to `FixedLengthString<Length>` after checking that it has\n   * exactly `length` characters.\n   *\n   * Use this instead of writing `s as unknown as FixedLengthString<N>`: the\n   * length is verified at runtime, and the original string type (e.g. literal\n   * types) is preserved via intersection.\n   *\n   * Supports a curried overload: calling it with only `length` returns a\n   * function that casts a string, which is convenient for `pipe`/`map`.\n   *\n   * @example\n   *\n   * ```ts\n   * const countryCode = Str.asFixedLengthString('JP', 2);\n   *\n   * const atMost5: MaxLengthString<5> = countryCode; // OK (2 <= 5)\n   *\n   * assert.isTrue(atMost5.length === 2);\n   *\n   * // curried version\n   * const asCountryCode = Str.asFixedLengthString(2);\n   *\n   * assert.strictEqual(asCountryCode('US'), 'US');\n   *\n   * assert.throws(() => Str.asFixedLengthString('JP', 3)); // length 2 !== 3\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 cast.\n   * @param length - The exact number of characters.\n   * @returns `s` typed as `FixedLengthString<Length> & S`.\n   * @throws {TypeError} If `s.length !== length`.\n   */\n  export function asFixedLengthString<\n    S extends string,\n    Length extends SupportedLength,\n  >(s: S, length: Length): FixedLengthString<Length> & S;\n\n  // Curried version\n  export function asFixedLengthString<Length extends SupportedLength>(\n    length: Length,\n  ): <S extends string>(s: S) => FixedLengthString<Length> & S;\n\n  export function asFixedLengthString(\n    ...args:\n      | readonly [s: string, length: SupportedLength]\n      | readonly [length: SupportedLength]\n  ): string | ((s: string) => string) {\n    switch (args.length) {\n      case 2:\n        return asFixedLengthStringImpl(...args);\n\n      case 1:\n        return (s) => asFixedLengthStringImpl(s, ...args);\n    }\n  }\n\n  const asFixedLengthStringImpl = (\n    s: string,\n    length: SupportedLength,\n  ): string => {\n    const actualLength = s.length;\n\n    if (!isFixedLengthString(s, length)) {\n      throw new TypeError(\n        `Expected a string of length ${length}, got a string of length ${actualLength}`,\n      );\n    }\n\n    return s;\n  };\n\n  /**\n   * Casts a string to `NonEmptyString` after checking that it has at least one\n   * character.\n   *\n   * `NonEmptyString` is an alias of `MinLengthString<1>`, so this is the\n   * length-1 specialization of {@link asMinLengthString}. Use this instead of\n   * writing `s as unknown as NonEmptyString`: the length is verified at\n   * runtime, and the original string type (e.g. literal types) is preserved\n   * via intersection.\n   *\n   * @example\n   *\n   * ```ts\n   * const name = Str.asNonEmptyString('noshiro');\n   *\n   * const nonEmpty: NonEmptyString = name; // OK\n   *\n   * assert.isTrue(nonEmpty.length >= 1);\n   *\n   * assert.throws(() => Str.asNonEmptyString('')); // length 0 < 1\n   * ```\n   *\n   * @template S - The input string type (literal types are preserved).\n   * @param s - The string to cast.\n   * @returns `s` typed as `NonEmptyString & S`.\n   * @throws {TypeError} If `s` is empty.\n   */\n  export const asNonEmptyString = <S extends string>(\n    s: S,\n  ): NonEmptyString & S => {\n    if (!isMinLengthString(s, 1)) {\n      throw new TypeError('Expected a non-empty string, got an empty string');\n    }\n\n    return s;\n  };\n}\n"],"names":["Str"],"mappings":"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"}