nalloc 0.0.2 → 0.0.3

package/build/option.cjs

@@ -214,8 +214,9 @@ function orElse(opt, fn) {
     return (0, _typescjs.isSome)(opt) ? opt : fn();
 }
 function xor(opt, optb) {
-    if ((0, _typescjs.isSome)(opt) && (0, _typescjs.isNone)(optb)) return opt;
-    if ((0, _typescjs.isNone)(opt) && (0, _typescjs.isSome)(optb)) return optb;
+    const a = (0, _typescjs.isSome)(opt);
+    const b = (0, _typescjs.isSome)(optb);
+    if (a !== b) return a ? opt : optb;
     return _typescjs.NONE;
 }
 function and(opt, optb) {

package/build/option.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/option.ts"],"sourcesContent":["import { NONE, EMPTY, isSome, isNone, optionOf as of, err, isOk, isErr } from './types.js';\nimport type { Some, None, Option, NoneValueType, ValueType, Result, Ok, Widen } from './types.js';\n\nexport type { Some, None, Option };\nexport { isSome, isNone, of };\n\n/**\n * Creates an Option from a nullable value with widened types.\n * @param value - The value to wrap\n * @returns Some(value) if non-null, None otherwise\n * @example\n * fromNullable(42)   // Some(42) with type Option<number>\n * fromNullable(null) // None\n */\nexport function fromNullable(value: null): None;\nexport function fromNullable(value: undefined): None;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>>;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>> {\n  return of(value) as Option<Widen<T>>;\n}\n\n/**\n * Creates an Option from a Promise. Resolves to Some if successful, None on rejection.\n * @param promise - The promise to convert\n * @param onRejected - Optional handler for rejected promises\n * @returns Promise resolving to Some(value) or None\n * @example\n * await fromPromise(Promise.resolve(42))     // Some(42)\n * await fromPromise(Promise.reject('error')) // None\n */\nexport async function fromPromise<T>(promise: Promise<T | NoneValueType>, onRejected?: (error: unknown) => T | NoneValueType): Promise<Option<T>> {\n  try {\n    const value = await promise;\n    return of(value as T);\n  } catch (error) {\n    if (!onRejected) {\n      return NONE;\n    }\n    return of(onRejected(error));\n  }\n}\n\n/**\n * Unwraps an Option or returns a computed value if None.\n * @param opt - The Option to unwrap\n * @param onNone - Function called if opt is None\n * @returns The value if Some, or the result of onNone()\n * @example\n * unwrapOrReturn(some(42), () => 0)  // 42\n * unwrapOrReturn(none, () => 0)      // 0\n */\nexport function unwrapOrReturn<T, R>(opt: Option<T>, onNone: () => R): Widen<T> | R {\n  return isSome(opt) ? (opt as Widen<T>) : onNone();\n}\n\n/**\n * Asserts that an Option is Some, throwing if None.\n * @param opt - The Option to assert\n * @param message - Custom error message\n * @throws Error if opt is None\n * @example\n * assertSome(some(42))  // passes\n * assertSome(none)      // throws Error\n */\nexport function assertSome<T>(opt: Option<T>, message?: string): asserts opt is Some<ValueType<T>> {\n  if (isNone(opt)) {\n    throw new Error(message ?? 'Expected Option to contain a value');\n  }\n}\n\n/**\n * Compile-time type assertion helper to satisfy Option type constraints.\n *\n * WARNING: This function performs NO runtime validation. It is a no-op at\n * runtime to preserve zero-allocation semantics. Use assertSome() if you\n * need runtime validation that a value is Some.\n *\n * @param _ - The value to assert as Option (not validated at runtime)\n * @example\n * const value: number | null = getValue();\n * satisfiesOption(value); // Compiles, but no runtime check\n * // value is now typed as Option<number>\n */\nexport function satisfiesOption<T>(_: Option<T> | T): asserts _ is Option<T> {\n  // Compile-time only - no runtime validation to preserve zero-allocation semantics.\n}\n\n/**\n * Maps and filters an iterable, collecting only Some values.\n * @param values - The iterable to process\n * @param fn - Function that returns Option for each value\n * @returns Array of unwrapped Some values\n * @example\n * filterMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // [4, 6]\n */\nexport function filterMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): U[] {\n  const collected: U[] = [];\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) collected.push(mapped);\n  }\n  return collected;\n}\n\n/**\n * Finds the first element that maps to Some, returning that value.\n * @param values - Iterable to search\n * @param fn - Function that returns Some for matches\n * @returns The first Some value, or None if no match\n * @example\n * findMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // Some(4)\n * findMap([1], n => n > 5 ? some(n) : none)           // None\n */\nexport function findMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): Option<U> {\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) return mapped;\n  }\n  return NONE;\n}\n\n/**\n * Transforms the value inside a Some, or returns None.\n * @param opt - The Option to map\n * @param fn - Transform function\n * @returns Some(fn(value)) if Some, None otherwise\n * @example\n * map(some(2), x => x * 2) // Some(4)\n * map(none, x => x * 2)    // None\n */\nexport function map<T, U>(opt: None, fn: (value: T) => U): None;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U>;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U> {\n  if (isNone(opt)) return NONE;\n  const result = fn(opt);\n  return result === null || result === undefined ? NONE : (result as Some<ValueType<U>>);\n}\n\n/**\n * Chains Option-returning functions. Returns None if the input is None.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n * @example\n * flatMap(some(2), x => some(x * 2)) // Some(4)\n * flatMap(some(2), x => none)        // None\n * flatMap(none, x => some(x * 2))    // None\n */\nexport function flatMap<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Alias for flatMap. Chains Option-returning functions.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n */\nexport function andThen<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Executes a side effect if Some, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tap(some(42), x => console.log(x)) // logs 42, returns Some(42)\n */\nexport function tap<T>(opt: None, fn: (value: T) => void): None;\nexport function tap<T>(opt: Some<T>, fn: (value: T) => void): Some<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T> {\n  if (isSome(opt)) {\n    fn(opt);\n  }\n  return opt;\n}\n\n/**\n * Returns true if None, or if Some and predicate returns true.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if None or predicate(value) is true\n * @example\n * isNoneOr(none, x => x > 2)    // true\n * isNoneOr(some(4), x => x > 2) // true\n * isNoneOr(some(1), x => x > 2) // false\n */\nexport function isNoneOr<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isNone(opt) || predicate(opt);\n}\n\n/**\n * Returns Some if the value passes the predicate, None otherwise.\n * @param opt - The Option to filter\n * @param predicate - Test function\n * @returns Some if predicate returns true, None otherwise\n * @example\n * filter(some(4), x => x > 2) // Some(4)\n * filter(some(1), x => x > 2) // None\n */\nexport function filter<T>(opt: None, predicate: (value: T) => boolean): None;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T>;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T> {\n  return isSome(opt) && predicate(opt) ? opt : NONE;\n}\n\n/**\n * Extracts the value from Some, throws if None.\n * @param opt - The Option to unwrap\n * @returns The contained value\n * @throws Error if opt is None\n * @example\n * unwrap(some(42)) // 42\n * unwrap(none)     // throws Error\n */\nexport function unwrap<T>(opt: Option<T>): T {\n  if (isNone(opt)) {\n    throw new Error('Called unwrap on None');\n  }\n  return opt;\n}\n\n/**\n * Extracts the value from Some, or returns a default value.\n * @param opt - The Option to unwrap\n * @param defaultValue - Value to return if None\n * @returns The contained value or defaultValue\n * @example\n * unwrapOr(some(42), 0) // 42\n * unwrapOr(none, 0)     // 0\n */\nexport function unwrapOr<T>(opt: Option<T>, defaultValue: T): T {\n  return isSome(opt) ? opt : defaultValue;\n}\n\n/**\n * Extracts the value from Some, or computes a default.\n * @param opt - The Option to unwrap\n * @param fn - Function to compute default value\n * @returns The contained value or fn()\n * @example\n * unwrapOrElse(some(42), () => 0) // 42\n * unwrapOrElse(none, () => 0)     // 0\n */\nexport function unwrapOrElse<T>(opt: Option<T>, fn: () => T): T {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Extracts the value from Some, throws with custom message if None.\n * @param opt - The Option to unwrap\n * @param message - Error message if None\n * @returns The contained value\n * @throws Error with message if opt is None\n * @example\n * expect(some(42), 'missing value') // 42\n * expect(none, 'missing value')     // throws Error('missing value')\n */\nexport function expect<T>(opt: Option<T>, message: string): T {\n  if (isNone(opt)) {\n    throw new Error(message);\n  }\n  return opt;\n}\n\n/**\n * Returns the first Some, or the second Option if the first is None.\n * @param opt - First Option\n * @param optb - Fallback Option\n * @returns opt if Some, optb otherwise\n * @example\n * or(some(1), some(2)) // Some(1)\n * or(none, some(2))    // Some(2)\n */\nexport function or<T>(opt: Some<T>, optb: Option<T>): Some<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  return isSome(opt) ? opt : optb;\n}\n\n/**\n * Returns opt if Some, otherwise computes a fallback Option.\n * @param opt - First Option\n * @param fn - Function to compute fallback\n * @returns opt if Some, fn() otherwise\n * @example\n * orElse(some(1), () => some(2)) // Some(1)\n * orElse(none, () => some(2))    // Some(2)\n */\nexport function orElse<T>(opt: Some<T>, fn: () => Option<T>): Some<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T> {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Returns Some if exactly one of the Options is Some.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns Some if exactly one is Some, None otherwise\n * @example\n * xor(some(1), none)    // Some(1)\n * xor(none, some(2))    // Some(2)\n * xor(some(1), some(2)) // None\n * xor(none, none)       // None\n */\nexport function xor<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  if (isSome(opt) && isNone(optb)) return opt;\n  if (isNone(opt) && isSome(optb)) return optb;\n  return NONE;\n}\n\n/**\n * Returns optb if opt is Some, None otherwise.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns optb if opt is Some, None otherwise\n * @example\n * and(some(1), some(2)) // Some(2)\n * and(none, some(2))    // None\n */\nexport function and<U>(opt: None, optb: Option<U>): None;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U>;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U> {\n  return isSome(opt) ? optb : NONE;\n}\n\n/**\n * Combines two Options into an Option of a tuple.\n * @param opt - First Option\n * @param other - Second Option\n * @returns Some([a, b]) if both are Some, None otherwise\n * @example\n * zip(some(1), some('a')) // Some([1, 'a'])\n * zip(some(1), none)      // None\n */\nexport function zip<T, U>(opt: Option<T>, other: Option<U>): Option<[T, U]> {\n  return isSome(opt) && isSome(other) ? ([opt, other] as Some<[T, U]>) : NONE;\n}\n\n/**\n * Splits an Option of a tuple into a tuple of Options.\n * @param opt - Option containing a tuple\n * @returns Tuple of Options\n * @example\n * unzip(some([1, 'a'])) // [Some(1), Some('a')]\n * unzip(none)           // [None, None]\n */\nexport function unzip<T, U>(opt: Option<[T, U]>): [Option<T>, Option<U>] {\n  if (isNone(opt)) return [NONE, NONE];\n  const [a, b] = opt;\n  return [of(a), of(b)];\n}\n\n/**\n * Maps the value and returns it, or returns a default.\n * @param opt - The Option to map\n * @param defaultValue - Value if None\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultValue otherwise\n * @example\n * mapOr(some(2), 0, x => x * 2) // 4\n * mapOr(none, 0, x => x * 2)    // 0\n */\nexport function mapOr<T, U>(opt: Option<T>, defaultValue: U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultValue;\n}\n\n/**\n * Maps the value and returns it, or computes a default.\n * @param opt - The Option to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultFn() otherwise\n * @example\n * mapOrElse(some(2), () => 0, x => x * 2) // 4\n * mapOrElse(none, () => 0, x => x * 2)    // 0\n */\nexport function mapOrElse<T, U>(opt: Option<T>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultFn();\n}\n\n/**\n * Flattens a nested Option.\n * @param opt - Option containing an Option\n * @returns The inner Option\n * @example\n * flatten(some(some(42))) // Some(42)\n * flatten(some(none))     // None\n * flatten(none)           // None\n */\nexport function flatten<T>(opt: Option<Option<T>>): Option<T> {\n  return isNone(opt) ? NONE : (opt as Option<T>);\n}\n\n/**\n * Checks if the Option contains a specific value (using ===).\n * @param opt - The Option to check\n * @param value - The value to compare\n * @returns true if Some and value matches\n * @example\n * contains(some(42), 42) // true\n * contains(some(42), 0)  // false\n * contains(none, 42)     // false\n */\nexport function contains<T>(opt: Option<T>, value: T): boolean {\n  return isSome(opt) && opt === value;\n}\n\n/**\n * Checks if Some and the value satisfies a predicate.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if Some and predicate returns true\n * @example\n * isSomeAnd(some(4), x => x > 2) // true\n * isSomeAnd(some(1), x => x > 2) // false\n * isSomeAnd(none, x => x > 2)    // false\n */\nexport function isSomeAnd<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isSome(opt) && predicate(opt);\n}\n\n/**\n * Converts an Option to an array.\n * @param opt - The Option to convert\n * @returns [value] if Some, [] if None\n * @example\n * toArray(some(42)) // [42]\n * toArray(none)     // []\n */\nexport function toArray<T>(opt: Option<T>): readonly T[] {\n  return isSome(opt) ? [opt] : (EMPTY as readonly T[]);\n}\n\n/**\n * Converts an Option to a nullable value.\n * @param opt - The Option to convert\n * @returns The value if Some, null if None\n * @example\n * toNullable(some(42)) // 42\n * toNullable(none)     // null\n */\nexport function toNullable<T>(opt: Option<T>): T | null {\n  return isSome(opt) ? opt : null;\n}\n\n/**\n * Converts an Option to an undefined-able value.\n * @param opt - The Option to convert\n * @returns The value if Some, undefined if None\n * @example\n * toUndefined(some(42)) // 42\n * toUndefined(none)     // undefined\n */\nexport function toUndefined<T>(opt: Option<T>): T | undefined {\n  return isSome(opt) ? opt : undefined;\n}\n\n/**\n * Pattern matches on an Option, handling both Some and None cases.\n * @param opt - The Option to match\n * @param onSome - Handler for Some case\n * @param onNone - Handler for None case\n * @returns Result of the matching handler\n * @example\n * match(some(42), x => x * 2, () => 0) // 84\n * match(none, x => x * 2, () => 0)     // 0\n */\nexport function match<T, U>(opt: Option<T>, onSome: (value: T) => U, onNone: () => U): U {\n  return isSome(opt) ? onSome(opt) : onNone();\n}\n\n/**\n * Converts an Option to a Result, using a provided error if None.\n * @param opt - The Option to convert\n * @param error - Error value if None\n * @returns Ok(value) if Some, Err(error) if None\n * @example\n * okOr(some(42), 'missing') // Ok(42)\n * okOr(none, 'missing')     // Err('missing')\n */\nexport function okOr<T, E>(opt: Option<T>, error: E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(error);\n}\n\n/**\n * Converts an Option to a Result, computing the error if None.\n * @param opt - The Option to convert\n * @param fn - Function to compute error\n * @returns Ok(value) if Some, Err(fn()) if None\n * @example\n * okOrElse(some(42), () => 'missing') // Ok(42)\n * okOrElse(none, () => 'missing')     // Err('missing')\n */\nexport function okOrElse<T, E>(opt: Option<T>, fn: () => E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(fn());\n}\n\n/**\n * Extracts the Ok value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * ofOk(ok(42))        // Some(42)\n * ofOk(err('failed')) // None\n */\nexport function ofOk<T, E>(result: Result<T, E>): Option<T> {\n  if (!isOk(result) || !isSome(result)) {\n    return NONE;\n  }\n  return result as Some<T>;\n}\n\n/**\n * Extracts the Err value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * ofErr(err('failed')) // Some('failed')\n * ofErr(ok(42))        // None\n */\nexport function ofErr<T, E>(result: Result<T, E>): Option<E> {\n  if (!isErr(result)) {\n    return NONE;\n  }\n  const error = (result as { error: E }).error;\n  if (!isSome(error)) {\n    return NONE;\n  }\n  return error as Some<E>;\n}\n"],"names":["and","andThen","assertSome","contains","expect","filter","filterMap","findMap","flatMap","flatten","fromNullable","fromPromise","isNone","isNoneOr","isSome","isSomeAnd","map","mapOr","mapOrElse","match","of","ofErr","ofOk","okOr","okOrElse","or","orElse","satisfiesOption","tap","toArray","toNullable","toUndefined","unwrap","unwrapOr","unwrapOrElse","unwrapOrReturn","unzip","xor","zip","value","promise","onRejected","error","NONE","opt","onNone","message","Error","_","values","fn","collected","mapped","push","result","undefined","predicate","defaultValue","optb","other","a","b","defaultFn","EMPTY","onSome","err","isOk","isErr"],"mappings":"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"}
+{"version":3,"sources":["../src/option.ts"],"sourcesContent":["import { NONE, EMPTY, isSome, isNone, optionOf as of, err, isOk, isErr } from './types.js';\nimport type { Some, None, Option, NoneValueType, ValueType, Result, Ok, Widen } from './types.js';\n\nexport type { Some, None, Option };\nexport { isSome, isNone, of };\n\n/**\n * Creates an Option from a nullable value with widened types.\n * @param value - The value to wrap\n * @returns Some(value) if non-null, None otherwise\n * @example\n * fromNullable(42)   // Some(42) with type Option<number>\n * fromNullable(null) // None\n */\nexport function fromNullable(value: null): None;\nexport function fromNullable(value: undefined): None;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>>;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>> {\n  return of(value) as Option<Widen<T>>;\n}\n\n/**\n * Creates an Option from a Promise. Resolves to Some if successful, None on rejection.\n * @param promise - The promise to convert\n * @param onRejected - Optional handler for rejected promises\n * @returns Promise resolving to Some(value) or None\n * @example\n * await fromPromise(Promise.resolve(42))     // Some(42)\n * await fromPromise(Promise.reject('error')) // None\n */\nexport async function fromPromise<T>(promise: Promise<T | NoneValueType>, onRejected?: (error: unknown) => T | NoneValueType): Promise<Option<T>> {\n  try {\n    const value = await promise;\n    return of(value as T);\n  } catch (error) {\n    if (!onRejected) {\n      return NONE;\n    }\n    return of(onRejected(error));\n  }\n}\n\n/**\n * Unwraps an Option or returns a computed value if None.\n * @param opt - The Option to unwrap\n * @param onNone - Function called if opt is None\n * @returns The value if Some, or the result of onNone()\n * @example\n * unwrapOrReturn(some(42), () => 0)  // 42\n * unwrapOrReturn(none, () => 0)      // 0\n */\nexport function unwrapOrReturn<T, R>(opt: Option<T>, onNone: () => R): Widen<T> | R {\n  return isSome(opt) ? (opt as Widen<T>) : onNone();\n}\n\n/**\n * Asserts that an Option is Some, throwing if None.\n * @param opt - The Option to assert\n * @param message - Custom error message\n * @throws Error if opt is None\n * @example\n * assertSome(some(42))  // passes\n * assertSome(none)      // throws Error\n */\nexport function assertSome<T>(opt: Option<T>, message?: string): asserts opt is Some<ValueType<T>> {\n  if (isNone(opt)) {\n    throw new Error(message ?? 'Expected Option to contain a value');\n  }\n}\n\n/**\n * Compile-time type assertion helper to satisfy Option type constraints.\n *\n * WARNING: This function performs NO runtime validation. It is a no-op at\n * runtime to preserve zero-allocation semantics. Use assertSome() if you\n * need runtime validation that a value is Some.\n *\n * @param _ - The value to assert as Option (not validated at runtime)\n * @example\n * const value: number | null = getValue();\n * satisfiesOption(value); // Compiles, but no runtime check\n * // value is now typed as Option<number>\n */\nexport function satisfiesOption<T>(_: Option<T> | T): asserts _ is Option<T> {\n  // Compile-time only - no runtime validation to preserve zero-allocation semantics.\n}\n\n/**\n * Maps and filters an iterable, collecting only Some values.\n * @param values - The iterable to process\n * @param fn - Function that returns Option for each value\n * @returns Array of unwrapped Some values\n * @example\n * filterMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // [4, 6]\n */\nexport function filterMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): U[] {\n  const collected: U[] = [];\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) collected.push(mapped);\n  }\n  return collected;\n}\n\n/**\n * Finds the first element that maps to Some, returning that value.\n * @param values - Iterable to search\n * @param fn - Function that returns Some for matches\n * @returns The first Some value, or None if no match\n * @example\n * findMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // Some(4)\n * findMap([1], n => n > 5 ? some(n) : none)           // None\n */\nexport function findMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): Option<U> {\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) return mapped;\n  }\n  return NONE;\n}\n\n/**\n * Transforms the value inside a Some, or returns None.\n * @param opt - The Option to map\n * @param fn - Transform function\n * @returns Some(fn(value)) if Some, None otherwise\n * @example\n * map(some(2), x => x * 2) // Some(4)\n * map(none, x => x * 2)    // None\n */\nexport function map<T, U>(opt: None, fn: (value: T) => U): None;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U>;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U> {\n  if (isNone(opt)) return NONE;\n  const result = fn(opt);\n  return result === null || result === undefined ? NONE : (result as Some<ValueType<U>>);\n}\n\n/**\n * Chains Option-returning functions. Returns None if the input is None.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n * @example\n * flatMap(some(2), x => some(x * 2)) // Some(4)\n * flatMap(some(2), x => none)        // None\n * flatMap(none, x => some(x * 2))    // None\n */\nexport function flatMap<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Alias for flatMap. Chains Option-returning functions.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n */\nexport function andThen<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Executes a side effect if Some, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tap(some(42), x => console.log(x)) // logs 42, returns Some(42)\n */\nexport function tap<T>(opt: None, fn: (value: T) => void): None;\nexport function tap<T>(opt: Some<T>, fn: (value: T) => void): Some<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T> {\n  if (isSome(opt)) {\n    fn(opt);\n  }\n  return opt;\n}\n\n/**\n * Returns true if None, or if Some and predicate returns true.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if None or predicate(value) is true\n * @example\n * isNoneOr(none, x => x > 2)    // true\n * isNoneOr(some(4), x => x > 2) // true\n * isNoneOr(some(1), x => x > 2) // false\n */\nexport function isNoneOr<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isNone(opt) || predicate(opt);\n}\n\n/**\n * Returns Some if the value passes the predicate, None otherwise.\n * @param opt - The Option to filter\n * @param predicate - Test function\n * @returns Some if predicate returns true, None otherwise\n * @example\n * filter(some(4), x => x > 2) // Some(4)\n * filter(some(1), x => x > 2) // None\n */\nexport function filter<T>(opt: None, predicate: (value: T) => boolean): None;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T>;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T> {\n  return isSome(opt) && predicate(opt) ? opt : NONE;\n}\n\n/**\n * Extracts the value from Some, throws if None.\n * @param opt - The Option to unwrap\n * @returns The contained value\n * @throws Error if opt is None\n * @example\n * unwrap(some(42)) // 42\n * unwrap(none)     // throws Error\n */\nexport function unwrap<T>(opt: Option<T>): T {\n  if (isNone(opt)) {\n    throw new Error('Called unwrap on None');\n  }\n  return opt;\n}\n\n/**\n * Extracts the value from Some, or returns a default value.\n * @param opt - The Option to unwrap\n * @param defaultValue - Value to return if None\n * @returns The contained value or defaultValue\n * @example\n * unwrapOr(some(42), 0) // 42\n * unwrapOr(none, 0)     // 0\n */\nexport function unwrapOr<T>(opt: Option<T>, defaultValue: T): T {\n  return isSome(opt) ? opt : defaultValue;\n}\n\n/**\n * Extracts the value from Some, or computes a default.\n * @param opt - The Option to unwrap\n * @param fn - Function to compute default value\n * @returns The contained value or fn()\n * @example\n * unwrapOrElse(some(42), () => 0) // 42\n * unwrapOrElse(none, () => 0)     // 0\n */\nexport function unwrapOrElse<T>(opt: Option<T>, fn: () => T): T {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Extracts the value from Some, throws with custom message if None.\n * @param opt - The Option to unwrap\n * @param message - Error message if None\n * @returns The contained value\n * @throws Error with message if opt is None\n * @example\n * expect(some(42), 'missing value') // 42\n * expect(none, 'missing value')     // throws Error('missing value')\n */\nexport function expect<T>(opt: Option<T>, message: string): T {\n  if (isNone(opt)) {\n    throw new Error(message);\n  }\n  return opt;\n}\n\n/**\n * Returns the first Some, or the second Option if the first is None.\n * @param opt - First Option\n * @param optb - Fallback Option\n * @returns opt if Some, optb otherwise\n * @example\n * or(some(1), some(2)) // Some(1)\n * or(none, some(2))    // Some(2)\n */\nexport function or<T>(opt: Some<T>, optb: Option<T>): Some<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  return isSome(opt) ? opt : optb;\n}\n\n/**\n * Returns opt if Some, otherwise computes a fallback Option.\n * @param opt - First Option\n * @param fn - Function to compute fallback\n * @returns opt if Some, fn() otherwise\n * @example\n * orElse(some(1), () => some(2)) // Some(1)\n * orElse(none, () => some(2))    // Some(2)\n */\nexport function orElse<T>(opt: Some<T>, fn: () => Option<T>): Some<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T> {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Returns Some if exactly one of the Options is Some.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns Some if exactly one is Some, None otherwise\n * @example\n * xor(some(1), none)    // Some(1)\n * xor(none, some(2))    // Some(2)\n * xor(some(1), some(2)) // None\n * xor(none, none)       // None\n */\nexport function xor<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  const a = isSome(opt);\n  const b = isSome(optb);\n  if (a !== b) return a ? opt : optb;\n  return NONE;\n}\n\n/**\n * Returns optb if opt is Some, None otherwise.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns optb if opt is Some, None otherwise\n * @example\n * and(some(1), some(2)) // Some(2)\n * and(none, some(2))    // None\n */\nexport function and<U>(opt: None, optb: Option<U>): None;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U>;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U> {\n  return isSome(opt) ? optb : NONE;\n}\n\n/**\n * Combines two Options into an Option of a tuple.\n * @param opt - First Option\n * @param other - Second Option\n * @returns Some([a, b]) if both are Some, None otherwise\n * @example\n * zip(some(1), some('a')) // Some([1, 'a'])\n * zip(some(1), none)      // None\n */\nexport function zip<T, U>(opt: Option<T>, other: Option<U>): Option<[T, U]> {\n  return isSome(opt) && isSome(other) ? ([opt, other] as Some<[T, U]>) : NONE;\n}\n\n/**\n * Splits an Option of a tuple into a tuple of Options.\n * @param opt - Option containing a tuple\n * @returns Tuple of Options\n * @example\n * unzip(some([1, 'a'])) // [Some(1), Some('a')]\n * unzip(none)           // [None, None]\n */\nexport function unzip<T, U>(opt: Option<[T, U]>): [Option<T>, Option<U>] {\n  if (isNone(opt)) return [NONE, NONE];\n  const [a, b] = opt;\n  return [of(a), of(b)];\n}\n\n/**\n * Maps the value and returns it, or returns a default.\n * @param opt - The Option to map\n * @param defaultValue - Value if None\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultValue otherwise\n * @example\n * mapOr(some(2), 0, x => x * 2) // 4\n * mapOr(none, 0, x => x * 2)    // 0\n */\nexport function mapOr<T, U>(opt: Option<T>, defaultValue: U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultValue;\n}\n\n/**\n * Maps the value and returns it, or computes a default.\n * @param opt - The Option to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultFn() otherwise\n * @example\n * mapOrElse(some(2), () => 0, x => x * 2) // 4\n * mapOrElse(none, () => 0, x => x * 2)    // 0\n */\nexport function mapOrElse<T, U>(opt: Option<T>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultFn();\n}\n\n/**\n * Flattens a nested Option.\n * @param opt - Option containing an Option\n * @returns The inner Option\n * @example\n * flatten(some(some(42))) // Some(42)\n * flatten(some(none))     // None\n * flatten(none)           // None\n */\nexport function flatten<T>(opt: Option<Option<T>>): Option<T> {\n  return isNone(opt) ? NONE : (opt as Option<T>);\n}\n\n/**\n * Checks if the Option contains a specific value (using ===).\n * @param opt - The Option to check\n * @param value - The value to compare\n * @returns true if Some and value matches\n * @example\n * contains(some(42), 42) // true\n * contains(some(42), 0)  // false\n * contains(none, 42)     // false\n */\nexport function contains<T>(opt: Option<T>, value: T): boolean {\n  return isSome(opt) && opt === value;\n}\n\n/**\n * Checks if Some and the value satisfies a predicate.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if Some and predicate returns true\n * @example\n * isSomeAnd(some(4), x => x > 2) // true\n * isSomeAnd(some(1), x => x > 2) // false\n * isSomeAnd(none, x => x > 2)    // false\n */\nexport function isSomeAnd<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isSome(opt) && predicate(opt);\n}\n\n/**\n * Converts an Option to an array.\n * @param opt - The Option to convert\n * @returns [value] if Some, [] if None\n * @example\n * toArray(some(42)) // [42]\n * toArray(none)     // []\n */\nexport function toArray<T>(opt: Option<T>): readonly T[] {\n  return isSome(opt) ? [opt] : (EMPTY as readonly T[]);\n}\n\n/**\n * Converts an Option to a nullable value.\n * @param opt - The Option to convert\n * @returns The value if Some, null if None\n * @example\n * toNullable(some(42)) // 42\n * toNullable(none)     // null\n */\nexport function toNullable<T>(opt: Option<T>): T | null {\n  return isSome(opt) ? opt : null;\n}\n\n/**\n * Converts an Option to an undefined-able value.\n * @param opt - The Option to convert\n * @returns The value if Some, undefined if None\n * @example\n * toUndefined(some(42)) // 42\n * toUndefined(none)     // undefined\n */\nexport function toUndefined<T>(opt: Option<T>): T | undefined {\n  return isSome(opt) ? opt : undefined;\n}\n\n/**\n * Pattern matches on an Option, handling both Some and None cases.\n * @param opt - The Option to match\n * @param onSome - Handler for Some case\n * @param onNone - Handler for None case\n * @returns Result of the matching handler\n * @example\n * match(some(42), x => x * 2, () => 0) // 84\n * match(none, x => x * 2, () => 0)     // 0\n */\nexport function match<T, U>(opt: Option<T>, onSome: (value: T) => U, onNone: () => U): U {\n  return isSome(opt) ? onSome(opt) : onNone();\n}\n\n/**\n * Converts an Option to a Result, using a provided error if None.\n * @param opt - The Option to convert\n * @param error - Error value if None\n * @returns Ok(value) if Some, Err(error) if None\n * @example\n * okOr(some(42), 'missing') // Ok(42)\n * okOr(none, 'missing')     // Err('missing')\n */\nexport function okOr<T, E>(opt: Option<T>, error: E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(error);\n}\n\n/**\n * Converts an Option to a Result, computing the error if None.\n * @param opt - The Option to convert\n * @param fn - Function to compute error\n * @returns Ok(value) if Some, Err(fn()) if None\n * @example\n * okOrElse(some(42), () => 'missing') // Ok(42)\n * okOrElse(none, () => 'missing')     // Err('missing')\n */\nexport function okOrElse<T, E>(opt: Option<T>, fn: () => E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(fn());\n}\n\n/**\n * Extracts the Ok value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * ofOk(ok(42))        // Some(42)\n * ofOk(err('failed')) // None\n */\nexport function ofOk<T, E>(result: Result<T, E>): Option<T> {\n  if (!isOk(result) || !isSome(result)) {\n    return NONE;\n  }\n  return result as Some<T>;\n}\n\n/**\n * Extracts the Err value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * ofErr(err('failed')) // Some('failed')\n * ofErr(ok(42))        // None\n */\nexport function ofErr<T, E>(result: Result<T, E>): Option<E> {\n  if (!isErr(result)) {\n    return NONE;\n  }\n  const error = (result as { error: E }).error;\n  if (!isSome(error)) {\n    return NONE;\n  }\n  return error as Some<E>;\n}\n"],"names":["and","andThen","assertSome","contains","expect","filter","filterMap","findMap","flatMap","flatten","fromNullable","fromPromise","isNone","isNoneOr","isSome","isSomeAnd","map","mapOr","mapOrElse","match","of","ofErr","ofOk","okOr","okOrElse","or","orElse","satisfiesOption","tap","toArray","toNullable","toUndefined","unwrap","unwrapOr","unwrapOrElse","unwrapOrReturn","unzip","xor","zip","value","promise","onRejected","error","NONE","opt","onNone","message","Error","_","values","fn","collected","mapped","push","result","undefined","predicate","defaultValue","optb","a","b","other","defaultFn","EMPTY","onSome","err","isOk","isErr"],"mappings":"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"}

package/build/option.js

@@ -86,8 +86,9 @@ export function orElse(opt, fn) {
     return isSome(opt) ? opt : fn();
 }
 export function xor(opt, optb) {
-    if (isSome(opt) && isNone(optb)) return opt;
-    if (isNone(opt) && isSome(optb)) return optb;
+    const a = isSome(opt);
+    const b = isSome(optb);
+    if (a !== b) return a ? opt : optb;
     return NONE;
 }
 export function and(opt, optb) {

package/build/option.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/option.ts"],"sourcesContent":["import { NONE, EMPTY, isSome, isNone, optionOf as of, err, isOk, isErr } from './types.js';\nimport type { Some, None, Option, NoneValueType, ValueType, Result, Ok, Widen } from './types.js';\n\nexport type { Some, None, Option };\nexport { isSome, isNone, of };\n\n/**\n * Creates an Option from a nullable value with widened types.\n * @param value - The value to wrap\n * @returns Some(value) if non-null, None otherwise\n * @example\n * fromNullable(42)   // Some(42) with type Option<number>\n * fromNullable(null) // None\n */\nexport function fromNullable(value: null): None;\nexport function fromNullable(value: undefined): None;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>>;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>> {\n  return of(value) as Option<Widen<T>>;\n}\n\n/**\n * Creates an Option from a Promise. Resolves to Some if successful, None on rejection.\n * @param promise - The promise to convert\n * @param onRejected - Optional handler for rejected promises\n * @returns Promise resolving to Some(value) or None\n * @example\n * await fromPromise(Promise.resolve(42))     // Some(42)\n * await fromPromise(Promise.reject('error')) // None\n */\nexport async function fromPromise<T>(promise: Promise<T | NoneValueType>, onRejected?: (error: unknown) => T | NoneValueType): Promise<Option<T>> {\n  try {\n    const value = await promise;\n    return of(value as T);\n  } catch (error) {\n    if (!onRejected) {\n      return NONE;\n    }\n    return of(onRejected(error));\n  }\n}\n\n/**\n * Unwraps an Option or returns a computed value if None.\n * @param opt - The Option to unwrap\n * @param onNone - Function called if opt is None\n * @returns The value if Some, or the result of onNone()\n * @example\n * unwrapOrReturn(some(42), () => 0)  // 42\n * unwrapOrReturn(none, () => 0)      // 0\n */\nexport function unwrapOrReturn<T, R>(opt: Option<T>, onNone: () => R): Widen<T> | R {\n  return isSome(opt) ? (opt as Widen<T>) : onNone();\n}\n\n/**\n * Asserts that an Option is Some, throwing if None.\n * @param opt - The Option to assert\n * @param message - Custom error message\n * @throws Error if opt is None\n * @example\n * assertSome(some(42))  // passes\n * assertSome(none)      // throws Error\n */\nexport function assertSome<T>(opt: Option<T>, message?: string): asserts opt is Some<ValueType<T>> {\n  if (isNone(opt)) {\n    throw new Error(message ?? 'Expected Option to contain a value');\n  }\n}\n\n/**\n * Compile-time type assertion helper to satisfy Option type constraints.\n *\n * WARNING: This function performs NO runtime validation. It is a no-op at\n * runtime to preserve zero-allocation semantics. Use assertSome() if you\n * need runtime validation that a value is Some.\n *\n * @param _ - The value to assert as Option (not validated at runtime)\n * @example\n * const value: number | null = getValue();\n * satisfiesOption(value); // Compiles, but no runtime check\n * // value is now typed as Option<number>\n */\nexport function satisfiesOption<T>(_: Option<T> | T): asserts _ is Option<T> {\n  // Compile-time only - no runtime validation to preserve zero-allocation semantics.\n}\n\n/**\n * Maps and filters an iterable, collecting only Some values.\n * @param values - The iterable to process\n * @param fn - Function that returns Option for each value\n * @returns Array of unwrapped Some values\n * @example\n * filterMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // [4, 6]\n */\nexport function filterMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): U[] {\n  const collected: U[] = [];\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) collected.push(mapped);\n  }\n  return collected;\n}\n\n/**\n * Finds the first element that maps to Some, returning that value.\n * @param values - Iterable to search\n * @param fn - Function that returns Some for matches\n * @returns The first Some value, or None if no match\n * @example\n * findMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // Some(4)\n * findMap([1], n => n > 5 ? some(n) : none)           // None\n */\nexport function findMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): Option<U> {\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) return mapped;\n  }\n  return NONE;\n}\n\n/**\n * Transforms the value inside a Some, or returns None.\n * @param opt - The Option to map\n * @param fn - Transform function\n * @returns Some(fn(value)) if Some, None otherwise\n * @example\n * map(some(2), x => x * 2) // Some(4)\n * map(none, x => x * 2)    // None\n */\nexport function map<T, U>(opt: None, fn: (value: T) => U): None;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U>;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U> {\n  if (isNone(opt)) return NONE;\n  const result = fn(opt);\n  return result === null || result === undefined ? NONE : (result as Some<ValueType<U>>);\n}\n\n/**\n * Chains Option-returning functions. Returns None if the input is None.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n * @example\n * flatMap(some(2), x => some(x * 2)) // Some(4)\n * flatMap(some(2), x => none)        // None\n * flatMap(none, x => some(x * 2))    // None\n */\nexport function flatMap<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Alias for flatMap. Chains Option-returning functions.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n */\nexport function andThen<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Executes a side effect if Some, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tap(some(42), x => console.log(x)) // logs 42, returns Some(42)\n */\nexport function tap<T>(opt: None, fn: (value: T) => void): None;\nexport function tap<T>(opt: Some<T>, fn: (value: T) => void): Some<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T> {\n  if (isSome(opt)) {\n    fn(opt);\n  }\n  return opt;\n}\n\n/**\n * Returns true if None, or if Some and predicate returns true.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if None or predicate(value) is true\n * @example\n * isNoneOr(none, x => x > 2)    // true\n * isNoneOr(some(4), x => x > 2) // true\n * isNoneOr(some(1), x => x > 2) // false\n */\nexport function isNoneOr<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isNone(opt) || predicate(opt);\n}\n\n/**\n * Returns Some if the value passes the predicate, None otherwise.\n * @param opt - The Option to filter\n * @param predicate - Test function\n * @returns Some if predicate returns true, None otherwise\n * @example\n * filter(some(4), x => x > 2) // Some(4)\n * filter(some(1), x => x > 2) // None\n */\nexport function filter<T>(opt: None, predicate: (value: T) => boolean): None;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T>;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T> {\n  return isSome(opt) && predicate(opt) ? opt : NONE;\n}\n\n/**\n * Extracts the value from Some, throws if None.\n * @param opt - The Option to unwrap\n * @returns The contained value\n * @throws Error if opt is None\n * @example\n * unwrap(some(42)) // 42\n * unwrap(none)     // throws Error\n */\nexport function unwrap<T>(opt: Option<T>): T {\n  if (isNone(opt)) {\n    throw new Error('Called unwrap on None');\n  }\n  return opt;\n}\n\n/**\n * Extracts the value from Some, or returns a default value.\n * @param opt - The Option to unwrap\n * @param defaultValue - Value to return if None\n * @returns The contained value or defaultValue\n * @example\n * unwrapOr(some(42), 0) // 42\n * unwrapOr(none, 0)     // 0\n */\nexport function unwrapOr<T>(opt: Option<T>, defaultValue: T): T {\n  return isSome(opt) ? opt : defaultValue;\n}\n\n/**\n * Extracts the value from Some, or computes a default.\n * @param opt - The Option to unwrap\n * @param fn - Function to compute default value\n * @returns The contained value or fn()\n * @example\n * unwrapOrElse(some(42), () => 0) // 42\n * unwrapOrElse(none, () => 0)     // 0\n */\nexport function unwrapOrElse<T>(opt: Option<T>, fn: () => T): T {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Extracts the value from Some, throws with custom message if None.\n * @param opt - The Option to unwrap\n * @param message - Error message if None\n * @returns The contained value\n * @throws Error with message if opt is None\n * @example\n * expect(some(42), 'missing value') // 42\n * expect(none, 'missing value')     // throws Error('missing value')\n */\nexport function expect<T>(opt: Option<T>, message: string): T {\n  if (isNone(opt)) {\n    throw new Error(message);\n  }\n  return opt;\n}\n\n/**\n * Returns the first Some, or the second Option if the first is None.\n * @param opt - First Option\n * @param optb - Fallback Option\n * @returns opt if Some, optb otherwise\n * @example\n * or(some(1), some(2)) // Some(1)\n * or(none, some(2))    // Some(2)\n */\nexport function or<T>(opt: Some<T>, optb: Option<T>): Some<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  return isSome(opt) ? opt : optb;\n}\n\n/**\n * Returns opt if Some, otherwise computes a fallback Option.\n * @param opt - First Option\n * @param fn - Function to compute fallback\n * @returns opt if Some, fn() otherwise\n * @example\n * orElse(some(1), () => some(2)) // Some(1)\n * orElse(none, () => some(2))    // Some(2)\n */\nexport function orElse<T>(opt: Some<T>, fn: () => Option<T>): Some<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T> {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Returns Some if exactly one of the Options is Some.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns Some if exactly one is Some, None otherwise\n * @example\n * xor(some(1), none)    // Some(1)\n * xor(none, some(2))    // Some(2)\n * xor(some(1), some(2)) // None\n * xor(none, none)       // None\n */\nexport function xor<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  if (isSome(opt) && isNone(optb)) return opt;\n  if (isNone(opt) && isSome(optb)) return optb;\n  return NONE;\n}\n\n/**\n * Returns optb if opt is Some, None otherwise.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns optb if opt is Some, None otherwise\n * @example\n * and(some(1), some(2)) // Some(2)\n * and(none, some(2))    // None\n */\nexport function and<U>(opt: None, optb: Option<U>): None;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U>;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U> {\n  return isSome(opt) ? optb : NONE;\n}\n\n/**\n * Combines two Options into an Option of a tuple.\n * @param opt - First Option\n * @param other - Second Option\n * @returns Some([a, b]) if both are Some, None otherwise\n * @example\n * zip(some(1), some('a')) // Some([1, 'a'])\n * zip(some(1), none)      // None\n */\nexport function zip<T, U>(opt: Option<T>, other: Option<U>): Option<[T, U]> {\n  return isSome(opt) && isSome(other) ? ([opt, other] as Some<[T, U]>) : NONE;\n}\n\n/**\n * Splits an Option of a tuple into a tuple of Options.\n * @param opt - Option containing a tuple\n * @returns Tuple of Options\n * @example\n * unzip(some([1, 'a'])) // [Some(1), Some('a')]\n * unzip(none)           // [None, None]\n */\nexport function unzip<T, U>(opt: Option<[T, U]>): [Option<T>, Option<U>] {\n  if (isNone(opt)) return [NONE, NONE];\n  const [a, b] = opt;\n  return [of(a), of(b)];\n}\n\n/**\n * Maps the value and returns it, or returns a default.\n * @param opt - The Option to map\n * @param defaultValue - Value if None\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultValue otherwise\n * @example\n * mapOr(some(2), 0, x => x * 2) // 4\n * mapOr(none, 0, x => x * 2)    // 0\n */\nexport function mapOr<T, U>(opt: Option<T>, defaultValue: U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultValue;\n}\n\n/**\n * Maps the value and returns it, or computes a default.\n * @param opt - The Option to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultFn() otherwise\n * @example\n * mapOrElse(some(2), () => 0, x => x * 2) // 4\n * mapOrElse(none, () => 0, x => x * 2)    // 0\n */\nexport function mapOrElse<T, U>(opt: Option<T>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultFn();\n}\n\n/**\n * Flattens a nested Option.\n * @param opt - Option containing an Option\n * @returns The inner Option\n * @example\n * flatten(some(some(42))) // Some(42)\n * flatten(some(none))     // None\n * flatten(none)           // None\n */\nexport function flatten<T>(opt: Option<Option<T>>): Option<T> {\n  return isNone(opt) ? NONE : (opt as Option<T>);\n}\n\n/**\n * Checks if the Option contains a specific value (using ===).\n * @param opt - The Option to check\n * @param value - The value to compare\n * @returns true if Some and value matches\n * @example\n * contains(some(42), 42) // true\n * contains(some(42), 0)  // false\n * contains(none, 42)     // false\n */\nexport function contains<T>(opt: Option<T>, value: T): boolean {\n  return isSome(opt) && opt === value;\n}\n\n/**\n * Checks if Some and the value satisfies a predicate.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if Some and predicate returns true\n * @example\n * isSomeAnd(some(4), x => x > 2) // true\n * isSomeAnd(some(1), x => x > 2) // false\n * isSomeAnd(none, x => x > 2)    // false\n */\nexport function isSomeAnd<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isSome(opt) && predicate(opt);\n}\n\n/**\n * Converts an Option to an array.\n * @param opt - The Option to convert\n * @returns [value] if Some, [] if None\n * @example\n * toArray(some(42)) // [42]\n * toArray(none)     // []\n */\nexport function toArray<T>(opt: Option<T>): readonly T[] {\n  return isSome(opt) ? [opt] : (EMPTY as readonly T[]);\n}\n\n/**\n * Converts an Option to a nullable value.\n * @param opt - The Option to convert\n * @returns The value if Some, null if None\n * @example\n * toNullable(some(42)) // 42\n * toNullable(none)     // null\n */\nexport function toNullable<T>(opt: Option<T>): T | null {\n  return isSome(opt) ? opt : null;\n}\n\n/**\n * Converts an Option to an undefined-able value.\n * @param opt - The Option to convert\n * @returns The value if Some, undefined if None\n * @example\n * toUndefined(some(42)) // 42\n * toUndefined(none)     // undefined\n */\nexport function toUndefined<T>(opt: Option<T>): T | undefined {\n  return isSome(opt) ? opt : undefined;\n}\n\n/**\n * Pattern matches on an Option, handling both Some and None cases.\n * @param opt - The Option to match\n * @param onSome - Handler for Some case\n * @param onNone - Handler for None case\n * @returns Result of the matching handler\n * @example\n * match(some(42), x => x * 2, () => 0) // 84\n * match(none, x => x * 2, () => 0)     // 0\n */\nexport function match<T, U>(opt: Option<T>, onSome: (value: T) => U, onNone: () => U): U {\n  return isSome(opt) ? onSome(opt) : onNone();\n}\n\n/**\n * Converts an Option to a Result, using a provided error if None.\n * @param opt - The Option to convert\n * @param error - Error value if None\n * @returns Ok(value) if Some, Err(error) if None\n * @example\n * okOr(some(42), 'missing') // Ok(42)\n * okOr(none, 'missing')     // Err('missing')\n */\nexport function okOr<T, E>(opt: Option<T>, error: E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(error);\n}\n\n/**\n * Converts an Option to a Result, computing the error if None.\n * @param opt - The Option to convert\n * @param fn - Function to compute error\n * @returns Ok(value) if Some, Err(fn()) if None\n * @example\n * okOrElse(some(42), () => 'missing') // Ok(42)\n * okOrElse(none, () => 'missing')     // Err('missing')\n */\nexport function okOrElse<T, E>(opt: Option<T>, fn: () => E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(fn());\n}\n\n/**\n * Extracts the Ok value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * ofOk(ok(42))        // Some(42)\n * ofOk(err('failed')) // None\n */\nexport function ofOk<T, E>(result: Result<T, E>): Option<T> {\n  if (!isOk(result) || !isSome(result)) {\n    return NONE;\n  }\n  return result as Some<T>;\n}\n\n/**\n * Extracts the Err value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * ofErr(err('failed')) // Some('failed')\n * ofErr(ok(42))        // None\n */\nexport function ofErr<T, E>(result: Result<T, E>): Option<E> {\n  if (!isErr(result)) {\n    return NONE;\n  }\n  const error = (result as { error: E }).error;\n  if (!isSome(error)) {\n    return NONE;\n  }\n  return error as Some<E>;\n}\n"],"names":["NONE","EMPTY","isSome","isNone","optionOf","of","err","isOk","isErr","fromNullable","value","fromPromise","promise","onRejected","error","unwrapOrReturn","opt","onNone","assertSome","message","Error","satisfiesOption","_","filterMap","values","fn","collected","mapped","push","findMap","map","result","undefined","flatMap","andThen","tap","isNoneOr","predicate","filter","unwrap","unwrapOr","defaultValue","unwrapOrElse","expect","or","optb","orElse","xor","and","zip","other","unzip","a","b","mapOr","mapOrElse","defaultFn","flatten","contains","isSomeAnd","toArray","toNullable","toUndefined","match","onSome","okOr","okOrElse","ofOk","ofErr"],"mappings":"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"}
+{"version":3,"sources":["../src/option.ts"],"sourcesContent":["import { NONE, EMPTY, isSome, isNone, optionOf as of, err, isOk, isErr } from './types.js';\nimport type { Some, None, Option, NoneValueType, ValueType, Result, Ok, Widen } from './types.js';\n\nexport type { Some, None, Option };\nexport { isSome, isNone, of };\n\n/**\n * Creates an Option from a nullable value with widened types.\n * @param value - The value to wrap\n * @returns Some(value) if non-null, None otherwise\n * @example\n * fromNullable(42)   // Some(42) with type Option<number>\n * fromNullable(null) // None\n */\nexport function fromNullable(value: null): None;\nexport function fromNullable(value: undefined): None;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>>;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>> {\n  return of(value) as Option<Widen<T>>;\n}\n\n/**\n * Creates an Option from a Promise. Resolves to Some if successful, None on rejection.\n * @param promise - The promise to convert\n * @param onRejected - Optional handler for rejected promises\n * @returns Promise resolving to Some(value) or None\n * @example\n * await fromPromise(Promise.resolve(42))     // Some(42)\n * await fromPromise(Promise.reject('error')) // None\n */\nexport async function fromPromise<T>(promise: Promise<T | NoneValueType>, onRejected?: (error: unknown) => T | NoneValueType): Promise<Option<T>> {\n  try {\n    const value = await promise;\n    return of(value as T);\n  } catch (error) {\n    if (!onRejected) {\n      return NONE;\n    }\n    return of(onRejected(error));\n  }\n}\n\n/**\n * Unwraps an Option or returns a computed value if None.\n * @param opt - The Option to unwrap\n * @param onNone - Function called if opt is None\n * @returns The value if Some, or the result of onNone()\n * @example\n * unwrapOrReturn(some(42), () => 0)  // 42\n * unwrapOrReturn(none, () => 0)      // 0\n */\nexport function unwrapOrReturn<T, R>(opt: Option<T>, onNone: () => R): Widen<T> | R {\n  return isSome(opt) ? (opt as Widen<T>) : onNone();\n}\n\n/**\n * Asserts that an Option is Some, throwing if None.\n * @param opt - The Option to assert\n * @param message - Custom error message\n * @throws Error if opt is None\n * @example\n * assertSome(some(42))  // passes\n * assertSome(none)      // throws Error\n */\nexport function assertSome<T>(opt: Option<T>, message?: string): asserts opt is Some<ValueType<T>> {\n  if (isNone(opt)) {\n    throw new Error(message ?? 'Expected Option to contain a value');\n  }\n}\n\n/**\n * Compile-time type assertion helper to satisfy Option type constraints.\n *\n * WARNING: This function performs NO runtime validation. It is a no-op at\n * runtime to preserve zero-allocation semantics. Use assertSome() if you\n * need runtime validation that a value is Some.\n *\n * @param _ - The value to assert as Option (not validated at runtime)\n * @example\n * const value: number | null = getValue();\n * satisfiesOption(value); // Compiles, but no runtime check\n * // value is now typed as Option<number>\n */\nexport function satisfiesOption<T>(_: Option<T> | T): asserts _ is Option<T> {\n  // Compile-time only - no runtime validation to preserve zero-allocation semantics.\n}\n\n/**\n * Maps and filters an iterable, collecting only Some values.\n * @param values - The iterable to process\n * @param fn - Function that returns Option for each value\n * @returns Array of unwrapped Some values\n * @example\n * filterMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // [4, 6]\n */\nexport function filterMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): U[] {\n  const collected: U[] = [];\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) collected.push(mapped);\n  }\n  return collected;\n}\n\n/**\n * Finds the first element that maps to Some, returning that value.\n * @param values - Iterable to search\n * @param fn - Function that returns Some for matches\n * @returns The first Some value, or None if no match\n * @example\n * findMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // Some(4)\n * findMap([1], n => n > 5 ? some(n) : none)           // None\n */\nexport function findMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): Option<U> {\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) return mapped;\n  }\n  return NONE;\n}\n\n/**\n * Transforms the value inside a Some, or returns None.\n * @param opt - The Option to map\n * @param fn - Transform function\n * @returns Some(fn(value)) if Some, None otherwise\n * @example\n * map(some(2), x => x * 2) // Some(4)\n * map(none, x => x * 2)    // None\n */\nexport function map<T, U>(opt: None, fn: (value: T) => U): None;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U>;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U> {\n  if (isNone(opt)) return NONE;\n  const result = fn(opt);\n  return result === null || result === undefined ? NONE : (result as Some<ValueType<U>>);\n}\n\n/**\n * Chains Option-returning functions. Returns None if the input is None.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n * @example\n * flatMap(some(2), x => some(x * 2)) // Some(4)\n * flatMap(some(2), x => none)        // None\n * flatMap(none, x => some(x * 2))    // None\n */\nexport function flatMap<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Alias for flatMap. Chains Option-returning functions.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n */\nexport function andThen<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Executes a side effect if Some, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tap(some(42), x => console.log(x)) // logs 42, returns Some(42)\n */\nexport function tap<T>(opt: None, fn: (value: T) => void): None;\nexport function tap<T>(opt: Some<T>, fn: (value: T) => void): Some<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T> {\n  if (isSome(opt)) {\n    fn(opt);\n  }\n  return opt;\n}\n\n/**\n * Returns true if None, or if Some and predicate returns true.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if None or predicate(value) is true\n * @example\n * isNoneOr(none, x => x > 2)    // true\n * isNoneOr(some(4), x => x > 2) // true\n * isNoneOr(some(1), x => x > 2) // false\n */\nexport function isNoneOr<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isNone(opt) || predicate(opt);\n}\n\n/**\n * Returns Some if the value passes the predicate, None otherwise.\n * @param opt - The Option to filter\n * @param predicate - Test function\n * @returns Some if predicate returns true, None otherwise\n * @example\n * filter(some(4), x => x > 2) // Some(4)\n * filter(some(1), x => x > 2) // None\n */\nexport function filter<T>(opt: None, predicate: (value: T) => boolean): None;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T>;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T> {\n  return isSome(opt) && predicate(opt) ? opt : NONE;\n}\n\n/**\n * Extracts the value from Some, throws if None.\n * @param opt - The Option to unwrap\n * @returns The contained value\n * @throws Error if opt is None\n * @example\n * unwrap(some(42)) // 42\n * unwrap(none)     // throws Error\n */\nexport function unwrap<T>(opt: Option<T>): T {\n  if (isNone(opt)) {\n    throw new Error('Called unwrap on None');\n  }\n  return opt;\n}\n\n/**\n * Extracts the value from Some, or returns a default value.\n * @param opt - The Option to unwrap\n * @param defaultValue - Value to return if None\n * @returns The contained value or defaultValue\n * @example\n * unwrapOr(some(42), 0) // 42\n * unwrapOr(none, 0)     // 0\n */\nexport function unwrapOr<T>(opt: Option<T>, defaultValue: T): T {\n  return isSome(opt) ? opt : defaultValue;\n}\n\n/**\n * Extracts the value from Some, or computes a default.\n * @param opt - The Option to unwrap\n * @param fn - Function to compute default value\n * @returns The contained value or fn()\n * @example\n * unwrapOrElse(some(42), () => 0) // 42\n * unwrapOrElse(none, () => 0)     // 0\n */\nexport function unwrapOrElse<T>(opt: Option<T>, fn: () => T): T {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Extracts the value from Some, throws with custom message if None.\n * @param opt - The Option to unwrap\n * @param message - Error message if None\n * @returns The contained value\n * @throws Error with message if opt is None\n * @example\n * expect(some(42), 'missing value') // 42\n * expect(none, 'missing value')     // throws Error('missing value')\n */\nexport function expect<T>(opt: Option<T>, message: string): T {\n  if (isNone(opt)) {\n    throw new Error(message);\n  }\n  return opt;\n}\n\n/**\n * Returns the first Some, or the second Option if the first is None.\n * @param opt - First Option\n * @param optb - Fallback Option\n * @returns opt if Some, optb otherwise\n * @example\n * or(some(1), some(2)) // Some(1)\n * or(none, some(2))    // Some(2)\n */\nexport function or<T>(opt: Some<T>, optb: Option<T>): Some<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  return isSome(opt) ? opt : optb;\n}\n\n/**\n * Returns opt if Some, otherwise computes a fallback Option.\n * @param opt - First Option\n * @param fn - Function to compute fallback\n * @returns opt if Some, fn() otherwise\n * @example\n * orElse(some(1), () => some(2)) // Some(1)\n * orElse(none, () => some(2))    // Some(2)\n */\nexport function orElse<T>(opt: Some<T>, fn: () => Option<T>): Some<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T> {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Returns Some if exactly one of the Options is Some.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns Some if exactly one is Some, None otherwise\n * @example\n * xor(some(1), none)    // Some(1)\n * xor(none, some(2))    // Some(2)\n * xor(some(1), some(2)) // None\n * xor(none, none)       // None\n */\nexport function xor<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  const a = isSome(opt);\n  const b = isSome(optb);\n  if (a !== b) return a ? opt : optb;\n  return NONE;\n}\n\n/**\n * Returns optb if opt is Some, None otherwise.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns optb if opt is Some, None otherwise\n * @example\n * and(some(1), some(2)) // Some(2)\n * and(none, some(2))    // None\n */\nexport function and<U>(opt: None, optb: Option<U>): None;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U>;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U> {\n  return isSome(opt) ? optb : NONE;\n}\n\n/**\n * Combines two Options into an Option of a tuple.\n * @param opt - First Option\n * @param other - Second Option\n * @returns Some([a, b]) if both are Some, None otherwise\n * @example\n * zip(some(1), some('a')) // Some([1, 'a'])\n * zip(some(1), none)      // None\n */\nexport function zip<T, U>(opt: Option<T>, other: Option<U>): Option<[T, U]> {\n  return isSome(opt) && isSome(other) ? ([opt, other] as Some<[T, U]>) : NONE;\n}\n\n/**\n * Splits an Option of a tuple into a tuple of Options.\n * @param opt - Option containing a tuple\n * @returns Tuple of Options\n * @example\n * unzip(some([1, 'a'])) // [Some(1), Some('a')]\n * unzip(none)           // [None, None]\n */\nexport function unzip<T, U>(opt: Option<[T, U]>): [Option<T>, Option<U>] {\n  if (isNone(opt)) return [NONE, NONE];\n  const [a, b] = opt;\n  return [of(a), of(b)];\n}\n\n/**\n * Maps the value and returns it, or returns a default.\n * @param opt - The Option to map\n * @param defaultValue - Value if None\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultValue otherwise\n * @example\n * mapOr(some(2), 0, x => x * 2) // 4\n * mapOr(none, 0, x => x * 2)    // 0\n */\nexport function mapOr<T, U>(opt: Option<T>, defaultValue: U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultValue;\n}\n\n/**\n * Maps the value and returns it, or computes a default.\n * @param opt - The Option to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultFn() otherwise\n * @example\n * mapOrElse(some(2), () => 0, x => x * 2) // 4\n * mapOrElse(none, () => 0, x => x * 2)    // 0\n */\nexport function mapOrElse<T, U>(opt: Option<T>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultFn();\n}\n\n/**\n * Flattens a nested Option.\n * @param opt - Option containing an Option\n * @returns The inner Option\n * @example\n * flatten(some(some(42))) // Some(42)\n * flatten(some(none))     // None\n * flatten(none)           // None\n */\nexport function flatten<T>(opt: Option<Option<T>>): Option<T> {\n  return isNone(opt) ? NONE : (opt as Option<T>);\n}\n\n/**\n * Checks if the Option contains a specific value (using ===).\n * @param opt - The Option to check\n * @param value - The value to compare\n * @returns true if Some and value matches\n * @example\n * contains(some(42), 42) // true\n * contains(some(42), 0)  // false\n * contains(none, 42)     // false\n */\nexport function contains<T>(opt: Option<T>, value: T): boolean {\n  return isSome(opt) && opt === value;\n}\n\n/**\n * Checks if Some and the value satisfies a predicate.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if Some and predicate returns true\n * @example\n * isSomeAnd(some(4), x => x > 2) // true\n * isSomeAnd(some(1), x => x > 2) // false\n * isSomeAnd(none, x => x > 2)    // false\n */\nexport function isSomeAnd<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isSome(opt) && predicate(opt);\n}\n\n/**\n * Converts an Option to an array.\n * @param opt - The Option to convert\n * @returns [value] if Some, [] if None\n * @example\n * toArray(some(42)) // [42]\n * toArray(none)     // []\n */\nexport function toArray<T>(opt: Option<T>): readonly T[] {\n  return isSome(opt) ? [opt] : (EMPTY as readonly T[]);\n}\n\n/**\n * Converts an Option to a nullable value.\n * @param opt - The Option to convert\n * @returns The value if Some, null if None\n * @example\n * toNullable(some(42)) // 42\n * toNullable(none)     // null\n */\nexport function toNullable<T>(opt: Option<T>): T | null {\n  return isSome(opt) ? opt : null;\n}\n\n/**\n * Converts an Option to an undefined-able value.\n * @param opt - The Option to convert\n * @returns The value if Some, undefined if None\n * @example\n * toUndefined(some(42)) // 42\n * toUndefined(none)     // undefined\n */\nexport function toUndefined<T>(opt: Option<T>): T | undefined {\n  return isSome(opt) ? opt : undefined;\n}\n\n/**\n * Pattern matches on an Option, handling both Some and None cases.\n * @param opt - The Option to match\n * @param onSome - Handler for Some case\n * @param onNone - Handler for None case\n * @returns Result of the matching handler\n * @example\n * match(some(42), x => x * 2, () => 0) // 84\n * match(none, x => x * 2, () => 0)     // 0\n */\nexport function match<T, U>(opt: Option<T>, onSome: (value: T) => U, onNone: () => U): U {\n  return isSome(opt) ? onSome(opt) : onNone();\n}\n\n/**\n * Converts an Option to a Result, using a provided error if None.\n * @param opt - The Option to convert\n * @param error - Error value if None\n * @returns Ok(value) if Some, Err(error) if None\n * @example\n * okOr(some(42), 'missing') // Ok(42)\n * okOr(none, 'missing')     // Err('missing')\n */\nexport function okOr<T, E>(opt: Option<T>, error: E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(error);\n}\n\n/**\n * Converts an Option to a Result, computing the error if None.\n * @param opt - The Option to convert\n * @param fn - Function to compute error\n * @returns Ok(value) if Some, Err(fn()) if None\n * @example\n * okOrElse(some(42), () => 'missing') // Ok(42)\n * okOrElse(none, () => 'missing')     // Err('missing')\n */\nexport function okOrElse<T, E>(opt: Option<T>, fn: () => E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(fn());\n}\n\n/**\n * Extracts the Ok value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * ofOk(ok(42))        // Some(42)\n * ofOk(err('failed')) // None\n */\nexport function ofOk<T, E>(result: Result<T, E>): Option<T> {\n  if (!isOk(result) || !isSome(result)) {\n    return NONE;\n  }\n  return result as Some<T>;\n}\n\n/**\n * Extracts the Err value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * ofErr(err('failed')) // Some('failed')\n * ofErr(ok(42))        // None\n */\nexport function ofErr<T, E>(result: Result<T, E>): Option<E> {\n  if (!isErr(result)) {\n    return NONE;\n  }\n  const error = (result as { error: E }).error;\n  if (!isSome(error)) {\n    return NONE;\n  }\n  return error as Some<E>;\n}\n"],"names":["NONE","EMPTY","isSome","isNone","optionOf","of","err","isOk","isErr","fromNullable","value","fromPromise","promise","onRejected","error","unwrapOrReturn","opt","onNone","assertSome","message","Error","satisfiesOption","_","filterMap","values","fn","collected","mapped","push","findMap","map","result","undefined","flatMap","andThen","tap","isNoneOr","predicate","filter","unwrap","unwrapOr","defaultValue","unwrapOrElse","expect","or","optb","orElse","xor","a","b","and","zip","other","unzip","mapOr","mapOrElse","defaultFn","flatten","contains","isSomeAnd","toArray","toNullable","toUndefined","match","onSome","okOr","okOrElse","ofOk","ofErr"],"mappings":"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"}

package/build/result.cjs

@@ -54,6 +54,9 @@ _export(exports, {
     get flatten () {
         return flatten;
     },
+    get fromPromise () {
+        return fromPromise;
+    },
     get isErr () {
         return _typescjs.isErr;
     },
@@ -171,6 +174,13 @@ function tryCatch(fn, onError) {
 function of(fn) {
     return tryCatch(fn);
 }
+async function fromPromise(promise, onError) {
+    try {
+        return await promise;
+    } catch (error) {
+        return (0, _typescjs.err)(onError ? onError(error) : error);
+    }
+}
 function tryCatchMaybePromise(fn, onError) {
     try {
         const result = fn();
@@ -334,7 +344,15 @@ function collect(results) {
     return values;
 }
 function collectAll(results) {
-    const [oks, errs] = partition(results);
+    const oks = [];
+    const errs = [];
+    for (const result of results){
+        if ((0, _typescjs.isOk)(result)) {
+            oks.push(result);
+        } else {
+            errs.push(result.error);
+        }
+    }
     return errs.length > 0 ? (0, _typescjs.err)(errs) : oks;
 }
 function all(results) {

package/build/result.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/result.ts"],"sourcesContent":["import { err as ERR, isOk, isErr, isSome, isNone, NONE, optionOf, isThenable } from './types.js';\nimport type { Ok, Err, Result, Option, Widen, WidenNever, MaybePromise } from './types.js';\n\nexport type { Ok, Err, Result };\nexport { isOk, isErr };\n\n/**\n * Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @param onError - Optional error transformer\n * @returns Ok(result) if successful, Err(error) if thrown\n * @example\n * tryCatch(() => JSON.parse('{\"a\":1}'))     // Ok({a: 1})\n * tryCatch(() => JSON.parse('invalid'))     // Err(SyntaxError)\n * tryCatch(() => { throw 'oops' }, e => e)  // Err('oops')\n */\nexport function tryCatch<T>(fn: () => T): Result<T, unknown>;\nexport function tryCatch<T, E>(fn: () => T, onError: (error: unknown) => E): Result<T, E>;\nexport function tryCatch<T, E = unknown>(fn: () => T, onError?: (error: unknown) => E): Result<T, E> {\n  try {\n    return fn() as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Alias for tryCatch. Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @returns Ok(result) if successful, Err(error) if thrown\n */\nexport function of<T>(fn: () => T): Result<T, unknown> {\n  return tryCatch(fn);\n}\n\n/**\n * Executes a function that may return sync or async, preserving sync execution when possible.\n * @param fn - Function that may return T or Promise<T>\n * @param onError - Optional error transformer\n * @returns Result<T, E> if sync, Promise<Result<T, E>> if async\n * @example\n * tryCatchMaybePromise(() => 42)                    // Ok(42) - sync\n * tryCatchMaybePromise(() => Promise.resolve(42))   // Promise<Ok(42)> - async\n * tryCatchMaybePromise(() => { throw 'err' })       // Err('err') - sync\n */\nexport function tryCatchMaybePromise<T>(fn: () => MaybePromise<T>): Result<T, unknown> | Promise<Result<T, unknown>>;\nexport function tryCatchMaybePromise<T, E>(fn: () => MaybePromise<T>, onError: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>>;\nexport function tryCatchMaybePromise<T, E = unknown>(fn: () => MaybePromise<T>, onError?: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>> {\n  try {\n    const result = fn();\n    if (isThenable(result)) {\n      return Promise.resolve(result).then(\n        (value) => value as Ok<T>,\n        (error) => ERR(onError ? onError(error) : (error as E)),\n      );\n    }\n    return result as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Unwraps an Ok value or returns a computed value for Err.\n * @param result - The Result to unwrap\n * @param onErr - Function called with error if Err\n * @returns The Ok value or result of onErr(error)\n * @example\n * unwrapOrReturn(ok(42), e => 0)          // 42\n * unwrapOrReturn(err('fail'), e => 0)     // 0\n */\nexport function unwrapOrReturn<T, E, const R>(result: Result<T, E>, onErr: (error: E) => R): T | R {\n  return isOk(result) ? result : onErr(result.error);\n}\n\n/**\n * Asserts that a Result is Ok, throwing if Err.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Err\n * @example\n * assertOk(ok(42))        // passes\n * assertOk(err('failed')) // throws Error\n */\nexport function assertOk<T, E>(result: Result<T, E>, message?: string): asserts result is Ok<T> {\n  if (isErr(result)) {\n    throw new Error(message ?? `Expected Ok result. Received error: ${String(result.error)}`);\n  }\n}\n\n/**\n * Asserts that a Result is Err, throwing if Ok.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Ok\n * @example\n * assertErr(err('failed')) // passes\n * assertErr(ok(42))        // throws Error\n */\nexport function assertErr<T, E>(result: Result<T, E>, message?: string): asserts result is Err<E> {\n  if (isOk(result)) {\n    throw new Error(message ?? 'Expected Err result.');\n  }\n}\n\n/**\n * Checks if result is Err with a non-null error value.\n * @param result - The Result to check\n * @returns true if Err with Some error value\n */\nexport function isSomeErr<T, E>(result: Result<T, E>): boolean {\n  return isErr(result) && isSome(result.error);\n}\n\n/**\n * Transforms the Ok value, leaving Err unchanged.\n * @param result - The Result to map\n * @param fn - Transform function\n * @returns Ok(fn(value)) if Ok, Err unchanged\n * @example\n * map(ok(2), x => x * 2)   // Ok(4)\n * map(err('e'), x => x * 2) // Err('e')\n */\nexport function map<T, U, E>(result: Err<E>, fn: (value: T) => U): Err<E>;\nexport function map<T, U>(result: Ok<T>, fn: (value: T) => U): Ok<U>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result) as Ok<U>;\n}\n\n/**\n * Transforms the Err value, leaving Ok unchanged.\n * @param result - The Result to map\n * @param fn - Error transform function\n * @returns Err(fn(error)) if Err, Ok unchanged\n * @example\n * mapErr(err('e'), e => e.toUpperCase()) // Err('E')\n * mapErr(ok(42), e => e.toUpperCase())   // Ok(42)\n */\nexport function mapErr<T, E, F>(result: Ok<T>, fn: (error: E) => F): Ok<T>;\nexport function mapErr<E, F>(result: Err<E>, fn: (error: E) => F): Err<F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> {\n  if (isOk(result)) return result;\n  return ERR(fn(result.error));\n}\n\n/**\n * Chains Result-returning functions. Returns Err if the input is Err.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n * @example\n * flatMap(ok(2), x => ok(x * 2))    // Ok(4)\n * flatMap(ok(2), x => err('fail'))  // Err('fail')\n * flatMap(err('e'), x => ok(x * 2)) // Err('e')\n */\nexport function flatMap<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result);\n}\n\n/**\n * Alias for flatMap. Chains Result-returning functions.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n */\nexport function andThen<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;\nexport function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;\nexport function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  return isErr(result) ? result : fn(result);\n}\n\n/**\n * Executes a side effect if Ok, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function\n * @returns The original Result unchanged\n * @example\n * tap(ok(42), x => console.log(x)) // logs 42, returns Ok(42)\n */\nexport function tap<T, E>(result: Err<E>, fn: (value: T) => void): Err<E>;\nexport function tap<T>(result: Ok<T>, fn: (value: T) => void): Ok<T>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> {\n  if (isOk(result)) {\n    fn(result);\n  }\n  return result;\n}\n\n/**\n * Executes a side effect if Err, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function for error\n * @returns The original Result unchanged\n * @example\n * tapErr(err('fail'), e => console.log(e)) // logs 'fail', returns Err('fail')\n */\nexport function tapErr<T, E>(result: Ok<T>, fn: (error: E) => void): Ok<T>;\nexport function tapErr<E>(result: Err<E>, fn: (error: E) => void): Err<E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E> {\n  if (isErr(result)) {\n    fn(result.error);\n  }\n  return result;\n}\n\n/**\n * Maps both Ok and Err values simultaneously.\n * @param result - The Result to map\n * @param okFn - Transform for Ok value\n * @param errFn - Transform for Err value\n * @returns Ok(okFn(value)) if Ok, Err(errFn(error)) if Err\n * @example\n * bimap(ok(2), x => x * 2, e => e.toUpperCase())   // Ok(4)\n * bimap(err('e'), x => x * 2, e => e.toUpperCase()) // Err('E')\n */\nexport function bimap<T, U, E, F>(result: Ok<T>, okFn: (value: T) => U, errFn: (error: E) => F): Ok<U>;\nexport function bimap<T, U, E, F>(result: Err<E>, okFn: (value: T) => U, errFn: (error: E) => F): Err<F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F> {\n  return isOk(result) ? (okFn(result) as Ok<U>) : ERR(errFn(result.error));\n}\n\n/**\n * Extracts the Ok value, throws Err if not Ok.\n * Use with safeTry for Rust-like ? operator ergonomics.\n * @param result - The Result to unwrap\n * @returns The contained Ok value\n * @throws The Err object itself\n * @example\n * unwrap(ok(42))        // 42\n * unwrap(err('failed')) // throws Err\n * safeTry(() => {\n *   const a = unwrap(getValue());\n *   return a + 1;\n * });\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n  if (isErr(result)) throw result.error;\n  return result;\n}\n\n/**\n * Extracts the Err value, throws if Ok.\n * @param result - The Result to unwrap\n * @returns The contained error\n * @throws Error if result is Ok\n * @example\n * unwrapErr(err('failed')) // 'failed'\n * unwrapErr(ok(42))        // throws Error\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n  if (isOk(result)) {\n    throw new Error(`Called unwrapErr on Ok: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Extracts the Ok value, or returns a default.\n * @param result - The Result to unwrap\n * @param defaultValue - Value if Err\n * @returns The Ok value or defaultValue\n * @example\n * unwrapOr(ok(42), 0)        // 42\n * unwrapOr(err('failed'), 0) // 0\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n  return isOk(result) ? result : defaultValue;\n}\n\n/**\n * Extracts the Ok value, or computes a default from the error.\n * @param result - The Result to unwrap\n * @param fn - Function to compute default from error\n * @returns The Ok value or fn(error)\n * @example\n * unwrapOrElse(ok(42), e => 0)        // 42\n * unwrapOrElse(err('failed'), e => 0) // 0\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Maps the Ok value and returns it, or returns a default.\n * @param result - The Result to map\n * @param defaultValue - Value if Err\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultValue otherwise\n * @example\n * mapOr(ok(2), 0, x => x * 2)   // 4\n * mapOr(err('e'), 0, x => x * 2) // 0\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultValue;\n}\n\n/**\n * Maps the Ok value and returns it, or computes a default.\n * @param result - The Result to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultFn() otherwise\n * @example\n * mapOrElse(ok(2), () => 0, x => x * 2)   // 4\n * mapOrElse(err('e'), () => 0, x => x * 2) // 0\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultFn();\n}\n\n/**\n * Extracts the Ok value, throws with custom message if Err.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Err\n * @returns The Ok value\n * @throws Error with message if Err\n * @example\n * expect(ok(42), 'missing value')        // 42\n * expect(err('fail'), 'missing value')   // throws Error('missing value: fail')\n */\nexport function expect<T, E>(result: Result<T, E>, message: string): T {\n  if (isErr(result)) {\n    throw new Error(`${message}: ${String(result.error)}`);\n  }\n  return result;\n}\n\n/**\n * Extracts the Err value, throws with custom message if Ok.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Ok\n * @returns The error value\n * @throws Error with message if Ok\n * @example\n * expectErr(err('fail'), 'expected error')  // 'fail'\n * expectErr(ok(42), 'expected error')       // throws Error\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n  if (isOk(result)) {\n    throw new Error(`${message}: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Returns other if result is Ok, otherwise returns the Err.\n * @param result - First Result\n * @param other - Second Result\n * @returns other if result is Ok, result (Err) otherwise\n * @example\n * and(ok(1), ok(2))   // Ok(2)\n * and(err('e'), ok(2)) // Err('e')\n */\nexport function and<T, U, E>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n  return isOk(result) ? other : result;\n}\n\n/**\n * Returns result if Ok, otherwise returns other.\n * @param result - First Result\n * @param other - Fallback Result\n * @returns result if Ok, other otherwise\n * @example\n * or(ok(1), ok(2))    // Ok(1)\n * or(err('e'), ok(2)) // Ok(2)\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : other;\n}\n\n/**\n * Returns result if Ok, otherwise computes a fallback from the error.\n * @param result - First Result\n * @param fn - Function to compute fallback\n * @returns result if Ok, fn(error) otherwise\n * @example\n * orElse(ok(1), e => ok(0))    // Ok(1)\n * orElse(err('e'), e => ok(0)) // Ok(0)\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Converts a Result to an Option, discarding the error.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * toOption(ok(42))        // Some(42)\n * toOption(err('failed')) // None\n */\nexport function toOption<T, E>(result: Result<T, E>): Option<T> {\n  return isOk(result) ? optionOf(result) : NONE;\n}\n\n/**\n * Converts a Result's error to an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * toErrorOption(err('failed')) // Some('failed')\n * toErrorOption(ok(42))        // None\n */\nexport function toErrorOption<T, E>(result: Result<T, E>): Option<E> {\n  return isErr(result) ? optionOf(result.error) : NONE;\n}\n\n/**\n * Combines two Results into a Result of a tuple.\n * @param left - First Result\n * @param right - Second Result\n * @returns Ok([a, b]) if both Ok, first Err otherwise\n * @example\n * zip(ok(1), ok('a')) // Ok([1, 'a'])\n * zip(ok(1), err('e')) // Err('e')\n */\nexport function zip<T, U, E>(left: Result<T, E>, right: Result<U, E>): Result<[T, U], E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return [left, right] as Ok<[T, U]>;\n}\n\n/**\n * Combines two Results using a function.\n * @param left - First Result\n * @param right - Second Result\n * @param fn - Combining function\n * @returns Ok(fn(a, b)) if both Ok, first Err otherwise\n * @example\n * zipWith(ok(2), ok(3), (a, b) => a + b) // Ok(5)\n */\nexport function zipWith<T, U, V, E>(left: Result<T, E>, right: Result<U, E>, fn: (left: T, right: U) => V): Result<V, E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return fn(left, right) as Ok<V>;\n}\n\n/**\n * Flattens a nested Result.\n * @param result - Result containing a Result\n * @returns The inner Result\n * @example\n * flatten(ok(ok(42)))    // Ok(42)\n * flatten(ok(err('e')))  // Err('e')\n * flatten(err('outer'))  // Err('outer')\n */\nexport function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {\n  return isErr(result) ? (result as Err<E>) : (result as Result<T, E>);\n}\n\n/**\n * Pattern matches on a Result, handling both Ok and Err cases.\n * @param result - The Result to match\n * @param onOk - Handler for Ok case\n * @param onErr - Handler for Err case\n * @returns Result of the matching handler\n * @example\n * match(ok(42), x => x * 2, e => 0)   // 84\n * match(err('e'), x => x * 2, e => 0) // 0\n */\nexport function match<T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U {\n  return isOk(result) ? onOk(result) : onErr(result.error);\n}\n\n/**\n * Separates an array of Results into Ok values and Err values.\n * @param results - Array of Results\n * @returns Tuple of [Ok values, Err values]\n * @example\n * partition([ok(1), err('a'), ok(2)]) // [[1, 2], ['a']]\n */\nexport function partition<T, E>(results: Result<T, E>[]): [T[], E[]] {\n  const oks: T[] = [];\n  const errs: E[] = [];\n\n  for (const result of results) {\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Extracts all Ok values from an iterable of Results.\n * @param results - Iterable of Results\n * @returns Array of Ok values\n * @example\n * filterOk([ok(1), err('a'), ok(2)]) // [1, 2]\n */\nexport function filterOk<T, E>(results: Iterable<Result<T, E>>): T[] {\n  const oks: T[] = [];\n  for (const result of results) {\n    if (isOk(result)) oks.push(result);\n  }\n  return oks;\n}\n\n/**\n * Extracts all Err values from an iterable of Results.\n * @param results - Iterable of Results\n * @returns Array of error values\n * @example\n * filterErr([ok(1), err('a'), ok(2)]) // ['a']\n */\nexport function filterErr<T, E>(results: Iterable<Result<T, E>>): E[] {\n  const errs: E[] = [];\n  for (const result of results) {\n    if (isErr(result)) errs.push(result.error);\n  }\n  return errs;\n}\n\n/**\n * Collects an array of Results into a Result of an array. Fails on first Err.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n * @example\n * collect([ok(1), ok(2)])       // Ok([1, 2])\n * collect([ok(1), err('e')])    // Err('e')\n */\nexport function collect<T, E>(results: Result<T, E>[]): Result<T[], E> {\n  const values: T[] = [];\n\n  for (const result of results) {\n    if (isErr(result)) return result;\n    values.push(result);\n  }\n\n  return values as Ok<T[]>;\n}\n\n/**\n * Collects all Results, returning all errors if any exist.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, Err(allErrors) otherwise\n * @example\n * collectAll([ok(1), ok(2)])           // Ok([1, 2])\n * collectAll([ok(1), err('a'), err('b')]) // Err(['a', 'b'])\n */\nexport function collectAll<T, E>(results: Result<T, E>[]): Result<T[], E[]> {\n  const [oks, errs] = partition(results);\n  return errs.length > 0 ? ERR(errs) : (oks as Ok<T[]>);\n}\n\n/**\n * Alias for collect with widened types. Collects Results into a Result of array.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n */\nexport function all<T, E>(results: Result<T, E>[]): Result<readonly Widen<T>[], WidenNever<E>> {\n  return collect(results) as Result<readonly Widen<T>[], WidenNever<E>>;\n}\n\n/**\n * Returns the first Ok, or all errors if none succeed.\n * @param results - Array of Results\n * @returns First Ok found, or Err(allErrors) if all fail\n * @example\n * any([err('a'), ok(1), err('b')]) // Ok(1)\n * any([err('a'), err('b')])        // Err(['a', 'b'])\n */\nexport function any<T, E>(results: Result<T, E>[]): Result<Widen<T>, WidenNever<E>[]> {\n  const errors: WidenNever<E>[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) return result as Ok<Widen<T>>;\n    errors.push((result as Err<WidenNever<E>>).error);\n  }\n  return ERR(errors);\n}\n\n/**\n * Transposes a Result of Option to an Option of Result.\n * @param result - Result containing an Option\n * @returns Some(Ok(value)) if Ok(Some), None if Ok(None), Some(Err) if Err\n * @example\n * transpose(ok(some(42)))  // Some(Ok(42))\n * transpose(ok(none))      // None\n * transpose(err('e'))      // Some(Err('e'))\n */\nexport function transpose<T, E>(result: Result<Option<T>, E>): Option<Result<T, E>> {\n  if (isErr(result)) {\n    return ERR(result.error) as Option<Result<T, E>>;\n  }\n  const opt = result as Option<T>;\n  return isNone(opt) ? NONE : (opt as unknown as Ok<T> as Option<Result<T, E>>);\n}\n\n/**\n * Checks if Ok and the value satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Ok and predicate returns true\n * @example\n * isOkAnd(ok(4), x => x > 2)   // true\n * isOkAnd(ok(1), x => x > 2)   // false\n * isOkAnd(err('e'), x => x > 2) // false\n */\nexport function isOkAnd<T, E>(result: Result<T, E>, predicate: (value: T) => boolean): boolean {\n  return isOk(result) && predicate(result);\n}\n\n/**\n * Checks if Err and the error satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Err and predicate returns true\n * @example\n * isErrAnd(err('fatal'), e => e.includes('fatal')) // true\n * isErrAnd(ok(42), e => true)                       // false\n */\nexport function isErrAnd<T, E>(result: Result<T, E>, predicate: (error: E) => boolean): boolean {\n  return isErr(result) && predicate(result.error);\n}\n\nexport function settledToResult<T, E>(result: PromiseSettledResult<Result<T, E>>): Result<T, E> {\n  if (result.status === 'fulfilled') return result.value;\n  return ERR(result.reason);\n}\n\n/**\n * Partitions an async iterable of Results.\n * @param results - Iterable of Promise Results\n * @returns Promise of [Ok values, Err values]\n * @example\n * await partitionAsync([Promise.resolve(ok(1)), Promise.resolve(err('a'))])\n * // [[1], ['a']]\n */\nexport async function partitionAsync<T, E>(promises: Iterable<Promise<Result<T, E>>>): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const settled = await Promise.allSettled(promises);\n  return partition(settled.map(settledToResult)) as [Widen<T>[], WidenNever<E>[]];\n}\n\n/**\n * Settles an array of MaybePromise values into Results.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of values that may or may not be Promises\n * @returns Array of Results (sync) or Promise of Results (if any async)\n * @example\n * settleMaybePromise([1, 2, 3])                    // [Ok(1), Ok(2), Ok(3)] - sync\n * settleMaybePromise([1, Promise.resolve(2)])     // Promise<[Ok(1), Ok(2)]>\n * settleMaybePromise([Promise.reject('e')])       // Promise<[Err('e')]>\n */\nexport function settleMaybePromise<T, E = unknown>(values: MaybePromise<T>[]): Result<T, E>[] | Promise<Result<T, E>[]> {\n  const len = values.length;\n  const results = new Array<Result<T, E>>(len);\n  let pendingIndices: number[] | undefined;\n  let pendingPromises: Promise<T>[] | undefined;\n\n  for (let i = 0; i < len; i++) {\n    const v = values[i];\n    if (isThenable(v)) {\n      (pendingIndices ??= []).push(i);\n      (pendingPromises ??= []).push(Promise.resolve(v));\n    } else {\n      results[i] = v as Ok<T>;\n    }\n  }\n\n  if (!pendingPromises) return results;\n\n  return Promise.allSettled(pendingPromises).then((settled) => {\n    for (let i = 0; i < settled.length; i++) {\n      const s = settled[i];\n      results[pendingIndices![i]] = s.status === 'fulfilled' ? (s.value as Ok<T>) : ERR(s.reason as E);\n    }\n    return results;\n  });\n}\n\nexport async function partitionMaybePromiseAsync<T, E>(\n  values: MaybePromise<Result<T, E>>[],\n  oks: Widen<T>[],\n  errs: WidenNever<E>[],\n  startIndex: number = 0,\n): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const suffixLength = values.length - startIndex;\n  const pending = new Array<Promise<Result<T, E>>>(suffixLength);\n\n  for (let i = 0; i < suffixLength; i++) {\n    const value = values[startIndex + i];\n    pending[i] = Promise.resolve(value).then(\n      (result) => result as Result<T, E>,\n      (error) => ERR(error as E),\n    );\n  }\n\n  const resolved = await Promise.all(pending);\n  for (let i = 0; i < resolved.length; i++) {\n    const result = resolved[i];\n    if (isOk(result)) {\n      oks.push(result as Widen<T>);\n    } else {\n      errs.push((result as Err<WidenNever<E>>).error);\n    }\n  }\n  return [oks, errs] as [Widen<T>[], WidenNever<E>[]];\n}\n\n/**\n * Partitions MaybePromise Results into Ok and Err values.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of MaybePromise Results\n * @returns [Ok values, Err values] (sync) or Promise of same (if any async)\n * @example\n * partitionMaybePromise([ok(1), err('a')])                   // [[1], ['a']] - sync\n * partitionMaybePromise([ok(1), Promise.resolve(err('a'))]) // Promise<[[1], ['a']]>\n */\nexport function partitionMaybePromise<T, E>(values: MaybePromise<Result<T, E>>[]): [Widen<T>[], WidenNever<E>[]] | Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const len = values.length;\n  const oks: Widen<T>[] = [];\n  const errs: WidenNever<E>[] = [];\n\n  for (let i = 0; i < len; i++) {\n    const value = values[i];\n    if (isThenable(value)) {\n      return partitionMaybePromiseAsync(values, oks, errs, i);\n    }\n    if (isOk(value)) {\n      oks.push(value as Widen<T>);\n    } else {\n      errs.push((value as Err<WidenNever<E>>).error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Executes a function, catching thrown Err values.\n * Use with unwrap for Rust-like ? operator ergonomics.\n * @param fn - Function that may throw Err via unwrap\n * @returns Ok(return value) or the caught Err\n * @example\n * const result = safeTry(() => {\n *   const a = unwrap(parseNumber('10'));\n *   const b = unwrap(parseNumber('5'));\n *   return a + b;\n * }); // Ok(15) or Err(...)\n */\nexport function safeTry<T>(fn: () => T): Result<T, unknown> {\n  try {\n    return fn() as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n\n/**\n * Async version of safeTry.\n * @param fn - Async function that may throw Err via unwrap\n * @returns Promise of Ok(return value) or the caught Err\n * @example\n * const result = await safeTryAsync(async () => {\n *   const user = unwrap(await fetchUser(id));\n *   const posts = unwrap(await fetchPosts(user.id));\n *   return { user, posts };\n * });\n */\nexport async function safeTryAsync<T>(fn: () => Promise<T>): Promise<Result<T, unknown>> {\n  try {\n    return (await fn()) as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n"],"names":["all","and","andThen","any","assertErr","assertOk","bimap","collect","collectAll","expect","expectErr","filterErr","filterOk","flatMap","flatten","isErr","isErrAnd","isOk","isOkAnd","isSomeErr","map","mapErr","mapOr","mapOrElse","match","of","or","orElse","partition","partitionAsync","partitionMaybePromise","partitionMaybePromiseAsync","safeTry","safeTryAsync","settleMaybePromise","settledToResult","tap","tapErr","toErrorOption","toOption","transpose","tryCatch","tryCatchMaybePromise","unwrap","unwrapErr","unwrapOr","unwrapOrElse","unwrapOrReturn","zip","zipWith","fn","onError","error","ERR","result","isThenable","Promise","resolve","then","value","onErr","message","Error","String","isSome","okFn","errFn","defaultValue","defaultFn","other","optionOf","NONE","left","right","onOk","results","oks","errs","push","values","length","errors","i","opt","isNone","predicate","status","reason","promises","settled","allSettled","len","Array","pendingIndices","pendingPromises","v","s","startIndex","suffixLength","pending","resolved","e"],"mappings":"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"}
+{"version":3,"sources":["../src/result.ts"],"sourcesContent":["import { err as ERR, isOk, isErr, isSome, isNone, NONE, optionOf, isThenable } from './types.js';\nimport type { Ok, Err, Result, Option, Widen, WidenNever, MaybePromise } from './types.js';\n\nexport type { Ok, Err, Result };\nexport { isOk, isErr };\n\n/**\n * Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @param onError - Optional error transformer\n * @returns Ok(result) if successful, Err(error) if thrown\n * @example\n * tryCatch(() => JSON.parse('{\"a\":1}'))     // Ok({a: 1})\n * tryCatch(() => JSON.parse('invalid'))     // Err(SyntaxError)\n * tryCatch(() => { throw 'oops' }, e => e)  // Err('oops')\n */\nexport function tryCatch<T>(fn: () => T): Result<T, unknown>;\nexport function tryCatch<T, E>(fn: () => T, onError: (error: unknown) => E): Result<T, E>;\nexport function tryCatch<T, E = unknown>(fn: () => T, onError?: (error: unknown) => E): Result<T, E> {\n  try {\n    return fn() as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Alias for tryCatch. Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @returns Ok(result) if successful, Err(error) if thrown\n */\nexport function of<T>(fn: () => T): Result<T, unknown> {\n  return tryCatch(fn);\n}\n\n/**\n * Converts a Promise to a Result. Resolves to Ok if successful, Err on rejection.\n * @param promise - The promise to convert\n * @param onError - Optional error transformer\n * @returns Promise resolving to Ok(value) or Err(error)\n * @example\n * await fromPromise(fetch('/api'))              // Ok(Response) or Err(unknown)\n * await fromPromise(fetch('/api'), e => String(e)) // Ok(Response) or Err(string)\n */\nexport async function fromPromise<T>(promise: Promise<T>): Promise<Result<T, unknown>>;\nexport async function fromPromise<T, E>(promise: Promise<T>, onError: (error: unknown) => E): Promise<Result<T, E>>;\nexport async function fromPromise<T, E = unknown>(promise: Promise<T>, onError?: (error: unknown) => E): Promise<Result<T, E>> {\n  try {\n    return (await promise) as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Executes a function that may return sync or async, preserving sync execution when possible.\n * @param fn - Function that may return T or Promise<T>\n * @param onError - Optional error transformer\n * @returns Result<T, E> if sync, Promise<Result<T, E>> if async\n * @example\n * tryCatchMaybePromise(() => 42)                    // Ok(42) - sync\n * tryCatchMaybePromise(() => Promise.resolve(42))   // Promise<Ok(42)> - async\n * tryCatchMaybePromise(() => { throw 'err' })       // Err('err') - sync\n */\nexport function tryCatchMaybePromise<T>(fn: () => MaybePromise<T>): Result<T, unknown> | Promise<Result<T, unknown>>;\nexport function tryCatchMaybePromise<T, E>(fn: () => MaybePromise<T>, onError: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>>;\nexport function tryCatchMaybePromise<T, E = unknown>(fn: () => MaybePromise<T>, onError?: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>> {\n  try {\n    const result = fn();\n    if (isThenable(result)) {\n      return Promise.resolve(result).then(\n        (value) => value as Ok<T>,\n        (error) => ERR(onError ? onError(error) : (error as E)),\n      );\n    }\n    return result as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Unwraps an Ok value or returns a computed value for Err.\n * @param result - The Result to unwrap\n * @param onErr - Function called with error if Err\n * @returns The Ok value or result of onErr(error)\n * @example\n * unwrapOrReturn(ok(42), e => 0)          // 42\n * unwrapOrReturn(err('fail'), e => 0)     // 0\n */\nexport function unwrapOrReturn<T, E, const R>(result: Result<T, E>, onErr: (error: E) => R): T | R {\n  return isOk(result) ? result : onErr(result.error);\n}\n\n/**\n * Asserts that a Result is Ok, throwing if Err.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Err\n * @example\n * assertOk(ok(42))        // passes\n * assertOk(err('failed')) // throws Error\n */\nexport function assertOk<T, E>(result: Result<T, E>, message?: string): asserts result is Ok<T> {\n  if (isErr(result)) {\n    throw new Error(message ?? `Expected Ok result. Received error: ${String(result.error)}`);\n  }\n}\n\n/**\n * Asserts that a Result is Err, throwing if Ok.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Ok\n * @example\n * assertErr(err('failed')) // passes\n * assertErr(ok(42))        // throws Error\n */\nexport function assertErr<T, E>(result: Result<T, E>, message?: string): asserts result is Err<E> {\n  if (isOk(result)) {\n    throw new Error(message ?? 'Expected Err result.');\n  }\n}\n\n/**\n * Checks if result is Err with a non-null error value.\n * @param result - The Result to check\n * @returns true if Err with Some error value\n */\nexport function isSomeErr<T, E>(result: Result<T, E>): boolean {\n  return isErr(result) && isSome(result.error);\n}\n\n/**\n * Transforms the Ok value, leaving Err unchanged.\n * @param result - The Result to map\n * @param fn - Transform function\n * @returns Ok(fn(value)) if Ok, Err unchanged\n * @example\n * map(ok(2), x => x * 2)   // Ok(4)\n * map(err('e'), x => x * 2) // Err('e')\n */\nexport function map<T, U, E>(result: Err<E>, fn: (value: T) => U): Err<E>;\nexport function map<T, U>(result: Ok<T>, fn: (value: T) => U): Ok<U>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result) as Ok<U>;\n}\n\n/**\n * Transforms the Err value, leaving Ok unchanged.\n * @param result - The Result to map\n * @param fn - Error transform function\n * @returns Err(fn(error)) if Err, Ok unchanged\n * @example\n * mapErr(err('e'), e => e.toUpperCase()) // Err('E')\n * mapErr(ok(42), e => e.toUpperCase())   // Ok(42)\n */\nexport function mapErr<T, E, F>(result: Ok<T>, fn: (error: E) => F): Ok<T>;\nexport function mapErr<E, F>(result: Err<E>, fn: (error: E) => F): Err<F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> {\n  if (isOk(result)) return result;\n  return ERR(fn(result.error));\n}\n\n/**\n * Chains Result-returning functions. Returns Err if the input is Err.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n * @example\n * flatMap(ok(2), x => ok(x * 2))    // Ok(4)\n * flatMap(ok(2), x => err('fail'))  // Err('fail')\n * flatMap(err('e'), x => ok(x * 2)) // Err('e')\n */\nexport function flatMap<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result);\n}\n\n/**\n * Alias for flatMap. Chains Result-returning functions.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n */\nexport function andThen<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;\nexport function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;\nexport function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  return isErr(result) ? result : fn(result);\n}\n\n/**\n * Executes a side effect if Ok, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function\n * @returns The original Result unchanged\n * @example\n * tap(ok(42), x => console.log(x)) // logs 42, returns Ok(42)\n */\nexport function tap<T, E>(result: Err<E>, fn: (value: T) => void): Err<E>;\nexport function tap<T>(result: Ok<T>, fn: (value: T) => void): Ok<T>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> {\n  if (isOk(result)) {\n    fn(result);\n  }\n  return result;\n}\n\n/**\n * Executes a side effect if Err, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function for error\n * @returns The original Result unchanged\n * @example\n * tapErr(err('fail'), e => console.log(e)) // logs 'fail', returns Err('fail')\n */\nexport function tapErr<T, E>(result: Ok<T>, fn: (error: E) => void): Ok<T>;\nexport function tapErr<E>(result: Err<E>, fn: (error: E) => void): Err<E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E> {\n  if (isErr(result)) {\n    fn(result.error);\n  }\n  return result;\n}\n\n/**\n * Maps both Ok and Err values simultaneously.\n * @param result - The Result to map\n * @param okFn - Transform for Ok value\n * @param errFn - Transform for Err value\n * @returns Ok(okFn(value)) if Ok, Err(errFn(error)) if Err\n * @example\n * bimap(ok(2), x => x * 2, e => e.toUpperCase())   // Ok(4)\n * bimap(err('e'), x => x * 2, e => e.toUpperCase()) // Err('E')\n */\nexport function bimap<T, U, E, F>(result: Ok<T>, okFn: (value: T) => U, errFn: (error: E) => F): Ok<U>;\nexport function bimap<T, U, E, F>(result: Err<E>, okFn: (value: T) => U, errFn: (error: E) => F): Err<F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F> {\n  return isOk(result) ? (okFn(result) as Ok<U>) : ERR(errFn(result.error));\n}\n\n/**\n * Extracts the Ok value, throws Err if not Ok.\n * Use with safeTry for Rust-like ? operator ergonomics.\n * @param result - The Result to unwrap\n * @returns The contained Ok value\n * @throws The Err object itself\n * @example\n * unwrap(ok(42))        // 42\n * unwrap(err('failed')) // throws Err\n * safeTry(() => {\n *   const a = unwrap(getValue());\n *   return a + 1;\n * });\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n  if (isErr(result)) throw result.error;\n  return result;\n}\n\n/**\n * Extracts the Err value, throws if Ok.\n * @param result - The Result to unwrap\n * @returns The contained error\n * @throws Error if result is Ok\n * @example\n * unwrapErr(err('failed')) // 'failed'\n * unwrapErr(ok(42))        // throws Error\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n  if (isOk(result)) {\n    throw new Error(`Called unwrapErr on Ok: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Extracts the Ok value, or returns a default.\n * @param result - The Result to unwrap\n * @param defaultValue - Value if Err\n * @returns The Ok value or defaultValue\n * @example\n * unwrapOr(ok(42), 0)        // 42\n * unwrapOr(err('failed'), 0) // 0\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n  return isOk(result) ? result : defaultValue;\n}\n\n/**\n * Extracts the Ok value, or computes a default from the error.\n * @param result - The Result to unwrap\n * @param fn - Function to compute default from error\n * @returns The Ok value or fn(error)\n * @example\n * unwrapOrElse(ok(42), e => 0)        // 42\n * unwrapOrElse(err('failed'), e => 0) // 0\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Maps the Ok value and returns it, or returns a default.\n * @param result - The Result to map\n * @param defaultValue - Value if Err\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultValue otherwise\n * @example\n * mapOr(ok(2), 0, x => x * 2)   // 4\n * mapOr(err('e'), 0, x => x * 2) // 0\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultValue;\n}\n\n/**\n * Maps the Ok value and returns it, or computes a default.\n * @param result - The Result to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultFn() otherwise\n * @example\n * mapOrElse(ok(2), () => 0, x => x * 2)   // 4\n * mapOrElse(err('e'), () => 0, x => x * 2) // 0\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultFn();\n}\n\n/**\n * Extracts the Ok value, throws with custom message if Err.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Err\n * @returns The Ok value\n * @throws Error with message if Err\n * @example\n * expect(ok(42), 'missing value')        // 42\n * expect(err('fail'), 'missing value')   // throws Error('missing value: fail')\n */\nexport function expect<T, E>(result: Result<T, E>, message: string): T {\n  if (isErr(result)) {\n    throw new Error(`${message}: ${String(result.error)}`);\n  }\n  return result;\n}\n\n/**\n * Extracts the Err value, throws with custom message if Ok.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Ok\n * @returns The error value\n * @throws Error with message if Ok\n * @example\n * expectErr(err('fail'), 'expected error')  // 'fail'\n * expectErr(ok(42), 'expected error')       // throws Error\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n  if (isOk(result)) {\n    throw new Error(`${message}: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Returns other if result is Ok, otherwise returns the Err.\n * @param result - First Result\n * @param other - Second Result\n * @returns other if result is Ok, result (Err) otherwise\n * @example\n * and(ok(1), ok(2))   // Ok(2)\n * and(err('e'), ok(2)) // Err('e')\n */\nexport function and<T, U, E>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n  return isOk(result) ? other : result;\n}\n\n/**\n * Returns result if Ok, otherwise returns other.\n * @param result - First Result\n * @param other - Fallback Result\n * @returns result if Ok, other otherwise\n * @example\n * or(ok(1), ok(2))    // Ok(1)\n * or(err('e'), ok(2)) // Ok(2)\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : other;\n}\n\n/**\n * Returns result if Ok, otherwise computes a fallback from the error.\n * @param result - First Result\n * @param fn - Function to compute fallback\n * @returns result if Ok, fn(error) otherwise\n * @example\n * orElse(ok(1), e => ok(0))    // Ok(1)\n * orElse(err('e'), e => ok(0)) // Ok(0)\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Converts a Result to an Option, discarding the error.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * toOption(ok(42))        // Some(42)\n * toOption(err('failed')) // None\n */\nexport function toOption<T, E>(result: Result<T, E>): Option<T> {\n  return isOk(result) ? optionOf(result) : NONE;\n}\n\n/**\n * Converts a Result's error to an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * toErrorOption(err('failed')) // Some('failed')\n * toErrorOption(ok(42))        // None\n */\nexport function toErrorOption<T, E>(result: Result<T, E>): Option<E> {\n  return isErr(result) ? optionOf(result.error) : NONE;\n}\n\n/**\n * Combines two Results into a Result of a tuple.\n * @param left - First Result\n * @param right - Second Result\n * @returns Ok([a, b]) if both Ok, first Err otherwise\n * @example\n * zip(ok(1), ok('a')) // Ok([1, 'a'])\n * zip(ok(1), err('e')) // Err('e')\n */\nexport function zip<T, U, E>(left: Result<T, E>, right: Result<U, E>): Result<[T, U], E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return [left, right] as Ok<[T, U]>;\n}\n\n/**\n * Combines two Results using a function.\n * @param left - First Result\n * @param right - Second Result\n * @param fn - Combining function\n * @returns Ok(fn(a, b)) if both Ok, first Err otherwise\n * @example\n * zipWith(ok(2), ok(3), (a, b) => a + b) // Ok(5)\n */\nexport function zipWith<T, U, V, E>(left: Result<T, E>, right: Result<U, E>, fn: (left: T, right: U) => V): Result<V, E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return fn(left, right) as Ok<V>;\n}\n\n/**\n * Flattens a nested Result.\n * @param result - Result containing a Result\n * @returns The inner Result\n * @example\n * flatten(ok(ok(42)))    // Ok(42)\n * flatten(ok(err('e')))  // Err('e')\n * flatten(err('outer'))  // Err('outer')\n */\nexport function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {\n  return isErr(result) ? (result as Err<E>) : (result as Result<T, E>);\n}\n\n/**\n * Pattern matches on a Result, handling both Ok and Err cases.\n * @param result - The Result to match\n * @param onOk - Handler for Ok case\n * @param onErr - Handler for Err case\n * @returns Result of the matching handler\n * @example\n * match(ok(42), x => x * 2, e => 0)   // 84\n * match(err('e'), x => x * 2, e => 0) // 0\n */\nexport function match<T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U {\n  return isOk(result) ? onOk(result) : onErr(result.error);\n}\n\n/**\n * Separates an array of Results into Ok values and Err values.\n * @param results - Array of Results\n * @returns Tuple of [Ok values, Err values]\n * @example\n * partition([ok(1), err('a'), ok(2)]) // [[1, 2], ['a']]\n */\nexport function partition<T, E>(results: Result<T, E>[]): [T[], E[]] {\n  const oks: T[] = [];\n  const errs: E[] = [];\n\n  for (const result of results) {\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Extracts all Ok values from an iterable of Results.\n * @param results - Iterable of Results\n * @returns Array of Ok values\n * @example\n * filterOk([ok(1), err('a'), ok(2)]) // [1, 2]\n */\nexport function filterOk<T, E>(results: Iterable<Result<T, E>>): T[] {\n  const oks: T[] = [];\n  for (const result of results) {\n    if (isOk(result)) oks.push(result);\n  }\n  return oks;\n}\n\n/**\n * Extracts all Err values from an iterable of Results.\n * @param results - Iterable of Results\n * @returns Array of error values\n * @example\n * filterErr([ok(1), err('a'), ok(2)]) // ['a']\n */\nexport function filterErr<T, E>(results: Iterable<Result<T, E>>): E[] {\n  const errs: E[] = [];\n  for (const result of results) {\n    if (isErr(result)) errs.push(result.error);\n  }\n  return errs;\n}\n\n/**\n * Collects an array of Results into a Result of an array. Fails on first Err.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n * @example\n * collect([ok(1), ok(2)])       // Ok([1, 2])\n * collect([ok(1), err('e')])    // Err('e')\n */\nexport function collect<T, E>(results: Result<T, E>[]): Result<T[], E> {\n  const values: T[] = [];\n\n  for (const result of results) {\n    if (isErr(result)) return result;\n    values.push(result);\n  }\n\n  return values as Ok<T[]>;\n}\n\n/**\n * Collects all Results, returning all errors if any exist.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, Err(allErrors) otherwise\n * @example\n * collectAll([ok(1), ok(2)])           // Ok([1, 2])\n * collectAll([ok(1), err('a'), err('b')]) // Err(['a', 'b'])\n */\nexport function collectAll<T, E>(results: Result<T, E>[]): Result<T[], E[]> {\n  const oks: T[] = [];\n  const errs: E[] = [];\n  for (const result of results) {\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n  return errs.length > 0 ? ERR(errs) : (oks as Ok<T[]>);\n}\n\n/**\n * Alias for collect with widened types. Collects Results into a Result of array.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n */\nexport function all<T, E>(results: Result<T, E>[]): Result<readonly Widen<T>[], WidenNever<E>> {\n  return collect(results) as Result<readonly Widen<T>[], WidenNever<E>>;\n}\n\n/**\n * Returns the first Ok, or all errors if none succeed.\n * @param results - Array of Results\n * @returns First Ok found, or Err(allErrors) if all fail\n * @example\n * any([err('a'), ok(1), err('b')]) // Ok(1)\n * any([err('a'), err('b')])        // Err(['a', 'b'])\n */\nexport function any<T, E>(results: Result<T, E>[]): Result<Widen<T>, WidenNever<E>[]> {\n  const errors: WidenNever<E>[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) return result as Ok<Widen<T>>;\n    errors.push((result as Err<WidenNever<E>>).error);\n  }\n  return ERR(errors);\n}\n\n/**\n * Transposes a Result of Option to an Option of Result.\n * @param result - Result containing an Option\n * @returns Some(Ok(value)) if Ok(Some), None if Ok(None), Some(Err) if Err\n * @example\n * transpose(ok(some(42)))  // Some(Ok(42))\n * transpose(ok(none))      // None\n * transpose(err('e'))      // Some(Err('e'))\n */\nexport function transpose<T, E>(result: Result<Option<T>, E>): Option<Result<T, E>> {\n  if (isErr(result)) {\n    return ERR(result.error) as Option<Result<T, E>>;\n  }\n  const opt = result as Option<T>;\n  return isNone(opt) ? NONE : (opt as unknown as Ok<T> as Option<Result<T, E>>);\n}\n\n/**\n * Checks if Ok and the value satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Ok and predicate returns true\n * @example\n * isOkAnd(ok(4), x => x > 2)   // true\n * isOkAnd(ok(1), x => x > 2)   // false\n * isOkAnd(err('e'), x => x > 2) // false\n */\nexport function isOkAnd<T, E>(result: Result<T, E>, predicate: (value: T) => boolean): boolean {\n  return isOk(result) && predicate(result);\n}\n\n/**\n * Checks if Err and the error satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Err and predicate returns true\n * @example\n * isErrAnd(err('fatal'), e => e.includes('fatal')) // true\n * isErrAnd(ok(42), e => true)                       // false\n */\nexport function isErrAnd<T, E>(result: Result<T, E>, predicate: (error: E) => boolean): boolean {\n  return isErr(result) && predicate(result.error);\n}\n\nexport function settledToResult<T, E>(result: PromiseSettledResult<Result<T, E>>): Result<T, E> {\n  if (result.status === 'fulfilled') return result.value;\n  return ERR(result.reason);\n}\n\n/**\n * Partitions an async iterable of Results.\n * @param results - Iterable of Promise Results\n * @returns Promise of [Ok values, Err values]\n * @example\n * await partitionAsync([Promise.resolve(ok(1)), Promise.resolve(err('a'))])\n * // [[1], ['a']]\n */\nexport async function partitionAsync<T, E>(promises: Iterable<Promise<Result<T, E>>>): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const settled = await Promise.allSettled(promises);\n  return partition(settled.map(settledToResult)) as [Widen<T>[], WidenNever<E>[]];\n}\n\n/**\n * Settles an array of MaybePromise values into Results.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of values that may or may not be Promises\n * @returns Array of Results (sync) or Promise of Results (if any async)\n * @example\n * settleMaybePromise([1, 2, 3])                    // [Ok(1), Ok(2), Ok(3)] - sync\n * settleMaybePromise([1, Promise.resolve(2)])     // Promise<[Ok(1), Ok(2)]>\n * settleMaybePromise([Promise.reject('e')])       // Promise<[Err('e')]>\n */\nexport function settleMaybePromise<T, E = unknown>(values: MaybePromise<T>[]): Result<T, E>[] | Promise<Result<T, E>[]> {\n  const len = values.length;\n  const results = new Array<Result<T, E>>(len);\n  let pendingIndices: number[] | undefined;\n  let pendingPromises: Promise<T>[] | undefined;\n\n  for (let i = 0; i < len; i++) {\n    const v = values[i];\n    if (isThenable(v)) {\n      (pendingIndices ??= []).push(i);\n      (pendingPromises ??= []).push(Promise.resolve(v));\n    } else {\n      results[i] = v as Ok<T>;\n    }\n  }\n\n  if (!pendingPromises) return results;\n\n  return Promise.allSettled(pendingPromises).then((settled) => {\n    for (let i = 0; i < settled.length; i++) {\n      const s = settled[i];\n      results[pendingIndices![i]] = s.status === 'fulfilled' ? (s.value as Ok<T>) : ERR(s.reason as E);\n    }\n    return results;\n  });\n}\n\nexport async function partitionMaybePromiseAsync<T, E>(\n  values: MaybePromise<Result<T, E>>[],\n  oks: Widen<T>[],\n  errs: WidenNever<E>[],\n  startIndex: number = 0,\n): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const suffixLength = values.length - startIndex;\n  const pending = new Array<Promise<Result<T, E>>>(suffixLength);\n\n  for (let i = 0; i < suffixLength; i++) {\n    const value = values[startIndex + i];\n    pending[i] = Promise.resolve(value).then(\n      (result) => result as Result<T, E>,\n      (error) => ERR(error as E),\n    );\n  }\n\n  const resolved = await Promise.all(pending);\n  for (let i = 0; i < resolved.length; i++) {\n    const result = resolved[i];\n    if (isOk(result)) {\n      oks.push(result as Widen<T>);\n    } else {\n      errs.push((result as Err<WidenNever<E>>).error);\n    }\n  }\n  return [oks, errs] as [Widen<T>[], WidenNever<E>[]];\n}\n\n/**\n * Partitions MaybePromise Results into Ok and Err values.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of MaybePromise Results\n * @returns [Ok values, Err values] (sync) or Promise of same (if any async)\n * @example\n * partitionMaybePromise([ok(1), err('a')])                   // [[1], ['a']] - sync\n * partitionMaybePromise([ok(1), Promise.resolve(err('a'))]) // Promise<[[1], ['a']]>\n */\nexport function partitionMaybePromise<T, E>(values: MaybePromise<Result<T, E>>[]): [Widen<T>[], WidenNever<E>[]] | Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const len = values.length;\n  const oks: Widen<T>[] = [];\n  const errs: WidenNever<E>[] = [];\n\n  for (let i = 0; i < len; i++) {\n    const value = values[i];\n    if (isThenable(value)) {\n      return partitionMaybePromiseAsync(values, oks, errs, i);\n    }\n    if (isOk(value)) {\n      oks.push(value as Widen<T>);\n    } else {\n      errs.push((value as Err<WidenNever<E>>).error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Executes a function, catching thrown Err values.\n * Use with unwrap for Rust-like ? operator ergonomics.\n * @param fn - Function that may throw Err via unwrap\n * @returns Ok(return value) or the caught Err\n * @example\n * const result = safeTry(() => {\n *   const a = unwrap(parseNumber('10'));\n *   const b = unwrap(parseNumber('5'));\n *   return a + b;\n * }); // Ok(15) or Err(...)\n */\nexport function safeTry<T>(fn: () => T): Result<T, unknown> {\n  try {\n    return fn() as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n\n/**\n * Async version of safeTry.\n * @param fn - Async function that may throw Err via unwrap\n * @returns Promise of Ok(return value) or the caught Err\n * @example\n * const result = await safeTryAsync(async () => {\n *   const user = unwrap(await fetchUser(id));\n *   const posts = unwrap(await fetchPosts(user.id));\n *   return { user, posts };\n * });\n */\nexport async function safeTryAsync<T>(fn: () => Promise<T>): Promise<Result<T, unknown>> {\n  try {\n    return (await fn()) as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n"],"names":["all","and","andThen","any","assertErr","assertOk","bimap","collect","collectAll","expect","expectErr","filterErr","filterOk","flatMap","flatten","fromPromise","isErr","isErrAnd","isOk","isOkAnd","isSomeErr","map","mapErr","mapOr","mapOrElse","match","of","or","orElse","partition","partitionAsync","partitionMaybePromise","partitionMaybePromiseAsync","safeTry","safeTryAsync","settleMaybePromise","settledToResult","tap","tapErr","toErrorOption","toOption","transpose","tryCatch","tryCatchMaybePromise","unwrap","unwrapErr","unwrapOr","unwrapOrElse","unwrapOrReturn","zip","zipWith","fn","onError","error","ERR","promise","result","isThenable","Promise","resolve","then","value","onErr","message","Error","String","isSome","okFn","errFn","defaultValue","defaultFn","other","optionOf","NONE","left","right","onOk","results","oks","errs","push","values","length","errors","i","opt","isNone","predicate","status","reason","promises","settled","allSettled","len","Array","pendingIndices","pendingPromises","v","s","startIndex","suffixLength","pending","resolved","e"],"mappings":"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"}

package/build/result.d.ts

@@ -20,6 +20,17 @@ export declare function tryCatch<T, E>(fn: () => T, onError: (error: unknown) =>
  * @returns Ok(result) if successful, Err(error) if thrown
  */
 export declare function of<T>(fn: () => T): Result<T, unknown>;
+/**
+ * Converts a Promise to a Result. Resolves to Ok if successful, Err on rejection.
+ * @param promise - The promise to convert
+ * @param onError - Optional error transformer
+ * @returns Promise resolving to Ok(value) or Err(error)
+ * @example
+ * await fromPromise(fetch('/api'))              // Ok(Response) or Err(unknown)
+ * await fromPromise(fetch('/api'), e => String(e)) // Ok(Response) or Err(string)
+ */
+export declare function fromPromise<T>(promise: Promise<T>): Promise<Result<T, unknown>>;
+export declare function fromPromise<T, E>(promise: Promise<T>, onError: (error: unknown) => E): Promise<Result<T, E>>;
 /**
  * Executes a function that may return sync or async, preserving sync execution when possible.
  * @param fn - Function that may return T or Promise<T>

package/build/result.js

@@ -10,6 +10,13 @@ export function tryCatch(fn, onError) {
 export function of(fn) {
     return tryCatch(fn);
 }
+export async function fromPromise(promise, onError) {
+    try {
+        return await promise;
+    } catch (error) {
+        return ERR(onError ? onError(error) : error);
+    }
+}
 export function tryCatchMaybePromise(fn, onError) {
     try {
         const result = fn();
@@ -173,7 +180,15 @@ export function collect(results) {
     return values;
 }
 export function collectAll(results) {
-    const [oks, errs] = partition(results);
+    const oks = [];
+    const errs = [];
+    for (const result of results){
+        if (isOk(result)) {
+            oks.push(result);
+        } else {
+            errs.push(result.error);
+        }
+    }
     return errs.length > 0 ? ERR(errs) : oks;
 }
 export function all(results) {

package/build/result.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/result.ts"],"sourcesContent":["import { err as ERR, isOk, isErr, isSome, isNone, NONE, optionOf, isThenable } from './types.js';\nimport type { Ok, Err, Result, Option, Widen, WidenNever, MaybePromise } from './types.js';\n\nexport type { Ok, Err, Result };\nexport { isOk, isErr };\n\n/**\n * Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @param onError - Optional error transformer\n * @returns Ok(result) if successful, Err(error) if thrown\n * @example\n * tryCatch(() => JSON.parse('{\"a\":1}'))     // Ok({a: 1})\n * tryCatch(() => JSON.parse('invalid'))     // Err(SyntaxError)\n * tryCatch(() => { throw 'oops' }, e => e)  // Err('oops')\n */\nexport function tryCatch<T>(fn: () => T): Result<T, unknown>;\nexport function tryCatch<T, E>(fn: () => T, onError: (error: unknown) => E): Result<T, E>;\nexport function tryCatch<T, E = unknown>(fn: () => T, onError?: (error: unknown) => E): Result<T, E> {\n  try {\n    return fn() as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Alias for tryCatch. Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @returns Ok(result) if successful, Err(error) if thrown\n */\nexport function of<T>(fn: () => T): Result<T, unknown> {\n  return tryCatch(fn);\n}\n\n/**\n * Executes a function that may return sync or async, preserving sync execution when possible.\n * @param fn - Function that may return T or Promise<T>\n * @param onError - Optional error transformer\n * @returns Result<T, E> if sync, Promise<Result<T, E>> if async\n * @example\n * tryCatchMaybePromise(() => 42)                    // Ok(42) - sync\n * tryCatchMaybePromise(() => Promise.resolve(42))   // Promise<Ok(42)> - async\n * tryCatchMaybePromise(() => { throw 'err' })       // Err('err') - sync\n */\nexport function tryCatchMaybePromise<T>(fn: () => MaybePromise<T>): Result<T, unknown> | Promise<Result<T, unknown>>;\nexport function tryCatchMaybePromise<T, E>(fn: () => MaybePromise<T>, onError: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>>;\nexport function tryCatchMaybePromise<T, E = unknown>(fn: () => MaybePromise<T>, onError?: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>> {\n  try {\n    const result = fn();\n    if (isThenable(result)) {\n      return Promise.resolve(result).then(\n        (value) => value as Ok<T>,\n        (error) => ERR(onError ? onError(error) : (error as E)),\n      );\n    }\n    return result as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Unwraps an Ok value or returns a computed value for Err.\n * @param result - The Result to unwrap\n * @param onErr - Function called with error if Err\n * @returns The Ok value or result of onErr(error)\n * @example\n * unwrapOrReturn(ok(42), e => 0)          // 42\n * unwrapOrReturn(err('fail'), e => 0)     // 0\n */\nexport function unwrapOrReturn<T, E, const R>(result: Result<T, E>, onErr: (error: E) => R): T | R {\n  return isOk(result) ? result : onErr(result.error);\n}\n\n/**\n * Asserts that a Result is Ok, throwing if Err.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Err\n * @example\n * assertOk(ok(42))        // passes\n * assertOk(err('failed')) // throws Error\n */\nexport function assertOk<T, E>(result: Result<T, E>, message?: string): asserts result is Ok<T> {\n  if (isErr(result)) {\n    throw new Error(message ?? `Expected Ok result. Received error: ${String(result.error)}`);\n  }\n}\n\n/**\n * Asserts that a Result is Err, throwing if Ok.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Ok\n * @example\n * assertErr(err('failed')) // passes\n * assertErr(ok(42))        // throws Error\n */\nexport function assertErr<T, E>(result: Result<T, E>, message?: string): asserts result is Err<E> {\n  if (isOk(result)) {\n    throw new Error(message ?? 'Expected Err result.');\n  }\n}\n\n/**\n * Checks if result is Err with a non-null error value.\n * @param result - The Result to check\n * @returns true if Err with Some error value\n */\nexport function isSomeErr<T, E>(result: Result<T, E>): boolean {\n  return isErr(result) && isSome(result.error);\n}\n\n/**\n * Transforms the Ok value, leaving Err unchanged.\n * @param result - The Result to map\n * @param fn - Transform function\n * @returns Ok(fn(value)) if Ok, Err unchanged\n * @example\n * map(ok(2), x => x * 2)   // Ok(4)\n * map(err('e'), x => x * 2) // Err('e')\n */\nexport function map<T, U, E>(result: Err<E>, fn: (value: T) => U): Err<E>;\nexport function map<T, U>(result: Ok<T>, fn: (value: T) => U): Ok<U>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result) as Ok<U>;\n}\n\n/**\n * Transforms the Err value, leaving Ok unchanged.\n * @param result - The Result to map\n * @param fn - Error transform function\n * @returns Err(fn(error)) if Err, Ok unchanged\n * @example\n * mapErr(err('e'), e => e.toUpperCase()) // Err('E')\n * mapErr(ok(42), e => e.toUpperCase())   // Ok(42)\n */\nexport function mapErr<T, E, F>(result: Ok<T>, fn: (error: E) => F): Ok<T>;\nexport function mapErr<E, F>(result: Err<E>, fn: (error: E) => F): Err<F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> {\n  if (isOk(result)) return result;\n  return ERR(fn(result.error));\n}\n\n/**\n * Chains Result-returning functions. Returns Err if the input is Err.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n * @example\n * flatMap(ok(2), x => ok(x * 2))    // Ok(4)\n * flatMap(ok(2), x => err('fail'))  // Err('fail')\n * flatMap(err('e'), x => ok(x * 2)) // Err('e')\n */\nexport function flatMap<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result);\n}\n\n/**\n * Alias for flatMap. Chains Result-returning functions.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n */\nexport function andThen<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;\nexport function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;\nexport function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  return isErr(result) ? result : fn(result);\n}\n\n/**\n * Executes a side effect if Ok, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function\n * @returns The original Result unchanged\n * @example\n * tap(ok(42), x => console.log(x)) // logs 42, returns Ok(42)\n */\nexport function tap<T, E>(result: Err<E>, fn: (value: T) => void): Err<E>;\nexport function tap<T>(result: Ok<T>, fn: (value: T) => void): Ok<T>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> {\n  if (isOk(result)) {\n    fn(result);\n  }\n  return result;\n}\n\n/**\n * Executes a side effect if Err, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function for error\n * @returns The original Result unchanged\n * @example\n * tapErr(err('fail'), e => console.log(e)) // logs 'fail', returns Err('fail')\n */\nexport function tapErr<T, E>(result: Ok<T>, fn: (error: E) => void): Ok<T>;\nexport function tapErr<E>(result: Err<E>, fn: (error: E) => void): Err<E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E> {\n  if (isErr(result)) {\n    fn(result.error);\n  }\n  return result;\n}\n\n/**\n * Maps both Ok and Err values simultaneously.\n * @param result - The Result to map\n * @param okFn - Transform for Ok value\n * @param errFn - Transform for Err value\n * @returns Ok(okFn(value)) if Ok, Err(errFn(error)) if Err\n * @example\n * bimap(ok(2), x => x * 2, e => e.toUpperCase())   // Ok(4)\n * bimap(err('e'), x => x * 2, e => e.toUpperCase()) // Err('E')\n */\nexport function bimap<T, U, E, F>(result: Ok<T>, okFn: (value: T) => U, errFn: (error: E) => F): Ok<U>;\nexport function bimap<T, U, E, F>(result: Err<E>, okFn: (value: T) => U, errFn: (error: E) => F): Err<F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F> {\n  return isOk(result) ? (okFn(result) as Ok<U>) : ERR(errFn(result.error));\n}\n\n/**\n * Extracts the Ok value, throws Err if not Ok.\n * Use with safeTry for Rust-like ? operator ergonomics.\n * @param result - The Result to unwrap\n * @returns The contained Ok value\n * @throws The Err object itself\n * @example\n * unwrap(ok(42))        // 42\n * unwrap(err('failed')) // throws Err\n * safeTry(() => {\n *   const a = unwrap(getValue());\n *   return a + 1;\n * });\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n  if (isErr(result)) throw result.error;\n  return result;\n}\n\n/**\n * Extracts the Err value, throws if Ok.\n * @param result - The Result to unwrap\n * @returns The contained error\n * @throws Error if result is Ok\n * @example\n * unwrapErr(err('failed')) // 'failed'\n * unwrapErr(ok(42))        // throws Error\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n  if (isOk(result)) {\n    throw new Error(`Called unwrapErr on Ok: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Extracts the Ok value, or returns a default.\n * @param result - The Result to unwrap\n * @param defaultValue - Value if Err\n * @returns The Ok value or defaultValue\n * @example\n * unwrapOr(ok(42), 0)        // 42\n * unwrapOr(err('failed'), 0) // 0\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n  return isOk(result) ? result : defaultValue;\n}\n\n/**\n * Extracts the Ok value, or computes a default from the error.\n * @param result - The Result to unwrap\n * @param fn - Function to compute default from error\n * @returns The Ok value or fn(error)\n * @example\n * unwrapOrElse(ok(42), e => 0)        // 42\n * unwrapOrElse(err('failed'), e => 0) // 0\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Maps the Ok value and returns it, or returns a default.\n * @param result - The Result to map\n * @param defaultValue - Value if Err\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultValue otherwise\n * @example\n * mapOr(ok(2), 0, x => x * 2)   // 4\n * mapOr(err('e'), 0, x => x * 2) // 0\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultValue;\n}\n\n/**\n * Maps the Ok value and returns it, or computes a default.\n * @param result - The Result to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultFn() otherwise\n * @example\n * mapOrElse(ok(2), () => 0, x => x * 2)   // 4\n * mapOrElse(err('e'), () => 0, x => x * 2) // 0\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultFn();\n}\n\n/**\n * Extracts the Ok value, throws with custom message if Err.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Err\n * @returns The Ok value\n * @throws Error with message if Err\n * @example\n * expect(ok(42), 'missing value')        // 42\n * expect(err('fail'), 'missing value')   // throws Error('missing value: fail')\n */\nexport function expect<T, E>(result: Result<T, E>, message: string): T {\n  if (isErr(result)) {\n    throw new Error(`${message}: ${String(result.error)}`);\n  }\n  return result;\n}\n\n/**\n * Extracts the Err value, throws with custom message if Ok.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Ok\n * @returns The error value\n * @throws Error with message if Ok\n * @example\n * expectErr(err('fail'), 'expected error')  // 'fail'\n * expectErr(ok(42), 'expected error')       // throws Error\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n  if (isOk(result)) {\n    throw new Error(`${message}: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Returns other if result is Ok, otherwise returns the Err.\n * @param result - First Result\n * @param other - Second Result\n * @returns other if result is Ok, result (Err) otherwise\n * @example\n * and(ok(1), ok(2))   // Ok(2)\n * and(err('e'), ok(2)) // Err('e')\n */\nexport function and<T, U, E>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n  return isOk(result) ? other : result;\n}\n\n/**\n * Returns result if Ok, otherwise returns other.\n * @param result - First Result\n * @param other - Fallback Result\n * @returns result if Ok, other otherwise\n * @example\n * or(ok(1), ok(2))    // Ok(1)\n * or(err('e'), ok(2)) // Ok(2)\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : other;\n}\n\n/**\n * Returns result if Ok, otherwise computes a fallback from the error.\n * @param result - First Result\n * @param fn - Function to compute fallback\n * @returns result if Ok, fn(error) otherwise\n * @example\n * orElse(ok(1), e => ok(0))    // Ok(1)\n * orElse(err('e'), e => ok(0)) // Ok(0)\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Converts a Result to an Option, discarding the error.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * toOption(ok(42))        // Some(42)\n * toOption(err('failed')) // None\n */\nexport function toOption<T, E>(result: Result<T, E>): Option<T> {\n  return isOk(result) ? optionOf(result) : NONE;\n}\n\n/**\n * Converts a Result's error to an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * toErrorOption(err('failed')) // Some('failed')\n * toErrorOption(ok(42))        // None\n */\nexport function toErrorOption<T, E>(result: Result<T, E>): Option<E> {\n  return isErr(result) ? optionOf(result.error) : NONE;\n}\n\n/**\n * Combines two Results into a Result of a tuple.\n * @param left - First Result\n * @param right - Second Result\n * @returns Ok([a, b]) if both Ok, first Err otherwise\n * @example\n * zip(ok(1), ok('a')) // Ok([1, 'a'])\n * zip(ok(1), err('e')) // Err('e')\n */\nexport function zip<T, U, E>(left: Result<T, E>, right: Result<U, E>): Result<[T, U], E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return [left, right] as Ok<[T, U]>;\n}\n\n/**\n * Combines two Results using a function.\n * @param left - First Result\n * @param right - Second Result\n * @param fn - Combining function\n * @returns Ok(fn(a, b)) if both Ok, first Err otherwise\n * @example\n * zipWith(ok(2), ok(3), (a, b) => a + b) // Ok(5)\n */\nexport function zipWith<T, U, V, E>(left: Result<T, E>, right: Result<U, E>, fn: (left: T, right: U) => V): Result<V, E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return fn(left, right) as Ok<V>;\n}\n\n/**\n * Flattens a nested Result.\n * @param result - Result containing a Result\n * @returns The inner Result\n * @example\n * flatten(ok(ok(42)))    // Ok(42)\n * flatten(ok(err('e')))  // Err('e')\n * flatten(err('outer'))  // Err('outer')\n */\nexport function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {\n  return isErr(result) ? (result as Err<E>) : (result as Result<T, E>);\n}\n\n/**\n * Pattern matches on a Result, handling both Ok and Err cases.\n * @param result - The Result to match\n * @param onOk - Handler for Ok case\n * @param onErr - Handler for Err case\n * @returns Result of the matching handler\n * @example\n * match(ok(42), x => x * 2, e => 0)   // 84\n * match(err('e'), x => x * 2, e => 0) // 0\n */\nexport function match<T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U {\n  return isOk(result) ? onOk(result) : onErr(result.error);\n}\n\n/**\n * Separates an array of Results into Ok values and Err values.\n * @param results - Array of Results\n * @returns Tuple of [Ok values, Err values]\n * @example\n * partition([ok(1), err('a'), ok(2)]) // [[1, 2], ['a']]\n */\nexport function partition<T, E>(results: Result<T, E>[]): [T[], E[]] {\n  const oks: T[] = [];\n  const errs: E[] = [];\n\n  for (const result of results) {\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Extracts all Ok values from an iterable of Results.\n * @param results - Iterable of Results\n * @returns Array of Ok values\n * @example\n * filterOk([ok(1), err('a'), ok(2)]) // [1, 2]\n */\nexport function filterOk<T, E>(results: Iterable<Result<T, E>>): T[] {\n  const oks: T[] = [];\n  for (const result of results) {\n    if (isOk(result)) oks.push(result);\n  }\n  return oks;\n}\n\n/**\n * Extracts all Err values from an iterable of Results.\n * @param results - Iterable of Results\n * @returns Array of error values\n * @example\n * filterErr([ok(1), err('a'), ok(2)]) // ['a']\n */\nexport function filterErr<T, E>(results: Iterable<Result<T, E>>): E[] {\n  const errs: E[] = [];\n  for (const result of results) {\n    if (isErr(result)) errs.push(result.error);\n  }\n  return errs;\n}\n\n/**\n * Collects an array of Results into a Result of an array. Fails on first Err.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n * @example\n * collect([ok(1), ok(2)])       // Ok([1, 2])\n * collect([ok(1), err('e')])    // Err('e')\n */\nexport function collect<T, E>(results: Result<T, E>[]): Result<T[], E> {\n  const values: T[] = [];\n\n  for (const result of results) {\n    if (isErr(result)) return result;\n    values.push(result);\n  }\n\n  return values as Ok<T[]>;\n}\n\n/**\n * Collects all Results, returning all errors if any exist.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, Err(allErrors) otherwise\n * @example\n * collectAll([ok(1), ok(2)])           // Ok([1, 2])\n * collectAll([ok(1), err('a'), err('b')]) // Err(['a', 'b'])\n */\nexport function collectAll<T, E>(results: Result<T, E>[]): Result<T[], E[]> {\n  const [oks, errs] = partition(results);\n  return errs.length > 0 ? ERR(errs) : (oks as Ok<T[]>);\n}\n\n/**\n * Alias for collect with widened types. Collects Results into a Result of array.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n */\nexport function all<T, E>(results: Result<T, E>[]): Result<readonly Widen<T>[], WidenNever<E>> {\n  return collect(results) as Result<readonly Widen<T>[], WidenNever<E>>;\n}\n\n/**\n * Returns the first Ok, or all errors if none succeed.\n * @param results - Array of Results\n * @returns First Ok found, or Err(allErrors) if all fail\n * @example\n * any([err('a'), ok(1), err('b')]) // Ok(1)\n * any([err('a'), err('b')])        // Err(['a', 'b'])\n */\nexport function any<T, E>(results: Result<T, E>[]): Result<Widen<T>, WidenNever<E>[]> {\n  const errors: WidenNever<E>[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) return result as Ok<Widen<T>>;\n    errors.push((result as Err<WidenNever<E>>).error);\n  }\n  return ERR(errors);\n}\n\n/**\n * Transposes a Result of Option to an Option of Result.\n * @param result - Result containing an Option\n * @returns Some(Ok(value)) if Ok(Some), None if Ok(None), Some(Err) if Err\n * @example\n * transpose(ok(some(42)))  // Some(Ok(42))\n * transpose(ok(none))      // None\n * transpose(err('e'))      // Some(Err('e'))\n */\nexport function transpose<T, E>(result: Result<Option<T>, E>): Option<Result<T, E>> {\n  if (isErr(result)) {\n    return ERR(result.error) as Option<Result<T, E>>;\n  }\n  const opt = result as Option<T>;\n  return isNone(opt) ? NONE : (opt as unknown as Ok<T> as Option<Result<T, E>>);\n}\n\n/**\n * Checks if Ok and the value satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Ok and predicate returns true\n * @example\n * isOkAnd(ok(4), x => x > 2)   // true\n * isOkAnd(ok(1), x => x > 2)   // false\n * isOkAnd(err('e'), x => x > 2) // false\n */\nexport function isOkAnd<T, E>(result: Result<T, E>, predicate: (value: T) => boolean): boolean {\n  return isOk(result) && predicate(result);\n}\n\n/**\n * Checks if Err and the error satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Err and predicate returns true\n * @example\n * isErrAnd(err('fatal'), e => e.includes('fatal')) // true\n * isErrAnd(ok(42), e => true)                       // false\n */\nexport function isErrAnd<T, E>(result: Result<T, E>, predicate: (error: E) => boolean): boolean {\n  return isErr(result) && predicate(result.error);\n}\n\nexport function settledToResult<T, E>(result: PromiseSettledResult<Result<T, E>>): Result<T, E> {\n  if (result.status === 'fulfilled') return result.value;\n  return ERR(result.reason);\n}\n\n/**\n * Partitions an async iterable of Results.\n * @param results - Iterable of Promise Results\n * @returns Promise of [Ok values, Err values]\n * @example\n * await partitionAsync([Promise.resolve(ok(1)), Promise.resolve(err('a'))])\n * // [[1], ['a']]\n */\nexport async function partitionAsync<T, E>(promises: Iterable<Promise<Result<T, E>>>): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const settled = await Promise.allSettled(promises);\n  return partition(settled.map(settledToResult)) as [Widen<T>[], WidenNever<E>[]];\n}\n\n/**\n * Settles an array of MaybePromise values into Results.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of values that may or may not be Promises\n * @returns Array of Results (sync) or Promise of Results (if any async)\n * @example\n * settleMaybePromise([1, 2, 3])                    // [Ok(1), Ok(2), Ok(3)] - sync\n * settleMaybePromise([1, Promise.resolve(2)])     // Promise<[Ok(1), Ok(2)]>\n * settleMaybePromise([Promise.reject('e')])       // Promise<[Err('e')]>\n */\nexport function settleMaybePromise<T, E = unknown>(values: MaybePromise<T>[]): Result<T, E>[] | Promise<Result<T, E>[]> {\n  const len = values.length;\n  const results = new Array<Result<T, E>>(len);\n  let pendingIndices: number[] | undefined;\n  let pendingPromises: Promise<T>[] | undefined;\n\n  for (let i = 0; i < len; i++) {\n    const v = values[i];\n    if (isThenable(v)) {\n      (pendingIndices ??= []).push(i);\n      (pendingPromises ??= []).push(Promise.resolve(v));\n    } else {\n      results[i] = v as Ok<T>;\n    }\n  }\n\n  if (!pendingPromises) return results;\n\n  return Promise.allSettled(pendingPromises).then((settled) => {\n    for (let i = 0; i < settled.length; i++) {\n      const s = settled[i];\n      results[pendingIndices![i]] = s.status === 'fulfilled' ? (s.value as Ok<T>) : ERR(s.reason as E);\n    }\n    return results;\n  });\n}\n\nexport async function partitionMaybePromiseAsync<T, E>(\n  values: MaybePromise<Result<T, E>>[],\n  oks: Widen<T>[],\n  errs: WidenNever<E>[],\n  startIndex: number = 0,\n): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const suffixLength = values.length - startIndex;\n  const pending = new Array<Promise<Result<T, E>>>(suffixLength);\n\n  for (let i = 0; i < suffixLength; i++) {\n    const value = values[startIndex + i];\n    pending[i] = Promise.resolve(value).then(\n      (result) => result as Result<T, E>,\n      (error) => ERR(error as E),\n    );\n  }\n\n  const resolved = await Promise.all(pending);\n  for (let i = 0; i < resolved.length; i++) {\n    const result = resolved[i];\n    if (isOk(result)) {\n      oks.push(result as Widen<T>);\n    } else {\n      errs.push((result as Err<WidenNever<E>>).error);\n    }\n  }\n  return [oks, errs] as [Widen<T>[], WidenNever<E>[]];\n}\n\n/**\n * Partitions MaybePromise Results into Ok and Err values.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of MaybePromise Results\n * @returns [Ok values, Err values] (sync) or Promise of same (if any async)\n * @example\n * partitionMaybePromise([ok(1), err('a')])                   // [[1], ['a']] - sync\n * partitionMaybePromise([ok(1), Promise.resolve(err('a'))]) // Promise<[[1], ['a']]>\n */\nexport function partitionMaybePromise<T, E>(values: MaybePromise<Result<T, E>>[]): [Widen<T>[], WidenNever<E>[]] | Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const len = values.length;\n  const oks: Widen<T>[] = [];\n  const errs: WidenNever<E>[] = [];\n\n  for (let i = 0; i < len; i++) {\n    const value = values[i];\n    if (isThenable(value)) {\n      return partitionMaybePromiseAsync(values, oks, errs, i);\n    }\n    if (isOk(value)) {\n      oks.push(value as Widen<T>);\n    } else {\n      errs.push((value as Err<WidenNever<E>>).error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Executes a function, catching thrown Err values.\n * Use with unwrap for Rust-like ? operator ergonomics.\n * @param fn - Function that may throw Err via unwrap\n * @returns Ok(return value) or the caught Err\n * @example\n * const result = safeTry(() => {\n *   const a = unwrap(parseNumber('10'));\n *   const b = unwrap(parseNumber('5'));\n *   return a + b;\n * }); // Ok(15) or Err(...)\n */\nexport function safeTry<T>(fn: () => T): Result<T, unknown> {\n  try {\n    return fn() as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n\n/**\n * Async version of safeTry.\n * @param fn - Async function that may throw Err via unwrap\n * @returns Promise of Ok(return value) or the caught Err\n * @example\n * const result = await safeTryAsync(async () => {\n *   const user = unwrap(await fetchUser(id));\n *   const posts = unwrap(await fetchPosts(user.id));\n *   return { user, posts };\n * });\n */\nexport async function safeTryAsync<T>(fn: () => Promise<T>): Promise<Result<T, unknown>> {\n  try {\n    return (await fn()) as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n"],"names":["err","ERR","isOk","isErr","isSome","isNone","NONE","optionOf","isThenable","tryCatch","fn","onError","error","of","tryCatchMaybePromise","result","Promise","resolve","then","value","unwrapOrReturn","onErr","assertOk","message","Error","String","assertErr","isSomeErr","map","mapErr","flatMap","andThen","tap","tapErr","bimap","okFn","errFn","unwrap","unwrapErr","unwrapOr","defaultValue","unwrapOrElse","mapOr","mapOrElse","defaultFn","expect","expectErr","and","other","or","orElse","toOption","toErrorOption","zip","left","right","zipWith","flatten","match","onOk","partition","results","oks","errs","push","filterOk","filterErr","collect","values","collectAll","length","all","any","errors","i","transpose","opt","isOkAnd","predicate","isErrAnd","settledToResult","status","reason","partitionAsync","promises","settled","allSettled","settleMaybePromise","len","Array","pendingIndices","pendingPromises","v","s","partitionMaybePromiseAsync","startIndex","suffixLength","pending","resolved","partitionMaybePromise","safeTry","e","safeTryAsync"],"mappings":"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"}
+{"version":3,"sources":["../src/result.ts"],"sourcesContent":["import { err as ERR, isOk, isErr, isSome, isNone, NONE, optionOf, isThenable } from './types.js';\nimport type { Ok, Err, Result, Option, Widen, WidenNever, MaybePromise } from './types.js';\n\nexport type { Ok, Err, Result };\nexport { isOk, isErr };\n\n/**\n * Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @param onError - Optional error transformer\n * @returns Ok(result) if successful, Err(error) if thrown\n * @example\n * tryCatch(() => JSON.parse('{\"a\":1}'))     // Ok({a: 1})\n * tryCatch(() => JSON.parse('invalid'))     // Err(SyntaxError)\n * tryCatch(() => { throw 'oops' }, e => e)  // Err('oops')\n */\nexport function tryCatch<T>(fn: () => T): Result<T, unknown>;\nexport function tryCatch<T, E>(fn: () => T, onError: (error: unknown) => E): Result<T, E>;\nexport function tryCatch<T, E = unknown>(fn: () => T, onError?: (error: unknown) => E): Result<T, E> {\n  try {\n    return fn() as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Alias for tryCatch. Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @returns Ok(result) if successful, Err(error) if thrown\n */\nexport function of<T>(fn: () => T): Result<T, unknown> {\n  return tryCatch(fn);\n}\n\n/**\n * Converts a Promise to a Result. Resolves to Ok if successful, Err on rejection.\n * @param promise - The promise to convert\n * @param onError - Optional error transformer\n * @returns Promise resolving to Ok(value) or Err(error)\n * @example\n * await fromPromise(fetch('/api'))              // Ok(Response) or Err(unknown)\n * await fromPromise(fetch('/api'), e => String(e)) // Ok(Response) or Err(string)\n */\nexport async function fromPromise<T>(promise: Promise<T>): Promise<Result<T, unknown>>;\nexport async function fromPromise<T, E>(promise: Promise<T>, onError: (error: unknown) => E): Promise<Result<T, E>>;\nexport async function fromPromise<T, E = unknown>(promise: Promise<T>, onError?: (error: unknown) => E): Promise<Result<T, E>> {\n  try {\n    return (await promise) as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Executes a function that may return sync or async, preserving sync execution when possible.\n * @param fn - Function that may return T or Promise<T>\n * @param onError - Optional error transformer\n * @returns Result<T, E> if sync, Promise<Result<T, E>> if async\n * @example\n * tryCatchMaybePromise(() => 42)                    // Ok(42) - sync\n * tryCatchMaybePromise(() => Promise.resolve(42))   // Promise<Ok(42)> - async\n * tryCatchMaybePromise(() => { throw 'err' })       // Err('err') - sync\n */\nexport function tryCatchMaybePromise<T>(fn: () => MaybePromise<T>): Result<T, unknown> | Promise<Result<T, unknown>>;\nexport function tryCatchMaybePromise<T, E>(fn: () => MaybePromise<T>, onError: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>>;\nexport function tryCatchMaybePromise<T, E = unknown>(fn: () => MaybePromise<T>, onError?: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>> {\n  try {\n    const result = fn();\n    if (isThenable(result)) {\n      return Promise.resolve(result).then(\n        (value) => value as Ok<T>,\n        (error) => ERR(onError ? onError(error) : (error as E)),\n      );\n    }\n    return result as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Unwraps an Ok value or returns a computed value for Err.\n * @param result - The Result to unwrap\n * @param onErr - Function called with error if Err\n * @returns The Ok value or result of onErr(error)\n * @example\n * unwrapOrReturn(ok(42), e => 0)          // 42\n * unwrapOrReturn(err('fail'), e => 0)     // 0\n */\nexport function unwrapOrReturn<T, E, const R>(result: Result<T, E>, onErr: (error: E) => R): T | R {\n  return isOk(result) ? result : onErr(result.error);\n}\n\n/**\n * Asserts that a Result is Ok, throwing if Err.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Err\n * @example\n * assertOk(ok(42))        // passes\n * assertOk(err('failed')) // throws Error\n */\nexport function assertOk<T, E>(result: Result<T, E>, message?: string): asserts result is Ok<T> {\n  if (isErr(result)) {\n    throw new Error(message ?? `Expected Ok result. Received error: ${String(result.error)}`);\n  }\n}\n\n/**\n * Asserts that a Result is Err, throwing if Ok.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Ok\n * @example\n * assertErr(err('failed')) // passes\n * assertErr(ok(42))        // throws Error\n */\nexport function assertErr<T, E>(result: Result<T, E>, message?: string): asserts result is Err<E> {\n  if (isOk(result)) {\n    throw new Error(message ?? 'Expected Err result.');\n  }\n}\n\n/**\n * Checks if result is Err with a non-null error value.\n * @param result - The Result to check\n * @returns true if Err with Some error value\n */\nexport function isSomeErr<T, E>(result: Result<T, E>): boolean {\n  return isErr(result) && isSome(result.error);\n}\n\n/**\n * Transforms the Ok value, leaving Err unchanged.\n * @param result - The Result to map\n * @param fn - Transform function\n * @returns Ok(fn(value)) if Ok, Err unchanged\n * @example\n * map(ok(2), x => x * 2)   // Ok(4)\n * map(err('e'), x => x * 2) // Err('e')\n */\nexport function map<T, U, E>(result: Err<E>, fn: (value: T) => U): Err<E>;\nexport function map<T, U>(result: Ok<T>, fn: (value: T) => U): Ok<U>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result) as Ok<U>;\n}\n\n/**\n * Transforms the Err value, leaving Ok unchanged.\n * @param result - The Result to map\n * @param fn - Error transform function\n * @returns Err(fn(error)) if Err, Ok unchanged\n * @example\n * mapErr(err('e'), e => e.toUpperCase()) // Err('E')\n * mapErr(ok(42), e => e.toUpperCase())   // Ok(42)\n */\nexport function mapErr<T, E, F>(result: Ok<T>, fn: (error: E) => F): Ok<T>;\nexport function mapErr<E, F>(result: Err<E>, fn: (error: E) => F): Err<F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> {\n  if (isOk(result)) return result;\n  return ERR(fn(result.error));\n}\n\n/**\n * Chains Result-returning functions. Returns Err if the input is Err.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n * @example\n * flatMap(ok(2), x => ok(x * 2))    // Ok(4)\n * flatMap(ok(2), x => err('fail'))  // Err('fail')\n * flatMap(err('e'), x => ok(x * 2)) // Err('e')\n */\nexport function flatMap<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  if (isErr(result)) return result;\n  return fn(result);\n}\n\n/**\n * Alias for flatMap. Chains Result-returning functions.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n */\nexport function andThen<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;\nexport function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;\nexport function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  return isErr(result) ? result : fn(result);\n}\n\n/**\n * Executes a side effect if Ok, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function\n * @returns The original Result unchanged\n * @example\n * tap(ok(42), x => console.log(x)) // logs 42, returns Ok(42)\n */\nexport function tap<T, E>(result: Err<E>, fn: (value: T) => void): Err<E>;\nexport function tap<T>(result: Ok<T>, fn: (value: T) => void): Ok<T>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> {\n  if (isOk(result)) {\n    fn(result);\n  }\n  return result;\n}\n\n/**\n * Executes a side effect if Err, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function for error\n * @returns The original Result unchanged\n * @example\n * tapErr(err('fail'), e => console.log(e)) // logs 'fail', returns Err('fail')\n */\nexport function tapErr<T, E>(result: Ok<T>, fn: (error: E) => void): Ok<T>;\nexport function tapErr<E>(result: Err<E>, fn: (error: E) => void): Err<E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E> {\n  if (isErr(result)) {\n    fn(result.error);\n  }\n  return result;\n}\n\n/**\n * Maps both Ok and Err values simultaneously.\n * @param result - The Result to map\n * @param okFn - Transform for Ok value\n * @param errFn - Transform for Err value\n * @returns Ok(okFn(value)) if Ok, Err(errFn(error)) if Err\n * @example\n * bimap(ok(2), x => x * 2, e => e.toUpperCase())   // Ok(4)\n * bimap(err('e'), x => x * 2, e => e.toUpperCase()) // Err('E')\n */\nexport function bimap<T, U, E, F>(result: Ok<T>, okFn: (value: T) => U, errFn: (error: E) => F): Ok<U>;\nexport function bimap<T, U, E, F>(result: Err<E>, okFn: (value: T) => U, errFn: (error: E) => F): Err<F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F> {\n  return isOk(result) ? (okFn(result) as Ok<U>) : ERR(errFn(result.error));\n}\n\n/**\n * Extracts the Ok value, throws Err if not Ok.\n * Use with safeTry for Rust-like ? operator ergonomics.\n * @param result - The Result to unwrap\n * @returns The contained Ok value\n * @throws The Err object itself\n * @example\n * unwrap(ok(42))        // 42\n * unwrap(err('failed')) // throws Err\n * safeTry(() => {\n *   const a = unwrap(getValue());\n *   return a + 1;\n * });\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n  if (isErr(result)) throw result.error;\n  return result;\n}\n\n/**\n * Extracts the Err value, throws if Ok.\n * @param result - The Result to unwrap\n * @returns The contained error\n * @throws Error if result is Ok\n * @example\n * unwrapErr(err('failed')) // 'failed'\n * unwrapErr(ok(42))        // throws Error\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n  if (isOk(result)) {\n    throw new Error(`Called unwrapErr on Ok: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Extracts the Ok value, or returns a default.\n * @param result - The Result to unwrap\n * @param defaultValue - Value if Err\n * @returns The Ok value or defaultValue\n * @example\n * unwrapOr(ok(42), 0)        // 42\n * unwrapOr(err('failed'), 0) // 0\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n  return isOk(result) ? result : defaultValue;\n}\n\n/**\n * Extracts the Ok value, or computes a default from the error.\n * @param result - The Result to unwrap\n * @param fn - Function to compute default from error\n * @returns The Ok value or fn(error)\n * @example\n * unwrapOrElse(ok(42), e => 0)        // 42\n * unwrapOrElse(err('failed'), e => 0) // 0\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Maps the Ok value and returns it, or returns a default.\n * @param result - The Result to map\n * @param defaultValue - Value if Err\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultValue otherwise\n * @example\n * mapOr(ok(2), 0, x => x * 2)   // 4\n * mapOr(err('e'), 0, x => x * 2) // 0\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultValue;\n}\n\n/**\n * Maps the Ok value and returns it, or computes a default.\n * @param result - The Result to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultFn() otherwise\n * @example\n * mapOrElse(ok(2), () => 0, x => x * 2)   // 4\n * mapOrElse(err('e'), () => 0, x => x * 2) // 0\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultFn();\n}\n\n/**\n * Extracts the Ok value, throws with custom message if Err.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Err\n * @returns The Ok value\n * @throws Error with message if Err\n * @example\n * expect(ok(42), 'missing value')        // 42\n * expect(err('fail'), 'missing value')   // throws Error('missing value: fail')\n */\nexport function expect<T, E>(result: Result<T, E>, message: string): T {\n  if (isErr(result)) {\n    throw new Error(`${message}: ${String(result.error)}`);\n  }\n  return result;\n}\n\n/**\n * Extracts the Err value, throws with custom message if Ok.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Ok\n * @returns The error value\n * @throws Error with message if Ok\n * @example\n * expectErr(err('fail'), 'expected error')  // 'fail'\n * expectErr(ok(42), 'expected error')       // throws Error\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n  if (isOk(result)) {\n    throw new Error(`${message}: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Returns other if result is Ok, otherwise returns the Err.\n * @param result - First Result\n * @param other - Second Result\n * @returns other if result is Ok, result (Err) otherwise\n * @example\n * and(ok(1), ok(2))   // Ok(2)\n * and(err('e'), ok(2)) // Err('e')\n */\nexport function and<T, U, E>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n  return isOk(result) ? other : result;\n}\n\n/**\n * Returns result if Ok, otherwise returns other.\n * @param result - First Result\n * @param other - Fallback Result\n * @returns result if Ok, other otherwise\n * @example\n * or(ok(1), ok(2))    // Ok(1)\n * or(err('e'), ok(2)) // Ok(2)\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : other;\n}\n\n/**\n * Returns result if Ok, otherwise computes a fallback from the error.\n * @param result - First Result\n * @param fn - Function to compute fallback\n * @returns result if Ok, fn(error) otherwise\n * @example\n * orElse(ok(1), e => ok(0))    // Ok(1)\n * orElse(err('e'), e => ok(0)) // Ok(0)\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Converts a Result to an Option, discarding the error.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * toOption(ok(42))        // Some(42)\n * toOption(err('failed')) // None\n */\nexport function toOption<T, E>(result: Result<T, E>): Option<T> {\n  return isOk(result) ? optionOf(result) : NONE;\n}\n\n/**\n * Converts a Result's error to an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * toErrorOption(err('failed')) // Some('failed')\n * toErrorOption(ok(42))        // None\n */\nexport function toErrorOption<T, E>(result: Result<T, E>): Option<E> {\n  return isErr(result) ? optionOf(result.error) : NONE;\n}\n\n/**\n * Combines two Results into a Result of a tuple.\n * @param left - First Result\n * @param right - Second Result\n * @returns Ok([a, b]) if both Ok, first Err otherwise\n * @example\n * zip(ok(1), ok('a')) // Ok([1, 'a'])\n * zip(ok(1), err('e')) // Err('e')\n */\nexport function zip<T, U, E>(left: Result<T, E>, right: Result<U, E>): Result<[T, U], E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return [left, right] as Ok<[T, U]>;\n}\n\n/**\n * Combines two Results using a function.\n * @param left - First Result\n * @param right - Second Result\n * @param fn - Combining function\n * @returns Ok(fn(a, b)) if both Ok, first Err otherwise\n * @example\n * zipWith(ok(2), ok(3), (a, b) => a + b) // Ok(5)\n */\nexport function zipWith<T, U, V, E>(left: Result<T, E>, right: Result<U, E>, fn: (left: T, right: U) => V): Result<V, E> {\n  if (isErr(left)) return left;\n  if (isErr(right)) return right;\n  return fn(left, right) as Ok<V>;\n}\n\n/**\n * Flattens a nested Result.\n * @param result - Result containing a Result\n * @returns The inner Result\n * @example\n * flatten(ok(ok(42)))    // Ok(42)\n * flatten(ok(err('e')))  // Err('e')\n * flatten(err('outer'))  // Err('outer')\n */\nexport function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {\n  return isErr(result) ? (result as Err<E>) : (result as Result<T, E>);\n}\n\n/**\n * Pattern matches on a Result, handling both Ok and Err cases.\n * @param result - The Result to match\n * @param onOk - Handler for Ok case\n * @param onErr - Handler for Err case\n * @returns Result of the matching handler\n * @example\n * match(ok(42), x => x * 2, e => 0)   // 84\n * match(err('e'), x => x * 2, e => 0) // 0\n */\nexport function match<T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U {\n  return isOk(result) ? onOk(result) : onErr(result.error);\n}\n\n/**\n * Separates an array of Results into Ok values and Err values.\n * @param results - Array of Results\n * @returns Tuple of [Ok values, Err values]\n * @example\n * partition([ok(1), err('a'), ok(2)]) // [[1, 2], ['a']]\n */\nexport function partition<T, E>(results: Result<T, E>[]): [T[], E[]] {\n  const oks: T[] = [];\n  const errs: E[] = [];\n\n  for (const result of results) {\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Extracts all Ok values from an iterable of Results.\n * @param results - Iterable of Results\n * @returns Array of Ok values\n * @example\n * filterOk([ok(1), err('a'), ok(2)]) // [1, 2]\n */\nexport function filterOk<T, E>(results: Iterable<Result<T, E>>): T[] {\n  const oks: T[] = [];\n  for (const result of results) {\n    if (isOk(result)) oks.push(result);\n  }\n  return oks;\n}\n\n/**\n * Extracts all Err values from an iterable of Results.\n * @param results - Iterable of Results\n * @returns Array of error values\n * @example\n * filterErr([ok(1), err('a'), ok(2)]) // ['a']\n */\nexport function filterErr<T, E>(results: Iterable<Result<T, E>>): E[] {\n  const errs: E[] = [];\n  for (const result of results) {\n    if (isErr(result)) errs.push(result.error);\n  }\n  return errs;\n}\n\n/**\n * Collects an array of Results into a Result of an array. Fails on first Err.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n * @example\n * collect([ok(1), ok(2)])       // Ok([1, 2])\n * collect([ok(1), err('e')])    // Err('e')\n */\nexport function collect<T, E>(results: Result<T, E>[]): Result<T[], E> {\n  const values: T[] = [];\n\n  for (const result of results) {\n    if (isErr(result)) return result;\n    values.push(result);\n  }\n\n  return values as Ok<T[]>;\n}\n\n/**\n * Collects all Results, returning all errors if any exist.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, Err(allErrors) otherwise\n * @example\n * collectAll([ok(1), ok(2)])           // Ok([1, 2])\n * collectAll([ok(1), err('a'), err('b')]) // Err(['a', 'b'])\n */\nexport function collectAll<T, E>(results: Result<T, E>[]): Result<T[], E[]> {\n  const oks: T[] = [];\n  const errs: E[] = [];\n  for (const result of results) {\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n  return errs.length > 0 ? ERR(errs) : (oks as Ok<T[]>);\n}\n\n/**\n * Alias for collect with widened types. Collects Results into a Result of array.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n */\nexport function all<T, E>(results: Result<T, E>[]): Result<readonly Widen<T>[], WidenNever<E>> {\n  return collect(results) as Result<readonly Widen<T>[], WidenNever<E>>;\n}\n\n/**\n * Returns the first Ok, or all errors if none succeed.\n * @param results - Array of Results\n * @returns First Ok found, or Err(allErrors) if all fail\n * @example\n * any([err('a'), ok(1), err('b')]) // Ok(1)\n * any([err('a'), err('b')])        // Err(['a', 'b'])\n */\nexport function any<T, E>(results: Result<T, E>[]): Result<Widen<T>, WidenNever<E>[]> {\n  const errors: WidenNever<E>[] = [];\n  for (let i = 0; i < results.length; i++) {\n    const result = results[i];\n    if (isOk(result)) return result as Ok<Widen<T>>;\n    errors.push((result as Err<WidenNever<E>>).error);\n  }\n  return ERR(errors);\n}\n\n/**\n * Transposes a Result of Option to an Option of Result.\n * @param result - Result containing an Option\n * @returns Some(Ok(value)) if Ok(Some), None if Ok(None), Some(Err) if Err\n * @example\n * transpose(ok(some(42)))  // Some(Ok(42))\n * transpose(ok(none))      // None\n * transpose(err('e'))      // Some(Err('e'))\n */\nexport function transpose<T, E>(result: Result<Option<T>, E>): Option<Result<T, E>> {\n  if (isErr(result)) {\n    return ERR(result.error) as Option<Result<T, E>>;\n  }\n  const opt = result as Option<T>;\n  return isNone(opt) ? NONE : (opt as unknown as Ok<T> as Option<Result<T, E>>);\n}\n\n/**\n * Checks if Ok and the value satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Ok and predicate returns true\n * @example\n * isOkAnd(ok(4), x => x > 2)   // true\n * isOkAnd(ok(1), x => x > 2)   // false\n * isOkAnd(err('e'), x => x > 2) // false\n */\nexport function isOkAnd<T, E>(result: Result<T, E>, predicate: (value: T) => boolean): boolean {\n  return isOk(result) && predicate(result);\n}\n\n/**\n * Checks if Err and the error satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Err and predicate returns true\n * @example\n * isErrAnd(err('fatal'), e => e.includes('fatal')) // true\n * isErrAnd(ok(42), e => true)                       // false\n */\nexport function isErrAnd<T, E>(result: Result<T, E>, predicate: (error: E) => boolean): boolean {\n  return isErr(result) && predicate(result.error);\n}\n\nexport function settledToResult<T, E>(result: PromiseSettledResult<Result<T, E>>): Result<T, E> {\n  if (result.status === 'fulfilled') return result.value;\n  return ERR(result.reason);\n}\n\n/**\n * Partitions an async iterable of Results.\n * @param results - Iterable of Promise Results\n * @returns Promise of [Ok values, Err values]\n * @example\n * await partitionAsync([Promise.resolve(ok(1)), Promise.resolve(err('a'))])\n * // [[1], ['a']]\n */\nexport async function partitionAsync<T, E>(promises: Iterable<Promise<Result<T, E>>>): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const settled = await Promise.allSettled(promises);\n  return partition(settled.map(settledToResult)) as [Widen<T>[], WidenNever<E>[]];\n}\n\n/**\n * Settles an array of MaybePromise values into Results.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of values that may or may not be Promises\n * @returns Array of Results (sync) or Promise of Results (if any async)\n * @example\n * settleMaybePromise([1, 2, 3])                    // [Ok(1), Ok(2), Ok(3)] - sync\n * settleMaybePromise([1, Promise.resolve(2)])     // Promise<[Ok(1), Ok(2)]>\n * settleMaybePromise([Promise.reject('e')])       // Promise<[Err('e')]>\n */\nexport function settleMaybePromise<T, E = unknown>(values: MaybePromise<T>[]): Result<T, E>[] | Promise<Result<T, E>[]> {\n  const len = values.length;\n  const results = new Array<Result<T, E>>(len);\n  let pendingIndices: number[] | undefined;\n  let pendingPromises: Promise<T>[] | undefined;\n\n  for (let i = 0; i < len; i++) {\n    const v = values[i];\n    if (isThenable(v)) {\n      (pendingIndices ??= []).push(i);\n      (pendingPromises ??= []).push(Promise.resolve(v));\n    } else {\n      results[i] = v as Ok<T>;\n    }\n  }\n\n  if (!pendingPromises) return results;\n\n  return Promise.allSettled(pendingPromises).then((settled) => {\n    for (let i = 0; i < settled.length; i++) {\n      const s = settled[i];\n      results[pendingIndices![i]] = s.status === 'fulfilled' ? (s.value as Ok<T>) : ERR(s.reason as E);\n    }\n    return results;\n  });\n}\n\nexport async function partitionMaybePromiseAsync<T, E>(\n  values: MaybePromise<Result<T, E>>[],\n  oks: Widen<T>[],\n  errs: WidenNever<E>[],\n  startIndex: number = 0,\n): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const suffixLength = values.length - startIndex;\n  const pending = new Array<Promise<Result<T, E>>>(suffixLength);\n\n  for (let i = 0; i < suffixLength; i++) {\n    const value = values[startIndex + i];\n    pending[i] = Promise.resolve(value).then(\n      (result) => result as Result<T, E>,\n      (error) => ERR(error as E),\n    );\n  }\n\n  const resolved = await Promise.all(pending);\n  for (let i = 0; i < resolved.length; i++) {\n    const result = resolved[i];\n    if (isOk(result)) {\n      oks.push(result as Widen<T>);\n    } else {\n      errs.push((result as Err<WidenNever<E>>).error);\n    }\n  }\n  return [oks, errs] as [Widen<T>[], WidenNever<E>[]];\n}\n\n/**\n * Partitions MaybePromise Results into Ok and Err values.\n * Returns synchronously if all inputs are sync, avoiding Promise overhead.\n * @param values - Array of MaybePromise Results\n * @returns [Ok values, Err values] (sync) or Promise of same (if any async)\n * @example\n * partitionMaybePromise([ok(1), err('a')])                   // [[1], ['a']] - sync\n * partitionMaybePromise([ok(1), Promise.resolve(err('a'))]) // Promise<[[1], ['a']]>\n */\nexport function partitionMaybePromise<T, E>(values: MaybePromise<Result<T, E>>[]): [Widen<T>[], WidenNever<E>[]] | Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const len = values.length;\n  const oks: Widen<T>[] = [];\n  const errs: WidenNever<E>[] = [];\n\n  for (let i = 0; i < len; i++) {\n    const value = values[i];\n    if (isThenable(value)) {\n      return partitionMaybePromiseAsync(values, oks, errs, i);\n    }\n    if (isOk(value)) {\n      oks.push(value as Widen<T>);\n    } else {\n      errs.push((value as Err<WidenNever<E>>).error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Executes a function, catching thrown Err values.\n * Use with unwrap for Rust-like ? operator ergonomics.\n * @param fn - Function that may throw Err via unwrap\n * @returns Ok(return value) or the caught Err\n * @example\n * const result = safeTry(() => {\n *   const a = unwrap(parseNumber('10'));\n *   const b = unwrap(parseNumber('5'));\n *   return a + b;\n * }); // Ok(15) or Err(...)\n */\nexport function safeTry<T>(fn: () => T): Result<T, unknown> {\n  try {\n    return fn() as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n\n/**\n * Async version of safeTry.\n * @param fn - Async function that may throw Err via unwrap\n * @returns Promise of Ok(return value) or the caught Err\n * @example\n * const result = await safeTryAsync(async () => {\n *   const user = unwrap(await fetchUser(id));\n *   const posts = unwrap(await fetchPosts(user.id));\n *   return { user, posts };\n * });\n */\nexport async function safeTryAsync<T>(fn: () => Promise<T>): Promise<Result<T, unknown>> {\n  try {\n    return (await fn()) as Ok<T>;\n  } catch (e) {\n    return ERR(e);\n  }\n}\n"],"names":["err","ERR","isOk","isErr","isSome","isNone","NONE","optionOf","isThenable","tryCatch","fn","onError","error","of","fromPromise","promise","tryCatchMaybePromise","result","Promise","resolve","then","value","unwrapOrReturn","onErr","assertOk","message","Error","String","assertErr","isSomeErr","map","mapErr","flatMap","andThen","tap","tapErr","bimap","okFn","errFn","unwrap","unwrapErr","unwrapOr","defaultValue","unwrapOrElse","mapOr","mapOrElse","defaultFn","expect","expectErr","and","other","or","orElse","toOption","toErrorOption","zip","left","right","zipWith","flatten","match","onOk","partition","results","oks","errs","push","filterOk","filterErr","collect","values","collectAll","length","all","any","errors","i","transpose","opt","isOkAnd","predicate","isErrAnd","settledToResult","status","reason","partitionAsync","promises","settled","allSettled","settleMaybePromise","len","Array","pendingIndices","pendingPromises","v","s","partitionMaybePromiseAsync","startIndex","suffixLength","pending","resolved","partitionMaybePromise","safeTry","e","safeTryAsync"],"mappings":"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"}

package/build/types.cjs

@@ -82,10 +82,10 @@ function ResultErrorCtor(error) {
 }
 ResultErrorCtor.prototype[ERR_BRAND] = true;
 function isOk(result) {
-    return !result?.[ERR_BRAND];
+    return typeof result !== 'object' || result === null || !result[ERR_BRAND];
 }
 function isErr(result) {
-    return result?.[ERR_BRAND] === true;
+    return typeof result === 'object' && result !== null && result[ERR_BRAND] === true;
 }
 function okUnchecked(value) {
     return value;

package/build/types.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/types.ts"],"sourcesContent":["/** Values that represent None (absence of a value). */\nexport type NoneValueType = null | undefined | void;\n\n/** Widens literal types to their base types for better type inference. */\nexport type Widen<T> = T extends string\n  ? string\n  : T extends number\n    ? number\n    : T extends boolean\n      ? boolean\n      : T extends bigint\n        ? bigint\n        : T extends symbol\n          ? symbol\n          : T;\n\n/** Widens never to unknown, otherwise preserves the type. */\nexport type WidenNever<T> = [T] extends [never] ? unknown : T;\n\n/** Excludes None values from a type, leaving only valid Some values. */\nexport type ValueType<T> = Exclude<T, NoneValueType>;\n\nexport declare const SOME_BRAND: unique symbol;\n\n/** Represents a value that is present. The value itself is the Some - no wrapper object. */\nexport type Some<T> = ValueType<T> & { readonly [SOME_BRAND]: true };\n\n/** Represents the absence of a value (null or undefined). */\nexport type None = NoneValueType & { readonly [SOME_BRAND]: false };\n\n/** Constant representing None. Use this instead of null/undefined for clarity. */\nexport const NONE = undefined as None;\n\n/** Shared frozen empty array to avoid allocations. */\nexport const EMPTY: readonly unknown[] = Object.freeze([]);\n\n/** A value that may or may not be present. Some(T) is the value itself; None is null/undefined. */\nexport type Option<T> = Some<ValueType<T>> | None;\n\n/** Extracts the value type from an Option type. */\nexport type OptionValue<TOption> = TOption extends Option<infer TValue> ? TValue : never;\n\n/** Type predicate: true if T is an Option type. */\nexport type IsOption<T> = T extends Option<any> ? true : false;\n\n/** Infers the Some type from a value, preserving the inner type. */\nexport type InferSome<T> = T extends Some<infer TValue> ? Some<ValueType<TValue>> : never;\n\n/**\n * Checks if an Option contains a value (is Some).\n * @param opt - The Option to check\n * @returns true if the Option is Some, false if None\n * @example\n * isSome(42)        // true\n * isSome(null)      // false\n * isSome(undefined) // false\n */\nexport function isSome<T>(opt: Some<T>): true;\nexport function isSome(opt: None): false;\nexport function isSome<T>(opt: unknown): opt is Some<T>;\nexport function isSome(opt: unknown): boolean {\n  return opt !== null && opt !== undefined;\n}\n\n/**\n * Checks if an Option is None (absent).\n * @param opt - The Option to check\n * @returns true if the Option is None, false if Some\n * @example\n * isNone(null)      // true\n * isNone(undefined) // true\n * isNone(42)        // false\n */\nexport function isNone<T>(opt: Some<T>): false;\nexport function isNone(opt: None): true;\nexport function isNone(opt: unknown): opt is None;\nexport function isNone(opt: unknown): boolean {\n  return opt === null || opt === undefined;\n}\n\n/**\n * Creates an Option from a nullable value. Returns None for null/undefined, Some otherwise.\n * @param value - The value to wrap\n * @returns Some(value) if value is non-null, None otherwise\n * @example\n * optionOf(42)        // Some(42)\n * optionOf(null)      // None\n * optionOf(undefined) // None\n */\nexport function optionOf(value: null): None;\nexport function optionOf(value: undefined): None;\nexport function optionOf<T>(value: T): T extends NoneValueType ? None : Some<T>;\nexport function optionOf<T>(value: T): Option<T> {\n  return isNone(value as Option<T>) ? NONE : (value as Some<T>);\n}\n\nexport function someUnchecked<T>(value: T): Some<ValueType<T>> {\n  return value as Some<ValueType<T>>;\n}\n\n/**\n * Creates a Some value with runtime validation.\n * @param value - The value to wrap\n * @returns The value typed as Some\n * @throws TypeError if value is null or undefined\n * @example\n * some(42) // Some(42)\n */\nexport function some<T>(value: ValueType<T>): Some<ValueType<T>> {\n  if (value === null || value === undefined) {\n    throw new TypeError('some() requires a non-nullable value');\n  }\n  return someUnchecked(value);\n}\n\n/** Constant representing None. Alias for NONE. */\nexport const none: None = NONE;\n\ndeclare const OK_BRAND: unique symbol;\n\n/** Represents a successful Result value. The value itself is the Ok - no wrapper object. */\nexport type Ok<T> = T & { readonly [OK_BRAND]: true };\n\nconst ERR_BRAND = Symbol.for('nalloc.ResultError');\n\ninterface ResultErrorShape<E> {\n  readonly error: E;\n  readonly [ERR_BRAND]: true;\n}\n\nfunction ResultErrorCtor<E>(this: ResultErrorShape<E>, error: E): void {\n  (this as { error: E }).error = error;\n}\n(ResultErrorCtor.prototype as { [ERR_BRAND]: true })[ERR_BRAND] = true;\n\n/** The error wrapper type used internally. */\nexport type ResultError<E> = ResultErrorShape<E>;\n\n/** Represents a failed Result containing an error. */\nexport type Err<E> = ResultError<E>;\n\n/** A value that is either successful (Ok) or failed (Err). Ok is the value itself; Err wraps the error. */\nexport type Result<T, E> = Ok<T> | Err<E>;\n\n/** Extracts the success value type from a Result type. */\nexport type ResultValue<TResult> = TResult extends Result<infer TValue, any> ? TValue : never;\n\n/** Extracts the error type from a Result type. */\nexport type ResultErrorType<TResult> = TResult extends Result<any, infer TError> ? TError : never;\n\n/** Type predicate: true if T is a Result type. */\nexport type IsResult<T> = T extends Result<any, any> ? true : false;\n\n/** Infers the Err type from a value, preserving the error type. */\nexport type InferErr<T> = T extends Err<infer TError> ? Err<TError> : never;\n\n/**\n * Checks if a Result is Ok (successful).\n * @param result - The Result to check\n * @returns true if the Result is Ok, false if Err\n * @example\n * isOk(42)           // true (Ok value)\n * isOk(err('fail'))  // false\n */\nexport function isOk<T>(result: Ok<T>): true;\nexport function isOk<E>(result: Err<E>): false;\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T>;\nexport function isOk(result: unknown): boolean;\nexport function isOk(result: unknown): boolean {\n  return !(result as Record<symbol, unknown>)?.[ERR_BRAND];\n}\n\n/**\n * Checks if a Result is Err (failed).\n * @param result - The Result to check\n * @returns true if the Result is Err, false if Ok\n * @example\n * isErr(err('fail')) // true\n * isErr(42)          // false (Ok value)\n */\nexport function isErr<E>(result: Err<E>): true;\nexport function isErr(result: Ok<unknown>): false;\nexport function isErr<T, E>(result: Result<T, E>): result is Err<E>;\nexport function isErr(result: unknown): result is Err<unknown>;\nexport function isErr(result: unknown): boolean {\n  return (result as Record<symbol, unknown>)?.[ERR_BRAND] === true;\n}\n\nexport function okUnchecked<T>(value: T): Ok<T> {\n  return value as Ok<T>;\n}\n\n/**\n * Creates an Ok value with runtime validation.\n * @param value - The success value\n * @returns The value typed as Ok\n * @throws TypeError if value is an Err\n * @example\n * ok(42) // Ok(42)\n */\nexport function ok<T>(value: T): Ok<T> {\n  if (isErr(value)) {\n    throw new TypeError('ok() cannot wrap an Err value');\n  }\n  return okUnchecked(value);\n}\n\n/**\n * Creates an Err value wrapping an error.\n * @param error - The error value\n * @returns An Err containing the error\n * @example\n * err('something went wrong') // Err('something went wrong')\n * err(new Error('failed'))    // Err(Error)\n */\nexport function err<E>(error: E): Err<E> {\n  return new (ResultErrorCtor as unknown as new (error: E) => Err<E>)(error);\n}\n\n/** A value that may or may not be a Promise. */\nexport type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;\n\n/**\n * Checks if a value is a thenable (has a .then method).\n * @param value - The value to check\n * @returns true if value is a PromiseLike\n */\nexport function isThenable<T>(value: MaybePromise<T>): value is PromiseLike<T> {\n  return typeof (value as PromiseLike<T>)?.then === 'function';\n}\n\n/**\n * Checks if a value is synchronous (not a thenable).\n * @param value - The value to check\n * @returns true if value is not a PromiseLike\n */\nexport function isSync<T>(value: MaybePromise<T>): value is T {\n  return typeof (value as PromiseLike<T>)?.then !== 'function';\n}\n"],"names":["EMPTY","NONE","err","isErr","isNone","isOk","isSome","isSync","isThenable","none","ok","okUnchecked","optionOf","some","someUnchecked","undefined","Object","freeze","opt","value","TypeError","ERR_BRAND","Symbol","for","ResultErrorCtor","error","prototype","result","then"],"mappings":";;;;;;;;;;;QAkCaA;eAAAA;;QAHAC;eAAAA;;QAwLGC;eAAAA;;QA/BAC;eAAAA;;QA5GAC;eAAAA;;QA4FAC;eAAAA;;QA5GAC;eAAAA;;QAgLAC;eAAAA;;QATAC;eAAAA;;QA/GHC;eAAAA;;QAoFGC;eAAAA;;QAZAC;eAAAA;;QAhGAC;eAAAA;;QAgBAC;eAAAA;;QAZAC;eAAAA;;;AAjET,MAAMb,OAAOc;AAGb,MAAMf,QAA4BgB,OAAOC,MAAM,CAAC,EAAE;AA0BlD,SAASX,OAAOY,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQH;AACjC;AAcO,SAASX,OAAOc,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQH;AACjC;AAcO,SAASH,SAAYO,KAAQ;IAClC,OAAOf,OAAOe,SAAsBlB,OAAQkB;AAC9C;AAEO,SAASL,cAAiBK,KAAQ;IACvC,OAAOA;AACT;AAUO,SAASN,KAAQM,KAAmB;IACzC,IAAIA,UAAU,QAAQA,UAAUJ,WAAW;QACzC,MAAM,IAAIK,UAAU;IACtB;IACA,OAAON,cAAcK;AACvB;AAGO,MAAMV,OAAaR;AAO1B,MAAMoB,YAAYC,OAAOC,GAAG,CAAC;AAO7B,SAASC,gBAA8CC,KAAQ;IAC7D,AAAC,IAAI,CAAkBA,KAAK,GAAGA;AACjC;AACCD,gBAAgBE,SAAS,AAA0B,CAACL,UAAU,GAAG;AAmC3D,SAAShB,KAAKsB,MAAe;IAClC,OAAO,CAAEA,QAAoC,CAACN,UAAU;AAC1D;AAcO,SAASlB,MAAMwB,MAAe;IACnC,OAAO,AAACA,QAAoC,CAACN,UAAU,KAAK;AAC9D;AAEO,SAASV,YAAeQ,KAAQ;IACrC,OAAOA;AACT;AAUO,SAAST,GAAMS,KAAQ;IAC5B,IAAIhB,MAAMgB,QAAQ;QAChB,MAAM,IAAIC,UAAU;IACtB;IACA,OAAOT,YAAYQ;AACrB;AAUO,SAASjB,IAAOuB,KAAQ;IAC7B,OAAO,IAAKD,gBAAwDC;AACtE;AAUO,SAASjB,WAAcW,KAAsB;IAClD,OAAO,OAAQA,OAA0BS,SAAS;AACpD;AAOO,SAASrB,OAAUY,KAAsB;IAC9C,OAAO,OAAQA,OAA0BS,SAAS;AACpD"}
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["/** Values that represent None (absence of a value). */\nexport type NoneValueType = null | undefined | void;\n\n/** Widens literal types to their base types for better type inference. */\nexport type Widen<T> = T extends string\n  ? string\n  : T extends number\n    ? number\n    : T extends boolean\n      ? boolean\n      : T extends bigint\n        ? bigint\n        : T extends symbol\n          ? symbol\n          : T;\n\n/** Widens never to unknown, otherwise preserves the type. */\nexport type WidenNever<T> = [T] extends [never] ? unknown : T;\n\n/** Excludes None values from a type, leaving only valid Some values. */\nexport type ValueType<T> = Exclude<T, NoneValueType>;\n\nexport declare const SOME_BRAND: unique symbol;\n\n/** Represents a value that is present. The value itself is the Some - no wrapper object. */\nexport type Some<T> = ValueType<T> & { readonly [SOME_BRAND]: true };\n\n/** Represents the absence of a value (null or undefined). */\nexport type None = NoneValueType & { readonly [SOME_BRAND]: false };\n\n/** Constant representing None. Use this instead of null/undefined for clarity. */\nexport const NONE = undefined as None;\n\n/** Shared frozen empty array to avoid allocations. */\nexport const EMPTY: readonly unknown[] = Object.freeze([]);\n\n/** A value that may or may not be present. Some(T) is the value itself; None is null/undefined. */\nexport type Option<T> = Some<ValueType<T>> | None;\n\n/** Extracts the value type from an Option type. */\nexport type OptionValue<TOption> = TOption extends Option<infer TValue> ? TValue : never;\n\n/** Type predicate: true if T is an Option type. */\nexport type IsOption<T> = T extends Option<any> ? true : false;\n\n/** Infers the Some type from a value, preserving the inner type. */\nexport type InferSome<T> = T extends Some<infer TValue> ? Some<ValueType<TValue>> : never;\n\n/**\n * Checks if an Option contains a value (is Some).\n * @param opt - The Option to check\n * @returns true if the Option is Some, false if None\n * @example\n * isSome(42)        // true\n * isSome(null)      // false\n * isSome(undefined) // false\n */\nexport function isSome<T>(opt: Some<T>): true;\nexport function isSome(opt: None): false;\nexport function isSome<T>(opt: unknown): opt is Some<T>;\nexport function isSome(opt: unknown): boolean {\n  return opt !== null && opt !== undefined;\n}\n\n/**\n * Checks if an Option is None (absent).\n * @param opt - The Option to check\n * @returns true if the Option is None, false if Some\n * @example\n * isNone(null)      // true\n * isNone(undefined) // true\n * isNone(42)        // false\n */\nexport function isNone<T>(opt: Some<T>): false;\nexport function isNone(opt: None): true;\nexport function isNone(opt: unknown): opt is None;\nexport function isNone(opt: unknown): boolean {\n  return opt === null || opt === undefined;\n}\n\n/**\n * Creates an Option from a nullable value. Returns None for null/undefined, Some otherwise.\n * @param value - The value to wrap\n * @returns Some(value) if value is non-null, None otherwise\n * @example\n * optionOf(42)        // Some(42)\n * optionOf(null)      // None\n * optionOf(undefined) // None\n */\nexport function optionOf(value: null): None;\nexport function optionOf(value: undefined): None;\nexport function optionOf<T>(value: T): T extends NoneValueType ? None : Some<T>;\nexport function optionOf<T>(value: T): Option<T> {\n  return isNone(value as Option<T>) ? NONE : (value as Some<T>);\n}\n\nexport function someUnchecked<T>(value: T): Some<ValueType<T>> {\n  return value as Some<ValueType<T>>;\n}\n\n/**\n * Creates a Some value with runtime validation.\n * @param value - The value to wrap\n * @returns The value typed as Some\n * @throws TypeError if value is null or undefined\n * @example\n * some(42) // Some(42)\n */\nexport function some<T>(value: ValueType<T>): Some<ValueType<T>> {\n  if (value === null || value === undefined) {\n    throw new TypeError('some() requires a non-nullable value');\n  }\n  return someUnchecked(value);\n}\n\n/** Constant representing None. Alias for NONE. */\nexport const none: None = NONE;\n\ndeclare const OK_BRAND: unique symbol;\n\n/** Represents a successful Result value. The value itself is the Ok - no wrapper object. */\nexport type Ok<T> = T & { readonly [OK_BRAND]: true };\n\nconst ERR_BRAND = Symbol.for('nalloc.ResultError');\n\ninterface ResultErrorShape<E> {\n  readonly error: E;\n  readonly [ERR_BRAND]: true;\n}\n\nfunction ResultErrorCtor<E>(this: ResultErrorShape<E>, error: E): void {\n  (this as { error: E }).error = error;\n}\n(ResultErrorCtor.prototype as { [ERR_BRAND]: true })[ERR_BRAND] = true;\n\n/** The error wrapper type used internally. */\nexport type ResultError<E> = ResultErrorShape<E>;\n\n/** Represents a failed Result containing an error. */\nexport type Err<E> = ResultError<E>;\n\n/** A value that is either successful (Ok) or failed (Err). Ok is the value itself; Err wraps the error. */\nexport type Result<T, E> = Ok<T> | Err<E>;\n\n/** Extracts the success value type from a Result type. */\nexport type ResultValue<TResult> = TResult extends Result<infer TValue, any> ? TValue : never;\n\n/** Extracts the error type from a Result type. */\nexport type ResultErrorType<TResult> = TResult extends Result<any, infer TError> ? TError : never;\n\n/** Type predicate: true if T is a Result type. */\nexport type IsResult<T> = T extends Result<any, any> ? true : false;\n\n/** Infers the Err type from a value, preserving the error type. */\nexport type InferErr<T> = T extends Err<infer TError> ? Err<TError> : never;\n\n/**\n * Checks if a Result is Ok (successful).\n * @param result - The Result to check\n * @returns true if the Result is Ok, false if Err\n * @example\n * isOk(42)           // true (Ok value)\n * isOk(err('fail'))  // false\n */\nexport function isOk<T>(result: Ok<T>): true;\nexport function isOk<E>(result: Err<E>): false;\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T>;\nexport function isOk(result: unknown): boolean;\nexport function isOk(result: unknown): boolean {\n  return typeof result !== 'object' || result === null || !(result as Record<symbol, boolean>)[ERR_BRAND];\n}\n\n/**\n * Checks if a Result is Err (failed).\n * @param result - The Result to check\n * @returns true if the Result is Err, false if Ok\n * @example\n * isErr(err('fail')) // true\n * isErr(42)          // false (Ok value)\n */\nexport function isErr<E>(result: Err<E>): true;\nexport function isErr(result: Ok<unknown>): false;\nexport function isErr<T, E>(result: Result<T, E>): result is Err<E>;\nexport function isErr(result: unknown): result is Err<unknown>;\nexport function isErr(result: unknown): boolean {\n  return typeof result === 'object' && result !== null && (result as Record<symbol, boolean>)[ERR_BRAND] === true;\n}\n\nexport function okUnchecked<T>(value: T): Ok<T> {\n  return value as Ok<T>;\n}\n\n/**\n * Creates an Ok value with runtime validation.\n * @param value - The success value\n * @returns The value typed as Ok\n * @throws TypeError if value is an Err\n * @example\n * ok(42) // Ok(42)\n */\nexport function ok<T>(value: T): Ok<T> {\n  if (isErr(value)) {\n    throw new TypeError('ok() cannot wrap an Err value');\n  }\n  return okUnchecked(value);\n}\n\n/**\n * Creates an Err value wrapping an error.\n * @param error - The error value\n * @returns An Err containing the error\n * @example\n * err('something went wrong') // Err('something went wrong')\n * err(new Error('failed'))    // Err(Error)\n */\nexport function err<E>(error: E): Err<E> {\n  return new (ResultErrorCtor as unknown as new (error: E) => Err<E>)(error);\n}\n\n/** A value that may or may not be a Promise. */\nexport type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;\n\n/**\n * Checks if a value is a thenable (has a .then method).\n * @param value - The value to check\n * @returns true if value is a PromiseLike\n */\nexport function isThenable<T>(value: MaybePromise<T>): value is PromiseLike<T> {\n  return typeof (value as PromiseLike<T>)?.then === 'function';\n}\n\n/**\n * Checks if a value is synchronous (not a thenable).\n * @param value - The value to check\n * @returns true if value is not a PromiseLike\n */\nexport function isSync<T>(value: MaybePromise<T>): value is T {\n  return typeof (value as PromiseLike<T>)?.then !== 'function';\n}\n"],"names":["EMPTY","NONE","err","isErr","isNone","isOk","isSome","isSync","isThenable","none","ok","okUnchecked","optionOf","some","someUnchecked","undefined","Object","freeze","opt","value","TypeError","ERR_BRAND","Symbol","for","ResultErrorCtor","error","prototype","result","then"],"mappings":";;;;;;;;;;;QAkCaA;eAAAA;;QAHAC;eAAAA;;QAwLGC;eAAAA;;QA/BAC;eAAAA;;QA5GAC;eAAAA;;QA4FAC;eAAAA;;QA5GAC;eAAAA;;QAgLAC;eAAAA;;QATAC;eAAAA;;QA/GHC;eAAAA;;QAoFGC;eAAAA;;QAZAC;eAAAA;;QAhGAC;eAAAA;;QAgBAC;eAAAA;;QAZAC;eAAAA;;;AAjET,MAAMb,OAAOc;AAGb,MAAMf,QAA4BgB,OAAOC,MAAM,CAAC,EAAE;AA0BlD,SAASX,OAAOY,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQH;AACjC;AAcO,SAASX,OAAOc,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQH;AACjC;AAcO,SAASH,SAAYO,KAAQ;IAClC,OAAOf,OAAOe,SAAsBlB,OAAQkB;AAC9C;AAEO,SAASL,cAAiBK,KAAQ;IACvC,OAAOA;AACT;AAUO,SAASN,KAAQM,KAAmB;IACzC,IAAIA,UAAU,QAAQA,UAAUJ,WAAW;QACzC,MAAM,IAAIK,UAAU;IACtB;IACA,OAAON,cAAcK;AACvB;AAGO,MAAMV,OAAaR;AAO1B,MAAMoB,YAAYC,OAAOC,GAAG,CAAC;AAO7B,SAASC,gBAA8CC,KAAQ;IAC7D,AAAC,IAAI,CAAkBA,KAAK,GAAGA;AACjC;AACCD,gBAAgBE,SAAS,AAA0B,CAACL,UAAU,GAAG;AAmC3D,SAAShB,KAAKsB,MAAe;IAClC,OAAO,OAAOA,WAAW,YAAYA,WAAW,QAAQ,CAAC,AAACA,MAAkC,CAACN,UAAU;AACzG;AAcO,SAASlB,MAAMwB,MAAe;IACnC,OAAO,OAAOA,WAAW,YAAYA,WAAW,QAAQ,AAACA,MAAkC,CAACN,UAAU,KAAK;AAC7G;AAEO,SAASV,YAAeQ,KAAQ;IACrC,OAAOA;AACT;AAUO,SAAST,GAAMS,KAAQ;IAC5B,IAAIhB,MAAMgB,QAAQ;QAChB,MAAM,IAAIC,UAAU;IACtB;IACA,OAAOT,YAAYQ;AACrB;AAUO,SAASjB,IAAOuB,KAAQ;IAC7B,OAAO,IAAKD,gBAAwDC;AACtE;AAUO,SAASjB,WAAcW,KAAsB;IAClD,OAAO,OAAQA,OAA0BS,SAAS;AACpD;AAOO,SAASrB,OAAUY,KAAsB;IAC9C,OAAO,OAAQA,OAA0BS,SAAS;AACpD"}

package/build/types.js

@@ -25,10 +25,10 @@ function ResultErrorCtor(error) {
 }
 ResultErrorCtor.prototype[ERR_BRAND] = true;
 export function isOk(result) {
-    return !result?.[ERR_BRAND];
+    return typeof result !== 'object' || result === null || !result[ERR_BRAND];
 }
 export function isErr(result) {
-    return result?.[ERR_BRAND] === true;
+    return typeof result === 'object' && result !== null && result[ERR_BRAND] === true;
 }
 export function okUnchecked(value) {
     return value;

package/build/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/types.ts"],"sourcesContent":["/** Values that represent None (absence of a value). */\nexport type NoneValueType = null | undefined | void;\n\n/** Widens literal types to their base types for better type inference. */\nexport type Widen<T> = T extends string\n  ? string\n  : T extends number\n    ? number\n    : T extends boolean\n      ? boolean\n      : T extends bigint\n        ? bigint\n        : T extends symbol\n          ? symbol\n          : T;\n\n/** Widens never to unknown, otherwise preserves the type. */\nexport type WidenNever<T> = [T] extends [never] ? unknown : T;\n\n/** Excludes None values from a type, leaving only valid Some values. */\nexport type ValueType<T> = Exclude<T, NoneValueType>;\n\nexport declare const SOME_BRAND: unique symbol;\n\n/** Represents a value that is present. The value itself is the Some - no wrapper object. */\nexport type Some<T> = ValueType<T> & { readonly [SOME_BRAND]: true };\n\n/** Represents the absence of a value (null or undefined). */\nexport type None = NoneValueType & { readonly [SOME_BRAND]: false };\n\n/** Constant representing None. Use this instead of null/undefined for clarity. */\nexport const NONE = undefined as None;\n\n/** Shared frozen empty array to avoid allocations. */\nexport const EMPTY: readonly unknown[] = Object.freeze([]);\n\n/** A value that may or may not be present. Some(T) is the value itself; None is null/undefined. */\nexport type Option<T> = Some<ValueType<T>> | None;\n\n/** Extracts the value type from an Option type. */\nexport type OptionValue<TOption> = TOption extends Option<infer TValue> ? TValue : never;\n\n/** Type predicate: true if T is an Option type. */\nexport type IsOption<T> = T extends Option<any> ? true : false;\n\n/** Infers the Some type from a value, preserving the inner type. */\nexport type InferSome<T> = T extends Some<infer TValue> ? Some<ValueType<TValue>> : never;\n\n/**\n * Checks if an Option contains a value (is Some).\n * @param opt - The Option to check\n * @returns true if the Option is Some, false if None\n * @example\n * isSome(42)        // true\n * isSome(null)      // false\n * isSome(undefined) // false\n */\nexport function isSome<T>(opt: Some<T>): true;\nexport function isSome(opt: None): false;\nexport function isSome<T>(opt: unknown): opt is Some<T>;\nexport function isSome(opt: unknown): boolean {\n  return opt !== null && opt !== undefined;\n}\n\n/**\n * Checks if an Option is None (absent).\n * @param opt - The Option to check\n * @returns true if the Option is None, false if Some\n * @example\n * isNone(null)      // true\n * isNone(undefined) // true\n * isNone(42)        // false\n */\nexport function isNone<T>(opt: Some<T>): false;\nexport function isNone(opt: None): true;\nexport function isNone(opt: unknown): opt is None;\nexport function isNone(opt: unknown): boolean {\n  return opt === null || opt === undefined;\n}\n\n/**\n * Creates an Option from a nullable value. Returns None for null/undefined, Some otherwise.\n * @param value - The value to wrap\n * @returns Some(value) if value is non-null, None otherwise\n * @example\n * optionOf(42)        // Some(42)\n * optionOf(null)      // None\n * optionOf(undefined) // None\n */\nexport function optionOf(value: null): None;\nexport function optionOf(value: undefined): None;\nexport function optionOf<T>(value: T): T extends NoneValueType ? None : Some<T>;\nexport function optionOf<T>(value: T): Option<T> {\n  return isNone(value as Option<T>) ? NONE : (value as Some<T>);\n}\n\nexport function someUnchecked<T>(value: T): Some<ValueType<T>> {\n  return value as Some<ValueType<T>>;\n}\n\n/**\n * Creates a Some value with runtime validation.\n * @param value - The value to wrap\n * @returns The value typed as Some\n * @throws TypeError if value is null or undefined\n * @example\n * some(42) // Some(42)\n */\nexport function some<T>(value: ValueType<T>): Some<ValueType<T>> {\n  if (value === null || value === undefined) {\n    throw new TypeError('some() requires a non-nullable value');\n  }\n  return someUnchecked(value);\n}\n\n/** Constant representing None. Alias for NONE. */\nexport const none: None = NONE;\n\ndeclare const OK_BRAND: unique symbol;\n\n/** Represents a successful Result value. The value itself is the Ok - no wrapper object. */\nexport type Ok<T> = T & { readonly [OK_BRAND]: true };\n\nconst ERR_BRAND = Symbol.for('nalloc.ResultError');\n\ninterface ResultErrorShape<E> {\n  readonly error: E;\n  readonly [ERR_BRAND]: true;\n}\n\nfunction ResultErrorCtor<E>(this: ResultErrorShape<E>, error: E): void {\n  (this as { error: E }).error = error;\n}\n(ResultErrorCtor.prototype as { [ERR_BRAND]: true })[ERR_BRAND] = true;\n\n/** The error wrapper type used internally. */\nexport type ResultError<E> = ResultErrorShape<E>;\n\n/** Represents a failed Result containing an error. */\nexport type Err<E> = ResultError<E>;\n\n/** A value that is either successful (Ok) or failed (Err). Ok is the value itself; Err wraps the error. */\nexport type Result<T, E> = Ok<T> | Err<E>;\n\n/** Extracts the success value type from a Result type. */\nexport type ResultValue<TResult> = TResult extends Result<infer TValue, any> ? TValue : never;\n\n/** Extracts the error type from a Result type. */\nexport type ResultErrorType<TResult> = TResult extends Result<any, infer TError> ? TError : never;\n\n/** Type predicate: true if T is a Result type. */\nexport type IsResult<T> = T extends Result<any, any> ? true : false;\n\n/** Infers the Err type from a value, preserving the error type. */\nexport type InferErr<T> = T extends Err<infer TError> ? Err<TError> : never;\n\n/**\n * Checks if a Result is Ok (successful).\n * @param result - The Result to check\n * @returns true if the Result is Ok, false if Err\n * @example\n * isOk(42)           // true (Ok value)\n * isOk(err('fail'))  // false\n */\nexport function isOk<T>(result: Ok<T>): true;\nexport function isOk<E>(result: Err<E>): false;\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T>;\nexport function isOk(result: unknown): boolean;\nexport function isOk(result: unknown): boolean {\n  return !(result as Record<symbol, unknown>)?.[ERR_BRAND];\n}\n\n/**\n * Checks if a Result is Err (failed).\n * @param result - The Result to check\n * @returns true if the Result is Err, false if Ok\n * @example\n * isErr(err('fail')) // true\n * isErr(42)          // false (Ok value)\n */\nexport function isErr<E>(result: Err<E>): true;\nexport function isErr(result: Ok<unknown>): false;\nexport function isErr<T, E>(result: Result<T, E>): result is Err<E>;\nexport function isErr(result: unknown): result is Err<unknown>;\nexport function isErr(result: unknown): boolean {\n  return (result as Record<symbol, unknown>)?.[ERR_BRAND] === true;\n}\n\nexport function okUnchecked<T>(value: T): Ok<T> {\n  return value as Ok<T>;\n}\n\n/**\n * Creates an Ok value with runtime validation.\n * @param value - The success value\n * @returns The value typed as Ok\n * @throws TypeError if value is an Err\n * @example\n * ok(42) // Ok(42)\n */\nexport function ok<T>(value: T): Ok<T> {\n  if (isErr(value)) {\n    throw new TypeError('ok() cannot wrap an Err value');\n  }\n  return okUnchecked(value);\n}\n\n/**\n * Creates an Err value wrapping an error.\n * @param error - The error value\n * @returns An Err containing the error\n * @example\n * err('something went wrong') // Err('something went wrong')\n * err(new Error('failed'))    // Err(Error)\n */\nexport function err<E>(error: E): Err<E> {\n  return new (ResultErrorCtor as unknown as new (error: E) => Err<E>)(error);\n}\n\n/** A value that may or may not be a Promise. */\nexport type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;\n\n/**\n * Checks if a value is a thenable (has a .then method).\n * @param value - The value to check\n * @returns true if value is a PromiseLike\n */\nexport function isThenable<T>(value: MaybePromise<T>): value is PromiseLike<T> {\n  return typeof (value as PromiseLike<T>)?.then === 'function';\n}\n\n/**\n * Checks if a value is synchronous (not a thenable).\n * @param value - The value to check\n * @returns true if value is not a PromiseLike\n */\nexport function isSync<T>(value: MaybePromise<T>): value is T {\n  return typeof (value as PromiseLike<T>)?.then !== 'function';\n}\n"],"names":["NONE","undefined","EMPTY","Object","freeze","isSome","opt","isNone","optionOf","value","someUnchecked","some","TypeError","none","ERR_BRAND","Symbol","for","ResultErrorCtor","error","prototype","isOk","result","isErr","okUnchecked","ok","err","isThenable","then","isSync"],"mappings":"AA+BA,OAAO,MAAMA,OAAOC,UAAkB;AAGtC,OAAO,MAAMC,QAA4BC,OAAOC,MAAM,CAAC,EAAE,EAAE;AA0B3D,OAAO,SAASC,OAAOC,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQL;AACjC;AAcA,OAAO,SAASM,OAAOD,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQL;AACjC;AAcA,OAAO,SAASO,SAAYC,KAAQ;IAClC,OAAOF,OAAOE,SAAsBT,OAAQS;AAC9C;AAEA,OAAO,SAASC,cAAiBD,KAAQ;IACvC,OAAOA;AACT;AAUA,OAAO,SAASE,KAAQF,KAAmB;IACzC,IAAIA,UAAU,QAAQA,UAAUR,WAAW;QACzC,MAAM,IAAIW,UAAU;IACtB;IACA,OAAOF,cAAcD;AACvB;AAGA,OAAO,MAAMI,OAAab,KAAK;AAO/B,MAAMc,YAAYC,OAAOC,GAAG,CAAC;AAO7B,SAASC,gBAA8CC,KAAQ;IAC7D,AAAC,IAAI,CAAkBA,KAAK,GAAGA;AACjC;AACCD,gBAAgBE,SAAS,AAA0B,CAACL,UAAU,GAAG;AAmClE,OAAO,SAASM,KAAKC,MAAe;IAClC,OAAO,CAAEA,QAAoC,CAACP,UAAU;AAC1D;AAcA,OAAO,SAASQ,MAAMD,MAAe;IACnC,OAAO,AAACA,QAAoC,CAACP,UAAU,KAAK;AAC9D;AAEA,OAAO,SAASS,YAAed,KAAQ;IACrC,OAAOA;AACT;AAUA,OAAO,SAASe,GAAMf,KAAQ;IAC5B,IAAIa,MAAMb,QAAQ;QAChB,MAAM,IAAIG,UAAU;IACtB;IACA,OAAOW,YAAYd;AACrB;AAUA,OAAO,SAASgB,IAAOP,KAAQ;IAC7B,OAAO,IAAKD,gBAAwDC;AACtE;AAUA,OAAO,SAASQ,WAAcjB,KAAsB;IAClD,OAAO,OAAQA,OAA0BkB,SAAS;AACpD;AAOA,OAAO,SAASC,OAAUnB,KAAsB;IAC9C,OAAO,OAAQA,OAA0BkB,SAAS;AACpD"}
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["/** Values that represent None (absence of a value). */\nexport type NoneValueType = null | undefined | void;\n\n/** Widens literal types to their base types for better type inference. */\nexport type Widen<T> = T extends string\n  ? string\n  : T extends number\n    ? number\n    : T extends boolean\n      ? boolean\n      : T extends bigint\n        ? bigint\n        : T extends symbol\n          ? symbol\n          : T;\n\n/** Widens never to unknown, otherwise preserves the type. */\nexport type WidenNever<T> = [T] extends [never] ? unknown : T;\n\n/** Excludes None values from a type, leaving only valid Some values. */\nexport type ValueType<T> = Exclude<T, NoneValueType>;\n\nexport declare const SOME_BRAND: unique symbol;\n\n/** Represents a value that is present. The value itself is the Some - no wrapper object. */\nexport type Some<T> = ValueType<T> & { readonly [SOME_BRAND]: true };\n\n/** Represents the absence of a value (null or undefined). */\nexport type None = NoneValueType & { readonly [SOME_BRAND]: false };\n\n/** Constant representing None. Use this instead of null/undefined for clarity. */\nexport const NONE = undefined as None;\n\n/** Shared frozen empty array to avoid allocations. */\nexport const EMPTY: readonly unknown[] = Object.freeze([]);\n\n/** A value that may or may not be present. Some(T) is the value itself; None is null/undefined. */\nexport type Option<T> = Some<ValueType<T>> | None;\n\n/** Extracts the value type from an Option type. */\nexport type OptionValue<TOption> = TOption extends Option<infer TValue> ? TValue : never;\n\n/** Type predicate: true if T is an Option type. */\nexport type IsOption<T> = T extends Option<any> ? true : false;\n\n/** Infers the Some type from a value, preserving the inner type. */\nexport type InferSome<T> = T extends Some<infer TValue> ? Some<ValueType<TValue>> : never;\n\n/**\n * Checks if an Option contains a value (is Some).\n * @param opt - The Option to check\n * @returns true if the Option is Some, false if None\n * @example\n * isSome(42)        // true\n * isSome(null)      // false\n * isSome(undefined) // false\n */\nexport function isSome<T>(opt: Some<T>): true;\nexport function isSome(opt: None): false;\nexport function isSome<T>(opt: unknown): opt is Some<T>;\nexport function isSome(opt: unknown): boolean {\n  return opt !== null && opt !== undefined;\n}\n\n/**\n * Checks if an Option is None (absent).\n * @param opt - The Option to check\n * @returns true if the Option is None, false if Some\n * @example\n * isNone(null)      // true\n * isNone(undefined) // true\n * isNone(42)        // false\n */\nexport function isNone<T>(opt: Some<T>): false;\nexport function isNone(opt: None): true;\nexport function isNone(opt: unknown): opt is None;\nexport function isNone(opt: unknown): boolean {\n  return opt === null || opt === undefined;\n}\n\n/**\n * Creates an Option from a nullable value. Returns None for null/undefined, Some otherwise.\n * @param value - The value to wrap\n * @returns Some(value) if value is non-null, None otherwise\n * @example\n * optionOf(42)        // Some(42)\n * optionOf(null)      // None\n * optionOf(undefined) // None\n */\nexport function optionOf(value: null): None;\nexport function optionOf(value: undefined): None;\nexport function optionOf<T>(value: T): T extends NoneValueType ? None : Some<T>;\nexport function optionOf<T>(value: T): Option<T> {\n  return isNone(value as Option<T>) ? NONE : (value as Some<T>);\n}\n\nexport function someUnchecked<T>(value: T): Some<ValueType<T>> {\n  return value as Some<ValueType<T>>;\n}\n\n/**\n * Creates a Some value with runtime validation.\n * @param value - The value to wrap\n * @returns The value typed as Some\n * @throws TypeError if value is null or undefined\n * @example\n * some(42) // Some(42)\n */\nexport function some<T>(value: ValueType<T>): Some<ValueType<T>> {\n  if (value === null || value === undefined) {\n    throw new TypeError('some() requires a non-nullable value');\n  }\n  return someUnchecked(value);\n}\n\n/** Constant representing None. Alias for NONE. */\nexport const none: None = NONE;\n\ndeclare const OK_BRAND: unique symbol;\n\n/** Represents a successful Result value. The value itself is the Ok - no wrapper object. */\nexport type Ok<T> = T & { readonly [OK_BRAND]: true };\n\nconst ERR_BRAND = Symbol.for('nalloc.ResultError');\n\ninterface ResultErrorShape<E> {\n  readonly error: E;\n  readonly [ERR_BRAND]: true;\n}\n\nfunction ResultErrorCtor<E>(this: ResultErrorShape<E>, error: E): void {\n  (this as { error: E }).error = error;\n}\n(ResultErrorCtor.prototype as { [ERR_BRAND]: true })[ERR_BRAND] = true;\n\n/** The error wrapper type used internally. */\nexport type ResultError<E> = ResultErrorShape<E>;\n\n/** Represents a failed Result containing an error. */\nexport type Err<E> = ResultError<E>;\n\n/** A value that is either successful (Ok) or failed (Err). Ok is the value itself; Err wraps the error. */\nexport type Result<T, E> = Ok<T> | Err<E>;\n\n/** Extracts the success value type from a Result type. */\nexport type ResultValue<TResult> = TResult extends Result<infer TValue, any> ? TValue : never;\n\n/** Extracts the error type from a Result type. */\nexport type ResultErrorType<TResult> = TResult extends Result<any, infer TError> ? TError : never;\n\n/** Type predicate: true if T is a Result type. */\nexport type IsResult<T> = T extends Result<any, any> ? true : false;\n\n/** Infers the Err type from a value, preserving the error type. */\nexport type InferErr<T> = T extends Err<infer TError> ? Err<TError> : never;\n\n/**\n * Checks if a Result is Ok (successful).\n * @param result - The Result to check\n * @returns true if the Result is Ok, false if Err\n * @example\n * isOk(42)           // true (Ok value)\n * isOk(err('fail'))  // false\n */\nexport function isOk<T>(result: Ok<T>): true;\nexport function isOk<E>(result: Err<E>): false;\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T>;\nexport function isOk(result: unknown): boolean;\nexport function isOk(result: unknown): boolean {\n  return typeof result !== 'object' || result === null || !(result as Record<symbol, boolean>)[ERR_BRAND];\n}\n\n/**\n * Checks if a Result is Err (failed).\n * @param result - The Result to check\n * @returns true if the Result is Err, false if Ok\n * @example\n * isErr(err('fail')) // true\n * isErr(42)          // false (Ok value)\n */\nexport function isErr<E>(result: Err<E>): true;\nexport function isErr(result: Ok<unknown>): false;\nexport function isErr<T, E>(result: Result<T, E>): result is Err<E>;\nexport function isErr(result: unknown): result is Err<unknown>;\nexport function isErr(result: unknown): boolean {\n  return typeof result === 'object' && result !== null && (result as Record<symbol, boolean>)[ERR_BRAND] === true;\n}\n\nexport function okUnchecked<T>(value: T): Ok<T> {\n  return value as Ok<T>;\n}\n\n/**\n * Creates an Ok value with runtime validation.\n * @param value - The success value\n * @returns The value typed as Ok\n * @throws TypeError if value is an Err\n * @example\n * ok(42) // Ok(42)\n */\nexport function ok<T>(value: T): Ok<T> {\n  if (isErr(value)) {\n    throw new TypeError('ok() cannot wrap an Err value');\n  }\n  return okUnchecked(value);\n}\n\n/**\n * Creates an Err value wrapping an error.\n * @param error - The error value\n * @returns An Err containing the error\n * @example\n * err('something went wrong') // Err('something went wrong')\n * err(new Error('failed'))    // Err(Error)\n */\nexport function err<E>(error: E): Err<E> {\n  return new (ResultErrorCtor as unknown as new (error: E) => Err<E>)(error);\n}\n\n/** A value that may or may not be a Promise. */\nexport type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;\n\n/**\n * Checks if a value is a thenable (has a .then method).\n * @param value - The value to check\n * @returns true if value is a PromiseLike\n */\nexport function isThenable<T>(value: MaybePromise<T>): value is PromiseLike<T> {\n  return typeof (value as PromiseLike<T>)?.then === 'function';\n}\n\n/**\n * Checks if a value is synchronous (not a thenable).\n * @param value - The value to check\n * @returns true if value is not a PromiseLike\n */\nexport function isSync<T>(value: MaybePromise<T>): value is T {\n  return typeof (value as PromiseLike<T>)?.then !== 'function';\n}\n"],"names":["NONE","undefined","EMPTY","Object","freeze","isSome","opt","isNone","optionOf","value","someUnchecked","some","TypeError","none","ERR_BRAND","Symbol","for","ResultErrorCtor","error","prototype","isOk","result","isErr","okUnchecked","ok","err","isThenable","then","isSync"],"mappings":"AA+BA,OAAO,MAAMA,OAAOC,UAAkB;AAGtC,OAAO,MAAMC,QAA4BC,OAAOC,MAAM,CAAC,EAAE,EAAE;AA0B3D,OAAO,SAASC,OAAOC,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQL;AACjC;AAcA,OAAO,SAASM,OAAOD,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQL;AACjC;AAcA,OAAO,SAASO,SAAYC,KAAQ;IAClC,OAAOF,OAAOE,SAAsBT,OAAQS;AAC9C;AAEA,OAAO,SAASC,cAAiBD,KAAQ;IACvC,OAAOA;AACT;AAUA,OAAO,SAASE,KAAQF,KAAmB;IACzC,IAAIA,UAAU,QAAQA,UAAUR,WAAW;QACzC,MAAM,IAAIW,UAAU;IACtB;IACA,OAAOF,cAAcD;AACvB;AAGA,OAAO,MAAMI,OAAab,KAAK;AAO/B,MAAMc,YAAYC,OAAOC,GAAG,CAAC;AAO7B,SAASC,gBAA8CC,KAAQ;IAC7D,AAAC,IAAI,CAAkBA,KAAK,GAAGA;AACjC;AACCD,gBAAgBE,SAAS,AAA0B,CAACL,UAAU,GAAG;AAmClE,OAAO,SAASM,KAAKC,MAAe;IAClC,OAAO,OAAOA,WAAW,YAAYA,WAAW,QAAQ,CAAC,AAACA,MAAkC,CAACP,UAAU;AACzG;AAcA,OAAO,SAASQ,MAAMD,MAAe;IACnC,OAAO,OAAOA,WAAW,YAAYA,WAAW,QAAQ,AAACA,MAAkC,CAACP,UAAU,KAAK;AAC7G;AAEA,OAAO,SAASS,YAAed,KAAQ;IACrC,OAAOA;AACT;AAUA,OAAO,SAASe,GAAMf,KAAQ;IAC5B,IAAIa,MAAMb,QAAQ;QAChB,MAAM,IAAIG,UAAU;IACtB;IACA,OAAOW,YAAYd;AACrB;AAUA,OAAO,SAASgB,IAAOP,KAAQ;IAC7B,OAAO,IAAKD,gBAAwDC;AACtE;AAUA,OAAO,SAASQ,WAAcjB,KAAsB;IAClD,OAAO,OAAQA,OAA0BkB,SAAS;AACpD;AAOA,OAAO,SAASC,OAAUnB,KAAsB;IAC9C,OAAO,OAAQA,OAA0BkB,SAAS;AACpD"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nalloc",
   "description": "Rust-like Option and Result for TypeScript with near-zero allocations for extreme performance",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "type": "module",
   "types": "build/index.d.ts",
   "main": "build/index.cjs",

package/src/__tests__/result.ts

@@ -45,7 +45,8 @@ import {
   filterOk,
   filterErr,
   safeTry,
-  safeTryAsync
+  safeTryAsync,
+  fromPromise
 } from '../result.js';
 import { ok, err, isOk, isErr, optionOf as optOf, none } from '../types.js';
 
@@ -913,4 +914,39 @@ describe('Result', () => {
     });
   });
 
+  describe('fromPromise', () => {
+    it('returns Ok for resolved promise', async () => {
+      const result = await fromPromise(Promise.resolve(42));
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(42);
+    });
+
+    it('returns Err for rejected promise', async () => {
+      const result = await fromPromise(Promise.reject(new Error('boom')));
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: Error }).error.message).toBe('boom');
+    });
+
+    it('uses onError mapper for rejected promise', async () => {
+      const result = await fromPromise(
+        Promise.reject(new Error('boom')),
+        (e) => `mapped: ${(e as Error).message}`,
+      );
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: string }).error).toBe('mapped: boom');
+    });
+
+    it('handles Ok(null) as valid success', async () => {
+      const result = await fromPromise(Promise.resolve(null));
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(null);
+    });
+
+    it('returns Err with unknown type when no onError provided', async () => {
+      const result = await fromPromise(Promise.reject('string error'));
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: string }).error).toBe('string error');
+    });
+  });
+
 });

package/src/option.ts

@@ -312,8 +312,9 @@ export function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T> {
  * xor(none, none)       // None
  */
 export function xor<T>(opt: Option<T>, optb: Option<T>): Option<T> {
-  if (isSome(opt) && isNone(optb)) return opt;
-  if (isNone(opt) && isSome(optb)) return optb;
+  const a = isSome(opt);
+  const b = isSome(optb);
+  if (a !== b) return a ? opt : optb;
   return NONE;
 }
 

package/src/result.ts

@@ -33,6 +33,25 @@ export function of<T>(fn: () => T): Result<T, unknown> {
   return tryCatch(fn);
 }
 
+/**
+ * Converts a Promise to a Result. Resolves to Ok if successful, Err on rejection.
+ * @param promise - The promise to convert
+ * @param onError - Optional error transformer
+ * @returns Promise resolving to Ok(value) or Err(error)
+ * @example
+ * await fromPromise(fetch('/api'))              // Ok(Response) or Err(unknown)
+ * await fromPromise(fetch('/api'), e => String(e)) // Ok(Response) or Err(string)
+ */
+export async function fromPromise<T>(promise: Promise<T>): Promise<Result<T, unknown>>;
+export async function fromPromise<T, E>(promise: Promise<T>, onError: (error: unknown) => E): Promise<Result<T, E>>;
+export async function fromPromise<T, E = unknown>(promise: Promise<T>, onError?: (error: unknown) => E): Promise<Result<T, E>> {
+  try {
+    return (await promise) as Ok<T>;
+  } catch (error) {
+    return ERR(onError ? onError(error) : (error as E));
+  }
+}
+
 /**
  * Executes a function that may return sync or async, preserving sync execution when possible.
  * @param fn - Function that may return T or Promise<T>
@@ -551,7 +570,15 @@ export function collect<T, E>(results: Result<T, E>[]): Result<T[], E> {
  * collectAll([ok(1), err('a'), err('b')]) // Err(['a', 'b'])
  */
 export function collectAll<T, E>(results: Result<T, E>[]): Result<T[], E[]> {
-  const [oks, errs] = partition(results);
+  const oks: T[] = [];
+  const errs: E[] = [];
+  for (const result of results) {
+    if (isOk(result)) {
+      oks.push(result);
+    } else {
+      errs.push(result.error);
+    }
+  }
   return errs.length > 0 ? ERR(errs) : (oks as Ok<T[]>);
 }
 

package/src/types.ts

@@ -167,7 +167,7 @@ export function isOk<E>(result: Err<E>): false;
 export function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
 export function isOk(result: unknown): boolean;
 export function isOk(result: unknown): boolean {
-  return !(result as Record<symbol, unknown>)?.[ERR_BRAND];
+  return typeof result !== 'object' || result === null || !(result as Record<symbol, boolean>)[ERR_BRAND];
 }
 
 /**
@@ -183,7 +183,7 @@ export function isErr(result: Ok<unknown>): false;
 export function isErr<T, E>(result: Result<T, E>): result is Err<E>;
 export function isErr(result: unknown): result is Err<unknown>;
 export function isErr(result: unknown): boolean {
-  return (result as Record<symbol, unknown>)?.[ERR_BRAND] === true;
+  return typeof result === 'object' && result !== null && (result as Record<symbol, boolean>)[ERR_BRAND] === true;
 }
 
 export function okUnchecked<T>(value: T): Ok<T> {