ts-data-forge 13.0.0 → 14.0.0

package/src/string/str.mts

@@ -33,30 +33,30 @@ export namespace Str {
    * ```ts
    * const input: string = 'very-secret-password';
    *
-   * assert.isTrue(Str.isMinLengthString(input, 12));
+   * assert.isTrue(Str.isMinLengthString(12, input));
    *
-   * assert.isFalse(Str.isMinLengthString('short', 12));
+   * assert.isFalse(Str.isMinLengthString(12, 'short'));
    *
-   * if (Str.isMinLengthString(input, 12)) {
+   * if (Str.isMinLengthString(12, input)) {
    *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)
    *
    *   assert.isTrue(nonEmpty.length >= 12);
    * }
    * ```
    *
-   * @template S - The input string type (literal types are preserved).
    * @template MinLength - The minimum number of characters (inclusive).
-   * @param s - The string to check.
+   * @template S - The input string type (literal types are preserved).
    * @param minLength - The minimum number of characters (inclusive).
+   * @param s - The string to check.
    * @returns `true` if `s.length >= minLength`, `false` otherwise. When `true`,
    *   TypeScript narrows `s` to `MinLengthString<MinLength> & S`.
    */
   export const isMinLengthString = <
-    S extends string,
     MinLength extends SupportedLength,
+    S extends string,
   >(
-    s: S,
     minLength: MinLength,
+    s: S,
   ): s is MinLengthString<MinLength> & S => s.length >= minLength;
 
   /**
@@ -75,30 +75,30 @@ export namespace Str {
    * ```ts
    * const input: string = 'noshiro';
    *
-   * assert.isTrue(Str.isMaxLengthString(input, 32));
+   * assert.isTrue(Str.isMaxLengthString(32, input));
    *
-   * assert.isFalse(Str.isMaxLengthString(input, 3));
+   * assert.isFalse(Str.isMaxLengthString(3, input));
    *
-   * if (Str.isMaxLengthString(input, 32)) {
+   * if (Str.isMaxLengthString(32, input)) {
    *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)
    *
    *   assert.isTrue(relaxed.length <= 32);
    * }
    * ```
    *
-   * @template S - The input string type (literal types are preserved).
    * @template MaxLength - The maximum number of characters (inclusive).
-   * @param s - The string to check.
+   * @template S - The input string type (literal types are preserved).
    * @param maxLength - The maximum number of characters (inclusive).
+   * @param s - The string to check.
    * @returns `true` if `s.length <= maxLength`, `false` otherwise. When `true`,
    *   TypeScript narrows `s` to `MaxLengthString<MaxLength> & S`.
    */
   export const isMaxLengthString = <
-    S extends string,
     MaxLength extends SupportedLength,
+    S extends string,
   >(
-    s: S,
     maxLength: MaxLength,
+    s: S,
   ): s is MaxLengthString<MaxLength> & S => s.length <= maxLength;
 
   /**
@@ -118,35 +118,35 @@ export namespace Str {
    * ```ts
    * const input: string = 'user-12345678';
    *
-   * assert.isTrue(Str.isBoundedLengthString(input, 8, 16));
+   * assert.isTrue(Str.isBoundedLengthString(8, 16, input));
    *
-   * assert.isFalse(Str.isBoundedLengthString('user', 8, 16));
+   * assert.isFalse(Str.isBoundedLengthString(8, 16, 'user'));
    *
-   * if (Str.isBoundedLengthString(input, 8, 16)) {
+   * if (Str.isBoundedLengthString(8, 16, input)) {
    *   const userId: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])
    *
    *   assert.isTrue(userId.length >= 8 && userId.length <= 16);
    * }
    * ```
    *
-   * @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.
+   * @template S - The input string type (literal types are preserved).
    * @param minLength - The minimum number of characters (inclusive).
    * @param maxLength - The maximum number of characters (inclusive).
+   * @param s - The string to check.
    * @returns `true` if `minLength <= s.length && s.length <= maxLength`, `false`
    *   otherwise. When `true`, TypeScript narrows `s` to
    *   `BoundedLengthString<MinLength, MaxLength> & S`.
    */
   export const isBoundedLengthString = <
-    S extends string,
     MinLength extends SupportedLength,
     MaxLength extends SupportedLength,
+    S extends string,
   >(
-    s: S,
     minLength: MinLength,
     maxLength: MaxLength,
+    s: S,
   ): s is BoundedLengthString<MinLength, MaxLength> & S =>
     s.length >= minLength && s.length <= maxLength;
 
@@ -167,30 +167,30 @@ export namespace Str {
    * ```ts
    * const input: string = 'JP';
    *
-   * assert.isTrue(Str.isFixedLengthString(input, 2));
+   * assert.isTrue(Str.isFixedLengthString(2, input));
    *
-   * assert.isFalse(Str.isFixedLengthString(input, 3));
+   * assert.isFalse(Str.isFixedLengthString(3, input));
    *
-   * if (Str.isFixedLengthString(input, 2)) {
+   * if (Str.isFixedLengthString(2, input)) {
    *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)
    *
    *   assert.isTrue(atMost5.length === 2);
    * }
    * ```
    *
-   * @template S - The input string type (literal types are preserved).
    * @template Length - The exact number of characters.
-   * @param s - The string to check.
+   * @template S - The input string type (literal types are preserved).
    * @param length - The exact number of characters.
+   * @param s - The string to check.
    * @returns `true` if `s.length === length`, `false` otherwise. When `true`,
    *   TypeScript narrows `s` to `FixedLengthString<Length> & S`.
    */
   export const isFixedLengthString = <
-    S extends string,
     Length extends SupportedLength,
+    S extends string,
   >(
-    s: S,
     length: Length,
+    s: S,
   ): s is FixedLengthString<Length> & S => s.length === length;
 
   /**
@@ -207,7 +207,7 @@ export namespace Str {
    * @example
    *
    * ```ts
-   * const password = Str.asMinLengthString('very-secret-password', 12);
+   * const password = Str.asMinLengthString(12, 'very-secret-password');
    *
    * const nonEmpty: NonEmptyString = password; // OK (>= 1)
    *
@@ -218,20 +218,20 @@ export namespace Str {
    *
    * assert.strictEqual(asPassword('another-secret'), 'another-secret');
    *
-   * assert.throws(() => Str.asMinLengthString('short', 12)); // length 5 < 12
+   * assert.throws(() => Str.asMinLengthString(12, 'short')); // length 5 < 12
    * ```
    *
-   * @template S - The input string type (literal types are preserved).
    * @template MinLength - The minimum number of characters (inclusive).
-   * @param s - The string to cast.
+   * @template S - The input string type (literal types are preserved).
    * @param minLength - The minimum number of characters (inclusive).
+   * @param s - The string to cast.
    * @returns `s` typed as `MinLengthString<MinLength> & S`.
    * @throws {TypeError} If `s.length < minLength`.
    */
   export function asMinLengthString<
-    S extends string,
     MinLength extends SupportedLength,
-  >(s: S, minLength: MinLength): MinLengthString<MinLength> & S;
+    S extends string,
+  >(minLength: MinLength, s: S): MinLengthString<MinLength> & S;
 
   // Curried version
   export function asMinLengthString<MinLength extends SupportedLength>(
@@ -240,7 +240,7 @@ export namespace Str {
 
   export function asMinLengthString(
     ...args:
-      | readonly [s: string, minLength: SupportedLength]
+      | readonly [minLength: SupportedLength, s: string]
       | readonly [minLength: SupportedLength]
   ): string | ((s: string) => string) {
     switch (args.length) {
@@ -248,17 +248,17 @@ export namespace Str {
         return asMinLengthStringImpl(...args);
 
       case 1:
-        return (s) => asMinLengthStringImpl(s, ...args);
+        return (s) => asMinLengthStringImpl(args[0], s);
     }
   }
 
   const asMinLengthStringImpl = (
-    s: string,
     minLength: SupportedLength,
+    s: string,
   ): string => {
     const actualLength = s.length;
 
-    if (!isMinLengthString(s, minLength)) {
+    if (!isMinLengthString(minLength, s)) {
       throw new TypeError(
         `Expected a string of length >= ${minLength}, got a string of length ${actualLength}`,
       );
@@ -281,7 +281,7 @@ export namespace Str {
    * @example
    *
    * ```ts
-   * const userName = Str.asMaxLengthString('noshiro', 32);
+   * const userName = Str.asMaxLengthString(32, 'noshiro');
    *
    * const relaxed: MaxLengthString<64> = userName; // OK (32 <= 64)
    *
@@ -292,20 +292,20 @@ export namespace Str {
    *
    * assert.strictEqual(asUserName('another-user'), 'another-user');
    *
-   * assert.throws(() => Str.asMaxLengthString('noshiro', 3)); // length 7 > 3
+   * assert.throws(() => Str.asMaxLengthString(3, 'noshiro')); // length 7 > 3
    * ```
    *
-   * @template S - The input string type (literal types are preserved).
    * @template MaxLength - The maximum number of characters (inclusive).
-   * @param s - The string to cast.
+   * @template S - The input string type (literal types are preserved).
    * @param maxLength - The maximum number of characters (inclusive).
+   * @param s - The string to cast.
    * @returns `s` typed as `MaxLengthString<MaxLength> & S`.
    * @throws {TypeError} If `s.length > maxLength`.
    */
   export function asMaxLengthString<
-    S extends string,
     MaxLength extends SupportedLength,
-  >(s: S, maxLength: MaxLength): MaxLengthString<MaxLength> & S;
+    S extends string,
+  >(maxLength: MaxLength, s: S): MaxLengthString<MaxLength> & S;
 
   // Curried version
   export function asMaxLengthString<MaxLength extends SupportedLength>(
@@ -314,7 +314,7 @@ export namespace Str {
 
   export function asMaxLengthString(
     ...args:
-      | readonly [s: string, maxLength: SupportedLength]
+      | readonly [maxLength: SupportedLength, s: string]
       | readonly [maxLength: SupportedLength]
   ): string | ((s: string) => string) {
     switch (args.length) {
@@ -322,17 +322,17 @@ export namespace Str {
         return asMaxLengthStringImpl(...args);
 
       case 1:
-        return (s) => asMaxLengthStringImpl(s, ...args);
+        return (s) => asMaxLengthStringImpl(args[0], s);
     }
   }
 
   const asMaxLengthStringImpl = (
-    s: string,
     maxLength: SupportedLength,
+    s: string,
   ): string => {
     const actualLength = s.length;
 
-    if (!isMaxLengthString(s, maxLength)) {
+    if (!isMaxLengthString(maxLength, s)) {
       throw new TypeError(
         `Expected a string of length <= ${maxLength}, got a string of length ${actualLength}`,
       );
@@ -357,7 +357,7 @@ export namespace Str {
    * @example
    *
    * ```ts
-   * const userId = Str.asBoundedLengthString('user-12345678', 8, 16);
+   * const userId = Str.asBoundedLengthString(8, 16, 'user-12345678');
    *
    * const relaxed: BoundedLengthString<1, 255> = userId; // OK ([8, 16] ⊆ [1, 255])
    *
@@ -368,26 +368,26 @@ export namespace Str {
    *
    * assert.strictEqual(asUserId('user-87654321'), 'user-87654321');
    *
-   * assert.throws(() => Str.asBoundedLengthString('user', 8, 16)); // length 4 < 8
+   * assert.throws(() => Str.asBoundedLengthString(8, 16, 'user')); // length 4 < 8
    * ```
    *
-   * @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 cast.
+   * @template S - The input string type (literal types are preserved).
    * @param minLength - The minimum number of characters (inclusive).
    * @param maxLength - The maximum number of characters (inclusive).
+   * @param s - The string to cast.
    * @returns `s` typed as `BoundedLengthString<MinLength, MaxLength> & S`.
    * @throws {TypeError} If `s.length < minLength` or `s.length > maxLength`.
    */
   export function asBoundedLengthString<
-    S extends string,
     MinLength extends SupportedLength,
     MaxLength extends SupportedLength,
+    S extends string,
   >(
-    s: S,
     minLength: MinLength,
     maxLength: MaxLength,
+    s: S,
   ): BoundedLengthString<MinLength, MaxLength> & S;
 
   // Curried version
@@ -402,9 +402,9 @@ export namespace Str {
   export function asBoundedLengthString(
     ...args:
       | readonly [
-          s: string,
           minLength: SupportedLength,
           maxLength: SupportedLength,
+          s: string,
         ]
       | readonly [minLength: SupportedLength, maxLength: SupportedLength]
   ): string | ((s: string) => string) {
@@ -413,18 +413,18 @@ export namespace Str {
         return asBoundedLengthStringImpl(...args);
 
       case 2:
-        return (s) => asBoundedLengthStringImpl(s, ...args);
+        return (s) => asBoundedLengthStringImpl(...args, s);
     }
   }
 
   const asBoundedLengthStringImpl = (
-    s: string,
     minLength: SupportedLength,
     maxLength: SupportedLength,
+    s: string,
   ): string => {
     const actualLength = s.length;
 
-    if (!isBoundedLengthString(s, minLength, maxLength)) {
+    if (!isBoundedLengthString(minLength, maxLength, s)) {
       throw new TypeError(
         `Expected a string of length in [${minLength}, ${maxLength}], got a string of length ${actualLength}`,
       );
@@ -447,7 +447,7 @@ export namespace Str {
    * @example
    *
    * ```ts
-   * const countryCode = Str.asFixedLengthString('JP', 2);
+   * const countryCode = Str.asFixedLengthString(2, 'JP');
    *
    * const atMost5: MaxLengthString<5> = countryCode; // OK (2 <= 5)
    *
@@ -458,20 +458,20 @@ export namespace Str {
    *
    * assert.strictEqual(asCountryCode('US'), 'US');
    *
-   * assert.throws(() => Str.asFixedLengthString('JP', 3)); // length 2 !== 3
+   * assert.throws(() => Str.asFixedLengthString(3, 'JP')); // length 2 !== 3
    * ```
    *
-   * @template S - The input string type (literal types are preserved).
    * @template Length - The exact number of characters.
-   * @param s - The string to cast.
+   * @template S - The input string type (literal types are preserved).
    * @param length - The exact number of characters.
+   * @param s - The string to cast.
    * @returns `s` typed as `FixedLengthString<Length> & S`.
    * @throws {TypeError} If `s.length !== length`.
    */
   export function asFixedLengthString<
-    S extends string,
     Length extends SupportedLength,
-  >(s: S, length: Length): FixedLengthString<Length> & S;
+    S extends string,
+  >(length: Length, s: S): FixedLengthString<Length> & S;
 
   // Curried version
   export function asFixedLengthString<Length extends SupportedLength>(
@@ -480,7 +480,7 @@ export namespace Str {
 
   export function asFixedLengthString(
     ...args:
-      | readonly [s: string, length: SupportedLength]
+      | readonly [length: SupportedLength, s: string]
       | readonly [length: SupportedLength]
   ): string | ((s: string) => string) {
     switch (args.length) {
@@ -488,17 +488,17 @@ export namespace Str {
         return asFixedLengthStringImpl(...args);
 
       case 1:
-        return (s) => asFixedLengthStringImpl(s, ...args);
+        return (s) => asFixedLengthStringImpl(args[0], s);
     }
   }
 
   const asFixedLengthStringImpl = (
-    s: string,
     length: SupportedLength,
+    s: string,
   ): string => {
     const actualLength = s.length;
 
-    if (!isFixedLengthString(s, length)) {
+    if (!isFixedLengthString(length, s)) {
       throw new TypeError(
         `Expected a string of length ${length}, got a string of length ${actualLength}`,
       );
@@ -537,7 +537,7 @@ export namespace Str {
   export const asNonEmptyString = <S extends string>(
     s: S,
   ): NonEmptyString & S => {
-    if (!isMinLengthString(s, 1)) {
+    if (!isMinLengthString(1, s)) {
       throw new TypeError('Expected a non-empty string, got an empty string');
     }
 

package/src/string/str.test.mts

@@ -10,31 +10,31 @@ import { Str } from './str.mjs';
 
 describe(Str.isMinLengthString, () => {
   test('should return true when the string is long enough', () => {
-    assert.isTrue(Str.isMinLengthString('hello', 3));
+    assert.isTrue(Str.isMinLengthString(3, 'hello'));
 
-    assert.isTrue(Str.isMinLengthString('hello', 5));
+    assert.isTrue(Str.isMinLengthString(5, 'hello'));
 
-    assert.isTrue(Str.isMinLengthString('', 0));
+    assert.isTrue(Str.isMinLengthString(0, ''));
 
-    assert.isTrue(Str.isMinLengthString(' ', 1)); // Space counts
+    assert.isTrue(Str.isMinLengthString(1, ' ')); // Space counts
   });
 
   test('should return false when the string is too short', () => {
-    assert.isFalse(Str.isMinLengthString('hi', 3));
+    assert.isFalse(Str.isMinLengthString(3, 'hi'));
 
-    assert.isFalse(Str.isMinLengthString('', 1));
+    assert.isFalse(Str.isMinLengthString(1, ''));
   });
 
   test('should measure length in UTF-16 code units', () => {
-    assert.isTrue(Str.isMinLengthString('🎉', 2)); // Surrogate pair
+    assert.isTrue(Str.isMinLengthString(2, '🎉')); // Surrogate pair
 
-    assert.isFalse(Str.isMinLengthString('🎉', 3));
+    assert.isFalse(Str.isMinLengthString(3, '🎉'));
   });
 
   test('should act as a type guard', () => {
     const value: string = 'very-secret-password';
 
-    if (Str.isMinLengthString(value, 12)) {
+    if (Str.isMinLengthString(12, value)) {
       expectType<typeof value, MinLengthString<12>>('<=');
 
       expectType<typeof value, NonEmptyString>('<='); // 12 >= 1
@@ -48,7 +48,7 @@ describe(Str.isMinLengthString, () => {
   test('should preserve literal string types', () => {
     const literal = 'hello';
 
-    if (Str.isMinLengthString(literal, 3)) {
+    if (Str.isMinLengthString(3, literal)) {
       expectType<typeof literal, 'hello'>('<=');
 
       expectType<typeof literal, MinLengthString<3>>('<=');
@@ -58,29 +58,29 @@ describe(Str.isMinLengthString, () => {
 
 describe(Str.isMaxLengthString, () => {
   test('should return true when the string is short enough', () => {
-    assert.isTrue(Str.isMaxLengthString('hello', 10));
+    assert.isTrue(Str.isMaxLengthString(10, 'hello'));
 
-    assert.isTrue(Str.isMaxLengthString('hello', 5));
+    assert.isTrue(Str.isMaxLengthString(5, 'hello'));
 
-    assert.isTrue(Str.isMaxLengthString('', 0));
+    assert.isTrue(Str.isMaxLengthString(0, ''));
   });
 
   test('should return false when the string is too long', () => {
-    assert.isFalse(Str.isMaxLengthString('hello', 3));
+    assert.isFalse(Str.isMaxLengthString(3, 'hello'));
 
-    assert.isFalse(Str.isMaxLengthString(' ', 0));
+    assert.isFalse(Str.isMaxLengthString(0, ' '));
   });
 
   test('should measure length in UTF-16 code units', () => {
-    assert.isFalse(Str.isMaxLengthString('🎉', 1)); // Surrogate pair
+    assert.isFalse(Str.isMaxLengthString(1, '🎉')); // Surrogate pair
 
-    assert.isTrue(Str.isMaxLengthString('🎉', 2));
+    assert.isTrue(Str.isMaxLengthString(2, '🎉'));
   });
 
   test('should act as a type guard', () => {
     const value: string = 'noshiro';
 
-    if (Str.isMaxLengthString(value, 32)) {
+    if (Str.isMaxLengthString(32, value)) {
       expectType<typeof value, MaxLengthString<32>>('<=');
 
       expectType<typeof value, MaxLengthString<64>>('<='); // 32 <= 64
@@ -94,25 +94,25 @@ describe(Str.isMaxLengthString, () => {
 
 describe(Str.isBoundedLengthString, () => {
   test('should return true when the length is within the range', () => {
-    assert.isTrue(Str.isBoundedLengthString('user-12345678', 8, 16));
+    assert.isTrue(Str.isBoundedLengthString(8, 16, 'user-12345678'));
 
-    assert.isTrue(Str.isBoundedLengthString('12345678', 8, 16)); // Lower bound (inclusive)
+    assert.isTrue(Str.isBoundedLengthString(8, 16, '12345678')); // Lower bound (inclusive)
 
-    assert.isTrue(Str.isBoundedLengthString('1234567890123456', 8, 16)); // Upper bound (inclusive)
+    assert.isTrue(Str.isBoundedLengthString(8, 16, '1234567890123456')); // Upper bound (inclusive)
 
-    assert.isTrue(Str.isBoundedLengthString('', 0, 0));
+    assert.isTrue(Str.isBoundedLengthString(0, 0, ''));
   });
 
   test('should return false when the length is out of range', () => {
-    assert.isFalse(Str.isBoundedLengthString('user', 8, 16));
+    assert.isFalse(Str.isBoundedLengthString(8, 16, 'user'));
 
-    assert.isFalse(Str.isBoundedLengthString('12345678901234567', 8, 16));
+    assert.isFalse(Str.isBoundedLengthString(8, 16, '12345678901234567'));
   });
 
   test('should act as a type guard', () => {
     const value: string = 'user-12345678';
 
-    if (Str.isBoundedLengthString(value, 8, 16)) {
+    if (Str.isBoundedLengthString(8, 16, value)) {
       expectType<typeof value, BoundedLengthString<8, 16>>('<=');
 
       expectType<typeof value, BoundedLengthString<1, 255>>('<='); // [8, 16] ⊆ [1, 255]
@@ -130,25 +130,25 @@ describe(Str.isBoundedLengthString, () => {
 
 describe(Str.isFixedLengthString, () => {
   test('should return true only for the exact length', () => {
-    assert.isTrue(Str.isFixedLengthString('JP', 2));
+    assert.isTrue(Str.isFixedLengthString(2, 'JP'));
 
-    assert.isTrue(Str.isFixedLengthString('', 0));
+    assert.isTrue(Str.isFixedLengthString(0, ''));
 
-    assert.isFalse(Str.isFixedLengthString('JPN', 2));
+    assert.isFalse(Str.isFixedLengthString(2, 'JPN'));
 
-    assert.isFalse(Str.isFixedLengthString('J', 2));
+    assert.isFalse(Str.isFixedLengthString(2, 'J'));
   });
 
   test('should measure length in UTF-16 code units', () => {
-    assert.isTrue(Str.isFixedLengthString('🎉', 2)); // Surrogate pair
+    assert.isTrue(Str.isFixedLengthString(2, '🎉')); // Surrogate pair
 
-    assert.isFalse(Str.isFixedLengthString('🎉', 1));
+    assert.isFalse(Str.isFixedLengthString(1, '🎉'));
   });
 
   test('should act as a type guard', () => {
     const value: string = 'JP';
 
-    if (Str.isFixedLengthString(value, 2)) {
+    if (Str.isFixedLengthString(2, value)) {
       expectType<typeof value, FixedLengthString<2>>('<=');
 
       expectType<typeof value, BoundedLengthString<2, 2>>('<=');
@@ -166,7 +166,7 @@ describe(Str.isFixedLengthString, () => {
 
 describe('Str length-bounded casts', () => {
   test('asMinLengthString returns the value and narrows its type', () => {
-    const result = Str.asMinLengthString('very-secret', 3);
+    const result = Str.asMinLengthString(3, 'very-secret');
 
     expectType<typeof result, MinLengthString<3>>('<=');
 
@@ -174,11 +174,11 @@ describe('Str length-bounded casts', () => {
   });
 
   test('asMinLengthString throws when too short', () => {
-    assert.throws(() => Str.asMinLengthString('hi', 3), TypeError);
+    assert.throws(() => Str.asMinLengthString(3, 'hi'), TypeError);
   });
 
   test('asMaxLengthString returns the value and narrows its type', () => {
-    const result = Str.asMaxLengthString('noshiro', 32);
+    const result = Str.asMaxLengthString(32, 'noshiro');
 
     expectType<typeof result, MaxLengthString<32>>('<=');
 
@@ -186,11 +186,11 @@ describe('Str length-bounded casts', () => {
   });
 
   test('asMaxLengthString throws when too long', () => {
-    assert.throws(() => Str.asMaxLengthString('noshiro', 3), TypeError);
+    assert.throws(() => Str.asMaxLengthString(3, 'noshiro'), TypeError);
   });
 
   test('asBoundedLengthString returns the value and narrows its type', () => {
-    const result = Str.asBoundedLengthString('user-12345678', 8, 16);
+    const result = Str.asBoundedLengthString(8, 16, 'user-12345678');
 
     expectType<typeof result, BoundedLengthString<8, 16>>('<=');
 
@@ -198,11 +198,11 @@ describe('Str length-bounded casts', () => {
   });
 
   test('asBoundedLengthString throws when out of range', () => {
-    assert.throws(() => Str.asBoundedLengthString('user', 8, 16), TypeError);
+    assert.throws(() => Str.asBoundedLengthString(8, 16, 'user'), TypeError);
   });
 
   test('asFixedLengthString returns the value and narrows its type', () => {
-    const result = Str.asFixedLengthString('JP', 2);
+    const result = Str.asFixedLengthString(2, 'JP');
 
     expectType<typeof result, FixedLengthString<2>>('<=');
 
@@ -210,7 +210,7 @@ describe('Str length-bounded casts', () => {
   });
 
   test('asFixedLengthString throws when the length differs', () => {
-    assert.throws(() => Str.asFixedLengthString('JP', 3), TypeError);
+    assert.throws(() => Str.asFixedLengthString(3, 'JP'), TypeError);
   });
 });