ts-data-forge 14.4.0 → 14.6.0

package/README.md

@@ -507,6 +507,12 @@ const value: unknown = { key: 'value' } as const;
 
 if (isNonNullObject(value)) {
     // value is guaranteed to be a non-null object
+    assert.isTrue(value !== null);
+}
+
+// `object` is not enough to read keys from: an index signature is what
+// says the keys are strings. `isRecord` is the guard that gives one.
+if (isRecord(value)) {
     assert.deepStrictEqual(Object.keys(value), ['key']);
 }
 

package/dist/array/impl/array-utils-element-access.mjs

@@ -1,7 +1,7 @@
 import { none } from '../../functional/optional/impl/optional-none.mjs';
 import { some } from '../../functional/optional/impl/optional-some.mjs';
-import { pipe } from '../../functional/pipe.mjs';
 import '@sindresorhus/is';
+import { pipe } from '../../functional/pipe.mjs';
 
 function at(...args) {
   switch (args.length) {

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

@@ -3,11 +3,11 @@ import '../../collections/imap-mapped.mjs';
 import { IMap } from '../../collections/imap.mjs';
 import '../../collections/iset-mapped.mjs';
 import '../../collections/iset.mjs';
-import { isString, isUndefined } from '../../guard/is-type.mjs';
-import { none } from '../../functional/optional/impl/optional-none.mjs';
-import { some } from '../../functional/optional/impl/optional-some.mjs';
 import { err } from '../../functional/result/impl/result-err.mjs';
 import { ok } from '../../functional/result/impl/result-ok.mjs';
+import { none } from '../../functional/optional/impl/optional-none.mjs';
+import { some } from '../../functional/optional/impl/optional-some.mjs';
+import { isString, isUndefined } from '../../guard/is-type.mjs';
 import { unknownToString } from '../../others/unknown-to-string.mjs';
 import '../../number/branded-types/finite-number.mjs';
 import '../../number/branded-types/int.mjs';

package/dist/array/impl/array-utils-search.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-search.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-search.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAQ,MAAM,4BAA4B,CAAC;AAE5D,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,UAAU,EACf,KAAK,QAAQ,EACd,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACjC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC,GAC1E,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEf,wBAAgB,IAAI,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACtD,KAAK,EAAE,EAAE,EACT,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,KAAK,OAAO,GACxE,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;AAExB,wBAAgB,IAAI,CAAC,CAAC,EACpB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO,GACvE,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;AAsDxC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACrC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC,GAC1E,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEf,wBAAgB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAC1D,KAAK,EAAE,EAAE,EACT,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,KAAK,OAAO,GACxE,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;AAExB,wBAAgB,QAAQ,CAAC,CAAC,EACxB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO,GACvE,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;AAsDxC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAC3D,KAAK,EAAE,EAAE,EACT,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,KAAK,OAAO,GACxE,UAAU,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AAEvB,wBAAgB,SAAS,CAAC,CAAC,EACzB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO,GACvE,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,QAAQ,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;AAwC9C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAC/D,KAAK,EAAE,EAAE,EACT,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,KAAK,OAAO,GACxE,UAAU,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AAEvB,wBAAgB,aAAa,CAAC,CAAC,EAC7B,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO,GACvE,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,QAAQ,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;AAwC9C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,OAAO,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACzD,KAAK,EAAE,EAAE,EACT,aAAa,EAAE,EAAE,CAAC,MAAM,CAAC,GACxB,UAAU,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AAEvB,wBAAgB,OAAO,CAAC,CAAC,EACvB,aAAa,EAAE,CAAC,GACf,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,QAAQ,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;AAyB9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7D,KAAK,EAAE,EAAE,EACT,aAAa,EAAE,EAAE,CAAC,MAAM,CAAC,EACzB,SAAS,EAAE,yBAAyB,CAAC,EAAE,CAAC,GACvC,UAAU,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AAEvB,wBAAgB,WAAW,CAAC,CAAC,EAC3B,aAAa,EAAE,CAAC,EAChB,SAAS,EAAE,QAAQ,CAAC,kBAAkB,GACrC,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,QAAQ,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;AA8B9C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7D,KAAK,EAAE,EAAE,EACT,aAAa,EAAE,EAAE,CAAC,MAAM,CAAC,GACxB,UAAU,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AAEvB,wBAAgB,WAAW,CAAC,CAAC,EAC3B,aAAa,EAAE,CAAC,GACf,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,QAAQ,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;AAyB9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,eAAe,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACjE,KAAK,EAAE,EAAE,EACT,aAAa,EAAE,EAAE,CAAC,MAAM,CAAC,EACzB,SAAS,EAAE,yBAAyB,CAAC,EAAE,CAAC,GACvC,UAAU,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AAEvB,wBAAgB,eAAe,CAAC,CAAC,EAC/B,aAAa,EAAE,CAAC,EAChB,SAAS,EAAE,QAAQ,CAAC,kBAAkB,GACrC,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,QAAQ,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC"}
+{"version":3,"file":"array-utils-search.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-search.mts"],"names":[],"mappings":"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"}

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

@@ -1,7 +1,7 @@
 import { none } from '../../functional/optional/impl/optional-none.mjs';
 import { some } from '../../functional/optional/impl/optional-some.mjs';
-import { pipe } from '../../functional/pipe.mjs';
 import '@sindresorhus/is';
+import { pipe } from '../../functional/pipe.mjs';
 import '../../number/branded-types/finite-number.mjs';
 import '../../number/branded-types/int.mjs';
 import '../../number/branded-types/int16.mjs';

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":["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      return findImpl(...args);\n\n    case 1:\n      return (array) => findImpl(array, ...args);\n  }\n}\n\nconst findImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): Optional<E> => {\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/**\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      return findLastImpl(...args);\n\n    case 1:\n      return (array) => findLastImpl(array, ...args);\n  }\n}\n\nconst findLastImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): Optional<E> => {\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/**\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      return findIndexImpl(...args);\n\n    case 1:\n      return (array) => findIndexImpl(array, ...args);\n  }\n}\n\nconst findIndexImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): SizeType.Arr | -1 =>\n  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 * 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      return findLastIndexImpl(...args);\n\n    case 1:\n      return (array) => findLastIndexImpl(array, ...args);\n  }\n}\n\nconst findLastIndexImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): SizeType.Arr | -1 =>\n  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 * 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      return indexOfImpl(...args);\n\n    case 1:\n      return (array) => indexOfImpl(array, ...args);\n  }\n}\n\nconst indexOfImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n): SizeType.Arr | -1 => {\n  const index = array.indexOf(searchElement);\n\n  return index !== -1 ? asUint32(index) : -1;\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      return indexOfFromImpl(...args);\n\n    case 2:\n      return (array) => indexOfFromImpl(array, ...args);\n  }\n}\n\nconst indexOfFromImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n  fromIndex: SizeType.ArgArrWithNegative,\n): SizeType.Arr | -1 => {\n  const index = array.indexOf(searchElement, fromIndex);\n\n  return index !== -1 ? asUint32(index) : -1;\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      return lastIndexOfImpl(...args);\n\n    case 1:\n      return (array) => lastIndexOfImpl(array, ...args);\n  }\n}\n\nconst lastIndexOfImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n): SizeType.Arr | -1 => {\n  const index = array.lastIndexOf(searchElement);\n\n  return index !== -1 ? asUint32(index) : -1;\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      return lastIndexOfFromImpl(...args);\n\n    case 2:\n      return (array) => lastIndexOfFromImpl(array, ...args);\n  }\n}\n\nconst lastIndexOfFromImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n  fromIndex: SizeType.ArgArrWithNegative,\n): SizeType.Arr | -1 => {\n  const index = array.lastIndexOf(searchElement, fromIndex);\n\n  return index !== -1 ? asUint32(index) : -1;\n};\n"],"names":["Optional.none","Optional.some"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CO,SAAS,QACX,IAAA,EAgBmD;AACtD,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,KACgB;AAChB,EAAA,MAAM,aAAa,KAAA,CAAM,SAAA;AAAA;AAAA,IAEvB;AAAA,GACF;AAYA,EAAA,OAAO,UAAA,KAAe,KAClBA,IAAS;AAAA;AAAA,IAETC,IAAS,CAAK,KAAA,CAAM,UAAU,CAAE;AAAA,GAAA;AACtC,CAAA;AAiCO,SAAS,YACX,IAAA,EAgBmD;AACtD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,YAAA,CAAa,GAAG,IAAI,CAAA;AAAA,IAE7B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,YAAA,CAAa,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAEnD;AAEA,MAAM,YAAA,GAAe,CACnB,KAAA,EACA,SAAA,KACgB;AAChB,EAAA,MAAM,aAAa,KAAA,CAAM,aAAA;AAAA;AAAA,IAEvB;AAAA,GACF;AAYA,EAAA,OAAO,UAAA,KAAe,KAClBD,IAAS;AAAA;AAAA,IAETC,IAAS,CAAK,KAAA,CAAM,UAAU,CAAE;AAAA,GAAA;AACtC,CAAA;AA8BO,SAAS,aACX,IAAA,EAgB+D;AAClE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,aAAA,CAAc,GAAG,IAAI,CAAA;AAAA,IAE9B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,aAAA,CAAc,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAEpD;AAEA,MAAM,aAAA,GAAgB,CACpB,KAAA,EACA,SAAA,KAEA,IAAA;AAAA,EACE,KAAA,CAAM,SAAA;AAAA;AAAA,IAEJ;AAAA;AAEJ,CAAA,CAAE,GAAA,CAAI,CAAC,GAAA,KAAS,GAAA,IAAO,IAAI,QAAA,CAAS,GAAG,CAAA,GAAI,EAAG,CAAA,CAAE,KAAA;AA8B3C,SAAS,iBACX,IAAA,EAgB+D;AAClE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,iBAAA,CAAkB,GAAG,IAAI,CAAA;AAAA,IAElC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,iBAAA,CAAkB,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAExD;AAEA,MAAM,iBAAA,GAAoB,CACxB,KAAA,EACA,SAAA,KAEA,IAAA;AAAA,EACE,KAAA,CAAM,aAAA;AAAA;AAAA,IAEJ;AAAA;AAEJ,CAAA,CAAE,GAAA,CAAI,CAAC,GAAA,KAAS,GAAA,IAAO,IAAI,QAAA,CAAS,GAAG,CAAA,GAAI,EAAG,CAAA,CAAE,KAAA;AAmC3C,SAAS,WACX,IAAA,EAG+D;AAClE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,WAAA,CAAY,GAAG,IAAI,CAAA;AAAA,IAE5B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,WAAA,CAAY,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAElD;AAEA,MAAM,WAAA,GAAc,CAClB,KAAA,EACA,aAAA,KACsB;AACtB,EAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,OAAA,CAAQ,aAAa,CAAA;AAEzC,EAAA,OAAO,KAAA,KAAU,EAAA,GAAK,QAAA,CAAS,KAAK,CAAA,GAAI,EAAA;AAC1C,CAAA;AA4CO,SAAS,eACX,IAAA,EAO+D;AAClE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,eAAA,CAAgB,GAAG,IAAI,CAAA;AAAA,IAEhC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,eAAA,CAAgB,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAEtD;AAEA,MAAM,eAAA,GAAkB,CACtB,KAAA,EACA,aAAA,EACA,SAAA,KACsB;AACtB,EAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,OAAA,CAAQ,aAAA,EAAe,SAAS,CAAA;AAEpD,EAAA,OAAO,KAAA,KAAU,EAAA,GAAK,QAAA,CAAS,KAAK,CAAA,GAAI,EAAA;AAC1C,CAAA;AAuCO,SAAS,eACX,IAAA,EAG+D;AAClE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,eAAA,CAAgB,GAAG,IAAI,CAAA;AAAA,IAEhC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,eAAA,CAAgB,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAEtD;AAEA,MAAM,eAAA,GAAkB,CACtB,KAAA,EACA,aAAA,KACsB;AACtB,EAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,WAAA,CAAY,aAAa,CAAA;AAE7C,EAAA,OAAO,KAAA,KAAU,EAAA,GAAK,QAAA,CAAS,KAAK,CAAA,GAAI,EAAA;AAC1C,CAAA;AA4CO,SAAS,mBACX,IAAA,EAO+D;AAClE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,mBAAA,CAAoB,GAAG,IAAI,CAAA;AAAA,IAEpC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,mBAAA,CAAoB,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAE1D;AAEA,MAAM,mBAAA,GAAsB,CAC1B,KAAA,EACA,aAAA,EACA,SAAA,KACsB;AACtB,EAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,WAAA,CAAY,aAAA,EAAe,SAAS,CAAA;AAExD,EAAA,OAAO,KAAA,KAAU,EAAA,GAAK,QAAA,CAAS,KAAK,CAAA,GAAI,EAAA;AAC1C,CAAA;;;;"}
+{"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      return findImpl(...args);\n\n    case 1:\n      return (array) => findImpl(array, ...args);\n  }\n}\n\nconst findImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): Optional<E> => {\n  const foundIndex = array.findIndex(\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    predicate as () => boolean,\n  );\n\n  // Left as a comment rather than asserted. This pinned the shape of the\n  // standard library's `findIndex`, and the shape differs between the stock\n  // library and the strict one — `(value, index, obj: this) => boolean` there\n  // against `(value, index, arr: readonly E[]) => unknown` here. `src` ships\n  // to consumers so that \"Go to Definition\" reaches it, so an assertion that\n  // only holds under one of them shows up as an error in their editor.\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/**\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      return findLastImpl(...args);\n\n    case 1:\n      return (array) => findLastImpl(array, ...args);\n  }\n}\n\nconst findLastImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): Optional<E> => {\n  const foundIndex = array.findLastIndex(\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    predicate as () => boolean,\n  );\n\n  // Left as a comment rather than asserted. This pinned the shape of the\n  // standard library's `findIndex`, and the shape differs between the stock\n  // library and the strict one — `(value, index, obj: this) => boolean` there\n  // against `(value, index, arr: readonly E[]) => unknown` here. `src` ships\n  // to consumers so that \"Go to Definition\" reaches it, so an assertion that\n  // only holds under one of them shows up as an error in their editor.\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/**\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      return findIndexImpl(...args);\n\n    case 1:\n      return (array) => findIndexImpl(array, ...args);\n  }\n}\n\nconst findIndexImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): SizeType.Arr | -1 =>\n  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 * 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      return findLastIndexImpl(...args);\n\n    case 1:\n      return (array) => findLastIndexImpl(array, ...args);\n  }\n}\n\nconst findLastIndexImpl = <E,>(\n  array: readonly E[],\n  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,\n): SizeType.Arr | -1 =>\n  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 * 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      return indexOfImpl(...args);\n\n    case 1:\n      return (array) => indexOfImpl(array, ...args);\n  }\n}\n\nconst indexOfImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n): SizeType.Arr | -1 => {\n  const index = array.indexOf(searchElement);\n\n  return index !== -1 ? asUint32(index) : -1;\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      return indexOfFromImpl(...args);\n\n    case 2:\n      return (array) => indexOfFromImpl(array, ...args);\n  }\n}\n\nconst indexOfFromImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n  fromIndex: SizeType.ArgArrWithNegative,\n): SizeType.Arr | -1 => {\n  const index = array.indexOf(searchElement, fromIndex);\n\n  return index !== -1 ? asUint32(index) : -1;\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      return lastIndexOfImpl(...args);\n\n    case 1:\n      return (array) => lastIndexOfImpl(array, ...args);\n  }\n}\n\nconst lastIndexOfImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n): SizeType.Arr | -1 => {\n  const index = array.lastIndexOf(searchElement);\n\n  return index !== -1 ? asUint32(index) : -1;\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      return lastIndexOfFromImpl(...args);\n\n    case 2:\n      return (array) => lastIndexOfFromImpl(array, ...args);\n  }\n}\n\nconst lastIndexOfFromImpl = <E,>(\n  array: readonly E[],\n  searchElement: E,\n  fromIndex: SizeType.ArgArrWithNegative,\n): SizeType.Arr | -1 => {\n  const index = array.lastIndexOf(searchElement, fromIndex);\n\n  return index !== -1 ? asUint32(index) : -1;\n};\n"],"names":["Optional.none","Optional.some"],"mappings":"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"}

package/dist/collections/imap-mapped.mjs

@@ -2,9 +2,9 @@ import { isSome } from '../functional/optional/impl/optional-is-some.mjs';
 import { none } from '../functional/optional/impl/optional-none.mjs';
 import { some } from '../functional/optional/impl/optional-some.mjs';
 import { isNone } from '../functional/optional/impl/optional-is-none.mjs';
-import { pipe } from '../functional/pipe.mjs';
 import '@sindresorhus/is';
 import { tp } from '../others/tuple.mjs';
+import { pipe } from '../functional/pipe.mjs';
 import '../number/branded-types/finite-number.mjs';
 import '../number/branded-types/int.mjs';
 import '../number/branded-types/int16.mjs';

package/dist/collections/imap.mjs

@@ -2,10 +2,10 @@ import { isSome } from '../functional/optional/impl/optional-is-some.mjs';
 import { none } from '../functional/optional/impl/optional-none.mjs';
 import { some } from '../functional/optional/impl/optional-some.mjs';
 import { isNone } from '../functional/optional/impl/optional-is-none.mjs';
-import { pipe } from '../functional/pipe.mjs';
 import '@sindresorhus/is';
 import { tp } from '../others/tuple.mjs';
 import { unknownToString } from '../others/unknown-to-string.mjs';
+import { pipe } from '../functional/pipe.mjs';
 import '../number/branded-types/finite-number.mjs';
 import '../number/branded-types/int.mjs';
 import '../number/branded-types/int16.mjs';

package/dist/entry-point.mjs

@@ -1,13 +1,15 @@
 import * as index from './array/impl/index.mjs';
 export { index as Arr };
+import * as index$1 from './functional/async-result/impl/index.mjs';
+export { index$1 as AsyncResult };
 export { match } from './functional/match.mjs';
-import * as index$1 from './functional/optional/impl/index.mjs';
-export { index$1 as Optional };
+import * as index$2 from './functional/optional/impl/index.mjs';
+export { index$2 as Optional };
 export { pipe } from './functional/pipe.mjs';
-import * as index$2 from './functional/result/impl/index.mjs';
-export { index$2 as Result };
-import * as index$3 from './functional/ternary-result/impl/index.mjs';
-export { index$3 as TernaryResult };
+import * as index$3 from './functional/result/impl/index.mjs';
+export { index$3 as Result };
+import * as index$4 from './functional/ternary-result/impl/index.mjs';
+export { index$4 as TernaryResult };
 export { IMapMapped } from './collections/imap-mapped.mjs';
 export { IMap } from './collections/imap.mjs';
 export { ISetMapped } from './collections/iset-mapped.mjs';

package/dist/entry-point.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"entry-point.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"entry-point.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/functional/async-result/async-result.d.mts

@@ -0,0 +1,16 @@
+import { type Result } from '../result/index.mjs';
+/**
+ * Represents an asynchronous computation that can either succeed (`Ok`) or
+ * fail (`Err`) — a `Promise` that resolves to a `Result<S, E>`.
+ *
+ * Unlike a raw `Promise`, an `AsyncResult` never rejects for expected
+ * failures: errors are carried in the `Err` channel with a concrete type `E`,
+ * so they can be handled with the same combinators as a synchronous
+ * `Result`.
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value.
+ */
+export type AsyncResult<S, E> = Promise<Result<S, E>>;
+export * as AsyncResult from './impl/index.mjs';
+//# sourceMappingURL=async-result.d.mts.map

package/dist/functional/async-result/async-result.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-result.d.mts","sourceRoot":"","sources":["../../../src/functional/async-result/async-result.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAEtD,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC"}

package/dist/functional/async-result/async-result.mjs

@@ -0,0 +1,3 @@
+import * as index from './impl/index.mjs';
+export { index as AsyncResult };
+//# sourceMappingURL=async-result.mjs.map

package/dist/functional/async-result/async-result.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-result.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/functional/async-result/impl/async-result-flat-map.d.mts

@@ -0,0 +1,39 @@
+import { type UnknownResult } from '../../result/index.mjs';
+import { type AsyncResult } from '../async-result.mjs';
+import { type UnknownAsyncResult, type UnwrapErr, type UnwrapOk } from './types.mjs';
+/**
+ * Applies a function that returns an `AsyncResult` or a `Result` to the
+ * success value of an `AsyncResult`. If the input resolves to `Err`, the
+ * original `Err` is passed through and the function is not called. This is
+ * the monadic bind operation for `AsyncResult`.
+ *
+ * @example
+ *
+ * ```ts
+ * const parseNumber = (input: string): Result<number, string> => {
+ *   const num = Number.parseInt(input, 10);
+ *
+ *   return Number.isNaN(num) ? Result.err('not a number') : Result.ok(num);
+ * };
+ *
+ * const input = AsyncResult.fromPromise(
+ *   Promise.resolve('42'),
+ *   () => 'failed',
+ * );
+ *
+ * const parsed = await AsyncResult.flatMap(input, parseNumber);
+ *
+ * assert.deepStrictEqual(parsed, Result.ok(42));
+ * ```
+ *
+ * @template S The type of the success value of the input.
+ * @template E The type of the error value of the input.
+ * @template R2 The `AsyncResult` or `Result` type returned by the function.
+ * @param asyncResult The `AsyncResult` to flat map.
+ * @param flatMapFn The function to apply that returns an `AsyncResult` or a
+ *   `Result`.
+ * @returns The result of applying the function, or the original `Err`.
+ */
+export declare function flatMap<S, E, R2 extends UnknownAsyncResult | UnknownResult>(asyncResult: AsyncResult<S, E>, flatMapFn: (value: S) => R2): AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>;
+export declare function flatMap<S, R2 extends UnknownAsyncResult | UnknownResult>(flatMapFn: (value: S) => R2): <E>(asyncResult: AsyncResult<S, E>) => AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>;
+//# sourceMappingURL=async-result-flat-map.d.mts.map

package/dist/functional/async-result/impl/async-result-flat-map.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-flat-map.d.mts","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-flat-map.mts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACpE,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,QAAQ,EACd,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,SAAS,kBAAkB,GAAG,aAAa,EACzE,WAAW,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAC9B,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GAC1B,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC;AAWhD,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,SAAS,kBAAkB,GAAG,aAAa,EACtE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GAC1B,CAAC,CAAC,EACH,WAAW,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,KAC3B,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/functional/async-result/impl/async-result-flat-map.mjs

@@ -0,0 +1,25 @@
+import { isErr } from '../../result/impl/result-is-err.mjs';
+import '@sindresorhus/is';
+
+function flatMap(...args) {
+  switch (args.length) {
+    case 2: {
+      const [asyncResult, flatMapFn] = args;
+      return flatMapImpl(asyncResult, flatMapFn);
+    }
+    case 1: {
+      const [flatMapFn] = args;
+      return (asyncResult) => flatMapImpl(asyncResult, flatMapFn);
+    }
+  }
+}
+const flatMapImpl = async (asyncResult, flatMapFn) => {
+  const result = await asyncResult;
+  return isErr(result) ? result : (
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    await flatMapFn(result.value)
+  );
+};
+
+export { flatMap };
+//# sourceMappingURL=async-result-flat-map.mjs.map

package/dist/functional/async-result/impl/async-result-flat-map.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-flat-map.mjs","sources":["../../../../src/functional/async-result/impl/async-result-flat-map.mts"],"sourcesContent":["import { Result, type UnknownResult } from '../../result/index.mjs';\nimport { type AsyncResult } from '../async-result.mjs';\nimport {\n  type UnknownAsyncResult,\n  type UnwrapErr,\n  type UnwrapOk,\n} from './types.mjs';\n\n/**\n * Applies a function that returns an `AsyncResult` or a `Result` to the\n * success value of an `AsyncResult`. If the input resolves to `Err`, the\n * original `Err` is passed through and the function is not called. This is\n * the monadic bind operation for `AsyncResult`.\n *\n * @example\n *\n * ```ts\n * const parseNumber = (input: string): Result<number, string> => {\n *   const num = Number.parseInt(input, 10);\n *\n *   return Number.isNaN(num) ? Result.err('not a number') : Result.ok(num);\n * };\n *\n * const input = AsyncResult.fromPromise(\n *   Promise.resolve('42'),\n *   () => 'failed',\n * );\n *\n * const parsed = await AsyncResult.flatMap(input, parseNumber);\n *\n * assert.deepStrictEqual(parsed, Result.ok(42));\n * ```\n *\n * @template S The type of the success value of the input.\n * @template E The type of the error value of the input.\n * @template R2 The `AsyncResult` or `Result` type returned by the function.\n * @param asyncResult The `AsyncResult` to flat map.\n * @param flatMapFn The function to apply that returns an `AsyncResult` or a\n *   `Result`.\n * @returns The result of applying the function, or the original `Err`.\n */\nexport function flatMap<S, E, R2 extends UnknownAsyncResult | UnknownResult>(\n  asyncResult: AsyncResult<S, E>,\n  flatMapFn: (value: S) => R2,\n): AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>;\n\n// Curried version\n//\n// The function's return type is captured as a whole (`R2`) and unwrapped with\n// `UnwrapOk` / `UnwrapErr`, instead of being written as\n// `AsyncResult<S2, E2> | Result<S2, E2>` with separate `S2` / `E2` type\n// parameters. With the union form, inference for `E2` collects a candidate\n// from matching `Ok<S2>` against `Err<E2>` (both have a `value` property), so\n// `E2` ends up as the success type and the call fails to type-check even for\n// a function annotated as returning `Result<S2, E2>`.\nexport function flatMap<S, R2 extends UnknownAsyncResult | UnknownResult>(\n  flatMapFn: (value: S) => R2,\n): <E>(\n  asyncResult: AsyncResult<S, E>,\n) => AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>;\n\nexport function flatMap<S, E, R2 extends UnknownAsyncResult | UnknownResult>(\n  ...args:\n    | readonly [asyncResult: AsyncResult<S, E>, flatMapFn: (value: S) => R2]\n    | readonly [flatMapFn: (value: S) => R2]\n):\n  | AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>\n  | ((\n      asyncResult: AsyncResult<S, E>,\n    ) => AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is asyncResult\n      const [asyncResult, flatMapFn] = args;\n\n      return flatMapImpl(asyncResult, flatMapFn);\n    }\n\n    case 1: {\n      // Curried version\n      const [flatMapFn] = args;\n\n      return (asyncResult: AsyncResult<S, E>) =>\n        flatMapImpl(asyncResult, flatMapFn);\n    }\n  }\n}\n\nconst flatMapImpl = async <S, E, R2 extends UnknownAsyncResult | UnknownResult>(\n  asyncResult: AsyncResult<S, E>,\n  flatMapFn: (value: S) => R2,\n): AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>> => {\n  const result = await asyncResult;\n\n  return Result.isErr(result)\n    ? result\n    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      ((await flatMapFn(result.value)) as Result<UnwrapOk<R2>, UnwrapErr<R2>>);\n};\n"],"names":["Result.isErr"],"mappings":";;;AA6DO,SAAS,WACX,IAAA,EAOkD;AACrD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,WAAA,EAAa,SAAS,CAAA,GAAI,IAAA;AAEjC,MAAA,OAAO,WAAA,CAAY,aAAa,SAAS,CAAA;AAAA,IAC3C;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,WAAA,KACN,WAAA,CAAY,WAAA,EAAa,SAAS,CAAA;AAAA,IACtC;AAAA;AAEJ;AAEA,MAAM,WAAA,GAAc,OAClB,WAAA,EACA,SAAA,KACiD;AACjD,EAAA,MAAM,SAAS,MAAM,WAAA;AAErB,EAAA,OAAOA,KAAO,CAAM,MAAM,CAAA,GACtB,MAAA;AAAA;AAAA,IAEE,MAAM,SAAA,CAAU,MAAA,CAAO,KAAK;AAAA,GAAA;AACpC,CAAA;;;;"}

package/dist/functional/async-result/impl/async-result-from-promise.d.mts

@@ -0,0 +1,47 @@
+import { type AsyncResult } from '../async-result.mjs';
+/**
+ * Converts a `Promise` into an `AsyncResult`. If the input Promise resolves,
+ * the `AsyncResult` resolves to `Ok` with the resolved value. If the input
+ * Promise rejects, the rejection reason is passed through `mapError` and the
+ * `AsyncResult` resolves to `Err` with the mapped error.
+ *
+ * Passing `mapError` is what gives the error channel a concrete type `E`.
+ * Omitting it carries the rejection reason through untouched, leaving the
+ * error channel as `unknown` — the same contract as `Result.fromPromise`.
+ *
+ * @example
+ *
+ * ```ts
+ * const resolved = await AsyncResult.fromPromise(
+ *   Promise.resolve('ok'),
+ *   (error) => `failed: ${String(error)}`,
+ * );
+ *
+ * const rejected = await AsyncResult.fromPromise(
+ *   Promise.reject(new Error('boom')),
+ *   (error) => (isError(error) ? error.message : 'unknown'),
+ * );
+ *
+ * assert.deepStrictEqual(resolved, Result.ok('ok'));
+ *
+ * assert.deepStrictEqual(rejected, Result.err('boom'));
+ *
+ * // Without `mapError`, the rejection reason is carried as-is.
+ * const untyped = await AsyncResult.fromPromise(
+ *   Promise.reject(new Error('boom')),
+ * );
+ *
+ * assert.isTrue(Result.isErr(untyped));
+ * ```
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value.
+ * @param promise The Promise to convert.
+ * @param mapError The function applied to the rejection reason to produce the
+ *   error value. Omit it to carry the rejection reason as `unknown`.
+ * @returns An `AsyncResult<S, E>` that never rejects for the input Promise's
+ *   failure.
+ */
+export declare function fromPromise<S>(promise: Promise<S>): AsyncResult<S, unknown>;
+export declare function fromPromise<S, E>(promise: Promise<S>, mapError: (error: unknown) => E): AsyncResult<S, E>;
+//# sourceMappingURL=async-result-from-promise.d.mts.map

package/dist/functional/async-result/impl/async-result-from-promise.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-from-promise.d.mts","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-from-promise.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;AAE7E,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAC9B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,GAC9B,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/functional/async-result/impl/async-result-from-promise.mjs

@@ -0,0 +1,11 @@
+import { err } from '../../result/impl/result-err.mjs';
+import { ok } from '../../result/impl/result-ok.mjs';
+import '@sindresorhus/is';
+
+function fromPromise(promise, mapError) {
+  return mapError === void 0 ? fromPromiseImpl(promise, (error) => error) : fromPromiseImpl(promise, mapError);
+}
+const fromPromiseImpl = (promise, mapError) => promise.then((value) => ok(value)).catch((error) => err(mapError(error)));
+
+export { fromPromise };
+//# sourceMappingURL=async-result-from-promise.mjs.map

package/dist/functional/async-result/impl/async-result-from-promise.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-from-promise.mjs","sources":["../../../../src/functional/async-result/impl/async-result-from-promise.mts"],"sourcesContent":["import { Result } from '../../result/index.mjs';\nimport { type AsyncResult } from '../async-result.mjs';\n\n/**\n * Converts a `Promise` into an `AsyncResult`. If the input Promise resolves,\n * the `AsyncResult` resolves to `Ok` with the resolved value. If the input\n * Promise rejects, the rejection reason is passed through `mapError` and the\n * `AsyncResult` resolves to `Err` with the mapped error.\n *\n * Passing `mapError` is what gives the error channel a concrete type `E`.\n * Omitting it carries the rejection reason through untouched, leaving the\n * error channel as `unknown` — the same contract as `Result.fromPromise`.\n *\n * @example\n *\n * ```ts\n * const resolved = await AsyncResult.fromPromise(\n *   Promise.resolve('ok'),\n *   (error) => `failed: ${String(error)}`,\n * );\n *\n * const rejected = await AsyncResult.fromPromise(\n *   Promise.reject(new Error('boom')),\n *   (error) => (isError(error) ? error.message : 'unknown'),\n * );\n *\n * assert.deepStrictEqual(resolved, Result.ok('ok'));\n *\n * assert.deepStrictEqual(rejected, Result.err('boom'));\n *\n * // Without `mapError`, the rejection reason is carried as-is.\n * const untyped = await AsyncResult.fromPromise(\n *   Promise.reject(new Error('boom')),\n * );\n *\n * assert.isTrue(Result.isErr(untyped));\n * ```\n *\n * @template S The type of the success value.\n * @template E The type of the error value.\n * @param promise The Promise to convert.\n * @param mapError The function applied to the rejection reason to produce the\n *   error value. Omit it to carry the rejection reason as `unknown`.\n * @returns An `AsyncResult<S, E>` that never rejects for the input Promise's\n *   failure.\n */\nexport function fromPromise<S>(promise: Promise<S>): AsyncResult<S, unknown>;\n\nexport function fromPromise<S, E>(\n  promise: Promise<S>,\n  mapError: (error: unknown) => E,\n): AsyncResult<S, E>;\n\nexport function fromPromise<S, E>(\n  promise: Promise<S>,\n  mapError?: (error: unknown) => E,\n): AsyncResult<S, E> | AsyncResult<S, unknown> {\n  return mapError === undefined\n    ? fromPromiseImpl(promise, (error: unknown) => error)\n    : fromPromiseImpl(promise, mapError);\n}\n\nconst fromPromiseImpl = <S, E>(\n  promise: Promise<S>,\n  mapError: (error: unknown) => E,\n): AsyncResult<S, E> =>\n  promise\n    .then((value) => Result.ok(value))\n    .catch((error: unknown) => Result.err(mapError(error)));\n"],"names":["Result.ok","Result.err"],"mappings":";;;;AAqDO,SAAS,WAAA,CACd,SACA,QAAA,EAC6C;AAC7C,EAAA,OAAO,QAAA,KAAa,MAAA,GAChB,eAAA,CAAgB,OAAA,EAAS,CAAC,UAAmB,KAAK,CAAA,GAClD,eAAA,CAAgB,OAAA,EAAS,QAAQ,CAAA;AACvC;AAEA,MAAM,eAAA,GAAkB,CACtB,OAAA,EACA,QAAA,KAEA,QACG,IAAA,CAAK,CAAC,UAAUA,EAAO,CAAG,KAAK,CAAC,CAAA,CAChC,MAAM,CAAC,KAAA,KAAmBC,GAAO,CAAI,QAAA,CAAS,KAAK,CAAC,CAAC,CAAA;;;;"}

package/dist/functional/async-result/impl/async-result-from-throwable.d.mts

@@ -0,0 +1,53 @@
+import { type AsyncResult } from '../async-result.mjs';
+/**
+ * Wraps a function returning a `Promise` in an `AsyncResult`. Both a
+ * synchronous `throw` while calling `fn` and an asynchronous rejection of the
+ * returned Promise are caught, passed through `mapError`, and carried as
+ * `Err`.
+ *
+ * Passing `mapError` is what gives the error channel a concrete type `E`.
+ * Omitting it carries the thrown value through untouched, leaving the error
+ * channel as `unknown`.
+ *
+ * @example
+ *
+ * ```ts
+ * const success = await AsyncResult.fromThrowable(
+ *   () => Promise.resolve(2),
+ *   (error) => `failed: ${String(error)}`,
+ * );
+ *
+ * const failure = await AsyncResult.fromThrowable(
+ *   (): Promise<number> => {
+ *     throw new Error('boom');
+ *   },
+ *   (error) => (isError(error) ? error.message : 'unknown'),
+ * );
+ *
+ * assert.deepStrictEqual(success, Result.ok(2));
+ *
+ * assert.deepStrictEqual(failure, Result.err('boom'));
+ *
+ * // Without `mapError`, the thrown value is carried as-is.
+ * const untyped = await AsyncResult.fromThrowable(
+ *   (): Promise<number> => {
+ *     throw new Error('boom');
+ *   },
+ * );
+ *
+ * assert.isTrue(Result.isErr(untyped));
+ * ```
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value.
+ * @param fn The function to execute; it may throw synchronously or return a
+ *   rejecting Promise.
+ * @param mapError The function applied to the thrown value or rejection
+ *   reason to produce the error value. Omit it to carry the thrown value as
+ *   `unknown`.
+ * @returns An `AsyncResult<S, E>` containing either the resolved value or the
+ *   mapped error.
+ */
+export declare function fromThrowable<S>(fn: () => Promise<S>): AsyncResult<S, unknown>;
+export declare function fromThrowable<S, E>(fn: () => Promise<S>, mapError: (error: unknown) => E): AsyncResult<S, E>;
+//# sourceMappingURL=async-result-from-throwable.d.mts.map

package/dist/functional/async-result/impl/async-result-from-throwable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-from-throwable.d.mts","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-from-throwable.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;AAEhF,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,EAChC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,GAC9B,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/functional/async-result/impl/async-result-from-throwable.mjs

@@ -0,0 +1,17 @@
+import { err } from '../../result/impl/result-err.mjs';
+import { ok } from '../../result/impl/result-ok.mjs';
+import '@sindresorhus/is';
+
+function fromThrowable(fn, mapError) {
+  return mapError === void 0 ? fromThrowableImpl(fn, (error) => error) : fromThrowableImpl(fn, mapError);
+}
+const fromThrowableImpl = async (fn, mapError) => {
+  try {
+    return ok(await fn());
+  } catch (error) {
+    return err(mapError(error));
+  }
+};
+
+export { fromThrowable };
+//# sourceMappingURL=async-result-from-throwable.mjs.map

package/dist/functional/async-result/impl/async-result-from-throwable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-from-throwable.mjs","sources":["../../../../src/functional/async-result/impl/async-result-from-throwable.mts"],"sourcesContent":["import { Result } from '../../result/index.mjs';\nimport { type AsyncResult } from '../async-result.mjs';\n\n/**\n * Wraps a function returning a `Promise` in an `AsyncResult`. Both a\n * synchronous `throw` while calling `fn` and an asynchronous rejection of the\n * returned Promise are caught, passed through `mapError`, and carried as\n * `Err`.\n *\n * Passing `mapError` is what gives the error channel a concrete type `E`.\n * Omitting it carries the thrown value through untouched, leaving the error\n * channel as `unknown`.\n *\n * @example\n *\n * ```ts\n * const success = await AsyncResult.fromThrowable(\n *   () => Promise.resolve(2),\n *   (error) => `failed: ${String(error)}`,\n * );\n *\n * const failure = await AsyncResult.fromThrowable(\n *   (): Promise<number> => {\n *     throw new Error('boom');\n *   },\n *   (error) => (isError(error) ? error.message : 'unknown'),\n * );\n *\n * assert.deepStrictEqual(success, Result.ok(2));\n *\n * assert.deepStrictEqual(failure, Result.err('boom'));\n *\n * // Without `mapError`, the thrown value is carried as-is.\n * const untyped = await AsyncResult.fromThrowable(\n *   (): Promise<number> => {\n *     throw new Error('boom');\n *   },\n * );\n *\n * assert.isTrue(Result.isErr(untyped));\n * ```\n *\n * @template S The type of the success value.\n * @template E The type of the error value.\n * @param fn The function to execute; it may throw synchronously or return a\n *   rejecting Promise.\n * @param mapError The function applied to the thrown value or rejection\n *   reason to produce the error value. Omit it to carry the thrown value as\n *   `unknown`.\n * @returns An `AsyncResult<S, E>` containing either the resolved value or the\n *   mapped error.\n */\nexport function fromThrowable<S>(fn: () => Promise<S>): AsyncResult<S, unknown>;\n\nexport function fromThrowable<S, E>(\n  fn: () => Promise<S>,\n  mapError: (error: unknown) => E,\n): AsyncResult<S, E>;\n\nexport function fromThrowable<S, E>(\n  fn: () => Promise<S>,\n  mapError?: (error: unknown) => E,\n): AsyncResult<S, E> | AsyncResult<S, unknown> {\n  return mapError === undefined\n    ? fromThrowableImpl(fn, (error: unknown) => error)\n    : fromThrowableImpl(fn, mapError);\n}\n\nconst fromThrowableImpl = async <S, E>(\n  fn: () => Promise<S>,\n  mapError: (error: unknown) => E,\n): AsyncResult<S, E> => {\n  try {\n    return Result.ok(await fn());\n  } catch (error) {\n    return Result.err(mapError(error));\n  }\n};\n"],"names":["Result.ok","Result.err"],"mappings":";;;;AA2DO,SAAS,aAAA,CACd,IACA,QAAA,EAC6C;AAC7C,EAAA,OAAO,QAAA,KAAa,MAAA,GAChB,iBAAA,CAAkB,EAAA,EAAI,CAAC,UAAmB,KAAK,CAAA,GAC/C,iBAAA,CAAkB,EAAA,EAAI,QAAQ,CAAA;AACpC;AAEA,MAAM,iBAAA,GAAoB,OACxB,EAAA,EACA,QAAA,KACsB;AACtB,EAAA,IAAI;AACF,IAAA,OAAOA,EAAO,CAAG,MAAM,EAAA,EAAI,CAAA;AAAA,EAC7B,SAAS,KAAA,EAAO;AACd,IAAA,OAAOC,GAAO,CAAI,QAAA,CAAS,KAAK,CAAC,CAAA;AAAA,EACnC;AACF,CAAA;;;;"}

package/dist/functional/async-result/impl/async-result-map-err.d.mts

@@ -0,0 +1,35 @@
+import { type AsyncResult } from '../async-result.mjs';
+/**
+ * Maps an `AsyncResult<S, E>` to `AsyncResult<S, E2>` by applying a function
+ * to the error value. The mapping function may be synchronous or return a
+ * `Promise`; both are handled transparently. If the `AsyncResult` resolves to
+ * `Ok`, the original `Ok` is passed through and the function is not called.
+ *
+ * If `mapFn` throws or returns a rejecting Promise, the rejection propagates
+ * as-is — it is **not** caught and converted into an `Err`.
+ *
+ * @example
+ *
+ * ```ts
+ * const errValue = AsyncResult.fromPromise(
+ *   Promise.reject(new Error('boom')),
+ *   () => 'failure',
+ * );
+ *
+ * const uppercased = await AsyncResult.mapErr(errValue, (error) =>
+ *   error.toUpperCase(),
+ * );
+ *
+ * assert.deepStrictEqual(uppercased, Result.err('FAILURE'));
+ * ```
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value of the input.
+ * @template E2 The type of the error value returned by the mapping function.
+ * @param asyncResult The `AsyncResult` to map.
+ * @param mapFn The function to apply to the error value if present.
+ * @returns A new `AsyncResult<S, E2>`.
+ */
+export declare function mapErr<S, E, E2>(asyncResult: AsyncResult<S, E>, mapFn: (error: E) => E2 | Promise<E2>): AsyncResult<S, E2>;
+export declare function mapErr<E, E2>(mapFn: (error: E) => E2 | Promise<E2>): <S>(asyncResult: AsyncResult<S, E>) => AsyncResult<S, E2>;
+//# sourceMappingURL=async-result-map-err.d.mts.map

package/dist/functional/async-result/impl/async-result-map-err.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-map-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-map-err.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAC7B,WAAW,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAC9B,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,GACpC,WAAW,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAQtB,wBAAgB,MAAM,CAAC,CAAC,EAAE,EAAE,EAC1B,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,GACpC,CAAC,CAAC,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC"}

package/dist/functional/async-result/impl/async-result-map-err.mjs

@@ -0,0 +1,23 @@
+import { err } from '../../result/impl/result-err.mjs';
+import { isOk } from '../../result/impl/result-is-ok.mjs';
+import '@sindresorhus/is';
+
+function mapErr(...args) {
+  switch (args.length) {
+    case 2: {
+      const [asyncResult, mapFn] = args;
+      return mapErrImpl(asyncResult, mapFn);
+    }
+    case 1: {
+      const [mapFn] = args;
+      return (asyncResult) => mapErrImpl(asyncResult, mapFn);
+    }
+  }
+}
+const mapErrImpl = async (asyncResult, mapFn) => {
+  const result = await asyncResult;
+  return isOk(result) ? result : err(await mapFn(result.value));
+};
+
+export { mapErr };
+//# sourceMappingURL=async-result-map-err.mjs.map

package/dist/functional/async-result/impl/async-result-map-err.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-map-err.mjs","sources":["../../../../src/functional/async-result/impl/async-result-map-err.mts"],"sourcesContent":["import { Result } from '../../result/index.mjs';\nimport { type AsyncResult } from '../async-result.mjs';\n\n/**\n * Maps an `AsyncResult<S, E>` to `AsyncResult<S, E2>` by applying a function\n * to the error value. The mapping function may be synchronous or return a\n * `Promise`; both are handled transparently. If the `AsyncResult` resolves to\n * `Ok`, the original `Ok` is passed through and the function is not called.\n *\n * If `mapFn` throws or returns a rejecting Promise, the rejection propagates\n * as-is — it is **not** caught and converted into an `Err`.\n *\n * @example\n *\n * ```ts\n * const errValue = AsyncResult.fromPromise(\n *   Promise.reject(new Error('boom')),\n *   () => 'failure',\n * );\n *\n * const uppercased = await AsyncResult.mapErr(errValue, (error) =>\n *   error.toUpperCase(),\n * );\n *\n * assert.deepStrictEqual(uppercased, Result.err('FAILURE'));\n * ```\n *\n * @template S The type of the success value.\n * @template E The type of the error value of the input.\n * @template E2 The type of the error value returned by the mapping function.\n * @param asyncResult The `AsyncResult` to map.\n * @param mapFn The function to apply to the error value if present.\n * @returns A new `AsyncResult<S, E2>`.\n */\nexport function mapErr<S, E, E2>(\n  asyncResult: AsyncResult<S, E>,\n  mapFn: (error: E) => E2 | Promise<E2>,\n): AsyncResult<S, E2>;\n\n// Curried version\n//\n// Unlike `Result.mapErr`, the returned function can simply be generic over\n// `S`: an `AsyncResult` is a `Promise`, not a discriminated union, so there\n// is no literal-narrowing problem that would require the whole-result\n// generic trick used by the synchronous combinators.\nexport function mapErr<E, E2>(\n  mapFn: (error: E) => E2 | Promise<E2>,\n): <S>(asyncResult: AsyncResult<S, E>) => AsyncResult<S, E2>;\n\nexport function mapErr<S, E, E2>(\n  ...args:\n    | readonly [\n        asyncResult: AsyncResult<S, E>,\n        mapFn: (error: E) => E2 | Promise<E2>,\n      ]\n    | readonly [mapFn: (error: E) => E2 | Promise<E2>]\n):\n  | AsyncResult<S, E2>\n  | ((asyncResult: AsyncResult<S, E>) => AsyncResult<S, E2>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is asyncResult\n      const [asyncResult, mapFn] = args;\n\n      return mapErrImpl(asyncResult, mapFn);\n    }\n\n    case 1: {\n      // Curried version: first argument is mapping function\n      const [mapFn] = args;\n\n      return (asyncResult: AsyncResult<S, E>) => mapErrImpl(asyncResult, mapFn);\n    }\n  }\n}\n\nconst mapErrImpl = async <S, E, E2>(\n  asyncResult: AsyncResult<S, E>,\n  mapFn: (error: E) => E2 | Promise<E2>,\n): AsyncResult<S, E2> => {\n  const result = await asyncResult;\n\n  return Result.isOk(result) ? result : Result.err(await mapFn(result.value));\n};\n"],"names":["Result.isOk","Result.err"],"mappings":";;;;AAiDO,SAAS,UACX,IAAA,EAQwD;AAC3D,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,WAAA,EAAa,KAAK,CAAA,GAAI,IAAA;AAE7B,MAAA,OAAO,UAAA,CAAW,aAAa,KAAK,CAAA;AAAA,IACtC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,WAAA,KAAmC,UAAA,CAAW,WAAA,EAAa,KAAK,CAAA;AAAA,IAC1E;AAAA;AAEJ;AAEA,MAAM,UAAA,GAAa,OACjB,WAAA,EACA,KAAA,KACuB;AACvB,EAAA,MAAM,SAAS,MAAM,WAAA;AAErB,EAAA,OAAOA,IAAO,CAAK,MAAM,CAAA,GAAI,MAAA,GAASC,GAAO,CAAI,MAAM,KAAA,CAAM,MAAA,CAAO,KAAK,CAAC,CAAA;AAC5E,CAAA;;;;"}