@sapphire/result 2.6.7-pr-725.55b1ff7b.0 → 2.7.0-next.0cb1b7f1

package/dist/iife/index.global.js

@@ -4,18 +4,28 @@ var SapphireResult = (function (exports) {
   var __defProp = Object.defineProperty;
   var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-  var __publicField = (obj, key, value) => {
-    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-    return value;
-  };
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
   // src/lib/common/utils.ts
   function isFunction(input) {
     return typeof input === "function";
   }
   __name(isFunction, "isFunction");
+  function returnThis() {
+    return this;
+  }
+  __name(returnThis, "returnThis");
+
+  // src/lib/OptionError.ts
+  var _OptionError = class _OptionError extends Error {
+    get name() {
+      return this.constructor.name;
+    }
+  };
+  __name(_OptionError, "OptionError");
+  var OptionError = _OptionError;
 
-  // src/lib/Result/ResultError.ts
+  // src/lib/ResultError.ts
   var _ResultError = class _ResultError extends Error {
     constructor(message, value) {
       super(message);
@@ -29,638 +39,1865 @@ var SapphireResult = (function (exports) {
   __name(_ResultError, "ResultError");
   var ResultError = _ResultError;
 
-  // src/lib/Result/Ok.ts
-  var _ResultOk = class _ResultOk {
-    constructor(value) {
-      __publicField(this, "value");
-      this.value = value;
-    }
+  // src/lib/Result.ts
+  var ValueProperty = Symbol.for("@sapphire/result:Result.value");
+  var SuccessProperty = Symbol.for("@sapphire/result:Result.success");
+  var _a, _b;
+  var _Result = class _Result {
+    constructor(value, success) {
+      __publicField(this, _b);
+      __publicField(this, _a);
+      this[ValueProperty] = value;
+      this[SuccessProperty] = success;
+    }
+    /**
+     * Returns `true` if the result is `Ok`.
+     *
+     * @example
+     * ```typescript
+     * const x = ok(-3);
+     * assert.equal(x.isOk(), true);
+     * ```
+     * @example
+     * ```typescript
+     * const x = err('Some error message');
+     * assert.equal(x.isOk(), false);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.is_ok}
+     */
     isOk() {
-      return true;
+      return this[SuccessProperty];
     }
     isOkAnd(cb) {
-      return cb(this.value);
-    }
+      return this.isOk() && cb(this[ValueProperty]);
+    }
+    /**
+     * Returns `true` if the result is `Err`.
+     *
+     * @example
+     * ```typescript
+     * const x = ok(-3);
+     * assert.equal(x.isErr(), false);
+     * ```
+     * @example
+     * ```typescript
+     * const x = err('Some error message');
+     * assert.equal(x.isErr(), true);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.is_err}
+     */
     isErr() {
-      return false;
-    }
-    isErrAnd() {
-      return false;
+      return !this[SuccessProperty];
     }
+    isErrAnd(cb) {
+      return this.isErr() && cb(this[ValueProperty]);
+    }
+    /**
+     * Converts from `Result<T, E>` to `Option<T>`.
+     *
+     * Converts itself into an `Option<T>`, and discarding the error, if any.
+     *
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = ok(2);
+     * assert.equal(x.ok(), some(2));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = err('Some error message');
+     * assert.equal(x.ok(), none);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.ok}
+     */
     ok() {
-      return createSome(this.value);
-    }
+      return this.match({ ok: /* @__PURE__ */ __name((value) => some(value), "ok"), err: /* @__PURE__ */ __name(() => none, "err") });
+    }
+    /**
+     * Converts from `Result<T, E>` to `Option<E>`.
+     *
+     * Converts itself into an `Option<E>`, and discarding the successful value, if any.
+     *
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = ok(2);
+     * assert.equal(x.err(), none);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = err('Some error message');
+     * assert.equal(x.err(), 'Some error message');
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.err}
+     */
     err() {
-      return createNone;
-    }
+      return this.match({ ok: /* @__PURE__ */ __name(() => none, "ok"), err: /* @__PURE__ */ __name((error) => some(error), "err") });
+    }
+    /**
+     * Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained `Ok` value, leaving an `Err` value
+     * untouched.
+     * @param cb The predicate.
+     *
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = ok(2);
+     * assert.equal(x.map((value) => value * 2), ok(4));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = err('Some error message');
+     * assert.equal(x.map((value) => value * 2), err('Some error message'));
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.map}
+     */
     map(cb) {
-      return createOk(cb(this.value));
-    }
+      return this.match({ ok: /* @__PURE__ */ __name((value) => ok(cb(value)), "ok"), err: returnThis });
+    }
+    /**
+     * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Ok` value, leaving an `Err` value
+     * untouched.
+     *
+     * Unlike {@link map}, this method does not wrap the returned value inside `Ok`, but instead, it returns the
+     * returned value.
+     * @param cb The predicate.
+     *
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = ok(2);
+     * assert.equal(x.mapInto((value) => ok(value * value)), ok(4));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = ok(0);
+     * assert.equal(
+     *   x.mapInto((value) => (value === 0 ? err('zero is not divisible') : ok(1 / value))),
+     *   err('zero is not divisible')
+     * );
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = err('Some error message');
+     * assert.equal(x.mapInto((value) => ok(4)), err('Some error message'));
+     * ```
+     *
+     * @note This is an extension not supported in Rust
+     */
     mapInto(cb) {
-      return cb(this.value);
-    }
-    mapOr(_, cb) {
-      return cb(this.value);
-    }
-    mapOrElse(_, cb) {
-      return cb(this.value);
-    }
-    mapErr() {
-      return this;
-    }
-    mapErrInto() {
-      return this;
-    }
+      return this.match({ ok: /* @__PURE__ */ __name((value) => cb(value), "ok"), err: returnThis });
+    }
+    /**
+     * Returns the provided default (if `Err`), or applies a function to the contained value (if `Ok`),
+     *
+     * Arguments passed to `mapOr` are eagerly evaluated; if you are passing the result of a function call, it is
+     * recommended to use `mapOrElse`, which is lazily evaluated.
+     * @param defaultValue The default value to use.
+     * @param cb The predicate.
+     *
+     * @example
+     * ```typescript
+     * const x = ok('hello');
+     * assert.equal(x.mapOr(42, (value) => value.length), 5);
+     * ```
+     * @example
+     * ```typescript
+     * const x = err('Some error message');
+     * assert.equal(x.mapOr(42, (value) => value.length), 42);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.map_or}
+     */
+    mapOr(defaultValue, cb) {
+      return this.match({ ok: /* @__PURE__ */ __name((value) => cb(value), "ok"), err: /* @__PURE__ */ __name(() => defaultValue, "err") });
+    }
+    /**
+     * Maps a `Result<T, E>` to `U` by applying fallback function default to a contained `Err` value, or function `cb`
+     * to a contained `Ok` value.
+     *
+     * This function can be used to unpack a successful result while handling an error.
+     * @param op The predicate that is run on `Err`.
+     * @param cb The predicate that is run on `Ok`.
+     *
+     * @example
+     * ```typescript
+     * const x: Result<string, string> = ok('hello');
+     * assert.equal(x.mapOrElse((error) => error.length, (value) => value.length), 5);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<string, string> = err('Some error message');
+     * assert.equal(x.mapOrElse((error) => error.length, (value) => value.length), 18);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.map_or_else}
+     */
+    mapOrElse(op, cb) {
+      return this.match({ ok: /* @__PURE__ */ __name((value) => cb(value), "ok"), err: /* @__PURE__ */ __name((error) => op(error), "err") });
+    }
+    /**
+     * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value, leaving an `Ok` value
+     * untouched.
+     *
+     * This function can be used to pass through a successful result while handling an error.
+     * @param cb The predicate.
+     *
+     * @example
+     * ```typescript
+     * const x: Result<number, Error> = ok(2);
+     * assert.equal(x.mapErr((error) => error.message), ok(2));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<number, Error> = err(new Error('Some error message'));
+     * assert.equal(x.mapErr((error) => error.message), err('Some error message'));
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.map_err}
+     */
+    mapErr(cb) {
+      return this.match({ ok: returnThis, err: /* @__PURE__ */ __name((error) => err(cb(error)), "err") });
+    }
+    /**
+     * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value, leaving an `Ok` value
+     * untouched.
+     *
+     * This function can be used to pass through a successful result while handling an error.
+     *
+     * Unlike {@link mapErr}, this method does not wrap the returned value inside `Err`, but instead, it returns the
+     * returned value.
+     * @param cb The predicate.
+     *
+     * @example
+     * ```typescript
+     * const x: Result<number, Error> = ok(2);
+     * assert.equal(x.mapErrInto((error) => err(error.message)), ok(2));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<number, Error> = err(new Error('Some error message'));
+     * assert.equal(x.mapErrInto((error) => err(error.message)), err('Some error message'));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<number, Error> = err(new Error('Some error message'));
+     * assert.equal(x.mapErrInto((error) => ok(4)), ok(4));
+     * ```
+     *
+     * @note This is an extension not supported in Rust
+     */
+    mapErrInto(cb) {
+      return this.match({ ok: returnThis, err: /* @__PURE__ */ __name((error) => cb(error), "err") });
+    }
+    /**
+     * Calls the provided closure with a reference to the contained value (if `Ok`).
+     * @param cb The predicate.
+     * @seealso {@link inspectAsync} for the awaitable version.
+     *
+     * @example
+     * ```typescript
+     * ok(2).inspect(console.log);
+     * // Logs: 2
+     * ```
+     * @example
+     * ```typescript
+     * err('Some error message').inspect(console.log);
+     * // Doesn't log
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.inspect}
+     */
     inspect(cb) {
-      cb(this.value);
+      if (this.isOk()) cb(this[ValueProperty]);
       return this;
     }
+    /**
+     * Calls the provided closure with a reference to the contained value (if `Ok`) and awaits it.
+     * @param cb The predicate.
+     * @seealso {@link inspect} for the sync version.
+     *
+     * @example
+     * ```typescript
+     * await ok(2).inspectAsync(console.log);
+     * // Logs: 2
+     * ```
+     * @example
+     * ```typescript
+     * await err('Some error message').inspectAsync(console.log);
+     * // Doesn't log
+     * ```
+     *
+     * @note This is an extension not supported in Rust
+     */
     async inspectAsync(cb) {
-      await cb(this.value);
+      if (this.isOk()) await cb(this[ValueProperty]);
       return this;
     }
-    inspectErr() {
+    /**
+     * Calls the provided closure with a reference to the contained error (if `Err`).
+     * @param cb The predicate.
+     * @seealso {@link inspectErrAsync} for the awaitable version.
+     *
+     * @example
+     * ```typescript
+     * ok(2).inspectErr(console.log);
+     * // Doesn't log
+     * ```
+     * @example
+     * ```typescript
+     * err('Some error message').inspectErr(console.log);
+     * // Logs: Some error message
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.inspect_err}
+     */
+    inspectErr(cb) {
+      if (this.isErr()) cb(this[ValueProperty]);
       return this;
     }
-    inspectErrAsync() {
-      return Promise.resolve(this);
+    /**
+     * Calls the provided closure with a reference to the contained error (if `Err`) and awaits it.
+     * @param cb The predicate.
+     * @seealso {@link inspectErr} for the sync version.
+     *
+     * @example
+     * ```typescript
+     * await ok(2).inspectErrAsync(console.log);
+     * // Doesn't log
+     * ```
+     * @example
+     * ```typescript
+     * await err('Some error message').inspectErrAsync(console.log);
+     * // Logs: Some error message
+     * ```
+     *
+     * @note This is an extension not supported in Rust
+     */
+    async inspectErrAsync(cb) {
+      if (this.isErr()) await cb(this[ValueProperty]);
+      return this;
     }
+    /**
+     * Returns an iterator over the possibly contained value.
+     *
+     * The iterator yields one value if the result is `Ok`, otherwise none.
+     *
+     * @example
+     * ```typescript
+     * const x = ok(7);
+     * for (const value of x.iter()) {
+     *   console.log(value);
+     * }
+     * // Logs 7
+     * ```
+     * @example
+     * ```typescript
+     * const x = err('Nothing!');
+     * for (const value of x.iter()) {
+     *   console.log(value);
+     * }
+     * // Doesn't log
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.iter}
+     */
     *iter() {
-      yield this.value;
-    }
-    expect() {
-      return this.value;
-    }
+      if (this.isOk()) yield this[ValueProperty];
+    }
+    /**
+     * Returns the contained `Ok` value.
+     *
+     * If the value is an `Err`, it throws a {@link ResultError} with the given message and the content of the `Err`.
+     * @param message The message for the error.
+     *
+     * @example
+     * ```typescript
+     * const x = ok(2);
+     * assert.equal(x.expect('Whoops!'), 2);
+     * ```
+     * @example
+     * ```typescript
+     * const x = err('Emergency failure');
+     * assert.throws(() => x.expect('Whoops!'), {
+     *   name: 'ResultError',
+     *   message: 'Whoops',
+     *   value: 'Emergency failure'
+     * });
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.expect}
+     */
+    expect(message) {
+      if (this.isErr()) throw new ResultError(message, this[ValueProperty]);
+      return this[ValueProperty];
+    }
+    /**
+     * Returns the contained `Err` value.
+     *
+     * If the value is an `Ok`, it throws a {@link ResultError} with the given message and the content of the `Ok`.
+     * @param message The message for the error.
+     *
+     * @example
+     * ```typescript
+     * const x = ok(2);
+     * assert.throws(() => x.expectErr('Whoops!'), {
+     *   name: 'ResultError',
+     *   message: 'Whoops',
+     *   value: 2
+     * });
+     * ```
+     * @example
+     * ```typescript
+     * const x = err('Emergency failure');
+     * assert.equal(x.expectErr('Whoops!'), 'Emergency failure');
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.expect_err}
+     */
     expectErr(message) {
-      throw new ResultError(message, this.value);
-    }
+      if (this.isOk()) throw new ResultError(message, this[ValueProperty]);
+      return this[ValueProperty];
+    }
+    /**
+     * Returns the contained `Ok` value.
+     *
+     * If the value is an `Err`, it throws a {@link ResultError} with the message, and the content of the `Err`.
+     * @seealso {@link unwrapOr}
+     * @seealso {@link unwrapOrElse}
+     * @seealso {@link unwrapErr}
+     * @seealso {@link unwrapRaw}
+     *
+     * @example
+     * ```typescript
+     * const x = ok(2);
+     * assert.equal(x.unwrap(), 2);
+     * ```
+     * @example
+     * ```typescript
+     * const x = err('Emergency failure');
+     * assert.throws(() => x.unwrap(), {
+     *   name: 'ResultError',
+     *   message: 'Unwrap failed',
+     *   value: 'Emergency failure'
+     * });
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.unwrap}
+     */
     unwrap() {
-      return this.value;
-    }
+      if (this.isErr()) throw new ResultError("Unwrap failed", this[ValueProperty]);
+      return this[ValueProperty];
+    }
+    /**
+     * Returns the contained `Err` value.
+     *
+     * If the value is an `Ok`, it throws a {@link ResultError} with the message, and the content of the `Ok`.
+     * @seealso {@link unwrap}
+     * @seealso {@link unwrapOr}
+     * @seealso {@link unwrapOrElse}
+     * @seealso {@link unwrapRaw}
+     *
+     * @example
+     * ```typescript
+     * const x = ok(2);
+     * assert.throws(() => x.unwrapErr(), {
+     *   name: 'ResultError',
+     *   message: 'Unwrap failed',
+     *   value: 2
+     * });
+     * ```
+     * @example
+     * ```typescript
+     * const x = err('Emergency failure');
+     * assert.equal(x.unwrapErr(), 'Emergency failure');
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.unwrap_err}
+     */
     unwrapErr() {
-      throw new ResultError("Unwrap failed", this.value);
-    }
-    unwrapOr() {
-      return this.value;
-    }
-    unwrapOrElse() {
-      return this.value;
-    }
+      if (this.isOk()) throw new ResultError("Unwrap failed", this[ValueProperty]);
+      return this[ValueProperty];
+    }
+    /**
+     * Returns the contained `Ok` value or the provided default.
+     *
+     * Arguments passed to `unwrapOr` are eagerly evaluated; if you are passing the result of a function call, it is
+     * recommended to use {@link unwrapOrElse}, which is lazily evaluated.
+     * @seealso {@link unwrap}
+     * @seealso {@link unwrapOrElse}
+     * @seealso {@link unwrapErr}
+     * @seealso {@link unwrapRaw}
+     *
+     * @param defaultValue The default value.
+     *
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = ok(9);
+     * assert.equal(x.unwrapOr(2), 9);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = err('Error');
+     * assert.equal(x.unwrapOr(2), 2);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.unwrap_or}
+     */
+    unwrapOr(defaultValue) {
+      return this.match({ ok: /* @__PURE__ */ __name((value) => value, "ok"), err: /* @__PURE__ */ __name(() => defaultValue, "err") });
+    }
+    /**
+     * Returns the contained `Ok` value or computes it from a closure.
+     * @seealso {@link unwrap}
+     * @seealso {@link unwrapOr}
+     * @seealso {@link unwrapErr}
+     * @seealso {@link unwrapRaw}
+     *
+     * @param op The predicate.
+     *
+     * @example
+     * ```typescript
+     * const count = (x: string) => x.length;
+     *
+     * assert.equal(ok(2).unwrapOrElse(count), 2);
+     * assert.equal(err('hello').unwrapOrElse(count), 5);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.unwrap_or_else}
+     */
+    unwrapOrElse(op) {
+      return this.match({ ok: /* @__PURE__ */ __name((value) => value, "ok"), err: /* @__PURE__ */ __name((error) => op(error), "err") });
+    }
+    /**
+     * Returns the contained `Ok` value.
+     *
+     * If the value is an `Err`, it throws the contained error.
+     * @seealso {@link unwrap}
+     * @seealso {@link unwrapOr}
+     * @seealso {@link unwrapOrElse}
+     * @seealso {@link unwrapErr}
+     *
+     * @example
+     * ```typescript
+     * const x = ok(2);
+     * assert.equal(x.unwrapRaw(), 2);
+     * ```
+     * @example
+     * ```typescript
+     * const x = err('Emergency failure');
+     * assert.throws(() => x.unwrapRaw(), {
+     *   name: 'Error',
+     *   message: 'Unwrap failed',
+     *   value: 'Emergency failure'
+     * });
+     * ```
+     */
     unwrapRaw() {
-      return this.value;
-    }
+      if (this.isErr()) throw this[ValueProperty];
+      return this[ValueProperty];
+    }
+    /**
+     * Returns `result` if the result is `Ok`, otherwise returns the `Err` value of itself.
+     * @param result The result to check.
+     *
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = ok(2);
+     * const y: Result<string, string> = err('Late error');
+     * assert.equal(x.and(y), err('Late error'));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = err('Early error');
+     * const y: Result<string, string> = err('Late error');
+     * assert.equal(x.and(y), err('Early error'));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = ok(2);
+     * const y: Result<string, string> = ok('Hello');
+     * assert.equal(x.and(y), ok('Hello'));
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.and}
+     */
     and(result) {
-      return result;
-    }
+      return this.match({ ok: /* @__PURE__ */ __name(() => result, "ok"), err: returnThis });
+    }
+    /**
+     * Calls `cb` if the result is `Ok`, otherwise returns the `Err` value of self.
+     *
+     * This function can be used for control flow based on `Result` values.
+     * @param cb The predicate.
+     *
+     * @example
+     * ```typescript
+     * function fractionOf4(value: number) {
+     *   return value === 0 ? err('overflowed') : ok(4 / value);
+     * }
+     *
+     * assert.equal(ok(2).andThen(fractionOf4), ok(4));
+     * assert.equal(ok(0).andThen(fractionOf4), err('overflowed'));
+     * assert.equal(err('not a number').andThen(fractionOf4), err('not a number'));
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.and_then}
+     */
     andThen(cb) {
-      return cb(this.value);
-    }
-    or() {
-      return this;
-    }
-    orElse() {
-      return this;
+      return this.match({ ok: /* @__PURE__ */ __name((value) => cb(value), "ok"), err: returnThis });
+    }
+    /**
+     * Return `result` if the result is `Err`, otherwise returns the `Ok` value of self.
+     *
+     * Arguments passed to or are eagerly evaluated; if you are passing the result of a function call, it is recommended
+     * to use {@link orElse}, which is lazily evaluated.
+     * @param result The result to check.
+     *
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = ok(2);
+     * const y: Result<number, string> = err('Late error');
+     * assert.equal(x.or(y), ok(2));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = err('Early error');
+     * const y: Result<number, string> = ok(2);
+     * assert.equal(x.or(y), ok(2));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = err('Early error');
+     * const y: Result<number, string> = err('Late error');
+     * assert.equal(x.or(y), err('Late error'));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<number, string> = ok(2);
+     * const y: Result<number, string> = ok(100);
+     * assert.equal(x.or(y), ok(2));
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.or}
+     */
+    or(result) {
+      return this.match({ ok: returnThis, err: /* @__PURE__ */ __name(() => result, "err") });
+    }
+    /**
+     * Calls `cb` if the result is `Err`, otherwise returns the `Ok` value of self.
+     *
+     * This function can be used for control flow based on result values.
+     * @param cb The predicate.
+     *
+     * @example
+     * ```typescript
+     * const square = (x: number): Result<number, string> => ok(x * x);
+     * const wrapErr = (x: number): Result<number, string> => err(x);
+     *
+     * assert.equal(ok(2).orElse(square).orElse(square), ok(2));
+     * assert.equal(ok(2).orElse(wrapErr).orElse(square), ok(2));
+     * assert.equal(err(3).orElse(square).orElse(wrapErr), ok(9));
+     * assert.equal(err(3).orElse(wrapErr).orElse(wrapErr), err(3));
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.or_else}
+     */
+    orElse(cb) {
+      return this.match({ ok: returnThis, err: /* @__PURE__ */ __name((error) => cb(error), "err") });
     }
     contains(value) {
-      return this.value === value;
-    }
-    containsErr() {
-      return false;
+      return this.isOkAnd((inner) => inner === value);
     }
+    containsErr(error) {
+      return this.isErrAnd((inner) => inner === error);
+    }
+    /**
+     * Transposes a `Result` of an `Option` into an `Option` of a `Result`.
+     *
+     * `ok(none)` will be mapped to `none`. `ok(some(v))` and `err(e)` will be mapped to `some(ok(v))` and `some(err(e))`.
+     *
+     * @example
+     * ```typescript
+     * const x: Result<Option<number>, Error> = ok(some(5));
+     * const y: Option<Result<number, Error>> = some(ok(5));
+     * assert.equal(x.transpose(), y);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.transpose}
+     */
     transpose() {
-      return this.value.match({
-        some: (value) => createSome(createOk(value)),
-        none: () => createNone
+      return this.match({
+        ok: /* @__PURE__ */ __name((value) => value.map((value2) => ok(value2)), "ok"),
+        err() {
+          return some(this);
+        }
       });
     }
+    /**
+     * Converts from `Result<Result<T, E>, E>` to `Result<T, E>`.
+     *
+     * @example
+     * ```typescript
+     * const x: Result<Result<string, number>, number> = ok(ok('Hello'));
+     * assert.equal(x.flatten(), ok('Hello'));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<Result<string, number>, number> = ok(err(6));
+     * assert.equal(x.flatten(), err(6));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Result<Result<string, number>, number> = err(6);
+     * assert.equal(x.flatten(), err(6));
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.flatten}
+     */
     flatten() {
-      return this.value;
-    }
+      return this.match({ ok: /* @__PURE__ */ __name((value) => value, "ok"), err: returnThis });
+    }
+    /**
+     * Returns the `Ok` value if self is `Ok`, and the `Err` value if self is `Err`.
+     *
+     * @example
+     * ```typescript
+     * let x: Result<number, number> = ok(3);
+     * assert.equal(x.intoOkOrErr(), 3);
+     * ```
+     * @example
+     * ```typescript
+     * let x: Result<number, number> = err(4);
+     * assert.equal(x.intoOkOrErr(), 4);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.into_ok_or_err}
+     */
     intoOkOrErr() {
-      return this.value;
-    }
-    async intoPromise() {
-      return createOk(await this.value);
+      return this[ValueProperty];
+    }
+    /**
+     * Returns a `Promise` object with the awaited value (if `Ok`) or the awaited error (if `Err`).
+     *
+     * @example
+     * ```typescript
+     * let x = ok(Promise.resolve(3));
+     * assert.equal(await x.intoPromise(), ok(3));
+     * ```
+     *
+     * @note This is an extension not supported in Rust
+     */
+    intoPromise() {
+      return this.match({
+        ok: /* @__PURE__ */ __name(async (value) => ok(await value), "ok"),
+        // NOSONAR
+        err: /* @__PURE__ */ __name(async (error) => err(await error), "err")
+        // NOSONAR
+      });
     }
+    /**
+     * Checks whether or not `other` equals with self.
+     * @param other The other result to compare.
+     *
+     * @see {@link https://doc.rust-lang.org/std/cmp/trait.PartialEq.html#tymethod.eq}
+     */
     eq(other) {
-      return other.isOkAnd((value) => this.value === value);
-    }
+      return this.isOk() === other.isOk() && this[ValueProperty] === other[ValueProperty];
+    }
+    /**
+     * Checks whether or not `other` doesn't equal with self.
+     * @param other The other result to compare.
+     *
+     * @see {@link https://doc.rust-lang.org/std/cmp/trait.PartialEq.html#method.ne}
+     */
     ne(other) {
       return !this.eq(other);
     }
+    /**
+     * Runs `ok` function if self is `Ok`, otherwise runs `err` function.
+     * @param branches The branches to match.
+     *
+     * @example
+     * ```typescript
+     * const result = ok(4).match({
+     *   ok: (v) => v,
+     *   err: () => 0
+     * });
+     * assert.equal(result, 4);
+     * ```
+     * @example
+     * ```typescript
+     * const result = err('Hello').match({
+     *   ok: (v) => v,
+     *   err: () => 0
+     * });
+     * assert.equal(result, 0);
+     * ```
+     */
     match(branches) {
-      return branches.ok(this.value);
+      return this.isOk() ? branches.ok.call(this, this[ValueProperty]) : branches.err.call(this, this[ValueProperty]);
+    }
+    /**
+     * Returns an iterator over the possibly contained value.
+     *
+     * The iterator yields one value if the result is `Ok`, otherwise none.
+     *
+     * @example
+     * ```typescript
+     * const x = ok(7);
+     * for (const value of x) {
+     *   console.log(value);
+     * }
+     * // Logs 7
+     * ```
+     * @example
+     * ```typescript
+     * const x = err('Nothing!');
+     * for (const value of x) {
+     *   console.log(value);
+     * }
+     * // Doesn't log
+     * ```
+     *
+     * @see {@link IResult.iter}
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.iter}
+     */
+    [(_b = ValueProperty, _a = SuccessProperty, Symbol.iterator)]() {
+      return this.iter();
+    }
+    get [Symbol.toStringTag]() {
+      return this.match({ ok: /* @__PURE__ */ __name(() => "Ok", "ok"), err: /* @__PURE__ */ __name(() => "Err", "err") });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    static ok(value) {
+      return new _Result(value, true);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    static err(value) {
+      return new _Result(value, false);
+    }
+    /**
+     * Checks if the `instance` object is an instance of `Result`, or if it is a `Result`-like object. This override
+     * exists to interoperate with other versions of this class, such as the one coming from another version of this
+     * library or from a different build.
+     *
+     * @param instance The instance to check.
+     * @returns Whether or not the instance is a `Result`.
+     *
+     * @example
+     * ```typescript
+     * import { Result } from '@sapphire/result';
+     * const { ok } = require('@sapphire/result');
+     *
+     * ok(2) instanceof Result; // true
+     * ```
+     */
+    static [Symbol.hasInstance](instance) {
+      return typeof instance === "object" && instance !== null && ValueProperty in instance && SuccessProperty in instance;
+    }
+    /**
+     * @deprecated Use {@link Result.isResult} instead.
+     *
+     * Checks if the `instance` object is an instance of `Result`, or if it is a `Result`-like object.
+     *
+     * @param instance The instance to check.
+     * @returns true if the instance is a `Result` or a `Result`-like object, false otherwise.
+     *
+     * @example
+     * ```typescript
+     * import { Result } from '@sapphire/result';
+     * const { ok } = require('@sapphire/result');
+     *
+     * Result.isResult(ok(2)); // true
+     * ```
+     */
+    static is(instance) {
+      return _Result[Symbol.hasInstance](instance);
+    }
+    /**
+     * Checks if the `instance` object is an instance of `Result`, or if it is a `Result`-like object.
+     *
+     * @param instance The instance to check.
+     * @returns true if the instance is a `Result` or a `Result`-like object, false otherwise.
+     *
+     * @example
+     * ```typescript
+     * import { Result } from '@sapphire/result';
+     * const { ok } = require('@sapphire/result');
+     *
+     * Result.isResult(ok(2)); // true
+     * ```
+     */
+    static isResult(instance) {
+      return _Result[Symbol.hasInstance](instance);
+    }
+    /**
+     * Creates a {@link Result} out of a callback.
+     *
+     * @typeparam T The result's type.
+     * @typeparam E The error's type.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    static from(op) {
+      try {
+        return resolve(isFunction(op) ? op() : op);
+      } catch (error) {
+        return err(error);
+      }
+    }
+    /**
+     * Creates a {@link Result} out of a promise or async callback.
+     *
+     * @typeparam T The result's type.
+     * @typeparam E The error's type.
+     */
+    static async fromAsync(op) {
+      try {
+        return resolve(await (isFunction(op) ? op() : op));
+      } catch (error) {
+        return err(error);
+      }
     }
-    *[Symbol.iterator]() {
-      yield this.value;
+    /**
+     * Creates an {@link Ok} that is the combination of all collected {@link Ok} values as an array, or the first
+     * {@link Err} encountered.
+     *
+     * @param results An array of {@link Result}s.
+     * @returns A new {@link Result}.
+     */
+    static all(results) {
+      const values = [];
+      for (const result of results) {
+        if (result.isErr()) return result;
+        values.push(result[ValueProperty]);
+      }
+      return ok(values);
+    }
+    /**
+     * Returns the first encountered {@link Ok}, or an {@link Err} that is the combination of all collected error values.
+     *
+     * @param results An array of {@link Result}s.
+     * @returns A new {@link Result}.
+     */
+    static any(results) {
+      const errors = [];
+      for (const result of results) {
+        if (result.isOk()) return result;
+        errors.push(result[ValueProperty]);
+      }
+      return err(errors);
     }
   };
-  __name(_ResultOk, "ResultOk");
-  var ResultOk = _ResultOk;
-  function createOk(x) {
-    return new ResultOk(x);
+  __name(_Result, "Result");
+  var Result = _Result;
+  var { ok, err } = Result;
+  function resolve(value) {
+    return Result.isResult(value) ? value : ok(value);
   }
-  __name(createOk, "createOk");
+  __name(resolve, "resolve");
 
-  // src/lib/Option/Some.ts
-  var _OptionSome = class _OptionSome {
-    constructor(value) {
-      __publicField(this, "value");
-      this.value = value;
-    }
+  // src/lib/Option.ts
+  var ValueProperty2 = Symbol.for("@sapphire/result:Option.value");
+  var ExistsProperty = Symbol.for("@sapphire/result:Option.exists");
+  var _a2, _b2;
+  var _Option = class _Option {
+    constructor(value, exists) {
+      __publicField(this, _b2);
+      __publicField(this, _a2);
+      this[ValueProperty2] = value;
+      this[ExistsProperty] = exists;
+    }
+    /**
+     * Returns `true` if the option is a `Some` value.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<number> = some(2);
+     * assert.equal(x.isSome(), true);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = none;
+     * assert.equal(x.isSome(), false);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.is_some}
+     */
     isSome() {
-      return true;
+      return this[ExistsProperty];
     }
     isSomeAnd(cb) {
-      return cb(this.value);
-    }
+      return this.isSome() && cb(this[ValueProperty2]);
+    }
+    /**
+     * Returns `true` if the option is a `None` value.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<number> = some(2);
+     * assert.equal(x.isNone(), false);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = none;
+     * assert.equal(x.isNone(), true);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.is_none}
+     */
     isNone() {
-      return false;
-    }
-    expect() {
-      return this.value;
-    }
+      return !this[ExistsProperty];
+    }
+    isNoneOr(cb) {
+      return this.match({ some: /* @__PURE__ */ __name((value) => cb(value), "some"), none: /* @__PURE__ */ __name(() => true, "none") });
+    }
+    /**
+     * Returns the contained `Some` value.
+     * @param message The message for the error.
+     * If the value is an `Err`, it throws an {@link OptionError} with the given message.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<string> = some(2);
+     * assert.equal(x.expect('Whoops!'), 2);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<string> = none;
+     * assert.throws(() => x.expect('Whoops!'), {
+     *   name: 'OptionError',
+     *   message: 'Whoops'
+     * });
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.expect}
+     */
+    expect(message) {
+      if (this.isNone()) throw new OptionError(message);
+      return this[ValueProperty2];
+    }
+    /**
+     * Returns the contained `Some` value.
+     *
+     * If the value is an `Err`, it throws an {@link OptionError} with the message.
+     * @seealso {@link unwrapOr}
+     * @seealso {@link unwrapOrElse}
+     *
+     * @example
+     * ```typescript
+     * const x: Option<string> = some(2);
+     * assert.equal(x.unwrap(), 2);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<string> = none;
+     * assert.throws(() => x.unwrap(), {
+     *   name: 'OptionError',
+     *   message: 'Unwrap failed'
+     * });
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.unwrap}
+     */
     unwrap() {
-      return this.value;
-    }
-    unwrapOr() {
-      return this.value;
-    }
-    unwrapOrElse() {
-      return this.value;
-    }
+      if (this.isNone()) throw new OptionError("Unwrap failed");
+      return this[ValueProperty2];
+    }
+    /**
+     * Returns the contained `Some` value or a provided default.
+     *
+     * Arguments passed to `unwrapOr` are eagerly evaluated; if you are passing the result of a function call, it is
+     * recommended to use {@link unwrapOrElse}, which is lazily evaluated.
+     *
+     * @example
+     * ```typescript
+     * assert.equal(some(2).unwrapOr(0), 2);
+     * ```
+     * @example
+     * ```typescript
+     * assert.equal(none.unwrapOr(0), 0);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.unwrap_or}
+     */
+    unwrapOr(defaultValue) {
+      return this.match({ some: /* @__PURE__ */ __name((value) => value, "some"), none: /* @__PURE__ */ __name(() => defaultValue, "none") });
+    }
+    /**
+     * Returns the contained Some value or computes it from a closure.
+     *
+     * @example
+     * ```typescript
+     * assert.equal(some(2).unwrapOrElse(() => 0), 2);
+     * ```
+     * @example
+     * ```typescript
+     * assert.equal(none.unwrapOrElse(() => 0), 0);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.unwrap_or_else}
+     */
+    unwrapOrElse(cb) {
+      return this.match({ some: /* @__PURE__ */ __name((value) => value, "some"), none: cb });
+    }
+    /**
+     * Maps an `Option<T>` to `Option<U>` by applying a function to a contained value.
+     * @param cb The predicate.
+     *
+     * @example
+     * ```typescript
+     * const maybeSomeString = some('Hello, world!');
+     * const maybeSomeLength = maybeSomeString.map((value) => value.length);
+     *
+     * assert.equal(maybeSomeLength, some(13));
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.map}
+     */
     map(cb) {
-      return createSome(cb(this.value));
-    }
+      return this.match({ some: /* @__PURE__ */ __name((value) => some(cb(value)), "some"), none: returnThis });
+    }
+    /**
+     * Maps a `Some<T>` to the returned `Option<U>` by applying a function to a contained value, leaving `None`
+     * untouched.
+     * @param cb The predicate.
+     *
+     * @example
+     * ```typescript
+     * const input: Option<string> = some('Hello, world!');
+     * const result = input.mapInto((value) => some(value.length));
+     *
+     * assert.equal(result, some(13));
+     * ```
+     * @example
+     * ```typescript
+     * const input: Option<string> = none;
+     * const result = input.mapInto((value) => some(value.length));
+     *
+     * assert.equal(result, none);
+     * ```
+     *
+     * @note This is an extension not supported in Rust
+     */
     mapInto(cb) {
-      return cb(this.value);
-    }
-    mapOr(_, cb) {
-      return cb(this.value);
-    }
-    mapOrElse(_, cb) {
-      return cb(this.value);
-    }
-    mapNoneInto() {
-      return this;
-    }
+      return this.match({ some: /* @__PURE__ */ __name((value) => cb(value), "some"), none: returnThis });
+    }
+    /**
+     * Returns the provided default result (if none), or applies a function to the contained value (if any).
+     *
+     * Arguments passed to `mapOr` are eagerly evaluated; if you are passing the result of a function call, it is
+     * recommended to use {@link mapOrElse}, which is lazily evaluated.
+     * @param defaultValue The default value.
+     * @param cb The predicate.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<string> = some('hello');
+     * assert.equal(x.mapOr(42, (value) => value.length), 5);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<string> = none;
+     * assert.equal(x.mapOr(42, (value) => value.length), 42);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.map_or}
+     */
+    mapOr(defaultValue, cb) {
+      return this.match({ some: /* @__PURE__ */ __name((value) => cb(value), "some"), none: /* @__PURE__ */ __name(() => defaultValue, "none") });
+    }
+    /**
+     * Computes a default function result (if none), or applies a different function to the contained value (if any).
+     * @param defaultValue The default value.
+     * @param cb The predicate.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<string> = some('hello');
+     * assert.equal(x.mapOrElse(() => 42, (value) => value.length), 5);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<string> = none;
+     * assert.equal(x.mapOrElse(() => 42, (value) => value.length), 42);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.map_or_else}
+     */
+    mapOrElse(defaultValue, cb) {
+      return this.match({ some: /* @__PURE__ */ __name((value) => cb(value), "some"), none: /* @__PURE__ */ __name(() => defaultValue(), "none") });
+    }
+    /**
+     * Maps a `None` to the returned `Option<U>` by applying a function to a contained value, leaving `Some<T>`
+     * untouched.
+     * @param cb The predicate.
+     *
+     * @example
+     * ```typescript
+     * const input: Option<string> = some('Hello, world!');
+     * const result = input.mapNoneInto(() => some(13));
+     *
+     * assert.equal(result, some('Hello, world!'));
+     * ```
+     * @example
+     * ```typescript
+     * const input: Option<string> = none;
+     * const result = input.mapNoneInto(() => some(13));
+     *
+     * assert.equal(result, some(13));
+     * ```
+     *
+     * @note This is an extension not supported in Rust
+     */
+    mapNoneInto(cb) {
+      return this.match({ some: returnThis, none: cb });
+    }
+    /**
+     * Calls the provided closure with a reference to the contained value (if `Some`).
+     * @param cb The predicate.
+     * @seealso {@link inspectAsync} for the awaitable version.
+     *
+     * @example
+     * ```typescript
+     * some(2).inspect(console.log);
+     * // Logs: 2
+     * ```
+     * @example
+     * ```typescript
+     * none.inspect(console.log);
+     * // Doesn't log
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.inspect}
+     */
     inspect(cb) {
-      cb(this.value);
+      if (this.isSome()) cb(this[ValueProperty2]);
       return this;
     }
+    /**
+     * Calls the provided closure with a reference to the contained value (if `Some`).
+     * @param cb The predicate.
+     * @seealso {@link inspect} for the sync version.
+     *
+     * @example
+     * ```typescript
+     * await some(2).inspectAsync(console.log);
+     * // Logs: 2
+     * ```
+     * @example
+     * ```typescript
+     * await none.inspectAsync(console.log);
+     * // Doesn't log
+     * ```
+     *
+     * @note This is an extension not supported in Rust
+     */
     async inspectAsync(cb) {
-      await cb(this.value);
+      if (this.isSome()) await cb(this[ValueProperty2]);
       return this;
     }
-    okOr() {
-      return createOk(this.value);
-    }
-    okOrElse() {
-      return createOk(this.value);
-    }
+    /**
+     * Transforms the `Option<T>` into a `Result<T, E>`, mapping `Some(v)` to `Ok(v)` and `None` to `Err(err)`.
+     *
+     * Arguments passed to `okOr` are eagerly evaluated; if you are passing the result of a function call, it is
+     * recommended to use {@link okOrElse}, which is lazily evaluated.
+     * @param err The error to be used.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<string> = some('hello');
+     * assert.equal(x.okOr(0), ok('hello'));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<string> = none;
+     * assert.equal(x.okOr(0), err(0));
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.ok_or}
+     */
+    okOr(error) {
+      return this.match({ some: /* @__PURE__ */ __name((value) => ok(value), "some"), none: /* @__PURE__ */ __name(() => err(error), "none") });
+    }
+    /**
+     * Transforms the `Option<T>` into a `Result<T, E>`, mapping `Some(v)` to `Ok(v)` and `None` to `Err(err())`.
+     * @param cb The error to be used.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<string> = some('hello');
+     * assert.equal(x.okOrElse(() => 0), ok('hello'));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<string> = none;
+     * assert.equal(x.okOrElse(() => 0), err(0));
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.ok_or_else}
+     */
+    okOrElse(cb) {
+      return this.match({ some: /* @__PURE__ */ __name((value) => ok(value), "some"), none: /* @__PURE__ */ __name(() => err(cb()), "none") });
+    }
+    /**
+     * Returns an iterator over the possibly contained value.
+     *
+     * The iterator yields one value if the result is `Some`, otherwise none.
+     *
+     * @example
+     * ```typescript
+     * const x = some(7);
+     * for (const value of x) {
+     *   console.log(value);
+     * }
+     * // Logs 7
+     * ```
+     * @example
+     * ```typescript
+     * const x = none;
+     * for (const value of x) {
+     *   console.log(value);
+     * }
+     * // Doesn't log
+     * ```
+     *
+     * @see {@link Option.iter}
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.iter}
+     */
     *iter() {
-      yield this.value;
-    }
+      if (this.isSome()) yield this[ValueProperty2];
+    }
+    /**
+     * Returns `None` if the option is `None`, otherwise returns `option`.
+     * @param option The option.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<number> = some(2);
+     * const y: Option<string> = none;
+     * assert.equal(x.and(y), none);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = none;
+     * const y: Option<string> = some('foo');
+     * assert.equal(x.and(y), none);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = some(2);
+     * const y: Option<string> = some('foo');
+     * assert.equal(x.and(y), some('foo'));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = none;
+     * const y: Option<string> = none;
+     * assert.equal(x.and(y), none);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.and}
+     */
     and(option) {
-      return option;
-    }
+      return this.match({ some: /* @__PURE__ */ __name(() => option, "some"), none: returnThis });
+    }
+    /**
+     * Calls `cb` if the result is `Ok`, otherwise returns the `Err` value of self.
+     *
+     * This function can be used for control flow based on `Result` values.
+     * @param cb The predicate.
+     *
+     * @example
+     * ```typescript
+     * function fractionOf4(value: number) {
+     *   return value === 0 ? none : some(4 / value);
+     * }
+     *
+     * assert.equal(some(2).andThen(fractionOf4), some(4));
+     * assert.equal(some(0).andThen(fractionOf4), none);
+     * assert.equal(none.andThen(fractionOf4), none);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.and_then}
+     */
     andThen(cb) {
-      return cb(this.value);
-    }
-    or() {
-      return this;
-    }
-    orElse() {
-      return this;
-    }
+      return this.match({ some: /* @__PURE__ */ __name((value) => cb(value), "some"), none: returnThis });
+    }
+    /**
+     * Returns the option if it contains a value, otherwise returns `option`.
+     * @param option The option.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<number> = some(2);
+     * const y: Option<number> = none;
+     * assert.equal(x.or(y), some(2));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = none;
+     * const y: Option<number> = some(100);
+     * assert.equal(x.or(y), some(100));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = some(2);
+     * const y: Option<number> = some(100);
+     * assert.equal(x.or(y), some(2));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = none;
+     * const y: Option<number> = none;
+     * assert.equal(x.or(y), none);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.or}
+     */
+    or(option) {
+      return this.match({ some: returnThis, none: /* @__PURE__ */ __name(() => option, "none") });
+    }
+    /**
+     * Calls `cb` if the result is `Ok`, otherwise returns the `Err` value of self.
+     *
+     * This function can be used for control flow based on `Result` values.
+     * @param cb The predicate.
+     *
+     * @example
+     * ```typescript
+     * const nobody = (): Option<string> => none;
+     * const vikings = (): Option<string> => some('vikings');
+     *
+     * assert.equal(some('barbarians').orElse(vikings), some('barbarians'));
+     * assert.equal(none.orElse(vikings), some('vikings'));
+     * assert.equal(none.orElse(nobody), none);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.or_else}
+     */
+    orElse(cb) {
+      return this.match({ some: returnThis, none: /* @__PURE__ */ __name(() => cb(), "none") });
+    }
+    /**
+     * Returns `Some` if exactly one of self or `option` is `Some`, otherwise returns `None`.
+     * @param option The option to compare.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<number> = some(2);
+     * const y: Option<number> = none;
+     * assert.equal(x.xor(y), some(2));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = none;
+     * const y: Option<number> = some(2);
+     * assert.equal(x.xor(y), some(2));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = some(2);
+     * const y: Option<number> = some(2);
+     * assert.equal(x.xor(y), none);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = none;
+     * const y: Option<number> = none;
+     * assert.equal(x.xor(y), none);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.xor}
+     */
     xor(option) {
-      return option.isSome() ? createNone : this;
+      return this.match({
+        some() {
+          return option.isNone() ? this : none;
+        },
+        none: /* @__PURE__ */ __name(() => option, "none")
+      });
     }
     filter(predicate) {
-      return predicate(this.value) ? this : createNone;
-    }
+      return this.isSomeAnd(predicate) ? this : none;
+    }
+    /**
+     * Returns `true` if the option is a `Some` value containing the given value.
+     * @param value The value to compare.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<number> = some(2);
+     * assert.equal(x.contains(2), true);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = some(3);
+     * assert.equal(x.contains(2), false);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<number> = none;
+     * assert.equal(x.contains(2), false);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.contains}
+     */
     contains(value) {
-      return this.value === value;
-    }
+      return this.isSomeAnd((inner) => inner === value);
+    }
+    /**
+     * Zips self with another `Option`.
+     *
+     * If self is `Some(s)` and `other` is `Some(o)`, this method returns `Some([s, o])`. Otherwise, `None` is returned.
+     * @param other The option to zip self with.
+     *
+     * @example
+     * ```typescript
+     * const x = some(1);
+     * const y = some('hi');
+     * const z = none;
+     *
+     * assert.equal(x.zip(y), some([1, 'hi']));
+     * assert.equal(x.zip(z), none);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.zip}
+     */
     zip(other) {
-      return other.map((o) => [this.value, o]);
-    }
+      return this.isSome() && other.isSome() ? some([this[ValueProperty2], other[ValueProperty2]]) : none;
+    }
+    /**
+     * Zips self and another `Option` with function `f`.
+     *
+     * If self is `Some(s)` and other is `Some(o)`, this method returns `Some(f(s, o))`. Otherwise, `None` is returned.
+     * @param other The option to zip self with.
+     * @param f The function that computes the returned value.
+     *
+     * @example
+     * ```typescript
+     * class Point {
+     *   public readonly x: number;
+     *   public readonly y: number;
+     *
+     *   public constructor(x: number, y: number) {
+     *     this.x = x;
+     *     this.y = y;
+     *   }
+     * }
+     *
+     * const x = some(17.5);
+     * const y = some(42.7);
+     *
+     * assert.equal(x.zipWith(y, (s, o) => new Point(s, o)), some(new Point(17.5, 42.7)));
+     * assert.equal(x.zipWith(none, (s, o) => new Point(s, o)), none);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.zip_with}
+     */
     zipWith(other, f) {
-      return other.map((o) => f(this.value, o));
-    }
+      return this.isSome() && other.isSome() ? some(f(this[ValueProperty2], other[ValueProperty2])) : none;
+    }
+    /**
+     * Unzips an option containing a tuple of two options.
+     *
+     * If self is `Some([a, b])` this method returns `[Some(a), Some(b)]`. Otherwise, `[None, None]` is returned.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<[number, string]> = some([1, 'hi']);
+     * assert.equal(x.unzip(), [some(1), some('hi')]);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<[number, string]> = none;
+     * assert.equal(x.unzip(), [none, none]);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.unzip}
+     */
     unzip() {
-      const [s, o] = this.value;
-      return [createSome(s), createSome(o)];
-    }
-    transpose() {
-      return this.value.match({
-        ok: (v) => createOk(createSome(v)),
-        err: (e) => createErr(e)
+      return this.match({
+        some: /* @__PURE__ */ __name(([value0, value1]) => [some(value0), some(value1)], "some"),
+        none: /* @__PURE__ */ __name(() => [none, none], "none")
       });
     }
-    flatten() {
-      return this.value;
-    }
-    async intoPromise() {
-      return createSome(await this.value);
-    }
-    eq(other) {
-      return other.isSomeAnd((value) => this.value === value);
-    }
-    ne(other) {
-      return !this.eq(other);
-    }
-    match(branches) {
-      return branches.some(this.value);
-    }
-    *[Symbol.iterator]() {
-      yield this.value;
-    }
-  };
-  __name(_OptionSome, "OptionSome");
-  var OptionSome = _OptionSome;
-  function createSome(value) {
-    return new OptionSome(value);
-  }
-  __name(createSome, "createSome");
-
-  // src/lib/Result/Err.ts
-  var _ResultErr = class _ResultErr {
-    constructor(error) {
-      __publicField(this, "error");
-      this.error = error;
-    }
-    isOk() {
-      return false;
-    }
-    isOkAnd() {
-      return false;
-    }
-    isErr() {
-      return true;
-    }
-    isErrAnd(cb) {
-      return cb(this.error);
-    }
-    ok() {
-      return createNone;
-    }
-    err() {
-      return createSome(this.error);
-    }
-    map() {
-      return this;
-    }
-    mapInto() {
-      return this;
-    }
-    mapOr(defaultValue) {
-      return defaultValue;
-    }
-    mapOrElse(op) {
-      return op(this.error);
-    }
-    mapErr(cb) {
-      return createErr(cb(this.error));
-    }
-    mapErrInto(cb) {
-      return cb(this.error);
-    }
-    inspect() {
-      return this;
-    }
-    inspectAsync() {
-      return Promise.resolve(this);
-    }
-    inspectErr(cb) {
-      cb(this.error);
-      return this;
-    }
-    async inspectErrAsync(cb) {
-      await cb(this.error);
-      return this;
-    }
-    *iter() {
-    }
-    expect(message) {
-      throw new ResultError(message, this.error);
-    }
-    expectErr() {
-      return this.error;
-    }
-    unwrap() {
-      throw new ResultError("Unwrap failed", this.error);
-    }
-    unwrapErr() {
-      return this.error;
-    }
-    unwrapOr(defaultValue) {
-      return defaultValue;
-    }
-    unwrapOrElse(op) {
-      return op(this.error);
-    }
-    unwrapRaw() {
-      throw this.error;
-    }
-    and() {
-      return this;
-    }
-    andThen() {
-      return this;
-    }
-    or(result) {
-      return result;
-    }
-    orElse(cb) {
-      return cb(this.error);
-    }
-    contains() {
-      return false;
-    }
-    containsErr(error) {
-      return this.error === error;
-    }
+    /**
+     * Transposes an `Option` of a `Result` into a `Result` of an `Option`.
+     *
+     * `none` will be mapped to `ok(none)`. `some(ok(v))` and `some(err(e))` will be mapped to `ok(some(v))` and `err(e)`.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<Result<number, Error>> = some(ok(5));
+     * const y: Result<Option<number>, Error> = ok(some(5));
+     * assert.equal(x.transpose(), y);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.transpose}
+     */
     transpose() {
-      return createSome(this);
-    }
-    flatten() {
-      return this;
-    }
-    intoOkOrErr() {
-      return this.error;
-    }
-    async intoPromise() {
-      return createErr(await this.error);
-    }
-    eq(other) {
-      return other.isErrAnd((error) => this.error === error);
-    }
-    ne(other) {
-      return !this.eq(other);
-    }
-    match(branches) {
-      return branches.err(this.error);
-    }
-    *[Symbol.iterator]() {
-    }
-  };
-  __name(_ResultErr, "ResultErr");
-  var ResultErr = _ResultErr;
-  function createErr(x) {
-    return new ResultErr(x);
-  }
-  __name(createErr, "createErr");
-
-  // src/lib/Option/OptionError.ts
-  var _OptionError = class _OptionError extends Error {
-    get name() {
-      return this.constructor.name;
-    }
-  };
-  __name(_OptionError, "OptionError");
-  var OptionError = _OptionError;
-
-  // src/lib/Option/None.ts
-  var _OptionNone = class _OptionNone {
-    isSome() {
-      return false;
-    }
-    isSomeAnd() {
-      return false;
-    }
-    isNone() {
-      return true;
-    }
-    expect(message) {
-      throw new OptionError(message);
-    }
-    unwrap() {
-      throw new OptionError("Unwrap failed");
-    }
-    unwrapOr(defaultValue) {
-      return defaultValue;
-    }
-    unwrapOrElse(cb) {
-      return cb();
-    }
-    map() {
-      return this;
-    }
-    mapInto() {
-      return this;
-    }
-    mapOr(defaultValue) {
-      return defaultValue;
-    }
-    mapOrElse(defaultValue) {
-      return defaultValue();
-    }
-    mapNoneInto(cb) {
-      return cb();
-    }
-    inspect() {
-      return this;
-    }
-    inspectAsync() {
-      return Promise.resolve(this);
-    }
-    okOr(error) {
-      return createErr(error);
-    }
-    okOrElse(cb) {
-      return createErr(cb());
-    }
-    *iter() {
-    }
-    and() {
-      return this;
-    }
-    andThen() {
-      return this;
-    }
-    or(option) {
-      return option;
-    }
-    orElse(cb) {
-      return cb();
-    }
-    xor(option) {
-      return option.isSome() ? option : this;
-    }
-    filter() {
-      return this;
-    }
-    contains() {
-      return false;
-    }
-    zip() {
-      return this;
-    }
-    zipWith() {
-      return this;
-    }
-    unzip() {
-      return [this, this];
-    }
-    transpose() {
-      return createOk(this);
+      return this.match({
+        // @ts-expect-error Complex types
+        some: /* @__PURE__ */ __name((result) => result.map(some), "some"),
+        none: /* @__PURE__ */ __name(() => ok(none), "none")
+      });
     }
+    /**
+     * Converts from `Result<Result<T, E>, E>` to `Result<T, E>`.
+     *
+     * @example
+     * ```typescript
+     * const x: Option<Option<number>> = some(some(6));
+     * assert.equal(x.flatten(), some(6));
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<Option<number>> = some(none);
+     * assert.equal(x.flatten(), none);
+     * ```
+     * @example
+     * ```typescript
+     * const x: Option<Option<number>> = none;
+     * assert.equal(x.flatten(), none);
+     * ```
+     *
+     * @see {@link https://doc.rust-lang.org/std/result/enum.Result.html#method.flatten}
+     */
     flatten() {
-      return this;
-    }
+      return this.match({ some: /* @__PURE__ */ __name((inner) => inner, "some"), none: returnThis });
+    }
+    /**
+     * Returns a `Promise` object with the awaited value (if `Some`).
+     *
+     * @example
+     * ```typescript
+     * let x = some(Promise.resolve(3));
+     * assert.equal(await x.intoPromise(), some(3));
+     * ```
+     *
+     * @note This is an extension not supported in Rust
+     */
     intoPromise() {
-      return Promise.resolve(createNone);
+      return this.match({
+        some: /* @__PURE__ */ __name(async (value) => some(await value), "some"),
+        // NOSONAR
+        none: /* @__PURE__ */ __name(() => Promise.resolve(none), "none")
+      });
     }
+    /**
+     * Checks whether or not `other` equals with self.
+     * @param other The other option to compare.
+     *
+     * @see {@link https://doc.rust-lang.org/std/cmp/trait.PartialEq.html#tymethod.eq}
+     */
     eq(other) {
-      return other.isNone();
-    }
+      return this.isSome() === other.isSome() && this[ValueProperty2] === other[ValueProperty2];
+    }
+    /**
+     * Checks whether or not `other` doesn't equal with self.
+     * @param other The other option to compare.
+     *
+     * @see {@link https://doc.rust-lang.org/std/cmp/trait.PartialEq.html#method.ne}
+     */
     ne(other) {
-      return other.isSome();
+      return !this.eq(other);
     }
+    /**
+     * Runs `ok` function if self is `Ok`, otherwise runs `err` function.
+     * @param branches The branches to match.
+     *
+     * @example
+     * ```typescript
+     * const option = some(4).match({
+     *   some: (v) => v,
+     *   none: () => 0
+     * });
+     * assert.equal(option, 4);
+     * ```
+     * @example
+     * ```typescript
+     * const option = none.match({
+     *   some: (v) => v,
+     *   none: () => 0
+     * });
+     * assert.equal(option, 0);
+     * ```
+     */
     match(branches) {
-      return branches.none();
-    }
-    *[Symbol.iterator]() {
-    }
-  };
-  __name(_OptionNone, "OptionNone");
-  var OptionNone = _OptionNone;
-  var createNone = new OptionNone();
-
-  // src/lib/Option.ts
-  exports.Option = void 0;
-  ((Option2) => {
-    function resolve(value) {
-      if (value === null || value === void 0)
-        return Option2.none;
-      if (is(value))
-        return value;
-      return (0, Option2.some)(value);
-    }
-    __name(resolve, "resolve");
-    function is(value) {
-      return value instanceof OptionNone || value instanceof OptionSome;
-    }
-    Option2.is = is;
-    __name(is, "is");
-    function from(op) {
-      if (!isFunction(op))
-        return resolve(op);
+      return this.isSome() ? branches.some.call(this, this[ValueProperty2]) : branches.none.call(this);
+    }
+    /**
+     * Returns an iterator over the possibly contained value.
+     *
+     * The iterator yields one value if the result is `Some`, otherwise none.
+     *
+     * @example
+     * ```typescript
+     * const x = some(7);
+     * for (const value of x) {
+     *   console.log(value);
+     * }
+     * // Logs 7
+     * ```
+     * @example
+     * ```typescript
+     * const x = none;
+     * for (const value of x) {
+     *   console.log(value);
+     * }
+     * // Doesn't log
+     * ```
+     *
+     * @see {@link IOption.iter}
+     * @see {@link https://doc.rust-lang.org/std/option/enum.Option.html#method.iter}
+     */
+    [(_b2 = ValueProperty2, _a2 = ExistsProperty, Symbol.iterator)]() {
+      return this.iter();
+    }
+    get [Symbol.toStringTag]() {
+      return this.match({ some: /* @__PURE__ */ __name(() => "Some", "some"), none: /* @__PURE__ */ __name(() => "None", "none") });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    static some(value) {
+      return new _Option(value, true);
+    }
+    /**
+     * Checks if the `instance` object is an instance of `Option`, or if it is a `Option`-like object. This override
+     * exists to interoperate with other versions of this class, such as the one coming from another version of this
+     * library or from a different build.
+     *
+     * @param instance The instance to check.
+     * @returns Whether or not the instance is a `Option`.
+     *
+     * @example
+     * ```typescript
+     * import { Option } from '@sapphire/result';
+     * const { some } = require('@sapphire/result');
+     *
+     * some(2) instanceof Option; // true
+     * ```
+     */
+    static [Symbol.hasInstance](instance) {
+      return typeof instance === "object" && instance !== null && ValueProperty2 in instance && ExistsProperty in instance;
+    }
+    /**
+     * @deprecated Use {@link Option.isOption} instead.
+     *
+     * Checks if the `instance` object is an instance of `Option`, or if it is a `Option`-like object.
+     *
+     * @param instance The instance to check.
+     * @returns true if the instance is a `Option` or a `Option`-like object, false otherwise.
+     *
+     * @example
+     * ```typescript
+     * import { Option } from '@sapphire/result';
+     * const { some } = require('@sapphire/result');
+     *
+     * Option.isOption(some(2)); // true
+     * ```
+     */
+    static is(instance) {
+      return _Option[Symbol.hasInstance](instance);
+    }
+    /**
+     * Checks if the `instance` object is an instance of `Option`, or if it is a `Option`-like object.
+     *
+     * @param instance The instance to check.
+     * @returns true if the instance is a `Option` or a `Option`-like object, false otherwise.
+     *
+     * @example
+     * ```typescript
+     * import { Option } from '@sapphire/result';
+     * const { some } = require('@sapphire/result');
+     *
+     * Option.isOption(some(2)); // true
+     * ```
+     */
+    static isOption(instance) {
+      return _Option[Symbol.hasInstance](instance);
+    }
+    /**
+     * Creates a {@link Result} out of a callback.
+     *
+     * @typeparam T The result's type.
+     * @typeparam E The error's type.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    static from(op) {
       try {
-        return resolve(op());
+        return resolve2(isFunction(op) ? op() : op);
       } catch {
-        return Option2.none;
+        return none;
       }
     }
-    Option2.from = from;
-    __name(from, "from");
-    async function fromAsync(op) {
+    /**
+     * Creates a {@link Result} out of a promise or async callback.
+     *
+     * @typeparam T The result's type.
+     * @typeparam E The error's type.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    static async fromAsync(op) {
       try {
-        return resolve(await (isFunction(op) ? op() : op));
+        return resolve2(await (isFunction(op) ? op() : op));
       } catch {
-        return Option2.none;
-      }
-    }
-    Option2.fromAsync = fromAsync;
-    __name(fromAsync, "fromAsync");
-    function all(options) {
-      const values = [];
-      for (const option of options) {
-        if (option.isNone()) {
-          return option;
-        }
-        values.push(option.unwrap());
-      }
-      return (0, Option2.some)(values);
-    }
-    Option2.all = all;
-    __name(all, "all");
-    function any(options) {
-      for (const result of options) {
-        if (result.isSome()) {
-          return result;
-        }
-      }
-      return Option2.none;
-    }
-    Option2.any = any;
-    __name(any, "any");
-    Option2.none = createNone;
-    Option2.some = createSome;
-  })(exports.Option || (exports.Option = {}));
-
-  // src/lib/Result.ts
-  exports.Result = void 0;
-  ((Result2) => {
-    function resolve(value) {
-      if (is(value))
-        return value;
-      return (0, Result2.ok)(value);
-    }
-    __name(resolve, "resolve");
-    function is(value) {
-      return value instanceof ResultOk || value instanceof ResultErr;
-    }
-    Result2.is = is;
-    __name(is, "is");
-    function from(op) {
-      if (!isFunction(op))
-        return resolve(op);
-      try {
-        return resolve(op());
-      } catch (error) {
-        return (0, Result2.err)(error);
-      }
-    }
-    Result2.from = from;
-    __name(from, "from");
-    async function fromAsync(op) {
-      try {
-        return resolve(await (isFunction(op) ? op() : op));
-      } catch (error) {
-        return (0, Result2.err)(error);
+        return none;
       }
     }
-    Result2.fromAsync = fromAsync;
-    __name(fromAsync, "fromAsync");
-    function all(results) {
+    /**
+     * Creates an {@link Ok} that is the combination of all collected {@link Ok} values as an array, or the first
+     * {@link Err} encountered.
+     *
+     * @param results An array of {@link Result}s.
+     * @returns A new {@link Result}.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    static all(results) {
       const values = [];
       for (const result of results) {
-        if (result.isErr()) {
-          return result;
-        }
-        values.push(result.unwrap());
+        if (result.isNone()) return result;
+        values.push(result[ValueProperty2]);
       }
-      return (0, Result2.ok)(values);
-    }
-    Result2.all = all;
-    __name(all, "all");
-    function any(results) {
-      const errors = [];
+      return some(values);
+    }
+    /**
+     * Returns the first encountered {@link Some}, or a {@link None} if none was found.
+     *
+     * @param options An array of {@link Option}s.
+     * @returns A new {@link Option}.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    static any(results) {
       for (const result of results) {
-        if (result.isOk()) {
-          return result;
-        }
-        errors.push(result.unwrapErr());
+        if (result.isSome()) return result;
       }
-      return (0, Result2.err)(errors);
+      return none;
     }
-    Result2.any = any;
-    __name(any, "any");
-    Result2.err = createErr;
-    Result2.ok = createOk;
-  })(exports.Result || (exports.Result = {}));
+  };
+  __name(_Option, "Option");
+  __publicField(_Option, "none", new _Option(null, false));
+  var Option = _Option;
+  var { some, none } = Option;
+  function resolve2(value) {
+    if (value === null || value === void 0) return none;
+    if (Option.isOption(value)) return value;
+    return some(value);
+  }
+  __name(resolve2, "resolve");
 
+  exports.Option = Option;
   exports.OptionError = OptionError;
+  exports.Result = Result;
   exports.ResultError = ResultError;
-  exports.err = createErr;
-  exports.none = createNone;
-  exports.ok = createOk;
-  exports.some = createSome;
+  exports.err = err;
+  exports.none = none;
+  exports.ok = ok;
+  exports.some = some;
 
   return exports;
 
 })({});
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.global.js.map
 //# sourceMappingURL=index.global.js.map