ts-data-forge 12.2.1 → 12.2.2

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 * 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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"}
+{"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      return scanImpl(...args);\n\n    case 2:\n      return (array) => scanImpl(array, ...args);\n  }\n}\n\nconst scanImpl = <E, S>(\n  array: readonly E[],\n  reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S,\n  init: S,\n): NonEmptyTuple<S> => {\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/**\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      return filterImpl(...args);\n\n    case 1:\n      return (array) => filterImpl(array, ...args);\n  }\n}\n\nconst filterImpl = <E,>(\n  array: readonly E[],\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): readonly E[] => array.filter((a, i) => predicate(a, asUint32(i)));\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      return filterNotImpl(...args);\n\n    case 1:\n      return (array) => filterNotImpl(array, ...args);\n  }\n}\n\nconst filterNotImpl = <E,>(\n  array: readonly E[],\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): readonly E[] => array.filter((a, i) => !predicate(a, asUint32(i)));\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      return flatImpl(...args);\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) => flatImpl(array, depth);\n      }\n\n      if (arrayOrDepth === undefined) {\n        return (array) => flatImpl(array, 1);\n      }\n\n      expectType<typeof arrayOrDepth, readonly E[]>('=');\n\n      return arrayOrDepth.flat();\n    }\n\n    case 0:\n      return (array) => flatImpl(array, 1);\n  }\n}\n\nconst flatImpl = (\n  array: readonly unknown[],\n  depth?: SafeUintWithSmallInt,\n): readonly unknown[] => array.flat(depth);\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      return partitionImpl(...args);\n\n    case 1:\n      return (array) => partitionImpl(array, ...args);\n  }\n}\n\nconst partitionImpl = <N extends WithSmallInt<PositiveInt & SizeType.Arr>, E>(\n  array: readonly E[],\n  chunkSize: N,\n): readonly (readonly E[])[] =>\n  chunkSize < 2\n    ? ([] as const)\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 * 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/array-utils-validation.d.mts.map

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

package/dist/array/impl/array-utils-validation.mjs

@@ -44,28 +44,22 @@ const isMaxLengthTuple = (array, len) => array.length <= len;
 const isBoundedLengthTuple = (array, min, max) => array.length >= min && array.length <= max;
 function every(...args) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-      return array.every((a, i) => predicate(a, asUint32(i)));
-    }
-    case 1: {
-      const [predicate] = args;
-      return (array) => every(array, predicate);
-    }
+    case 2:
+      return everyImpl(...args);
+    case 1:
+      return (array) => everyImpl(array, ...args);
   }
 }
+const everyImpl = (array, predicate) => array.every((a, i) => predicate(a, asUint32(i)));
 function some(...args) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-      return array.some((a, i) => predicate(a, asUint32(i)));
-    }
-    case 1: {
-      const [predicate] = args;
-      return (array) => some(array, predicate);
-    }
+    case 2:
+      return someImpl(...args);
+    case 1:
+      return (array) => someImpl(array, ...args);
   }
 }
+const someImpl = (array, predicate) => array.some((a, i) => predicate(a, asUint32(i)));
 const indexIsInRange = (array, index) => Num.isInRange(0, array.length)(index);
 
 export { every, indexIsInRange, isArray, isBoundedLengthTuple, isEmpty, isFixedLengthTuple, isMaxLengthTuple, isMinLengthTuple, isNonEmpty, some };

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

@@ -1 +1 @@
-{"version":3,"file":"array-utils-validation.mjs","sources":["../../../src/array/impl/array-utils-validation.mts"],"sourcesContent":["import {\n  type BoolOr,\n  type BoundedLengthTuple,\n  type FixedLengthTuple,\n  type MaxLengthTuple,\n  type MinLengthTuple,\n  type NonEmptyArray,\n  type TypeEq,\n} from 'ts-type-forge';\nimport { asUint32, Num } from '../../number/index.mjs';\nimport { type ArrayIndex, type SizeType } from '../../types.mjs';\n\n/**\n * Type guard that checks if a value is an array.\n *\n * @example\n *\n * ```ts\n * const maybeArray: unknown = [1, 2, 3] as const;\n *\n * const maybeValue: unknown = 'Ada';\n *\n * assert.isTrue(Arr.isArray(maybeArray));\n *\n * assert.isFalse(Arr.isArray(maybeValue));\n *\n * if (Arr.isArray(maybeArray)) {\n *   assert.deepStrictEqual(maybeArray, [1, 2, 3]);\n * }\n * ```\n */\nexport const isArray = <E,>(value: E): value is FilterArray<E> =>\n  Array.isArray(value);\n\ntype FilterArray<T> = T extends T\n  ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    BoolOr<TypeEq<T, unknown>, TypeEq<T, any>> extends true\n    ? Cast<readonly unknown[], T>\n    : T extends readonly unknown[]\n      ? T\n      : never // Exclude non-array types\n  : never;\n\ntype Cast<A, B> = A extends B ? A : never;\n\n// validation\n\n/**\n * Type guard that checks if an array is empty.\n *\n * @example\n *\n * ```ts\n * const emptyNumbers: readonly number[] = [] as const;\n *\n * const words = ['Ada', 'Lovelace'] as const;\n *\n * assert.isTrue(Arr.isEmpty(emptyNumbers));\n *\n * assert.isFalse(Arr.isEmpty(words));\n *\n * if (Arr.isEmpty(emptyNumbers)) {\n *   assert.deepStrictEqual(emptyNumbers, []);\n * }\n * ```\n */\nexport const isEmpty = <E,>(array: readonly E[]): array is readonly [] =>\n  array.length === 0;\n\n/**\n * Type guard that checks if an array is non-empty.\n *\n * @example\n *\n * ```ts\n * const users: readonly Readonly<{ id: number }>[] = [{ id: 1 }] as const;\n *\n * const emptyUsers: readonly Readonly<{ id: number }>[] = [] as const;\n *\n * assert.isTrue(Arr.isNonEmpty(users));\n *\n * assert.isFalse(Arr.isNonEmpty(emptyUsers));\n *\n * if (Arr.isNonEmpty(users)) {\n *   assert.deepStrictEqual(users[0], { id: 1 });\n * }\n * ```\n */\nexport const isNonEmpty = <E,>(\n  array: readonly E[],\n): array is NonEmptyArray<E> => array.length > 0;\n\n/**\n * Checks if an array has a specific length.\n *\n * @example\n *\n * ```ts\n * const pair: readonly number[] = [1, 2] as const;\n *\n * const triple: readonly number[] = [1, 2, 3] as const;\n *\n * assert.isTrue(Arr.isFixedLengthTuple(pair, 2));\n *\n * assert.isFalse(Arr.isFixedLengthTuple(triple, 2));\n *\n * if (Arr.isFixedLengthTuple(pair, 2)) {\n *   assert.deepStrictEqual(pair, [1, 2]);\n * }\n * ```\n */\nexport const isFixedLengthTuple = <E, N extends SizeType.ArgArr>(\n  array: readonly E[],\n  len: N,\n): array is FixedLengthTuple<N, E> => array.length === len;\n\n/**\n * Checks if an array has at least a specific length.\n *\n * @example\n *\n * ```ts\n * const queue: readonly string[] = ['task-1', 'task-2'] as const;\n *\n * const emptyQueue: readonly string[] = [] as const;\n *\n * assert.isTrue(Arr.isMinLengthTuple(queue, 1));\n *\n * assert.isFalse(Arr.isMinLengthTuple(emptyQueue, 1));\n *\n * if (Arr.isMinLengthTuple(queue, 1)) {\n *   assert.isTrue(queue[0] === 'task-1');\n * }\n * ```\n */\nexport const isMinLengthTuple = <E, N extends SizeType.ArgArr>(\n  array: readonly E[],\n  len: N,\n): array is MinLengthTuple<N, E> => array.length >= len;\n\n/**\n * Checks if an array has at most a specific length.\n *\n * @example\n *\n * ```ts\n * const pair: readonly number[] = [1, 2] as const;\n *\n * const triple: readonly number[] = [1, 2, 3] as const;\n *\n * assert.isTrue(Arr.isMaxLengthTuple(pair, 2));\n *\n * assert.isFalse(Arr.isMaxLengthTuple(triple, 2));\n *\n * if (Arr.isMaxLengthTuple(pair, 2)) {\n *   assert.isTrue(pair.length <= 2);\n * }\n * ```\n */\nexport const isMaxLengthTuple = <E, N extends SizeType.ArgArr>(\n  array: readonly E[],\n  len: N,\n): array is MaxLengthTuple<N, E> => array.length <= len;\n\n/**\n * Checks if an array's length is within a specific inclusive range.\n *\n * @example\n *\n * ```ts\n * const pair: readonly number[] = [1, 2] as const;\n *\n * const quad: readonly number[] = [1, 2, 3, 4] as const;\n *\n * assert.isTrue(Arr.isBoundedLengthTuple(pair, 1, 3));\n *\n * assert.isFalse(Arr.isBoundedLengthTuple(quad, 1, 3));\n *\n * if (Arr.isBoundedLengthTuple(pair, 1, 3)) {\n *   assert.isTrue(pair.length >= 1 && pair.length <= 3);\n * }\n * ```\n */\nexport const isBoundedLengthTuple = <\n  E,\n  Min extends SizeType.ArgArr,\n  Max extends SizeType.ArgArr,\n>(\n  array: readonly E[],\n  min: Min,\n  max: Max,\n): array is BoundedLengthTuple<Min, Max, E> =>\n  array.length >= min && array.length <= max;\n\n/**\n * Tests whether all elements in an array pass a test implemented by a predicate.\n *\n * @example\n *\n * ```ts\n * const numbers = [2, 4, 6] as const;\n *\n * const words = ['Ada', 'Grace'] as const;\n *\n * const allEven = Arr.every(numbers, (value) => value % 2 === 0);\n *\n * const allStartWithA = Arr.every(words, (value) => value.startsWith('A'));\n *\n * assert.isTrue(allEven);\n *\n * assert.isFalse(allStartWithA);\n * ```\n */\n// Type guard overloads - narrow the entire array type\nexport function every<E, S extends E>(\n  array: readonly E[],\n  predicate: (a: E, index: SizeType.Arr) => a is S,\n): array is readonly S[];\n\nexport function every<E, S extends E>(\n  predicate: (a: E, index: SizeType.Arr) => a is S,\n): (array: readonly E[]) => array is readonly S[];\n\n// Regular boolean predicate overloads\nexport function every<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): boolean;\n\nexport function every<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => boolean;\n\nexport function every<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): boolean | ((array: readonly E[]) => boolean) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return array.every((a, i) => predicate(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => every(array, predicate);\n    }\n  }\n}\n\n/**\n * Tests whether at least one element in an array passes a test implemented by a predicate.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 3, 5] as const;\n *\n * const words = ['Ada', 'Grace'] as const;\n *\n * const hasEven = Arr.some(numbers, (value) => value % 2 === 0);\n *\n * const hasShortName = Arr.some(words, (value) => value.length <= 3);\n *\n * assert.isFalse(hasEven);\n *\n * assert.isTrue(hasShortName);\n * ```\n */\nexport function some<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): boolean;\n\nexport function some<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => boolean;\n\nexport function some<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): boolean | ((array: readonly E[]) => boolean) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return array.some((a, i) => predicate(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => some(array, predicate);\n    }\n  }\n}\n\n/**\n * Checks if an index is within the valid range of an array.\n *\n * @example\n *\n * ```ts\n * const items = ['Ada', 'Grace', 'Katherine'] as const;\n *\n * assert.isTrue(Arr.indexIsInRange(items, 1));\n *\n * assert.isFalse(Arr.indexIsInRange(items, 3));\n *\n * if (Arr.indexIsInRange(items, 2)) {\n *   assert.isTrue(items[2] === 'Katherine');\n * }\n * ```\n */\nexport const indexIsInRange = <E,>(\n  array: readonly E[],\n  index: SizeType.ArgArr,\n): boolean => Num.isInRange(0, array.length)(index);\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BO,MAAM,OAAA,GAAU,CAAK,KAAA,KAC1B,KAAA,CAAM,QAAQ,KAAK;AAkCd,MAAM,OAAA,GAAU,CAAK,KAAA,KAC1B,KAAA,CAAM,MAAA,KAAW;AAqBZ,MAAM,UAAA,GAAa,CACxB,KAAA,KAC8B,KAAA,CAAM,MAAA,GAAS;AAqBxC,MAAM,kBAAA,GAAqB,CAChC,KAAA,EACA,GAAA,KACoC,MAAM,MAAA,KAAW;AAqBhD,MAAM,gBAAA,GAAmB,CAC9B,KAAA,EACA,GAAA,KACkC,MAAM,MAAA,IAAU;AAqB7C,MAAM,gBAAA,GAAmB,CAC9B,KAAA,EACA,GAAA,KACkC,MAAM,MAAA,IAAU;AAqB7C,MAAM,oBAAA,GAAuB,CAKlC,KAAA,EACA,GAAA,EACA,QAEA,KAAA,CAAM,MAAA,IAAU,GAAA,IAAO,KAAA,CAAM,MAAA,IAAU;AAyClC,SAAS,SACX,IAAA,EAM2C;AAC9C,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,SAAS,CAAA,GAAI,IAAA;AAE3B,MAAA,OAAO,KAAA,CAAM,KAAA,CAAM,CAAC,CAAA,EAAG,CAAA,KAAM,UAAU,CAAA,EAAG,QAAA,CAAS,CAAC,CAAC,CAAC,CAAA;AAAA,IACxD;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,KAAA,KAAU,KAAA,CAAM,KAAA,EAAO,SAAS,CAAA;AAAA,IAC1C;AAAA;AAEJ;AA8BO,SAAS,QACX,IAAA,EAM2C;AAC9C,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,SAAS,CAAA,GAAI,IAAA;AAE3B,MAAA,OAAO,KAAA,CAAM,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,UAAU,CAAA,EAAG,QAAA,CAAS,CAAC,CAAC,CAAC,CAAA;AAAA,IACvD;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,KAAA,KAAU,IAAA,CAAK,KAAA,EAAO,SAAS,CAAA;AAAA,IACzC;AAAA;AAEJ;AAmBO,MAAM,cAAA,GAAiB,CAC5B,KAAA,EACA,KAAA,KACY,GAAA,CAAI,UAAU,CAAA,EAAG,KAAA,CAAM,MAAM,CAAA,CAAE,KAAK;;;;"}
+{"version":3,"file":"array-utils-validation.mjs","sources":["../../../src/array/impl/array-utils-validation.mts"],"sourcesContent":["import {\n  type BoolOr,\n  type BoundedLengthTuple,\n  type FixedLengthTuple,\n  type MaxLengthTuple,\n  type MinLengthTuple,\n  type NonEmptyArray,\n  type TypeEq,\n} from 'ts-type-forge';\nimport { asUint32, Num } from '../../number/index.mjs';\nimport { type ArrayIndex, type SizeType } from '../../types.mjs';\n\n/**\n * Type guard that checks if a value is an array.\n *\n * @example\n *\n * ```ts\n * const maybeArray: unknown = [1, 2, 3] as const;\n *\n * const maybeValue: unknown = 'Ada';\n *\n * assert.isTrue(Arr.isArray(maybeArray));\n *\n * assert.isFalse(Arr.isArray(maybeValue));\n *\n * if (Arr.isArray(maybeArray)) {\n *   assert.deepStrictEqual(maybeArray, [1, 2, 3]);\n * }\n * ```\n */\nexport const isArray = <E,>(value: E): value is FilterArray<E> =>\n  Array.isArray(value);\n\ntype FilterArray<T> = T extends T\n  ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    BoolOr<TypeEq<T, unknown>, TypeEq<T, any>> extends true\n    ? Cast<readonly unknown[], T>\n    : T extends readonly unknown[]\n      ? T\n      : never // Exclude non-array types\n  : never;\n\ntype Cast<A, B> = A extends B ? A : never;\n\n// validation\n\n/**\n * Type guard that checks if an array is empty.\n *\n * @example\n *\n * ```ts\n * const emptyNumbers: readonly number[] = [] as const;\n *\n * const words = ['Ada', 'Lovelace'] as const;\n *\n * assert.isTrue(Arr.isEmpty(emptyNumbers));\n *\n * assert.isFalse(Arr.isEmpty(words));\n *\n * if (Arr.isEmpty(emptyNumbers)) {\n *   assert.deepStrictEqual(emptyNumbers, []);\n * }\n * ```\n */\nexport const isEmpty = <E,>(array: readonly E[]): array is readonly [] =>\n  array.length === 0;\n\n/**\n * Type guard that checks if an array is non-empty.\n *\n * @example\n *\n * ```ts\n * const users: readonly Readonly<{ id: number }>[] = [{ id: 1 }] as const;\n *\n * const emptyUsers: readonly Readonly<{ id: number }>[] = [] as const;\n *\n * assert.isTrue(Arr.isNonEmpty(users));\n *\n * assert.isFalse(Arr.isNonEmpty(emptyUsers));\n *\n * if (Arr.isNonEmpty(users)) {\n *   assert.deepStrictEqual(users[0], { id: 1 });\n * }\n * ```\n */\nexport const isNonEmpty = <E,>(\n  array: readonly E[],\n): array is NonEmptyArray<E> => array.length > 0;\n\n/**\n * Checks if an array has a specific length.\n *\n * @example\n *\n * ```ts\n * const pair: readonly number[] = [1, 2] as const;\n *\n * const triple: readonly number[] = [1, 2, 3] as const;\n *\n * assert.isTrue(Arr.isFixedLengthTuple(pair, 2));\n *\n * assert.isFalse(Arr.isFixedLengthTuple(triple, 2));\n *\n * if (Arr.isFixedLengthTuple(pair, 2)) {\n *   assert.deepStrictEqual(pair, [1, 2]);\n * }\n * ```\n */\nexport const isFixedLengthTuple = <E, N extends SizeType.ArgArr>(\n  array: readonly E[],\n  len: N,\n): array is FixedLengthTuple<N, E> => array.length === len;\n\n/**\n * Checks if an array has at least a specific length.\n *\n * @example\n *\n * ```ts\n * const queue: readonly string[] = ['task-1', 'task-2'] as const;\n *\n * const emptyQueue: readonly string[] = [] as const;\n *\n * assert.isTrue(Arr.isMinLengthTuple(queue, 1));\n *\n * assert.isFalse(Arr.isMinLengthTuple(emptyQueue, 1));\n *\n * if (Arr.isMinLengthTuple(queue, 1)) {\n *   assert.isTrue(queue[0] === 'task-1');\n * }\n * ```\n */\nexport const isMinLengthTuple = <E, N extends SizeType.ArgArr>(\n  array: readonly E[],\n  len: N,\n): array is MinLengthTuple<N, E> => array.length >= len;\n\n/**\n * Checks if an array has at most a specific length.\n *\n * @example\n *\n * ```ts\n * const pair: readonly number[] = [1, 2] as const;\n *\n * const triple: readonly number[] = [1, 2, 3] as const;\n *\n * assert.isTrue(Arr.isMaxLengthTuple(pair, 2));\n *\n * assert.isFalse(Arr.isMaxLengthTuple(triple, 2));\n *\n * if (Arr.isMaxLengthTuple(pair, 2)) {\n *   assert.isTrue(pair.length <= 2);\n * }\n * ```\n */\nexport const isMaxLengthTuple = <E, N extends SizeType.ArgArr>(\n  array: readonly E[],\n  len: N,\n): array is MaxLengthTuple<N, E> => array.length <= len;\n\n/**\n * Checks if an array's length is within a specific inclusive range.\n *\n * @example\n *\n * ```ts\n * const pair: readonly number[] = [1, 2] as const;\n *\n * const quad: readonly number[] = [1, 2, 3, 4] as const;\n *\n * assert.isTrue(Arr.isBoundedLengthTuple(pair, 1, 3));\n *\n * assert.isFalse(Arr.isBoundedLengthTuple(quad, 1, 3));\n *\n * if (Arr.isBoundedLengthTuple(pair, 1, 3)) {\n *   assert.isTrue(pair.length >= 1 && pair.length <= 3);\n * }\n * ```\n */\nexport const isBoundedLengthTuple = <\n  E,\n  Min extends SizeType.ArgArr,\n  Max extends SizeType.ArgArr,\n>(\n  array: readonly E[],\n  min: Min,\n  max: Max,\n): array is BoundedLengthTuple<Min, Max, E> =>\n  array.length >= min && array.length <= max;\n\n/**\n * Tests whether all elements in an array pass a test implemented by a predicate.\n *\n * @example\n *\n * ```ts\n * const numbers = [2, 4, 6] as const;\n *\n * const words = ['Ada', 'Grace'] as const;\n *\n * const allEven = Arr.every(numbers, (value) => value % 2 === 0);\n *\n * const allStartWithA = Arr.every(words, (value) => value.startsWith('A'));\n *\n * assert.isTrue(allEven);\n *\n * assert.isFalse(allStartWithA);\n * ```\n */\n// Type guard overloads - narrow the entire array type\nexport function every<E, S extends E>(\n  array: readonly E[],\n  predicate: (a: E, index: SizeType.Arr) => a is S,\n): array is readonly S[];\n\nexport function every<E, S extends E>(\n  predicate: (a: E, index: SizeType.Arr) => a is S,\n): (array: readonly E[]) => array is readonly S[];\n\n// Regular boolean predicate overloads\nexport function every<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): boolean;\n\nexport function every<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => boolean;\n\nexport function every<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): boolean | ((array: readonly E[]) => boolean) {\n  switch (args.length) {\n    case 2:\n      return everyImpl(...args);\n\n    case 1:\n      return (array) => everyImpl(array, ...args);\n  }\n}\n\nconst everyImpl = <E,>(\n  array: readonly E[],\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): boolean => array.every((a, i) => predicate(a, asUint32(i)));\n\n/**\n * Tests whether at least one element in an array passes a test implemented by a predicate.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 3, 5] as const;\n *\n * const words = ['Ada', 'Grace'] as const;\n *\n * const hasEven = Arr.some(numbers, (value) => value % 2 === 0);\n *\n * const hasShortName = Arr.some(words, (value) => value.length <= 3);\n *\n * assert.isFalse(hasEven);\n *\n * assert.isTrue(hasShortName);\n * ```\n */\nexport function some<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): boolean;\n\nexport function some<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => boolean;\n\nexport function some<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): boolean | ((array: readonly E[]) => boolean) {\n  switch (args.length) {\n    case 2:\n      return someImpl(...args);\n\n    case 1:\n      return (array) => someImpl(array, ...args);\n  }\n}\n\nconst someImpl = <E,>(\n  array: readonly E[],\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): boolean => array.some((a, i) => predicate(a, asUint32(i)));\n\n/**\n * Checks if an index is within the valid range of an array.\n *\n * @example\n *\n * ```ts\n * const items = ['Ada', 'Grace', 'Katherine'] as const;\n *\n * assert.isTrue(Arr.indexIsInRange(items, 1));\n *\n * assert.isFalse(Arr.indexIsInRange(items, 3));\n *\n * if (Arr.indexIsInRange(items, 2)) {\n *   assert.isTrue(items[2] === 'Katherine');\n * }\n * ```\n */\nexport const indexIsInRange = <E,>(\n  array: readonly E[],\n  index: SizeType.ArgArr,\n): boolean => Num.isInRange(0, array.length)(index);\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BO,MAAM,OAAA,GAAU,CAAK,KAAA,KAC1B,KAAA,CAAM,QAAQ,KAAK;AAkCd,MAAM,OAAA,GAAU,CAAK,KAAA,KAC1B,KAAA,CAAM,MAAA,KAAW;AAqBZ,MAAM,UAAA,GAAa,CACxB,KAAA,KAC8B,KAAA,CAAM,MAAA,GAAS;AAqBxC,MAAM,kBAAA,GAAqB,CAChC,KAAA,EACA,GAAA,KACoC,MAAM,MAAA,KAAW;AAqBhD,MAAM,gBAAA,GAAmB,CAC9B,KAAA,EACA,GAAA,KACkC,MAAM,MAAA,IAAU;AAqB7C,MAAM,gBAAA,GAAmB,CAC9B,KAAA,EACA,GAAA,KACkC,MAAM,MAAA,IAAU;AAqB7C,MAAM,oBAAA,GAAuB,CAKlC,KAAA,EACA,GAAA,EACA,QAEA,KAAA,CAAM,MAAA,IAAU,GAAA,IAAO,KAAA,CAAM,MAAA,IAAU;AAyClC,SAAS,SACX,IAAA,EAM2C;AAC9C,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,SAAA,CAAU,GAAG,IAAI,CAAA;AAAA,IAE1B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,SAAA,CAAU,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAEhD;AAEA,MAAM,SAAA,GAAY,CAChB,KAAA,EACA,SAAA,KACY,MAAM,KAAA,CAAM,CAAC,CAAA,EAAG,CAAA,KAAM,SAAA,CAAU,CAAA,EAAG,QAAA,CAAS,CAAC,CAAC,CAAC,CAAA;AA8BtD,SAAS,QACX,IAAA,EAM2C;AAC9C,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,QAAA,CAAS,GAAG,IAAI,CAAA;AAAA,IAEzB,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,QAAA,CAAS,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAE/C;AAEA,MAAM,QAAA,GAAW,CACf,KAAA,EACA,SAAA,KACY,MAAM,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,SAAA,CAAU,CAAA,EAAG,QAAA,CAAS,CAAC,CAAC,CAAC,CAAA;AAmBrD,MAAM,cAAA,GAAiB,CAC5B,KAAA,EACA,KAAA,KACY,GAAA,CAAI,UAAU,CAAA,EAAG,KAAA,CAAM,MAAM,CAAA,CAAE,KAAK;;;;"}

package/dist/json/json.mjs

@@ -82,7 +82,7 @@ var Json;
     }
   };
   Json2.stringifySortedKey = (value, space) => {
-    const allKeys = pipe(keysDeep(value)).map((keys) => uniq(keys)).map((ks) => ks.toSorted()).value;
+    const allKeys = pipe(keysDeep(value)).map(uniq).map((ks) => ks.toSorted()).value;
     return (0, Json2.stringifySelected)(value, allKeys, space);
   };
 })(Json || (Json = {}));

package/dist/json/json.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"json.mjs","sources":["../../src/json/json.mts"],"sourcesContent":["import {\n  type JsonValue,\n  type UintRangeInclusive,\n  type UnknownRecord,\n} from 'ts-type-forge';\nimport { Arr } from '../array/index.mjs';\nimport { pipe, Result } from '../functional/index.mjs';\nimport { isRecord } from '../guard/index.mjs';\nimport { castMutable, unknownToString } from '../others/index.mjs';\n\n/**\n * A collection of type-safe JSON utility functions that provide safe parsing,\n * stringification, and manipulation of JSON data. All functions return `Result`\n * types to handle errors without throwing exceptions.\n */\nexport namespace Json {\n  /**\n   * Safely converts a JSON string into a JavaScript value without throwing\n   * exceptions.\n   *\n   * This function provides type-safe JSON parsing by wrapping the native\n   * `JSON.parse` in a `Result` type, allowing you to handle parsing errors\n   * gracefully without try-catch blocks.\n   *\n   * @example\n   *\n   * ```ts\n   * const validJson = '{\"name\": \"Alice\", \"age\": 30}';\n   *\n   * const invalidJson = '{invalid json}';\n   *\n   * const parsed = Json.parse(validJson);\n   *\n   * const failed = Json.parse(invalidJson);\n   *\n   * assert.isTrue(Result.isOk(parsed));\n   *\n   * if (Result.isOk(parsed)) {\n   *   assert.deepStrictEqual(parsed.value, { name: 'Alice', age: 30 });\n   * }\n   *\n   * assert.isTrue(Result.isErr(failed));\n   *\n   * // With reviver\n   * const jsonWithDate = '{\"created\": \"2024-01-01T00:00:00.000Z\"}';\n   *\n   * const withReviver = Json.parse(jsonWithDate, (key, value) => {\n   *   if (key === 'created' && typeof value === 'string') {\n   *     return new Date(value);\n   *   }\n   *\n   *   return value;\n   * });\n   *\n   * assert.isTrue(Result.isOk(withReviver));\n   * ```\n   *\n   * @param text - A valid JSON string to parse. Can contain any valid JSON data\n   *   type: primitives (string, number, boolean, null), arrays, or objects.\n   * @param reviver - Optional function that transforms parsed values. Called\n   *   for each key-value pair in the JSON. The function receives the key name\n   *   and parsed value, and should return the transformed value. For nested\n   *   objects, inner objects are processed before outer objects.\n   * @returns A `Result<JsonValue, string>` containing:\n   *\n   *   - On success: `Result.ok(parsedValue)` where `parsedValue` is the parsed JSON\n   *   - On failure: `Result.err(errorMessage)` where `errorMessage` describes the\n   *       parsing error\n   */\n  export const parse = (\n    text: string,\n    reviver?: (this: unknown, key: string, value: JsonValue) => unknown,\n  ): Result<JsonValue, string> => {\n    try {\n      return Result.ok(\n        JSON.parse(\n          text,\n          // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n          reviver as (this: unknown, key: string, value: unknown) => unknown,\n        ),\n      );\n    } catch (error: unknown) {\n      const errStr = unknownToString(error);\n\n      return Result.err(errStr);\n    }\n  };\n\n  /**\n   * Safely converts a JavaScript value to a JSON string without throwing\n   * exceptions.\n   *\n   * This function provides type-safe JSON stringification by wrapping the\n   * native `JSON.stringify` in a `Result` type, allowing you to handle\n   * serialization errors gracefully (such as circular references or BigInt\n   * values).\n   *\n   * @example\n   *\n   * ```ts\n   * const data = { name: 'Bob', age: 25, active: true } as const;\n   *\n   * // Basic stringify\n   * const basic = Json.stringify(data);\n   *\n   * assert.isTrue(Result.isOk(basic));\n   *\n   * if (Result.isOk(basic)) {\n   *   assert.isTrue(basic.value === '{\"name\":\"Bob\",\"age\":25,\"active\":true}');\n   * }\n   *\n   * // With formatting\n   * const formatted = Json.stringify(data, undefined, 2);\n   *\n   * assert.isTrue(Result.isOk(formatted));\n   *\n   * // With replacer\n   * const filtered = Json.stringify(data, (key, value) => {\n   *   if (key === 'age') return undefined; // omit age field\n   *\n   *   return value;\n   * });\n   *\n   * assert.isTrue(Result.isOk(filtered));\n   *\n   * if (Result.isOk(filtered)) {\n   *   assert.isTrue(isString(filtered.value));\n   *\n   *   assert.isFalse(filtered.value.includes('age'));\n   * }\n   * ```\n   *\n   * @param value - The JavaScript value to serialize. Can be any value that\n   *   JSON.stringify accepts: primitives, objects, arrays. Non-serializable\n   *   values (functions, undefined, symbols) will be omitted or converted to\n   *   null according to JSON.stringify behavior.\n   * @param replacer - Optional function that transforms values during\n   *   serialization. Called for each key-value pair. Should return the value to\n   *   be serialized, or undefined to omit the property from the result.\n   * @param space - Optional parameter for formatting the output JSON:\n   *\n   *   - Number (1-10): Number of spaces to indent each level\n   *   - String: String to use for indentation (first 10 characters)\n   *   - Undefined/null: No formatting (compact output)\n   *\n   * @returns A `Result<string, string>` containing:\n   *\n   *   - On success: `Result.ok(jsonString)` where `jsonString` is the serialized\n   *       JSON\n   *   - On failure: `Result.err(errorMessage)` where `errorMessage` describes the\n   *       error\n   */\n  export const stringify = (\n    value: unknown,\n    replacer?: (this: unknown, key: string, val: unknown) => unknown,\n    space?: UintRangeInclusive<1, 10> | string,\n  ): Result<string | undefined, string> => {\n    try {\n      return Result.ok(JSON.stringify(value, replacer, space));\n    } catch (error) {\n      const errStr = unknownToString(error);\n\n      return Result.err(errStr);\n    }\n  };\n\n  /**\n   * Safely converts a JavaScript value to a JSON string, including only the\n   * specified properties.\n   *\n   * This function provides selective serialization by allowing you to specify\n   * exactly which object properties should be included in the resulting JSON.\n   * It's useful for creating filtered or minimal representations of objects,\n   * such as for API responses or logging.\n   *\n   * @example\n   *\n   * ```ts\n   * const user = {\n   *   id: 1,\n   *   name: 'Charlie',\n   *   email: 'charlie@example.com',\n   *   password: 'secret123',\n   *   role: 'admin',\n   * } as const;\n   *\n   * // Select only safe properties to serialize\n   * const safeJson = Json.stringifySelected(user, ['id', 'name', 'role']);\n   *\n   * assert.isTrue(Result.isOk(safeJson));\n   *\n   * if (Result.isOk(safeJson)) {\n   *   assert.isTrue(isString(safeJson.value));\n   *\n   *   const parsed: unknown = JSON.parse(safeJson.value);\n   *\n   *   assert.deepStrictEqual(parsed, {\n   *     id: 1,\n   *     name: 'Charlie',\n   *     role: 'admin',\n   *   });\n   *\n   *   assert.isFalse(safeJson.value.includes('password'));\n   *\n   *   assert.isFalse(safeJson.value.includes('email'));\n   * }\n   *\n   * // With formatting\n   * const formatted = Json.stringifySelected(user, ['id', 'name'], 2);\n   *\n   * assert.isTrue(Result.isOk(formatted));\n   * ```\n   *\n   * @param value - The JavaScript value to serialize. While any value is\n   *   accepted, the property filtering only applies to objects and nested\n   *   objects.\n   * @param propertiesToBeSelected - Optional array of property names (strings)\n   *   and array indices (numbers) to include in the serialization. If provided,\n   *   only these properties will appear in the output JSON. If undefined, all\n   *   properties are included.\n   * @param space - Optional formatting parameter:\n   *\n   *   - Number (1-10): Number of spaces to indent each level\n   *   - String: String to use for indentation (first 10 characters)\n   *   - Undefined/null: No formatting (compact output)\n   *\n   * @returns A `Result<string, string>` containing:\n   *\n   *   - On success: `Result.ok(jsonString)` with only selected properties\n   *   - On failure: `Result.err(errorMessage)` describing the serialization error\n   */\n  export const stringifySelected = (\n    value: unknown,\n    propertiesToBeSelected?: readonly (number | string)[],\n    space?: UintRangeInclusive<1, 10> | string,\n  ): Result<string | undefined, string> => {\n    try {\n      return Result.ok(\n        JSON.stringify(value, castMutable(propertiesToBeSelected), space),\n      );\n    } catch (error) {\n      const errStr = unknownToString(error);\n\n      return Result.err(errStr);\n    }\n  };\n\n  /**\n   * Safely converts a JavaScript record to a JSON string with keys sorted\n   * alphabetically at all levels.\n   *\n   * This function creates deterministic JSON output by ensuring that object\n   * keys appear in alphabetical order at every level of nesting. This is\n   * particularly useful for creating consistent output for comparison, hashing,\n   * caching, or when you need reproducible JSON representations across\n   * different JavaScript engines or runs.\n   *\n   * @example\n   *\n   * ```ts\n   * const unorderedData = {\n   *   zebra: 1,\n   *   apple: 2,\n   *   mango: 3,\n   *   nested: {\n   *     zulu: 'z',\n   *     alpha: 'a',\n   *     beta: 'b',\n   *   },\n   * } as const;\n   *\n   * // Keys will be sorted alphabetically at all levels\n   * const sorted = Json.stringifySortedKey(unorderedData);\n   *\n   * assert.isTrue(Result.isOk(sorted));\n   *\n   * if (Result.isOk(sorted)) {\n   *   // Keys should appear in alphabetical order\n   *   const expected =\n   *     '{\"apple\":2,\"mango\":3,\"nested\":{\"alpha\":\"a\",\"beta\":\"b\",\"zulu\":\"z\"},\"zebra\":1}';\n   *\n   *   assert.isTrue(sorted.value === expected);\n   * }\n   *\n   * // With formatting\n   * const formatted = Json.stringifySortedKey(unorderedData, 2);\n   *\n   * assert.isTrue(Result.isOk(formatted));\n   *\n   * if (Result.isOk(formatted)) {\n   *   assert.isTrue(isString(formatted.value));\n   *\n   *   // Check that keys are in order (first key should be \"apple\")\n   *   assert.isTrue(\n   *     formatted.value.indexOf('\"apple\"') < formatted.value.indexOf('\"mango\"'),\n   *   );\n   *\n   *   assert.isTrue(\n   *     formatted.value.indexOf('\"mango\"') <\n   *       formatted.value.indexOf('\"nested\"'),\n   *   );\n   *\n   *   assert.isTrue(\n   *     formatted.value.indexOf('\"nested\"') <\n   *       formatted.value.indexOf('\"zebra\"'),\n   *   );\n   * }\n   * ```\n   *\n   * @param value - An object (`UnknownRecord`) to serialize. Must be a plain\n   *   object (not an array, primitive, or null). Nested objects and arrays\n   *   within the object will also have their keys sorted alphabetically.\n   * @param space - Optional formatting parameter:\n   *\n   *   - Number (1-10): Number of spaces to indent each level\n   *   - String: String to use for indentation (first 10 characters)\n   *   - Undefined/null: No formatting (compact output)\n   *\n   * @returns A `Result<string, string>` containing:\n   *\n   *   - On success: `Result.ok(jsonString)` with all object keys sorted\n   *       alphabetically\n   *   - On failure: `Result.err(errorMessage)` describing the serialization error\n   */\n  export const stringifySortedKey = (\n    value: UnknownRecord,\n    space?: UintRangeInclusive<1, 10> | string,\n  ): Result<string | undefined, string> => {\n    const allKeys = pipe(keysDeep(value))\n      .map((keys) => Arr.uniq(keys))\n      .map((ks) => ks.toSorted()).value;\n\n    return stringifySelected(value, allKeys, space);\n  };\n}\n\n/**\n * @param obj - The record to extract keys from. Must be a plain object.\n * @param mut_keys - A mutable array to accumulate the collected keys. This\n *   array will be modified in-place by the function for performance reasons.\n * @internal\n * Recursively collects all property keys from a nested object structure.\n *\n * This helper function traverses an object and its nested objects and arrays,\n * collecting all string keys found at any level of nesting. The function mutates\n * the provided keys array for performance reasons.\n */\nconst keysDeepImpl = (\n  obj: UnknownRecord,\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  mut_keys: string[],\n): void => {\n  for (const [k, v] of Object.entries(obj)) {\n    mut_keys.push(k);\n\n    if (isRecord(v)) {\n      keysDeepImpl(v, mut_keys);\n    }\n\n    if (Array.isArray(v)) {\n      for (const li of v) {\n        if (isRecord(li)) {\n          keysDeepImpl(li, mut_keys);\n        }\n      }\n    }\n  }\n};\n\n/**\n * @param obj - The record to extract keys from. Must be a plain object.\n * @returns A readonly array of all string keys found in the object and its\n *   nested objects/arrays. May contain duplicates if the same key appears at\n *   multiple levels.\n * @internal\n * Extracts all property keys from a nested object structure into a flat array.\n *\n * This function serves as a safe wrapper around `keysDeepImpl`, creating a new\n * mutable array and passing it to the recursive implementation. The result\n * contains all keys found at any level of nesting within the input object.\n */\nconst keysDeep = (obj: UnknownRecord): readonly string[] => {\n  const mut_keys: string[] = [];\n\n  keysDeepImpl(obj, mut_keys);\n\n  return mut_keys;\n};\n"],"names":["Json","Result.ok","Result.err","Arr.uniq"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeO,IAAU;AAAA,CAAV,CAAUA,KAAAA,KAAV;AAsDE,EAAMA,KAAAA,CAAA,KAAA,GAAQ,CACnB,IAAA,EACA,OAAA,KAC8B;AAC9B,IAAA,IAAI;AACF,MAAA,OAAOC,EAAO;AAAA,QACZ,IAAA,CAAK,KAAA;AAAA,UACH,IAAA;AAAA;AAAA,UAEA;AAAA;AACF,OACF;AAAA,IACF,SAAS,KAAA,EAAgB;AACvB,MAAA,MAAM,MAAA,GAAS,gBAAgB,KAAK,CAAA;AAEpC,MAAA,OAAOC,IAAW,MAAM,CAAA;AAAA,IAC1B;AAAA,EACF,CAAA;AAkEO,EAAMF,KAAAA,CAAA,SAAA,GAAY,CACvB,KAAA,EACA,UACA,KAAA,KACuC;AACvC,IAAA,IAAI;AACF,MAAA,OAAOC,EAAO,CAAG,IAAA,CAAK,UAAU,KAAA,EAAO,QAAA,EAAU,KAAK,CAAC,CAAA;AAAA,IACzD,SAAS,KAAA,EAAO;AACd,MAAA,MAAM,MAAA,GAAS,gBAAgB,KAAK,CAAA;AAEpC,MAAA,OAAOC,IAAW,MAAM,CAAA;AAAA,IAC1B;AAAA,EACF,CAAA;AAmEO,EAAMF,KAAAA,CAAA,iBAAA,GAAoB,CAC/B,KAAA,EACA,wBACA,KAAA,KACuC;AACvC,IAAA,IAAI;AACF,MAAA,OAAOC,EAAO;AAAA,QACZ,KAAK,SAAA,CAAU,KAAA,EAAO,WAAA,CAAY,sBAAsB,GAAG,KAAK;AAAA,OAClE;AAAA,IACF,SAAS,KAAA,EAAO;AACd,MAAA,MAAM,MAAA,GAAS,gBAAgB,KAAK,CAAA;AAEpC,MAAA,OAAOC,IAAW,MAAM,CAAA;AAAA,IAC1B;AAAA,EACF,CAAA;AA+EO,EAAMF,KAAAA,CAAA,kBAAA,GAAqB,CAChC,KAAA,EACA,KAAA,KACuC;AACvC,IAAA,MAAM,OAAA,GAAU,KAAK,QAAA,CAAS,KAAK,CAAC,CAAA,CACjC,GAAA,CAAI,CAAC,IAAA,KAASG,KAAS,IAAI,CAAC,EAC5B,GAAA,CAAI,CAAC,OAAO,EAAA,CAAG,QAAA,EAAU,CAAA,CAAE,KAAA;AAE9B,IAAA,OAAA,IAAOH,KAAAA,CAAA,iBAAA,EAAkB,KAAA,EAAO,OAAA,EAAS,KAAK,CAAA;AAAA,EAChD,CAAA;AAAA,CAAA,EA9Te,IAAA,KAAA,IAAA,GAAA,EAAA,CAAA,CAAA;AA4UjB,MAAM,YAAA,GAAe,CACnB,GAAA,EAEA,QAAA,KACS;AACT,EAAA,KAAA,MAAW,CAAC,CAAA,EAAG,CAAC,KAAK,MAAA,CAAO,OAAA,CAAQ,GAAG,CAAA,EAAG;AACxC,IAAA,QAAA,CAAS,KAAK,CAAC,CAAA;AAEf,IAAA,IAAI,QAAA,CAAS,CAAC,CAAA,EAAG;AACf,MAAA,YAAA,CAAa,GAAG,QAAQ,CAAA;AAAA,IAC1B;AAEA,IAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,CAAC,CAAA,EAAG;AACpB,MAAA,KAAA,MAAW,MAAM,CAAA,EAAG;AAClB,QAAA,IAAI,QAAA,CAAS,EAAE,CAAA,EAAG;AAChB,UAAA,YAAA,CAAa,IAAI,QAAQ,CAAA;AAAA,QAC3B;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF,CAAA;AAcA,MAAM,QAAA,GAAW,CAAC,GAAA,KAA0C;AAC1D,EAAA,MAAM,WAAqB,EAAC;AAE5B,EAAA,YAAA,CAAa,KAAK,QAAQ,CAAA;AAE1B,EAAA,OAAO,QAAA;AACT,CAAA;;;;"}
+{"version":3,"file":"json.mjs","sources":["../../src/json/json.mts"],"sourcesContent":["import {\n  type JsonValue,\n  type UintRangeInclusive,\n  type UnknownRecord,\n} from 'ts-type-forge';\nimport { Arr } from '../array/index.mjs';\nimport { pipe, Result } from '../functional/index.mjs';\nimport { isRecord } from '../guard/index.mjs';\nimport { castMutable, unknownToString } from '../others/index.mjs';\n\n/**\n * A collection of type-safe JSON utility functions that provide safe parsing,\n * stringification, and manipulation of JSON data. All functions return `Result`\n * types to handle errors without throwing exceptions.\n */\nexport namespace Json {\n  /**\n   * Safely converts a JSON string into a JavaScript value without throwing\n   * exceptions.\n   *\n   * This function provides type-safe JSON parsing by wrapping the native\n   * `JSON.parse` in a `Result` type, allowing you to handle parsing errors\n   * gracefully without try-catch blocks.\n   *\n   * @example\n   *\n   * ```ts\n   * const validJson = '{\"name\": \"Alice\", \"age\": 30}';\n   *\n   * const invalidJson = '{invalid json}';\n   *\n   * const parsed = Json.parse(validJson);\n   *\n   * const failed = Json.parse(invalidJson);\n   *\n   * assert.isTrue(Result.isOk(parsed));\n   *\n   * if (Result.isOk(parsed)) {\n   *   assert.deepStrictEqual(parsed.value, { name: 'Alice', age: 30 });\n   * }\n   *\n   * assert.isTrue(Result.isErr(failed));\n   *\n   * // With reviver\n   * const jsonWithDate = '{\"created\": \"2024-01-01T00:00:00.000Z\"}';\n   *\n   * const withReviver = Json.parse(jsonWithDate, (key, value) => {\n   *   if (key === 'created' && typeof value === 'string') {\n   *     return new Date(value);\n   *   }\n   *\n   *   return value;\n   * });\n   *\n   * assert.isTrue(Result.isOk(withReviver));\n   * ```\n   *\n   * @param text - A valid JSON string to parse. Can contain any valid JSON data\n   *   type: primitives (string, number, boolean, null), arrays, or objects.\n   * @param reviver - Optional function that transforms parsed values. Called\n   *   for each key-value pair in the JSON. The function receives the key name\n   *   and parsed value, and should return the transformed value. For nested\n   *   objects, inner objects are processed before outer objects.\n   * @returns A `Result<JsonValue, string>` containing:\n   *\n   *   - On success: `Result.ok(parsedValue)` where `parsedValue` is the parsed JSON\n   *   - On failure: `Result.err(errorMessage)` where `errorMessage` describes the\n   *       parsing error\n   */\n  export const parse = (\n    text: string,\n    reviver?: (this: unknown, key: string, value: JsonValue) => unknown,\n  ): Result<JsonValue, string> => {\n    try {\n      return Result.ok(\n        JSON.parse(\n          text,\n          // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n          reviver as (this: unknown, key: string, value: unknown) => unknown,\n        ),\n      );\n    } catch (error: unknown) {\n      const errStr = unknownToString(error);\n\n      return Result.err(errStr);\n    }\n  };\n\n  /**\n   * Safely converts a JavaScript value to a JSON string without throwing\n   * exceptions.\n   *\n   * This function provides type-safe JSON stringification by wrapping the\n   * native `JSON.stringify` in a `Result` type, allowing you to handle\n   * serialization errors gracefully (such as circular references or BigInt\n   * values).\n   *\n   * @example\n   *\n   * ```ts\n   * const data = { name: 'Bob', age: 25, active: true } as const;\n   *\n   * // Basic stringify\n   * const basic = Json.stringify(data);\n   *\n   * assert.isTrue(Result.isOk(basic));\n   *\n   * if (Result.isOk(basic)) {\n   *   assert.isTrue(basic.value === '{\"name\":\"Bob\",\"age\":25,\"active\":true}');\n   * }\n   *\n   * // With formatting\n   * const formatted = Json.stringify(data, undefined, 2);\n   *\n   * assert.isTrue(Result.isOk(formatted));\n   *\n   * // With replacer\n   * const filtered = Json.stringify(data, (key, value) => {\n   *   if (key === 'age') return undefined; // omit age field\n   *\n   *   return value;\n   * });\n   *\n   * assert.isTrue(Result.isOk(filtered));\n   *\n   * if (Result.isOk(filtered)) {\n   *   assert.isTrue(isString(filtered.value));\n   *\n   *   assert.isFalse(filtered.value.includes('age'));\n   * }\n   * ```\n   *\n   * @param value - The JavaScript value to serialize. Can be any value that\n   *   JSON.stringify accepts: primitives, objects, arrays. Non-serializable\n   *   values (functions, undefined, symbols) will be omitted or converted to\n   *   null according to JSON.stringify behavior.\n   * @param replacer - Optional function that transforms values during\n   *   serialization. Called for each key-value pair. Should return the value to\n   *   be serialized, or undefined to omit the property from the result.\n   * @param space - Optional parameter for formatting the output JSON:\n   *\n   *   - Number (1-10): Number of spaces to indent each level\n   *   - String: String to use for indentation (first 10 characters)\n   *   - Undefined/null: No formatting (compact output)\n   *\n   * @returns A `Result<string, string>` containing:\n   *\n   *   - On success: `Result.ok(jsonString)` where `jsonString` is the serialized\n   *       JSON\n   *   - On failure: `Result.err(errorMessage)` where `errorMessage` describes the\n   *       error\n   */\n  export const stringify = (\n    value: unknown,\n    replacer?: (this: unknown, key: string, val: unknown) => unknown,\n    space?: UintRangeInclusive<1, 10> | string,\n  ): Result<string | undefined, string> => {\n    try {\n      return Result.ok(JSON.stringify(value, replacer, space));\n    } catch (error) {\n      const errStr = unknownToString(error);\n\n      return Result.err(errStr);\n    }\n  };\n\n  /**\n   * Safely converts a JavaScript value to a JSON string, including only the\n   * specified properties.\n   *\n   * This function provides selective serialization by allowing you to specify\n   * exactly which object properties should be included in the resulting JSON.\n   * It's useful for creating filtered or minimal representations of objects,\n   * such as for API responses or logging.\n   *\n   * @example\n   *\n   * ```ts\n   * const user = {\n   *   id: 1,\n   *   name: 'Charlie',\n   *   email: 'charlie@example.com',\n   *   password: 'secret123',\n   *   role: 'admin',\n   * } as const;\n   *\n   * // Select only safe properties to serialize\n   * const safeJson = Json.stringifySelected(user, ['id', 'name', 'role']);\n   *\n   * assert.isTrue(Result.isOk(safeJson));\n   *\n   * if (Result.isOk(safeJson)) {\n   *   assert.isTrue(isString(safeJson.value));\n   *\n   *   const parsed: unknown = JSON.parse(safeJson.value);\n   *\n   *   assert.deepStrictEqual(parsed, {\n   *     id: 1,\n   *     name: 'Charlie',\n   *     role: 'admin',\n   *   });\n   *\n   *   assert.isFalse(safeJson.value.includes('password'));\n   *\n   *   assert.isFalse(safeJson.value.includes('email'));\n   * }\n   *\n   * // With formatting\n   * const formatted = Json.stringifySelected(user, ['id', 'name'], 2);\n   *\n   * assert.isTrue(Result.isOk(formatted));\n   * ```\n   *\n   * @param value - The JavaScript value to serialize. While any value is\n   *   accepted, the property filtering only applies to objects and nested\n   *   objects.\n   * @param propertiesToBeSelected - Optional array of property names (strings)\n   *   and array indices (numbers) to include in the serialization. If provided,\n   *   only these properties will appear in the output JSON. If undefined, all\n   *   properties are included.\n   * @param space - Optional formatting parameter:\n   *\n   *   - Number (1-10): Number of spaces to indent each level\n   *   - String: String to use for indentation (first 10 characters)\n   *   - Undefined/null: No formatting (compact output)\n   *\n   * @returns A `Result<string, string>` containing:\n   *\n   *   - On success: `Result.ok(jsonString)` with only selected properties\n   *   - On failure: `Result.err(errorMessage)` describing the serialization error\n   */\n  export const stringifySelected = (\n    value: unknown,\n    propertiesToBeSelected?: readonly (number | string)[],\n    space?: UintRangeInclusive<1, 10> | string,\n  ): Result<string | undefined, string> => {\n    try {\n      return Result.ok(\n        JSON.stringify(value, castMutable(propertiesToBeSelected), space),\n      );\n    } catch (error) {\n      const errStr = unknownToString(error);\n\n      return Result.err(errStr);\n    }\n  };\n\n  /**\n   * Safely converts a JavaScript record to a JSON string with keys sorted\n   * alphabetically at all levels.\n   *\n   * This function creates deterministic JSON output by ensuring that object\n   * keys appear in alphabetical order at every level of nesting. This is\n   * particularly useful for creating consistent output for comparison, hashing,\n   * caching, or when you need reproducible JSON representations across\n   * different JavaScript engines or runs.\n   *\n   * @example\n   *\n   * ```ts\n   * const unorderedData = {\n   *   zebra: 1,\n   *   apple: 2,\n   *   mango: 3,\n   *   nested: {\n   *     zulu: 'z',\n   *     alpha: 'a',\n   *     beta: 'b',\n   *   },\n   * } as const;\n   *\n   * // Keys will be sorted alphabetically at all levels\n   * const sorted = Json.stringifySortedKey(unorderedData);\n   *\n   * assert.isTrue(Result.isOk(sorted));\n   *\n   * if (Result.isOk(sorted)) {\n   *   // Keys should appear in alphabetical order\n   *   const expected =\n   *     '{\"apple\":2,\"mango\":3,\"nested\":{\"alpha\":\"a\",\"beta\":\"b\",\"zulu\":\"z\"},\"zebra\":1}';\n   *\n   *   assert.isTrue(sorted.value === expected);\n   * }\n   *\n   * // With formatting\n   * const formatted = Json.stringifySortedKey(unorderedData, 2);\n   *\n   * assert.isTrue(Result.isOk(formatted));\n   *\n   * if (Result.isOk(formatted)) {\n   *   assert.isTrue(isString(formatted.value));\n   *\n   *   // Check that keys are in order (first key should be \"apple\")\n   *   assert.isTrue(\n   *     formatted.value.indexOf('\"apple\"') < formatted.value.indexOf('\"mango\"'),\n   *   );\n   *\n   *   assert.isTrue(\n   *     formatted.value.indexOf('\"mango\"') <\n   *       formatted.value.indexOf('\"nested\"'),\n   *   );\n   *\n   *   assert.isTrue(\n   *     formatted.value.indexOf('\"nested\"') <\n   *       formatted.value.indexOf('\"zebra\"'),\n   *   );\n   * }\n   * ```\n   *\n   * @param value - An object (`UnknownRecord`) to serialize. Must be a plain\n   *   object (not an array, primitive, or null). Nested objects and arrays\n   *   within the object will also have their keys sorted alphabetically.\n   * @param space - Optional formatting parameter:\n   *\n   *   - Number (1-10): Number of spaces to indent each level\n   *   - String: String to use for indentation (first 10 characters)\n   *   - Undefined/null: No formatting (compact output)\n   *\n   * @returns A `Result<string, string>` containing:\n   *\n   *   - On success: `Result.ok(jsonString)` with all object keys sorted\n   *       alphabetically\n   *   - On failure: `Result.err(errorMessage)` describing the serialization error\n   */\n  export const stringifySortedKey = (\n    value: UnknownRecord,\n    space?: UintRangeInclusive<1, 10> | string,\n  ): Result<string | undefined, string> => {\n    const allKeys = pipe(keysDeep(value))\n      .map(Arr.uniq)\n      .map((ks) => ks.toSorted()).value;\n\n    return stringifySelected(value, allKeys, space);\n  };\n}\n\n/**\n * @param obj - The record to extract keys from. Must be a plain object.\n * @param mut_keys - A mutable array to accumulate the collected keys. This\n *   array will be modified in-place by the function for performance reasons.\n * @internal\n * Recursively collects all property keys from a nested object structure.\n *\n * This helper function traverses an object and its nested objects and arrays,\n * collecting all string keys found at any level of nesting. The function mutates\n * the provided keys array for performance reasons.\n */\nconst keysDeepImpl = (\n  obj: UnknownRecord,\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  mut_keys: string[],\n): void => {\n  for (const [k, v] of Object.entries(obj)) {\n    mut_keys.push(k);\n\n    if (isRecord(v)) {\n      keysDeepImpl(v, mut_keys);\n    }\n\n    if (Array.isArray(v)) {\n      for (const li of v) {\n        if (isRecord(li)) {\n          keysDeepImpl(li, mut_keys);\n        }\n      }\n    }\n  }\n};\n\n/**\n * @param obj - The record to extract keys from. Must be a plain object.\n * @returns A readonly array of all string keys found in the object and its\n *   nested objects/arrays. May contain duplicates if the same key appears at\n *   multiple levels.\n * @internal\n * Extracts all property keys from a nested object structure into a flat array.\n *\n * This function serves as a safe wrapper around `keysDeepImpl`, creating a new\n * mutable array and passing it to the recursive implementation. The result\n * contains all keys found at any level of nesting within the input object.\n */\nconst keysDeep = (obj: UnknownRecord): readonly string[] => {\n  const mut_keys: string[] = [];\n\n  keysDeepImpl(obj, mut_keys);\n\n  return mut_keys;\n};\n"],"names":["Json","Result.ok","Result.err","Arr.uniq"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeO,IAAU;AAAA,CAAV,CAAUA,KAAAA,KAAV;AAsDE,EAAMA,KAAAA,CAAA,KAAA,GAAQ,CACnB,IAAA,EACA,OAAA,KAC8B;AAC9B,IAAA,IAAI;AACF,MAAA,OAAOC,EAAO;AAAA,QACZ,IAAA,CAAK,KAAA;AAAA,UACH,IAAA;AAAA;AAAA,UAEA;AAAA;AACF,OACF;AAAA,IACF,SAAS,KAAA,EAAgB;AACvB,MAAA,MAAM,MAAA,GAAS,gBAAgB,KAAK,CAAA;AAEpC,MAAA,OAAOC,IAAW,MAAM,CAAA;AAAA,IAC1B;AAAA,EACF,CAAA;AAkEO,EAAMF,KAAAA,CAAA,SAAA,GAAY,CACvB,KAAA,EACA,UACA,KAAA,KACuC;AACvC,IAAA,IAAI;AACF,MAAA,OAAOC,EAAO,CAAG,IAAA,CAAK,UAAU,KAAA,EAAO,QAAA,EAAU,KAAK,CAAC,CAAA;AAAA,IACzD,SAAS,KAAA,EAAO;AACd,MAAA,MAAM,MAAA,GAAS,gBAAgB,KAAK,CAAA;AAEpC,MAAA,OAAOC,IAAW,MAAM,CAAA;AAAA,IAC1B;AAAA,EACF,CAAA;AAmEO,EAAMF,KAAAA,CAAA,iBAAA,GAAoB,CAC/B,KAAA,EACA,wBACA,KAAA,KACuC;AACvC,IAAA,IAAI;AACF,MAAA,OAAOC,EAAO;AAAA,QACZ,KAAK,SAAA,CAAU,KAAA,EAAO,WAAA,CAAY,sBAAsB,GAAG,KAAK;AAAA,OAClE;AAAA,IACF,SAAS,KAAA,EAAO;AACd,MAAA,MAAM,MAAA,GAAS,gBAAgB,KAAK,CAAA;AAEpC,MAAA,OAAOC,IAAW,MAAM,CAAA;AAAA,IAC1B;AAAA,EACF,CAAA;AA+EO,EAAMF,KAAAA,CAAA,kBAAA,GAAqB,CAChC,KAAA,EACA,KAAA,KACuC;AACvC,IAAA,MAAM,UAAU,IAAA,CAAK,QAAA,CAAS,KAAK,CAAC,EACjC,GAAA,CAAIG,IAAQ,CAAA,CACZ,IAAI,CAAC,EAAA,KAAO,EAAA,CAAG,QAAA,EAAU,CAAA,CAAE,KAAA;AAE9B,IAAA,OAAA,IAAOH,KAAAA,CAAA,iBAAA,EAAkB,KAAA,EAAO,OAAA,EAAS,KAAK,CAAA;AAAA,EAChD,CAAA;AAAA,CAAA,EA9Te,IAAA,KAAA,IAAA,GAAA,EAAA,CAAA,CAAA;AA4UjB,MAAM,YAAA,GAAe,CACnB,GAAA,EAEA,QAAA,KACS;AACT,EAAA,KAAA,MAAW,CAAC,CAAA,EAAG,CAAC,KAAK,MAAA,CAAO,OAAA,CAAQ,GAAG,CAAA,EAAG;AACxC,IAAA,QAAA,CAAS,KAAK,CAAC,CAAA;AAEf,IAAA,IAAI,QAAA,CAAS,CAAC,CAAA,EAAG;AACf,MAAA,YAAA,CAAa,GAAG,QAAQ,CAAA;AAAA,IAC1B;AAEA,IAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,CAAC,CAAA,EAAG;AACpB,MAAA,KAAA,MAAW,MAAM,CAAA,EAAG;AAClB,QAAA,IAAI,QAAA,CAAS,EAAE,CAAA,EAAG;AAChB,UAAA,YAAA,CAAa,IAAI,QAAQ,CAAA;AAAA,QAC3B;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF,CAAA;AAcA,MAAM,QAAA,GAAW,CAAC,GAAA,KAA0C;AAC1D,EAAA,MAAM,WAAqB,EAAC;AAE5B,EAAA,YAAA,CAAa,KAAK,QAAQ,CAAA;AAE1B,EAAA,OAAO,QAAA;AACT,CAAA;;;;"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,YAAY,IAAI,wBAAwB,EAC9C,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,YAAY,GAAG,wBAAwB,CAAC;AAEpD,KAAK,WAAW,GAAG,YAAY,CAAC;AAgDhC;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,8CAAK,CAAC;AAEjC;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc;;;;;MAAW,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;wBA1FA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA4F3D;;;;;OAKG;uBA5FA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA8F3D;;;;;OAKG;wBA9FA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAgG3D;;;;;;;;OAQG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,YAAY,IAAI,wBAAwB,EAC9C,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,YAAY,GAAG,wBAAwB,CAAC;AAEpD,KAAK,WAAW,GAAG,YAAY,CAAC;AA0BhC,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAE9E,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEgB,CAAC;AAE7E,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAM9E;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,8CAAK,CAAC;AAEjC;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc;;;;;MAAW,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;CAEK,CAAC"}

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

@@ -3,6 +3,10 @@ import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 import { PositiveFiniteNumber } from './positive-finite-number.mjs';
 export type NegativeFiniteNumber = TtfImported_NegativeFiniteNumber;
 type ElementType = NegativeFiniteNumber;
+declare const abs: (x: ElementType) => PositiveFiniteNumber;
+declare const floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+declare const ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
+declare const round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
 /**
  * Type guard that checks if a value is a negative finite number.
  *
@@ -66,7 +70,7 @@ export declare const NegativeFiniteNumber: {
      * @param a - The negative finite number value
      * @returns The absolute value as a non-negative `NegativeFiniteNumber`
      */
-    readonly abs: (x: ElementType) => PositiveFiniteNumber;
+    readonly abs: typeof abs;
     /**
      * Returns the smallest of the given negative finite numbers.
      *
@@ -100,7 +104,7 @@ export declare const NegativeFiniteNumber: {
      * @param a - The negative finite number value
      * @returns The floored value as an integer
      */
-    readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly floor: typeof floor;
     /**
      * Returns the smallest integer greater than or equal to a negative finite
      * number.
@@ -108,7 +112,7 @@ export declare const NegativeFiniteNumber: {
      * @param a - The negative finite number value
      * @returns The ceiled value as an integer
      */
-    readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
+    readonly ceil: typeof ceil;
     /**
      * Returns the value of a negative finite number rounded to the nearest
      * integer.
@@ -116,7 +120,7 @@ export declare const NegativeFiniteNumber: {
      * @param a - The negative finite number value
      * @returns The rounded value as an integer
      */
-    readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
+    readonly round: typeof round;
     /**
      * Generates a random `NegativeFiniteNumber` within the given range.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,IAAI,gCAAgC,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEpE,MAAM,MAAM,oBAAoB,GAAG,gCAAgC,CAAC;AAEpE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AAyDxC;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,sDAAK,CAAC;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;MAAW,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;;;OAOG;sBArFW,WAAW,KAAG,oBAAoB;IAwFhD;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;wBAvHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAyH3D;;;;;;OAMG;uBA1HA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IA0HC;;;;;;OAMG;wBAzHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IAyHC;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}
+{"version":3,"file":"negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,IAAI,gCAAgC,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEpE,MAAM,MAAM,oBAAoB,GAAG,gCAAgC,CAAC;AAEpE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AA0BxC,QAAA,MAAM,GAAG,MAAO,WAAW,KAAG,oBACgB,CAAC;AAE/C,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAE9E,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAKzD,CAAC;AAEJ,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,sDAAK,CAAC;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;MAAW,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}

package/dist/number/branded-types/negative-int.d.mts

@@ -2,6 +2,7 @@ import { type NegativeInt as TtfImported_NegativeInt, type WithSmallInt } from '
 import { PositiveInt } from './positive-int.mjs';
 export type NegativeInt = TtfImported_NegativeInt;
 type ElementType = NegativeInt;
+declare const abs: (x: WithSmallInt<ElementType>) => PositiveInt;
 /**
  * Type guard that checks if a value is a negative integer.
  *
@@ -70,7 +71,7 @@ export declare const NegativeInt: {
      * @param a - The negative integer value
      * @returns The absolute value as a non-negative `NegativeInt`
      */
-    readonly abs: (x: WithSmallInt<ElementType>) => PositiveInt;
+    readonly abs: typeof abs;
     /**
      * Returns the smallest of the given negative integers.
      *

package/dist/number/branded-types/negative-int.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"negative-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-int.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,IAAI,uBAAuB,EAC3C,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG,uBAAuB,CAAC;AAElD,KAAK,WAAW,GAAG,WAAW,CAAC;AA8B/B;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,6CAAK,CAAC;AAEhC;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;MAAW,CAAC;AAEtC;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;IACtB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;;;;;OASG;sBA7DW,YAAY,CAAC,WAAW,CAAC,KAAG,WAAW;IAgErD;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}
+{"version":3,"file":"negative-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-int.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,IAAI,uBAAuB,EAC3C,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG,uBAAuB,CAAC;AAElD,KAAK,WAAW,GAAG,WAAW,CAAC;AA2B/B,QAAA,MAAM,GAAG,MAAO,YAAY,CAAC,WAAW,CAAC,KAAG,WACP,CAAC;AAEtC;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,6CAAK,CAAC;AAEhC;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;MAAW,CAAC;AAEtC;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;IACtB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}

package/dist/number/branded-types/negative-safe-int.d.mts

@@ -2,6 +2,7 @@ import { type NegativeSafeInt as TtfImported_NegativeSafeInt, type WithSmallInt
 import { PositiveSafeInt } from './positive-safe-int.mjs';
 export type NegativeSafeInt = TtfImported_NegativeSafeInt;
 type ElementType = NegativeSafeInt;
+declare const abs: (x: WithSmallInt<ElementType>) => PositiveSafeInt;
 /**
  * Type guard that checks if a value is a negative safe integer.
  *
@@ -71,7 +72,7 @@ export declare const NegativeSafeInt: {
      * @param a - The negative safe integer value
      * @returns The absolute value as a non-negative `NegativeSafeInt`
      */
-    readonly abs: (x: WithSmallInt<ElementType>) => PositiveSafeInt;
+    readonly abs: typeof abs;
     /**
      * Returns the smallest of the given negative safe integers.
      *

package/dist/number/branded-types/negative-safe-int.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"negative-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,IAAI,2BAA2B,EACnD,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,MAAM,MAAM,eAAe,GAAG,2BAA2B,CAAC;AAE1D,KAAK,WAAW,GAAG,eAAe,CAAC;AA+BnC;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,iDAAK,CAAC;AAEpC;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;MAAW,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;OAOG;sBA9DW,YAAY,CAAC,WAAW,CAAC,KAAG,eAAe;IAiEzD;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}
+{"version":3,"file":"negative-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,IAAI,2BAA2B,EACnD,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,MAAM,MAAM,eAAe,GAAG,2BAA2B,CAAC;AAE1D,KAAK,WAAW,GAAG,eAAe,CAAC;AA4BnC,QAAA,MAAM,GAAG,MAAO,YAAY,CAAC,WAAW,CAAC,KAAG,eACH,CAAC;AAE1C;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,iDAAK,CAAC;AAEpC;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;MAAW,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}

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

@@ -2,6 +2,9 @@ import { type NonNegativeFiniteNumber as TtfImported_NonNegativeFiniteNumber } f
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type NonNegativeFiniteNumber = TtfImported_NonNegativeFiniteNumber;
 type ElementType = NonNegativeFiniteNumber;
+declare const floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+declare const ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+declare const round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
 /**
  * Type guard that checks if a value is a non-negative finite number.
  *
@@ -86,7 +89,7 @@ export declare const NonNegativeFiniteNumber: {
      * @param a - The non-negative finite number value
      * @returns The floored value as an integer
      */
-    readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly floor: typeof floor;
     /**
      * Returns the smallest integer greater than or equal to a non-negative finite
      * number.
@@ -94,7 +97,7 @@ export declare const NonNegativeFiniteNumber: {
      * @param a - The non-negative finite number value
      * @returns The ceiled value as an integer
      */
-    readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly ceil: typeof ceil;
     /**
      * Returns the value of a non-negative finite number rounded to the nearest
      * integer.
@@ -102,7 +105,7 @@ export declare const NonNegativeFiniteNumber: {
      * @param a - The non-negative finite number value
      * @returns The rounded value as an integer
      */
-    readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly round: typeof round;
     /**
      * Generates a random `NonNegativeFiniteNumber` within the given range.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,IAAI,mCAAmC,EAEpE,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,uBAAuB,GAAG,mCAAmC,CAAC;AAE1E,KAAK,WAAW,GAAG,uBAAuB,CAAC;AAiD3C;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,yDAAK,CAAC;AAE5C;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;MAAW,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;wBArGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAuG3D;;;;;;OAMG;uBAxGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA0G3D;;;;;;OAMG;wBA3GA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA6G3D;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,IAAI,mCAAmC,EAEpE,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,uBAAuB,GAAG,mCAAmC,CAAC;AAE1E,KAAK,WAAW,GAAG,uBAAuB,CAAC;AA2B3C,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAE9E,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEgB,CAAC;AAE7E,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAM9E;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,yDAAK,CAAC;AAE5C;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;MAAW,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;CAEK,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"non-positive-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-positive-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,uBAAuB,IAAI,mCAAmC,EAAE,MAAM,eAAe,CAAC;AACpG,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,uBAAuB,GAAG,mCAAmC,CAAC;AAE1E,KAAK,WAAW,GAAG,uBAAuB,CAAC;AA2D3C;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,yDAAK,CAAC;AAE5C;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;MAAW,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;wBAjHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IAiHC;;;;;;OAMG;uBA9GA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IA8GC;;;;;;OAMG;wBA7GA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IA6GC;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}
+{"version":3,"file":"non-positive-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-positive-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,uBAAuB,IAAI,mCAAmC,EAAE,MAAM,eAAe,CAAC;AACpG,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,uBAAuB,GAAG,mCAAmC,CAAC;AAE1E,KAAK,WAAW,GAAG,uBAAuB,CAAC;AAyB3C,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAEJ,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAKzD,CAAC;AAEJ,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,yDAAK,CAAC;AAE5C;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;MAAW,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}