npm - ts-data-forge - Versions diffs - 12.2.1 → 13.0.0 - Mend

ts-data-forge 12.2.1 → 13.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (80) hide show

package/dist/string/str.mjs.map CHANGED Viewed

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

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "12.2.1",
+  "version": "13.0.0",
   "private": false,
   "keywords": [
     "typescript",
@@ -36,16 +36,16 @@
   ],
   "dependencies": {
     "@sindresorhus/is": "^8.1.0",
-    "ts-type-forge": "7.x"
+    "ts-type-forge": "~7.2.1"
   },
   "devDependencies": {
     "@emotion/react": "11.14.0",
     "@emotion/styled": "11.14.1",
     "@mui/material": "9.2.0",
     "@types/react": "19.2.17",
-    "immer": "11.1.11",
+    "immer": "11.1.15",
     "react": "19.2.7",
-    "typedoc": "0.28.19",
+    "typedoc": "0.28.20",
     "typedoc-github-theme": "0.4.0"
   },
   "peerDependencies": {
@@ -55,6 +55,10 @@
     "node": ">=22.22.2",
     "pnpm": ">=9.0.0"
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "scripts": {
     "build": "tsx ./scripts/cmd/build.mts",
     "build:min": "tsx ./scripts/cmd/build.mts --skip-check",

package/src/array/impl/array-utils-element-access.mts CHANGED Viewed

@@ -45,26 +45,25 @@ export function at<E>(
     | readonly [index: SizeType.ArgArrWithNegative]
 ): Optional<E> | ((array: readonly E[]) => Optional<E>) {
   switch (args.length) {
-    case 2: {
-      const [array, index] = args;
+    case 2:
+      return atImpl(...args);
-      return pipe(index < 0 ? array.length + index : index).map(
-        (normalizedIndex) =>
-          normalizedIndex < 0 || normalizedIndex >= array.length
-            ? Optional.none
-            : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-              Optional.some(array[normalizedIndex]!),
-      ).value;
-    }
-    case 1: {
-      const [index] = args;
-      return (array) => at(array, index);
-    }
+    case 1:
+      return (array) => atImpl(array, ...args);
   }
 }
+const atImpl = <E,>(
+  array: readonly E[],
+  index: SizeType.ArgArrWithNegative,
+): Optional<E> =>
+  pipe(index < 0 ? array.length + index : index).map((normalizedIndex) =>
+    normalizedIndex < 0 || normalizedIndex >= array.length
+      ? Optional.none
+      : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        Optional.some(array[normalizedIndex]!),
+  ).value;
 /**
  * Returns the first element of an array as an Optional.
  *

package/src/array/impl/array-utils-length-bounded-array-cast.mts CHANGED Viewed

@@ -66,25 +66,28 @@ export function asFixedLengthArray<E>(
     | readonly [length: SupportedLength]
 ): readonly E[] | ((xs: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [xs, length] = args;
+    case 2:
+      return asFixedLengthArrayImpl(...args);
-      if (!isFixedLengthArray(xs, length)) {
-        throw new TypeError(
-          `Expected an array of length ${length}, got an array of length ${xs.length}`,
-        );
-      }
-      return xs;
-    }
+    case 1:
+      return (xs) => asFixedLengthArrayImpl(xs, ...args);
+  }
+}
-    case 1: {
-      const [length] = args;
+const asFixedLengthArrayImpl = <E,>(
+  xs: readonly E[],
+  length: SupportedLength,
+): readonly E[] => {
+  const actualLength = xs.length;
-      return (xs) => asFixedLengthArray(xs, length);
-    }
+  if (!isFixedLengthArray(xs, length)) {
+    throw new TypeError(
+      `Expected an array of length ${length}, got an array of length ${actualLength}`,
+    );
   }
-}
+  return xs;
+};
 /**
  * Casts an array to `MinLengthArray<MinLength, E>` after checking that it has
@@ -139,25 +142,28 @@ export function asMinLengthArray<E>(
     | readonly [minLength: SupportedLength]
 ): readonly E[] | ((xs: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [xs, minLength] = args;
+    case 2:
+      return asMinLengthArrayImpl(...args);
-      if (!isMinLengthArray(xs, minLength)) {
-        throw new TypeError(
-          `Expected an array of length >= ${minLength}, got an array of length ${xs.length}`,
-        );
-      }
-      return xs;
-    }
+    case 1:
+      return (xs) => asMinLengthArrayImpl(xs, ...args);
+  }
+}
-    case 1: {
-      const [minLength] = args;
+const asMinLengthArrayImpl = <E,>(
+  xs: readonly E[],
+  minLength: SupportedLength,
+): readonly E[] => {
+  const actualLength = xs.length;
-      return (xs) => asMinLengthArray(xs, minLength);
-    }
+  if (!isMinLengthArray(xs, minLength)) {
+    throw new TypeError(
+      `Expected an array of length >= ${minLength}, got an array of length ${actualLength}`,
+    );
   }
-}
+  return xs;
+};
 /**
  * Casts an array to `MaxLengthArray<MaxLength, E>` after checking that it has
@@ -209,25 +215,28 @@ export function asMaxLengthArray<E>(
     | readonly [maxLength: SupportedLength]
 ): readonly E[] | ((xs: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [xs, maxLength] = args;
+    case 2:
+      return asMaxLengthArrayImpl(...args);
-      if (!isMaxLengthArray(xs, maxLength)) {
-        throw new TypeError(
-          `Expected an array of length <= ${maxLength}, got an array of length ${xs.length}`,
-        );
-      }
-      return xs;
-    }
+    case 1:
+      return (xs) => asMaxLengthArrayImpl(xs, ...args);
+  }
+}
-    case 1: {
-      const [maxLength] = args;
+const asMaxLengthArrayImpl = <E,>(
+  xs: readonly E[],
+  maxLength: SupportedLength,
+): readonly E[] => {
+  const actualLength = xs.length;
-      return (xs) => asMaxLengthArray(xs, maxLength);
-    }
+  if (!isMaxLengthArray(xs, maxLength)) {
+    throw new TypeError(
+      `Expected an array of length <= ${maxLength}, got an array of length ${actualLength}`,
+    );
   }
-}
+  return xs;
+};
 /**
  * Casts an array to `BoundedLengthArray<MinLength, MaxLength, E>` after
@@ -298,25 +307,29 @@ export function asBoundedLengthArray<E>(
     | readonly [minLength: SupportedLength, maxLength: SupportedLength]
 ): readonly E[] | ((xs: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 3: {
-      const [xs, minLength, maxLength] = args;
+    case 3:
+      return asBoundedLengthArrayImpl(...args);
-      if (!isBoundedLengthArray(xs, minLength, maxLength)) {
-        throw new TypeError(
-          `Expected an array of length in [${minLength}, ${maxLength}], got an array of length ${xs.length}`,
-        );
-      }
-      return xs;
-    }
+    case 2:
+      return (xs) => asBoundedLengthArrayImpl(xs, ...args);
+  }
+}
-    case 2: {
-      const [minLength, maxLength] = args;
+const asBoundedLengthArrayImpl = <E,>(
+  xs: readonly E[],
+  minLength: SupportedLength,
+  maxLength: SupportedLength,
+): readonly E[] => {
+  const actualLength = xs.length;
-      return (xs) => asBoundedLengthArray(xs, minLength, maxLength);
-    }
+  if (!isBoundedLengthArray(xs, minLength, maxLength)) {
+    throw new TypeError(
+      `Expected an array of length in [${minLength}, ${maxLength}], got an array of length ${actualLength}`,
+    );
   }
-}
+  return xs;
+};
 /**
  * Casts an array to `NonEmptyArray<E>` after checking that it has at least one

package/src/array/impl/array-utils-modification.mts CHANGED Viewed

@@ -55,20 +55,20 @@ export function set<E, const V = E>(
     | readonly [index: SizeType.ArgArr, newValue: V]
 ): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {
   switch (args.length) {
-    case 3: {
-      const [array, index, newValue] = args;
+    case 3:
+      return setImpl(...args);
-      return (array as readonly (E | V)[]).with(index, newValue);
-    }
-    case 2: {
-      const [index, newValue] = args;
-      return (array) => set(array, index, newValue);
-    }
+    case 2:
+      return (array) => setImpl(array, ...args);
   }
 }
+const setImpl = <E, const V = E>(
+  array: readonly E[],
+  index: SizeType.ArgArr,
+  newValue: V,
+): readonly (E | V)[] => (array as readonly (E | V)[]).with(index, newValue);
 /**
  * Returns a new array with an element at the specified index updated by applying a function.
  *
@@ -124,21 +124,22 @@ export function toUpdated<E, V = E>(
     | readonly [index: SizeType.ArgArr, updater: (prev: E) => V]
 ): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {
   switch (args.length) {
-    case 3: {
-      const [array, index, updater] = args;
+    case 3:
+      return toUpdatedImpl(...args);
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      return (array as readonly (E | V)[]).with(index, updater(array[index]!));
-    }
-    case 2: {
-      const [index, updater] = args;
-      return (array) => toUpdated(array, index, updater);
-    }
+    case 2:
+      return (array) => toUpdatedImpl(array, ...args);
   }
 }
+const toUpdatedImpl = <E, V = E>(
+  array: readonly E[],
+  index: SizeType.ArgArr,
+  updater: (prev: E) => V,
+): readonly (E | V)[] =>
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  (array as readonly (E | V)[]).with(index, updater(array[index]!));
 /**
  * Returns a new array with a value inserted at the specified index.
  *
@@ -187,25 +188,26 @@ export function toInserted<E, const V = E>(
     | readonly [index: SizeType.ArgArrWithNegative, newValue: V]
 ): NonEmptyArray<E | V> | ((array: readonly E[]) => NonEmptyArray<E | V>) {
   switch (args.length) {
-    case 3: {
-      const [array, index, newValue] = args;
-      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      return (array as readonly (E | V)[]).toSpliced(
-        index,
-        0,
-        newValue,
-      ) as unknown as NonEmptyArray<E | V>;
-    }
-    case 2: {
-      const [index, newValue] = args;
-      return (array) => toInserted(array, index, newValue);
-    }
+    case 3:
+      return toInsertedImpl(...args);
+    case 2:
+      return (array) => toInsertedImpl(array, ...args);
   }
 }
+const toInsertedImpl = <E, const V = E>(
+  array: readonly E[],
+  index: SizeType.ArgArrWithNegative,
+  newValue: V,
+): NonEmptyArray<E | V> =>
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  (array as readonly (E | V)[]).toSpliced(
+    index,
+    0,
+    newValue,
+  ) as unknown as NonEmptyArray<E | V>;
 type CastToNumber<T> = T extends number ? T : never;
 /**
@@ -240,20 +242,19 @@ export function toRemoved<E>(
     | readonly [index: SizeType.ArgArrWithNegative]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [array, index] = args;
-      return array.toSpliced(index, 1);
-    }
+    case 2:
+      return toRemovedImpl(...args);
-    case 1: {
-      const [index] = args;
-      return (array) => toRemoved(array, index);
-    }
+    case 1:
+      return (array) => toRemovedImpl(array, ...args);
   }
 }
+const toRemovedImpl = <E,>(
+  array: readonly E[],
+  index: SizeType.ArgArrWithNegative,
+): readonly E[] => array.toSpliced(index, 1);
 /**
  * Returns a new array with a value appended to the end.
  *
@@ -291,24 +292,21 @@ export function toPushed<const Ar extends readonly unknown[], const V>(
   ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]
 ): readonly [...Ar, V] | ((array: Ar) => readonly [...Ar, V]) {
   switch (args.length) {
-    case 2: {
-      const [array, newValue] = args;
-      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      return array.toSpliced(array.length, 0, newValue) as unknown as readonly [
-        ...Ar,
-        V,
-      ];
-    }
-    case 1: {
-      const [newValue] = args;
+    case 2:
+      return toPushedImpl(...args);
-      return (array) => toPushed(array, newValue);
-    }
+    case 1:
+      return (array) => toPushedImpl(array, ...args);
   }
 }
+const toPushedImpl = <const Ar extends readonly unknown[], const V>(
+  array: Ar,
+  newValue: V,
+): readonly [...Ar, V] =>
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  array.toSpliced(array.length, 0, newValue) as unknown as readonly [...Ar, V];
 /**
  * Returns a new array with a value prepended to the beginning.
  *
@@ -346,21 +344,21 @@ export function toUnshifted<Ar extends readonly unknown[], const V>(
   ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]
 ): readonly [V, ...Ar] | ((array: Ar) => readonly [V, ...Ar]) {
   switch (args.length) {
-    case 2: {
-      const [array, newValue] = args;
-      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      return array.toSpliced(0, 0, newValue) as unknown as readonly [V, ...Ar];
-    }
-    case 1: {
-      const [newValue] = args;
+    case 2:
+      return toUnshiftedImpl(...args);
-      return (array) => toUnshifted(array, newValue);
-    }
+    case 1:
+      return (array) => toUnshiftedImpl(array, ...args);
   }
 }
+const toUnshiftedImpl = <Ar extends readonly unknown[], const V>(
+  array: Ar,
+  newValue: V,
+): readonly [V, ...Ar] =>
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  array.toSpliced(0, 0, newValue) as unknown as readonly [V, ...Ar];
 /**
  * Returns a new array with all elements replaced by the specified value.
  *
@@ -402,20 +400,17 @@ export function toFilled<E>(
   ...args: readonly [array: readonly E[], value: E] | readonly [value: E]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [array, value] = args;
-      return create(asPositiveUint32(array.length), value);
-    }
-    case 1: {
-      const [value] = args;
+    case 2:
+      return toFilledImpl(...args);
-      return (array) => toFilled(array, value);
-    }
+    case 1:
+      return (array) => toFilledImpl(array, ...args);
   }
 }
+const toFilledImpl = <E,>(array: readonly E[], value: E): readonly E[] =>
+  create(asPositiveUint32(array.length), value);
 /**
  * Returns a new array with elements in the specified range replaced by the specified value.
  *
@@ -480,20 +475,27 @@ export function toRangeFilled<E, const V>(
       ]
 ): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {
   switch (args.length) {
-    case 3: {
-      const [array, value, [start, end]] = args;
+    case 3:
+      return toRangeFilledImpl(...args);
-      const mut_cp: (E | V)[] = castMutable(copy(array));
+    case 2:
+      return (array) => toRangeFilledImpl(array, ...args);
+  }
+}
-      mut_cp.fill(value, start, end);
+const toRangeFilledImpl = <E, const V>(
+  array: readonly E[],
+  value: V,
+  fillRange: readonly [
+    start: SizeType.ArgArrWithNegative,
+    end: SizeType.ArgArrWithNegative,
+  ],
+): readonly (E | V)[] => {
+  const [start, end] = fillRange;
-      return mut_cp;
-    }
+  const mut_cp: (E | V)[] = castMutable(copy(array));
-    case 2: {
-      const [value, fillRange] = args;
+  mut_cp.fill(value, start, end);
-      return (array) => toRangeFilled(array, value, fillRange);
-    }
-  }
-}
+  return mut_cp;
+};