ts-data-forge 12.0.0 → 12.2.0

package/dist/array/impl/array-utils-transformation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-transformation.mjs","sources":["../../../src/array/impl/array-utils-transformation.mts"],"sourcesContent":["import {\n  type FixedLengthTuple,\n  type IsFixedLengthList,\n  type List,\n  type NonEmptyArray,\n  type NonEmptyTuple,\n  type PositiveInt,\n  type PositiveUint32,\n  type Primitive,\n  type SafeUintWithSmallInt,\n  type WithSmallInt,\n} from 'ts-type-forge';\nimport { IMap } from '../../collections/index.mjs';\nimport { expectType } from '../../expect-type.mjs';\nimport { asPositiveUint32, asUint32, Uint32 } from '../../number/index.mjs';\nimport { castMutable, tp } from '../../others/index.mjs';\nimport {\n  type ArrayIndex,\n  type MapSetKeyType,\n  type SizeType,\n} from '../../types.mjs';\nimport { newArray, seq } from './array-utils-creation.mjs';\nimport { size } from './array-utils-size.mjs';\nimport { isNonEmpty } from './array-utils-validation.mjs';\n\n/**\n * Creates a new array by transforming each element with a mapping function.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3] as const;\n *\n * const doubled = Arr.map(numbers, (value) => value * 2);\n *\n * const indexed = Arr.map<number, string>(\n *   (value, index) => `${index}:${value}`,\n * )(numbers);\n *\n * assert.deepStrictEqual(doubled, [2, 4, 6]);\n *\n * assert.deepStrictEqual(indexed, ['0:1', '1:2', '2:3']);\n * ```\n */\nexport function map<const Ar extends readonly unknown[], B>(\n  array: Ar,\n  mapFn: (a: Ar[number], index: ArrayIndex<Ar>) => B,\n): Readonly<{ [K in keyof Ar]: B }>;\n\n// curried version\nexport function map<A, B>(\n  mapFn: (a: A, index: SizeType.Arr) => B,\n): <const Ar extends readonly A[]>(\n  array: Ar,\n) => Readonly<{ [K in keyof Ar]: B }>;\n\nexport function map<A, B>(\n  ...args:\n    | readonly [array: readonly A[], mapFn: (a: A, index: SizeType.Arr) => B]\n    | readonly [mapFn: (a: A, index: SizeType.Arr) => B]\n): readonly B[] | ((array: readonly A[]) => readonly B[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, mapFn] = args;\n\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      return array.map(mapFn as never);\n    }\n\n    case 1: {\n      const [mapFn] = args;\n\n      return (array: readonly A[]) => map(array, mapFn);\n    }\n  }\n}\n\n/**\n * Returns an array of successively reduced values from an array.\n *\n * @example\n *\n * ```ts\n * const changes = [5, -2, 3] as const;\n *\n * const runningTotals = Arr.scan(\n *   changes,\n *   (total, change) => total + change,\n *   0,\n * );\n *\n * const runningTotalsFromCurried = Arr.scan(\n *   (total: number, change: number) => total + change,\n *   10,\n * )([-5, 15]);\n *\n * const expectedTotals = [0, 5, 3, 6] as const;\n *\n * const expectedCurriedTotals = [10, 5, 20] as const;\n *\n * assert.deepStrictEqual<readonly number[]>(runningTotals, expectedTotals);\n *\n * assert.deepStrictEqual<readonly number[]>(\n *   runningTotalsFromCurried,\n *   expectedCurriedTotals,\n * );\n * ```\n */\nexport function scan<const Ar extends readonly unknown[], S>(\n  array: Ar,\n  reducer: (\n    accumulator: S,\n    currentValue: Ar[number],\n    currentIndex: ArrayIndex<Ar>,\n  ) => S,\n  init: S,\n): NonEmptyArray<S>;\n\nexport function scan<E, S>(\n  reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S,\n  init: S,\n): (array: readonly E[]) => NonEmptyArray<S>;\n\nexport function scan<E, S>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        reducer: (\n          accumulator: S,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => S,\n        init: S,\n      ]\n    | readonly [\n        reducer: (\n          accumulator: S,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => S,\n        init: S,\n      ]\n): NonEmptyTuple<S> | ((array: readonly E[]) => NonEmptyTuple<S>) {\n  switch (args.length) {\n    case 3: {\n      const [array, reducer, init] = args;\n\n      const mut_result = castMutable<NonEmptyTuple<S>>(\n        newArray<PositiveUint32, S>(asPositiveUint32(array.length + 1), init),\n      );\n\n      let mut_acc = init;\n\n      for (const [index, value] of array.entries()) {\n        mut_acc = reducer(mut_acc, value, asUint32(index));\n\n        mut_result[index + 1] = mut_acc;\n      }\n\n      return mut_result;\n    }\n\n    case 2: {\n      const [reducer, init] = args;\n\n      return (array) => scan(array, reducer, init);\n    }\n  }\n}\n\n/**\n * Reverses an array.\n *\n * @example\n *\n * ```ts\n * const tuple = [1, 'two', true] as const;\n *\n * const reversed = Arr.toReversed(tuple);\n *\n * const expected = [true, 'two', 1] as const;\n *\n * assert.deepStrictEqual(reversed, expected);\n * ```\n */\nexport const toReversed = <const Ar extends readonly unknown[]>(\n  array: Ar,\n): List.Reverse<Ar> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  array.toReversed() as never;\n\n/**\n * Sorts an array.\n *\n * @example\n *\n * ```ts\n * const numbers = [3, 1, 2] as const;\n *\n * const words = ['banana', 'apple', 'cherry'] as const;\n *\n * const ascendingNumbers = Arr.toSorted(numbers);\n *\n * const alphabetical = Arr.toSorted(words, (left, right) =>\n *   left.localeCompare(right),\n * );\n *\n * const expectedNumbers = [1, 2, 3] as const;\n *\n * const expectedWords = ['apple', 'banana', 'cherry'] as const;\n *\n * assert.deepStrictEqual(ascendingNumbers, expectedNumbers);\n *\n * assert.deepStrictEqual(alphabetical, expectedWords);\n * ```\n */\nexport const toSorted = <const Ar extends readonly unknown[]>(\n  ...[array, comparator]: Ar extends readonly number[]\n    ? readonly [\n        array: Ar,\n        // If the array elements are mapped to numbers, comparator is optional.\n        comparator?: (x: Ar[number], y: Ar[number]) => number,\n      ]\n    : readonly [array: Ar, comparator: (x: Ar[number], y: Ar[number]) => number]\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], Ar[number]>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number]>\n    : readonly Ar[number][] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  array.toSorted(\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    (comparator as ((x: unknown, y: unknown) => number) | undefined) ??\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      ((x, y) => (x as number) - (y as number)),\n  ) as never;\n\n/**\n * Sorts an array by a mapped value.\n *\n * @example\n *\n * ```ts\n * const projects = [\n *   { name: 'compiler', issues: 7 },\n *   { name: 'docs', issues: 2 },\n *   { name: 'ui', issues: 5 },\n * ] as const;\n *\n * const byIssueCount = Arr.toSortedBy(projects, (project) => project.issues);\n *\n * const byIssueCountDescending = Arr.toSortedBy(\n *   projects,\n *   (project) => project.issues,\n *   (left, right) => right - left,\n * );\n *\n * const expectedByIssues = [\n *   { name: 'docs', issues: 2 },\n *   { name: 'ui', issues: 5 },\n *   { name: 'compiler', issues: 7 },\n * ] as const;\n *\n * const expectedByIssueCountDescending = [\n *   { name: 'compiler', issues: 7 },\n *   { name: 'ui', issues: 5 },\n *   { name: 'docs', issues: 2 },\n * ] as const;\n *\n * assert.deepStrictEqual(byIssueCount, expectedByIssues);\n *\n * assert.deepStrictEqual(\n *   byIssueCountDescending,\n *   expectedByIssueCountDescending,\n * );\n * ```\n */\nexport function toSortedBy<const Ar extends readonly unknown[]>(\n  array: Ar,\n  comparatorValueMapper: (value: Ar[number]) => number,\n  // If the array elements are mapped to numbers, comparator is optional.\n  comparator?: (x: number, y: number) => number,\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], Ar[number]>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number]>\n    : readonly Ar[number][];\n\nexport function toSortedBy<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  comparatorValueMapper: (value: Ar[number]) => V,\n  comparator: (x: V, y: V) => number,\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], Ar[number]>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number]>\n    : readonly Ar[number][];\n\nexport function toSortedBy<E, const V>(\n  array: readonly E[],\n  comparatorValueMapper: (value: E) => V,\n  comparator?: (x: V, y: V) => number,\n): readonly E[] {\n  return array.toSorted((x, y) =>\n    comparator === undefined\n      ? // This branch assumes V is number if comparator is undefined.\n        // The overloads should handle this, but explicit cast might be needed if V is not number.\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        (comparatorValueMapper(x) as number) -\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        (comparatorValueMapper(y) as number)\n      : comparator(comparatorValueMapper(x), comparatorValueMapper(y)),\n  );\n}\n\n/**\n * Filters an array based on a predicate function.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3, 4] as const;\n *\n * const evens = Arr.filter(numbers, (value) => value % 2 === 0);\n *\n * const greaterThanTwo = Arr.filter<number>((value) => value > 2)(numbers);\n *\n * assert.deepStrictEqual(evens, [2, 4]);\n *\n * assert.deepStrictEqual(greaterThanTwo, [3, 4]);\n * ```\n */\n// Type guard overloads\nexport function filter<\n  const Ar extends readonly unknown[],\n  S extends Ar[number],\n>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => a is S,\n): readonly S[];\n\nexport function filter<E, S extends E>(\n  predicate: (a: E, index: SizeType.Arr) => a is S,\n): (array: readonly E[]) => readonly S[];\n\n// Regular boolean predicate overloads\nexport function filter<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): readonly Ar[number][];\n\nexport function filter<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => readonly E[];\n\nexport function filter<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (a: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return array.filter((a, i) => predicate(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => filter(array, predicate);\n    }\n  }\n}\n\n/**\n * Filters an array by excluding elements for which the predicate returns true.\n *\n * @example\n *\n * ```ts\n * const names = ['Ada', 'Grace', 'Linus'] as const;\n *\n * const notAda = Arr.filterNot(names, (name) => name === 'Ada');\n *\n * const notShort = Arr.filterNot<string>((name) => name.length <= 4)(names);\n *\n * assert.deepStrictEqual(notAda, ['Grace', 'Linus']);\n *\n * assert.deepStrictEqual(notShort, ['Grace', 'Linus']);\n * ```\n */\nexport function filterNot<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): readonly Ar[number][];\n\nexport function filterNot<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => readonly E[];\n\nexport function filterNot<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (a: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return array.filter((a, i) => !predicate(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => filterNot(array, predicate);\n    }\n  }\n}\n\n/**\n * Creates a new array with unique elements.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'a', 'c', 'b'] as const;\n *\n * const uniqueLetters = Arr.uniq(letters);\n *\n * const expected = ['a', 'b', 'c'] as const;\n *\n * assert.deepStrictEqual<readonly string[]>(uniqueLetters, expected);\n * ```\n */\nexport const uniq = <const Ar extends readonly Primitive[]>(\n  array: Ar,\n): Ar extends NonEmptyTuple<unknown>\n  ? NonEmptyArray<Ar[number]>\n  : readonly Ar[number][] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  Array.from(new Set(array)) as never;\n\n/**\n * Creates a new array with unique elements based on a mapped value.\n *\n * @example\n *\n * ```ts\n * const people = [\n *   { id: 1, name: 'Ada' },\n *   { id: 2, name: 'Brian' },\n *   { id: 1, name: 'Alan' },\n *   { id: 3, name: 'Grace' },\n * ] as const;\n *\n * const uniqueById = Arr.uniqBy(people, (person) => person.id);\n *\n * const expected = [\n *   { id: 1, name: 'Ada' },\n *   { id: 2, name: 'Brian' },\n *   { id: 3, name: 'Grace' },\n * ] as const;\n *\n * assert.deepStrictEqual<readonly Readonly<{ id: number; name: string }>[]>(\n *   uniqueById,\n *   expected,\n * );\n * ```\n */\nexport const uniqBy = <\n  const Ar extends readonly unknown[],\n  P extends Primitive,\n>(\n  array: Ar,\n  mapFn: (value: Ar[number]) => P,\n): Ar extends NonEmptyTuple<unknown>\n  ? NonEmptyArray<Ar[number]>\n  : readonly Ar[number][] => {\n  const mut_mappedValues = new Set<P>();\n\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  return array.filter((val) => {\n    const mappedValue = mapFn(val);\n\n    if (mut_mappedValues.has(mappedValue)) return false;\n\n    mut_mappedValues.add(mappedValue);\n\n    return true;\n  }) satisfies readonly Ar[number][] as never;\n};\n\n/**\n * Flattens nested arrays up to the specified depth.\n *\n * @example\n *\n * ```ts\n * const nested = [\n *   [1, 2],\n *   [3, 4],\n * ] as const;\n *\n * const flatOnce = Arr.flat(nested, 1);\n *\n * const flatCurried = Arr.flat()(nested);\n *\n * assert.deepStrictEqual(flatOnce, [1, 2, 3, 4]);\n *\n * assert.deepStrictEqual(flatCurried, [1, 2, 3, 4]);\n * ```\n */\nexport function flat<\n  const Ar extends readonly unknown[],\n  D extends SafeUintWithSmallInt = 1,\n>(array: Ar, depth?: D): readonly FlatArray<Ar, D>[];\n\nexport function flat<D extends SafeUintWithSmallInt = 1>(\n  depth?: number,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => readonly FlatArray<Ar, D>[];\n\nexport function flat<E, D extends SafeUintWithSmallInt = 1>(\n  ...args: readonly [array: readonly E[], depth?: D] | readonly [depth?: D]\n): readonly unknown[] | ((array: readonly unknown[]) => readonly unknown[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, depth] = args;\n\n      return array.flat(depth);\n    }\n\n    case 1: {\n      const [arrayOrDepth] = args;\n\n      if (typeof arrayOrDepth === 'number') {\n        const depth = arrayOrDepth as SafeUintWithSmallInt | undefined;\n\n        return (array) => flat(array, depth);\n      }\n\n      if (arrayOrDepth === undefined) {\n        return (array) => flat(array, 1);\n      }\n\n      expectType<typeof arrayOrDepth, readonly E[]>('=');\n\n      return arrayOrDepth.flat();\n    }\n\n    case 0:\n      return (array) => flat(array, 1);\n  }\n}\n\n/**\n * Maps each element and flattens the result.\n *\n * @example\n *\n * ```ts\n * const words = ['Ada', 'AI'] as const;\n *\n * const characters = Arr.flatMap(words, (word) => word.split(''));\n *\n * const labeled = Arr.flatMap<string, string>((word, index) =>\n *   word.split('').map((char) => `${index}-${char}`),\n * )(words);\n *\n * assert.deepStrictEqual(characters, ['A', 'd', 'a', 'A', 'I']);\n *\n * assert.deepStrictEqual(labeled, ['0-A', '0-d', '0-a', '1-A', '1-I']);\n * ```\n */\nexport function flatMap<const Ar extends readonly unknown[], B>(\n  array: Ar,\n  mapFn: (a: Ar[number], index: ArrayIndex<Ar>) => readonly B[],\n): readonly B[];\n\nexport function flatMap<A, B>(\n  mapFn: (a: A, index: SizeType.Arr) => readonly B[],\n): (array: readonly A[]) => readonly B[];\n\nexport function flatMap<A, B>(\n  ...args:\n    | readonly [\n        array: readonly A[],\n        mapFn: (a: A, index: SizeType.Arr) => readonly B[],\n      ]\n    | readonly [mapFn: (a: A, index: SizeType.Arr) => readonly B[]]\n): readonly B[] | ((array: readonly A[]) => readonly B[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, mapFn] = args;\n\n      return array.flatMap((a, i) => mapFn(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [mapFn] = args;\n\n      return (array: readonly A[]) => flatMap(array, mapFn);\n    }\n  }\n}\n\n/**\n * Partitions an array into sub-arrays of a specified size.\n *\n * @example\n *\n * ```ts\n * const values = [1, 2, 3, 4, 5] as const;\n *\n * const pairs = Arr.partition(values, 2);\n *\n * const triples = Arr.partition(3)(values);\n *\n * const expectedPairs = [[1, 2], [3, 4], [5]] as const;\n *\n * assert.deepStrictEqual(pairs, expectedPairs);\n *\n * assert.deepStrictEqual(triples, [\n *   [1, 2, 3],\n *   [4, 5],\n * ]);\n *\n * const pairs2 = Arr.chunk([1, 2, 3, 4, 5, 6], 2);\n *\n * assert.deepStrictEqual(pairs2, [\n *   [1, 2],\n *   [3, 4],\n *   [5, 6],\n * ]);\n * ```\n */\nexport function partition<\n  N extends WithSmallInt<PositiveInt & SizeType.Arr>,\n  E,\n>(array: readonly E[], chunkSize: N): readonly (readonly E[])[];\n\nexport function partition<N extends WithSmallInt<PositiveInt & SizeType.Arr>>(\n  chunkSize: N,\n): <E>(array: readonly E[]) => readonly (readonly E[])[];\n\nexport function partition<\n  N extends WithSmallInt<PositiveInt & SizeType.Arr>,\n  E,\n>(\n  ...args:\n    readonly [array: readonly E[], chunkSize: N] | readonly [chunkSize: N]\n):\n  | readonly (readonly E[])[]\n  | ((array: readonly E[]) => readonly (readonly E[])[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, chunkSize] = args;\n\n      return chunkSize < 2\n        ? []\n        : // eslint-disable-next-line total-functions/no-partial-division\n          seq(asUint32(Math.ceil(array.length / chunkSize))).map((i: Uint32) =>\n            array.slice(chunkSize * i, chunkSize * (i + 1)),\n          );\n    }\n\n    case 1: {\n      const [chunkSize] = args;\n\n      return (array) => partition(array, chunkSize);\n    }\n  }\n}\n\n/**\n * Concatenates two arrays.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2] as const;\n *\n * const words = ['three', 'four'] as const;\n *\n * const combined = Arr.concat(numbers, words);\n *\n * const expectedCombined = [1, 2, 'three', 'four'] as const;\n *\n * assert.deepStrictEqual(combined, expectedCombined);\n * ```\n */\nexport const concat = <\n  const Ar1 extends readonly unknown[],\n  const Ar2 extends readonly unknown[],\n>(\n  array1: Ar1,\n  array2: Ar2,\n): readonly [...Ar1, ...Ar2] => [...array1, ...array2] as const;\n\n/**\n * Groups elements by a key derived from each element.\n *\n * @example\n *\n * ```ts\n * const animals = ['ant', 'bat', 'cat', 'dove'] as const;\n *\n * const groupedByLength = Arr.groupBy(animals, (animal) => animal.length);\n *\n * const groupedByFirstLetter = Arr.groupBy((animal: string) => animal.at(0))(\n *   animals,\n * );\n *\n * assert.deepStrictEqual(\n *   groupedByLength.get(3),\n *   Optional.some(['ant', 'bat', 'cat'] as const),\n * );\n *\n * assert.deepStrictEqual(\n *   groupedByLength.get(4),\n *   Optional.some(['dove'] as const),\n * );\n *\n * assert.deepStrictEqual(groupedByLength.get(5), Optional.none);\n *\n * assert.deepStrictEqual(\n *   groupedByFirstLetter.get('a'),\n *   Optional.some(['ant'] as const),\n * );\n *\n * assert.deepStrictEqual(\n *   groupedByFirstLetter.get('d'),\n *   Optional.some(['dove'] as const),\n * );\n * ```\n */\nexport function groupBy<\n  const Ar extends readonly unknown[],\n  G extends MapSetKeyType,\n>(\n  array: Ar,\n  grouper: (value: Ar[number], index: ArrayIndex<Ar>) => G,\n): IMap<G, readonly Ar[number][]>;\n\nexport function groupBy<E, G extends MapSetKeyType>(\n  grouper: (value: E, index: SizeType.Arr) => G,\n): (array: readonly E[]) => IMap<G, readonly E[]>;\n\nexport function groupBy<E, G extends MapSetKeyType>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        grouper: (value: E, index: SizeType.Arr) => G,\n      ]\n    | readonly [grouper: (value: E, index: SizeType.Arr) => G]\n): IMap<G, readonly E[]> | ((array: readonly E[]) => IMap<G, readonly E[]>) {\n  switch (args.length) {\n    case 2: {\n      const [array, grouper] = args;\n\n      const mut_groups = new Map<G, E[]>(); // Store mutable arrays internally\n\n      for (const [index, e] of array.entries()) {\n        const key = grouper(e, asUint32(index)); // Ensure index is treated as SizeType.Arr\n\n        const mut_group = mut_groups.get(key);\n\n        if (mut_group !== undefined) {\n          mut_group.push(e);\n        } else {\n          mut_groups.set(key, [e]);\n        }\n      }\n\n      // Cast to IMap<G, readonly A[]> for the public interface\n      return IMap.create<G, readonly E[]>(mut_groups);\n    }\n\n    case 1: {\n      const [grouper] = args;\n\n      return (array: readonly E[]) => groupBy(array, grouper);\n    }\n  }\n}\n\n/**\n * Creates an array of tuples by pairing corresponding elements from two arrays.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c'] as const;\n *\n * const numbers = [1, 2, 3] as const;\n *\n * const pairs = Arr.zip(letters, numbers);\n *\n * const expectedPairs = [\n *   ['a', 1],\n *   ['b', 2],\n *   ['c', 3],\n * ] as const;\n *\n * assert.deepStrictEqual(pairs, expectedPairs);\n * ```\n */\nexport const zip = <\n  const Ar1 extends readonly unknown[],\n  const Ar2 extends readonly unknown[],\n>(\n  array1: Ar1,\n  array2: Ar2,\n): List.Zip<Ar1, Ar2> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  seq(Uint32.min(size(array1), size(array2))).map((i: Uint32) =>\n    // Non-null assertion is safe here because `i` is always within bounds of both arrays up to the length of the shorter one.\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    tp(array1[i]!, array2[i]!),\n  ) as unknown as List.Zip<Ar1, Ar2>;\n\n/**\n * Alias for `partition`.\n *\n * @see {@link partition}\n */\nexport const chunk = partition;\n\n/**\n * Computes the cartesian product of arrays.\n * cartesianProduct([[1,2], [3,4]]) => [[1,3], [1,4], [2,3], [2,4]]\n *\n * @example\n *\n *\n * ```ts\n * const sizes = ['S', 'M'] as const;\n *\n * const colors = ['red', 'blue'] as const;\n *\n * const combinations = Arr.cartesianProduct([sizes, colors]);\n *\n * const expectedCombinations = [\n *   ['S', 'red'],\n *   ['S', 'blue'],\n *   ['M', 'red'],\n *   ['M', 'blue'],\n * ] as const;\n *\n * assert.deepStrictEqual(combinations, expectedCombinations);\n * ```\n */\nexport const cartesianProduct = <T,>(\n  arrays: readonly (readonly T[])[],\n): readonly (readonly T[])[] => {\n  if (!isNonEmpty(arrays)) return [[]];\n\n  const [first, ...rest] = arrays;\n\n  // If first array is empty, the result is empty\n  if (!isNonEmpty(first)) return [];\n\n  const restProduct = cartesianProduct(rest);\n\n  return first.flatMap((item) => restProduct.map((prod) => [item, ...prod]));\n};\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"array-utils-transformation.mjs","sources":["../../../src/array/impl/array-utils-transformation.mts"],"sourcesContent":["import {\n  type FixedLengthTuple,\n  type IsFixedLengthList,\n  type List,\n  type NonEmptyArray,\n  type NonEmptyTuple,\n  type PositiveInt,\n  type PositiveUint32,\n  type Primitive,\n  type SafeUintWithSmallInt,\n  type WithSmallInt,\n} from 'ts-type-forge';\nimport { IMap } from '../../collections/index.mjs';\nimport { expectType } from '../../expect-type.mjs';\nimport { asPositiveUint32, asUint32, Uint32 } from '../../number/index.mjs';\nimport { castMutable, tp } from '../../others/index.mjs';\nimport {\n  type ArrayIndex,\n  type MapSetKeyType,\n  type SizeType,\n} from '../../types.mjs';\nimport { newArray, seq } from './array-utils-creation.mjs';\nimport { size } from './array-utils-size.mjs';\nimport { isNonEmpty } from './array-utils-validation.mjs';\n\n/**\n * Creates a new array by transforming each element with a mapping function.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3] as const;\n *\n * const doubled = Arr.map(numbers, (value) => value * 2);\n *\n * const indexed = Arr.map<number, string>(\n *   (value, index) => `${index}:${value}`,\n * )(numbers);\n *\n * assert.deepStrictEqual(doubled, [2, 4, 6]);\n *\n * assert.deepStrictEqual(indexed, ['0:1', '1:2', '2:3']);\n * ```\n */\nexport function map<const Ar extends readonly unknown[], B>(\n  array: Ar,\n  mapFn: (a: Ar[number], index: ArrayIndex<Ar>) => B,\n): Readonly<{ [K in keyof Ar]: B }>;\n\n// curried version\nexport function map<A, B>(\n  mapFn: (a: A, index: SizeType.Arr) => B,\n): <const Ar extends readonly A[]>(\n  array: Ar,\n) => Readonly<{ [K in keyof Ar]: B }>;\n\nexport function map<A, B>(\n  ...args:\n    | readonly [array: readonly A[], mapFn: (a: A, index: SizeType.Arr) => B]\n    | readonly [mapFn: (a: A, index: SizeType.Arr) => B]\n): readonly B[] | ((array: readonly A[]) => readonly B[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, mapFn] = args;\n\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      return array.map(mapFn as never);\n    }\n\n    case 1: {\n      const [mapFn] = args;\n\n      return (array: readonly A[]) => map(array, mapFn);\n    }\n  }\n}\n\n/**\n * Returns an array of successively reduced values from an array.\n *\n * @example\n *\n * ```ts\n * const changes = [5, -2, 3] as const;\n *\n * const runningTotals = Arr.scan(\n *   changes,\n *   (total, change) => total + change,\n *   0,\n * );\n *\n * const runningTotalsFromCurried = Arr.scan(\n *   (total: number, change: number) => total + change,\n *   10,\n * )([-5, 15]);\n *\n * const expectedTotals = [0, 5, 3, 6] as const;\n *\n * const expectedCurriedTotals = [10, 5, 20] as const;\n *\n * assert.deepStrictEqual<readonly number[]>(runningTotals, expectedTotals);\n *\n * assert.deepStrictEqual<readonly number[]>(\n *   runningTotalsFromCurried,\n *   expectedCurriedTotals,\n * );\n * ```\n */\nexport function scan<const Ar extends readonly unknown[], S>(\n  array: Ar,\n  reducer: (\n    accumulator: S,\n    currentValue: Ar[number],\n    currentIndex: ArrayIndex<Ar>,\n  ) => S,\n  init: S,\n): NonEmptyArray<S>;\n\nexport function scan<E, S>(\n  reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S,\n  init: S,\n): (array: readonly E[]) => NonEmptyArray<S>;\n\nexport function scan<E, S>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        reducer: (\n          accumulator: S,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => S,\n        init: S,\n      ]\n    | readonly [\n        reducer: (\n          accumulator: S,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => S,\n        init: S,\n      ]\n): NonEmptyTuple<S> | ((array: readonly E[]) => NonEmptyTuple<S>) {\n  switch (args.length) {\n    case 3: {\n      const [array, reducer, init] = args;\n\n      const mut_result = castMutable<NonEmptyTuple<S>>(\n        newArray<PositiveUint32, S>(asPositiveUint32(array.length + 1), init),\n      );\n\n      let mut_acc = init;\n\n      for (const [index, value] of array.entries()) {\n        mut_acc = reducer(mut_acc, value, asUint32(index));\n\n        mut_result[index + 1] = mut_acc;\n      }\n\n      return mut_result;\n    }\n\n    case 2: {\n      const [reducer, init] = args;\n\n      return (array) => scan(array, reducer, init);\n    }\n  }\n}\n\n/**\n * Reverses an array.\n *\n * @example\n *\n * ```ts\n * const tuple = [1, 'two', true] as const;\n *\n * const reversed = Arr.toReversed(tuple);\n *\n * const expected = [true, 'two', 1] as const;\n *\n * assert.deepStrictEqual(reversed, expected);\n * ```\n */\nexport const toReversed = <const Ar extends readonly unknown[]>(\n  array: Ar,\n): List.Reverse<Ar> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  array.toReversed() as never;\n\n/**\n * Sorts an array.\n *\n * @example\n *\n * ```ts\n * const numbers = [3, 1, 2] as const;\n *\n * const words = ['banana', 'apple', 'cherry'] as const;\n *\n * const ascendingNumbers = Arr.toSorted(numbers);\n *\n * const alphabetical = Arr.toSorted(words, (left, right) =>\n *   left.localeCompare(right),\n * );\n *\n * const expectedNumbers = [1, 2, 3] as const;\n *\n * const expectedWords = ['apple', 'banana', 'cherry'] as const;\n *\n * assert.deepStrictEqual(ascendingNumbers, expectedNumbers);\n *\n * assert.deepStrictEqual(alphabetical, expectedWords);\n * ```\n */\nexport const toSorted = <const Ar extends readonly unknown[]>(\n  ...[array, comparator]: Ar extends readonly number[]\n    ? readonly [\n        array: Ar,\n        // If the array elements are mapped to numbers, comparator is optional.\n        comparator?: (x: Ar[number], y: Ar[number]) => number,\n      ]\n    : readonly [array: Ar, comparator: (x: Ar[number], y: Ar[number]) => number]\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], Ar[number]>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number]>\n    : readonly Ar[number][] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  array.toSorted(\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    (comparator as ((x: unknown, y: unknown) => number) | undefined) ??\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      ((x, y) => (x as number) - (y as number)),\n  ) as never;\n\n/**\n * Sorts an array by a mapped value.\n *\n * @example\n *\n * ```ts\n * const projects = [\n *   { name: 'compiler', issues: 7 },\n *   { name: 'docs', issues: 2 },\n *   { name: 'ui', issues: 5 },\n * ] as const;\n *\n * const byIssueCount = Arr.toSortedBy(projects, (project) => project.issues);\n *\n * const byIssueCountDescending = Arr.toSortedBy(\n *   projects,\n *   (project) => project.issues,\n *   (left, right) => right - left,\n * );\n *\n * const expectedByIssues = [\n *   { name: 'docs', issues: 2 },\n *   { name: 'ui', issues: 5 },\n *   { name: 'compiler', issues: 7 },\n * ] as const;\n *\n * const expectedByIssueCountDescending = [\n *   { name: 'compiler', issues: 7 },\n *   { name: 'ui', issues: 5 },\n *   { name: 'docs', issues: 2 },\n * ] as const;\n *\n * assert.deepStrictEqual(byIssueCount, expectedByIssues);\n *\n * assert.deepStrictEqual(\n *   byIssueCountDescending,\n *   expectedByIssueCountDescending,\n * );\n * ```\n */\nexport function toSortedBy<const Ar extends readonly unknown[]>(\n  array: Ar,\n  comparatorValueMapper: (value: Ar[number]) => number,\n  // If the array elements are mapped to numbers, comparator is optional.\n  comparator?: (x: number, y: number) => number,\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], Ar[number]>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number]>\n    : readonly Ar[number][];\n\nexport function toSortedBy<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  comparatorValueMapper: (value: Ar[number]) => V,\n  comparator: (x: V, y: V) => number,\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], Ar[number]>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number]>\n    : readonly Ar[number][];\n\nexport function toSortedBy<E, const V>(\n  array: readonly E[],\n  comparatorValueMapper: (value: E) => V,\n  comparator?: (x: V, y: V) => number,\n): readonly E[] {\n  return array.toSorted((x, y) =>\n    comparator === undefined\n      ? // This branch assumes V is number if comparator is undefined.\n        // The overloads should handle this, but explicit cast might be needed if V is not number.\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        (comparatorValueMapper(x) as number) -\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        (comparatorValueMapper(y) as number)\n      : comparator(comparatorValueMapper(x), comparatorValueMapper(y)),\n  );\n}\n\n/**\n * Filters an array based on a predicate function.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3, 4] as const;\n *\n * const evens = Arr.filter(numbers, (value) => value % 2 === 0);\n *\n * const greaterThanTwo = Arr.filter<number>((value) => value > 2)(numbers);\n *\n * assert.deepStrictEqual(evens, [2, 4]);\n *\n * assert.deepStrictEqual(greaterThanTwo, [3, 4]);\n * ```\n */\n// Type guard overloads\nexport function filter<\n  const Ar extends readonly unknown[],\n  S extends Ar[number],\n>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => a is S,\n): readonly S[];\n\nexport function filter<E, S extends E>(\n  predicate: (a: E, index: SizeType.Arr) => a is S,\n): (array: readonly E[]) => readonly S[];\n\n// Regular boolean predicate overloads\nexport function filter<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): readonly Ar[number][];\n\nexport function filter<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => readonly E[];\n\nexport function filter<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (a: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return array.filter((a, i) => predicate(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => filter(array, predicate);\n    }\n  }\n}\n\n/**\n * Filters an array by excluding elements for which the predicate returns true.\n *\n * @example\n *\n * ```ts\n * const names = ['Ada', 'Grace', 'Linus'] as const;\n *\n * const notAda = Arr.filterNot(names, (name) => name === 'Ada');\n *\n * const notShort = Arr.filterNot<string>((name) => name.length <= 4)(names);\n *\n * assert.deepStrictEqual(notAda, ['Grace', 'Linus']);\n *\n * assert.deepStrictEqual(notShort, ['Grace', 'Linus']);\n * ```\n */\nexport function filterNot<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): readonly Ar[number][];\n\nexport function filterNot<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => readonly E[];\n\nexport function filterNot<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (a: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return array.filter((a, i) => !predicate(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => filterNot(array, predicate);\n    }\n  }\n}\n\n/**\n * Creates a new array with unique elements.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'a', 'c', 'b'] as const;\n *\n * const uniqueLetters = Arr.uniq(letters);\n *\n * const expected = ['a', 'b', 'c'] as const;\n *\n * assert.deepStrictEqual<readonly string[]>(uniqueLetters, expected);\n * ```\n */\nexport const uniq = <const Ar extends readonly Primitive[]>(\n  array: Ar,\n): Ar extends NonEmptyTuple<unknown>\n  ? NonEmptyArray<Ar[number]>\n  : readonly Ar[number][] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  Array.from(new Set(array)) as never;\n\n/**\n * Creates a new array with unique elements based on a mapped value.\n *\n * @example\n *\n * ```ts\n * const people = [\n *   { id: 1, name: 'Ada' },\n *   { id: 2, name: 'Brian' },\n *   { id: 1, name: 'Alan' },\n *   { id: 3, name: 'Grace' },\n * ] as const;\n *\n * const uniqueById = Arr.uniqBy(people, (person) => person.id);\n *\n * const expected = [\n *   { id: 1, name: 'Ada' },\n *   { id: 2, name: 'Brian' },\n *   { id: 3, name: 'Grace' },\n * ] as const;\n *\n * assert.deepStrictEqual<readonly Readonly<{ id: number; name: string }>[]>(\n *   uniqueById,\n *   expected,\n * );\n * ```\n */\nexport const uniqBy = <\n  const Ar extends readonly unknown[],\n  P extends Primitive,\n>(\n  array: Ar,\n  mapFn: (value: Ar[number]) => P,\n): Ar extends NonEmptyTuple<unknown>\n  ? NonEmptyArray<Ar[number]>\n  : readonly Ar[number][] => {\n  const mut_mappedValues = new Set<P>();\n\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  return array.filter((val) => {\n    const mappedValue = mapFn(val);\n\n    if (mut_mappedValues.has(mappedValue)) return false;\n\n    mut_mappedValues.add(mappedValue);\n\n    return true;\n  }) satisfies readonly Ar[number][] as never;\n};\n\n/**\n * Flattens nested arrays up to the specified depth.\n *\n * @example\n *\n * ```ts\n * const nested = [\n *   [1, 2],\n *   [3, 4],\n * ] as const;\n *\n * const flatOnce = Arr.flat(nested, 1);\n *\n * const flatCurried = Arr.flat()(nested);\n *\n * assert.deepStrictEqual(flatOnce, [1, 2, 3, 4]);\n *\n * assert.deepStrictEqual(flatCurried, [1, 2, 3, 4]);\n * ```\n */\nexport function flat<\n  const Ar extends readonly unknown[],\n  D extends SafeUintWithSmallInt = 1,\n>(array: Ar, depth?: D): readonly FlatArray<Ar, D>[];\n\nexport function flat<D extends SafeUintWithSmallInt = 1>(\n  depth?: number,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => readonly FlatArray<Ar, D>[];\n\nexport function flat<E, D extends SafeUintWithSmallInt = 1>(\n  ...args: readonly [array: readonly E[], depth?: D] | readonly [depth?: D]\n): readonly unknown[] | ((array: readonly unknown[]) => readonly unknown[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, depth] = args;\n\n      return array.flat(depth);\n    }\n\n    case 1: {\n      const [arrayOrDepth] = args;\n\n      if (typeof arrayOrDepth === 'number') {\n        const depth = arrayOrDepth as SafeUintWithSmallInt | undefined;\n\n        return (array) => flat(array, depth);\n      }\n\n      if (arrayOrDepth === undefined) {\n        return (array) => flat(array, 1);\n      }\n\n      expectType<typeof arrayOrDepth, readonly E[]>('=');\n\n      return arrayOrDepth.flat();\n    }\n\n    case 0:\n      return (array) => flat(array, 1);\n  }\n}\n\n/**\n * Maps each element and flattens the result.\n *\n * @example\n *\n * ```ts\n * const words = ['Ada', 'AI'] as const;\n *\n * const characters = Arr.flatMap(words, (word) => word.split(''));\n *\n * const labeled = Arr.flatMap<string, string>((word, index) =>\n *   word.split('').map((char) => `${index}-${char}`),\n * )(words);\n *\n * assert.deepStrictEqual(characters, ['A', 'd', 'a', 'A', 'I']);\n *\n * assert.deepStrictEqual(labeled, ['0-A', '0-d', '0-a', '1-A', '1-I']);\n * ```\n */\nexport function flatMap<const Ar extends readonly unknown[], B>(\n  array: Ar,\n  mapFn: (a: Ar[number], index: ArrayIndex<Ar>) => readonly B[],\n): readonly B[];\n\nexport function flatMap<A, B>(\n  mapFn: (a: A, index: SizeType.Arr) => readonly B[],\n): (array: readonly A[]) => readonly B[];\n\nexport function flatMap<A, B>(\n  ...args:\n    | readonly [\n        array: readonly A[],\n        mapFn: (a: A, index: SizeType.Arr) => readonly B[],\n      ]\n    | readonly [mapFn: (a: A, index: SizeType.Arr) => readonly B[]]\n): readonly B[] | ((array: readonly A[]) => readonly B[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, mapFn] = args;\n\n      return array.flatMap((a, i) => mapFn(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [mapFn] = args;\n\n      return (array: readonly A[]) => flatMap(array, mapFn);\n    }\n  }\n}\n\n/**\n * Partitions an array into sub-arrays of a specified size.\n *\n * @example\n *\n * ```ts\n * const values = [1, 2, 3, 4, 5] as const;\n *\n * const pairs = Arr.partition(values, 2);\n *\n * const triples = Arr.partition(3)(values);\n *\n * const expectedPairs = [[1, 2], [3, 4], [5]] as const;\n *\n * assert.deepStrictEqual(pairs, expectedPairs);\n *\n * assert.deepStrictEqual(triples, [\n *   [1, 2, 3],\n *   [4, 5],\n * ]);\n *\n * const pairs2 = Arr.chunk([1, 2, 3, 4, 5, 6], 2);\n *\n * assert.deepStrictEqual(pairs2, [\n *   [1, 2],\n *   [3, 4],\n *   [5, 6],\n * ]);\n * ```\n */\nexport function partition<\n  N extends WithSmallInt<PositiveInt & SizeType.Arr>,\n  E,\n>(array: readonly E[], chunkSize: N): readonly (readonly E[])[];\n\nexport function partition<N extends WithSmallInt<PositiveInt & SizeType.Arr>>(\n  chunkSize: N,\n): <E>(array: readonly E[]) => readonly (readonly E[])[];\n\nexport function partition<\n  N extends WithSmallInt<PositiveInt & SizeType.Arr>,\n  E,\n>(\n  ...args:\n    readonly [array: readonly E[], chunkSize: N] | readonly [chunkSize: N]\n):\n  | readonly (readonly E[])[]\n  | ((array: readonly E[]) => readonly (readonly E[])[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, chunkSize] = args;\n\n      return chunkSize < 2\n        ? []\n        : // eslint-disable-next-line total-functions/no-partial-division\n          seq(asUint32(Math.ceil(array.length / chunkSize))).map((i: Uint32) =>\n            array.slice(chunkSize * i, chunkSize * (i + 1)),\n          );\n    }\n\n    case 1: {\n      const [chunkSize] = args;\n\n      return (array) => partition(array, chunkSize);\n    }\n  }\n}\n\n/**\n * Concatenates two arrays.\n *\n * The exact tuple shape is preserved. Additionally, when either input is known\n * to be non-empty (a non-empty tuple or a branded `NonEmptyArray`), the result\n * is branded as non-empty so it is assignable to `NonEmptyArray`.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2] as const;\n *\n * const words = ['three', 'four'] as const;\n *\n * const combined = Arr.concat(numbers, words);\n *\n * // Because at least one input is non-empty, the result is assignable to\n * // NonEmptyArray.\n * const nonEmpty: NonEmptyArray<number | string> = combined;\n *\n * const expectedCombined = [1, 2, 'three', 'four'] as const;\n *\n * assert.deepStrictEqual<readonly (number | string)[]>(\n *   combined,\n *   expectedCombined,\n * );\n *\n * assert.isTrue(nonEmpty.length >= 1);\n * ```\n */\nexport const concat = <\n  const Ar1 extends readonly unknown[],\n  const Ar2 extends readonly unknown[],\n>(\n  array1: Ar1,\n  array2: Ar2,\n): ConcatResult<Ar1, Ar2> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  [...array1, ...array2] as never;\n\n/**\n * Return type of {@link concat}: the concatenated tuple `readonly [...Ar1,\n * ...Ar2]`, additionally branded as {@link NonEmptyArray} when either input is\n * a non-empty tuple (a plain non-empty tuple or a branded `NonEmptyArray`,\n * both of which extend `NonEmptyTuple<unknown>`).\n */\ntype ConcatResult<\n  Ar1 extends readonly unknown[],\n  Ar2 extends readonly unknown[],\n> =\n  Ar1 extends NonEmptyTuple<unknown>\n    ? readonly [...Ar1, ...Ar2] & NonEmptyArray<Ar1[number] | Ar2[number]>\n    : Ar2 extends NonEmptyTuple<unknown>\n      ? readonly [...Ar1, ...Ar2] & NonEmptyArray<Ar1[number] | Ar2[number]>\n      : readonly [...Ar1, ...Ar2];\n\n/**\n * Groups elements by a key derived from each element.\n *\n * @example\n *\n * ```ts\n * const animals = ['ant', 'bat', 'cat', 'dove'] as const;\n *\n * const groupedByLength = Arr.groupBy(animals, (animal) => animal.length);\n *\n * const groupedByFirstLetter = Arr.groupBy((animal: string) => animal.at(0))(\n *   animals,\n * );\n *\n * assert.deepStrictEqual(\n *   groupedByLength.get(3),\n *   Optional.some(['ant', 'bat', 'cat'] as const),\n * );\n *\n * assert.deepStrictEqual(\n *   groupedByLength.get(4),\n *   Optional.some(['dove'] as const),\n * );\n *\n * assert.deepStrictEqual(groupedByLength.get(5), Optional.none);\n *\n * assert.deepStrictEqual(\n *   groupedByFirstLetter.get('a'),\n *   Optional.some(['ant'] as const),\n * );\n *\n * assert.deepStrictEqual(\n *   groupedByFirstLetter.get('d'),\n *   Optional.some(['dove'] as const),\n * );\n * ```\n */\nexport function groupBy<\n  const Ar extends readonly unknown[],\n  G extends MapSetKeyType,\n>(\n  array: Ar,\n  grouper: (value: Ar[number], index: ArrayIndex<Ar>) => G,\n): IMap<G, readonly Ar[number][]>;\n\nexport function groupBy<E, G extends MapSetKeyType>(\n  grouper: (value: E, index: SizeType.Arr) => G,\n): (array: readonly E[]) => IMap<G, readonly E[]>;\n\nexport function groupBy<E, G extends MapSetKeyType>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        grouper: (value: E, index: SizeType.Arr) => G,\n      ]\n    | readonly [grouper: (value: E, index: SizeType.Arr) => G]\n): IMap<G, readonly E[]> | ((array: readonly E[]) => IMap<G, readonly E[]>) {\n  switch (args.length) {\n    case 2: {\n      const [array, grouper] = args;\n\n      const mut_groups = new Map<G, E[]>(); // Store mutable arrays internally\n\n      for (const [index, e] of array.entries()) {\n        const key = grouper(e, asUint32(index)); // Ensure index is treated as SizeType.Arr\n\n        const mut_group = mut_groups.get(key);\n\n        if (mut_group !== undefined) {\n          mut_group.push(e);\n        } else {\n          mut_groups.set(key, [e]);\n        }\n      }\n\n      // Cast to IMap<G, readonly A[]> for the public interface\n      return IMap.create<G, readonly E[]>(mut_groups);\n    }\n\n    case 1: {\n      const [grouper] = args;\n\n      return (array: readonly E[]) => groupBy(array, grouper);\n    }\n  }\n}\n\n/**\n * Creates an array of tuples by pairing corresponding elements from two arrays.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c'] as const;\n *\n * const numbers = [1, 2, 3] as const;\n *\n * const pairs = Arr.zip(letters, numbers);\n *\n * const expectedPairs = [\n *   ['a', 1],\n *   ['b', 2],\n *   ['c', 3],\n * ] as const;\n *\n * assert.deepStrictEqual(pairs, expectedPairs);\n * ```\n */\nexport const zip = <\n  const Ar1 extends readonly unknown[],\n  const Ar2 extends readonly unknown[],\n>(\n  array1: Ar1,\n  array2: Ar2,\n): List.Zip<Ar1, Ar2> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  seq(Uint32.min(size(array1), size(array2))).map((i: Uint32) =>\n    // Non-null assertion is safe here because `i` is always within bounds of both arrays up to the length of the shorter one.\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    tp(array1[i]!, array2[i]!),\n  ) as unknown as List.Zip<Ar1, Ar2>;\n\n/**\n * Alias for `partition`.\n *\n * @see {@link partition}\n */\nexport const chunk = partition;\n\n/**\n * Computes the cartesian product of arrays.\n * cartesianProduct([[1,2], [3,4]]) => [[1,3], [1,4], [2,3], [2,4]]\n *\n * @example\n *\n *\n * ```ts\n * const sizes = ['S', 'M'] as const;\n *\n * const colors = ['red', 'blue'] as const;\n *\n * const combinations = Arr.cartesianProduct([sizes, colors]);\n *\n * const expectedCombinations = [\n *   ['S', 'red'],\n *   ['S', 'blue'],\n *   ['M', 'red'],\n *   ['M', 'blue'],\n * ] as const;\n *\n * assert.deepStrictEqual(combinations, expectedCombinations);\n * ```\n */\nexport const cartesianProduct = <T,>(\n  arrays: readonly (readonly T[])[],\n): readonly (readonly T[])[] => {\n  if (!isNonEmpty(arrays)) return [[]];\n\n  const [first, ...rest] = arrays;\n\n  // If first array is empty, the result is empty\n  if (!isNonEmpty(first)) return [];\n\n  const restProduct = cartesianProduct(rest);\n\n  return first.flatMap((item) => restProduct.map((prod) => [item, ...prod]));\n};\n"],"names":[],"mappings":"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"}

package/dist/array/impl/index.mjs

@@ -1,7 +1,7 @@
 export { copy, create, generate, generateAsync, newArray, range, seq, zeros } from './array-utils-creation.mjs';
 export { at, first, head, last } from './array-utils-element-access.mjs';
 export { entries, indices, keys, values } from './array-utils-iterators.mjs';
-export { asBoundedLengthArray, asFixedLengthArray, asMaxLengthArray, asMinLengthArray } from './array-utils-length-bounded-array-cast.mjs';
+export { asBoundedLengthArray, asFixedLengthArray, asMaxLengthArray, asMinLengthArray, asNonEmptyArray } from './array-utils-length-bounded-array-cast.mjs';
 export { isBoundedLengthArray, isFixedLengthArray, isMaxLengthArray, isMinLengthArray } from './array-utils-length-bounded-array-guard.mjs';
 export { set, toFilled, toInserted, toPushed, toRangeFilled, toRemoved, toUnshifted, toUpdated } from './array-utils-modification.mjs';
 export { count, countBy, foldl, foldr, join, max, maxBy, min, minBy, reduce, reduceRight, sum, sumBy } from './array-utils-reducing-value.mjs';

package/dist/string/str.d.mts

@@ -1,4 +1,4 @@
-import { type BoundedLengthString, type FixedLengthString, type MaxLengthString, type MinLengthString, type SupportedLength } from 'ts-type-forge';
+import { type BoundedLengthString, type FixedLengthString, type MaxLengthString, type MinLengthString, type NonEmptyString, type SupportedLength } from 'ts-type-forge';
 /**
  * Namespace providing type guards and runtime-checked casts for the branded
  * length-constrained string types (`MinLengthString`, `MaxLengthString`,
@@ -162,6 +162,9 @@ export declare namespace Str {
      * length is verified at runtime, and the original string type (e.g. literal
      * types) is preserved via intersection.
      *
+     * Supports a curried overload: calling it with only `minLength` returns a
+     * function that casts a string, which is convenient for `pipe`/`map`.
+     *
      * @example
      *
      * ```ts
@@ -171,6 +174,11 @@ export declare namespace Str {
      *
      * assert.isTrue(nonEmpty.length >= 12);
      *
+     * // curried version
+     * const asPassword = Str.asMinLengthString(12);
+     *
+     * assert.strictEqual(asPassword('another-secret'), 'another-secret');
+     *
      * assert.throws(() => Str.asMinLengthString('short', 12)); // length 5 < 12
      * ```
      *
@@ -181,7 +189,8 @@ export declare namespace Str {
      * @returns `s` typed as `MinLengthString<MinLength> & S`.
      * @throws {TypeError} If `s.length < minLength`.
      */
-    const asMinLengthString: <S extends string, MinLength extends SupportedLength>(s: S, minLength: MinLength) => MinLengthString<MinLength> & S;
+    function asMinLengthString<S extends string, MinLength extends SupportedLength>(s: S, minLength: MinLength): MinLengthString<MinLength> & S;
+    function asMinLengthString<MinLength extends SupportedLength>(minLength: MinLength): <S extends string>(s: S) => MinLengthString<MinLength> & S;
     /**
      * Casts a string to `MaxLengthString<MaxLength>` after checking that it has
      * at most `maxLength` characters.
@@ -190,6 +199,9 @@ export declare namespace Str {
      * length is verified at runtime, and the original string type (e.g. literal
      * types) is preserved via intersection.
      *
+     * Supports a curried overload: calling it with only `maxLength` returns a
+     * function that casts a string, which is convenient for `pipe`/`map`.
+     *
      * @example
      *
      * ```ts
@@ -199,6 +211,11 @@ export declare namespace Str {
      *
      * assert.isTrue(relaxed.length <= 32);
      *
+     * // curried version
+     * const asUserName = Str.asMaxLengthString(32);
+     *
+     * assert.strictEqual(asUserName('another-user'), 'another-user');
+     *
      * assert.throws(() => Str.asMaxLengthString('noshiro', 3)); // length 7 > 3
      * ```
      *
@@ -209,7 +226,8 @@ export declare namespace Str {
      * @returns `s` typed as `MaxLengthString<MaxLength> & S`.
      * @throws {TypeError} If `s.length > maxLength`.
      */
-    const asMaxLengthString: <S extends string, MaxLength extends SupportedLength>(s: S, maxLength: MaxLength) => MaxLengthString<MaxLength> & S;
+    function asMaxLengthString<S extends string, MaxLength extends SupportedLength>(s: S, maxLength: MaxLength): MaxLengthString<MaxLength> & S;
+    function asMaxLengthString<MaxLength extends SupportedLength>(maxLength: MaxLength): <S extends string>(s: S) => MaxLengthString<MaxLength> & S;
     /**
      * Casts a string to `BoundedLengthString<MinLength, MaxLength>` after
      * checking that its length is within the inclusive range
@@ -219,6 +237,10 @@ export declare namespace Str {
      * the length is verified at runtime, and the original string type (e.g.
      * literal types) is preserved via intersection.
      *
+     * Supports a curried overload: calling it with only `minLength` and
+     * `maxLength` returns a function that casts a string, which is convenient for
+     * `pipe`/`map`.
+     *
      * @example
      *
      * ```ts
@@ -228,6 +250,11 @@ export declare namespace Str {
      *
      * assert.isTrue(relaxed.length >= 8 && relaxed.length <= 16);
      *
+     * // curried version
+     * const asUserId = Str.asBoundedLengthString(8, 16);
+     *
+     * assert.strictEqual(asUserId('user-87654321'), 'user-87654321');
+     *
      * assert.throws(() => Str.asBoundedLengthString('user', 8, 16)); // length 4 < 8
      * ```
      *
@@ -240,7 +267,8 @@ export declare namespace Str {
      * @returns `s` typed as `BoundedLengthString<MinLength, MaxLength> & S`.
      * @throws {TypeError} If `s.length < minLength` or `s.length > maxLength`.
      */
-    const asBoundedLengthString: <S extends string, MinLength extends SupportedLength, MaxLength extends SupportedLength>(s: S, minLength: MinLength, maxLength: MaxLength) => BoundedLengthString<MinLength, MaxLength> & S;
+    function asBoundedLengthString<S extends string, MinLength extends SupportedLength, MaxLength extends SupportedLength>(s: S, minLength: MinLength, maxLength: MaxLength): BoundedLengthString<MinLength, MaxLength> & S;
+    function asBoundedLengthString<MinLength extends SupportedLength, MaxLength extends SupportedLength>(minLength: MinLength, maxLength: MaxLength): <S extends string>(s: S) => BoundedLengthString<MinLength, MaxLength> & S;
     /**
      * Casts a string to `FixedLengthString<Length>` after checking that it has
      * exactly `length` characters.
@@ -249,6 +277,9 @@ export declare namespace Str {
      * length is verified at runtime, and the original string type (e.g. literal
      * types) is preserved via intersection.
      *
+     * Supports a curried overload: calling it with only `length` returns a
+     * function that casts a string, which is convenient for `pipe`/`map`.
+     *
      * @example
      *
      * ```ts
@@ -258,6 +289,11 @@ export declare namespace Str {
      *
      * assert.isTrue(atMost5.length === 2);
      *
+     * // curried version
+     * const asCountryCode = Str.asFixedLengthString(2);
+     *
+     * assert.strictEqual(asCountryCode('US'), 'US');
+     *
      * assert.throws(() => Str.asFixedLengthString('JP', 3)); // length 2 !== 3
      * ```
      *
@@ -268,6 +304,35 @@ export declare namespace Str {
      * @returns `s` typed as `FixedLengthString<Length> & S`.
      * @throws {TypeError} If `s.length !== length`.
      */
-    const asFixedLengthString: <S extends string, Length extends SupportedLength>(s: S, length: Length) => FixedLengthString<Length> & S;
+    function asFixedLengthString<S extends string, Length extends SupportedLength>(s: S, length: Length): FixedLengthString<Length> & S;
+    function asFixedLengthString<Length extends SupportedLength>(length: Length): <S extends string>(s: S) => FixedLengthString<Length> & S;
+    /**
+     * Casts a string to `NonEmptyString` after checking that it has at least one
+     * character.
+     *
+     * `NonEmptyString` is an alias of `MinLengthString<1>`, so this is the
+     * length-1 specialization of {@link asMinLengthString}. Use this instead of
+     * writing `s as unknown as NonEmptyString`: the length is verified at
+     * runtime, and the original string type (e.g. literal types) is preserved
+     * via intersection.
+     *
+     * @example
+     *
+     * ```ts
+     * const name = Str.asNonEmptyString('noshiro');
+     *
+     * const nonEmpty: NonEmptyString = name; // OK
+     *
+     * assert.isTrue(nonEmpty.length >= 1);
+     *
+     * assert.throws(() => Str.asNonEmptyString('')); // length 0 < 1
+     * ```
+     *
+     * @template S - The input string type (literal types are preserved).
+     * @param s - The string to cast.
+     * @returns `s` typed as `NonEmptyString & S`.
+     * @throws {TypeError} If `s` is empty.
+     */
+    const asNonEmptyString: <S extends string>(s: S) => NonEmptyString & S;
 }
 //# sourceMappingURL=str.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"str.d.mts","sourceRoot":"","sources":["../../src/string/str.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAEvB;;;;;;;;GAQG;AACH,yBAAiB,GAAG,CAAC;IACnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACI,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,KACnB,CAAC,IAAI,eAAe,CAAC,SAAS,CAAC,GAAG,CAA0B,CAAC;IAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACI,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,KACnB,CAAC,IAAI,eAAe,CAAC,SAAS,CAAC,GAAG,CAA0B,CAAC;IAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACI,MAAM,qBAAqB,GAChC,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,EACjC,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,aACT,SAAS,KACnB,CAAC,IAAI,mBAAmB,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,CACJ,CAAC;IAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACI,MAAM,mBAAmB,GAC9B,CAAC,SAAS,MAAM,EAChB,MAAM,SAAS,eAAe,KAE3B,CAAC,UACI,MAAM,KACb,CAAC,IAAI,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAAwB,CAAC;IAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACI,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,KACnB,eAAe,CAAC,SAAS,CAAC,GAAG,CAQ/B,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACI,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,KACnB,eAAe,CAAC,SAAS,CAAC,GAAG,CAQ/B,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACI,MAAM,qBAAqB,GAChC,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,EACjC,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,aACT,SAAS,KACnB,mBAAmB,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,CAQ9C,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACI,MAAM,mBAAmB,GAC9B,CAAC,SAAS,MAAM,EAChB,MAAM,SAAS,eAAe,KAE3B,CAAC,UACI,MAAM,KACb,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAQ9B,CAAC;CACH"}
+{"version":3,"file":"str.d.mts","sourceRoot":"","sources":["../../src/string/str.mts"],"names":[],"mappings":"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"}

package/dist/string/str.mjs

@@ -4,35 +4,81 @@ var Str;
   Str2.isMaxLengthString = (s, maxLength) => s.length <= maxLength;
   Str2.isBoundedLengthString = (s, minLength, maxLength) => s.length >= minLength && s.length <= maxLength;
   Str2.isFixedLengthString = (s, length) => s.length === length;
-  Str2.asMinLengthString = (s, minLength) => {
-    if (!(0, Str2.isMinLengthString)(s, minLength)) {
-      throw new TypeError(
-        `Expected a string of length >= ${minLength}, got a string of length ${s.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);
+      }
     }
-    return s;
-  };
-  Str2.asMaxLengthString = (s, maxLength) => {
-    if (!(0, Str2.isMaxLengthString)(s, maxLength)) {
-      throw new TypeError(
-        `Expected a string of length <= ${maxLength}, got a string of length ${s.length}`
-      );
+  }
+  Str2.asMinLengthString = asMinLengthString;
+  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);
+      }
     }
-    return s;
-  };
-  Str2.asBoundedLengthString = (s, minLength, maxLength) => {
-    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}`
-      );
+  }
+  Str2.asMaxLengthString = asMaxLengthString;
+  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);
+      }
     }
-    return s;
-  };
-  Str2.asFixedLengthString = (s, length) => {
-    if (!(0, Str2.isFixedLengthString)(s, length)) {
-      throw new TypeError(
-        `Expected a string of length ${length}, got a string of length ${s.length}`
-      );
+  }
+  Str2.asBoundedLengthString = asBoundedLengthString;
+  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);
+      }
+    }
+  }
+  Str2.asFixedLengthString = asFixedLengthString;
+  Str2.asNonEmptyString = (s) => {
+    if (!(0, Str2.isMinLengthString)(s, 1)) {
+      throw new TypeError("Expected a non-empty string, got an empty string");
     }
     return s;
   };

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 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   * @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   * 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 const asMinLengthString = <\n    S extends string,\n    MinLength extends SupportedLength,\n  >(\n    s: S,\n    minLength: MinLength,\n  ): MinLengthString<MinLength> & S => {\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  /**\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   * @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   * 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 const asMaxLengthString = <\n    S extends string,\n    MaxLength extends SupportedLength,\n  >(\n    s: S,\n    maxLength: MaxLength,\n  ): MaxLengthString<MaxLength> & S => {\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  /**\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   * @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   * 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 const 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    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  /**\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   * @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   * 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 const asFixedLengthString = <\n    S extends string,\n    Length extends SupportedLength,\n  >(\n    s: S,\n    length: Length,\n  ): FixedLengthString<Length> & S => {\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"],"names":["Str"],"mappings":"AAiBO,IAAU;AAAA,CAAV,CAAUA,IAAAA,KAAV;AAmCE,EAAMA,KAAA,iBAAA,GAAoB,CAI/B,CAAA,EACA,SAAA,KACwC,EAAE,MAAA,IAAU,SAAA;AAoC/C,EAAMA,KAAA,iBAAA,GAAoB,CAI/B,CAAA,EACA,SAAA,KACwC,EAAE,MAAA,IAAU,SAAA;AAwC/C,EAAMA,IAAAA,CAAA,qBAAA,GAAwB,CAKnC,CAAA,EACA,SAAA,EACA,cAEA,CAAA,CAAE,MAAA,IAAU,SAAA,IAAa,CAAA,CAAE,MAAA,IAAU,SAAA;AAqChC,EAAMA,KAAA,mBAAA,GAAsB,CAIjC,CAAA,EACA,MAAA,KACuC,EAAE,MAAA,KAAW,MAAA;AA6B/C,EAAMA,IAAAA,CAAA,iBAAA,GAAoB,CAI/B,CAAA,EACA,SAAA,KACmC;AACnC,IAAA,IAAI,CAAA,IAACA,IAAAA,CAAA,iBAAA,EAAkB,CAAA,EAAG,SAAS,CAAA,EAAG;AACpC,MAAA,MAAM,IAAI,SAAA;AAAA,QACR,CAAA,+BAAA,EAAkC,SAAS,CAAA,yBAAA,EAA4B,CAAA,CAAE,MAAM,CAAA;AAAA,OACjF;AAAA,IACF;AAEA,IAAA,OAAO,CAAA;AAAA,EACT,CAAA;AA6BO,EAAMA,IAAAA,CAAA,iBAAA,GAAoB,CAI/B,CAAA,EACA,SAAA,KACmC;AACnC,IAAA,IAAI,CAAA,IAACA,IAAAA,CAAA,iBAAA,EAAkB,CAAA,EAAG,SAAS,CAAA,EAAG;AACpC,MAAA,MAAM,IAAI,SAAA;AAAA,QACR,CAAA,+BAAA,EAAkC,SAAS,CAAA,yBAAA,EAA4B,CAAA,CAAE,MAAM,CAAA;AAAA,OACjF;AAAA,IACF;AAEA,IAAA,OAAO,CAAA;AAAA,EACT,CAAA;AAgCO,EAAMA,IAAAA,CAAA,qBAAA,GAAwB,CAKnC,CAAA,EACA,WACA,SAAA,KACkD;AAClD,IAAA,IAAI,KAACA,IAAAA,CAAA,qBAAA,EAAsB,CAAA,EAAG,SAAA,EAAW,SAAS,CAAA,EAAG;AACnD,MAAA,MAAM,IAAI,SAAA;AAAA,QACR,mCAAmC,SAAS,CAAA,EAAA,EAAK,SAAS,CAAA,0BAAA,EAA6B,EAAE,MAAM,CAAA;AAAA,OACjG;AAAA,IACF;AAEA,IAAA,OAAO,CAAA;AAAA,EACT,CAAA;AA6BO,EAAMA,IAAAA,CAAA,mBAAA,GAAsB,CAIjC,CAAA,EACA,MAAA,KACkC;AAClC,IAAA,IAAI,CAAA,IAACA,IAAAA,CAAA,mBAAA,EAAoB,CAAA,EAAG,MAAM,CAAA,EAAG;AACnC,MAAA,MAAM,IAAI,SAAA;AAAA,QACR,CAAA,4BAAA,EAA+B,MAAM,CAAA,yBAAA,EAA4B,CAAA,CAAE,MAAM,CAAA;AAAA,OAC3E;AAAA,IACF;AAEA,IAAA,OAAO,CAAA;AAAA,EACT,CAAA;AAAA,CAAA,EAhWe,GAAA,KAAA,GAAA,GAAA,EAAA,CAAA,CAAA;;;;"}
+{"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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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "12.0.0",
+  "version": "12.2.0",
   "private": false,
   "keywords": [
     "typescript",