ts-data-forge 8.0.0 → 9.0.1

package/dist/array/impl/array-utils-reducing-value.mjs

@@ -48,124 +48,130 @@ import '../../number/refined-number-utils.mjs';
 import { isNonEmpty } from './array-utils-validation.mjs';
 
 function min(array, comparator) {
-    if (!isNonEmpty(array)) {
-        return none;
-    }
-    const cmp = comparator ?? ((x, y) => Num.from(x) - Num.from(y));
-    return some(array.reduce((currentMin, curr) => (cmp(curr, currentMin) < 0 ? curr : currentMin), array[0]));
+  if (!isNonEmpty(array)) {
+    return none;
+  }
+  const cmp = comparator ?? ((x, y) => Num.from(x) - Num.from(y));
+  return some(
+    array.reduce(
+      (currentMin, curr) => cmp(curr, currentMin) < 0 ? curr : currentMin,
+      array[0]
+    )
+  );
 }
 function max(array, comparator) {
-    const cmp = comparator ?? ((x, y) => Num.from(x) - Num.from(y));
-    // Find max by finding min with an inverted comparator
-    return min(array, (x, y) => -cmp(x, y));
+  const cmp = comparator ?? ((x, y) => Num.from(x) - Num.from(y));
+  return min(array, (x, y) => -cmp(x, y));
 }
 function minBy(array, comparatorValueMapper, comparator) {
-    return min(array, (x, y) => comparator === undefined
-        ? Num.from(comparatorValueMapper(x)) - Num.from(comparatorValueMapper(y))
-        : comparator(comparatorValueMapper(x), comparatorValueMapper(y)));
+  return min(
+    array,
+    (x, y) => comparator === void 0 ? Num.from(comparatorValueMapper(x)) - Num.from(comparatorValueMapper(y)) : comparator(comparatorValueMapper(x), comparatorValueMapper(y))
+  );
 }
 function maxBy(array, comparatorValueMapper, comparator) {
-    return max(array, (x, y) => comparator === undefined
-        ? Num.from(comparatorValueMapper(x)) - Num.from(comparatorValueMapper(y))
-        : comparator(comparatorValueMapper(x), comparatorValueMapper(y)));
+  return max(
+    array,
+    (x, y) => comparator === void 0 ? Num.from(comparatorValueMapper(x)) - Num.from(comparatorValueMapper(y)) : comparator(comparatorValueMapper(x), comparatorValueMapper(y))
+  );
 }
 function count(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, predicate] = args;
-            return array.reduce((acc, curr, index) => predicate(curr, asUint32(index)) ? Uint32.add(acc, 1) : acc, asUint32(0));
-        }
-        case 1: {
-            const [predicate] = args;
-            return (array) => count(array, predicate);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, predicate] = args;
+      return array.reduce(
+        (acc, curr, index) => predicate(curr, asUint32(index)) ? Uint32.add(acc, 1) : acc,
+        asUint32(0)
+      );
+    }
+    case 1: {
+      const [predicate] = args;
+      return (array) => count(array, predicate);
     }
+  }
 }
 function countBy(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, grouper] = args;
-            const mut_groups = new Map();
-            for (const [index, e] of array.entries()) {
-                const key = grouper(e, asUint32(index));
-                const curr = mut_groups.get(key) ?? 0;
-                mut_groups.set(key, asUint32(curr + 1));
-            }
-            return IMap.create(mut_groups);
-        }
-        case 1: {
-            const [grouper] = args;
-            return (array) => countBy(array, grouper);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, grouper] = args;
+      const mut_groups = /* @__PURE__ */ new Map();
+      for (const [index, e] of array.entries()) {
+        const key = grouper(e, asUint32(index));
+        const curr = mut_groups.get(key) ?? 0;
+        mut_groups.set(key, asUint32(curr + 1));
+      }
+      return IMap.create(mut_groups);
     }
+    case 1: {
+      const [grouper] = args;
+      return (array) => countBy(array, grouper);
+    }
+  }
 }
 function foldl(...args) {
-    switch (args.length) {
-        case 3: {
-            const [array, callbackfn, initialValue] = args;
-            return array.reduce((prev, curr, index) => callbackfn(prev, curr, asUint32(index)), initialValue);
-        }
-        case 2: {
-            const [callbackfn, initialValue] = args;
-            return (array) => foldl(array, callbackfn, initialValue);
-        }
+  switch (args.length) {
+    case 3: {
+      const [array, callbackfn, initialValue] = args;
+      return array.reduce(
+        (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
+        initialValue
+      );
+    }
+    case 2: {
+      const [callbackfn, initialValue] = args;
+      return (array) => foldl(array, callbackfn, initialValue);
     }
+  }
 }
 function foldr(...args) {
-    switch (args.length) {
-        case 3: {
-            const [array, callbackfn, initialValue] = args;
-            return array.reduceRight((prev, curr, index) => callbackfn(prev, curr, asUint32(index)), initialValue);
-        }
-        case 2: {
-            const [callbackfn, initialValue] = args;
-            return (array) => foldr(array, callbackfn, initialValue);
-        }
+  switch (args.length) {
+    case 3: {
+      const [array, callbackfn, initialValue] = args;
+      return array.reduceRight(
+        (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
+        initialValue
+      );
     }
+    case 2: {
+      const [callbackfn, initialValue] = args;
+      return (array) => foldr(array, callbackfn, initialValue);
+    }
+  }
 }
 function sum(array) {
-    return array.reduce((prev, curr) => prev + curr, 0);
+  return array.reduce((prev, curr) => prev + curr, 0);
 }
 function sumBy(array, mapFn) {
-    return array.reduce((prev, curr) => prev + mapFn(curr), 0);
+  return array.reduce((prev, curr) => prev + mapFn(curr), 0);
 }
 function join(...args) {
-    switch (args.length) {
-        case 0:
-            return (array) => joinImpl(array, undefined);
-        case 1: {
-            const [arg] = args;
-            if (isString(arg) || isUndefined(arg)) {
-                return (array) => joinImpl(array, arg);
-            }
-            return joinImpl(arg, undefined);
-        }
-        case 2: {
-            const [array, separator] = args;
-            return joinImpl(array, separator);
-        }
+  switch (args.length) {
+    case 0:
+      return (array) => joinImpl(array, void 0);
+    case 1: {
+      const [arg] = args;
+      if (isString(arg) || isUndefined(arg)) {
+        return (array) => joinImpl(array, arg);
+      }
+      return joinImpl(arg, void 0);
+    }
+    case 2: {
+      const [array, separator] = args;
+      return joinImpl(array, separator);
     }
+  }
 }
 const joinImpl = (array, separator) => {
-    try {
-        const result = array.join(separator);
-        return ok(result);
-    }
-    catch (error) {
-        return err(isError(error) ? error : new Error(unknownToString(error)));
-    }
+  try {
+    const result = array.join(separator);
+    return ok(result);
+  } catch (error) {
+    return err(
+      isError(error) ? error : new Error(unknownToString(error))
+    );
+  }
 };
-/**
- * Alias for `foldl`.
- *
- * @see {@link foldl}
- */
 const reduce = foldl;
-/**
- * Alias for `foldr`.
- *
- * @see {@link foldr}
- */
 const reduceRight = foldr;
 
 export { count, countBy, foldl, foldr, join, max, maxBy, min, minBy, reduce, reduceRight, sum, sumBy };

package/dist/array/impl/array-utils-reducing-value.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-reducing-value.mjs","sources":["../../../src/array/impl/array-utils-reducing-value.mts"],"sourcesContent":[null],"names":["Optional.none","Optional.some","Result.ok","Result.err"],"mappings":"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"}
+{"version":3,"file":"array-utils-reducing-value.mjs","sources":["../../../src/array/impl/array-utils-reducing-value.mts"],"sourcesContent":["import { isError } from '@sindresorhus/is';\nimport { type Int, type NonEmptyArray, type Uint } from 'ts-type-forge';\nimport { IMap } from '../../collections/index.mjs';\nimport { Optional, Result } from '../../functional/index.mjs';\nimport { isString, isUndefined } from '../../guard/index.mjs';\nimport { asUint32, Num, Uint32 } from '../../number/index.mjs';\nimport { unknownToString } from '../../others/index.mjs';\nimport {\n  type ArrayIndex,\n  type MapSetKeyType,\n  type SizeType,\n  type Some,\n} from '../../types.mjs';\nimport { isNonEmpty } from './array-utils-validation.mjs';\n\n/**\n * Finds the minimum value in an array.\n *\n * @example\n *\n * ```ts\n * const values = [5, 3, 9] as const;\n *\n * const empty: readonly number[] = [] as const;\n *\n * const smallest = Arr.min(values);\n *\n * const none = Arr.min(empty);\n *\n * const custom = Arr.min(values, (a, b) => b - a);\n *\n * assert.deepStrictEqual(smallest, Optional.some(3));\n *\n * assert.deepStrictEqual(none, Optional.none);\n *\n * assert.deepStrictEqual(custom, Optional.some(9));\n * ```\n */\nexport function min<const Ar extends readonly number[]>(\n  array: Ar,\n  // If the array elements are numbers, comparator is optional.\n  comparator?: (x: Ar[number], y: Ar[number]) => number,\n): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function min<const Ar extends readonly unknown[]>(\n  array: Ar,\n  comparator: (x: Ar[number], y: Ar[number]) => number,\n): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function min<E extends number>(\n  array: readonly E[],\n  comparator?: (x: E, y: E) => number,\n): Optional<E> {\n  if (!isNonEmpty(array)) {\n    return Optional.none;\n  }\n\n  const cmp = comparator ?? ((x, y) => Num.from(x) - Num.from(y));\n\n  return Optional.some(\n    array.reduce(\n      (currentMin, curr) => (cmp(curr, currentMin) < 0 ? curr : currentMin),\n      array[0],\n    ),\n  );\n}\n\n/**\n * Finds the maximum value in an array.\n *\n * @example\n *\n * ```ts\n * const values = [5, 3, 9] as const;\n *\n * const largest = Arr.max(values);\n *\n * const reversed = Arr.max(values, (a, b) => b - a);\n *\n * assert.deepStrictEqual(largest, Optional.some(9));\n *\n * assert.deepStrictEqual(reversed, Optional.some(3));\n * ```\n */\nexport function max<const Ar extends readonly number[]>(\n  array: Ar,\n  // If the array elements are numbers, comparator is optional.\n  comparator?: (x: Ar[number], y: Ar[number]) => number,\n): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function max<const Ar extends readonly unknown[]>(\n  array: Ar,\n  comparator: (x: Ar[number], y: Ar[number]) => number,\n): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function max<E extends number>(\n  array: readonly E[],\n  comparator?: (x: E, y: E) => number,\n): Optional<E> {\n  const cmp = comparator ?? ((x, y) => Num.from(x) - Num.from(y));\n\n  // Find max by finding min with an inverted comparator\n  return min(array, (x, y) => -cmp(x, y));\n}\n\n/**\n * Finds the element with the minimum mapped value.\n *\n * @example\n *\n * ```ts\n * const users = [\n *   { id: 1, visits: 10 },\n *   { id: 2, visits: 3 },\n *   { id: 3, visits: 5 },\n * ] as const;\n *\n * const leastVisits = Arr.minBy(users, (user) => user.visits);\n *\n * const custom = Arr.minBy(\n *   users,\n *   (user) => user.visits,\n *   (a, b) => b - a,\n * );\n *\n * assert.deepStrictEqual(leastVisits, Optional.some({ id: 2, visits: 3 }));\n *\n * assert.deepStrictEqual(custom, Optional.some({ id: 1, visits: 10 }));\n * ```\n */\nexport function minBy<const Ar extends readonly unknown[]>(\n  array: Ar,\n  // If the array elements are mapped to numbers, comparator is optional.\n  comparatorValueMapper: (value: Ar[number]) => number,\n): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function minBy<const Ar extends readonly unknown[], V>(\n  array: Ar,\n  comparatorValueMapper: (value: Ar[number]) => V,\n  comparator: (x: V, y: V) => number,\n): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function minBy<E, V>(\n  array: readonly E[],\n  comparatorValueMapper: (value: E) => V,\n  comparator?: (x: V, y: V) => number,\n): Optional<E> {\n  return min(array, (x, y) =>\n    comparator === undefined\n      ? Num.from(comparatorValueMapper(x)) - Num.from(comparatorValueMapper(y))\n      : comparator(comparatorValueMapper(x), comparatorValueMapper(y)),\n  );\n}\n\n/**\n * Finds the element with the maximum mapped value.\n *\n * @example\n *\n * ```ts\n * const projects = [\n *   { id: 'a', stars: 10 },\n *   { id: 'b', stars: 30 },\n *   { id: 'c', stars: 20 },\n * ] as const;\n *\n * const mostStars = Arr.maxBy(projects, (project) => project.stars);\n *\n * const smallestStars = Arr.maxBy(\n *   projects,\n *   (project) => project.stars,\n *   (a, b) => b - a,\n * );\n *\n * assert.deepStrictEqual(mostStars, Optional.some({ id: 'b', stars: 30 }));\n *\n * assert.deepStrictEqual(\n *   smallestStars,\n *   Optional.some({ id: 'a', stars: 10 }),\n * );\n * ```\n */\nexport function maxBy<const Ar extends readonly unknown[]>(\n  array: Ar,\n  // If the array elements are mapped to numbers, comparator is optional.\n  comparatorValueMapper: (value: Ar[number]) => number,\n): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function maxBy<const Ar extends readonly unknown[], V>(\n  array: Ar,\n  comparatorValueMapper: (value: Ar[number]) => V,\n  comparator: (x: V, y: V) => number,\n): Ar extends NonEmptyArray<unknown> ? Some<Ar[number]> : Optional<Ar[number]>;\n\nexport function maxBy<E, V>(\n  array: readonly E[],\n  comparatorValueMapper: (value: E) => V,\n  comparator?: (x: V, y: V) => number,\n): Optional<E> {\n  return max(array, (x, y) =>\n    comparator === undefined\n      ? Num.from(comparatorValueMapper(x)) - Num.from(comparatorValueMapper(y))\n      : comparator(comparatorValueMapper(x), comparatorValueMapper(y)),\n  );\n}\n\n/**\n * Counts the number of elements that satisfy a predicate.\n *\n * @example\n *\n * ```ts\n * const words = ['Ada', 'Grace', 'Linus'] as const;\n *\n * const longWords = Arr.count(words, (word) => word.length > 4);\n *\n * const withCurried = Arr.count<string>((word) => word.includes('a'))(words);\n *\n * assert.isTrue(longWords === 2);\n *\n * assert.isTrue(withCurried === 2);\n * ```\n */\nexport function count<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): SizeType.Arr;\n\nexport function count<E>(\n  predicate: (value: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => SizeType.Arr;\n\nexport function count<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (value: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (value: E, index: SizeType.Arr) => boolean]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return array.reduce<Uint32>(\n        (acc, curr, index) =>\n          predicate(curr, asUint32(index)) ? Uint32.add(acc, 1) : acc,\n        asUint32(0),\n      );\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => count(array, predicate);\n    }\n  }\n}\n\n/**\n * Groups elements by a key and counts the elements in each group.\n *\n * @example\n *\n * ```ts\n * const words = ['Ada', 'Grace', 'Alan', 'Barbara'] as const;\n *\n * const counts = Arr.countBy(words, (word) => word.at(0));\n *\n * assert.deepStrictEqual(counts.get('A'), Optional.some(2));\n *\n * assert.deepStrictEqual(counts.get('G'), Optional.some(1));\n *\n * assert.deepStrictEqual(counts.get('B'), Optional.some(1));\n * ```\n */\nexport function countBy<\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, ArrayIndex<Ar>>;\n\nexport function countBy<E, G extends MapSetKeyType>(\n  grouper: (value: E, index: SizeType.Arr) => G,\n): (array: readonly E[]) => IMap<G, SizeType.Arr>;\n\nexport function countBy<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, SizeType.Arr> | ((array: readonly E[]) => IMap<G, SizeType.Arr>) {\n  switch (args.length) {\n    case 2: {\n      const [array, grouper] = args;\n\n      const mut_groups = new Map<G, SizeType.Arr>();\n\n      for (const [index, e] of array.entries()) {\n        const key = grouper(e, asUint32(index));\n\n        const curr = mut_groups.get(key) ?? 0;\n\n        mut_groups.set(key, asUint32(curr + 1));\n      }\n\n      return IMap.create(mut_groups);\n    }\n\n    case 1: {\n      const [grouper] = args;\n\n      return (array) => countBy(array, grouper);\n    }\n  }\n}\n\n/**\n * Reduces an array to a single value from left to right.\n *\n * @example\n *\n * ```ts\n * const words = ['Ada', 'Lovelace'] as const;\n *\n * const totalLength = Arr.foldl(words, (acc, word) => acc + word.length, 0);\n *\n * const concat = Arr.foldl<string | number, string>(\n *   (acc, value) => `${acc}-${value}`,\n *   'items',\n * )(words);\n *\n * assert.isTrue(totalLength === 11);\n *\n * assert.isTrue(concat === 'items-Ada-Lovelace');\n * ```\n */\nexport function foldl<const Ar extends readonly unknown[], P>(\n  array: Ar,\n  callbackfn: (\n    previousValue: P,\n    currentValue: Ar[number],\n    currentIndex: ArrayIndex<Ar>,\n  ) => P,\n  initialValue: P,\n): P;\n\nexport function foldl<E, P>(\n  callbackfn: (\n    previousValue: P,\n    currentValue: E,\n    currentIndex: SizeType.Arr,\n  ) => P,\n  initialValue: P,\n): (array: readonly E[]) => P;\n\nexport function foldl<E, P>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        callbackfn: (\n          previousValue: P,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => P,\n        initialValue: P,\n      ]\n    | readonly [\n        callbackfn: (\n          previousValue: P,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => P,\n        initialValue: P,\n      ]\n): P | ((array: readonly E[]) => P) {\n  switch (args.length) {\n    case 3: {\n      const [array, callbackfn, initialValue] = args;\n\n      return array.reduce(\n        (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),\n        initialValue,\n      );\n    }\n\n    case 2: {\n      const [callbackfn, initialValue] = args;\n\n      return (array) => foldl(array, callbackfn, initialValue);\n    }\n  }\n}\n\n/**\n * Reduces an array to a single value from right to left.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3] as const;\n *\n * const subtractRight = Arr.foldr(numbers, (acc, value) => acc - value, 0);\n *\n * const joinFromRight = Arr.foldr<number, string>(\n *   (acc, value) => `${acc}${value}`,\n *   '',\n * )(numbers);\n *\n * assert.isTrue(subtractRight === -6);\n *\n * assert.isTrue(joinFromRight === '321');\n * ```\n */\nexport function foldr<const Ar extends readonly unknown[], P>(\n  array: Ar,\n  callbackfn: (\n    previousValue: P,\n    currentValue: Ar[number],\n    currentIndex: ArrayIndex<Ar>,\n  ) => P,\n  initialValue: P,\n): P;\n\nexport function foldr<E, P>(\n  callbackfn: (\n    previousValue: P,\n    currentValue: E,\n    currentIndex: SizeType.Arr,\n  ) => P,\n  initialValue: P,\n): (array: readonly E[]) => P;\n\nexport function foldr<E, P>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        callbackfn: (\n          previousValue: P,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => P,\n        initialValue: P,\n      ]\n    | readonly [\n        callbackfn: (\n          previousValue: P,\n          currentValue: E,\n          currentIndex: SizeType.Arr,\n        ) => P,\n        initialValue: P,\n      ]\n): P | ((array: readonly E[]) => P) {\n  switch (args.length) {\n    case 3: {\n      const [array, callbackfn, initialValue] = args;\n\n      return array.reduceRight(\n        (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),\n        initialValue,\n      );\n    }\n\n    case 2: {\n      const [callbackfn, initialValue] = args;\n\n      return (array) => foldr(array, callbackfn, initialValue);\n    }\n  }\n}\n\n/**\n * Calculates the sum of numbers in an array.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3, 4] as const;\n *\n * const negatives = [3, -2, 5] as const;\n *\n * const total = Arr.sum(numbers);\n *\n * const totalNegatives = Arr.sum(negatives);\n *\n * assert.isTrue(total === 10);\n *\n * assert.isTrue(totalNegatives === 6);\n * ```\n */\nexport function sum(array: readonly []): 0;\n\nexport function sum<N extends number>(array: readonly [N]): N;\n\nexport function sum(array: readonly Uint[]): Uint;\n\nexport function sum(array: readonly Int[]): Int;\n\nexport function sum(array: readonly number[]): number;\n\nexport function sum(array: readonly number[]): number {\n  return array.reduce((prev, curr) => prev + curr, 0);\n}\n\n/**\n * Calculates the sum of values in an array by applying a mapping function to each element.\n *\n * @example\n *\n * ```ts\n * const numbers = [\n *   { value: 1 },\n *   { value: 2 },\n *   { value: 3 },\n *   { value: 4 },\n * ] as const;\n *\n * const negatives = [{ value: 3 }, { value: -2 }, { value: 5 }] as const;\n *\n * const total = Arr.sumBy(numbers, (item) => item.value);\n *\n * const totalNegatives = Arr.sumBy(negatives, (item) => item.value);\n *\n * assert.isTrue(total === 10);\n *\n * assert.isTrue(totalNegatives === 6);\n * ```\n */\nexport function sumBy(array: readonly [], mapFn: (item: unknown) => number): 0;\n\nexport function sumBy<N extends Uint, E>(\n  array: readonly E[],\n  mapFn: (item: E) => N,\n): Uint;\n\nexport function sumBy<N extends Int, E>(\n  array: readonly E[],\n  mapFn: (item: E) => N,\n): Int;\n\nexport function sumBy<N extends number, E>(\n  array: readonly E[],\n  mapFn: (item: E) => N,\n): number;\n\nexport function sumBy<N extends number, E>(\n  array: readonly E[],\n  mapFn: (item: E) => N,\n): number {\n  return array.reduce((prev, curr) => prev + mapFn(curr), 0);\n}\n\n/**\n * Joins array elements into a string.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 3] as const;\n *\n * const defaultSeparator = Arr.join(numbers);\n *\n * const hyphenSeparated = Arr.join(numbers, '-');\n *\n * assert.deepStrictEqual(defaultSeparator, Result.ok('1,2,3'));\n *\n * assert.deepStrictEqual(hyphenSeparated, Result.ok('1-2-3'));\n * ```\n */\nexport function join(\n  array: readonly unknown[],\n  separator?: string,\n): Result<string, Error>;\n\nexport function join(\n  separator?: string,\n): (array: readonly unknown[]) => Result<string, Error>;\n\nexport function join(\n  ...args:\n    | readonly [array: readonly unknown[], separator?: string]\n    | readonly [separator?: string]\n):\n  | Result<string, Error>\n  | ((array: readonly unknown[]) => Result<string, Error>) {\n  switch (args.length) {\n    case 0:\n      return (array) => joinImpl(array, undefined);\n\n    case 1: {\n      const [arg] = args;\n\n      if (isString(arg) || isUndefined(arg)) {\n        return (array) => joinImpl(array, arg);\n      }\n\n      return joinImpl(arg, undefined);\n    }\n\n    case 2: {\n      const [array, separator] = args;\n\n      return joinImpl(array, separator);\n    }\n  }\n}\n\nconst joinImpl = (\n  array: readonly unknown[],\n  separator: string | undefined,\n): Result<string, Error> => {\n  try {\n    const result = array.join(separator);\n\n    return Result.ok(result);\n  } catch (error) {\n    return Result.err(\n      isError(error) ? error : new Error(unknownToString(error)),\n    );\n  }\n};\n\n/**\n * Alias for `foldl`.\n *\n * @see {@link foldl}\n */\nexport const reduce = foldl;\n\n/**\n * Alias for `foldr`.\n *\n * @see {@link foldr}\n */\nexport const reduceRight = foldr;\n"],"names":["Optional.none","Optional.some","Result.ok","Result.err"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDO,SAAS,GAAA,CACd,OACA,UAAA,EACa;AACb,EAAA,IAAI,CAAC,UAAA,CAAW,KAAK,CAAA,EAAG;AACtB,IAAA,OAAOA,IAAS;AAAA,EAClB;AAEA,EAAA,MAAM,GAAA,GAAM,UAAA,KAAe,CAAC,CAAA,EAAG,CAAA,KAAM,GAAA,CAAI,IAAA,CAAK,CAAC,CAAA,GAAI,GAAA,CAAI,IAAA,CAAK,CAAC,CAAA,CAAA;AAE7D,EAAA,OAAOC,IAAS;AAAA,IACd,KAAA,CAAM,MAAA;AAAA,MACJ,CAAC,YAAY,IAAA,KAAU,GAAA,CAAI,MAAM,UAAU,CAAA,GAAI,IAAI,IAAA,GAAO,UAAA;AAAA,MAC1D,MAAM,CAAC;AAAA;AACT,GACF;AACF;AA8BO,SAAS,GAAA,CACd,OACA,UAAA,EACa;AACb,EAAA,MAAM,GAAA,GAAM,UAAA,KAAe,CAAC,CAAA,EAAG,CAAA,KAAM,GAAA,CAAI,IAAA,CAAK,CAAC,CAAA,GAAI,GAAA,CAAI,IAAA,CAAK,CAAC,CAAA,CAAA;AAG7D,EAAA,OAAO,GAAA,CAAI,OAAO,CAAC,CAAA,EAAG,MAAM,CAAC,GAAA,CAAI,CAAA,EAAG,CAAC,CAAC,CAAA;AACxC;AAuCO,SAAS,KAAA,CACd,KAAA,EACA,qBAAA,EACA,UAAA,EACa;AACb,EAAA,OAAO,GAAA;AAAA,IAAI,KAAA;AAAA,IAAO,CAAC,GAAG,CAAA,KACpB,UAAA,KAAe,SACX,GAAA,CAAI,IAAA,CAAK,qBAAA,CAAsB,CAAC,CAAC,CAAA,GAAI,IAAI,IAAA,CAAK,qBAAA,CAAsB,CAAC,CAAC,CAAA,GACtE,UAAA,CAAW,sBAAsB,CAAC,CAAA,EAAG,qBAAA,CAAsB,CAAC,CAAC;AAAA,GACnE;AACF;AA0CO,SAAS,KAAA,CACd,KAAA,EACA,qBAAA,EACA,UAAA,EACa;AACb,EAAA,OAAO,GAAA;AAAA,IAAI,KAAA;AAAA,IAAO,CAAC,GAAG,CAAA,KACpB,UAAA,KAAe,SACX,GAAA,CAAI,IAAA,CAAK,qBAAA,CAAsB,CAAC,CAAC,CAAA,GAAI,IAAI,IAAA,CAAK,qBAAA,CAAsB,CAAC,CAAC,CAAA,GACtE,UAAA,CAAW,sBAAsB,CAAC,CAAA,EAAG,qBAAA,CAAsB,CAAC,CAAC;AAAA,GACnE;AACF;AA4BO,SAAS,SACX,IAAA,EAMqD;AACxD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,SAAS,CAAA,GAAI,IAAA;AAE3B,MAAA,OAAO,KAAA,CAAM,MAAA;AAAA,QACX,CAAC,GAAA,EAAK,IAAA,EAAM,KAAA,KACV,UAAU,IAAA,EAAM,QAAA,CAAS,KAAK,CAAC,CAAA,GAAI,MAAA,CAAO,GAAA,CAAI,GAAA,EAAK,CAAC,CAAA,GAAI,GAAA;AAAA,QAC1D,SAAS,CAAC;AAAA,OACZ;AAAA,IACF;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;AA+BO,SAAS,WACX,IAAA,EAMuE;AAC1E,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,OAAO,CAAA,GAAI,IAAA;AAEzB,MAAA,MAAM,UAAA,uBAAiB,GAAA,EAAqB;AAE5C,MAAA,KAAA,MAAW,CAAC,KAAA,EAAO,CAAC,CAAA,IAAK,KAAA,CAAM,SAAQ,EAAG;AACxC,QAAA,MAAM,GAAA,GAAM,OAAA,CAAQ,CAAA,EAAG,QAAA,CAAS,KAAK,CAAC,CAAA;AAEtC,QAAA,MAAM,IAAA,GAAO,UAAA,CAAW,GAAA,CAAI,GAAG,CAAA,IAAK,CAAA;AAEpC,QAAA,UAAA,CAAW,GAAA,CAAI,GAAA,EAAK,QAAA,CAAS,IAAA,GAAO,CAAC,CAAC,CAAA;AAAA,MACxC;AAEA,MAAA,OAAO,IAAA,CAAK,OAAO,UAAU,CAAA;AAAA,IAC/B;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,OAAO,CAAA,GAAI,IAAA;AAElB,MAAA,OAAO,CAAC,KAAA,KAAU,OAAA,CAAQ,KAAA,EAAO,OAAO,CAAA;AAAA,IAC1C;AAAA;AAEJ;AAyCO,SAAS,SACX,IAAA,EAkB+B;AAClC,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,UAAA,EAAY,YAAY,CAAA,GAAI,IAAA;AAE1C,MAAA,OAAO,KAAA,CAAM,MAAA;AAAA,QACX,CAAC,MAAM,IAAA,EAAM,KAAA,KAAU,WAAW,IAAA,EAAM,IAAA,EAAM,QAAA,CAAS,KAAK,CAAC,CAAA;AAAA,QAC7D;AAAA,OACF;AAAA,IACF;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,UAAA,EAAY,YAAY,CAAA,GAAI,IAAA;AAEnC,MAAA,OAAO,CAAC,KAAA,KAAU,KAAA,CAAM,KAAA,EAAO,YAAY,YAAY,CAAA;AAAA,IACzD;AAAA;AAEJ;AAyCO,SAAS,SACX,IAAA,EAkB+B;AAClC,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,UAAA,EAAY,YAAY,CAAA,GAAI,IAAA;AAE1C,MAAA,OAAO,KAAA,CAAM,WAAA;AAAA,QACX,CAAC,MAAM,IAAA,EAAM,KAAA,KAAU,WAAW,IAAA,EAAM,IAAA,EAAM,QAAA,CAAS,KAAK,CAAC,CAAA;AAAA,QAC7D;AAAA,OACF;AAAA,IACF;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,UAAA,EAAY,YAAY,CAAA,GAAI,IAAA;AAEnC,MAAA,OAAO,CAAC,KAAA,KAAU,KAAA,CAAM,KAAA,EAAO,YAAY,YAAY,CAAA;AAAA,IACzD;AAAA;AAEJ;AA+BO,SAAS,IAAI,KAAA,EAAkC;AACpD,EAAA,OAAO,MAAM,MAAA,CAAO,CAAC,MAAM,IAAA,KAAS,IAAA,GAAO,MAAM,CAAC,CAAA;AACpD;AA2CO,SAAS,KAAA,CACd,OACA,KAAA,EACQ;AACR,EAAA,OAAO,KAAA,CAAM,OAAO,CAAC,IAAA,EAAM,SAAS,IAAA,GAAO,KAAA,CAAM,IAAI,CAAA,EAAG,CAAC,CAAA;AAC3D;AA4BO,SAAS,QACX,IAAA,EAKsD;AACzD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,QAAA,CAAS,KAAA,EAAO,MAAS,CAAA;AAAA,IAE7C,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,GAAG,CAAA,GAAI,IAAA;AAEd,MAAA,IAAI,QAAA,CAAS,GAAG,CAAA,IAAK,WAAA,CAAY,GAAG,CAAA,EAAG;AACrC,QAAA,OAAO,CAAC,KAAA,KAAU,QAAA,CAAS,KAAA,EAAO,GAAG,CAAA;AAAA,MACvC;AAEA,MAAA,OAAO,QAAA,CAAS,KAAK,MAAS,CAAA;AAAA,IAChC;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,SAAS,CAAA,GAAI,IAAA;AAE3B,MAAA,OAAO,QAAA,CAAS,OAAO,SAAS,CAAA;AAAA,IAClC;AAAA;AAEJ;AAEA,MAAM,QAAA,GAAW,CACf,KAAA,EACA,SAAA,KAC0B;AAC1B,EAAA,IAAI;AACF,IAAA,MAAM,MAAA,GAAS,KAAA,CAAM,IAAA,CAAK,SAAS,CAAA;AAEnC,IAAA,OAAOC,GAAU,MAAM,CAAA;AAAA,EACzB,SAAS,KAAA,EAAO;AACd,IAAA,OAAOC,GAAO;AAAA,MACZ,OAAA,CAAQ,KAAK,CAAA,GAAI,KAAA,GAAQ,IAAI,KAAA,CAAM,eAAA,CAAgB,KAAK,CAAC;AAAA,KAC3D;AAAA,EACF;AACF,CAAA;AAOO,MAAM,MAAA,GAAS;AAOf,MAAM,WAAA,GAAc;;;;"}

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

@@ -40,120 +40,128 @@ import '../../number/num.mjs';
 import '../../number/refined-number-utils.mjs';
 
 function find(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, predicate] = args;
-            const foundIndex = array.findIndex(
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            predicate);
-            return foundIndex === -1
-                ? none
-                : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    some(array[foundIndex]);
-        }
-        case 1: {
-            const [predicate] = args;
-            return (array) => find(array, predicate);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, predicate] = args;
+      const foundIndex = array.findIndex(
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        predicate
+      );
+      return foundIndex === -1 ? none : (
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        some(array[foundIndex])
+      );
     }
+    case 1: {
+      const [predicate] = args;
+      return (array) => find(array, predicate);
+    }
+  }
 }
 function findLast(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, predicate] = args;
-            const foundIndex = array.findLastIndex(
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            predicate);
-            return foundIndex === -1
-                ? none
-                : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    some(array[foundIndex]);
-        }
-        case 1: {
-            const [predicate] = args;
-            return (array) => findLast(array, predicate);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, predicate] = args;
+      const foundIndex = array.findLastIndex(
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        predicate
+      );
+      return foundIndex === -1 ? none : (
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        some(array[foundIndex])
+      );
+    }
+    case 1: {
+      const [predicate] = args;
+      return (array) => findLast(array, predicate);
     }
+  }
 }
 function findIndex(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, predicate] = args;
-            return pipe(array.findIndex(
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            predicate)).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
-        }
-        case 1: {
-            const [predicate] = args;
-            return (array) => findIndex(array, predicate);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, predicate] = args;
+      return pipe(
+        array.findIndex(
+          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+          predicate
+        )
+      ).map((idx) => idx >= 0 ? asUint32(idx) : -1).value;
     }
+    case 1: {
+      const [predicate] = args;
+      return (array) => findIndex(array, predicate);
+    }
+  }
 }
 function findLastIndex(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, predicate] = args;
-            return pipe(array.findLastIndex(
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            predicate)).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
-        }
-        case 1: {
-            const [predicate] = args;
-            return (array) => findLastIndex(array, predicate);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, predicate] = args;
+      return pipe(
+        array.findLastIndex(
+          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+          predicate
+        )
+      ).map((idx) => idx >= 0 ? asUint32(idx) : -1).value;
+    }
+    case 1: {
+      const [predicate] = args;
+      return (array) => findLastIndex(array, predicate);
     }
+  }
 }
 function indexOf(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, searchElement] = args;
-            const index = array.indexOf(searchElement);
-            return index !== -1 ? asUint32(index) : -1;
-        }
-        case 1: {
-            const [searchElement] = args;
-            return (array) => indexOf(array, searchElement);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, searchElement] = args;
+      const index = array.indexOf(searchElement);
+      return index !== -1 ? asUint32(index) : -1;
     }
+    case 1: {
+      const [searchElement] = args;
+      return (array) => indexOf(array, searchElement);
+    }
+  }
 }
 function indexOfFrom(...args) {
-    switch (args.length) {
-        case 3: {
-            const [array, searchElement, fromIndex] = args;
-            const index = array.indexOf(searchElement, fromIndex);
-            return index !== -1 ? asUint32(index) : -1;
-        }
-        case 2: {
-            const [searchElement, fromIndex] = args;
-            return (array) => indexOfFrom(array, searchElement, fromIndex);
-        }
+  switch (args.length) {
+    case 3: {
+      const [array, searchElement, fromIndex] = args;
+      const index = array.indexOf(searchElement, fromIndex);
+      return index !== -1 ? asUint32(index) : -1;
+    }
+    case 2: {
+      const [searchElement, fromIndex] = args;
+      return (array) => indexOfFrom(array, searchElement, fromIndex);
     }
+  }
 }
 function lastIndexOf(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, searchElement] = args;
-            const index = array.lastIndexOf(searchElement);
-            return index !== -1 ? asUint32(index) : -1;
-        }
-        case 1: {
-            const [searchElement] = args;
-            return (array) => lastIndexOf(array, searchElement);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, searchElement] = args;
+      const index = array.lastIndexOf(searchElement);
+      return index !== -1 ? asUint32(index) : -1;
     }
+    case 1: {
+      const [searchElement] = args;
+      return (array) => lastIndexOf(array, searchElement);
+    }
+  }
 }
 function lastIndexOfFrom(...args) {
-    switch (args.length) {
-        case 3: {
-            const [array, searchElement, fromIndex] = args;
-            const index = array.lastIndexOf(searchElement, fromIndex);
-            return index !== -1 ? asUint32(index) : -1;
-        }
-        case 2: {
-            const [searchElement, fromIndex] = args;
-            return (array) => lastIndexOfFrom(array, searchElement, fromIndex);
-        }
+  switch (args.length) {
+    case 3: {
+      const [array, searchElement, fromIndex] = args;
+      const index = array.lastIndexOf(searchElement, fromIndex);
+      return index !== -1 ? asUint32(index) : -1;
+    }
+    case 2: {
+      const [searchElement, fromIndex] = args;
+      return (array) => lastIndexOfFrom(array, searchElement, fromIndex);
     }
+  }
 }
 
 export { find, findIndex, findLast, findLastIndex, indexOf, indexOfFrom, lastIndexOf, lastIndexOfFrom };

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

@@ -1 +1 @@
-{"version":3,"file":"array-utils-search.mjs","sources":["../../../src/array/impl/array-utils-search.mts"],"sourcesContent":[null],"names":["Optional.none","Optional.some"],"mappings":"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"}
+{"version":3,"file":"array-utils-search.mjs","sources":["../../../src/array/impl/array-utils-search.mts"],"sourcesContent":["import { expectType } from '../../expect-type.mjs';\nimport { Optional, pipe } from '../../functional/index.mjs';\nimport { asUint32 } from '../../number/index.mjs';\nimport {\n  type ArgArrayIndexWithNegative,\n  type ArrayIndex,\n  type SizeType,\n} from '../../types.mjs';\n\n/**\n * Finds the first element that satisfies a predicate.\n *\n * @example\n *\n * ```ts\n * const users = [\n *   { id: 1, name: 'Ada' },\n *   { id: 2, name: 'Grace' },\n * ] as const;\n *\n * const found = Arr.find(users, (user) => user.id === 2);\n *\n * const missing = Arr.find<Readonly<{ id: number }>>((user) => user.id === 3)(\n *   users,\n * );\n *\n * assert.deepStrictEqual(found, Optional.some({ id: 2, name: 'Grace' }));\n *\n * assert.deepStrictEqual(missing, Optional.none);\n * ```\n */\nexport function find<E, F extends E>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => value is F,\n): Optional<F>;\n\nexport function find<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean,\n): Optional<Ar[number]>;\n\nexport function find<E>(\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): (array: readonly E[]) => Optional<E>;\n\nexport function find<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n    | readonly [\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n): Optional<E> | ((array: readonly E[]) => Optional<E>) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      const foundIndex = array.findIndex(\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        predicate as () => boolean,\n      );\n\n      expectType<\n        Parameters<typeof array.findIndex>[0],\n        (value: E, index: number, arr: readonly E[]) => unknown\n      >('=');\n\n      expectType<\n        typeof predicate,\n        (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean\n      >('=');\n\n      return foundIndex === -1\n        ? Optional.none\n        : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n          Optional.some(array[foundIndex]!);\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      expectType<\n        typeof predicate,\n        (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean\n      >('=');\n\n      return (array) => find(array, predicate);\n    }\n  }\n}\n\n/**\n * Finds the last element that satisfies a predicate.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 3, 2, 4, 5] as const;\n *\n * const lastEven = Arr.findLast(numbers, (n) => n % 2 === 0);\n *\n * const none = Arr.findLast<number>((n) => n > 10)(numbers);\n *\n * assert.deepStrictEqual(lastEven, Optional.some(4));\n *\n * assert.deepStrictEqual(none, Optional.none);\n * ```\n */\nexport function findLast<E, F extends E>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => value is F,\n): Optional<F>;\n\nexport function findLast<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean,\n): Optional<Ar[number]>;\n\nexport function findLast<E>(\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): (array: readonly E[]) => Optional<E>;\n\nexport function findLast<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n    | readonly [\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n): Optional<E> | ((array: readonly E[]) => Optional<E>) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      const foundIndex = array.findLastIndex(\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        predicate as () => boolean,\n      );\n\n      expectType<\n        Parameters<typeof array.findIndex>[0],\n        (value: E, index: number, arr: readonly E[]) => unknown\n      >('=');\n\n      expectType<\n        typeof predicate,\n        (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean\n      >('=');\n\n      return foundIndex === -1\n        ? Optional.none\n        : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n          Optional.some(array[foundIndex]!);\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      expectType<\n        typeof predicate,\n        (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean\n      >('=');\n\n      return (array) => findLast(array, predicate);\n    }\n  }\n}\n\n/**\n * Finds the index of the first element that satisfies a predicate.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c'] as const;\n *\n * const indexOfB = Arr.findIndex(letters, (letter) => letter === 'b');\n *\n * const indexOfMissing = Arr.findIndex<string>((letter) => letter === 'z')(\n *   letters,\n * );\n *\n * assert.isTrue(indexOfB === 1);\n *\n * assert.isTrue(indexOfMissing === -1);\n * ```\n */\nexport function findIndex<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean,\n): ArrayIndex<Ar> | -1;\n\nexport function findIndex<E>(\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function findIndex<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n    | readonly [\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return pipe(\n        array.findIndex(\n          // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n          predicate as (value: E, index: number) => boolean,\n        ),\n      ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => findIndex(array, predicate);\n    }\n  }\n}\n\n/**\n * Finds the index of the last element that satisfies a predicate.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c', 'b'] as const;\n *\n * const lastIndexOfB = Arr.findLastIndex(letters, (letter) => letter === 'b');\n *\n * const notFound = Arr.findLastIndex<string>((letter) => letter === 'z')(\n *   letters,\n * );\n *\n * assert.isTrue(lastIndexOfB === 3);\n *\n * assert.isTrue(notFound === -1);\n * ```\n */\nexport function findLastIndex<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (value: Ar[number], index: ArrayIndex<Ar>, arr: Ar) => boolean,\n): ArrayIndex<Ar> | -1;\n\nexport function findLastIndex<E>(\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function findLastIndex<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n    | readonly [\n        predicate: (\n          value: E,\n          index: SizeType.Arr,\n          arr: readonly E[],\n        ) => boolean,\n      ]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return pipe(\n        array.findLastIndex(\n          // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n          predicate as (value: E, index: number) => boolean,\n        ),\n      ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => findLastIndex(array, predicate);\n    }\n  }\n}\n\n/**\n * Gets the index of a value in an array.\n *\n * @example\n *\n * ```ts\n * const fruits = ['apple', 'banana', 'orange', 'banana'] as readonly string[];\n *\n * const indexOfBanana = Arr.indexOf(fruits, 'banana');\n *\n * const indexOfGrape = Arr.indexOf(fruits, 'grape');\n *\n * // Curried version\n * const findApple = Arr.indexOf('apple');\n *\n * const indexOfApple = findApple(fruits);\n *\n * console.log(indexOfBanana); // => 1\n *\n * console.log(indexOfGrape); // => -1\n *\n * console.log(indexOfApple); // => 0\n * ```\n */\nexport function indexOf<const Ar extends readonly unknown[]>(\n  array: Ar,\n  searchElement: Ar[number],\n): ArrayIndex<Ar> | -1;\n\nexport function indexOf<E>(\n  searchElement: E,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function indexOf<E>(\n  ...args:\n    | readonly [array: readonly E[], searchElement: E]\n    | readonly [searchElement: E]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 2: {\n      const [array, searchElement] = args;\n\n      const index = array.indexOf(searchElement);\n\n      return index !== -1 ? asUint32(index) : -1;\n    }\n\n    case 1: {\n      const [searchElement] = args;\n\n      return (array) => indexOf(array, searchElement);\n    }\n  }\n}\n\n/**\n * Gets the index of a value in an array, starting from a specified index.\n *\n * @example\n *\n * ```ts\n * const fruits = ['apple', 'banana', 'orange', 'banana'] as readonly string[];\n *\n * // Search for 'banana' starting from index 1\n * const firstBanana = Arr.indexOfFrom(fruits, 'banana', 1);\n *\n * // Search for 'banana' starting from index 2\n * const secondBanana = Arr.indexOfFrom(fruits, 'banana', 2);\n *\n * // Element not found\n * const notFound = Arr.indexOfFrom(fruits, 'grape', 0);\n *\n * // Curried version\n * const findBananaFrom2 = Arr.indexOfFrom('banana', 2);\n *\n * const index = findBananaFrom2(fruits);\n *\n * console.log(firstBanana); // => 1\n *\n * console.log(secondBanana); // => 3\n *\n * console.log(notFound); // => -1\n *\n * console.log(index); // => 3\n * ```\n */\nexport function indexOfFrom<const Ar extends readonly unknown[]>(\n  array: Ar,\n  searchElement: Ar[number],\n  fromIndex: ArgArrayIndexWithNegative<Ar>,\n): ArrayIndex<Ar> | -1;\n\nexport function indexOfFrom<E>(\n  searchElement: E,\n  fromIndex: SizeType.ArgArrWithNegative,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function indexOfFrom<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        searchElement: E,\n        fromIndex: SizeType.ArgArrWithNegative,\n      ]\n    | readonly [searchElement: E, fromIndex: SizeType.ArgArrWithNegative]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 3: {\n      const [array, searchElement, fromIndex] = args;\n\n      const index = array.indexOf(searchElement, fromIndex);\n\n      return index !== -1 ? asUint32(index) : -1;\n    }\n\n    case 2: {\n      const [searchElement, fromIndex] = args;\n\n      return (array) => indexOfFrom(array, searchElement, fromIndex);\n    }\n  }\n}\n\n/**\n * Gets the last index of a value in an array.\n *\n * @example\n *\n * ```ts\n * const fruits = ['apple', 'banana', 'orange', 'banana'] as readonly string[];\n *\n * const lastBanana = Arr.lastIndexOf(fruits, 'banana');\n *\n * const lastApple = Arr.lastIndexOf(fruits, 'apple');\n *\n * const notFound = Arr.lastIndexOf(fruits, 'grape');\n *\n * // Curried version\n * const findLastBanana = Arr.lastIndexOf('banana');\n *\n * const index = findLastBanana(fruits);\n *\n * console.log(lastBanana); // => 3\n *\n * console.log(lastApple); // => 0\n *\n * console.log(notFound); // => -1\n *\n * console.log(index); // => 3\n * ```\n */\nexport function lastIndexOf<const Ar extends readonly unknown[]>(\n  array: Ar,\n  searchElement: Ar[number],\n): ArrayIndex<Ar> | -1;\n\nexport function lastIndexOf<E>(\n  searchElement: E,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function lastIndexOf<E>(\n  ...args:\n    | readonly [array: readonly E[], searchElement: E]\n    | readonly [searchElement: E]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 2: {\n      const [array, searchElement] = args;\n\n      const index = array.lastIndexOf(searchElement);\n\n      return index !== -1 ? asUint32(index) : -1;\n    }\n\n    case 1: {\n      const [searchElement] = args;\n\n      return (array) => lastIndexOf(array, searchElement);\n    }\n  }\n}\n\n/**\n * Gets the last index of a value in an array, starting from a specified index.\n *\n * @example\n *\n * ```ts\n * const fruits = ['apple', 'banana', 'orange', 'banana', 'grape'] as const;\n *\n * // Search backwards for 'banana' from index 3\n * const lastBananaFrom3 = Arr.lastIndexOfFrom(fruits, 'banana', 3);\n *\n * // Search backwards for 'banana' from index 2\n * const lastBananaFrom2 = Arr.lastIndexOfFrom(fruits, 'banana', 2);\n *\n * // Element not found\n * const notFound = Arr.lastIndexOfFrom(fruits, 'grape', 2);\n *\n * // Curried version\n * const findBananaFrom3 = Arr.lastIndexOfFrom('banana', 3);\n *\n * const index = findBananaFrom3(fruits);\n *\n * console.log(lastBananaFrom3); // => 3\n *\n * console.log(lastBananaFrom2); // => 1\n *\n * console.log(notFound); // => -1\n *\n * console.log(index); // => 3\n * ```\n */\nexport function lastIndexOfFrom<const Ar extends readonly unknown[]>(\n  array: Ar,\n  searchElement: Ar[number],\n  fromIndex: ArgArrayIndexWithNegative<Ar>,\n): ArrayIndex<Ar> | -1;\n\nexport function lastIndexOfFrom<E>(\n  searchElement: E,\n  fromIndex: SizeType.ArgArrWithNegative,\n): (array: readonly E[]) => SizeType.Arr | -1;\n\nexport function lastIndexOfFrom<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        searchElement: E,\n        fromIndex: SizeType.ArgArrWithNegative,\n      ]\n    | readonly [searchElement: E, fromIndex: SizeType.ArgArrWithNegative]\n): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {\n  switch (args.length) {\n    case 3: {\n      const [array, searchElement, fromIndex] = args;\n\n      const index = array.lastIndexOf(searchElement, fromIndex);\n\n      return index !== -1 ? asUint32(index) : -1;\n    }\n\n    case 2: {\n      const [searchElement, fromIndex] = args;\n\n      return (array) => lastIndexOfFrom(array, searchElement, fromIndex);\n    }\n  }\n}\n"],"names":["Optional.none","Optional.some"],"mappings":"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"}

package/dist/array/impl/array-utils-set-op.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-set-op.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-set-op.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAClB,QAAQ,SAAS,CAAC,EAAE,EACpB,QAAQ,SAAS,CAAC,EAAE,EACpB,WAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAmB,KAC5C,OAG8C,CAAC;AAElD;;;;GAIG;AACH,eAAO,MAAM,KAAK,GAdC,CAAC,UACV,SAAS,CAAC,EAAE,UACZ,SAAS,CAAC,EAAE,aACV,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,KAChC,OAUoB,CAAC;AAExB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ,GAAI,EAAE,SAAS,SAAS,EAAE,EAAE,SAAS,SAAS,GAAG,EAAE,EACtE,QAAQ,SAAS,EAAE,EAAE,EACrB,QAAQ,SAAS,EAAE,EAAE,KACpB,OAIA,CAAC;AAEJ;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,GAAI,EAAE,SAAS,SAAS,EAAE,EAAE,SAAS,SAAS,GAAG,EAAE,EACxE,QAAQ,SAAS,EAAE,EAAE,EACrB,QAAQ,SAAS,EAAE,EAAE,KACpB,OAAmC,CAAC;AAEvC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,GAC1B,EAAE,SAAS,SAAS,EACpB,EAAE,SAAS,SAAS,GAAG,EAAE,EAEzB,QAAQ,SAAS,EAAE,EAAE,EACrB,QAAQ,SAAS,EAAE,EAAE,KACpB,SAAS,CAAC,EAAE,GAAG,EAAE,CAAC,EAE+C,CAAC;AAErE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,SAAS,EAC/C,QAAQ,SAAS,CAAC,EAAE,EACpB,QAAQ,SAAS,CAAC,EAAE,KACnB,SAAS,CAAC,EAA+C,CAAC;AAE7D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,MAAM,EACrD,aAAa,SAAS,CAAC,EAAE,EACzB,aAAa,SAAS,CAAC,EAAE,KACxB,SAAS,CAAC,EAoCZ,CAAC"}
+{"version":3,"file":"array-utils-set-op.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-set-op.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,UACV,SAAS,CAAC,EAAE,UACZ,SAAS,CAAC,EAAE,aACV,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,KAChC,OAG8C,CAAC;AAElD;;;;GAIG;AACH,eAAO,MAAM,KAAK,GAdC,CAAC,UACV,SAAS,CAAC,EAAE,UACZ,SAAS,CAAC,EAAE,aACV,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,KAChC,OAUoB,CAAC;AAExB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ,GAAI,EAAE,SAAS,SAAS,EAAE,EAAE,SAAS,SAAS,GAAG,EAAE,UAC9D,SAAS,EAAE,EAAE,UACb,SAAS,EAAE,EAAE,KACpB,OAIA,CAAC;AAEJ;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,GAAI,EAAE,SAAS,SAAS,EAAE,EAAE,SAAS,SAAS,GAAG,EAAE,UAChE,SAAS,EAAE,EAAE,UACb,SAAS,EAAE,EAAE,KACpB,OAAmC,CAAC;AAEvC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,GAC1B,EAAE,SAAS,SAAS,EACpB,EAAE,SAAS,SAAS,GAAG,EAAE,UAEjB,SAAS,EAAE,EAAE,UACb,SAAS,EAAE,EAAE,KACpB,SAAS,CAAC,EAAE,GAAG,EAAE,CAAC,EAE+C,CAAC;AAErE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,SAAS,UACvC,SAAS,CAAC,EAAE,UACZ,SAAS,CAAC,EAAE,KACnB,SAAS,CAAC,EAA+C,CAAC;AAE7D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,MAAM,eACxC,SAAS,CAAC,EAAE,eACZ,SAAS,CAAC,EAAE,KACxB,SAAS,CAAC,EAoCZ,CAAC"}