nalloc 0.0.1 → 0.0.3

package/build/result.d.ts

@@ -1,5 +1,5 @@
 import { isOk, isErr } from './types.js';
-import type { Ok, Err, Result, Option, Widen, WidenNever } from './types.js';
+import type { Ok, Err, Result, Option, Widen, WidenNever, MaybePromise } from './types.js';
 export type { Ok, Err, Result };
 export { isOk, isErr };
 /**
@@ -12,38 +12,37 @@ export { isOk, isErr };
  * tryCatch(() => JSON.parse('invalid'))     // Err(SyntaxError)
  * tryCatch(() => { throw 'oops' }, e => e)  // Err('oops')
  */
-export declare function tryCatch<T, E = unknown>(fn: () => T, onError?: (error: unknown) => E): Result<T, E>;
+export declare function tryCatch<T>(fn: () => T): Result<T, unknown>;
+export declare function tryCatch<T, E>(fn: () => T, onError: (error: unknown) => E): Result<T, E>;
 /**
  * Alias for tryCatch. Executes a function and captures the result or error.
  * @param fn - Function to execute
  * @returns Ok(result) if successful, Err(error) if thrown
  */
-export declare function of<T, E = unknown>(fn: () => T): Result<T, E>;
+export declare function of<T>(fn: () => T): Result<T, unknown>;
 /**
- * Executes an async function and captures the result or error.
- * @param fn - Async function to execute
+ * 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 of Ok(result) if successful, Err(error) if rejected
+ * @returns Promise resolving to Ok(value) or Err(error)
  * @example
- * await tryAsync(() => fetch('/api').then(r => r.json())) // Ok(data) or Err(error)
- */
-export declare function tryAsync<T, E = unknown>(fn: () => Promise<T>, onError?: (error: unknown) => E): Promise<Result<T, E>>;
-/**
- * Alias for tryAsync. Executes an async function and captures the result or error.
- * @param fn - Async function to execute
- * @returns Promise of Ok(result) if successful, Err(error) if rejected
+ * await fromPromise(fetch('/api'))              // Ok(Response) or Err(unknown)
+ * await fromPromise(fetch('/api'), e => String(e)) // Ok(Response) or Err(string)
  */
-export declare function ofAsync<T, E = unknown>(fn: () => Promise<T>): Promise<Result<T, E>>;
+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>>;
 /**
- * Converts a Promise to a Result.
- * @param promise - The promise to convert
- * @param onRejected - Optional rejection handler
- * @returns Promise of Ok(value) if resolved, Err(error) if rejected
+ * Executes a function that may return sync or async, preserving sync execution when possible.
+ * @param fn - Function that may return T or Promise<T>
+ * @param onError - Optional error transformer
+ * @returns Result<T, E> if sync, Promise<Result<T, E>> if async
  * @example
- * await fromPromise(Promise.resolve(42))        // Ok(42)
- * await fromPromise(Promise.reject('error'))    // Err('error')
+ * tryCatchMaybePromise(() => 42)                    // Ok(42) - sync
+ * tryCatchMaybePromise(() => Promise.resolve(42))   // Promise<Ok(42)> - async
+ * tryCatchMaybePromise(() => { throw 'err' })       // Err('err') - sync
  */
-export declare function fromPromise<T, E = unknown>(promise: Promise<T>, onRejected?: (reason: unknown) => E): Promise<Result<T, E>>;
+export declare function tryCatchMaybePromise<T>(fn: () => MaybePromise<T>): Result<T, unknown> | Promise<Result<T, unknown>>;
+export declare function tryCatchMaybePromise<T, E>(fn: () => MaybePromise<T>, onError: (error: unknown) => E): Result<T, E> | Promise<Result<T, E>>;
 /**
  * Unwraps an Ok value or returns a computed value for Err.
  * @param result - The Result to unwrap
@@ -160,13 +159,18 @@ export declare function bimap<T, U, E, F>(result: Ok<T>, okFn: (value: T) => U,
 export declare function bimap<T, U, E, F>(result: Err<E>, okFn: (value: T) => U, errFn: (error: E) => F): Err<F>;
 export declare function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F>;
 /**
- * Extracts the Ok value, throws if Err.
+ * Extracts the Ok value, throws Err if not Ok.
+ * Use with safeTry for Rust-like ? operator ergonomics.
  * @param result - The Result to unwrap
  * @returns The contained Ok value
- * @throws Error if result is Err
+ * @throws The Err object itself
  * @example
  * unwrap(ok(42))        // 42
- * unwrap(err('failed')) // throws Error
+ * unwrap(err('failed')) // throws Err
+ * safeTry(() => {
+ *   const a = unwrap(getValue());
+ *   return a + 1;
+ * });
  */
 export declare function unwrap<T, E>(result: Result<T, E>): T;
 /**
@@ -340,6 +344,22 @@ export declare function match<T, E, U>(result: Result<T, E>, onOk: (value: T) =>
  * partition([ok(1), err('a'), ok(2)]) // [[1, 2], ['a']]
  */
 export declare function partition<T, E>(results: Result<T, E>[]): [T[], E[]];
+/**
+ * Extracts all Ok values from an iterable of Results.
+ * @param results - Iterable of Results
+ * @returns Array of Ok values
+ * @example
+ * filterOk([ok(1), err('a'), ok(2)]) // [1, 2]
+ */
+export declare function filterOk<T, E>(results: Iterable<Result<T, E>>): T[];
+/**
+ * Extracts all Err values from an iterable of Results.
+ * @param results - Iterable of Results
+ * @returns Array of error values
+ * @example
+ * filterErr([ok(1), err('a'), ok(2)]) // ['a']
+ */
+export declare function filterErr<T, E>(results: Iterable<Result<T, E>>): E[];
 /**
  * Collects an array of Results into a Result of an array. Fails on first Err.
  * @param results - Array of Results
@@ -363,7 +383,7 @@ export declare function collectAll<T, E>(results: Result<T, E>[]): Result<T[], E
  * @param results - Array of Results
  * @returns Ok(values) if all Ok, first Err otherwise
  */
-export declare function all<T, E>(results: Result<T, E>[]): Result<Widen<T>[], WidenNever<E>>;
+export declare function all<T, E>(results: Result<T, E>[]): Result<readonly Widen<T>[], WidenNever<E>>;
 /**
  * Returns the first Ok, or all errors if none succeed.
  * @param results - Array of Results
@@ -404,39 +424,60 @@ export declare function isOkAnd<T, E>(result: Result<T, E>, predicate: (value: T
  * isErrAnd(ok(42), e => true)                       // false
  */
 export declare function isErrAnd<T, E>(result: Result<T, E>, predicate: (error: E) => boolean): boolean;
+export declare function settledToResult<T, E>(result: PromiseSettledResult<Result<T, E>>): Result<T, E>;
 /**
- * Maps an async function over an Ok value.
- * @param result - The Result to map
- * @param fn - Async transform function
- * @param onRejected - Optional rejection handler
- * @returns Promise of mapped Result
+ * Partitions an async iterable of Results.
+ * @param results - Iterable of Promise Results
+ * @returns Promise of [Ok values, Err values]
  * @example
- * await mapAsync(ok(2), async x => x * 2) // Ok(4)
+ * await partitionAsync([Promise.resolve(ok(1)), Promise.resolve(err('a'))])
+ * // [[1], ['a']]
  */
-export declare function mapAsync<T, U, E = unknown>(result: Result<T, E>, fn: (value: T) => Promise<U>, onRejected?: (error: unknown) => E): Promise<Result<U, E>>;
+export declare function partitionAsync<T, E>(promises: Iterable<Promise<Result<T, E>>>): Promise<[Widen<T>[], WidenNever<E>[]]>;
 /**
- * Chains an async Result-returning function.
- * @param result - The Result to chain
- * @param fn - Async function returning a Result
- * @returns Promise of the chained Result
+ * Settles an array of MaybePromise values into Results.
+ * Returns synchronously if all inputs are sync, avoiding Promise overhead.
+ * @param values - Array of values that may or may not be Promises
+ * @returns Array of Results (sync) or Promise of Results (if any async)
  * @example
- * await andThenAsync(ok(2), async x => ok(x * 2)) // Ok(4)
+ * settleMaybePromise([1, 2, 3])                    // [Ok(1), Ok(2), Ok(3)] - sync
+ * settleMaybePromise([1, Promise.resolve(2)])     // Promise<[Ok(1), Ok(2)]>
+ * settleMaybePromise([Promise.reject('e')])       // Promise<[Err('e')]>
  */
-export declare function andThenAsync<T, U, E>(result: Result<T, E>, fn: (value: T) => Promise<Result<U, E>>): Promise<Result<U, E>>;
+export declare function settleMaybePromise<T, E = unknown>(values: MaybePromise<T>[]): Result<T, E>[] | Promise<Result<T, E>[]>;
+export declare function partitionMaybePromiseAsync<T, E>(values: MaybePromise<Result<T, E>>[], oks: Widen<T>[], errs: WidenNever<E>[], startIndex?: number): Promise<[Widen<T>[], WidenNever<E>[]]>;
 /**
- * Pattern matches with async handlers.
- * @param result - The Result to match
- * @param onOk - Async handler for Ok
- * @param onErr - Async handler for Err
- * @returns Promise of the handler result
+ * Partitions MaybePromise Results into Ok and Err values.
+ * Returns synchronously if all inputs are sync, avoiding Promise overhead.
+ * @param values - Array of MaybePromise Results
+ * @returns [Ok values, Err values] (sync) or Promise of same (if any async)
+ * @example
+ * partitionMaybePromise([ok(1), err('a')])                   // [[1], ['a']] - sync
+ * partitionMaybePromise([ok(1), Promise.resolve(err('a'))]) // Promise<[[1], ['a']]>
  */
-export declare function matchAsync<T, E, U>(result: Result<T, E>, onOk: (value: T) => Promise<U>, onErr: (error: E) => Promise<U>): Promise<U>;
+export declare function partitionMaybePromise<T, E>(values: MaybePromise<Result<T, E>>[]): [Widen<T>[], WidenNever<E>[]] | Promise<[Widen<T>[], WidenNever<E>[]]>;
 /**
- * Partitions an async iterable of Results.
- * @param results - Iterable of Promise Results
- * @returns Promise of [Ok values, Err values]
+ * Executes a function, catching thrown Err values.
+ * Use with unwrap for Rust-like ? operator ergonomics.
+ * @param fn - Function that may throw Err via unwrap
+ * @returns Ok(return value) or the caught Err
  * @example
- * await partitionAsync([Promise.resolve(ok(1)), Promise.resolve(err('a'))])
- * // [[1], ['a']]
+ * const result = safeTry(() => {
+ *   const a = unwrap(parseNumber('10'));
+ *   const b = unwrap(parseNumber('5'));
+ *   return a + b;
+ * }); // Ok(15) or Err(...)
+ */
+export declare function safeTry<T>(fn: () => T): Result<T, unknown>;
+/**
+ * Async version of safeTry.
+ * @param fn - Async function that may throw Err via unwrap
+ * @returns Promise of Ok(return value) or the caught Err
+ * @example
+ * const result = await safeTryAsync(async () => {
+ *   const user = unwrap(await fetchUser(id));
+ *   const posts = unwrap(await fetchPosts(user.id));
+ *   return { user, posts };
+ * });
  */
-export declare function partitionAsync<T, E>(results: Iterable<Promise<Result<T, E>>>): Promise<[Widen<T>[], WidenNever<E>[]]>;
+export declare function safeTryAsync<T>(fn: () => Promise<T>): Promise<Result<T, unknown>>;

package/build/result.js

@@ -1,4 +1,4 @@
-import { err as ERR, isOk, isErr, isSome, isNone, NONE, optionOf } from "./types.js";
+import { err as ERR, isOk, isErr, isSome, isNone, NONE, optionOf, isThenable } from "./types.js";
 export { isOk, isErr };
 export function tryCatch(fn, onError) {
     try {
@@ -10,21 +10,22 @@ export function tryCatch(fn, onError) {
 export function of(fn) {
     return tryCatch(fn);
 }
-export async function tryAsync(fn, onError) {
+export async function fromPromise(promise, onError) {
     try {
-        return await fn();
+        return await promise;
     } catch (error) {
         return ERR(onError ? onError(error) : error);
     }
 }
-export function ofAsync(fn) {
-    return tryAsync(fn);
-}
-export async function fromPromise(promise, onRejected) {
+export function tryCatchMaybePromise(fn, onError) {
     try {
-        return await promise;
+        const result = fn();
+        if (isThenable(result)) {
+            return Promise.resolve(result).then((value)=>value, (error)=>ERR(onError ? onError(error) : error));
+        }
+        return result;
     } catch (error) {
-        return ERR(onRejected ? onRejected(error) : error);
+        return ERR(onError ? onError(error) : error);
     }
 }
 export function unwrapOrReturn(result, onErr) {
@@ -56,7 +57,7 @@ export function flatMap(result, fn) {
     return fn(result);
 }
 export function andThen(result, fn) {
-    return flatMap(result, fn);
+    return isErr(result) ? result : fn(result);
 }
 export function tap(result, fn) {
     if (isOk(result)) {
@@ -74,9 +75,7 @@ export function bimap(result, okFn, errFn) {
     return isOk(result) ? okFn(result) : ERR(errFn(result.error));
 }
 export function unwrap(result) {
-    if (isErr(result)) {
-        throw new Error(`Called unwrap on Err: ${String(result.error)}`);
-    }
+    if (isErr(result)) throw result.error;
     return result;
 }
 export function unwrapErr(result) {
@@ -158,30 +157,49 @@ export function partition(results) {
         errs
     ];
 }
+export function filterOk(results) {
+    const oks = [];
+    for (const result of results){
+        if (isOk(result)) oks.push(result);
+    }
+    return oks;
+}
+export function filterErr(results) {
+    const errs = [];
+    for (const result of results){
+        if (isErr(result)) errs.push(result.error);
+    }
+    return errs;
+}
 export function collect(results) {
     const values = [];
     for (const result of results){
-        if (isErr(result)) {
-            return result;
-        }
+        if (isErr(result)) return result;
         values.push(result);
     }
     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) {
     return collect(results);
 }
 export function any(results) {
-    const len = results.length;
-    const errors = new Array(len);
-    for(let i = 0; i < len; i++){
+    const errors = [];
+    for(let i = 0; i < results.length; i++){
         const result = results[i];
         if (isOk(result)) return result;
-        errors[i] = result.error;
+        errors.push(result.error);
     }
     return ERR(errors);
 }
@@ -198,22 +216,47 @@ export function isOkAnd(result, predicate) {
 export function isErrAnd(result, predicate) {
     return isErr(result) && predicate(result.error);
 }
-export async function mapAsync(result, fn, onRejected) {
-    if (isErr(result)) return result;
-    return fromPromise(fn(result), onRejected);
-}
-export async function andThenAsync(result, fn) {
-    if (isErr(result)) return result;
-    return fn(result);
+export function settledToResult(result) {
+    if (result.status === 'fulfilled') return result.value;
+    return ERR(result.reason);
 }
-export async function matchAsync(result, onOk, onErr) {
-    return isOk(result) ? onOk(result) : onErr(result.error);
+export async function partitionAsync(promises) {
+    const settled = await Promise.allSettled(promises);
+    return partition(settled.map(settledToResult));
 }
-export async function partitionAsync(results) {
-    const oks = [];
-    const errs = [];
-    for (const promise of results){
-        const result = await promise;
+export function settleMaybePromise(values) {
+    const len = values.length;
+    const results = new Array(len);
+    let pendingIndices;
+    let pendingPromises;
+    for(let i = 0; i < len; i++){
+        const v = values[i];
+        if (isThenable(v)) {
+            (pendingIndices ??= []).push(i);
+            (pendingPromises ??= []).push(Promise.resolve(v));
+        } else {
+            results[i] = v;
+        }
+    }
+    if (!pendingPromises) return results;
+    return Promise.allSettled(pendingPromises).then((settled)=>{
+        for(let i = 0; i < settled.length; i++){
+            const s = settled[i];
+            results[pendingIndices[i]] = s.status === 'fulfilled' ? s.value : ERR(s.reason);
+        }
+        return results;
+    });
+}
+export async function partitionMaybePromiseAsync(values, oks, errs, startIndex = 0) {
+    const suffixLength = values.length - startIndex;
+    const pending = new Array(suffixLength);
+    for(let i = 0; i < suffixLength; i++){
+        const value = values[startIndex + i];
+        pending[i] = Promise.resolve(value).then((result)=>result, (error)=>ERR(error));
+    }
+    const resolved = await Promise.all(pending);
+    for(let i = 0; i < resolved.length; i++){
+        const result = resolved[i];
         if (isOk(result)) {
             oks.push(result);
         } else {
@@ -225,5 +268,39 @@ export async function partitionAsync(results) {
         errs
     ];
 }
+export function partitionMaybePromise(values) {
+    const len = values.length;
+    const oks = [];
+    const errs = [];
+    for(let i = 0; i < len; i++){
+        const value = values[i];
+        if (isThenable(value)) {
+            return partitionMaybePromiseAsync(values, oks, errs, i);
+        }
+        if (isOk(value)) {
+            oks.push(value);
+        } else {
+            errs.push(value.error);
+        }
+    }
+    return [
+        oks,
+        errs
+    ];
+}
+export function safeTry(fn) {
+    try {
+        return fn();
+    } catch (e) {
+        return ERR(e);
+    }
+}
+export async function safeTryAsync(fn) {
+    try {
+        return await fn();
+    } catch (e) {
+        return ERR(e);
+    }
+}
 
 //# sourceMappingURL=result.js.map

package/build/result.js.map

@@ -1 +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":["err","ERR","isOk","isErr","isSome","isNone","NONE","optionOf","tryCatch","fn","onError","error","of","tryAsync","ofAsync","fromPromise","promise","onRejected","unwrapOrReturn","result","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","collect","values","collectAll","length","all","any","len","errors","Array","i","transpose","opt","isOkAnd","predicate","isErrAnd","mapAsync","andThenAsync","matchAsync","partitionAsync"],"mappings":"AAAA,SAASA,OAAOC,GAAG,EAAEC,IAAI,EAAEC,KAAK,EAAEC,MAAM,EAAEC,MAAM,EAAEC,IAAI,EAAEC,QAAQ,QAAQ,aAAa;AAIrF,SAASL,IAAI,EAAEC,KAAK,GAAG;AAYvB,OAAO,SAASK,SAAyBC,EAAW,EAAEC,OAA+B;IACnF,IAAI;QACF,OAAOD;IACT,EAAE,OAAOE,OAAO;QACd,OAAOV,IAAIS,UAAUA,QAAQC,SAAUA;IACzC;AACF;AAOA,OAAO,SAASC,GAAmBH,EAAW;IAC5C,OAAOD,SAASC;AAClB;AAUA,OAAO,eAAeI,SAAyBJ,EAAoB,EAAEC,OAA+B;IAClG,IAAI;QACF,OAAQ,MAAMD;IAChB,EAAE,OAAOE,OAAO;QACd,OAAOV,IAAIS,UAAUA,QAAQC,SAAUA;IACzC;AACF;AAOA,OAAO,SAASG,QAAwBL,EAAoB;IAC1D,OAAOI,SAASJ;AAClB;AAWA,OAAO,eAAeM,YAA4BC,OAAmB,EAAEC,UAAmC;IACxG,IAAI;QACF,OAAQ,MAAMD;IAChB,EAAE,OAAOL,OAAO;QACd,OAAOV,IAAIgB,aAAaA,WAAWN,SAAUA;IAC/C;AACF;AAWA,OAAO,SAASO,eAA8BC,MAAoB,EAAEC,KAAsB;IACxF,OAAOlB,KAAKiB,UAAUA,SAASC,MAAMD,OAAOR,KAAK;AACnD;AAWA,OAAO,SAASU,SAAeF,MAAoB,EAAEG,OAAgB;IACnE,IAAInB,MAAMgB,SAAS;QACjB,MAAM,IAAII,MAAMD,WAAW,CAAC,oCAAoC,EAAEE,OAAO,AAACL,OAAkBR,KAAK,GAAG;IACtG;AACF;AAWA,OAAO,SAASc,UAAgBN,MAAoB,EAAEG,OAAgB;IACpE,IAAIpB,KAAKiB,SAAS;QAChB,MAAM,IAAII,MAAMD,WAAW;IAC7B;AACF;AAOA,OAAO,SAASI,UAAgBP,MAAoB;IAClD,OAAOhB,MAAMgB,WAAWf,OAAO,AAACe,OAAkBR,KAAK;AACzD;AAcA,OAAO,SAASgB,IAAaR,MAAoB,EAAEV,EAAmB;IACpE,IAAIN,MAAMgB,SAAS,OAAOA;IAC1B,OAAOV,GAAGU;AACZ;AAcA,OAAO,SAASS,OAAgBT,MAAoB,EAAEV,EAAmB;IACvE,IAAIP,KAAKiB,SAAS,OAAOA;IACzB,OAAOlB,IAAIQ,GAAGU,OAAOR,KAAK;AAC5B;AAcA,OAAO,SAASkB,QAAiBV,MAAoB,EAAEV,EAA8B;IACnF,IAAIN,MAAMgB,SAAS,OAAOA;IAC1B,OAAOV,GAAGU;AACZ;AAUA,OAAO,SAASW,QAAiBX,MAAoB,EAAEV,EAA8B;IACnF,OAAOoB,QAAQV,QAAQV;AACzB;AAaA,OAAO,SAASsB,IAAUZ,MAAoB,EAAEV,EAAsB;IACpE,IAAIP,KAAKiB,SAAS;QAChBV,GAAGU;IACL;IACA,OAAOA;AACT;AAaA,OAAO,SAASa,OAAab,MAAoB,EAAEV,EAAsB;IACvE,IAAIN,MAAMgB,SAAS;QACjBV,GAAG,AAACU,OAAkBR,KAAK;IAC7B;IACA,OAAOQ;AACT;AAeA,OAAO,SAASc,MAAkBd,MAAoB,EAAEe,IAAqB,EAAEC,KAAsB;IACnG,OAAOjC,KAAKiB,UAAWe,KAAKf,UAAoBlB,IAAIkC,MAAMhB,OAAOR,KAAK;AACxE;AAWA,OAAO,SAASyB,OAAajB,MAAoB;IAC/C,IAAIhB,MAAMgB,SAAS;QACjB,MAAM,IAAII,MAAM,CAAC,sBAAsB,EAAEC,OAAO,AAACL,OAAkBR,KAAK,GAAG;IAC7E;IACA,OAAOQ;AACT;AAWA,OAAO,SAASkB,UAAgBlB,MAAoB;IAClD,IAAIjB,KAAKiB,SAAS;QAChB,MAAM,IAAII,MAAM,CAAC,wBAAwB,EAAEC,OAAOL,SAAS;IAC7D;IACA,OAAOA,OAAOR,KAAK;AACrB;AAWA,OAAO,SAAS2B,SAAenB,MAAoB,EAAEoB,YAAe;IAClE,OAAOrC,KAAKiB,UAAUA,SAASoB;AACjC;AAWA,OAAO,SAASC,aAAmBrB,MAAoB,EAAEV,EAAmB;IAC1E,OAAOP,KAAKiB,UAAUA,SAASV,GAAGU,OAAOR,KAAK;AAChD;AAYA,OAAO,SAAS8B,MAAetB,MAAoB,EAAEoB,YAAe,EAAE9B,EAAmB;IACvF,OAAOP,KAAKiB,UAAUV,GAAGU,UAAUoB;AACrC;AAYA,OAAO,SAASG,UAAmBvB,MAAoB,EAAEwB,SAAkB,EAAElC,EAAmB;IAC9F,OAAOP,KAAKiB,UAAUV,GAAGU,UAAUwB;AACrC;AAYA,OAAO,SAASC,OAAazB,MAAoB,EAAEG,OAAe;IAChE,IAAInB,MAAMgB,SAAS;QACjB,MAAM,IAAII,MAAM,GAAGD,QAAQ,EAAE,EAAEE,OAAO,AAACL,OAAkBR,KAAK,GAAG;IACnE;IACA,OAAOQ;AACT;AAYA,OAAO,SAAS0B,UAAgB1B,MAAoB,EAAEG,OAAe;IACnE,IAAIpB,KAAKiB,SAAS;QAChB,MAAM,IAAII,MAAM,GAAGD,QAAQ,EAAE,EAAEE,OAAOL,SAAS;IACjD;IACA,OAAOA,OAAOR,KAAK;AACrB;AAWA,OAAO,SAASmC,IAAa3B,MAAoB,EAAE4B,KAAmB;IACpE,OAAO7C,KAAKiB,UAAU4B,QAAQ5B;AAChC;AAWA,OAAO,SAAS6B,GAAY7B,MAAoB,EAAE4B,KAAmB;IACnE,OAAO7C,KAAKiB,UAAUA,SAAS4B;AACjC;AAWA,OAAO,SAASE,OAAgB9B,MAAoB,EAAEV,EAA8B;IAClF,OAAOP,KAAKiB,UAAUA,SAASV,GAAGU,OAAOR,KAAK;AAChD;AAUA,OAAO,SAASuC,SAAe/B,MAAoB;IACjD,OAAOjB,KAAKiB,UAAUZ,SAASY,UAAUb;AAC3C;AAUA,OAAO,SAAS6C,cAAoBhC,MAAoB;IACtD,OAAOhB,MAAMgB,UAAUZ,SAAS,AAACY,OAAkBR,KAAK,IAAIL;AAC9D;AAWA,OAAO,SAAS8C,IAAaC,IAAkB,EAAEC,KAAmB;IAClE,IAAInD,MAAMkD,OAAO,OAAOA;IACxB,IAAIlD,MAAMmD,QAAQ,OAAOA;IACzB,OAAO;QAACD;QAAeC;KAAe;AACxC;AAWA,OAAO,SAASC,QAAoBF,IAAkB,EAAEC,KAAmB,EAAE7C,EAA4B;IACvG,IAAIN,MAAMkD,OAAO,OAAOA;IACxB,IAAIlD,MAAMmD,QAAQ,OAAOA;IACzB,OAAO7C,GAAG4C,MAAeC;AAC3B;AAWA,OAAO,SAASE,QAAcrC,MAA+B;IAC3D,OAAOhB,MAAMgB,UAAWA,SAAqBA;AAC/C;AAYA,OAAO,SAASsC,MAAetC,MAAoB,EAAEuC,IAAqB,EAAEtC,KAAsB;IAChG,OAAOlB,KAAKiB,UAAUuC,KAAKvC,UAAUC,MAAMD,OAAOR,KAAK;AACzD;AASA,OAAO,SAASgD,UAAgBC,OAAuB;IACrD,MAAMC,MAAW,EAAE;IACnB,MAAMC,OAAY,EAAE;IAEpB,KAAK,MAAM3C,UAAUyC,QAAS;QAC5B,IAAI1D,KAAKiB,SAAS;YAChB0C,IAAIE,IAAI,CAAC5C;QACX,OAAO;YACL2C,KAAKC,IAAI,CAAC5C,OAAOR,KAAK;QACxB;IACF;IAEA,OAAO;QAACkD;QAAKC;KAAK;AACpB;AAUA,OAAO,SAASE,QAAcJ,OAAuB;IACnD,MAAMK,SAAc,EAAE;IAEtB,KAAK,MAAM9C,UAAUyC,QAAS;QAC5B,IAAIzD,MAAMgB,SAAS;YACjB,OAAOA;QACT;QACA8C,OAAOF,IAAI,CAAC5C;IACd;IAEA,OAAO8C;AACT;AAUA,OAAO,SAASC,WAAiBN,OAAuB;IACtD,MAAM,CAACC,KAAKC,KAAK,GAAGH,UAAUC;IAC9B,OAAOE,KAAKK,MAAM,GAAG,IAAIlE,IAAI6D,QAASD;AACxC;AAOA,OAAO,SAASO,IAAUR,OAAuB;IAC/C,OAAOI,QAAQJ;AACjB;AAUA,OAAO,SAASS,IAAUT,OAAuB;IAC/C,MAAMU,MAAMV,QAAQO,MAAM;IAC1B,MAAMI,SAAS,IAAIC,MAAqBF;IACxC,IAAK,IAAIG,IAAI,GAAGA,IAAIH,KAAKG,IAAK;QAC5B,MAAMtD,SAASyC,OAAO,CAACa,EAAE;QACzB,IAAIvE,KAAKiB,SAAS,OAAOA;QACzBoD,MAAM,CAACE,EAAE,GAAG,AAACtD,OAA8BR,KAAK;IAClD;IACA,OAAOV,IAAIsE;AACb;AAWA,OAAO,SAASG,UAAgBvD,MAA4B;IAC1D,IAAIhB,MAAMgB,SAAS;QACjB,OAAOlB,IAAI,AAACkB,OAAkBR,KAAK;IACrC;IACA,MAAMgE,MAAMxD;IACZ,OAAOd,OAAOsE,OAAOrE,OAAQqE;AAC/B;AAYA,OAAO,SAASC,QAAczD,MAAoB,EAAE0D,SAAgC;IAClF,OAAO3E,KAAKiB,WAAW0D,UAAU1D;AACnC;AAWA,OAAO,SAAS2D,SAAe3D,MAAoB,EAAE0D,SAAgC;IACnF,OAAO1E,MAAMgB,WAAW0D,UAAU,AAAC1D,OAAkBR,KAAK;AAC5D;AAWA,OAAO,eAAeoE,SACpB5D,MAAoB,EACpBV,EAA4B,EAC5BQ,UAAkC;IAElC,IAAId,MAAMgB,SAAS,OAAOA;IAC1B,OAAOJ,YAAYN,GAAGU,SAAkBF;AAC1C;AAUA,OAAO,eAAe+D,aAAsB7D,MAAoB,EAAEV,EAAuC;IACvG,IAAIN,MAAMgB,SAAS,OAAOA;IAC1B,OAAOV,GAAGU;AACZ;AASA,OAAO,eAAe8D,WAAoB9D,MAAoB,EAAEuC,IAA8B,EAAEtC,KAA+B;IAC7H,OAAOlB,KAAKiB,UAAUuC,KAAKvC,UAAUC,MAAMD,OAAOR,KAAK;AACzD;AAUA,OAAO,eAAeuE,eAAqBtB,OAAwC;IACjF,MAAMC,MAAkB,EAAE;IAC1B,MAAMC,OAAwB,EAAE;IAEhC,KAAK,MAAM9C,WAAW4C,QAAS;QAC7B,MAAMzC,SAAS,MAAMH;QACrB,IAAId,KAAKiB,SAAS;YAChB0C,IAAIE,IAAI,CAAC5C;QACX,OAAO;YACL2C,KAAKC,IAAI,CAAC,AAAC5C,OAA8BR,KAAK;QAChD;IACF;IAEA,OAAO;QAACkD;QAAKC;KAAK;AACpB"}
+{"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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"}