@shirudo/result 1.1.0 → 1.2.0

package/dist/operators.cjs

@@ -1,34 +1,415 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_result = require('./result-BBOGxvSH.cjs');
-const require_swap = require('./swap-BnyMBdD_.cjs');
+const require_result = require('./result-DoqQufvR.cjs');
+const require_errors = require('./errors-CVgC7NII.cjs');
 
-exports.and = require_swap.and;
-exports.bimap = require_swap.bimap;
+//#region src/core/map.ts
+/**
+* Transforms the value (Ok case).
+* Corresponds to Rust `map`.
+*/
+function map(project) {
+	return (source) => {
+		if (source.isOk()) return require_result.ok(project(source.value));
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("map");
+	};
+}
+
+//#endregion
+//#region src/core/mapErr.ts
+/**
+* Transforms the error (Err case).
+* Corresponds to Rust `map_err`.
+*/
+function mapErr(project) {
+	return (source) => {
+		if (source.isErr()) return require_result.err(project(source.error));
+		if (source.isOk()) return source;
+		throw new require_errors.InvalidResultStateError("mapErr");
+	};
+}
+
+//#endregion
+//#region src/core/mapBoth.ts
+/**
+* Transforms both the Ok value and the Err error.
+* Corresponds to FP `bimap` / `mapBoth`.
+*/
+function mapBoth(mapOk, mapErr) {
+	return (source) => {
+		if (source.isOk()) return require_result.ok(mapOk(source.value));
+		if (source.isErr()) return require_result.err(mapErr(source.error));
+		throw new require_errors.InvalidResultStateError("mapBoth");
+	};
+}
+/**
+* Alias for `mapBoth`.
+*/
+const bimap = mapBoth;
+
+//#endregion
+//#region src/core/flatMap.ts
+/**
+* Chains another operation that returns a Result.
+* Corresponds to Rust `and_then` or JS `flatMap`.
+*/
+function flatMap(project) {
+	return (source) => {
+		if (source.isOk()) return project(source.value);
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("flatMap");
+	};
+}
+
+//#endregion
+//#region src/core/tap.ts
+/**
+* Executes a side effect (logging, debugging) without changing the Result.
+* Corresponds to Rust `inspect` / `inspect_err`.
+*/
+function tap(observer) {
+	return (source) => {
+		if (source.isOk()) {
+			if (observer.ok) observer.ok(source.value);
+			return source;
+		}
+		if (source.isErr()) {
+			if (observer.err) observer.err(source.error);
+			return source;
+		}
+		throw new require_errors.InvalidResultStateError("tap");
+	};
+}
+
+//#endregion
+//#region src/core/filter.ts
+/**
+* Checks a condition. If false, the Result becomes Err.
+* Corresponds to Rust `filter` (partially).
+*/
+function filter(predicate, errorFn) {
+	return (source) => {
+		if (source.isOk()) {
+			if (predicate(source.value)) return source;
+			return require_result.err(errorFn());
+		}
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("filter");
+	};
+}
+
+//#endregion
+//#region src/core/fold.ts
+/**
+* Folds the Result into a single value by applying one of two functions.
+* The end of the pipe.
+*
+* This is the pipe operator equivalent of the `.fold()` instance method.
+*/
+function fold(handlers) {
+	return (source) => {
+		if (source.isOk()) return handlers.ok(source.value);
+		if (source.isErr()) return handlers.err(source.error);
+		throw new require_errors.InvalidResultStateError("fold");
+	};
+}
+
+//#endregion
+//#region src/core/tryCatch.ts
+function tryCatch(fn, errorMapper) {
+	return (source) => {
+		if (source.isErr()) return source;
+		try {
+			return require_result.ok(fn());
+		} catch (error) {
+			return require_result.err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/tryMap.ts
+function tryMap(project, errorMapper) {
+	return (source) => {
+		if (source.isErr()) return source;
+		if (!source.isOk()) throw new require_errors.InvalidResultStateError("tryMap");
+		try {
+			return require_result.ok(project(source.value));
+		} catch (error) {
+			return require_result.err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/recover.ts
+/**
+* Recover: converts Err to Ok(defaultValue).
+* Result is guaranteed to be Ok → Error type becomes `never`.
+*/
+function recover(defaultValue) {
+	return (source) => {
+		if (source.isOk()) return source;
+		if (source.isErr()) return require_result.ok(defaultValue);
+		throw new require_errors.InvalidResultStateError("recover");
+	};
+}
+/**
+* Like `recover`, but calculates the default value based on the error.
+*/
+function recoverWith(fn) {
+	return (source) => {
+		if (source.isOk()) return source;
+		if (source.isErr()) return require_result.ok(fn(source.error));
+		throw new require_errors.InvalidResultStateError("recoverWith");
+	};
+}
+
+//#endregion
+//#region src/core/match.ts
+/**
+* Resolves the Result. The end of the pipe.
+* Corresponds to Rust `match`.
+*/
+function match(handlers) {
+	return (source) => {
+		if (source.isOk()) return handlers.ok(source.value);
+		if (source.isErr()) return handlers.err(source.error);
+		throw new require_errors.InvalidResultStateError("match");
+	};
+}
+
+//#endregion
+//#region src/core/mapAsync.ts
+/**
+* Async version of map.
+*/
+function mapAsync(project) {
+	return async (source) => {
+		if (source.isOk()) return require_result.ok(await project(source.value));
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("mapAsync");
+	};
+}
+
+//#endregion
+//#region src/core/mapErrAsync.ts
+/**
+* Async version of mapErr.
+*/
+function mapErrAsync(project) {
+	return async (source) => {
+		if (source.isErr()) return require_result.err(await project(source.error));
+		if (source.isOk()) return source;
+		throw new require_errors.InvalidResultStateError("mapErrAsync");
+	};
+}
+
+//#endregion
+//#region src/core/flatMapAsync.ts
+/**
+* Async version of flatMap.
+*/
+function flatMapAsync(project) {
+	return async (source) => {
+		if (source.isOk()) return await project(source.value);
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("flatMapAsync");
+	};
+}
+
+//#endregion
+//#region src/core/tapAsync.ts
+/**
+* Async version of tap.
+*/
+function tapAsync(observer) {
+	return async (source) => {
+		if (source.isOk()) {
+			if (observer.ok) await observer.ok(source.value);
+			return source;
+		}
+		if (source.isErr()) {
+			if (observer.err) await observer.err(source.error);
+			return source;
+		}
+		throw new require_errors.InvalidResultStateError("tapAsync");
+	};
+}
+
+//#endregion
+//#region src/core/filterAsync.ts
+/**
+* Async version of filter.
+*/
+function filterAsync(predicate, errorFn) {
+	return async (source) => {
+		if (source.isOk()) {
+			if (await predicate(source.value)) return source;
+			return require_result.err(await errorFn());
+		}
+		if (source.isErr()) return source;
+		throw new require_errors.InvalidResultStateError("filterAsync");
+	};
+}
+
+//#endregion
+//#region src/core/foldAsync.ts
+/**
+* Async version of `fold`. Folds the Result into a single value asynchronously.
+* The end of the pipe.
+*
+* This is the async pipe operator equivalent of the `.fold()` instance method.
+*/
+function foldAsync(handlers) {
+	return async (source) => {
+		if (source.isOk()) return await handlers.ok(source.value);
+		if (source.isErr()) return await handlers.err(source.error);
+		throw new require_errors.InvalidResultStateError("foldAsync");
+	};
+}
+
+//#endregion
+//#region src/core/tryCatchAsync.ts
+function tryCatchAsync(fn, errorMapper) {
+	return async (source) => {
+		if (source.isErr()) return source;
+		try {
+			return require_result.ok(await fn());
+		} catch (error) {
+			return require_result.err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/tryMapAsync.ts
+function tryMapAsync(project, errorMapper) {
+	return async (source) => {
+		if (source.isErr()) return source;
+		if (!source.isOk()) throw new require_errors.InvalidResultStateError("tryMapAsync");
+		try {
+			return require_result.ok(await project(source.value));
+		} catch (error) {
+			return require_result.err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/matchAsync.ts
+/**
+* Async version of match.
+*/
+function matchAsync(handlers) {
+	return async (source) => {
+		if (source.isOk()) return await handlers.ok(source.value);
+		if (source.isErr()) return await handlers.err(source.error);
+		throw new require_errors.InvalidResultStateError("matchAsync");
+	};
+}
+
+//#endregion
+//#region src/core/and.ts
+/**
+* Combines two Results. Returns the second one only if the first is Ok.
+* Corresponds to Rust `and`.
+*/
+function and(result, other) {
+	if (result.isOk()) return other;
+	if (result.isErr()) return result;
+	throw new require_errors.InvalidResultStateError("and");
+}
+
+//#endregion
+//#region src/core/or.ts
+/**
+* Fallback to another Result if the first is Err.
+* Corresponds to Rust `or`.
+*/
+function or(result, other) {
+	if (result.isOk()) return result;
+	if (result.isErr()) return other;
+	throw new require_errors.InvalidResultStateError("or");
+}
+
+//#endregion
+//#region src/core/orElse.ts
+/**
+* Fallback with a function that returns a Result.
+* Corresponds to Rust `or_else`.
+*/
+function orElse(result, fn) {
+	if (result.isOk()) return result;
+	if (result.isErr()) return fn(result.error);
+	throw new require_errors.InvalidResultStateError("orElse");
+}
+
+//#endregion
+//#region src/core/mapOr.ts
+/**
+* Transforms the value or returns a default value.
+* Corresponds to Rust `map_or`.
+*/
+function mapOr(result, defaultValue, fn) {
+	if (result.isOk()) return fn(result.value);
+	if (result.isErr()) return defaultValue;
+	throw new require_errors.InvalidResultStateError("mapOr");
+}
+
+//#endregion
+//#region src/core/mapOrElse.ts
+/**
+* Transforms the value or calculates a default value using a function.
+* Corresponds to Rust `map_or_else`.
+*/
+function mapOrElse(result, defaultFn, fn) {
+	if (result.isOk()) return fn(result.value);
+	if (result.isErr()) return defaultFn(result.error);
+	throw new require_errors.InvalidResultStateError("mapOrElse");
+}
+
+//#endregion
+//#region src/core/swap.ts
+/**
+* Swaps Ok and Err.
+* Result<T, E> → Result<E, T>
+*/
+function swap(result) {
+	if (result.isOk()) return require_result.err(result.value);
+	if (result.isErr()) return require_result.ok(result.error);
+	throw new require_errors.InvalidResultStateError("swap");
+}
+
+//#endregion
+exports.and = and;
+exports.bimap = bimap;
 exports.combine = require_result.combine;
-exports.filter = require_swap.filter;
-exports.filterAsync = require_swap.filterAsync;
-exports.flatMap = require_swap.flatMap;
-exports.flatMapAsync = require_swap.flatMapAsync;
-exports.fold = require_swap.fold;
-exports.foldAsync = require_swap.foldAsync;
-exports.map = require_swap.map;
-exports.mapAsync = require_swap.mapAsync;
-exports.mapBoth = require_swap.mapBoth;
-exports.mapErr = require_swap.mapErr;
-exports.mapErrAsync = require_swap.mapErrAsync;
-exports.mapOr = require_swap.mapOr;
-exports.mapOrElse = require_swap.mapOrElse;
-exports.match = require_swap.match;
-exports.matchAsync = require_swap.matchAsync;
-exports.or = require_swap.or;
-exports.orElse = require_swap.orElse;
-exports.recover = require_swap.recover;
-exports.recoverWith = require_swap.recoverWith;
-exports.swap = require_swap.swap;
-exports.tap = require_swap.tap;
-exports.tapAsync = require_swap.tapAsync;
-exports.tryCatch = require_swap.tryCatch;
-exports.tryCatchAsync = require_swap.tryCatchAsync;
-exports.tryMap = require_swap.tryMap;
-exports.tryMapAsync = require_swap.tryMapAsync;
-exports.zip = require_result.zip;
+exports.filter = filter;
+exports.filterAsync = filterAsync;
+exports.flatMap = flatMap;
+exports.flatMapAsync = flatMapAsync;
+exports.fold = fold;
+exports.foldAsync = foldAsync;
+exports.map = map;
+exports.mapAsync = mapAsync;
+exports.mapBoth = mapBoth;
+exports.mapErr = mapErr;
+exports.mapErrAsync = mapErrAsync;
+exports.mapOr = mapOr;
+exports.mapOrElse = mapOrElse;
+exports.match = match;
+exports.matchAsync = matchAsync;
+exports.or = or;
+exports.orElse = orElse;
+exports.recover = recover;
+exports.recoverWith = recoverWith;
+exports.swap = swap;
+exports.tap = tap;
+exports.tapAsync = tapAsync;
+exports.tryCatch = tryCatch;
+exports.tryCatchAsync = tryCatchAsync;
+exports.tryMap = tryMap;
+exports.tryMapAsync = tryMapAsync;
+exports.zip = require_result.zip;
+//# sourceMappingURL=operators.cjs.map

package/dist/operators.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.cjs","names":["ok","InvalidResultStateError","err","InvalidResultStateError","ok","err","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","err","InvalidResultStateError","InvalidResultStateError","ok","err","InvalidResultStateError","ok","err","ok","InvalidResultStateError","InvalidResultStateError","ok","InvalidResultStateError","err","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","err","InvalidResultStateError","InvalidResultStateError","ok","err","InvalidResultStateError","ok","err","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","err","ok","InvalidResultStateError"],"sources":["../src/core/map.ts","../src/core/mapErr.ts","../src/core/mapBoth.ts","../src/core/flatMap.ts","../src/core/tap.ts","../src/core/filter.ts","../src/core/fold.ts","../src/core/tryCatch.ts","../src/core/tryMap.ts","../src/core/recover.ts","../src/core/match.ts","../src/core/mapAsync.ts","../src/core/mapErrAsync.ts","../src/core/flatMapAsync.ts","../src/core/tapAsync.ts","../src/core/filterAsync.ts","../src/core/foldAsync.ts","../src/core/tryCatchAsync.ts","../src/core/tryMapAsync.ts","../src/core/matchAsync.ts","../src/core/and.ts","../src/core/or.ts","../src/core/orElse.ts","../src/core/mapOr.ts","../src/core/mapOrElse.ts","../src/core/swap.ts"],"sourcesContent":["import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms the value (Ok case).\n * Corresponds to Rust `map`.\n */\nexport function map<T, E, U>(project: (value: T) => U) {\n    return (source: Result<T, E>): Result<U, E> => {\n        if (source.isOk()) {\n            return ok(project(source.value));\n        }\n        if (source.isErr()) return source as unknown as Result<U, E>;\n        throw new InvalidResultStateError('map');\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms the error (Err case).\n * Corresponds to Rust `map_err`.\n */\nexport function mapErr<T, E, F>(project: (error: E) => F) {\n    return (source: Result<T, E>): Result<T, F> => {\n        if (source.isErr()) {\n            return err(project(source.error));\n        }\n        if (source.isOk()) return source as unknown as Result<T, F>;\n        throw new InvalidResultStateError('mapErr');\n    };\n}\n","import type { Result } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms both the Ok value and the Err error.\n * Corresponds to FP `bimap` / `mapBoth`.\n */\nexport function mapBoth<T, E, U, F>(mapOk: (value: T) => U, mapErr: (error: E) => F) {\n    return (source: Result<T, E>): Result<U, F> => {\n        if (source.isOk()) {\n            return ok<U, F>(mapOk(source.value));\n        }\n        if (source.isErr()) {\n            return err<F, U>(mapErr(source.error));\n        }\n        throw new InvalidResultStateError('mapBoth');\n    };\n}\n\n/**\n * Alias for `mapBoth`.\n */\nexport const bimap: typeof mapBoth = mapBoth;\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Chains another operation that returns a Result.\n * Corresponds to Rust `and_then` or JS `flatMap`.\n */\nexport function flatMap<T, E, U, F>(project: (value: T) => Result<U, F>) {\n    return (source: Result<T, E>): Result<U, E | F> => {\n        if (source.isOk()) {\n            return project(source.value);\n        }\n        if (source.isErr()) return source as unknown as Result<U, E | F>;\n        throw new InvalidResultStateError('flatMap');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Executes a side effect (logging, debugging) without changing the Result.\n * Corresponds to Rust `inspect` / `inspect_err`.\n */\nexport function tap<T, E>(observer: { ok?: (val: T) => void; err?: (e: E) => void }) {\n    return (source: Result<T, E>): Result<T, E> => {\n        if (source.isOk()) {\n            if (observer.ok) observer.ok(source.value);\n            return source;\n        }\n        if (source.isErr()) {\n            if (observer.err) observer.err(source.error);\n            return source;\n        }\n        throw new InvalidResultStateError('tap');\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks a condition. If false, the Result becomes Err.\n * Corresponds to Rust `filter` (partially).\n */\nexport function filter<T, E>(predicate: (val: T) => boolean, errorFn: () => E) {\n    return (source: Result<T, E>): Result<T, E> => {\n        if (source.isOk()) {\n            if (predicate(source.value)) {\n                return source;\n            }\n            return err(errorFn());\n        }\n        if (source.isErr()) return source;\n        throw new InvalidResultStateError('filter');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Folds the Result into a single value by applying one of two functions.\n * The end of the pipe.\n *\n * This is the pipe operator equivalent of the `.fold()` instance method.\n */\nexport function fold<T, E, R>(handlers: { ok: (val: T) => R; err: (e: E) => R }) {\n    return (source: Result<T, E>): R => {\n        if (source.isOk()) {\n            return handlers.ok(source.value);\n        }\n        if (source.isErr()) return handlers.err(source.error);\n        throw new InvalidResultStateError('fold');\n    };\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\n\n/**\n * Executes a function and catches exceptions.\n * Converts exceptions into Result<E>.\n * Corresponds to Rust `Result::from` for fallible operations.\n */\nexport function tryCatch<T>(fn: () => T): <SE>(source: Result<unknown, SE>) => Result<T, unknown>;\nexport function tryCatch<T, E>(\n    fn: () => T,\n    errorMapper: (error: unknown) => E\n): <SE>(source: Result<unknown, SE>) => Result<T, SE | E>;\nexport function tryCatch<T, E>(\n    fn: () => T,\n    errorMapper?: (error: unknown) => E\n): <SE>(source: Result<unknown, SE>) => Result<T, SE | E> {\n    return <SE>(source: Result<unknown, SE>): Result<T, SE | E> => {\n        if (source.isErr()) return source as unknown as Result<T, SE | E>;\n\n        try {\n            return ok<T, SE | E>(fn());\n        } catch (error) {\n            return err<SE | E, T>(errorMapper ? errorMapper(error) : error as E);\n        }\n    };\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Like `map`, but catches exceptions and converts them to Err.\n */\nexport function tryMap<T, E, U>(project: (value: T) => U): (source: Result<T, E>) => Result<U, unknown>;\nexport function tryMap<T, E, U, F>(\n    project: (value: T) => U,\n    errorMapper: (error: unknown) => F\n): (source: Result<T, E>) => Result<U, E | F>;\nexport function tryMap<T, E, U, F>(\n    project: (value: T) => U,\n    errorMapper?: (error: unknown) => F\n): (source: Result<T, E>) => Result<U, E | F> {\n    return (source: Result<T, E>): Result<U, E | F> => {\n        if (source.isErr()) {\n            return source as unknown as Result<U, E | F>;\n        }\n        if (!source.isOk()) throw new InvalidResultStateError('tryMap');\n\n        try {\n            return ok<U, E | F>(project(source.value));\n        } catch (error) {\n            return err<E | F, U>(errorMapper ? errorMapper(error) : error as F);\n        }\n    };\n}\n","import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Recover: converts Err to Ok(defaultValue).\n * Result is guaranteed to be Ok → Error type becomes `never`.\n */\nexport function recover<T, E, F>(defaultValue: F) {\n    return (source: Result<T, E>): Result<T | F, never> => {\n        if (source.isOk()) return source as unknown as Result<T | F, never>;\n        if (source.isErr()) return ok(defaultValue);\n        throw new InvalidResultStateError('recover');\n    };\n}\n\n/**\n * Like `recover`, but calculates the default value based on the error.\n */\nexport function recoverWith<T, E, F>(fn: (error: E) => F) {\n    return (source: Result<T, E>): Result<T | F, never> => {\n        if (source.isOk()) return source as unknown as Result<T | F, never>;\n        if (source.isErr()) return ok(fn(source.error));\n        throw new InvalidResultStateError('recoverWith');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Resolves the Result. The end of the pipe.\n * Corresponds to Rust `match`.\n */\nexport function match<T, E, R>(handlers: { ok: (val: T) => R; err: (e: E) => R }) {\n    return (source: Result<T, E>): R => {\n        if (source.isOk()) {\n            return handlers.ok(source.value);\n        }\n        if (source.isErr()) return handlers.err(source.error);\n        throw new InvalidResultStateError('match');\n    };\n}\n","import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of map.\n */\nexport function mapAsync<T, E, U>(project: (value: T) => Promise<U>) {\n    return async (source: Result<T, E>): Promise<Result<U, E>> => {\n        if (source.isOk()) {\n            return ok(await project(source.value));\n        }\n        if (source.isErr()) return source as unknown as Result<U, E>;\n        throw new InvalidResultStateError('mapAsync');\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of mapErr.\n */\nexport function mapErrAsync<T, E, F>(project: (error: E) => Promise<F>) {\n    return async (source: Result<T, E>): Promise<Result<T, F>> => {\n        if (source.isErr()) {\n            return err(await project(source.error));\n        }\n        if (source.isOk()) return source as unknown as Result<T, F>;\n        throw new InvalidResultStateError('mapErrAsync');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of flatMap.\n */\nexport function flatMapAsync<T, E, U, F>(project: (value: T) => Promise<Result<U, F>>) {\n    return async (source: Result<T, E>): Promise<Result<U, E | F>> => {\n        if (source.isOk()) {\n            return await project(source.value);\n        }\n        if (source.isErr()) return source as unknown as Result<U, E | F>;\n        throw new InvalidResultStateError('flatMapAsync');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of tap.\n */\nexport function tapAsync<T, E>(observer: { ok?: (val: T) => Promise<void>; err?: (e: E) => Promise<void> }) {\n    return async (source: Result<T, E>): Promise<Result<T, E>> => {\n        if (source.isOk()) {\n            if (observer.ok) await observer.ok(source.value);\n            return source;\n        }\n        if (source.isErr()) {\n            if (observer.err) await observer.err(source.error);\n            return source;\n        }\n        throw new InvalidResultStateError('tapAsync');\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of filter.\n */\nexport function filterAsync<T, E>(predicate: (val: T) => Promise<boolean>, errorFn: () => Promise<E>) {\n    return async (source: Result<T, E>): Promise<Result<T, E>> => {\n        if (source.isOk()) {\n            if (await predicate(source.value)) {\n                return source;\n            }\n            return err(await errorFn());\n        }\n        if (source.isErr()) return source;\n        throw new InvalidResultStateError('filterAsync');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of `fold`. Folds the Result into a single value asynchronously.\n * The end of the pipe.\n *\n * This is the async pipe operator equivalent of the `.fold()` instance method.\n */\nexport function foldAsync<T, E, R>(handlers: { ok: (val: T) => Promise<R>; err: (e: E) => Promise<R> }) {\n    return async (source: Result<T, E>): Promise<R> => {\n        if (source.isOk()) {\n            return await handlers.ok(source.value);\n        }\n        if (source.isErr()) return await handlers.err(source.error);\n        throw new InvalidResultStateError('foldAsync');\n    };\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\n\n/**\n * Async version of tryCatch.\n */\nexport function tryCatchAsync<T>(fn: () => Promise<T>): <SE>(source: Result<unknown, SE>) => Promise<Result<T, unknown>>;\nexport function tryCatchAsync<T, E>(\n    fn: () => Promise<T>,\n    errorMapper: (error: unknown) => E\n): <SE>(source: Result<unknown, SE>) => Promise<Result<T, SE | E>>;\nexport function tryCatchAsync<T, E>(\n    fn: () => Promise<T>,\n    errorMapper?: (error: unknown) => E\n): <SE>(source: Result<unknown, SE>) => Promise<Result<T, SE | E>> {\n    return async <SE>(source: Result<unknown, SE>): Promise<Result<T, SE | E>> => {\n        if (source.isErr()) return source as unknown as Result<T, SE | E>;\n\n        try {\n            return ok<T, SE | E>(await fn());\n        } catch (error) {\n            return err<SE | E, T>(errorMapper ? errorMapper(error) : error as E);\n        }\n    };\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of tryMap.\n */\nexport function tryMapAsync<T, E, U>(project: (value: T) => Promise<U>): (source: Result<T, E>) => Promise<Result<U, unknown>>;\nexport function tryMapAsync<T, E, U, F>(\n    project: (value: T) => Promise<U>,\n    errorMapper: (error: unknown) => F\n): (source: Result<T, E>) => Promise<Result<U, E | F>>;\nexport function tryMapAsync<T, E, U, F>(\n    project: (value: T) => Promise<U>,\n    errorMapper?: (error: unknown) => F\n): (source: Result<T, E>) => Promise<Result<U, E | F>> {\n    return async (source: Result<T, E>): Promise<Result<U, E | F>> => {\n        if (source.isErr()) {\n            return source as unknown as Result<U, E | F>;\n        }\n        if (!source.isOk()) throw new InvalidResultStateError('tryMapAsync');\n\n        try {\n            return ok<U, E | F>(await project(source.value));\n        } catch (error) {\n            return err<E | F, U>(errorMapper ? errorMapper(error) : error as F);\n        }\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of match.\n */\nexport function matchAsync<T, E, R>(handlers: { ok: (val: T) => Promise<R>; err: (e: E) => Promise<R> }) {\n    return async (source: Result<T, E>): Promise<R> => {\n        if (source.isOk()) {\n            return await handlers.ok(source.value);\n        }\n        if (source.isErr()) return await handlers.err(source.error);\n        throw new InvalidResultStateError('matchAsync');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Combines two Results. Returns the second one only if the first is Ok.\n * Corresponds to Rust `and`.\n */\nexport function and<T, E, U>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n    if (result.isOk()) return other;\n    if (result.isErr()) return result as unknown as Result<U, E>;\n    throw new InvalidResultStateError('and');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Fallback to another Result if the first is Err.\n * Corresponds to Rust `or`.\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n    if (result.isOk()) return result as unknown as Result<T, F>;\n    if (result.isErr()) return other;\n    throw new InvalidResultStateError('or');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Fallback with a function that returns a Result.\n * Corresponds to Rust `or_else`.\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n    if (result.isOk()) return result as unknown as Result<T, F>;\n    if (result.isErr()) return fn(result.error);\n    throw new InvalidResultStateError('orElse');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms the value or returns a default value.\n * Corresponds to Rust `map_or`.\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n    if (result.isOk()) return fn(result.value);\n    if (result.isErr()) return defaultValue;\n    throw new InvalidResultStateError('mapOr');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms the value or calculates a default value using a function.\n * Corresponds to Rust `map_or_else`.\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: (error: E) => U, fn: (value: T) => U): U {\n    if (result.isOk()) return fn(result.value);\n    if (result.isErr()) return defaultFn(result.error);\n    throw new InvalidResultStateError('mapOrElse');\n}\n","import type { Result } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Swaps Ok and Err.\n * Result<T, E> → Result<E, T>\n */\nexport function swap<T, E>(result: Result<T, E>): Result<E, T> {\n    if (result.isOk()) {\n        return err<T, E>(result.value);\n    }\n    if (result.isErr()) {\n        return ok<E, T>(result.error);\n    }\n    throw new InvalidResultStateError('swap');\n}\n"],"mappings":";;;;;;;;;AAQA,SAAgB,IAAa,SAA0B;CACnD,QAAQ,WAAuC;EAC3C,IAAI,OAAO,KAAK,GACZ,OAAOA,kBAAG,QAAQ,OAAO,KAAK,CAAC;EAEnC,IAAI,OAAO,MAAM,GAAG,OAAO;EAC3B,MAAM,IAAIC,uCAAwB,KAAK;CAC3C;AACJ;;;;;;;;ACRA,SAAgB,OAAgB,SAA0B;CACtD,QAAQ,WAAuC;EAC3C,IAAI,OAAO,MAAM,GACb,OAAOC,mBAAI,QAAQ,OAAO,KAAK,CAAC;EAEpC,IAAI,OAAO,KAAK,GAAG,OAAO;EAC1B,MAAM,IAAIC,uCAAwB,QAAQ;CAC9C;AACJ;;;;;;;;ACRA,SAAgB,QAAoB,OAAwB,QAAyB;CACjF,QAAQ,WAAuC;EAC3C,IAAI,OAAO,KAAK,GACZ,OAAOC,kBAAS,MAAM,OAAO,KAAK,CAAC;EAEvC,IAAI,OAAO,MAAM,GACb,OAAOC,mBAAU,OAAO,OAAO,KAAK,CAAC;EAEzC,MAAM,IAAIC,uCAAwB,SAAS;CAC/C;AACJ;;;;AAKA,MAAa,QAAwB;;;;;;;;AChBrC,SAAgB,QAAoB,SAAqC;CACrE,QAAQ,WAA2C;EAC/C,IAAI,OAAO,KAAK,GACZ,OAAO,QAAQ,OAAO,KAAK;EAE/B,IAAI,OAAO,MAAM,GAAG,OAAO;EAC3B,MAAM,IAAIC,uCAAwB,SAAS;CAC/C;AACJ;;;;;;;;ACRA,SAAgB,IAAU,UAA2D;CACjF,QAAQ,WAAuC;EAC3C,IAAI,OAAO,KAAK,GAAG;GACf,IAAI,SAAS,IAAI,SAAS,GAAG,OAAO,KAAK;GACzC,OAAO;EACX;EACA,IAAI,OAAO,MAAM,GAAG;GAChB,IAAI,SAAS,KAAK,SAAS,IAAI,OAAO,KAAK;GAC3C,OAAO;EACX;EACA,MAAM,IAAIC,uCAAwB,KAAK;CAC3C;AACJ;;;;;;;;ACXA,SAAgB,OAAa,WAAgC,SAAkB;CAC3E,QAAQ,WAAuC;EAC3C,IAAI,OAAO,KAAK,GAAG;GACf,IAAI,UAAU,OAAO,KAAK,GACtB,OAAO;GAEX,OAAOC,mBAAI,QAAQ,CAAC;EACxB;EACA,IAAI,OAAO,MAAM,GAAG,OAAO;EAC3B,MAAM,IAAIC,uCAAwB,QAAQ;CAC9C;AACJ;;;;;;;;;;ACVA,SAAgB,KAAc,UAAmD;CAC7E,QAAQ,WAA4B;EAChC,IAAI,OAAO,KAAK,GACZ,OAAO,SAAS,GAAG,OAAO,KAAK;EAEnC,IAAI,OAAO,MAAM,GAAG,OAAO,SAAS,IAAI,OAAO,KAAK;EACpD,MAAM,IAAIC,uCAAwB,MAAM;CAC5C;AACJ;;;;ACJA,SAAgB,SACZ,IACA,aACsD;CACtD,QAAY,WAAmD;EAC3D,IAAI,OAAO,MAAM,GAAG,OAAO;EAE3B,IAAI;GACA,OAAOC,kBAAc,GAAG,CAAC;EAC7B,SAAS,OAAO;GACZ,OAAOC,mBAAe,cAAc,YAAY,KAAK,IAAI,KAAU;EACvE;CACJ;AACJ;;;;ACdA,SAAgB,OACZ,SACA,aAC0C;CAC1C,QAAQ,WAA2C;EAC/C,IAAI,OAAO,MAAM,GACb,OAAO;EAEX,IAAI,CAAC,OAAO,KAAK,GAAG,MAAM,IAAIC,uCAAwB,QAAQ;EAE9D,IAAI;GACA,OAAOC,kBAAa,QAAQ,OAAO,KAAK,CAAC;EAC7C,SAAS,OAAO;GACZ,OAAOC,mBAAc,cAAc,YAAY,KAAK,IAAI,KAAU;EACtE;CACJ;AACJ;;;;;;;;ACpBA,SAAgB,QAAiB,cAAiB;CAC9C,QAAQ,WAA+C;EACnD,IAAI,OAAO,KAAK,GAAG,OAAO;EAC1B,IAAI,OAAO,MAAM,GAAG,OAAOC,kBAAG,YAAY;EAC1C,MAAM,IAAIC,uCAAwB,SAAS;CAC/C;AACJ;;;;AAKA,SAAgB,YAAqB,IAAqB;CACtD,QAAQ,WAA+C;EACnD,IAAI,OAAO,KAAK,GAAG,OAAO;EAC1B,IAAI,OAAO,MAAM,GAAG,OAAOD,kBAAG,GAAG,OAAO,KAAK,CAAC;EAC9C,MAAM,IAAIC,uCAAwB,aAAa;CACnD;AACJ;;;;;;;;AClBA,SAAgB,MAAe,UAAmD;CAC9E,QAAQ,WAA4B;EAChC,IAAI,OAAO,KAAK,GACZ,OAAO,SAAS,GAAG,OAAO,KAAK;EAEnC,IAAI,OAAO,MAAM,GAAG,OAAO,SAAS,IAAI,OAAO,KAAK;EACpD,MAAM,IAAIC,uCAAwB,OAAO;CAC7C;AACJ;;;;;;;ACRA,SAAgB,SAAkB,SAAmC;CACjE,OAAO,OAAO,WAAgD;EAC1D,IAAI,OAAO,KAAK,GACZ,OAAOC,kBAAG,MAAM,QAAQ,OAAO,KAAK,CAAC;EAEzC,IAAI,OAAO,MAAM,GAAG,OAAO;EAC3B,MAAM,IAAIC,uCAAwB,UAAU;CAChD;AACJ;;;;;;;ACRA,SAAgB,YAAqB,SAAmC;CACpE,OAAO,OAAO,WAAgD;EAC1D,IAAI,OAAO,MAAM,GACb,OAAOC,mBAAI,MAAM,QAAQ,OAAO,KAAK,CAAC;EAE1C,IAAI,OAAO,KAAK,GAAG,OAAO;EAC1B,MAAM,IAAIC,uCAAwB,aAAa;CACnD;AACJ;;;;;;;ACTA,SAAgB,aAAyB,SAA8C;CACnF,OAAO,OAAO,WAAoD;EAC9D,IAAI,OAAO,KAAK,GACZ,OAAO,MAAM,QAAQ,OAAO,KAAK;EAErC,IAAI,OAAO,MAAM,GAAG,OAAO;EAC3B,MAAM,IAAIC,uCAAwB,cAAc;CACpD;AACJ;;;;;;;ACRA,SAAgB,SAAe,UAA6E;CACxG,OAAO,OAAO,WAAgD;EAC1D,IAAI,OAAO,KAAK,GAAG;GACf,IAAI,SAAS,IAAI,MAAM,SAAS,GAAG,OAAO,KAAK;GAC/C,OAAO;EACX;EACA,IAAI,OAAO,MAAM,GAAG;GAChB,IAAI,SAAS,KAAK,MAAM,SAAS,IAAI,OAAO,KAAK;GACjD,OAAO;EACX;EACA,MAAM,IAAIC,uCAAwB,UAAU;CAChD;AACJ;;;;;;;ACXA,SAAgB,YAAkB,WAAyC,SAA2B;CAClG,OAAO,OAAO,WAAgD;EAC1D,IAAI,OAAO,KAAK,GAAG;GACf,IAAI,MAAM,UAAU,OAAO,KAAK,GAC5B,OAAO;GAEX,OAAOC,mBAAI,MAAM,QAAQ,CAAC;EAC9B;EACA,IAAI,OAAO,MAAM,GAAG,OAAO;EAC3B,MAAM,IAAIC,uCAAwB,aAAa;CACnD;AACJ;;;;;;;;;;ACTA,SAAgB,UAAmB,UAAqE;CACpG,OAAO,OAAO,WAAqC;EAC/C,IAAI,OAAO,KAAK,GACZ,OAAO,MAAM,SAAS,GAAG,OAAO,KAAK;EAEzC,IAAI,OAAO,MAAM,GAAG,OAAO,MAAM,SAAS,IAAI,OAAO,KAAK;EAC1D,MAAM,IAAIC,uCAAwB,WAAW;CACjD;AACJ;;;;ACNA,SAAgB,cACZ,IACA,aAC+D;CAC/D,OAAO,OAAW,WAA4D;EAC1E,IAAI,OAAO,MAAM,GAAG,OAAO;EAE3B,IAAI;GACA,OAAOC,kBAAc,MAAM,GAAG,CAAC;EACnC,SAAS,OAAO;GACZ,OAAOC,mBAAe,cAAc,YAAY,KAAK,IAAI,KAAU;EACvE;CACJ;AACJ;;;;ACZA,SAAgB,YACZ,SACA,aACmD;CACnD,OAAO,OAAO,WAAoD;EAC9D,IAAI,OAAO,MAAM,GACb,OAAO;EAEX,IAAI,CAAC,OAAO,KAAK,GAAG,MAAM,IAAIC,uCAAwB,aAAa;EAEnE,IAAI;GACA,OAAOC,kBAAa,MAAM,QAAQ,OAAO,KAAK,CAAC;EACnD,SAAS,OAAO;GACZ,OAAOC,mBAAc,cAAc,YAAY,KAAK,IAAI,KAAU;EACtE;CACJ;AACJ;;;;;;;ACtBA,SAAgB,WAAoB,UAAqE;CACrG,OAAO,OAAO,WAAqC;EAC/C,IAAI,OAAO,KAAK,GACZ,OAAO,MAAM,SAAS,GAAG,OAAO,KAAK;EAEzC,IAAI,OAAO,MAAM,GAAG,OAAO,MAAM,SAAS,IAAI,OAAO,KAAK;EAC1D,MAAM,IAAIC,uCAAwB,YAAY;CAClD;AACJ;;;;;;;;ACPA,SAAgB,IAAa,QAAsB,OAAmC;CAClF,IAAI,OAAO,KAAK,GAAG,OAAO;CAC1B,IAAI,OAAO,MAAM,GAAG,OAAO;CAC3B,MAAM,IAAIC,uCAAwB,KAAK;AAC3C;;;;;;;;ACJA,SAAgB,GAAY,QAAsB,OAAmC;CACjF,IAAI,OAAO,KAAK,GAAG,OAAO;CAC1B,IAAI,OAAO,MAAM,GAAG,OAAO;CAC3B,MAAM,IAAIC,uCAAwB,IAAI;AAC1C;;;;;;;;ACJA,SAAgB,OAAgB,QAAsB,IAA8C;CAChG,IAAI,OAAO,KAAK,GAAG,OAAO;CAC1B,IAAI,OAAO,MAAM,GAAG,OAAO,GAAG,OAAO,KAAK;CAC1C,MAAM,IAAIC,uCAAwB,QAAQ;AAC9C;;;;;;;;ACJA,SAAgB,MAAe,QAAsB,cAAiB,IAAwB;CAC1F,IAAI,OAAO,KAAK,GAAG,OAAO,GAAG,OAAO,KAAK;CACzC,IAAI,OAAO,MAAM,GAAG,OAAO;CAC3B,MAAM,IAAIC,uCAAwB,OAAO;AAC7C;;;;;;;;ACJA,SAAgB,UAAmB,QAAsB,WAA4B,IAAwB;CACzG,IAAI,OAAO,KAAK,GAAG,OAAO,GAAG,OAAO,KAAK;CACzC,IAAI,OAAO,MAAM,GAAG,OAAO,UAAU,OAAO,KAAK;CACjD,MAAM,IAAIC,uCAAwB,WAAW;AACjD;;;;;;;;ACHA,SAAgB,KAAW,QAAoC;CAC3D,IAAI,OAAO,KAAK,GACZ,OAAOC,mBAAU,OAAO,KAAK;CAEjC,IAAI,OAAO,MAAM,GACb,OAAOC,kBAAS,OAAO,KAAK;CAEhC,MAAM,IAAIC,uCAAwB,MAAM;AAC5C"}