@semyonf/kamchazky 0.2.0

package/dist/index.cjs

@@ -0,0 +1,482 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all2) => {
+  for (var name in all2)
+    __defProp(target, name, { get: all2[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Maybe: () => Maybe,
+  Result: () => Result,
+  err: () => err,
+  isErr: () => isErr,
+  isNone: () => isNone,
+  isOk: () => isOk,
+  isSome: () => isSome,
+  none: () => none,
+  normalizeError: () => normalizeError,
+  ok: () => ok,
+  some: () => some
+});
+module.exports = __toCommonJS(src_exports);
+function ok(value) {
+  const self = Object.freeze({
+    ok: true,
+    value,
+    map: (fn) => ok(fn(value)),
+    flatMap: (fn) => fn(value),
+    mapError: (_fn) => self,
+    inspect: (fn) => {
+      fn(value);
+      return self;
+    },
+    inspectError: (_fn) => self,
+    match: (handlers) => handlers.ok(value),
+    unwrap: () => value,
+    unwrapOr: (_fallback) => value,
+    unwrapOrElse: (_fn) => value,
+    expect: (_message) => value
+  });
+  return self;
+}
+function err(error) {
+  const self = Object.freeze({
+    ok: false,
+    error,
+    map: (_fn) => self,
+    flatMap: (_fn) => self,
+    mapError: (fn) => err(fn(error)),
+    inspect: (_fn) => self,
+    inspectError: (fn) => {
+      fn(error);
+      return self;
+    },
+    match: (handlers) => handlers.err(error),
+    unwrap: () => {
+      throw error;
+    },
+    unwrapOr: (fallback) => fallback,
+    unwrapOrElse: (fn) => fn(),
+    expect: (message) => {
+      const thrown = new Error(`${message}: ${error.message}`, {
+        cause: error
+      });
+      Object.setPrototypeOf(thrown, error.constructor.prototype);
+      if (error.stack !== void 0)
+        thrown.stack = error.stack;
+      throw thrown;
+    }
+  });
+  return self;
+}
+function isOk(result) {
+  return result.ok;
+}
+function isErr(result) {
+  return !result.ok;
+}
+function map(result, fn) {
+  return result.ok ? ok(fn(result.value)) : result;
+}
+function mapError(result, fn) {
+  return result.ok ? result : err(fn(result.error));
+}
+function inspect(result, fn) {
+  if (result.ok)
+    fn(result.value);
+  return result;
+}
+function inspectError(result, fn) {
+  if (!result.ok)
+    fn(result.error);
+  return result;
+}
+function flatMap(result, fn) {
+  if (result.ok)
+    return fn(result.value);
+  return result;
+}
+function orElse(result, fn) {
+  if (!result.ok)
+    return fn(result.error);
+  return result;
+}
+function flatMapErr(result, fn) {
+  return orElse(result, fn);
+}
+function flatten(result) {
+  return result.ok ? result.value : result;
+}
+function match(result, handlers) {
+  return result.ok ? handlers.ok(result.value) : handlers.err(result.error);
+}
+function exhaustive(value) {
+  let detail;
+  try {
+    detail = JSON.stringify(value);
+  } catch {
+    detail = String(value);
+  }
+  throw new Error(`Unhandled result case: ${detail}`);
+}
+function unwrap(result) {
+  if (result.ok)
+    return result.value;
+  throw result.error;
+}
+function unwrapOr(result, fallback) {
+  return result.ok ? result.value : fallback;
+}
+function unwrapOrElse(result, fn) {
+  return result.ok ? result.value : fn();
+}
+function expect(result, message) {
+  if (result.ok)
+    return result.value;
+  const thrown = new Error(`${message}: ${result.error.message}`, {
+    cause: result.error
+  });
+  Object.setPrototypeOf(thrown, result.error.constructor.prototype);
+  if (result.error.stack !== void 0)
+    thrown.stack = result.error.stack;
+  throw thrown;
+}
+function fromNullable(value, errorFactory) {
+  return value != null ? ok(value) : err(errorFactory());
+}
+function fromPredicate(value, predicate, errorFactory) {
+  return predicate(value) ? ok(value) : err(errorFactory());
+}
+function normalizeError(error) {
+  if (error instanceof Error)
+    return error;
+  if (error === null || error === void 0)
+    return new Error(String(error));
+  if (typeof error === "object") {
+    try {
+      const json = JSON.stringify(error);
+      if (json !== "{}")
+        return new Error(json);
+    } catch {
+    }
+  }
+  try {
+    return new Error(String(error));
+  } catch {
+    return new Error("Non-stringifiable thrown value");
+  }
+}
+function tryCatch(fn, onError) {
+  try {
+    return ok(fn());
+  } catch (error) {
+    try {
+      return err(onError ? onError(error) : normalizeError(error));
+    } catch (mapperError) {
+      return err(new Error("Error mapper threw", { cause: mapperError }));
+    }
+  }
+}
+async function tryCatchAsync(fn, onError) {
+  try {
+    return ok(await fn());
+  } catch (error) {
+    try {
+      return err(onError ? onError(error) : normalizeError(error));
+    } catch (mapperError) {
+      return err(new Error("Error mapper threw", { cause: mapperError }));
+    }
+  }
+}
+async function fromPromise(promise, onError) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    try {
+      return err(onError ? onError(error) : normalizeError(error));
+    } catch (mapperError) {
+      return err(new Error("Error mapper threw", { cause: mapperError }));
+    }
+  }
+}
+function all(...results) {
+  const values = [];
+  for (const result of results) {
+    if (!result.ok)
+      return err(result.error);
+    values.push(result.value);
+  }
+  return ok(values);
+}
+async function allAsync(...promises) {
+  const settled = await Promise.allSettled(promises);
+  const values = [];
+  for (const s of settled) {
+    if (s.status === "rejected") {
+      return err(normalizeError(s.reason));
+    }
+    if (!s.value.ok) {
+      return err(s.value.error);
+    }
+    values.push(s.value.value);
+  }
+  return ok(values);
+}
+async function collectAsync(...promises) {
+  const settled = await Promise.allSettled(promises);
+  const values = [];
+  const errors = [];
+  for (const s of settled) {
+    if (s.status === "rejected") {
+      errors.push(normalizeError(s.reason));
+    } else if (!s.value.ok) {
+      errors.push(s.value.error);
+    } else {
+      values.push(s.value.value);
+    }
+  }
+  if (errors.length > 0)
+    return err(new AggregateError(errors));
+  return ok(values);
+}
+function collect(...results) {
+  const values = [];
+  const errors = [];
+  for (const result of results) {
+    if (result.ok)
+      values.push(result.value);
+    else
+      errors.push(result.error);
+  }
+  if (errors.length > 0)
+    return err(new AggregateError(errors));
+  return ok(values);
+}
+function some(value) {
+  const self = Object.freeze({
+    some: true,
+    value,
+    map: (fn) => some(fn(value)),
+    flatMap: (fn) => fn(value),
+    filter: (predicate) => predicate(value) ? self : NONE,
+    inspect: (fn) => {
+      fn(value);
+      return self;
+    },
+    match: (handlers) => handlers.some(value),
+    unwrap: () => value,
+    expect: (_message) => value,
+    unwrapOr: (_fallback) => value,
+    unwrapOrElse: (_fn) => value
+  });
+  return self;
+}
+var NONE = Object.freeze({
+  some: false,
+  map: (_fn) => NONE,
+  flatMap: (_fn) => NONE,
+  filter: (_predicate) => NONE,
+  inspect: (_fn) => NONE,
+  match: (handlers) => handlers.none(),
+  unwrap: () => {
+    throw new Error("Called unwrap on None");
+  },
+  expect: (message) => {
+    throw new Error(message);
+  },
+  unwrapOr: (fallback) => fallback,
+  unwrapOrElse: (fn) => fn()
+});
+function none() {
+  return NONE;
+}
+function isSome(maybe) {
+  return maybe.some;
+}
+function isNone(maybe) {
+  return !maybe.some;
+}
+function maybeMap(maybe, fn) {
+  return maybe.some ? some(fn(maybe.value)) : NONE;
+}
+function maybeFlatMap(maybe, fn) {
+  return maybe.some ? fn(maybe.value) : NONE;
+}
+function maybeFlatten(maybe) {
+  return maybe.some ? maybe.value : NONE;
+}
+function maybeFilter(maybe, predicate) {
+  return maybe.some && predicate(maybe.value) ? maybe : NONE;
+}
+function maybeInspect(maybe, fn) {
+  if (maybe.some)
+    fn(maybe.value);
+  return maybe;
+}
+function maybeMatch(maybe, handlers) {
+  return maybe.some ? handlers.some(maybe.value) : handlers.none();
+}
+function maybeUnwrap(maybe) {
+  if (maybe.some)
+    return maybe.value;
+  throw new Error("Called unwrap on None");
+}
+function maybeUnwrapOr(maybe, fallback) {
+  return maybe.some ? maybe.value : fallback;
+}
+function maybeUnwrapOrElse(maybe, fn) {
+  return maybe.some ? maybe.value : fn();
+}
+function maybeExpect(maybe, message) {
+  if (maybe.some)
+    return maybe.value;
+  throw new Error(message);
+}
+function maybeFromNullable(value) {
+  return value != null ? some(value) : NONE;
+}
+function maybeFromPredicate(value, predicate) {
+  return predicate(value) ? some(value) : NONE;
+}
+function maybeAll(...maybes) {
+  const values = [];
+  for (const m of maybes) {
+    if (!m.some)
+      return NONE;
+    values.push(m.value);
+  }
+  return some(values);
+}
+function maybeFirstSome(...maybes) {
+  for (const m of maybes) {
+    if (m.some)
+      return m;
+  }
+  return NONE;
+}
+async function maybeAllAsync(...promises) {
+  const settled = await Promise.allSettled(promises);
+  const values = [];
+  for (const s of settled) {
+    if (s.status === "rejected")
+      return NONE;
+    if (!s.value.some)
+      return NONE;
+    values.push(s.value.value);
+  }
+  return some(values);
+}
+var maybeCollect = maybeAll;
+function maybeToResult(maybe, errorFactory) {
+  return maybe.some ? ok(maybe.value) : err(errorFactory());
+}
+function maybeFromResult(result) {
+  return result.ok ? some(result.value) : NONE;
+}
+function resultToMaybe(result) {
+  return maybeFromResult(result);
+}
+function resultFromMaybe(maybe, errorFactory) {
+  return maybeToResult(maybe, errorFactory);
+}
+function resultTranspose(result) {
+  if (!result.ok)
+    return some(result);
+  if (result.value.some)
+    return some(ok(result.value.value));
+  return NONE;
+}
+function maybeTranspose(maybe) {
+  if (!maybe.some)
+    return ok(NONE);
+  if (maybe.value.ok)
+    return ok(some(maybe.value.value));
+  return err(maybe.value.error);
+}
+var Maybe = {
+  some,
+  none,
+  isSome,
+  isNone,
+  map: maybeMap,
+  flatMap: maybeFlatMap,
+  flatten: maybeFlatten,
+  filter: maybeFilter,
+  inspect: maybeInspect,
+  match: maybeMatch,
+  unwrap: maybeUnwrap,
+  unwrapOr: maybeUnwrapOr,
+  unwrapOrElse: maybeUnwrapOrElse,
+  expect: maybeExpect,
+  fromNullable: maybeFromNullable,
+  fromPredicate: maybeFromPredicate,
+  all: maybeAll,
+  allAsync: maybeAllAsync,
+  collect: maybeCollect,
+  firstSome: maybeFirstSome,
+  toResult: maybeToResult,
+  fromResult: maybeFromResult,
+  transpose: maybeTranspose
+};
+var Result = {
+  ok,
+  err,
+  isOk,
+  isErr,
+  map,
+  mapError,
+  inspect,
+  inspectError,
+  flatMap,
+  flatMapErr,
+  orElse,
+  flatten,
+  match,
+  exhaustive,
+  unwrap,
+  unwrapOr,
+  unwrapOrElse,
+  expect,
+  fromNullable,
+  fromPredicate,
+  normalizeError,
+  tryCatch,
+  tryCatchAsync,
+  fromPromise,
+  all,
+  allAsync,
+  collect,
+  collectAsync,
+  toMaybe: resultToMaybe,
+  fromMaybe: resultFromMaybe,
+  transpose: resultTranspose
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Maybe,
+  Result,
+  err,
+  isErr,
+  isNone,
+  isOk,
+  isSome,
+  none,
+  normalizeError,
+  ok,
+  some
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/** A successful result containing a value of type `T`. */\nexport type OkResult<T> = {\n  readonly ok: true;\n  readonly value: T;\n  map<U>(fn: (value: T) => U): OkResult<U>;\n  flatMap<U, F extends Error = never>(\n    fn: (value: T) => Result<U, F>\n  ): Result<U, F>;\n  mapError<F extends Error>(fn: (error: never) => F): OkResult<T>;\n  inspect(fn: (value: T) => void): OkResult<T>;\n  inspectError(fn: (error: never) => void): OkResult<T>;\n  match<R>(handlers: { ok: (value: T) => R; err: (error: never) => R }): R;\n  unwrap(): T;\n  unwrapOr(fallback: T): T;\n  unwrapOrElse(fn: () => T): T;\n  expect(message: string): T;\n};\n\n/** A failed result containing an error of type `E`. */\nexport type ErrResult<E extends Error = Error> = {\n  readonly ok: false;\n  readonly error: E;\n  map<U>(fn: (value: never) => U): ErrResult<E>;\n  flatMap<U, F extends Error = never>(\n    fn: (value: never) => Result<U, F>\n  ): ErrResult<E>;\n  mapError<F extends Error>(fn: (error: E) => F): ErrResult<F>;\n  inspect(fn: (value: never) => void): ErrResult<E>;\n  inspectError(fn: (error: E) => void): ErrResult<E>;\n  match<R>(handlers: { ok: (value: never) => R; err: (error: E) => R }): R;\n  unwrap(): never;\n  unwrapOr<T>(fallback: T): T;\n  unwrapOrElse<T>(fn: () => T): T;\n  expect(message: string): never;\n};\n\n/**\n * A value that is either a success (`OkResult<T>`) or a failure\n * (`ErrResult<E>`).  Use `Result.ok` / `Result.err` to construct, and the\n * companion `Result.*` functions or instance methods to transform.\n */\nexport type Result<T, E extends Error = Error> = OkResult<T> | ErrResult<E>;\n\ntype AnyResult = Result<unknown, Error>;\n\ntype ValueOf<R> = R extends OkResult<infer T> ? T : never;\ntype ErrorOf<R> = R extends ErrResult<infer E> ? E : never;\n\ntype TupleValues<R extends readonly AnyResult[]> = {\n  [K in keyof R]: ValueOf<R[K]>;\n};\ntype TupleErrors<R extends readonly AnyResult[]> = ErrorOf<R[number]>;\n\n/** Create a successful `Result` containing `value`. */\nfunction ok<T>(value: T): OkResult<T> {\n  const self: OkResult<T> = Object.freeze({\n    ok: true as const,\n    value,\n    map: <U>(fn: (value: T) => U): OkResult<U> => ok(fn(value)),\n    flatMap: <U, F extends Error = never>(\n      fn: (value: T) => Result<U, F>\n    ): Result<U, F> => fn(value),\n    mapError: <F extends Error>(_fn: (error: never) => F): OkResult<T> => self,\n    inspect: (fn: (value: T) => void): OkResult<T> => {\n      fn(value);\n      return self;\n    },\n    inspectError: (_fn: (error: never) => void): OkResult<T> => self,\n    match: <R>(handlers: {\n      ok: (value: T) => R;\n      err: (error: never) => R;\n    }): R => handlers.ok(value),\n    unwrap: (): T => value,\n    unwrapOr: (_fallback: T): T => value,\n    unwrapOrElse: (_fn: () => T): T => value,\n    expect: (_message: string): T => value,\n  });\n  return self;\n}\n\n/** Create a failed `Result` containing `error`. */\nfunction err<E extends Error>(error: E): ErrResult<E> {\n  const self: ErrResult<E> = Object.freeze({\n    ok: false as const,\n    error,\n    map: <U>(_fn: (value: never) => U): ErrResult<E> => self,\n    flatMap: <U, F extends Error = never>(\n      _fn: (value: never) => Result<U, F>\n    ): ErrResult<E> => self,\n    mapError: <F extends Error>(fn: (error: E) => F): ErrResult<F> =>\n      err(fn(error)),\n    inspect: (_fn: (value: never) => void): ErrResult<E> => self,\n    inspectError: (fn: (error: E) => void): ErrResult<E> => {\n      fn(error);\n      return self;\n    },\n    match: <R>(handlers: {\n      ok: (value: never) => R;\n      err: (error: E) => R;\n    }): R => handlers.err(error),\n    unwrap: (): never => {\n      throw error;\n    },\n    unwrapOr: <T>(fallback: T): T => fallback,\n    unwrapOrElse: <T>(fn: () => T): T => fn(),\n    expect: (message: string): never => {\n      const thrown = new Error(`${message}: ${error.message}`, {\n        cause: error,\n      });\n      Object.setPrototypeOf(thrown, error.constructor.prototype);\n      if (error.stack !== undefined) thrown.stack = error.stack;\n      throw thrown;\n    },\n  });\n  return self;\n}\n\n/** Narrow a `Result` to `OkResult`. */\nfunction isOk<T, E extends Error>(result: Result<T, E>): result is OkResult<T> {\n  return result.ok;\n}\n\n/** Narrow a `Result` to `ErrResult`. */\nfunction isErr<T, E extends Error>(\n  result: Result<T, E>\n): result is ErrResult<E> {\n  return !result.ok;\n}\n\n/** Transform the value inside an `Ok`, leaving `Err` unchanged. */\nfunction map<T, U>(result: OkResult<T>, fn: (value: T) => U): OkResult<U>;\nfunction map<T, U, E extends Error>(\n  result: Result<T, E>,\n  fn: (value: T) => U\n): Result<U, E>;\nfunction map<T, U, E extends Error>(\n  result: Result<T, E>,\n  fn: (value: T) => U\n): Result<U, E> {\n  return result.ok ? ok(fn(result.value)) : result;\n}\n\n/** Transform the error inside an `Err`, leaving `Ok` unchanged. */\nfunction mapError<T>(\n  result: OkResult<T>,\n  fn: (error: never) => Error\n): OkResult<T>;\nfunction mapError<T, E extends Error, F extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => F\n): Result<T, F>;\nfunction mapError<T, E extends Error, F extends Error>(\n  result: OkResult<T> | Result<T, E>,\n  fn: ((error: never) => Error) | ((error: E) => F)\n): OkResult<T> | Result<T, F> {\n  return result.ok ? result : err((fn as (error: E) => F)(result.error));\n}\n\n/** Run a side-effect on the `Ok` value without transforming the result. */\nfunction inspect<T>(result: OkResult<T>, fn: (value: T) => void): OkResult<T>;\nfunction inspect<T, E extends Error>(\n  result: Result<T, E>,\n  fn: (value: T) => void\n): Result<T, E>;\nfunction inspect<T, E extends Error>(\n  result: Result<T, E>,\n  fn: (value: T) => void\n): Result<T, E> {\n  if (result.ok) fn(result.value);\n  return result;\n}\n\n/** Run a side-effect on the `Err` error without transforming the result. */\nfunction inspectError<E extends Error>(\n  result: ErrResult<E>,\n  fn: (error: E) => void\n): ErrResult<E>;\nfunction inspectError<T, E extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => void\n): Result<T, E>;\nfunction inspectError<T, E extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => void\n): Result<T, E> {\n  if (!result.ok) fn(result.error);\n  return result;\n}\n\n/** Chain a `Result`-returning function on the `Ok` value. */\nfunction flatMap<T, U, E extends Error, F extends Error = never>(\n  result: Result<T, E>,\n  fn: (value: T) => Result<U, F>\n): Result<U, E | F> {\n  if (result.ok) return fn(result.value);\n  // Safe: ErrResult<E> ⊆ Result<U, E | F>  — error type is widened, value\n  // channel is unused.  The assertion is needed because ErrResult's methods\n  // make E invariant in TypeScript's structural checker.\n  return result as ErrResult<E | F>;\n}\n\n/**\n * Recover from an error by applying `fn` to produce a new `Result`.\n * Alias: `flatMapErr`.\n */\nfunction orElse<T, E extends Error, F extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => Result<T, F>\n): Result<T, F> {\n  if (!result.ok) return fn(result.error);\n  // Safe: OkResult<T> ⊆ Result<T, F> — same variance pattern as flatMap.\n  return result as OkResult<T>;\n}\n\n/**\n * Recover from an error by applying `fn` to produce a new `Result`.\n * Alias for `orElse`.\n */\nfunction flatMapErr<T, E extends Error, F extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => Result<T, F>\n): Result<T, F> {\n  return orElse(result, fn);\n}\n\n/** Flatten a nested `Result<Result<T, E>, F>` into `Result<T, E | F>`. */\nfunction flatten<T, E extends Error, F extends Error>(\n  result: Result<Result<T, E>, F>\n): Result<T, E | F> {\n  // Safe: both branches widen the error type — same variance pattern as flatMap.\n  return (result.ok ? result.value : result) as Result<T, E | F>;\n}\n\n/** Exhaustively handle both `Ok` and `Err` branches, returning `R`. */\nfunction match<T, E extends Error, R>(\n  result: Result<T, E>,\n  handlers: { ok: (value: T) => R; err: (error: E) => R }\n): R {\n  return result.ok ? handlers.ok(result.value) : handlers.err(result.error);\n}\n\n/** Compile-time exhaustiveness guard — only accepts `never`. */\nfunction exhaustive(value: never): never {\n  let detail: string;\n  try {\n    detail = JSON.stringify(value);\n  } catch {\n    detail = String(value);\n  }\n  throw new Error(`Unhandled result case: ${detail}`);\n}\n\n/** Return the `Ok` value or throw the contained error. */\nfunction unwrap<T, E extends Error>(result: Result<T, E>): T {\n  if (result.ok) return result.value;\n  throw result.error;\n}\n\n/**\n * Return the `Ok` value or `fallback`.\n *\n * The fallback must be the same type `T` as the success value.  This is\n * intentional — use `match` when you need a different return type.\n */\nfunction unwrapOr<T, E extends Error>(result: Result<T, E>, fallback: T): T {\n  return result.ok ? result.value : fallback;\n}\n\n/** Return the `Ok` value, or compute a fallback from `fn`. */\nfunction unwrapOrElse<T, E extends Error>(\n  result: Result<T, E>,\n  fn: () => T\n): T {\n  return result.ok ? result.value : fn();\n}\n\n/** Return the `Ok` value or throw with a custom `message`. */\nfunction expect<T, E extends Error>(result: Result<T, E>, message: string): T {\n  if (result.ok) return result.value;\n  const thrown = new Error(`${message}: ${result.error.message}`, {\n    cause: result.error,\n  });\n  Object.setPrototypeOf(thrown, result.error.constructor.prototype);\n  if (result.error.stack !== undefined) thrown.stack = result.error.stack;\n  throw thrown;\n}\n\n/** Convert a nullable value to a `Result`. */\nfunction fromNullable<T, E extends Error>(\n  value: T | null | undefined,\n  errorFactory: () => E\n): Result<NonNullable<T>, E> {\n  return value != null ? ok(value as NonNullable<T>) : err(errorFactory());\n}\n\n/** Convert a predicate check to a `Result`.  Supports type-guard predicates. */\nfunction fromPredicate<T, S extends T, E extends Error>(\n  value: T,\n  predicate: (value: T) => value is S,\n  errorFactory: () => E\n): Result<S, E>;\nfunction fromPredicate<T, E extends Error>(\n  value: T,\n  predicate: (value: T) => boolean,\n  errorFactory: () => E\n): Result<T, E>;\nfunction fromPredicate<T, E extends Error>(\n  value: T,\n  predicate: (value: T) => boolean,\n  errorFactory: () => E\n): Result<T, E> {\n  return predicate(value) ? ok(value) : err(errorFactory());\n}\n\n/** Convert an unknown thrown value to an `Error` instance. */\nfunction normalizeError(error: unknown): Error {\n  if (error instanceof Error) return error;\n  if (error === null || error === undefined) return new Error(String(error));\n  if (typeof error === \"object\") {\n    try {\n      const json = JSON.stringify(error);\n      if (json !== \"{}\") return new Error(json);\n      // JSON.stringify produced '{}' — likely RegExp or similar with no\n      // enumerable own properties. Fall through to String().\n    } catch {\n      // JSON.stringify throws on BigInt and circular references\n    }\n  }\n  try {\n    return new Error(String(error));\n  } catch {\n    return new Error(\"Non-stringifiable thrown value\");\n  }\n}\n\n/** Wrap a synchronous function that may throw into a `Result`. */\nfunction tryCatch<T>(fn: () => T): Result<T, Error>;\nfunction tryCatch<T, E extends Error>(\n  fn: () => T,\n  onError: (error: unknown) => E\n): Result<T, E>;\nfunction tryCatch<T, E extends Error>(\n  fn: () => T,\n  onError?: (error: unknown) => E\n): Result<T, E | Error> {\n  try {\n    return ok(fn());\n  } catch (error) {\n    try {\n      return err(onError ? onError(error) : normalizeError(error));\n    } catch (mapperError) {\n      return err(new Error(\"Error mapper threw\", { cause: mapperError }));\n    }\n  }\n}\n\n/** Wrap an asynchronous function that may reject into a `Result`. */\nfunction tryCatchAsync<T>(fn: () => Promise<T>): Promise<Result<T, Error>>;\nfunction tryCatchAsync<T, E extends Error>(\n  fn: () => Promise<T>,\n  onError: (error: unknown) => E\n): Promise<Result<T, E>>;\nasync function tryCatchAsync<T, E extends Error>(\n  fn: () => Promise<T>,\n  onError?: (error: unknown) => E\n): Promise<Result<T, E | Error>> {\n  try {\n    return ok(await fn());\n  } catch (error) {\n    try {\n      return err(onError ? onError(error) : normalizeError(error));\n    } catch (mapperError) {\n      return err(new Error(\"Error mapper threw\", { cause: mapperError }));\n    }\n  }\n}\n\n/** Wrap a `Promise` that may reject into a `Result`. */\nfunction fromPromise<T>(promise: Promise<T>): Promise<Result<T, Error>>;\nfunction fromPromise<T, E extends Error>(\n  promise: Promise<T>,\n  onError: (error: unknown) => E\n): Promise<Result<T, E>>;\nasync function fromPromise<T, E extends Error>(\n  promise: Promise<T>,\n  onError?: (error: unknown) => E\n): Promise<Result<T, E | Error>> {\n  try {\n    return ok(await promise);\n  } catch (error) {\n    try {\n      return err(onError ? onError(error) : normalizeError(error));\n    } catch (mapperError) {\n      return err(new Error(\"Error mapper threw\", { cause: mapperError }));\n    }\n  }\n}\n\n/**\n * Combine multiple `Result`s into a single `Result` containing a tuple of\n * values.  Returns the first `Err` encountered (fail-fast).\n *\n * Pass results as individual arguments — spreading an array loses tuple\n * inference and degrades value types to `unknown[]`.\n */\nfunction all<const R extends readonly AnyResult[]>(\n  ...results: R\n): Result<TupleValues<R>, TupleErrors<R>> {\n  const values: unknown[] = [];\n  for (const result of results) {\n    if (!result.ok) return err(result.error) as ErrResult<TupleErrors<R>>;\n    values.push(result.value);\n  }\n  return ok(values) as OkResult<TupleValues<R>>;\n}\n\n/**\n * Like `all`, but accepts promises of `Result`s.  All promises are resolved\n * concurrently via `Promise.allSettled` before checking for errors.\n *\n * Promises are expected to resolve to `Result`s — not reject.  If a promise\n * does reject, the rejection is caught and wrapped as an `Err`.\n *\n * @breaking v0.2 — Uses `Promise.allSettled` instead of `Promise.all`. All\n * promises are now always awaited to completion; the first error found during\n * iteration is returned.\n */\nasync function allAsync<const R extends readonly Promise<AnyResult>[]>(\n  ...promises: R\n): Promise<\n  Result<\n    { [K in keyof R]: ValueOf<Awaited<R[K]>> },\n    ErrorOf<Awaited<R[number]>> | Error\n  >\n> {\n  type Values = { [K in keyof R]: ValueOf<Awaited<R[K]>> };\n  type Errors = ErrorOf<Awaited<R[number]>> | Error;\n\n  const settled = await Promise.allSettled(promises);\n  const values: unknown[] = [];\n  for (const s of settled) {\n    if (s.status === \"rejected\") {\n      return err(normalizeError(s.reason)) as ErrResult<Errors>;\n    }\n    if (!s.value.ok) {\n      return err(s.value.error) as ErrResult<Errors>;\n    }\n    values.push(s.value.value);\n  }\n  return ok(values) as OkResult<Values>;\n}\n\n/**\n * Like `collect`, but for promises of `Result`s.  Resolves all promises\n * via `Promise.allSettled`, then collects all errors.  Returns an\n * `AggregateError` containing every error found.\n */\nasync function collectAsync<const R extends readonly Promise<AnyResult>[]>(\n  ...promises: R\n): Promise<Result<{ [K in keyof R]: ValueOf<Awaited<R[K]>> }, AggregateError>> {\n  type Values = { [K in keyof R]: ValueOf<Awaited<R[K]>> };\n\n  const settled = await Promise.allSettled(promises);\n  const values: unknown[] = [];\n  const errors: Error[] = [];\n  for (const s of settled) {\n    if (s.status === \"rejected\") {\n      errors.push(normalizeError(s.reason));\n    } else if (!s.value.ok) {\n      errors.push(s.value.error);\n    } else {\n      values.push(s.value.value);\n    }\n  }\n  if (errors.length > 0)\n    return err(new AggregateError(errors)) as ErrResult<AggregateError>;\n  return ok(values) as OkResult<Values>;\n}\n\n/**\n * Combine multiple `Result`s, collecting **all** errors instead of\n * short-circuiting on the first one.  Returns an `AggregateError` whose\n * `.errors` array contains every individual error.\n */\nfunction collect<const R extends readonly AnyResult[]>(\n  ...results: R\n): Result<TupleValues<R>, AggregateError> {\n  const values: unknown[] = [];\n  const errors: Error[] = [];\n  for (const result of results) {\n    if (result.ok) values.push(result.value);\n    else errors.push(result.error);\n  }\n  if (errors.length > 0)\n    return err(new AggregateError(errors)) as ErrResult<AggregateError>;\n  return ok(values) as OkResult<TupleValues<R>>;\n}\n\n// ===========================================================================\n// Maybe\n// ===========================================================================\n\n/** A `Maybe` that contains a value of type `T`. */\nexport type Some<T> = {\n  readonly some: true;\n  readonly value: T;\n  map<U>(fn: (value: T) => U): Some<U>;\n  flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U>;\n  filter(predicate: (value: T) => boolean): Maybe<T>;\n  inspect(fn: (value: T) => void): Some<T>;\n  match<R>(handlers: { some: (value: T) => R; none: () => R }): R;\n  unwrap(): T;\n  expect(message: string): T;\n  unwrapOr(fallback: T): T;\n  unwrapOrElse(fn: () => T): T;\n};\n\n/** A `Maybe` that contains no value. */\nexport type None = {\n  readonly some: false;\n  map<U>(fn: (value: never) => U): None;\n  flatMap<U>(fn: (value: never) => Maybe<U>): None;\n  filter(predicate: (value: never) => boolean): None;\n  inspect(fn: (value: never) => void): None;\n  match<R>(handlers: { some: (value: never) => R; none: () => R }): R;\n  unwrap(): never;\n  expect(message: string): never;\n  unwrapOr<T>(fallback: T): T;\n  unwrapOrElse<T>(fn: () => T): T;\n};\n\n/**\n * A value that is either present (`Some<T>`) or absent (`None`).\n * Use `Maybe.some` / `Maybe.none` to construct, and the companion `Maybe.*`\n * functions or instance methods to transform.\n */\nexport type Maybe<T> = Some<T> | None;\n\ntype AnyMaybe = Maybe<unknown>;\n\ntype MaybeValueOf<M> = M extends Some<infer T> ? T : never;\n\ntype TupleMaybeValues<M extends readonly AnyMaybe[]> = {\n  [K in keyof M]: MaybeValueOf<M[K]>;\n};\n\n/** Create a `Maybe` containing `value`. */\nfunction some<T>(value: T): Some<T> {\n  const self: Some<T> = Object.freeze({\n    some: true as const,\n    value,\n    map: <U>(fn: (value: T) => U): Some<U> => some(fn(value)),\n    flatMap: <U>(fn: (value: T) => Maybe<U>): Maybe<U> => fn(value),\n    filter: (predicate: (value: T) => boolean): Maybe<T> =>\n      predicate(value) ? self : NONE,\n    inspect: (fn: (value: T) => void): Some<T> => {\n      fn(value);\n      return self;\n    },\n    match: <R>(handlers: { some: (value: T) => R; none: () => R }): R =>\n      handlers.some(value),\n    unwrap: (): T => value,\n    expect: (_message: string): T => value,\n    unwrapOr: (_fallback: T): T => value,\n    unwrapOrElse: (_fn: () => T): T => value,\n  });\n  return self;\n}\n\nconst NONE: None = Object.freeze({\n  some: false as const,\n  map: <U>(_fn: (value: never) => U): None => NONE,\n  flatMap: <U>(_fn: (value: never) => Maybe<U>): None => NONE,\n  filter: (_predicate: (value: never) => boolean): None => NONE,\n  inspect: (_fn: (value: never) => void): None => NONE,\n  match: <R>(handlers: { some: (value: never) => R; none: () => R }): R =>\n    handlers.none(),\n  unwrap: (): never => {\n    throw new Error(\"Called unwrap on None\");\n  },\n  expect: (message: string): never => {\n    throw new Error(message);\n  },\n  unwrapOr: <T>(fallback: T): T => fallback,\n  unwrapOrElse: <T>(fn: () => T): T => fn(),\n});\n\n/** Create an empty `Maybe`. */\nfunction none(): None {\n  return NONE;\n}\n\n/** Narrow a `Maybe` to `Some`. */\nfunction isSome<T>(maybe: Maybe<T>): maybe is Some<T> {\n  return maybe.some;\n}\n\n/** Narrow a `Maybe` to `None`. */\nfunction isNone<T>(maybe: Maybe<T>): maybe is None {\n  return !maybe.some;\n}\n\n/** Transform the value inside a `Some`, leaving `None` unchanged. */\nfunction maybeMap<T, U>(maybe: Some<T>, fn: (value: T) => U): Some<U>;\nfunction maybeMap<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nfunction maybeMap<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> {\n  return maybe.some ? some(fn(maybe.value)) : NONE;\n}\n\n/** Chain a `Maybe`-returning function on the `Some` value. */\nfunction maybeFlatMap<T, U>(\n  maybe: Maybe<T>,\n  fn: (value: T) => Maybe<U>\n): Maybe<U> {\n  return maybe.some ? fn(maybe.value) : NONE;\n}\n\n/** Flatten a nested `Maybe<Maybe<T>>` into `Maybe<T>`. */\nfunction maybeFlatten<T>(maybe: Maybe<Maybe<T>>): Maybe<T> {\n  return maybe.some ? maybe.value : NONE;\n}\n\n/** Keep the `Some` value only if `predicate` returns true. */\nfunction maybeFilter<T, S extends T>(\n  maybe: Maybe<T>,\n  predicate: (value: T) => value is S\n): Maybe<S>;\nfunction maybeFilter<T>(\n  maybe: Maybe<T>,\n  predicate: (value: T) => boolean\n): Maybe<T>;\nfunction maybeFilter<T>(\n  maybe: Maybe<T>,\n  predicate: (value: T) => boolean\n): Maybe<T> {\n  return maybe.some && predicate(maybe.value) ? maybe : NONE;\n}\n\n/** Run a side-effect on the `Some` value without transforming the maybe. */\nfunction maybeInspect<T>(maybe: Some<T>, fn: (value: T) => void): Some<T>;\nfunction maybeInspect<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nfunction maybeInspect<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> {\n  if (maybe.some) fn(maybe.value);\n  return maybe;\n}\n\n/** Exhaustively handle both `Some` and `None` branches, returning `R`. */\nfunction maybeMatch<T, R>(\n  maybe: Maybe<T>,\n  handlers: { some: (value: T) => R; none: () => R }\n): R {\n  return maybe.some ? handlers.some(maybe.value) : handlers.none();\n}\n\n/** Return the `Some` value or throw. */\nfunction maybeUnwrap<T>(maybe: Maybe<T>): T {\n  if (maybe.some) return maybe.value;\n  throw new Error(\"Called unwrap on None\");\n}\n\n/**\n * Return the `Some` value or `fallback`.\n *\n * The fallback must be the same type `T` as the contained value.  This is\n * intentional — use `match` when you need a different return type.\n */\nfunction maybeUnwrapOr<T>(maybe: Maybe<T>, fallback: T): T {\n  return maybe.some ? maybe.value : fallback;\n}\n\n/** Return the `Some` value, or compute a fallback from `fn`. */\nfunction maybeUnwrapOrElse<T>(maybe: Maybe<T>, fn: () => T): T {\n  return maybe.some ? maybe.value : fn();\n}\n\n/** Return the `Some` value or throw with a custom `message`. */\nfunction maybeExpect<T>(maybe: Maybe<T>, message: string): T {\n  if (maybe.some) return maybe.value;\n  throw new Error(message);\n}\n\n/** Convert a nullable value to a `Maybe`. */\nfunction maybeFromNullable<T>(\n  value: T | null | undefined\n): Maybe<NonNullable<T>> {\n  return value != null ? some(value as NonNullable<T>) : NONE;\n}\n\n/** Convert a predicate check to a `Maybe`.  Supports type-guard predicates. */\nfunction maybeFromPredicate<T, S extends T>(\n  value: T,\n  predicate: (value: T) => value is S\n): Maybe<S>;\nfunction maybeFromPredicate<T>(\n  value: T,\n  predicate: (value: T) => boolean\n): Maybe<T>;\nfunction maybeFromPredicate<T>(\n  value: T,\n  predicate: (value: T) => boolean\n): Maybe<T> {\n  return predicate(value) ? some(value) : NONE;\n}\n\n/**\n * Combine multiple `Maybe`s into a single `Maybe` containing a tuple of\n * values.  Returns `None` if any input is `None` (fail-fast).\n *\n * Pass maybes as individual arguments — spreading an array loses tuple\n * inference and degrades value types to `unknown[]`.\n */\nfunction maybeAll<const M extends readonly AnyMaybe[]>(\n  ...maybes: M\n): Maybe<TupleMaybeValues<M>> {\n  const values: unknown[] = [];\n  for (const m of maybes) {\n    if (!m.some) return NONE;\n    values.push(m.value);\n  }\n  return some(values) as Some<TupleMaybeValues<M>>;\n}\n\n/** Return the first `Some` found, or `None` if all are `None`. */\nfunction maybeFirstSome<T>(...maybes: Maybe<T>[]): Maybe<T> {\n  for (const m of maybes) {\n    if (m.some) return m;\n  }\n  return NONE;\n}\n\n/** Like `all`, but for promises of `Maybe`s.  Resolves all promises\n *  concurrently via `Promise.allSettled`. */\nasync function maybeAllAsync<const M extends readonly Promise<AnyMaybe>[]>(\n  ...promises: M\n): Promise<Maybe<{ [K in keyof M]: MaybeValueOf<Awaited<M[K]>> }>> {\n  type Values = { [K in keyof M]: MaybeValueOf<Awaited<M[K]>> };\n\n  const settled = await Promise.allSettled(promises);\n  const values: unknown[] = [];\n  for (const s of settled) {\n    if (s.status === \"rejected\") return NONE;\n    if (!s.value.some) return NONE;\n    values.push(s.value.value);\n  }\n  return some(values) as Some<Values>;\n}\n\n/** Combine multiple `Maybe's, returning `None` if any is `None`.\n * Same as `all` — `None` carries no error data to collect,\n * unlike `Result.collect` which gathers all errors.\n */\nconst maybeCollect = maybeAll;\n\n// ---------------------------------------------------------------------------\n// Maybe <-> Result interop\n// ---------------------------------------------------------------------------\n\n/** Convert a `Maybe` to a `Result`, calling `errorFactory` only when `None`.\n *\n * @breaking v0.2 — The second argument changed from `error: E` to\n * `errorFactory: () => E`. The factory is only called when the Maybe is\n * None, avoiding unnecessary error construction for Some.\n */\nfunction maybeToResult<T, E extends Error>(\n  maybe: Maybe<T>,\n  errorFactory: () => E\n): Result<T, E> {\n  return maybe.some ? ok(maybe.value) : err(errorFactory());\n}\n\n/** Convert a `Result` to a `Maybe`, discarding the error. */\nfunction maybeFromResult<T, E extends Error>(result: Result<T, E>): Maybe<T> {\n  return result.ok ? some(result.value) : NONE;\n}\n\n/** Convert a `Result` to a `Maybe`, discarding the error. */\nfunction resultToMaybe<T, E extends Error>(result: Result<T, E>): Maybe<T> {\n  return maybeFromResult(result);\n}\n\n/** Convert a `Maybe` to a `Result`, calling `errorFactory` only when `None`.\n * Alias for `maybeToResult`.\n *\n * @breaking v0.2 — The second argument changed from `error: E` to\n * `errorFactory: () => E`.\n */\nfunction resultFromMaybe<T, E extends Error>(\n  maybe: Maybe<T>,\n  errorFactory: () => E\n): Result<T, E> {\n  return maybeToResult(maybe, errorFactory);\n}\n\n/** Convert a `Result<Maybe<T>, E>` to `Maybe<Result<T, E>>`. */\nfunction resultTranspose<T, E extends Error>(\n  result: Result<Maybe<T>, E>\n): Maybe<Result<T, E>> {\n  if (!result.ok) return some(result as ErrResult<E>);\n  if (result.value.some) return some(ok(result.value.value));\n  return NONE;\n}\n\n/** Convert a `Maybe<Result<T, E>>` to `Result<Maybe<T>, E>`. */\nfunction maybeTranspose<T, E extends Error>(\n  maybe: Maybe<Result<T, E>>\n): Result<Maybe<T>, E> {\n  if (!maybe.some) return ok(NONE) as OkResult<Maybe<T>>;\n  if (maybe.value.ok) return ok(some(maybe.value.value));\n  return err(maybe.value.error) as ErrResult<E>;\n}\n\nexport const Maybe = {\n  some,\n  none,\n  isSome,\n  isNone,\n  map: maybeMap,\n  flatMap: maybeFlatMap,\n  flatten: maybeFlatten,\n  filter: maybeFilter,\n  inspect: maybeInspect,\n  match: maybeMatch,\n  unwrap: maybeUnwrap,\n  unwrapOr: maybeUnwrapOr,\n  unwrapOrElse: maybeUnwrapOrElse,\n  expect: maybeExpect,\n  fromNullable: maybeFromNullable,\n  fromPredicate: maybeFromPredicate,\n  all: maybeAll,\n  allAsync: maybeAllAsync,\n  collect: maybeCollect,\n  firstSome: maybeFirstSome,\n  toResult: maybeToResult,\n  fromResult: maybeFromResult,\n  transpose: maybeTranspose,\n} as const satisfies Record<string, (...args: never[]) => unknown>;\n\n// Add interop to Result namespace\nexport const Result = {\n  ok,\n  err,\n  isOk,\n  isErr,\n  map,\n  mapError,\n  inspect,\n  inspectError,\n  flatMap,\n  flatMapErr,\n  orElse,\n  flatten,\n  match,\n  exhaustive,\n  unwrap,\n  unwrapOr,\n  unwrapOrElse,\n  expect,\n  fromNullable,\n  fromPredicate,\n  normalizeError,\n  tryCatch,\n  tryCatchAsync,\n  fromPromise,\n  all,\n  allAsync,\n  collect,\n  collectAsync,\n  toMaybe: resultToMaybe,\n  fromMaybe: resultFromMaybe,\n  transpose: resultTranspose,\n} as const satisfies Record<string, (...args: never[]) => unknown>;\n\nexport { err, isErr, isNone, isOk, isSome, none, normalizeError, ok, some };\n"],"mappings":"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","names":[]}