nalloc 0.0.1

package/build/option.js

@@ -0,0 +1,157 @@
+import { NONE, isSome, isNone, optionOf as of, err, isOk, isErr } from "./types.js";
+export { isSome, isNone, of };
+export function fromNullable(value) {
+    return of(value);
+}
+export async function fromPromise(promise, onRejected) {
+    try {
+        const value = await promise;
+        return of(value);
+    } catch (error) {
+        if (!onRejected) {
+            return NONE;
+        }
+        return of(onRejected(error));
+    }
+}
+export function unwrapOrReturn(opt, onNone) {
+    return isSome(opt) ? opt : onNone();
+}
+export function assertSome(opt, message) {
+    if (isNone(opt)) {
+        throw new Error(message ?? 'Expected Option to contain a value');
+    }
+}
+export function satisfiesOption(_) {}
+export function filterMap(values, fn) {
+    const collected = [];
+    for (const value of values){
+        const mapped = fn(value);
+        if (isSome(mapped)) {
+            collected.push(mapped);
+        }
+    }
+    return collected;
+}
+export function map(opt, fn) {
+    if (isNone(opt)) return NONE;
+    const result = fn(opt);
+    return result === null || result === undefined ? NONE : result;
+}
+export function flatMap(opt, fn) {
+    return isNone(opt) ? NONE : fn(opt);
+}
+export function andThen(opt, fn) {
+    return flatMap(opt, fn);
+}
+export function tap(opt, fn) {
+    if (isSome(opt)) {
+        fn(opt);
+    }
+    return opt;
+}
+export function filter(opt, predicate) {
+    return isSome(opt) && predicate(opt) ? opt : NONE;
+}
+export function unwrap(opt) {
+    if (isNone(opt)) {
+        throw new Error('Called unwrap on None');
+    }
+    return opt;
+}
+export function unwrapOr(opt, defaultValue) {
+    return isSome(opt) ? opt : defaultValue;
+}
+export function unwrapOrElse(opt, fn) {
+    return isSome(opt) ? opt : fn();
+}
+export function expect(opt, message) {
+    if (isNone(opt)) {
+        throw new Error(message);
+    }
+    return opt;
+}
+export function or(opt, optb) {
+    return isSome(opt) ? opt : optb;
+}
+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;
+    return NONE;
+}
+export function and(opt, optb) {
+    return isSome(opt) ? optb : NONE;
+}
+export function zip(opt, other) {
+    return isSome(opt) && isSome(other) ? [
+        opt,
+        other
+    ] : NONE;
+}
+export function unzip(opt) {
+    if (isNone(opt)) return [
+        NONE,
+        NONE
+    ];
+    const [a, b] = opt;
+    return [
+        of(a),
+        of(b)
+    ];
+}
+export function mapOr(opt, defaultValue, fn) {
+    return isSome(opt) ? fn(opt) : defaultValue;
+}
+export function mapOrElse(opt, defaultFn, fn) {
+    return isSome(opt) ? fn(opt) : defaultFn();
+}
+export function flatten(opt) {
+    return isNone(opt) ? NONE : opt;
+}
+export function contains(opt, value) {
+    return isSome(opt) && opt === value;
+}
+export function isSomeAnd(opt, predicate) {
+    return isSome(opt) && predicate(opt);
+}
+export function toArray(opt) {
+    return isSome(opt) ? [
+        opt
+    ] : [];
+}
+export function toNullable(opt) {
+    return isSome(opt) ? opt : null;
+}
+export function toUndefined(opt) {
+    return isSome(opt) ? opt : undefined;
+}
+export function match(opt, onSome, onNone) {
+    return isSome(opt) ? onSome(opt) : onNone();
+}
+export function okOr(opt, error) {
+    return isSome(opt) ? opt : err(error);
+}
+export function okOrElse(opt, fn) {
+    return isSome(opt) ? opt : err(fn());
+}
+export function ofOk(result) {
+    if (!isOk(result) || !isSome(result)) {
+        return NONE;
+    }
+    return result;
+}
+export function ofErr(result) {
+    if (!isErr(result)) {
+        return NONE;
+    }
+    const error = result.error;
+    if (!isSome(error)) {
+        return NONE;
+    }
+    return error;
+}
+
+//# sourceMappingURL=option.js.map

package/build/option.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/option.ts"],"sourcesContent":["import { NONE, 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)) {\n      collected.push(mapped);\n    }\n  }\n  return collected;\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 flatMap(opt, fn);\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 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>): T[] {\n  return isSome(opt) ? [opt] : [];\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","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","map","result","undefined","flatMap","andThen","tap","filter","predicate","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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"}

package/build/result.cjs

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get all () {
+        return all;
+    },
+    get and () {
+        return and;
+    },
+    get andThen () {
+        return andThen;
+    },
+    get andThenAsync () {
+        return andThenAsync;
+    },
+    get any () {
+        return any;
+    },
+    get assertErr () {
+        return assertErr;
+    },
+    get assertOk () {
+        return assertOk;
+    },
+    get bimap () {
+        return bimap;
+    },
+    get collect () {
+        return collect;
+    },
+    get collectAll () {
+        return collectAll;
+    },
+    get expect () {
+        return expect;
+    },
+    get expectErr () {
+        return expectErr;
+    },
+    get flatMap () {
+        return flatMap;
+    },
+    get flatten () {
+        return flatten;
+    },
+    get fromPromise () {
+        return fromPromise;
+    },
+    get isErr () {
+        return _typescjs.isErr;
+    },
+    get isErrAnd () {
+        return isErrAnd;
+    },
+    get isOk () {
+        return _typescjs.isOk;
+    },
+    get isOkAnd () {
+        return isOkAnd;
+    },
+    get isSomeErr () {
+        return isSomeErr;
+    },
+    get map () {
+        return map;
+    },
+    get mapAsync () {
+        return mapAsync;
+    },
+    get mapErr () {
+        return mapErr;
+    },
+    get mapOr () {
+        return mapOr;
+    },
+    get mapOrElse () {
+        return mapOrElse;
+    },
+    get match () {
+        return match;
+    },
+    get matchAsync () {
+        return matchAsync;
+    },
+    get of () {
+        return of;
+    },
+    get ofAsync () {
+        return ofAsync;
+    },
+    get or () {
+        return or;
+    },
+    get orElse () {
+        return orElse;
+    },
+    get partition () {
+        return partition;
+    },
+    get partitionAsync () {
+        return partitionAsync;
+    },
+    get tap () {
+        return tap;
+    },
+    get tapErr () {
+        return tapErr;
+    },
+    get toErrorOption () {
+        return toErrorOption;
+    },
+    get toOption () {
+        return toOption;
+    },
+    get transpose () {
+        return transpose;
+    },
+    get tryAsync () {
+        return tryAsync;
+    },
+    get tryCatch () {
+        return tryCatch;
+    },
+    get unwrap () {
+        return unwrap;
+    },
+    get unwrapErr () {
+        return unwrapErr;
+    },
+    get unwrapOr () {
+        return unwrapOr;
+    },
+    get unwrapOrElse () {
+        return unwrapOrElse;
+    },
+    get unwrapOrReturn () {
+        return unwrapOrReturn;
+    },
+    get zip () {
+        return zip;
+    },
+    get zipWith () {
+        return zipWith;
+    }
+});
+const _typescjs = require("./types.cjs");
+function tryCatch(fn, onError) {
+    try {
+        return fn();
+    } catch (error) {
+        return (0, _typescjs.err)(onError ? onError(error) : error);
+    }
+}
+function of(fn) {
+    return tryCatch(fn);
+}
+async function tryAsync(fn, onError) {
+    try {
+        return await fn();
+    } catch (error) {
+        return (0, _typescjs.err)(onError ? onError(error) : error);
+    }
+}
+function ofAsync(fn) {
+    return tryAsync(fn);
+}
+async function fromPromise(promise, onRejected) {
+    try {
+        return await promise;
+    } catch (error) {
+        return (0, _typescjs.err)(onRejected ? onRejected(error) : error);
+    }
+}
+function unwrapOrReturn(result, onErr) {
+    return (0, _typescjs.isOk)(result) ? result : onErr(result.error);
+}
+function assertOk(result, message) {
+    if ((0, _typescjs.isErr)(result)) {
+        throw new Error(message ?? `Expected Ok result. Received error: ${String(result.error)}`);
+    }
+}
+function assertErr(result, message) {
+    if ((0, _typescjs.isOk)(result)) {
+        throw new Error(message ?? 'Expected Err result.');
+    }
+}
+function isSomeErr(result) {
+    return (0, _typescjs.isErr)(result) && (0, _typescjs.isSome)(result.error);
+}
+function map(result, fn) {
+    if ((0, _typescjs.isErr)(result)) return result;
+    return fn(result);
+}
+function mapErr(result, fn) {
+    if ((0, _typescjs.isOk)(result)) return result;
+    return (0, _typescjs.err)(fn(result.error));
+}
+function flatMap(result, fn) {
+    if ((0, _typescjs.isErr)(result)) return result;
+    return fn(result);
+}
+function andThen(result, fn) {
+    return flatMap(result, fn);
+}
+function tap(result, fn) {
+    if ((0, _typescjs.isOk)(result)) {
+        fn(result);
+    }
+    return result;
+}
+function tapErr(result, fn) {
+    if ((0, _typescjs.isErr)(result)) {
+        fn(result.error);
+    }
+    return result;
+}
+function bimap(result, okFn, errFn) {
+    return (0, _typescjs.isOk)(result) ? okFn(result) : (0, _typescjs.err)(errFn(result.error));
+}
+function unwrap(result) {
+    if ((0, _typescjs.isErr)(result)) {
+        throw new Error(`Called unwrap on Err: ${String(result.error)}`);
+    }
+    return result;
+}
+function unwrapErr(result) {
+    if ((0, _typescjs.isOk)(result)) {
+        throw new Error(`Called unwrapErr on Ok: ${String(result)}`);
+    }
+    return result.error;
+}
+function unwrapOr(result, defaultValue) {
+    return (0, _typescjs.isOk)(result) ? result : defaultValue;
+}
+function unwrapOrElse(result, fn) {
+    return (0, _typescjs.isOk)(result) ? result : fn(result.error);
+}
+function mapOr(result, defaultValue, fn) {
+    return (0, _typescjs.isOk)(result) ? fn(result) : defaultValue;
+}
+function mapOrElse(result, defaultFn, fn) {
+    return (0, _typescjs.isOk)(result) ? fn(result) : defaultFn();
+}
+function expect(result, message) {
+    if ((0, _typescjs.isErr)(result)) {
+        throw new Error(`${message}: ${String(result.error)}`);
+    }
+    return result;
+}
+function expectErr(result, message) {
+    if ((0, _typescjs.isOk)(result)) {
+        throw new Error(`${message}: ${String(result)}`);
+    }
+    return result.error;
+}
+function and(result, other) {
+    return (0, _typescjs.isOk)(result) ? other : result;
+}
+function or(result, other) {
+    return (0, _typescjs.isOk)(result) ? result : other;
+}
+function orElse(result, fn) {
+    return (0, _typescjs.isOk)(result) ? result : fn(result.error);
+}
+function toOption(result) {
+    return (0, _typescjs.isOk)(result) ? (0, _typescjs.optionOf)(result) : _typescjs.NONE;
+}
+function toErrorOption(result) {
+    return (0, _typescjs.isErr)(result) ? (0, _typescjs.optionOf)(result.error) : _typescjs.NONE;
+}
+function zip(left, right) {
+    if ((0, _typescjs.isErr)(left)) return left;
+    if ((0, _typescjs.isErr)(right)) return right;
+    return [
+        left,
+        right
+    ];
+}
+function zipWith(left, right, fn) {
+    if ((0, _typescjs.isErr)(left)) return left;
+    if ((0, _typescjs.isErr)(right)) return right;
+    return fn(left, right);
+}
+function flatten(result) {
+    return (0, _typescjs.isErr)(result) ? result : result;
+}
+function match(result, onOk, onErr) {
+    return (0, _typescjs.isOk)(result) ? onOk(result) : onErr(result.error);
+}
+function 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 [
+        oks,
+        errs
+    ];
+}
+function collect(results) {
+    const values = [];
+    for (const result of results){
+        if ((0, _typescjs.isErr)(result)) {
+            return result;
+        }
+        values.push(result);
+    }
+    return values;
+}
+function collectAll(results) {
+    const [oks, errs] = partition(results);
+    return errs.length > 0 ? (0, _typescjs.err)(errs) : oks;
+}
+function all(results) {
+    return collect(results);
+}
+function any(results) {
+    const len = results.length;
+    const errors = new Array(len);
+    for(let i = 0; i < len; i++){
+        const result = results[i];
+        if ((0, _typescjs.isOk)(result)) return result;
+        errors[i] = result.error;
+    }
+    return (0, _typescjs.err)(errors);
+}
+function transpose(result) {
+    if ((0, _typescjs.isErr)(result)) {
+        return (0, _typescjs.err)(result.error);
+    }
+    const opt = result;
+    return (0, _typescjs.isNone)(opt) ? _typescjs.NONE : opt;
+}
+function isOkAnd(result, predicate) {
+    return (0, _typescjs.isOk)(result) && predicate(result);
+}
+function isErrAnd(result, predicate) {
+    return (0, _typescjs.isErr)(result) && predicate(result.error);
+}
+async function mapAsync(result, fn, onRejected) {
+    if ((0, _typescjs.isErr)(result)) return result;
+    return fromPromise(fn(result), onRejected);
+}
+async function andThenAsync(result, fn) {
+    if ((0, _typescjs.isErr)(result)) return result;
+    return fn(result);
+}
+async function matchAsync(result, onOk, onErr) {
+    return (0, _typescjs.isOk)(result) ? onOk(result) : onErr(result.error);
+}
+async function partitionAsync(results) {
+    const oks = [];
+    const errs = [];
+    for (const promise of results){
+        const result = await promise;
+        if ((0, _typescjs.isOk)(result)) {
+            oks.push(result);
+        } else {
+            errs.push(result.error);
+        }
+    }
+    return [
+        oks,
+        errs
+    ];
+}
+
+//# sourceMappingURL=result.cjs.map

package/build/result.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/result.ts"],"sourcesContent":["import { err as ERR, isOk, isErr, isSome, isNone, NONE, optionOf } from './types.js';\nimport type { Ok, Err, Result, Option, Widen, WidenNever } 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, 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, E = unknown>(fn: () => T): Result<T, E> {\n  return tryCatch(fn);\n}\n\n/**\n * Executes an async function and captures the result or error.\n * @param fn - Async function to execute\n * @param onError - Optional error transformer\n * @returns Promise of Ok(result) if successful, Err(error) if rejected\n * @example\n * await tryAsync(() => fetch('/api').then(r => r.json())) // Ok(data) or Err(error)\n */\nexport async function tryAsync<T, E = unknown>(fn: () => Promise<T>, onError?: (error: unknown) => E): Promise<Result<T, E>> {\n  try {\n    return (await fn()) as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Alias for tryAsync. Executes an async function and captures the result or error.\n * @param fn - Async function to execute\n * @returns Promise of Ok(result) if successful, Err(error) if rejected\n */\nexport function ofAsync<T, E = unknown>(fn: () => Promise<T>): Promise<Result<T, E>> {\n  return tryAsync(fn);\n}\n\n/**\n * Converts a Promise to a Result.\n * @param promise - The promise to convert\n * @param onRejected - Optional rejection handler\n * @returns Promise of Ok(value) if resolved, Err(error) if rejected\n * @example\n * await fromPromise(Promise.resolve(42))        // Ok(42)\n * await fromPromise(Promise.reject('error'))    // Err('error')\n */\nexport async function fromPromise<T, E = unknown>(promise: Promise<T>, onRejected?: (reason: unknown) => E): Promise<Result<T, E>> {\n  try {\n    return (await promise) as Ok<T>;\n  } catch (error) {\n    return ERR(onRejected ? onRejected(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 as Err<E>).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 as Err<E>).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 as Err<E>;\n  return fn(result as Ok<T>) 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 as Err<E>;\n  return fn(result as Ok<T>);\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 flatMap(result, fn);\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 as Err<E>).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 if Err.\n * @param result - The Result to unwrap\n * @returns The contained Ok value\n * @throws Error if result is Err\n * @example\n * unwrap(ok(42))        // 42\n * unwrap(err('failed')) // throws Error\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n  if (isErr(result)) {\n    throw new Error(`Called unwrap on Err: ${String((result as Err<E>).error)}`);\n  }\n  return result as T;\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 as Err<E>).error)}`);\n  }\n  return result as Ok<T>;\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 as Err<E>).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 as Err<E>;\n  if (isErr(right)) return right as Err<E>;\n  return [left as Ok<T>, right as Ok<U>] 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 as Err<E>;\n  if (isErr(right)) return right as Err<E>;\n  return fn(left as Ok<T>, right as Ok<U>) 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 * 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)) {\n      return result as Err<E>;\n    }\n    values.push(result as Ok<T>);\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<Widen<T>[], WidenNever<E>> {\n  return collect(results) as Result<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 len = results.length;\n  const errors = new Array<WidenNever<E>>(len);\n  for (let i = 0; i < len; i++) {\n    const result = results[i];\n    if (isOk(result)) return result as Ok<Widen<T>>;\n    errors[i] = (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 as Err<E>).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 as Err<E>).error);\n}\n\n/**\n * Maps an async function over an Ok value.\n * @param result - The Result to map\n * @param fn - Async transform function\n * @param onRejected - Optional rejection handler\n * @returns Promise of mapped Result\n * @example\n * await mapAsync(ok(2), async x => x * 2) // Ok(4)\n */\nexport async function mapAsync<T, U, E = unknown>(\n  result: Result<T, E>,\n  fn: (value: T) => Promise<U>,\n  onRejected?: (error: unknown) => E,\n): Promise<Result<U, E>> {\n  if (isErr(result)) return result as Err<E>;\n  return fromPromise(fn(result as Ok<T>), onRejected);\n}\n\n/**\n * Chains an async Result-returning function.\n * @param result - The Result to chain\n * @param fn - Async function returning a Result\n * @returns Promise of the chained Result\n * @example\n * await andThenAsync(ok(2), async x => ok(x * 2)) // Ok(4)\n */\nexport async function andThenAsync<T, U, E>(result: Result<T, E>, fn: (value: T) => Promise<Result<U, E>>): Promise<Result<U, E>> {\n  if (isErr(result)) return result as Err<E>;\n  return fn(result as Ok<T>);\n}\n\n/**\n * Pattern matches with async handlers.\n * @param result - The Result to match\n * @param onOk - Async handler for Ok\n * @param onErr - Async handler for Err\n * @returns Promise of the handler result\n */\nexport async function matchAsync<T, E, U>(result: Result<T, E>, onOk: (value: T) => Promise<U>, onErr: (error: E) => Promise<U>): Promise<U> {\n  return isOk(result) ? onOk(result) : onErr(result.error);\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>(results: Iterable<Promise<Result<T, E>>>): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const oks: Widen<T>[] = [];\n  const errs: WidenNever<E>[] = [];\n\n  for (const promise of results) {\n    const result = await promise;\n    if (isOk(result)) {\n      oks.push(result as Ok<Widen<T>>);\n    } else {\n      errs.push((result as Err<WidenNever<E>>).error);\n    }\n  }\n\n  return [oks, errs];\n}\n"],"names":["all","and","andThen","andThenAsync","any","assertErr","assertOk","bimap","collect","collectAll","expect","expectErr","flatMap","flatten","fromPromise","isErr","isErrAnd","isOk","isOkAnd","isSomeErr","map","mapAsync","mapErr","mapOr","mapOrElse","match","matchAsync","of","ofAsync","or","orElse","partition","partitionAsync","tap","tapErr","toErrorOption","toOption","transpose","tryAsync","tryCatch","unwrap","unwrapErr","unwrapOr","unwrapOrElse","unwrapOrReturn","zip","zipWith","fn","onError","error","ERR","promise","onRejected","result","onErr","message","Error","String","isSome","okFn","errFn","defaultValue","defaultFn","other","optionOf","NONE","left","right","onOk","results","oks","errs","push","values","length","len","errors","Array","i","opt","isNone","predicate"],"mappings":"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"}