@shirudo/result 1.0.1 → 1.1.0

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["input: unknown","step: IteratorResult<Y, R>"],"sources":["../src/gen.ts","../src/core/unwrap.ts","../src/core/unwrapOr.ts","../src/core/unwrapOrElse.ts","../src/core/unwrapOrDefault.ts","../src/core/unwrapOrThrow.ts","../src/core/unwrapErr.ts","../src/core/expectResult.ts","../src/core/expectErr.ts","../src/core/toPromise.ts","../src/core/toNullable.ts","../src/core/isOk.ts","../src/core/isErr.ts","../src/core/contains.ts","../src/core/containsErr.ts"],"sourcesContent":["import type { Result } from './core/result';\nimport { err, ok } from './core/result';\nimport { isResult } from './core/isResult';\nimport { InvalidResultStateError, TaskYieldNotResultError } from './errors';\n\ntype AnyGenerator<Y = unknown, R = unknown, N = unknown> = Generator<Y, R, N> | AsyncGenerator<Y, R, N>;\n\ntype ErrorOfYield<Y> = Y extends Result<any, infer E> ? E : never;\n\ntype OnThrow<E> = (error: unknown) => E;\n\ntype AwaitedReturn<R> = Awaited<R>;\ntype OkOfReturn<R> = AwaitedReturn<R> extends Result<infer T, any> ? T : AwaitedReturn<R>;\ntype ErrOfReturn<R> = AwaitedReturn<R> extends Result<any, infer E> ? E : never;\n\n/**\n * Generator-based do-notation for `Result`.\n *\n * Usage:\n * ```ts\n * const out = await task(async function* () {\n *   const user = yield* await fromPromise(findUser(1));\n *   const email = yield* validate(user.email);\n *   return email;\n * });\n * ```\n */\nexport async function task<const Y, const R>(\n    makeGenerator: () => AnyGenerator<Y, R, unknown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R>>>;\nexport async function task<const Y, const R, EThrown>(\n    makeGenerator: () => AnyGenerator<Y, R, unknown>,\n    onThrow: OnThrow<EThrown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>>;\nexport async function task<const Y, const R, EThrown>(\n    makeGenerator: () => AnyGenerator<Y, R, unknown>,\n    onThrow?: OnThrow<EThrown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>> {\n    const iterator = makeGenerator();\n    let input: unknown = undefined;\n\n    while (true) {\n        let step: IteratorResult<Y, R>;\n        try {\n            step = await iterator.next(input);\n        } catch (caught) {\n            if (!onThrow) throw caught;\n            return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n        }\n\n        if (step.done) {\n            try {\n                const awaited = await step.value;\n                if (isResult(awaited)) {\n                    return awaited as Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>;\n                }\n                return ok<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>(awaited as OkOfReturn<R>);\n            } catch (caught) {\n                if (!onThrow) throw caught;\n                return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n            }\n        }\n\n        const yielded = step.value as unknown;\n        if (!isResult(yielded)) {\n            throw new TaskYieldNotResultError(yielded);\n        }\n\n        if (yielded.isOk()) {\n            input = yielded.value;\n            continue;\n        }\n\n        if (yielded.isErr()) {\n            try {\n                if (typeof iterator.return === 'function') {\n                    await iterator.return(undefined as unknown as R);\n                }\n            } catch (caught) {\n                if (!onThrow) throw caught;\n                return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n            }\n\n            return yielded as Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>;\n        }\n\n        throw new InvalidResultStateError('task');\n    }\n}\n\nexport const gen = task;\n","import type { Result } from './result';\nimport { InvalidResultStateError, UnwrapOnErrError } from '../errors';\n\n/**\n * Returns the value or throws an Error.\n * Corresponds to Rust `unwrap`.\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n    if (result.isOk()) {\n        return result.value;\n    }\n    if (result.isErr()) throw new UnwrapOnErrError(result.error);\n    throw new InvalidResultStateError('unwrap');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or a default value.\n * Pure function alternative to the instance method.\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) return defaultValue;\n    throw new InvalidResultStateError('unwrapOr');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or calculates a default value using a function.\n * Corresponds to Rust `unwrap_or_else`.\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) return fn(result.error);\n    throw new InvalidResultStateError('unwrapOrElse');\n}\n","import type { Result } from './result';\nimport { unwrapOr } from './unwrapOr';\n\n/**\n * Alias for `unwrapOr`.\n * Corresponds to Rust `unwrap_or_default` (with explicit default value).\n */\nexport function unwrapOrDefault<T, E>(result: Result<T, E>, defaultValue: T): T {\n    return unwrapOr(result, defaultValue);\n}\n\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or throws the original Err value (not wrapped).\n * Useful to preserve `Error` instances including stack traces.\n */\nexport function unwrapOrThrow<T, E>(result: Result<T, E>): T {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) throw result.error;\n    throw new InvalidResultStateError('unwrapOrThrow');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError, UnwrapErrOnOkError } from '../errors';\n\n/**\n * Returns the error or throws an Error.\n * Corresponds to Rust `unwrap_err`.\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n    if (result.isErr()) {\n        return result.error;\n    }\n    if (result.isOk()) throw new UnwrapErrOnOkError(result.value);\n    throw new InvalidResultStateError('unwrapErr');\n}\n","import type { Result } from './result';\nimport { ExpectOkError, InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or throws an Error with a custom message.\n * Corresponds to Rust `expect`.\n */\nexport function expectResult<T, E>(result: Result<T, E>, message: string): T {\n    if (result.isOk()) {\n        return result.value;\n    }\n    if (result.isErr()) {\n        throw new ExpectOkError(message);\n    }\n    throw new InvalidResultStateError('expectResult');\n}\n","import type { Result } from './result';\nimport { ExpectErrError, InvalidResultStateError } from '../errors';\n\n/**\n * Returns the error or throws an Error with a custom message.\n * Corresponds to Rust `expect_err`.\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n    if (result.isErr()) {\n        return result.error;\n    }\n    if (result.isOk()) {\n        throw new ExpectErrError(message);\n    }\n    throw new InvalidResultStateError('expectErr');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Converts a Result to a Promise.\n * Ok → resolve(value), Err → reject(error)\n */\nexport function toPromise<T, E>(result: Result<T, E>): Promise<T> {\n    if (result.isOk()) {\n        return Promise.resolve(result.value);\n    }\n    if (result.isErr()) return Promise.reject(result.error);\n    throw new InvalidResultStateError('toPromise');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Converts a Result to `T | null`.\n * Ok → value, Err → null\n */\nexport function toNullable<T, E>(result: Result<T, E>): T | null {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) return null;\n    throw new InvalidResultStateError('toNullable');\n}\n","import type { Ok, Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if a Result is Ok.\n * Pure function alternative to the instance method.\n */\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T, E> {\n    if (result.isOk()) return true;\n    if (result.isErr()) return false;\n    throw new InvalidResultStateError('isOk');\n}\n","import type { Err, Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if a Result is Err.\n * Pure function alternative to the instance method.\n */\nexport function isErr<T, E>(result: Result<T, E>): result is Err<T, E> {\n    if (result.isErr()) return true;\n    if (result.isOk()) return false;\n    throw new InvalidResultStateError('isErr');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if the Result contains a specific value.\n * Corresponds to Rust `contains`.\n */\nexport function contains<T, E>(result: Result<T, E>, value: T): boolean {\n    if (result.isOk()) return result.value === value;\n    if (result.isErr()) return false;\n    throw new InvalidResultStateError('contains');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if the Result contains a specific error.\n * Analogous to `contains` for the Err case.\n */\nexport function containsErr<T, E>(result: Result<T, E>, error: E): boolean {\n    if (result.isErr()) return result.error === error;\n    if (result.isOk()) return false;\n    throw new InvalidResultStateError('containsErr');\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/gen.ts","../src/core/unwrap.ts","../src/core/unwrapOr.ts","../src/core/unwrapOrElse.ts","../src/core/unwrapOrDefault.ts","../src/core/unwrapOrThrow.ts","../src/core/unwrapErr.ts","../src/core/expectResult.ts","../src/core/expectErr.ts","../src/core/fromSerialized.ts","../src/core/toPromise.ts","../src/core/toNullable.ts","../src/core/isOk.ts","../src/core/isErr.ts","../src/core/contains.ts","../src/core/containsErr.ts"],"sourcesContent":["import type { Result } from './core/result';\nimport { err, ok } from './core/result';\nimport { isResult } from './core/isResult';\nimport { InvalidResultStateError, TaskYieldNotResultError } from './errors';\n\ntype AnyGenerator<Y = unknown, R = unknown, N = unknown> = Generator<Y, R, N> | AsyncGenerator<Y, R, N>;\n\ntype ErrorOfYield<Y> = Y extends Result<any, infer E> ? E : never;\n\ntype OnThrow<E> = (error: unknown) => E;\n\ntype AwaitedReturn<R> = Awaited<R>;\ntype OkOfReturn<R> = AwaitedReturn<R> extends Result<infer T, any> ? T : AwaitedReturn<R>;\ntype ErrOfReturn<R> = AwaitedReturn<R> extends Result<any, infer E> ? E : never;\n\n/**\n * Generator-based do-notation for `Result`.\n *\n * Usage:\n * ```ts\n * const out = await task(async function* () {\n *   const user = yield* await fromPromise(findUser(1));\n *   const email = yield* validate(user.email);\n *   return email;\n * });\n * ```\n */\nexport async function task<const Y, const R>(\n    makeGenerator: () => AnyGenerator<Y, R, unknown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R>>>;\nexport async function task<const Y, const R, EThrown>(\n    makeGenerator: () => AnyGenerator<Y, R, unknown>,\n    onThrow: OnThrow<EThrown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>>;\nexport async function task<const Y, const R, EThrown>(\n    makeGenerator: () => AnyGenerator<Y, R, unknown>,\n    onThrow?: OnThrow<EThrown>\n): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>> {\n    const iterator = makeGenerator();\n    let input: unknown = undefined;\n\n    // Resume the suspended generator as if it returned, so its `finally`\n    // blocks run before we abort the workflow (short-circuit or error path).\n    const runGeneratorReturn = async (): Promise<void> => {\n        if (typeof iterator.return !== 'function') return;\n        // A `yield` inside a `finally` block suspends the generator again\n        // ({done: false}). Resume with next() so the remaining cleanup code\n        // still runs — calling return() again would abort the rest of that\n        // finally block. The pending return completion ends the generator\n        // once all finally blocks have finished.\n        let step = await iterator.return(undefined as unknown as R);\n        while (!step.done) {\n            step = await iterator.next(undefined);\n        }\n    };\n\n    while (true) {\n        let step: IteratorResult<Y, R>;\n        try {\n            step = await iterator.next(input);\n        } catch (caught) {\n            if (!onThrow) throw caught;\n            return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n        }\n\n        if (step.done) {\n            try {\n                const awaited = await step.value;\n                if (isResult(awaited)) {\n                    return awaited as Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>;\n                }\n                return ok<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>(awaited as OkOfReturn<R>);\n            } catch (caught) {\n                if (!onThrow) throw caught;\n                return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n            }\n        }\n\n        const yielded = step.value as unknown;\n        if (!isResult(yielded)) {\n            try {\n                await runGeneratorReturn();\n            } catch (caught) {\n                if (!onThrow) throw caught;\n                return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n            }\n            throw new TaskYieldNotResultError(yielded);\n        }\n\n        if (yielded.isOk()) {\n            input = yielded.value;\n            continue;\n        }\n\n        if (yielded.isErr()) {\n            try {\n                await runGeneratorReturn();\n            } catch (caught) {\n                if (!onThrow) throw caught;\n                return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n            }\n\n            return yielded as Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>;\n        }\n\n        try {\n            await runGeneratorReturn();\n        } catch (caught) {\n            if (!onThrow) throw caught;\n            return err<ErrorOfYield<Y> | ErrOfReturn<R> | EThrown, OkOfReturn<R>>(onThrow(caught));\n        }\n        throw new InvalidResultStateError('task');\n    }\n}\n\nexport const gen: typeof task = task;\n","import type { Result } from './result';\nimport { InvalidResultStateError, UnwrapOnErrError } from '../errors';\n\n/**\n * Returns the value or throws an Error.\n * Corresponds to Rust `unwrap`.\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n    if (result.isOk()) {\n        return result.value;\n    }\n    if (result.isErr()) throw new UnwrapOnErrError(result.error);\n    throw new InvalidResultStateError('unwrap');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or a default value.\n * Pure function alternative to the instance method.\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) return defaultValue;\n    throw new InvalidResultStateError('unwrapOr');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or calculates a default value using a function.\n * Corresponds to Rust `unwrap_or_else`.\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) return fn(result.error);\n    throw new InvalidResultStateError('unwrapOrElse');\n}\n","import type { Result } from './result';\nimport { unwrapOr } from './unwrapOr';\n\n/**\n * Alias for `unwrapOr`.\n *\n * @deprecated Use {@link unwrapOr} instead. The name is misleading: Rust's\n * `unwrap_or_default` takes no argument (it uses the type's `Default`),\n * whereas this function requires an explicit default value — which is exactly\n * what `unwrapOr` does.\n */\nexport function unwrapOrDefault<T, E>(result: Result<T, E>, defaultValue: T): T {\n    return unwrapOr(result, defaultValue);\n}\n\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or throws the original Err value (not wrapped).\n * Useful to preserve `Error` instances including stack traces.\n */\nexport function unwrapOrThrow<T, E>(result: Result<T, E>): T {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) throw result.error;\n    throw new InvalidResultStateError('unwrapOrThrow');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError, UnwrapErrOnOkError } from '../errors';\n\n/**\n * Returns the error or throws an Error.\n * Corresponds to Rust `unwrap_err`.\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n    if (result.isErr()) {\n        return result.error;\n    }\n    if (result.isOk()) throw new UnwrapErrOnOkError(result.value);\n    throw new InvalidResultStateError('unwrapErr');\n}\n","import type { Result } from './result';\nimport { ExpectOkError, InvalidResultStateError } from '../errors';\n\n/**\n * Returns the value or throws an Error with a custom message.\n * Corresponds to Rust `expect`.\n */\nexport function expectResult<T, E>(result: Result<T, E>, message: string): T {\n    if (result.isOk()) {\n        return result.value;\n    }\n    if (result.isErr()) {\n        throw new ExpectOkError(message, result.error);\n    }\n    throw new InvalidResultStateError('expectResult');\n}\n","import type { Result } from './result';\nimport { ExpectErrError, InvalidResultStateError } from '../errors';\n\n/**\n * Returns the error or throws an Error with a custom message.\n * Corresponds to Rust `expect_err`.\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n    if (result.isErr()) {\n        return result.error;\n    }\n    if (result.isOk()) {\n        throw new ExpectErrError(message, result.value);\n    }\n    throw new InvalidResultStateError('expectErr');\n}\n","import type { Result, ResultType } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Rebuilds a `Result` from its serialized discriminated form\n * (`{ _tag: 'Ok', value }` / `{ _tag: 'Err', error }`), the shape produced\n * by `Result.toSerialized()` and by `JSON.stringify` on a Result.\n *\n * Throws `InvalidResultStateError` for data that is not in that shape.\n */\nexport function fromSerialized<T, E>(data: ResultType<T, E>): Result<T, E> {\n    if (data !== null && typeof data === 'object') {\n        if (data._tag === 'Ok' && 'value' in data) return ok<T, E>(data.value);\n        if (data._tag === 'Err' && 'error' in data) return err<E, T>(data.error);\n    }\n    throw new InvalidResultStateError('fromSerialized');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Converts a Result to a Promise.\n * Ok → resolve(value), Err → reject(error)\n */\nexport function toPromise<T, E>(result: Result<T, E>): Promise<T> {\n    if (result.isOk()) {\n        return Promise.resolve(result.value);\n    }\n    if (result.isErr()) return Promise.reject(result.error);\n    throw new InvalidResultStateError('toPromise');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Converts a Result to `T | null`.\n * Ok → value, Err → null\n */\nexport function toNullable<T, E>(result: Result<T, E>): T | null {\n    if (result.isOk()) return result.value;\n    if (result.isErr()) return null;\n    throw new InvalidResultStateError('toNullable');\n}\n","import type { Ok, Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if a Result is Ok.\n * Pure function alternative to the instance method.\n */\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T, E> {\n    if (result.isOk()) return true;\n    if (result.isErr()) return false;\n    throw new InvalidResultStateError('isOk');\n}\n","import type { Err, Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if a Result is Err.\n * Pure function alternative to the instance method.\n */\nexport function isErr<T, E>(result: Result<T, E>): result is Err<T, E> {\n    if (result.isErr()) return true;\n    if (result.isOk()) return false;\n    throw new InvalidResultStateError('isErr');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if the Result contains a specific value.\n * Corresponds to Rust `contains`.\n *\n * Comparison uses `Object.is` (SameValue): `NaN` matches `NaN`, `+0` and\n * `-0` are distinct, and objects are compared by reference.\n */\nexport function contains<T, E>(result: Result<T, E>, value: T): boolean {\n    if (result.isOk()) return Object.is(result.value, value);\n    if (result.isErr()) return false;\n    throw new InvalidResultStateError('contains');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks if the Result contains a specific error.\n * Analogous to `contains` for the Err case.\n *\n * Comparison uses `Object.is` (SameValue): `NaN` matches `NaN`, `+0` and\n * `-0` are distinct, and objects are compared by reference.\n */\nexport function containsErr<T, E>(result: Result<T, E>, error: E): boolean {\n    if (result.isErr()) return Object.is(result.error, error);\n    if (result.isOk()) return false;\n    throw new InvalidResultStateError('containsErr');\n}\n"],"mappings":"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"}

package/dist/operators.cjs

@@ -1,33 +1,34 @@
-const require_result = require('./result-CY-KIivk.cjs');
-const require_mapOrElse = require('./mapOrElse-H-GvAUka.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_result = require('./result-BBOGxvSH.cjs');
+const require_swap = require('./swap-BnyMBdD_.cjs');
 
-exports.and = require_mapOrElse.and;
-exports.bimap = require_result.bimap;
+exports.and = require_swap.and;
+exports.bimap = require_swap.bimap;
 exports.combine = require_result.combine;
-exports.filter = require_result.filter;
-exports.filterAsync = require_result.filterAsync;
-exports.flatMap = require_result.flatMap;
-exports.flatMapAsync = require_result.flatMapAsync;
-exports.fold = require_mapOrElse.fold;
-exports.foldAsync = require_mapOrElse.foldAsync;
-exports.map = require_result.map;
-exports.mapAsync = require_result.mapAsync;
-exports.mapBoth = require_result.mapBoth;
-exports.mapErr = require_result.mapErr;
-exports.mapErrAsync = require_result.mapErrAsync;
-exports.mapOr = require_mapOrElse.mapOr;
-exports.mapOrElse = require_mapOrElse.mapOrElse;
-exports.match = require_result.match;
-exports.matchAsync = require_result.matchAsync;
-exports.or = require_mapOrElse.or;
-exports.orElse = require_mapOrElse.orElse;
-exports.recover = require_result.recover;
-exports.recoverWith = require_result.recoverWith;
-exports.swap = require_result.swap;
-exports.tap = require_result.tap;
-exports.tapAsync = require_result.tapAsync;
-exports.tryCatch = require_result.tryCatch;
-exports.tryCatchAsync = require_result.tryCatchAsync;
-exports.tryMap = require_result.tryMap;
-exports.tryMapAsync = require_result.tryMapAsync;
+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;

package/dist/operators.d.cts

@@ -1,3 +1,3 @@
-import { A as recover, B as combine, C as flatMapAsync, D as tryMap, F as flatMap, I as bimap, L as mapBoth, M as match, N as filter, O as tryCatch, P as tap, R as mapErr, S as tapAsync, T as mapAsync, V as zip, b as matchAsync, j as recoverWith, k as swap, v as tryMapAsync, w as mapErrAsync, x as filterAsync, y as tryCatchAsync, z as map } from "./sequence-Br6tAIIu.cjs";
-import { a as and, i as or, n as mapOr, o as foldAsync, r as orElse, s as fold, t as mapOrElse } from "./mapOrElse-DIe7LkYV.cjs";
+import { v as combine, y as zip } from "./sequence-DDwePRLd.cjs";
+import { C as tap, D as mapErr, E as mapBoth, O as map, S as filter, T as bimap, _ as recoverWith, a as or, b as match, c as tryCatchAsync, d as filterAsync, f as tapAsync, g as recover, h as mapAsync, i as orElse, l as matchAsync, m as mapErrAsync, n as mapOrElse, o as and, p as flatMapAsync, r as mapOr, s as tryMapAsync, t as swap, u as foldAsync, v as tryMap, w as flatMap, x as fold, y as tryCatch } from "./swap-CrHQZIax.cjs";
 export { and, bimap, combine, filter, filterAsync, flatMap, flatMapAsync, fold, foldAsync, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, or, orElse, recover, recoverWith, swap, tap, tapAsync, tryCatch, tryCatchAsync, tryMap, tryMapAsync, zip };

package/dist/operators.d.mts

@@ -1,3 +1,3 @@
-import { A as recover, B as combine, C as flatMapAsync, D as tryMap, F as flatMap, I as bimap, L as mapBoth, M as match, N as filter, O as tryCatch, P as tap, R as mapErr, S as tapAsync, T as mapAsync, V as zip, b as matchAsync, j as recoverWith, k as swap, v as tryMapAsync, w as mapErrAsync, x as filterAsync, y as tryCatchAsync, z as map } from "./sequence-C0jlR3AY.mjs";
-import { a as and, i as or, n as mapOr, o as foldAsync, r as orElse, s as fold, t as mapOrElse } from "./mapOrElse-B5gx9x2E.mjs";
+import { v as combine, y as zip } from "./sequence-DDwePRLd.mjs";
+import { C as tap, D as mapErr, E as mapBoth, O as map, S as filter, T as bimap, _ as recoverWith, a as or, b as match, c as tryCatchAsync, d as filterAsync, f as tapAsync, g as recover, h as mapAsync, i as orElse, l as matchAsync, m as mapErrAsync, n as mapOrElse, o as and, p as flatMapAsync, r as mapOr, s as tryMapAsync, t as swap, u as foldAsync, v as tryMap, w as flatMap, x as fold, y as tryCatch } from "./swap-DT4LdRFV.mjs";
 export { and, bimap, combine, filter, filterAsync, flatMap, flatMapAsync, fold, foldAsync, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, or, orElse, recover, recoverWith, swap, tap, tapAsync, tryCatch, tryCatchAsync, tryMap, tryMapAsync, zip };

package/dist/operators.mjs

@@ -1,4 +1,4 @@
-import { A as flatMap, C as tryCatch, D as match, E as recoverWith, F as combine, I as zip, M as mapBoth, N as mapErr, O as filter, P as map, S as tryMap, T as recover, _ as tapAsync, b as mapAsync, g as filterAsync, h as matchAsync, j as bimap, k as tap, m as tryCatchAsync, p as tryMapAsync, v as flatMapAsync, w as swap, y as mapErrAsync } from "./result-DKKaNdOx.mjs";
-import { a as and, i as or, n as mapOr, o as foldAsync, r as orElse, s as fold, t as mapOrElse } from "./mapOrElse-B0_4r6Jn.mjs";
+import { m as zip, p as combine } from "./result-q9Na2bGa.mjs";
+import { C as tap, D as mapErr, E as mapBoth, O as map, S as filter, T as bimap, _ as recoverWith, a as or, b as match, c as tryCatchAsync, d as filterAsync, f as tapAsync, g as recover, h as mapAsync, i as orElse, l as matchAsync, m as mapErrAsync, n as mapOrElse, o as and, p as flatMapAsync, r as mapOr, s as tryMapAsync, t as swap, u as foldAsync, v as tryMap, w as flatMap, x as fold, y as tryCatch } from "./swap-CFD2g1cB.mjs";
 
 export { and, bimap, combine, filter, filterAsync, flatMap, flatMapAsync, fold, foldAsync, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, or, orElse, recover, recoverWith, swap, tap, tapAsync, tryCatch, tryCatchAsync, tryMap, tryMapAsync, zip };