@consolidados/results 0.1.2 → 0.1.3

package/dist/err-B7LUEZ0f.d.cts

@@ -0,0 +1,128 @@
+/**
+ * Represents a successful result (`Ok`) that contains a value.
+ * @template T The type of the value contained in this `Ok`.
+ */
+declare class Ok<T> implements ResultDefinition<T, never> {
+    private value;
+    /**
+     * Creates a new `Ok` instance with the given value.
+     * @param value The value to wrap in the `Ok` instance.
+     */
+    constructor(value: T);
+    /**
+     * Checks if this result is an `Ok`.
+     * @returns `true` because this is an `Ok`.
+     */
+    isOk(): this is Ok<T>;
+    /**
+     * Checks if this result is an `Err`.
+     * @returns `false` because this is an `Ok`.
+     */
+    isErr(): this is Err<never>;
+    /**
+     * Retrieves the value contained in this `Ok`.
+     * @returns The value contained in this `Ok`.
+     */
+    unwrap(): T;
+    /**
+     * Applies a transformation function to the value contained in this `Ok` and returns a new `Result` with the transformed value.
+     * @template U The type of the transformed value.
+     * @param fn The transformation function to apply to the value.
+     * @returns A new `Ok` containing the transformed value.
+     */
+    map<U>(fn: (value: T) => U): ResultDefinition<U, never>;
+    /**
+     * Applies a transformation function that returns a `Result` to the value contained in this `Ok`.
+     * @template U The type of the value in the resulting `Result`.
+     * @param fn The transformation function to apply to the value.
+     * @returns The result of applying the transformation function.
+     */
+    flatMap<U>(fn: (value: T) => ResultDefinition<U, never>): ResultDefinition<U, never>;
+    /**
+     * Maps the error value (if any). Since this is an `Ok`, the error mapping function is ignored, and the original `Ok` is returned.
+     * @template U The type of the error (ignored for `Ok`).
+     * @param _fn The mapping function for errors (not used).
+     * @returns The original `Ok` instance.
+     */
+    mapErr<U extends Error>(_fn: (err: never) => U): ResultDefinition<T, U>;
+    /**
+     * Retrieves the error contained in this result. Since this is an `Ok`, an error is thrown.
+     * @throws An error because `unwrapErr` is called on an `Ok`.
+     */
+    unwrapErr(): never;
+}
+
+type OkType<T> = [T] extends [never] ? never : T;
+type ErrType<E> = [E] extends [never] ? never : E;
+/**
+ * Represents the result of an operation that can either succeed (`Ok`) or fail (`Err`).
+ */
+type Result<T, E extends Error> = Ok<OkType<T>> | Err<ErrType<E>>;
+/**
+ * Represents the result methods that must be implemented for success (`Ok`) or failure (`Err`).
+ */
+interface ResultDefinition<T = never, E = never> {
+    isOk(): this is Ok<T>;
+    isErr(): this is Err<E extends Error ? E : Error>;
+    unwrap(): T;
+    unwrapErr(): E;
+    map<U>(fn: (value: T) => U): ResultDefinition<U, E>;
+    flatMap<U>(fn: (value: T) => ResultDefinition<U, E>): ResultDefinition<U, E>;
+    mapErr<U extends Error>(fn: (err: E) => U): ResultDefinition<T, U>;
+}
+
+/**
+ * Represents a failed result (`Err`) that contains an error value.
+ * @template E The type of the error contained in this `Err`.
+ */
+declare class Err<E extends Error> extends Error implements ResultDefinition<never, E> {
+    private error;
+    /**
+     * Creates a new `Err` instance with the given error value.
+     * @param error The error to wrap in the `Err` instance.
+     */
+    constructor(error: E | string);
+    /**
+     * Checks if this result is an `Ok`.
+     * @returns `false` because this is an `Err`.
+     */
+    isOk(): this is Ok<never>;
+    /**
+     * Checks if this result is an `Err`.
+     * @returns `true` because this is an `Err`.
+     */
+    isErr(): this is Err<E extends Error ? E : Error>;
+    /**
+     * Retrieves the value contained in this result. Since this is an `Err`, an error is thrown.
+     * @throws An error because `unwrap` is called on an `Err`.
+     */
+    unwrap(): never;
+    /**
+     * Maps the value (if any). Since this is an `Err`, the mapping function is ignored, and the original `Err` is returned.
+     * @template U The type of the value (ignored for `Err`).
+     * @param _fn The mapping function for values (not used).
+     * @returns The original `Err` instance.
+     */
+    map<U>(_fn: (value: never) => U): ResultDefinition<never, E>;
+    /**
+     * Maps the error value using a transformation function and returns a new `Result` with the transformed error.
+     * @template U The type of the transformed error.
+     * @param fn The transformation function to apply to the error value.
+     * @returns A new `Err` containing the transformed error.
+     */
+    mapErr<U extends Error>(fn: (err: E) => U): ResultDefinition<never, U>;
+    /**
+     * Applies a transformation function that returns a `Result` to the value (which does not exist) of this `Err`.
+     * @template U The type of the value in the resulting `Result`.
+     * @param _fn The transformation function (ignored in this implementation).
+     * @returns The original `Err` instance.
+     */
+    flatMap<U>(_fn: (value: never) => ResultDefinition<U, never>): ResultDefinition<never, E>;
+    /**
+     * Retrieves the error value contained in this `Err`.
+     * @returns The error value contained in this `Err`.
+     */
+    unwrapErr(): E;
+}
+
+export { Err as E, Ok as O, type Result as R };

package/dist/err-B7LUEZ0f.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Represents a successful result (`Ok`) that contains a value.
+ * @template T The type of the value contained in this `Ok`.
+ */
+declare class Ok<T> implements ResultDefinition<T, never> {
+    private value;
+    /**
+     * Creates a new `Ok` instance with the given value.
+     * @param value The value to wrap in the `Ok` instance.
+     */
+    constructor(value: T);
+    /**
+     * Checks if this result is an `Ok`.
+     * @returns `true` because this is an `Ok`.
+     */
+    isOk(): this is Ok<T>;
+    /**
+     * Checks if this result is an `Err`.
+     * @returns `false` because this is an `Ok`.
+     */
+    isErr(): this is Err<never>;
+    /**
+     * Retrieves the value contained in this `Ok`.
+     * @returns The value contained in this `Ok`.
+     */
+    unwrap(): T;
+    /**
+     * Applies a transformation function to the value contained in this `Ok` and returns a new `Result` with the transformed value.
+     * @template U The type of the transformed value.
+     * @param fn The transformation function to apply to the value.
+     * @returns A new `Ok` containing the transformed value.
+     */
+    map<U>(fn: (value: T) => U): ResultDefinition<U, never>;
+    /**
+     * Applies a transformation function that returns a `Result` to the value contained in this `Ok`.
+     * @template U The type of the value in the resulting `Result`.
+     * @param fn The transformation function to apply to the value.
+     * @returns The result of applying the transformation function.
+     */
+    flatMap<U>(fn: (value: T) => ResultDefinition<U, never>): ResultDefinition<U, never>;
+    /**
+     * Maps the error value (if any). Since this is an `Ok`, the error mapping function is ignored, and the original `Ok` is returned.
+     * @template U The type of the error (ignored for `Ok`).
+     * @param _fn The mapping function for errors (not used).
+     * @returns The original `Ok` instance.
+     */
+    mapErr<U extends Error>(_fn: (err: never) => U): ResultDefinition<T, U>;
+    /**
+     * Retrieves the error contained in this result. Since this is an `Ok`, an error is thrown.
+     * @throws An error because `unwrapErr` is called on an `Ok`.
+     */
+    unwrapErr(): never;
+}
+
+type OkType<T> = [T] extends [never] ? never : T;
+type ErrType<E> = [E] extends [never] ? never : E;
+/**
+ * Represents the result of an operation that can either succeed (`Ok`) or fail (`Err`).
+ */
+type Result<T, E extends Error> = Ok<OkType<T>> | Err<ErrType<E>>;
+/**
+ * Represents the result methods that must be implemented for success (`Ok`) or failure (`Err`).
+ */
+interface ResultDefinition<T = never, E = never> {
+    isOk(): this is Ok<T>;
+    isErr(): this is Err<E extends Error ? E : Error>;
+    unwrap(): T;
+    unwrapErr(): E;
+    map<U>(fn: (value: T) => U): ResultDefinition<U, E>;
+    flatMap<U>(fn: (value: T) => ResultDefinition<U, E>): ResultDefinition<U, E>;
+    mapErr<U extends Error>(fn: (err: E) => U): ResultDefinition<T, U>;
+}
+
+/**
+ * Represents a failed result (`Err`) that contains an error value.
+ * @template E The type of the error contained in this `Err`.
+ */
+declare class Err<E extends Error> extends Error implements ResultDefinition<never, E> {
+    private error;
+    /**
+     * Creates a new `Err` instance with the given error value.
+     * @param error The error to wrap in the `Err` instance.
+     */
+    constructor(error: E | string);
+    /**
+     * Checks if this result is an `Ok`.
+     * @returns `false` because this is an `Err`.
+     */
+    isOk(): this is Ok<never>;
+    /**
+     * Checks if this result is an `Err`.
+     * @returns `true` because this is an `Err`.
+     */
+    isErr(): this is Err<E extends Error ? E : Error>;
+    /**
+     * Retrieves the value contained in this result. Since this is an `Err`, an error is thrown.
+     * @throws An error because `unwrap` is called on an `Err`.
+     */
+    unwrap(): never;
+    /**
+     * Maps the value (if any). Since this is an `Err`, the mapping function is ignored, and the original `Err` is returned.
+     * @template U The type of the value (ignored for `Err`).
+     * @param _fn The mapping function for values (not used).
+     * @returns The original `Err` instance.
+     */
+    map<U>(_fn: (value: never) => U): ResultDefinition<never, E>;
+    /**
+     * Maps the error value using a transformation function and returns a new `Result` with the transformed error.
+     * @template U The type of the transformed error.
+     * @param fn The transformation function to apply to the error value.
+     * @returns A new `Err` containing the transformed error.
+     */
+    mapErr<U extends Error>(fn: (err: E) => U): ResultDefinition<never, U>;
+    /**
+     * Applies a transformation function that returns a `Result` to the value (which does not exist) of this `Err`.
+     * @template U The type of the value in the resulting `Result`.
+     * @param _fn The transformation function (ignored in this implementation).
+     * @returns The original `Err` instance.
+     */
+    flatMap<U>(_fn: (value: never) => ResultDefinition<U, never>): ResultDefinition<never, E>;
+    /**
+     * Retrieves the error value contained in this `Err`.
+     * @returns The error value contained in this `Err`.
+     */
+    unwrapErr(): E;
+}
+
+export { Err as E, Ok as O, type Result as R };

package/dist/helpers/match.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+// src/helpers/match.ts
+function match(matcher, cases) {
+  if ("isOk" in matcher && matcher.isOk()) {
+    if (!cases.Ok) throw new Error("Missing case for Ok");
+    return cases.Ok(matcher.unwrap());
+  }
+  if ("isErr" in matcher && matcher.isErr()) {
+    if (!cases.Err) throw new Error("Missing case for Err");
+    return cases.Err(matcher.unwrapErr());
+  }
+  if ("isSome" in matcher && matcher.isSome()) {
+    if (!cases.Some) throw new Error("Missing case for Some");
+    return cases.Some(matcher.unwrap());
+  }
+  if ("isNone" in matcher && matcher.isNone()) {
+    if (!cases.None) throw new Error("Missing case for None");
+    return cases.None();
+  }
+  throw new Error("Invalid matcher or missing case");
+}
+global.match = match;
+
+exports.match = match;
+//# sourceMappingURL=match.cjs.map
+//# sourceMappingURL=match.cjs.map

package/dist/helpers/match.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/helpers/match.ts"],"names":[],"mappings":";;;AAiBO,SAAS,KAAA,CACd,SACA,KAMG,EAAA;AACH,EAAA,IAAI,MAAU,IAAA,OAAA,IAAW,OAAQ,CAAA,IAAA,EAAQ,EAAA;AACvC,IAAA,IAAI,CAAC,KAAM,CAAA,EAAA,EAAU,MAAA,IAAI,MAAM,qBAAqB,CAAA;AACpD,IAAA,OAAO,KAAM,CAAA,EAAA,CAAG,OAAQ,CAAA,MAAA,EAAQ,CAAA;AAAA;AAGlC,EAAA,IAAI,OAAW,IAAA,OAAA,IAAW,OAAQ,CAAA,KAAA,EAAS,EAAA;AACzC,IAAA,IAAI,CAAC,KAAM,CAAA,GAAA,EAAW,MAAA,IAAI,MAAM,sBAAsB,CAAA;AACtD,IAAA,OAAO,KAAM,CAAA,GAAA,CAAI,OAAQ,CAAA,SAAA,EAAgB,CAAA;AAAA;AAG3C,EAAA,IAAI,QAAY,IAAA,OAAA,IAAW,OAAQ,CAAA,MAAA,EAAU,EAAA;AAC3C,IAAA,IAAI,CAAC,KAAM,CAAA,IAAA,EAAY,MAAA,IAAI,MAAM,uBAAuB,CAAA;AACxD,IAAA,OAAO,KAAM,CAAA,IAAA,CAAK,OAAQ,CAAA,MAAA,EAAQ,CAAA;AAAA;AAGpC,EAAA,IAAI,QAAY,IAAA,OAAA,IAAW,OAAQ,CAAA,MAAA,EAAU,EAAA;AAC3C,IAAA,IAAI,CAAC,KAAM,CAAA,IAAA,EAAY,MAAA,IAAI,MAAM,uBAAuB,CAAA;AACxD,IAAA,OAAO,MAAM,IAAK,EAAA;AAAA;AAGpB,EAAM,MAAA,IAAI,MAAM,iCAAiC,CAAA;AACnD;AAGC,MAAA,CAAe,KAAQ,GAAA,KAAA","file":"match.cjs","sourcesContent":["import type { Option } from \"../option\";\nimport type { Result } from \"../result\";\n\nexport function match<T, E extends Error, R>(\n  matcher: Result<T, E>,\n  cases: {\n    Ok: (value: T) => R;\n    Err: (error: E) => R;\n  },\n): R;\nexport function match<T, R>(\n  matcher: Option<T>,\n  cases: {\n    Some: (value: T) => R;\n    None: () => R;\n  },\n): R;\nexport function match<T, E extends Error, R>(\n  matcher: Result<T, E> | Option<T>,\n  cases: {\n    Ok?: (value: T) => R;\n    Err?: (error: E) => R;\n    Some?: (value: T) => R;\n    None?: () => R;\n  },\n): R {\n  if (\"isOk\" in matcher && matcher.isOk()) {\n    if (!cases.Ok) throw new Error(\"Missing case for Ok\");\n    return cases.Ok(matcher.unwrap());\n  }\n\n  if (\"isErr\" in matcher && matcher.isErr()) {\n    if (!cases.Err) throw new Error(\"Missing case for Err\");\n    return cases.Err(matcher.unwrapErr() as E);\n  }\n\n  if (\"isSome\" in matcher && matcher.isSome()) {\n    if (!cases.Some) throw new Error(\"Missing case for Some\");\n    return cases.Some(matcher.unwrap());\n  }\n\n  if (\"isNone\" in matcher && matcher.isNone()) {\n    if (!cases.None) throw new Error(\"Missing case for None\");\n    return cases.None();\n  }\n\n  throw new Error(\"Invalid matcher or missing case\");\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: <explanation>\n(global as any).match = match;\n"]}

package/dist/helpers/match.d.cts

@@ -0,0 +1,13 @@
+import { O as Option } from '../option-DpT8KCGE.cjs';
+import { R as Result } from '../err-B7LUEZ0f.cjs';
+
+declare function match<T, E extends Error, R>(matcher: Result<T, E>, cases: {
+    Ok: (value: T) => R;
+    Err: (error: E) => R;
+}): R;
+declare function match<T, R>(matcher: Option<T>, cases: {
+    Some: (value: T) => R;
+    None: () => R;
+}): R;
+
+export { match };

package/dist/helpers/match.d.ts

@@ -0,0 +1,13 @@
+import { O as Option } from '../option-DpT8KCGE.js';
+import { R as Result } from '../err-B7LUEZ0f.js';
+
+declare function match<T, E extends Error, R>(matcher: Result<T, E>, cases: {
+    Ok: (value: T) => R;
+    Err: (error: E) => R;
+}): R;
+declare function match<T, R>(matcher: Option<T>, cases: {
+    Some: (value: T) => R;
+    None: () => R;
+}): R;
+
+export { match };

package/dist/helpers/match.js

@@ -0,0 +1,25 @@
+// src/helpers/match.ts
+function match(matcher, cases) {
+  if ("isOk" in matcher && matcher.isOk()) {
+    if (!cases.Ok) throw new Error("Missing case for Ok");
+    return cases.Ok(matcher.unwrap());
+  }
+  if ("isErr" in matcher && matcher.isErr()) {
+    if (!cases.Err) throw new Error("Missing case for Err");
+    return cases.Err(matcher.unwrapErr());
+  }
+  if ("isSome" in matcher && matcher.isSome()) {
+    if (!cases.Some) throw new Error("Missing case for Some");
+    return cases.Some(matcher.unwrap());
+  }
+  if ("isNone" in matcher && matcher.isNone()) {
+    if (!cases.None) throw new Error("Missing case for None");
+    return cases.None();
+  }
+  throw new Error("Invalid matcher or missing case");
+}
+global.match = match;
+
+export { match };
+//# sourceMappingURL=match.js.map
+//# sourceMappingURL=match.js.map

package/dist/helpers/match.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/helpers/match.ts"],"names":[],"mappings":";AAiBO,SAAS,KAAA,CACd,SACA,KAMG,EAAA;AACH,EAAA,IAAI,MAAU,IAAA,OAAA,IAAW,OAAQ,CAAA,IAAA,EAAQ,EAAA;AACvC,IAAA,IAAI,CAAC,KAAM,CAAA,EAAA,EAAU,MAAA,IAAI,MAAM,qBAAqB,CAAA;AACpD,IAAA,OAAO,KAAM,CAAA,EAAA,CAAG,OAAQ,CAAA,MAAA,EAAQ,CAAA;AAAA;AAGlC,EAAA,IAAI,OAAW,IAAA,OAAA,IAAW,OAAQ,CAAA,KAAA,EAAS,EAAA;AACzC,IAAA,IAAI,CAAC,KAAM,CAAA,GAAA,EAAW,MAAA,IAAI,MAAM,sBAAsB,CAAA;AACtD,IAAA,OAAO,KAAM,CAAA,GAAA,CAAI,OAAQ,CAAA,SAAA,EAAgB,CAAA;AAAA;AAG3C,EAAA,IAAI,QAAY,IAAA,OAAA,IAAW,OAAQ,CAAA,MAAA,EAAU,EAAA;AAC3C,IAAA,IAAI,CAAC,KAAM,CAAA,IAAA,EAAY,MAAA,IAAI,MAAM,uBAAuB,CAAA;AACxD,IAAA,OAAO,KAAM,CAAA,IAAA,CAAK,OAAQ,CAAA,MAAA,EAAQ,CAAA;AAAA;AAGpC,EAAA,IAAI,QAAY,IAAA,OAAA,IAAW,OAAQ,CAAA,MAAA,EAAU,EAAA;AAC3C,IAAA,IAAI,CAAC,KAAM,CAAA,IAAA,EAAY,MAAA,IAAI,MAAM,uBAAuB,CAAA;AACxD,IAAA,OAAO,MAAM,IAAK,EAAA;AAAA;AAGpB,EAAM,MAAA,IAAI,MAAM,iCAAiC,CAAA;AACnD;AAGC,MAAA,CAAe,KAAQ,GAAA,KAAA","file":"match.js","sourcesContent":["import type { Option } from \"../option\";\nimport type { Result } from \"../result\";\n\nexport function match<T, E extends Error, R>(\n  matcher: Result<T, E>,\n  cases: {\n    Ok: (value: T) => R;\n    Err: (error: E) => R;\n  },\n): R;\nexport function match<T, R>(\n  matcher: Option<T>,\n  cases: {\n    Some: (value: T) => R;\n    None: () => R;\n  },\n): R;\nexport function match<T, E extends Error, R>(\n  matcher: Result<T, E> | Option<T>,\n  cases: {\n    Ok?: (value: T) => R;\n    Err?: (error: E) => R;\n    Some?: (value: T) => R;\n    None?: () => R;\n  },\n): R {\n  if (\"isOk\" in matcher && matcher.isOk()) {\n    if (!cases.Ok) throw new Error(\"Missing case for Ok\");\n    return cases.Ok(matcher.unwrap());\n  }\n\n  if (\"isErr\" in matcher && matcher.isErr()) {\n    if (!cases.Err) throw new Error(\"Missing case for Err\");\n    return cases.Err(matcher.unwrapErr() as E);\n  }\n\n  if (\"isSome\" in matcher && matcher.isSome()) {\n    if (!cases.Some) throw new Error(\"Missing case for Some\");\n    return cases.Some(matcher.unwrap());\n  }\n\n  if (\"isNone\" in matcher && matcher.isNone()) {\n    if (!cases.None) throw new Error(\"Missing case for None\");\n    return cases.None();\n  }\n\n  throw new Error(\"Invalid matcher or missing case\");\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: <explanation>\n(global as any).match = match;\n"]}

package/dist/index.cjs

@@ -0,0 +1,301 @@
+'use strict';
+
+// src/helpers/match.ts
+function match(matcher, cases) {
+  if ("isOk" in matcher && matcher.isOk()) {
+    if (!cases.Ok) throw new Error("Missing case for Ok");
+    return cases.Ok(matcher.unwrap());
+  }
+  if ("isErr" in matcher && matcher.isErr()) {
+    if (!cases.Err) throw new Error("Missing case for Err");
+    return cases.Err(matcher.unwrapErr());
+  }
+  if ("isSome" in matcher && matcher.isSome()) {
+    if (!cases.Some) throw new Error("Missing case for Some");
+    return cases.Some(matcher.unwrap());
+  }
+  if ("isNone" in matcher && matcher.isNone()) {
+    if (!cases.None) throw new Error("Missing case for None");
+    return cases.None();
+  }
+  throw new Error("Invalid matcher or missing case");
+}
+global.match = match;
+
+// src/option/__internal__/return-types/some.ts
+var Some = class _Some {
+  /**
+   * Creates a new `Some` option with the given value.
+   * @param value The value to be wrapped in the `Some` option.
+   */
+  constructor(value) {
+    this.value = value;
+  }
+  /**
+   * Checks if this option is a `Some`.
+   * @returns `true` if this option is a `Some`, otherwise `false`.
+   */
+  isSome() {
+    return true;
+  }
+  /**
+   * Checks if this option is a `None`.
+   * @returns `false` because this is a `Some`.
+   */
+  isNone() {
+    return false;
+  }
+  /**
+   * Unwraps the value held by this `Some` option.
+   * @returns The value held by this `Some` option.
+   */
+  unwrap() {
+    return this.value;
+  }
+  /**
+   * Applies a transformation function to the value held by this `Some` option and returns a new `Option` with the transformed value.
+   * @template U The type of the transformed value.
+   * @param fn The transformation function to apply to the value.
+   * @returns A new `Some` option containing the transformed value.
+   */
+  map(fn) {
+    return new _Some(fn(this.value));
+  }
+  /**
+   * Applies a transformation function that returns an `Option` to the value held by this `Some` option.
+   * @template U The type of the value in the resulting `Option`.
+   * @param fn The transformation function to apply to the value.
+   * @returns The result of applying the transformation function.
+   */
+  flatMap(fn) {
+    return fn(this.value);
+  }
+  /**
+   * Returns the value held by this `Some` option, ignoring the default value provided.
+   * @param _ A default value (ignored in this implementation).
+   * @returns The value held by this `Some` option.
+   */
+  unwrapOr(_) {
+    return this.value;
+  }
+};
+
+// src/option/__internal__/return-types/none.ts
+var None = class _None {
+  /**
+   * Checks if this option is a `Some`.
+   * @returns `false` because this is a `None`.
+   */
+  isSome() {
+    return false;
+  }
+  /**
+   * Checks if this option is a `None`.
+   * @returns `true` because this is a `None`.
+   */
+  isNone() {
+    return true;
+  }
+  /**
+   * Attempts to unwrap the value from this `None` option.
+   * @throws An error because `None` has no value.
+   */
+  unwrap() {
+    throw new Error("Called unwrap on a None value");
+  }
+  /**
+   * Applies a transformation function to the value (which does not exist) of this `None` option.
+   * @template U The type of the value that would have been returned.
+   * @param _fn The transformation function (ignored in this implementation).
+   * @returns A new `None` option.
+   */
+  map(_fn) {
+    return new _None();
+  }
+  /**
+   * Applies a transformation function that returns an `Option` to the value (which does not exist) of this `None` option.
+   * @template U The type of the value in the resulting `Option`.
+   * @param _fn The transformation function (ignored in this implementation).
+   * @returns A new `None` option.
+   */
+  flatMap(_fn) {
+    return new _None();
+  }
+  /**
+   * Returns the default value provided, since `None` has no value.
+   * @template T The type of the default value.
+   * @param defaultValue The value to return.
+   * @returns The default value provided.
+   */
+  unwrapOr(defaultValue) {
+    return defaultValue;
+  }
+};
+
+// src/option/option.ts
+function Some2(value) {
+  return new Some(value);
+}
+function None2() {
+  return new None();
+}
+global.Some = Some2;
+global.None = None2;
+
+// src/result/__internal__/return-types/err.ts
+var Err = class _Err extends Error {
+  error;
+  /**
+   * Creates a new `Err` instance with the given error value.
+   * @param error The error to wrap in the `Err` instance.
+   */
+  constructor(error) {
+    super(typeof error === "string" ? error : error.message);
+    this.error = typeof error === "string" ? new Error(error) : error;
+    Object.setPrototypeOf(this, _Err.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _Err);
+    }
+  }
+  /**
+   * Checks if this result is an `Ok`.
+   * @returns `false` because this is an `Err`.
+   */
+  isOk() {
+    return false;
+  }
+  /**
+   * Checks if this result is an `Err`.
+   * @returns `true` because this is an `Err`.
+   */
+  isErr() {
+    return true;
+  }
+  /**
+   * Retrieves the value contained in this result. Since this is an `Err`, an error is thrown.
+   * @throws An error because `unwrap` is called on an `Err`.
+   */
+  unwrap() {
+    throw new Error("Called unwrap on an Err value");
+  }
+  /**
+   * Maps the value (if any). Since this is an `Err`, the mapping function is ignored, and the original `Err` is returned.
+   * @template U The type of the value (ignored for `Err`).
+   * @param _fn The mapping function for values (not used).
+   * @returns The original `Err` instance.
+   */
+  map(_fn) {
+    return this;
+  }
+  /**
+   * Maps the error value using a transformation function and returns a new `Result` with the transformed error.
+   * @template U The type of the transformed error.
+   * @param fn The transformation function to apply to the error value.
+   * @returns A new `Err` containing the transformed error.
+   */
+  mapErr(fn) {
+    return new _Err(fn(this.error));
+  }
+  /**
+   * Applies a transformation function that returns a `Result` to the value (which does not exist) of this `Err`.
+   * @template U The type of the value in the resulting `Result`.
+   * @param _fn The transformation function (ignored in this implementation).
+   * @returns The original `Err` instance.
+   */
+  flatMap(_fn) {
+    return this;
+  }
+  /**
+   * Retrieves the error value contained in this `Err`.
+   * @returns The error value contained in this `Err`.
+   */
+  unwrapErr() {
+    return this.error;
+  }
+};
+
+// src/result/__internal__/return-types/ok.ts
+var Ok = class _Ok {
+  /**
+   * Creates a new `Ok` instance with the given value.
+   * @param value The value to wrap in the `Ok` instance.
+   */
+  constructor(value) {
+    this.value = value;
+  }
+  /**
+   * Checks if this result is an `Ok`.
+   * @returns `true` because this is an `Ok`.
+   */
+  isOk() {
+    return true;
+  }
+  /**
+   * Checks if this result is an `Err`.
+   * @returns `false` because this is an `Ok`.
+   */
+  isErr() {
+    return false;
+  }
+  /**
+   * Retrieves the value contained in this `Ok`.
+   * @returns The value contained in this `Ok`.
+   */
+  unwrap() {
+    return this.value;
+  }
+  /**
+   * Applies a transformation function to the value contained in this `Ok` and returns a new `Result` with the transformed value.
+   * @template U The type of the transformed value.
+   * @param fn The transformation function to apply to the value.
+   * @returns A new `Ok` containing the transformed value.
+   */
+  map(fn) {
+    return new _Ok(fn(this.value));
+  }
+  /**
+   * Applies a transformation function that returns a `Result` to the value contained in this `Ok`.
+   * @template U The type of the value in the resulting `Result`.
+   * @param fn The transformation function to apply to the value.
+   * @returns The result of applying the transformation function.
+   */
+  flatMap(fn) {
+    return fn(this.value);
+  }
+  /**
+   * Maps the error value (if any). Since this is an `Ok`, the error mapping function is ignored, and the original `Ok` is returned.
+   * @template U The type of the error (ignored for `Ok`).
+   * @param _fn The mapping function for errors (not used).
+   * @returns The original `Ok` instance.
+   */
+  // mapErr<U extends Error | string>(fn: (err: U) => U): Result<T, never> {
+  // 	return this;
+  mapErr(_fn) {
+    return this;
+  }
+  /**
+   * Retrieves the error contained in this result. Since this is an `Ok`, an error is thrown.
+   * @throws An error because `unwrapErr` is called on an `Ok`.
+   */
+  unwrapErr() {
+    throw new Error("Called unwrapErr on an Ok value");
+  }
+};
+
+// src/result/result.ts
+function Ok2(value) {
+  return new Ok(value);
+}
+function Err2(error) {
+  return new Err(error);
+}
+global.Ok = Ok2;
+global.Err = Err2;
+
+exports.Err = Err2;
+exports.None = None2;
+exports.Ok = Ok2;
+exports.Some = Some2;
+exports.match = match;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map