lite-fp 0.1.0 → 0.4.1

package/dist/index.d.ts

@@ -1,74 +1,82 @@
-type Pair<A, B> = readonly [A, B];
-declare const Pair: {
-    fst: <A, B>(p: Pair<A, B>) => A;
-    snd: <A, B>(p: Pair<A, B>) => B;
-    new: <A, B>(fst: A, snd: B) => Pair<A, B>;
-    fromArray: <A, B>([fst, snd]: [A, B]) => Pair<A, B>;
-    fromObject: <A, B>(obj: {
-        fst: A;
-        snd: B;
-    }) => Pair<A, B>;
-    curry: <A>(fst: A) => <B>(snd: B) => Pair<A, B>;
-    mapFirst: <A, B, C>(p: Pair<A, B>, fn: (a: A) => C) => Pair<C, B>;
-    mapSecond: <A, B, C>(p: Pair<A, B>, fn: (b: B) => C) => Pair<A, C>;
-    map: <A, B, C, D>(p: Pair<A, B>, fnA: (a: A) => C, fnB: (b: B) => D) => Pair<C, D>;
-    swap: <A, B>(p: Pair<A, B>) => Pair<B, A>;
-    apply: <A, B, C>(p: Pair<(a: A) => B, C>, value: A) => Pair<B, C>;
-    apply2: <A, B, C>(fnPair: Pair<(a: A) => B, (b: B) => C>, vPair: Pair<A, B>) => Pair<A, C>;
-    reduce: <A, B, C>(p: Pair<A, B>, fn: (a: A, b: B) => C) => C;
-    toArray: <A, B>(p: Pair<A, B>) => [A, B];
-    toObject: <A, B>(p: Pair<A, B>) => {
-        fst: A;
-        snd: B;
-    };
-    eq: <A, B>(p1: Pair<A, B>, p2: Pair<A, B>) => boolean;
-    equals: <A, B>(p1: Pair<A, B>, p2: Pair<A, B>, eqA: (a1: A, a2: A) => boolean, eqB: (b1: B, b2: B) => boolean) => boolean;
-    traverseOption: <A, B, C>(p: Pair<A, Option<B>>, fn: (a: A, b: B) => C) => Option<Pair<A, C>>;
-    traverseResult: <A, B, C, E>(p: Pair<A, Result<B, E>>, fn: (a: A, b: B) => C) => Result<Pair<A, C>, E>;
-    zip: <A, B, C, D>(p1: Pair<A, B>, p2: Pair<C, D>) => Pair<A & C, Pair<B, D>>;
-};
-declare const pair: <A, B>(fst: A, snd: B) => Pair<A, B>;
-
-type Done<T> = {
-    readonly $: "Done";
-    readonly value: T;
+type Left<A> = {
+    readonly $: "Left";
+    readonly value: A;
 };
-type Fail<E> = {
-    readonly $: "Fail";
-    readonly error: E;
+type Right<B> = {
+    readonly $: "Right";
+    readonly value: B;
 };
-type Result<T, E> = Done<T> | Fail<E>;
-declare const Result: {
-    done: <T>(value: T) => Done<T>;
-    fail: <E>(error: E) => Fail<E>;
-    new: <T, E = unknown>(value: T, error: E) => Result<T, E>;
-    isDone: <T, E>(result: Result<T, E>) => result is Done<T>;
-    isFail: <T, E>(result: Result<T, E>) => result is Fail<E>;
-    fromNullable: <T, E = unknown>(value: T | null | undefined, error: E) => Result<T, E>;
-    fromThrowable: <T, E = unknown>(fn: () => T, onError: (e: unknown) => E) => Result<T, E>;
-    fromPromise: <T, E = unknown>(promise: Promise<T>, onError: (e: unknown) => E) => Promise<Result<T, E>>;
-    map: <T, U, E>(result: Result<T, E>, fn: (value: T) => U) => Result<U, E>;
-    mapError: <T, E, F>(result: Result<T, E>, fn: (error: E) => F) => Result<T, F>;
-    flatMap: <T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>) => Result<U, E>;
-    match: <T, E, U>(result: Result<T, E>, matcher: {
-        done: (value: T) => U;
-        fail: (error: E) => U;
-    }) => U;
-    recover: <T, E>(result: Result<T, E>, fn: (error: E) => T) => Result<T, never>;
-    getOrElse: <T, E>(result: Result<T, E>, defaultValue: T) => T;
-    getOrThrow: <T, E>(result: Result<T, E>, onError: (error: E) => never) => T;
-    zip: <A, B, E>(a: Result<A, E>, b: Result<B, E>) => Result<Pair<A, B>, E>;
-    apply: <T, U, E>(fn: Result<(value: T) => U, E>, arg: Result<T, E>) => Result<U, E>;
-    toOption: <T, E>(result: Result<T, E>) => Option<T>;
+declare const left: <A>(value: A) => Left<A>;
+declare const right: <B>(value: B) => Right<B>;
+type Either<A, B> = Left<A> | Right<B>;
+declare const Either: {
+    left: <A>(value: A) => Left<A>;
+    right: <B>(value: B) => Right<B>;
+    new: <A, B>(value: B | null | undefined, error: A) => Either<A, B>;
+    isLeft: <A, B>(e: Either<A, B>) => e is Left<A>;
+    isRight: <A, B>(e: Either<A, B>) => e is Right<B>;
+    fromNullable: <A, B>(value: B | null | undefined, error: A) => Either<A, B>;
+    fromThrowable: <A, B>(fn: () => B, onError: (e: unknown) => A) => Either<A, B>;
+    fromPromise: <A, B>(promise: Promise<B>, onError: (e: unknown) => A) => Promise<Either<A, B>>;
+    map: <A, B, C>(e: Either<A, B>, fn: (r: B) => C) => Either<A, C>;
+    mapLeft: <A, B, C>(e: Either<A, B>, fn: (l: A) => C) => Either<C, B>;
+    bimap: <A, B, C, D>(e: Either<A, B>, fl: (l: A) => C, fr: (r: B) => D) => Either<C, D>;
+    flatMap: <A, B, C>(e: Either<A, B>, fn: (value: B) => Either<A, C>) => Either<A, C>;
+    chain: <A, B, C>(e: Either<A, B>, fn: (r: B) => Either<A, C>) => Either<A, C>;
+    fold: <A, B, C>(e: Either<A, B>, onLeft: (l: A) => C, onRight: (r: B) => C) => C;
+    match: <A, B, C>(e: Either<A, B>, matcher: {
+        right: (value: B) => C;
+        left: (value: A) => C;
+    }) => C;
+    swap: <A, B>(e: Either<A, B>) => Either<B, A>;
+    getOrElse: <A, B>(e: Either<A, B>, defaultValue: B) => B;
+    zip: <E, A, B>(a: Either<E, A>, b: Either<E, B>) => Either<E, [A, B]>;
+    apply: <E, A, B>(fn: Either<E, (value: A) => B>, arg: Either<E, A>) => Either<E, B>;
+    tap: <A, B>(e: Either<A, B>, f: (r: B) => void) => Either<A, B>;
+    tapLeft: <A, B>(e: Either<A, B>, f: (l: A) => void) => Either<A, B>;
 };
-declare const done: <T>(value: T) => Done<T>;
-declare const fail: <E>(error: E) => Fail<E>;
 declare global {
     interface Promise<T> {
-        toResult<E = unknown>(onError?: (e: unknown) => E): Promise<Result<T, E>>;
+        toEither<A>(onError: (e: unknown) => A): Promise<Either<A, T>>;
     }
 }
 
+type NothingNull = null;
+type NothingUndefined = undefined;
+type Nothing = NothingNull | NothingUndefined;
+declare const just: <T>(value: T) => Maybe<T>;
+declare const nothing: () => Nothing;
+type Maybe<T> = T | Nothing;
+declare const Maybe: {
+    just: <T>(value: T) => Maybe<T>;
+    nothing: () => Nothing;
+    new: <T>(v: T | null | undefined) => Maybe<T>;
+    nothingNull: () => NothingNull;
+    nothingUndefined: () => NothingUndefined;
+    isSome: <T>(m: Maybe<T>) => m is T;
+    isNothing: <T>(m: Maybe<T>) => m is Nothing;
+    isNothingNull: <T>(m: Maybe<T>) => m is NothingNull;
+    isNothingUndefined: <T>(m: Maybe<T>) => m is NothingUndefined;
+    fromNullable: <T>(v: T | null | undefined) => Maybe<T>;
+    toNullable: <T>(m: Maybe<T>) => T | null;
+    toUndefined: <T>(m: Maybe<T>) => T | undefined;
+    map: <T, U>(m: Maybe<T>, fn: (v: T) => U) => Maybe<U>;
+    flatMap: <T, U>(m: Maybe<T>, fn: (v: T) => Maybe<U>) => Maybe<U>;
+    filter: <T>(m: Maybe<T>, predicate: (value: T) => boolean) => Maybe<T>;
+    match: <T, U>(m: Maybe<T>, matcher: {
+        some: (v: T) => U;
+        nothing: () => U;
+    }) => U;
+    getOrElse: <T>(m: Maybe<T>, d: T) => T;
+    getOrUndefined: <T>(m: Maybe<T>) => T | undefined;
+    getOrThrow: <T>(m: Maybe<T>, error: Error) => T;
+    fromThrowable: <T>(fn: () => T) => Maybe<T>;
+    fromPromise: <T>(promise: Promise<T>) => Promise<Maybe<T>>;
+    zip: <T, U>(a: Maybe<T>, b: Maybe<U>) => Maybe<[T, U]>;
+    apply: <T, U>(fn: Maybe<(value: T) => U>, opt: Maybe<T>) => Maybe<U>;
+    orElse: <T>(opt: Maybe<T>, other: Maybe<T>) => Maybe<T>;
+};
+
 type None = {
     readonly $: "None";
 };
@@ -76,11 +84,13 @@ type Some<T> = {
     readonly $: "Some";
     readonly value: T;
 };
+declare const none: <T>() => Option<T>;
+declare const some: <T>(value: T) => Option<T>;
 type Option<T> = None | Some<T>;
 declare const Option: {
     none: <T>() => Option<T>;
     some: <T>(value: T) => Option<T>;
-    new: <T>(value: T) => Option<T>;
+    new: <T>(value: T | null | undefined) => Option<T>;
     isSome: <T>(option: Option<T>) => option is Some<T>;
     isNone: <T>(option: Option<T>) => option is None;
     fromNullable: <T>(value: T | null | undefined) => Option<T>;
@@ -100,78 +110,90 @@ declare const Option: {
     zip: <T, U>(a: Option<T>, b: Option<U>) => Option<[T, U]>;
     apply: <T, U>(fn: Option<(value: T) => U>, opt: Option<T>) => Option<U>;
     orElse: <T>(opt: Option<T>, other: Option<T>) => Option<T>;
-    toResult: <T, E>(option: Option<T>, error: E) => Result<T, E>;
 };
-declare const none: <T>() => Option<T>;
-declare const some: <T>(value: T) => Option<T>;
 declare global {
     interface Array<T> {
         firstOption(): Option<T>;
     }
+    interface Promise<T> {
+        toOption(): Promise<Option<T>>;
+    }
 }
 
-type Left<A> = {
-    readonly $: "Left";
-    readonly value: A;
+type Pair<A, B> = readonly [A, B];
+declare const Pair: {
+    fst: <A, B>(p: Pair<A, B>) => A;
+    snd: <A, B>(p: Pair<A, B>) => B;
+    new: <A, B>(a: A, b: B) => Pair<A, B>;
+    fromArray: <A, B>([a, b]: [A, B]) => Pair<A, B>;
+    fromObject: <A, B>(obj: {
+        fst: A;
+        snd: B;
+    }) => Pair<A, B>;
+    curry: <A>(a: A) => <B>(b: B) => Pair<A, B>;
+    mapFirst: <A, B, C>(p: Pair<A, B>, fn: (a: A) => C) => Pair<C, B>;
+    mapSecond: <A, B, C>(p: Pair<A, B>, fn: (b: B) => C) => Pair<A, C>;
+    map: <A, B, C, D>(p: Pair<A, B>, fnA: (a: A) => C, fnB: (b: B) => D) => Pair<C, D>;
+    swap: <A, B>(p: Pair<A, B>) => Pair<B, A>;
+    apply: <A, B, C>(p: Pair<(a: A) => B, C>, value: A) => Pair<B, C>;
+    apply2: <A, B, C>(fnPair: Pair<(a: A) => B, (b: B) => C>, vPair: Pair<A, B>) => Pair<A, C>;
+    reduce: <A, B, C>(p: Pair<A, B>, fn: (a: A, b: B) => C) => C;
+    toArray: <A, B>(p: Pair<A, B>) => [A, B];
+    toObject: <A, B>(p: Pair<A, B>) => {
+        fst: A;
+        snd: B;
+    };
+    eq: <A, B>(p1: Pair<A, B>, p2: Pair<A, B>) => boolean;
+    equals: <A, B>(p1: Pair<A, B>, p2: Pair<A, B>, eqA: (a1: A, a2: A) => boolean, eqB: (b1: B, b2: B) => boolean) => boolean;
+    zip: <A, B, C, D>(p1: Pair<A, B>, p2: Pair<C, D>) => Pair<Pair<A, C>, Pair<B, D>>;
 };
-type Right<B> = {
-    readonly $: "Right";
-    readonly value: B;
+declare const pair: <A, B>(a: A, b: B) => Pair<A, B>;
+
+type Done<T> = {
+    readonly v: T;
 };
-type Either<A, B> = Left<A> | Right<B>;
-declare const Either: {
-    left: <A>(value: A) => Left<A>;
-    right: <B>(value: B) => Right<B>;
-    new: <A, B>(rgt: B, lft: A) => Either<A, B>;
-    isLeft: <A, B>(e: Either<A, B>) => e is Left<A>;
-    isRight: <A, B>(e: Either<A, B>) => e is Right<B>;
-    fromNullable: <A, B>(value: B | null | undefined, error: A) => Either<A, B>;
-    fromThrowable: <A, B>(fn: () => B, onError: (e: unknown) => A) => Either<A, B>;
-    fromPromise: <A, B>(promise: Promise<B>, onError: (e: unknown) => A) => Promise<Either<A, B>>;
-    map: <A, B, C>(e: Either<A, B>, fn: (r: B) => C) => Either<A, C>;
-    mapLeft: <A, B, C>(e: Either<A, B>, fn: (l: A) => C) => Either<C, B>;
-    bimap: <A, B, C, D>(e: Either<A, B>, fl: (l: A) => C, fr: (r: B) => D) => Either<C, D>;
-    flatMap: <A, B, C>(e: Either<A, B>, fn: (value: B) => Either<A, C>) => Either<A, C>;
-    chain: <A, B, C>(e: Either<A, B>, fn: (r: B) => Either<A, C>) => Either<A, C>;
-    fold: <A, B, C>(e: Either<A, B>, onLeft: (l: A) => C, onRight: (r: B) => C) => C;
-    match: <A, B, C>(e: Either<A, B>, matcher: {
-        right: (value: B) => C;
-        left: (value: A) => C;
-    }) => C;
-    swap: <A, B>(e: Either<A, B>) => Either<B, A>;
-    getOrElse: <A, B>(e: Either<A, B>, defaultValue: B) => B;
-    zip: <E, A, B>(a: Either<E, A>, b: Either<E, B>) => Either<E, Pair<A, B>>;
-    apply: <E, A, B>(fn: Either<E, (value: A) => B>, arg: Either<E, A>) => Either<E, B>;
-    tap: <A, B>(e: Either<A, B>, f: (r: B) => void) => Either<A, B>;
-    tapLeft: <A, B>(e: Either<A, B>, f: (l: A) => void) => Either<A, B>;
+type Fail<E> = {
+    readonly e: E;
+};
+declare const done: <T>(value: T) => Done<T>;
+declare const fail: <E>(error: E) => Fail<E>;
+type Result<T, E> = Done<T> | Fail<E>;
+declare const Result: {
+    done: <T>(value: T) => Done<T>;
+    fail: <E>(error: E) => Fail<E>;
+    OK: <T>(value: T) => Done<T>;
+    Err: <E>(error: E) => Fail<E>;
+    new: <T, E>(value: T | null | undefined, error: E) => Result<T, E>;
+    isDone: <T, E>(r: Result<T, E>) => r is Done<T>;
+    isFail: <T, E>(r: Result<T, E>) => r is Fail<E>;
+    isOk: <T, E>(r: Result<T, E>) => r is Done<T>;
+    isErr: <T, E>(r: Result<T, E>) => r is Fail<E>;
+    fromNullable: <T, E>(value: T | null | undefined, error: E) => Result<T, E>;
+    fromThrowable: <T, E>(fn: () => T, onError: (e: unknown) => E) => Result<T, E>;
+    fromPromise: <T, E>(promise: Promise<T>, onError: (e: unknown) => E) => Promise<Result<T, E>>;
+    map: <T, E, U>(r: Result<T, E>, fn: (a: T) => U) => Result<U, E>;
+    mapErr: <T, E, F>(r: Result<T, E>, fn: (b: E) => F) => Result<T, F>;
+    bimap: <T, E, U, F>(r: Result<T, E>, onDone: (a: T) => U, onFail: (b: E) => F) => Result<U, F>;
+    flatMap: <T, E, C>(r: Result<T, E>, fn: (a: T) => Result<C, E>) => Result<C, E>;
+    match: <T, E, U>(r: Result<T, E>, matcher: {
+        done: (a: T) => U;
+        fail: (b: E) => U;
+    }) => U;
+    fold: <T, E, U>(r: Result<T, E>, onFail: (error: E) => U, onDone: (value: T) => U) => U;
+    recover: <T, E>(r: Result<T, E>, fn: (error: E) => T) => Result<T, E>;
+    getOrElse: <T, E>(r: Result<T, E>, d: T) => T;
+    getOrThrow: <T, E>(r: Result<T, E>, onError: (b: E) => never) => T;
+    zip: <T, U, E>(a: Result<T, E>, b: Result<U, E>) => Result<[T, U], E>;
+    apply: <T, U, E>(fn: Result<(a: T) => U, E>, arg: Result<T, E>) => Result<U, E>;
+    orElse: <T, E>(a: Result<T, E>, b: Result<T, E>) => Result<T, E>;
+    filter: <T, E>(r: Result<T, E>, predicate: (a: T) => boolean, onFalse: E) => Result<T, E>;
+    tap: <T, E>(r: Result<T, E>, f: (a: T) => void) => Result<T, E>;
+    tapErr: <T, E>(r: Result<T, E>, f: (b: E) => void) => Result<T, E>;
 };
 declare global {
     interface Promise<T> {
-        toEither<A>(onError: (e: unknown) => A): Promise<Either<A, T>>;
+        toResult<E = unknown>(onError: (e: unknown) => E): Promise<Result<T, E>>;
     }
 }
-declare const left: <A>(value: A) => Left<A>;
-declare const right: <B>(value: B) => Right<B>;
-
-type Triple<A, B, C> = readonly [A, B, C];
-declare const Triple: {
-    fst: <A, B, C>(t: Triple<A, B, C>) => A;
-    snd: <A, B, C>(t: Triple<A, B, C>) => B;
-    thd: <A, B, C>(t: Triple<A, B, C>) => C;
-    new: <A, B, C>(fst: A, snd: B, thd: C) => Triple<A, B, C>;
-    fromArray: <A, B, C>([fst, snd, thd]: [A, B, C]) => Triple<A, B, C>;
-    toArray: <A, B, C>(t: Triple<A, B, C>) => [A, B, C];
-    fromObject: <A, B, C>(obj: {
-        fst: A;
-        snd: B;
-        thd: C;
-    }) => Triple<A, B, C>;
-    curry: <A>(fst: A) => <B>(snd: B) => <C>(thd: C) => Triple<A, B, C>;
-    equals: <A, B, C>(t1: Triple<A, B, C>, t2: Triple<A, B, C>, eqA: (a1: A, a2: A) => boolean, eqB: (b1: B, b2: B) => boolean, eqC: (c1: C, c2: C) => boolean) => boolean;
-    map: <A, B, C, D, E, F>(t: Triple<A, B, C>, fnA: (a: A) => D, fnB: (b: B) => E, fnC: (c: C) => F) => Triple<D, E, F>;
-    zip: <A, B, C, D, E, F>(t1: Triple<A, B, C>, t2: Triple<D, E, F>) => Triple<A & D, B & E, C & F>;
-    apply: <A, B, C, D>(t: Triple<(a: A) => B, (b: B) => C, (c: C) => D>, value: A) => Triple<B, C, D>;
-};
-declare const triple: <A, B, C>(fst: A, snd: B, thd: C) => Triple<A, B, C>;
 
-export { type Done, Either, type Fail, type Left, type None, Option, Pair, Result, type Right, type Some, Triple, done, fail, left, none, pair, right, some, triple };
+export { type Done, Either, type Fail, type Left, Maybe, type None, type Nothing, type NothingNull, type NothingUndefined, Option, Pair, Result, type Right, type Some, done, fail, just, left, none, nothing, pair, right, some };

package/dist/index.js

@@ -1,287 +1 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[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 index_exports = {};
-__export(index_exports, {
-  Either: () => Either,
-  Option: () => Option,
-  Pair: () => Pair,
-  Result: () => Result,
-  Triple: () => Triple,
-  done: () => done,
-  fail: () => fail,
-  left: () => left,
-  none: () => none,
-  pair: () => pair,
-  right: () => right,
-  some: () => some,
-  triple: () => triple
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/Result.ts
-var Result = {
-  // Constructors
-  done: (value) => ({ $: "Done", value }),
-  fail: (error) => ({ $: "Fail", error }),
-  new: (value, error) => value === void 0 || value === null ? { $: "Fail", error } : { $: "Done", value },
-  // Guards
-  isDone: (result) => result.$ === "Done",
-  isFail: (result) => result.$ === "Fail",
-  // Conversions
-  fromNullable: (value, error) => value == null ? Result.fail(error) : Result.done(value),
-  fromThrowable: (fn, onError) => {
-    try {
-      return Result.done(fn());
-    } catch (e) {
-      return Result.fail(onError(e));
-    }
-  },
-  fromPromise: async (promise, onError) => {
-    try {
-      const value = await promise;
-      return Result.done(value);
-    } catch (e) {
-      return Result.fail(onError(e));
-    }
-  },
-  // Ops
-  map: (result, fn) => result.$ === "Done" ? Result.done(fn(result.value)) : result,
-  mapError: (result, fn) => result.$ === "Fail" ? Result.fail(fn(result.error)) : result,
-  flatMap: (result, fn) => result.$ === "Done" ? fn(result.value) : result,
-  match: (result, matcher) => result.$ === "Done" ? matcher.done(result.value) : matcher.fail(result.error),
-  recover: (result, fn) => result.$ === "Fail" ? Result.done(fn(result.error)) : result,
-  // Extract
-  getOrElse: (result, defaultValue) => result.$ === "Done" ? result.value : defaultValue,
-  getOrThrow: (result, onError) => result.$ === "Done" ? result.value : onError(result.error),
-  // Combine
-  zip: (a, b) => {
-    if (a.$ === "Fail") return a;
-    if (b.$ === "Fail") return b;
-    return Result.done([a.value, b.value]);
-  },
-  apply: (fn, arg) => {
-    if (fn.$ === "Fail") return fn;
-    if (arg.$ === "Fail") return arg;
-    return Result.done(fn.value(arg.value));
-  },
-  // Convert
-  toOption: (result) => result.$ === "Done" ? some(result.value) : none()
-};
-var done = Result.done;
-var fail = Result.fail;
-Promise.prototype.toResult = function(onError) {
-  const mapErr = (e) => onError ? onError(e) : e;
-  return Result.fromPromise(this, mapErr);
-};
-
-// src/Option.ts
-var Option = {
-  // Constructors
-  none: () => ({ $: "None" }),
-  some: (value) => ({ $: "Some", value }),
-  new: (value) => value === void 0 || value === null ? { $: "None" } : { $: "Some", value },
-  // Guards
-  isSome: (option) => option.$ === "Some",
-  isNone: (option) => option.$ === "None",
-  // Conversions
-  fromNullable: (value) => value == null ? Option.none() : Option.some(value),
-  fromPredicate: (value, predicate) => predicate(value) ? Option.some(value) : Option.none(),
-  fromThrowable: (fn) => {
-    try {
-      return Option.some(fn());
-    } catch {
-      return Option.none();
-    }
-  },
-  fromPromise: async (promise) => {
-    try {
-      const value = await promise;
-      return Option.some(value);
-    } catch {
-      return Option.none();
-    }
-  },
-  // Ops
-  map: (option, fn) => option.$ === "Some" ? Option.some(fn(option.value)) : Option.none(),
-  flatMap: (option, fn) => option.$ === "Some" ? fn(option.value) : Option.none(),
-  filter: (option, predicate) => option.$ === "Some" && predicate(option.value) ? option : Option.none(),
-  match: (option, matcher) => option.$ === "Some" ? matcher.some(option.value) : matcher.none(),
-  // Extract
-  getOrElse: (option, defaultValue) => option.$ === "Some" ? option.value : defaultValue,
-  getOrUndefined: (option) => option.$ === "Some" ? option.value : void 0,
-  getOrThrow: (option, error) => {
-    if (option.$ === "Some") return option.value;
-    throw error;
-  },
-  // Combine
-  zip: (a, b) => a.$ === "Some" && b.$ === "Some" ? Option.some([a.value, b.value]) : Option.none(),
-  apply: (fn, opt) => fn.$ === "Some" && opt.$ === "Some" ? Option.some(fn.value(opt.value)) : Option.none(),
-  orElse: (opt, other) => opt.$ === "Some" ? opt : other,
-  // Convert
-  toResult: (option, error) => option.$ === "Some" ? done(option.value) : fail(error)
-};
-var none = Option.none;
-var some = Option.some;
-Array.prototype.firstOption = function() {
-  return this[0] ? some(this[0]) : none();
-};
-
-// src/Pair.ts
-var Pair = {
-  fst: (p) => p[0],
-  snd: (p) => p[1],
-  new: (fst, snd) => [fst, snd],
-  fromArray: ([fst, snd]) => [fst, snd],
-  fromObject: (obj) => [obj.fst, obj.snd],
-  curry: (fst) => (snd) => [fst, snd],
-  mapFirst: (p, fn) => pair(fn(p[0]), p[1]),
-  mapSecond: (p, fn) => pair(p[0], fn(p[1])),
-  map: (p, fnA, fnB) => pair(fnA(p[0]), fnB(p[1])),
-  swap: (p) => pair(p[1], p[0]),
-  apply: (p, value) => pair(p[0](value), p[1]),
-  apply2: (fnPair, vPair) => pair(vPair[0], fnPair[1](vPair[1])),
-  reduce: (p, fn) => fn(p[0], p[1]),
-  toArray: (p) => [p[0], p[1]],
-  toObject: (p) => ({
-    fst: p[0],
-    snd: p[1]
-  }),
-  eq: (p1, p2) => p1[0] === p2[0] && p1[1] === p2[1],
-  equals: (p1, p2, eqA, eqB) => eqA(p1[0], p2[0]) && eqB(p1[1], p2[1]),
-  traverseOption: (p, fn) => p[1].$ === "Some" ? some(Pair.new(p[0], fn(p[0], p[1].value))) : none(),
-  traverseResult: (p, fn) => p[1].$ === "Done" ? done(Pair.new(p[0], fn(p[0], p[1].value))) : fail(p[1].error),
-  zip: (p1, p2) => pair({ ...p1[0], ...p2[0] }, pair(p1[1], p2[1]))
-};
-var pair = Pair.new;
-
-// src/Either.ts
-var Either = {
-  // Constructors
-  left: (value) => ({ $: "Left", value }),
-  right: (value) => ({ $: "Right", value }),
-  new: (rgt, lft) => rgt === void 0 || rgt === null ? Either.left(lft) : Either.right(rgt),
-  // Guards
-  isLeft: (e) => e.$ === "Left",
-  isRight: (e) => e.$ === "Right",
-  // Conversions
-  fromNullable: (value, error) => value == null ? Either.left(error) : Either.right(value),
-  fromThrowable: (fn, onError) => {
-    try {
-      return Either.right(fn());
-    } catch (e) {
-      return Either.left(onError(e));
-    }
-  },
-  fromPromise: async (promise, onError) => {
-    try {
-      const value = await promise;
-      return Either.right(value);
-    } catch (e) {
-      return Either.left(onError(e));
-    }
-  },
-  // Ops
-  map: (e, fn) => e.$ === "Right" ? Either.right(fn(e.value)) : e,
-  mapLeft: (e, fn) => e.$ === "Left" ? Either.left(fn(e.value)) : e,
-  bimap: (e, fl, fr) => e.$ === "Left" ? Either.left(fl(e.value)) : Either.right(fr(e.value)),
-  flatMap: (e, fn) => e.$ === "Right" ? fn(e.value) : e,
-  chain: (e, fn) => e.$ === "Right" ? fn(e.value) : e,
-  fold: (e, onLeft, onRight) => e.$ === "Left" ? onLeft(e.value) : onRight(e.value),
-  match: (e, matcher) => e.$ === "Right" ? matcher.right(e.value) : matcher.left(e.value),
-  swap: (e) => e.$ === "Right" ? Either.left(e.value) : Either.right(e.value),
-  // Extract
-  getOrElse: (e, defaultValue) => e.$ === "Right" ? e.value : defaultValue,
-  // Combine
-  zip: (a, b) => {
-    if (a.$ === "Left") return a;
-    if (b.$ === "Left") return b;
-    return Either.right(pair(a.value, b.value));
-  },
-  apply: (fn, arg) => {
-    if (fn.$ === "Left") return fn;
-    if (arg.$ === "Left") return arg;
-    return Either.right(fn.value(arg.value));
-  },
-  tap: (e, f) => {
-    if (e.$ === "Right") f(e.value);
-    return e;
-  },
-  tapLeft: (e, f) => {
-    if (e.$ === "Left") f(e.value);
-    return e;
-  }
-};
-Promise.prototype.toEither = async function(onError) {
-  try {
-    const v = await this;
-    return right(v);
-  } catch (e_1) {
-    return left(onError(e_1));
-  }
-};
-var left = Either.left;
-var right = Either.right;
-
-// src/Triple.ts
-var Triple = {
-  fst: (t) => t[0],
-  snd: (t) => t[1],
-  thd: (t) => t[2],
-  new: (fst, snd, thd) => [fst, snd, thd],
-  fromArray: ([fst, snd, thd]) => [
-    fst,
-    snd,
-    thd
-  ],
-  toArray: (t) => [t[0], t[1], t[2]],
-  fromObject: (obj) => [
-    obj.fst,
-    obj.snd,
-    obj.thd
-  ],
-  curry: (fst) => (snd) => (thd) => [fst, snd, thd],
-  equals: (t1, t2, eqA, eqB, eqC) => eqA(t1[0], t2[0]) && eqB(t1[1], t2[1]) && eqC(t1[2], t2[2]),
-  map: (t, fnA, fnB, fnC) => triple(fnA(t[0]), fnB(t[1]), fnC(t[2])),
-  zip: (t1, t2) => triple(
-    { ...t1[0], ...t2[0] },
-    { ...t1[1], ...t2[1] },
-    { ...t1[2], ...t2[2] }
-  ),
-  apply: (t, value) => triple(t[0](value), t[1](t[0](value)), t[2](t[1](t[0](value))))
-};
-var triple = Triple.new;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Either,
-  Option,
-  Pair,
-  Result,
-  Triple,
-  done,
-  fail,
-  left,
-  none,
-  pair,
-  right,
-  some,
-  triple
-});
-//# sourceMappingURL=index.js.map
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var h=(e,t,o)=>new Promise((x,f)=>{var O=E=>{try{A(o.next(E))}catch(B){f(B)}},g=E=>{try{A(o.throw(E))}catch(B){f(B)}},A=E=>E.done?x(E.value):Promise.resolve(E.value).then(O,g);A((o=o.apply(e,t)).next())});var T=e=>({$:"Left",value:e}),i= exports.right =e=>({$:"Right",value:e}),C=e=>e.$==="Left",M=e=>e.$==="Right",y=(e,t)=>e==null?T(t):i(e),$=(e,t)=>{try{return i(e())}catch(o){return T(t(o))}},N=(e,t)=>h(null,null,function*(){try{let o=yield e;return i(o)}catch(o){return T(t(o))}}),w=(e,t)=>e.$==="Right"?i(t(e.value)):e,L=(e,t)=>e.$==="Left"?T(t(e.value)):e,S=(e,t,o)=>e.$==="Left"?T(t(e.value)):i(o(e.value)),D=(e,t)=>e.$==="Right"?t(e.value):e,k=(e,t)=>e.$==="Right"?t(e.value):e,F=(e,t,o)=>e.$==="Left"?t(e.value):o(e.value),z=(e,t)=>e.$==="Right"?t.right(e.value):t.left(e.value),j=e=>e.$==="Right"?T(e.value):i(e.value),q=(e,t)=>e.$==="Right"?e.value:t,K=(e,t)=>e.$==="Left"?e:t.$==="Left"?t:i([e.value,t.value]),_=(e,t)=>e.$==="Left"?e:t.$==="Left"?t:i(e.value(t.value)),G=(e,t)=>(e.$==="Right"&&t(e.value),e),H=(e,t)=>(e.$==="Left"&&t(e.value),e),I= exports.Either ={left:T,right:i,new:y,isLeft:C,isRight:M,fromNullable:y,fromThrowable:$,fromPromise:N,map:w,mapLeft:L,bimap:S,flatMap:D,chain:k,fold:F,match:z,swap:j,getOrElse:q,zip:K,apply:_,tap:G,tapLeft:H};Promise.prototype.toEither=function(e){return h(this,null,function*(){try{let t=yield this;return i(t)}catch(t){return T(e(t))}})};var d=e=>e,a= exports.nothing =()=>{},J=()=>null,v=()=>{},Q=e=>e!=null,V=e=>e==null,W=e=>e===null,X=e=>e===void 0,m=e=>e,Y=e=>e==null?null:e,Z=e=>e==null?void 0:e,ee=e=>{try{return e()}catch(t){return a()}},te=e=>e.then(t=>t,()=>a());var oe=(e,t)=>e==null?a():t(e),re=(e,t)=>e==null?a():t(e),ne=(e,t)=>e!=null&&t(e)?e:a(),ie=(e,t)=>e==null?t.nothing():t.some(e),se=(e,t)=>e==null?t:e,le=e=>e==null?v():e,Te=(e,t)=>{if(e!=null)return e;throw t},ae=(e,t)=>e!=null&&t!=null?[e,t]:a(),pe=(e,t)=>e!=null&&t!=null?e(t):a(),ue=(e,t)=>e!=null?e:t,ce= exports.Maybe ={just:d,nothing:a,new:m,nothingNull:J,nothingUndefined:v,isSome:Q,isNothing:V,isNothingNull:W,isNothingUndefined:X,fromNullable:m,toNullable:Y,toUndefined:Z,map:oe,flatMap:re,filter:ne,match:ie,getOrElse:se,getOrUndefined:le,getOrThrow:Te,fromThrowable:ee,fromPromise:te,zip:ae,apply:pe,orElse:ue};var r=()=>({$:"None"}),l= exports.some =e=>({$:"Some",value:e}),Ee=e=>e.$==="Some",xe=e=>e.$==="None",b=e=>e==null?r():l(e),Ae=(e,t)=>t(e)?l(e):r(),Be=e=>{try{return l(e())}catch(t){return r()}},U=e=>e.then(l,()=>r()),he=(e,t)=>e.$==="Some"?l(t(e.value)):r(),fe=(e,t)=>e.$==="Some"?t(e.value):r(),ye=(e,t)=>e.$==="Some"&&t(e.value)?e:r(),me=(e,t)=>e.$==="Some"?t.some(e.value):t.none(),de=(e,t)=>e.$==="Some"?e.value:t,ve=e=>e.$==="Some"?e.value:void 0,be=(e,t)=>{if(e.$==="Some")return e.value;throw t},Ue=(e,t)=>e.$==="Some"&&t.$==="Some"?l([e.value,t.value]):r(),Pe=(e,t)=>e.$==="Some"&&t.$==="Some"?l(e.value(t.value)):r(),Re=(e,t)=>e.$==="Some"?e:t,Oe= exports.Option ={none:r,some:l,new:b,isSome:Ee,isNone:xe,fromNullable:b,fromPredicate:Ae,fromThrowable:Be,fromPromise:U,map:he,flatMap:fe,filter:ye,match:me,getOrElse:de,getOrUndefined:ve,getOrThrow:be,zip:Ue,apply:Pe,orElse:Re};Array.prototype.firstOption=function(){return this[0]?l(this[0]):r()};Promise.prototype.toOption=function(){return U(this)};var ge=e=>e[0],Ce=e=>e[1],p=(e,t)=>[e,t],Me=([e,t])=>[e,t],$e=e=>[e.fst,e.snd],Ne=e=>t=>[e,t],we=(e,t)=>p(t(e[0]),e[1]),Le=(e,t)=>p(e[0],t(e[1])),Se=(e,t,o)=>p(t(e[0]),o(e[1])),De=e=>p(e[1],e[0]),ke=(e,t)=>p(e[0](t),e[1]),Fe=(e,t)=>p(t[0],e[1](t[1])),ze=(e,t)=>t(e[0],e[1]),je=e=>[e[0],e[1]],qe=e=>({fst:e[0],snd:e[1]}),Ke=(e,t)=>e[0]===t[0]&&e[1]===t[1],_e=(e,t,o,x)=>o(e[0],t[0])&&x(e[1],t[1]),Ge=(e,t)=>p([e[0],t[0]],[e[1],t[1]]),He= exports.Pair ={fst:ge,snd:Ce,new:p,fromArray:Me,fromObject:$e,curry:Ne,mapFirst:we,mapSecond:Le,map:Se,swap:De,apply:ke,apply2:Fe,reduce:ze,toArray:je,toObject:qe,eq:Ke,equals:_e,zip:Ge},Ie= exports.pair =p;var s=e=>({v:e}),u= exports.fail =e=>({e}),n=e=>"value"in e,c=e=>"error"in e,P=(e,t)=>e==null?u(t):s(e),Je=(e,t)=>{try{return s(e())}catch(o){return u(t(o))}},R=(e,t)=>e.then(s,o=>u(t(o))),Qe=(e,t)=>n(e)?s(t(e.v)):e,Ve=(e,t)=>c(e)?u(t(e.e)):e,We=(e,t,o)=>n(e)?s(t(e.v)):u(o(e.e)),Xe=(e,t)=>n(e)?t(e.v):e,Ye=(e,t)=>n(e)?t.done(e.v):t.fail(e.e),Ze=(e,t,o)=>n(e)?o(e.v):t(e.e),et=(e,t)=>c(e)?s(t(e.e)):e,tt=(e,t)=>n(e)?e.v:t;var ot=(e,t)=>n(e)?e.v:t(e.e),rt=(e,t)=>c(e)?e:c(t)?t:s([e.v,t.v]),nt=(e,t)=>c(e)?e:c(t)?t:s(e.v(t.v)),it=(e,t)=>n(e)?e:t,st=(e,t,o)=>n(e)?t(e.v)?e:u(o):e,lt=(e,t)=>(n(e)&&t(e.v),e),Tt=(e,t)=>(c(e)&&t(e.e),e),at= exports.Result ={done:s,fail:u,OK:s,Err:u,new:P,isDone:n,isFail:c,isOk:n,isErr:c,fromNullable:P,fromThrowable:Je,fromPromise:R,map:Qe,mapErr:Ve,bimap:We,flatMap:Xe,match:Ye,fold:Ze,recover:et,getOrElse:tt,getOrThrow:ot,zip:rt,apply:nt,orElse:it,filter:st,tap:lt,tapErr:Tt};Promise.prototype.toResult=function(e){return R(this,e)};exports.Either = I; exports.Maybe = ce; exports.Option = Oe; exports.Pair = He; exports.Result = at; exports.done = s; exports.fail = u; exports.just = d; exports.left = T; exports.none = r; exports.nothing = a; exports.pair = Ie; exports.right = i; exports.some = l;