@praha/byethrow 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) PrAha, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+# @praha/byethrow
+
+[![npm version](https://badge.fury.io/js/@praha%2Fbyethrow.svg)](https://www.npmjs.com/package/@praha/byethrow)
+[![npm download](https://img.shields.io/npm/dm/@praha/byethrow.svg)](https://www.npmjs.com/package/@praha/byethrow)
+[![license](https://img.shields.io/badge/License-MIT-green.svg)](https://github.com/praha-inc/byethrow/blob/main/LICENSE)
+[![Github](https://img.shields.io/github/followers/praha-inc?label=Follow&logo=github&style=social)](https://github.com/orgs/praha-inc/followers)
+
+A lightweight, tree-shakable Result type package with a simple, consistent API designed.
+
+## ✨ Features
+
+- 🌲 Tree-shakable: Only include what you use.
+- 🧱 Lightweight & object-based: No classes, no magic—just plain objects.
+- 🔄 Consistent API: Designed for readability and predictability.
+- 🔀 Unified sync/async handling: Works seamlessly with both Result<T, E> and Promise<Result<T, E>>.
+- 🎯 Focused functionality: Result-centric utilities without unnecessary aliases or confusing variants.
+
+## 🧠 Motivation
+
+Handling errors in JavaScript and TypeScript often leads to unstructured code. The typical try/catch approach doesn’t scale well and mixes error handling with business logic. `@praha/byethrow` addresses this by introducing a simple Result type, empowering you to model computation outcomes clearly—while keeping control flow explicit and maintainable.
+
+If you're a fan of libraries like `neverthrow` or effect-ts, this tool will feel familiar. While `neverthrow` may occasionally lack certain features, and `effect-ts` or `fp-ts` can introduce unnecessary complexity or overhead for many use cases, `@praha/byethrow` strikes a thoughtful balance—remaining lightweight and focused, while still offering everything you need to handle both synchronous and asynchronous fallible operations.
+
+## 📦 Installation
+
+```bash
+npm install @praha/byethrow
+```
+
+## 📚 Documentation
+
+Detailed API docs are available at:
+👉 https://praha-inc.github.io/byethrow
+
+## 🚀 Quick Example
+
+Here's a simple example showing how it is used:
+
+```ts
+import { Result } from '@praha/byethrow';
+
+const validateId = (id: string) => {
+  if (!id.startsWith('u')) {
+    return Result.fail(new Error('Invalid ID format'));
+  }
+  return Result.succeed();
+};
+
+const findUser = Result.try({
+  try: (id: string) => {
+    return { id, name: 'John Doe' };
+  },
+  catch: (error) => new Error('Failed to find user', { cause: error }),
+});
+
+const result = Result.pipe(
+  Result.succeed('u123'),
+  Result.andThrough(validateId),
+  Result.andThen(findUser),
+);
+
+if (Result.isSuccess(result)) {
+  console.log(result.value); // User found: John Doe
+}
+```
+
+## 🤝 Contributing
+
+Contributions, issues and feature requests are welcome.
+
+Feel free to check [issues page](https://github.com/praha-inc/byethrow/issues) if you want to contribute.
+
+## 📝 License
+
+Copyright © [PrAha, Inc.](https://www.praha-inc.com/)
+
+This project is [```MIT```](https://github.com/praha-inc/byethrow/blob/main/packages/byethrow/LICENSE) licensed.

package/dist/cjs/exports.cjs

@@ -0,0 +1,186 @@
+"use strict";
+var __webpack_modules__ = {
+    "./functions/and-then": function(module) {
+        module.exports = require("./functions/and-then.cjs");
+    },
+    "./functions/and-through": function(module) {
+        module.exports = require("./functions/and-through.cjs");
+    },
+    "./functions/bind": function(module) {
+        module.exports = require("./functions/bind.cjs");
+    },
+    "./functions/do": function(module) {
+        module.exports = require("./functions/do.cjs");
+    },
+    "./functions/fail": function(module) {
+        module.exports = require("./functions/fail.cjs");
+    },
+    "./functions/is-failure": function(module) {
+        module.exports = require("./functions/is-failure.cjs");
+    },
+    "./functions/is-success": function(module) {
+        module.exports = require("./functions/is-success.cjs");
+    },
+    "./functions/map-error": function(module) {
+        module.exports = require("./functions/map-error.cjs");
+    },
+    "./functions/map": function(module) {
+        module.exports = require("./functions/map.cjs");
+    },
+    "./functions/pipe": function(module) {
+        module.exports = require("./functions/pipe.cjs");
+    },
+    "./functions/succeed": function(module) {
+        module.exports = require("./functions/succeed.cjs");
+    },
+    "./functions/try": function(module) {
+        module.exports = require("./functions/try.cjs");
+    },
+    "./functions/unwrap-error": function(module) {
+        module.exports = require("./functions/unwrap-error.cjs");
+    },
+    "./functions/unwrap": function(module) {
+        module.exports = require("./functions/unwrap.cjs");
+    },
+    "./result": function(module) {
+        module.exports = require("./result.cjs");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _result__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./result");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _result__WEBPACK_IMPORTED_MODULE_0__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _result__WEBPACK_IMPORTED_MODULE_0__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_and_then__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./functions/and-then");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_and_then__WEBPACK_IMPORTED_MODULE_1__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_and_then__WEBPACK_IMPORTED_MODULE_1__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_and_through__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./functions/and-through");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_and_through__WEBPACK_IMPORTED_MODULE_2__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_and_through__WEBPACK_IMPORTED_MODULE_2__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_bind__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./functions/bind");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_bind__WEBPACK_IMPORTED_MODULE_3__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_bind__WEBPACK_IMPORTED_MODULE_3__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_do__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("./functions/do");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_do__WEBPACK_IMPORTED_MODULE_4__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_do__WEBPACK_IMPORTED_MODULE_4__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_fail__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("./functions/fail");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_fail__WEBPACK_IMPORTED_MODULE_5__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_fail__WEBPACK_IMPORTED_MODULE_5__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_is_failure__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("./functions/is-failure");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_is_failure__WEBPACK_IMPORTED_MODULE_6__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_is_failure__WEBPACK_IMPORTED_MODULE_6__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_is_success__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__("./functions/is-success");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_is_success__WEBPACK_IMPORTED_MODULE_7__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_is_success__WEBPACK_IMPORTED_MODULE_7__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_map__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__("./functions/map");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_map__WEBPACK_IMPORTED_MODULE_8__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_map__WEBPACK_IMPORTED_MODULE_8__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_map_error__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__("./functions/map-error");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_map_error__WEBPACK_IMPORTED_MODULE_9__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_map_error__WEBPACK_IMPORTED_MODULE_9__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_pipe__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__("./functions/pipe");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_pipe__WEBPACK_IMPORTED_MODULE_10__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_pipe__WEBPACK_IMPORTED_MODULE_10__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_succeed__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__("./functions/succeed");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_succeed__WEBPACK_IMPORTED_MODULE_11__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_succeed__WEBPACK_IMPORTED_MODULE_11__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_try__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__("./functions/try");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_try__WEBPACK_IMPORTED_MODULE_12__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_try__WEBPACK_IMPORTED_MODULE_12__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_unwrap__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__("./functions/unwrap");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_unwrap__WEBPACK_IMPORTED_MODULE_13__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_unwrap__WEBPACK_IMPORTED_MODULE_13__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__("./functions/unwrap-error");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_14__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_14__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+})();
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/exports.d.ts

@@ -0,0 +1,15 @@
+export * from './result';
+export * from './functions/and-then';
+export * from './functions/and-through';
+export * from './functions/bind';
+export * from './functions/do';
+export * from './functions/fail';
+export * from './functions/is-failure';
+export * from './functions/is-success';
+export * from './functions/map';
+export * from './functions/map-error';
+export * from './functions/pipe';
+export * from './functions/succeed';
+export * from './functions/try';
+export * from './functions/unwrap';
+export * from './functions/unwrap-error';

package/dist/cjs/functions/and-then.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    andThen: ()=>andThen
+});
+const external_is_failure_cjs_namespaceObject = require("./is-failure.cjs");
+const is_promise_cjs_namespaceObject = require("../internals/helpers/is-promise.cjs");
+const andThen = (fn)=>(result)=>{
+        const apply = (r)=>{
+            if ((0, external_is_failure_cjs_namespaceObject.isFailure)(r)) return r;
+            return fn(r.value);
+        };
+        return (0, is_promise_cjs_namespaceObject.isPromise)(result) ? result.then(apply) : apply(result);
+    };
+exports.andThen = __webpack_exports__.andThen;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "andThen"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/functions/and-then.d.ts

@@ -0,0 +1,45 @@
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+/**
+ * Chains the next computation using the success value of a {@link Result} or {@link ResultAsync}.
+ * If the original result is a {@link Failure}, it is returned unchanged.
+ * Otherwise, the provided function is called, and its result is returned as-is.
+ *
+ * @function
+ * @typeParam R1 - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam R2 - The result type returned by `fn`.
+ *
+ * @example Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed(3),
+ *   Result.andThen((x) => Result.succeed(x * 2)),
+ * );
+ * // { type: 'Success', value: 6 }
+ * ```
+ *
+ * @example Failure Case (input is a Failure)
+ * ```ts
+ * const result = Result.pipe(
+ *   Result.fail('error'),
+ *   Result.andThen((x) => Result.succeed(x * 2)),
+ * );
+ * // result: { type: 'Failure', error: 'error' }
+ * ```
+ *
+ * @example Failure Case (function returns a Failure)
+ * ```ts
+ * const result = Result.pipe(
+ *   Result.succeed(3),
+ *   Result.andThen((x) => Result.fail('error: ' + x)),
+ * );
+ * // result: { type: 'Failure', error: 'error: 3' }
+ * ```
+ *
+ * @category Combinators
+ */
+export declare const andThen: {
+    <R1 extends ResultMaybeAsync<any, any>, R2 extends ResultMaybeAsync<any, any>>(fn: (a: InferSuccess<R1>) => R2): (result: R1) => ResultFor<R1 | R2, InferSuccess<R2>, InferFailure<R1> | InferFailure<R2>>;
+    <F extends (a: any) => ResultMaybeAsync<any, any>>(fn: F): <R1 extends ResultMaybeAsync<Parameters<F>[0], any>>(result: R1) => ResultFor<R1 | ReturnType<F>, InferSuccess<F>, InferFailure<R1> | InferFailure<F>>;
+};

package/dist/cjs/functions/and-through.cjs

@@ -0,0 +1,50 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    andThrough: ()=>andThrough
+});
+const external_is_failure_cjs_namespaceObject = require("./is-failure.cjs");
+const is_promise_cjs_namespaceObject = require("../internals/helpers/is-promise.cjs");
+const andThrough = (fn)=>(result)=>{
+        const apply = (r)=>{
+            if ((0, external_is_failure_cjs_namespaceObject.isFailure)(r)) return r;
+            const next = fn(r.value);
+            if (next instanceof Promise) return next.then((n)=>{
+                if ((0, external_is_failure_cjs_namespaceObject.isFailure)(n)) return n;
+                return r;
+            });
+            if ((0, external_is_failure_cjs_namespaceObject.isFailure)(next)) return next;
+            return r;
+        };
+        return (0, is_promise_cjs_namespaceObject.isPromise)(result) ? result.then(apply) : apply(result);
+    };
+exports.andThrough = __webpack_exports__.andThrough;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "andThrough"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/functions/and-through.d.ts

@@ -0,0 +1,57 @@
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+/**
+ * Runs an additional computation using the success value of a {@link Result} or {@link ResultAsync},
+ * but **returns the original result** if the additional computation is successful.
+ *
+ * If either the original result or the side effect result is a {@link Failure}, that failure is returned.
+ * Useful for running validations or side effects without altering the main result on success.
+ *
+ * @function
+ * @typeParam R1 - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam R2 - The result type returned by `fn`.
+ *
+ * @example Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed(5),
+ *   Result.andThrough((x) => {
+ *     return x > 0 ? Result.succeed(null) : Result.fail('Must be > 0');
+ *   }),
+ * );
+ * // { type: 'Success', value: 5 }
+ * ```
+ *
+ * @example Failure Case (input is a Failure)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.fail('error),
+ *   Result.andThrough((x) => {
+ *     return x > 0 ? Result.succeed(null) : Result.fail('Must be > 0');
+ *   }),
+ * );
+ * // { type: 'Failure', error: 'error' }
+ * ```
+ *
+ * @example Failure Case (function returns a Failure)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed(-10),
+ *   Result.andThrough((x) => {
+ *     return x > 0 ? Result.succeed(null) : Result.fail('Must be > 0');
+ *   }),
+ * );
+ * // { type: 'Failure', error: 'Must be > 0' }
+ * ```
+ *
+ * @category Combinators
+ */
+export declare const andThrough: {
+    <R1 extends ResultMaybeAsync<any, any>, R2 extends ResultMaybeAsync<any, any>>(fn: (a: InferSuccess<R1>) => R2): (result: R1) => ResultFor<R1 | R2, InferSuccess<R1>, InferFailure<R1> | InferFailure<R2>>;
+    <F extends (a: any) => ResultMaybeAsync<any, any>>(fn: F): <R1 extends ResultMaybeAsync<Parameters<F>[0], any>>(result: R1) => ResultFor<R1 | ReturnType<F>, InferSuccess<R1>, InferFailure<R1> | InferFailure<F>>;
+};

package/dist/cjs/functions/bind.cjs

@@ -0,0 +1,50 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    bind: ()=>bind
+});
+const external_is_failure_cjs_namespaceObject = require("./is-failure.cjs");
+const external_succeed_cjs_namespaceObject = require("./succeed.cjs");
+const is_promise_cjs_namespaceObject = require("../internals/helpers/is-promise.cjs");
+const bind = (name, fn)=>(result)=>{
+        const apply = (r)=>{
+            if ((0, external_is_failure_cjs_namespaceObject.isFailure)(r)) return r;
+            const fr = fn(r.value);
+            const attach = (fr)=>(0, external_is_failure_cjs_namespaceObject.isFailure)(fr) ? fr : (0, external_succeed_cjs_namespaceObject.succeed)({
+                    ...r.value,
+                    [name]: fr.value
+                });
+            return (0, is_promise_cjs_namespaceObject.isPromise)(fr) ? fr.then(attach) : attach(fr);
+        };
+        return (0, is_promise_cjs_namespaceObject.isPromise)(result) ? result.then(apply) : apply(result);
+    };
+exports.bind = __webpack_exports__.bind;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "bind"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/functions/bind.d.ts

@@ -0,0 +1,61 @@
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+/**
+ * Chains another {@link Result}-producing computation and **merges its success value**
+ * into the existing object under the specified key.
+ *
+ * - If the original result is a {@link Failure}, it is returned as-is.
+ * - If the next result is a {@link Failure}, it is returned as-is.
+ * - If both are {@link Success}, a new object is returned by shallow-merging:
+ *   the original success object and `{ [name]: nextSuccess }`.
+ *
+ * This is useful for building up objects in a compositional and type-safe way,
+ * especially in validation or data-fetching pipelines.
+ *
+ * @function
+ * @typeParam N - The key to assign the result of the `fn` computation.
+ * @typeParam R1 - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam R2 - The result type returned by `fn`.
+ *
+ * @example Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed({ name: 'Alice' }),
+ *   Result.bind('age', (user) => Result.succeed(20)),
+ * );
+ * // { type: 'Success', value: { name: 1, age: 20 } }
+ * ```
+ *
+ * @example Failure Case (input is a Failure)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.fail('error'),
+ *   Result.bind('age', (user) => Result.succeed(20)),
+ * );
+ * // { type: 'Failure', error: 'error' }
+ * ```
+ *
+ * @example Failure Case (function returns a Failure)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed({ name: 'Alice' }),
+ *   Result.bind('age', (user) => Result.fail('error')),
+ * );
+ * // { type: 'Failure', error: 'error' }
+ * ```
+ *
+ * @category Combinators
+ */
+export declare const bind: {
+    <N extends string, R1 extends ResultMaybeAsync<any, any>, R2 extends ResultMaybeAsync<any, any>>(name: N, fn: (a: InferSuccess<R1>) => R2): (result: R1) => InferSuccess<R1> extends object ? ResultFor<R1 | R2, {
+        [K in N | keyof InferSuccess<R1>]: K extends keyof InferSuccess<R1> ? InferSuccess<R1>[K] : InferSuccess<R2>;
+    }, InferFailure<R1> | InferFailure<R2>> : unknown;
+    <N extends string, F extends (a: any) => ResultMaybeAsync<any, any>>(name: N, fn: F): <R1 extends ResultMaybeAsync<Parameters<F>[0], any>>(result: R1) => Parameters<F>[0] extends object ? ResultFor<R1 | ReturnType<F>, {
+        [K in N | keyof Parameters<F>[0]]: K extends keyof Parameters<F>[0] ? Parameters<F>[0][K] : InferSuccess<F>;
+    }, InferFailure<R1> | InferFailure<F>> : unknown;
+};

package/dist/cjs/functions/do.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    do: ()=>do_
+});
+const external_succeed_cjs_namespaceObject = require("./succeed.cjs");
+const do_ = ()=>(0, external_succeed_cjs_namespaceObject.succeed)({});
+exports["do"] = __webpack_exports__["do"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "do"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});