@duplojs/utils 0.3.0 → 1.0.0

package/dist/either/bool/base.d.ts

@@ -0,0 +1 @@
+export declare const eitherBoolKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-bool", unknown>>;

package/dist/either/bool/base.mjs

@@ -0,0 +1,5 @@
+import { createKind } from '../../common/kind.mjs';
+
+const eitherBoolKind = createKind("either-bool");
+
+export { eitherBoolKind };

package/dist/either/bool/create.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var falsy = require('./falsy.cjs');
+var truthy = require('./truthy.cjs');
+
+function bool(value) {
+    return value === undefined
+        || value === null
+        || value === 0
+        || value === ""
+        || value === false
+        ? falsy.boolFalsy(value)
+        : truthy.boolTruthy(value);
+}
+
+exports.bool = bool;

package/dist/either/bool/create.d.ts

@@ -0,0 +1,4 @@
+import { type IsEqual } from "../../common";
+import { type BoolFalsyValue, type EitherBoolFalsy } from "./falsy";
+import { type EitherBoolTruthy } from "./truthy";
+export declare function bool<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends BoolFalsyValue ? EitherBoolFalsy<GenericValue> : IsEqual<GenericValue, number> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<0> : IsEqual<GenericValue, string> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<""> : EitherBoolTruthy<GenericValue>;

package/dist/either/bool/create.mjs

@@ -0,0 +1,14 @@
+import { boolFalsy } from './falsy.mjs';
+import { boolTruthy } from './truthy.mjs';
+
+function bool(value) {
+    return value === undefined
+        || value === null
+        || value === 0
+        || value === ""
+        || value === false
+        ? boolFalsy(value)
+        : boolTruthy(value);
+}
+
+export { bool };

package/dist/either/bool/falsy.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var unwrap = require('../../common/unwrap.cjs');
+var create = require('../left/create.cjs');
+var is = require('../left/is.cjs');
+var is$1 = require('../right/is.cjs');
+var create$1 = require('./create.cjs');
+var base = require('./base.cjs');
+
+const eitherBoolFalsyKind = kind.createKind("either-bool-falsy");
+function boolFalsy(value = undefined) {
+    return base.eitherBoolKind.addTo(eitherBoolFalsyKind.addTo(create.left("bool", value)));
+}
+function isBoolFalsy(input) {
+    return is.isLeft(input)
+        && base.eitherBoolKind.has(input)
+        && eitherBoolFalsyKind.has(input);
+}
+function whenIsBoolFalsy(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsBoolFalsy(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is$1.isRight(input)) {
+        return input;
+    }
+    else if (!isBoolFalsy(input) && is.isLeft(input)) {
+        return input;
+    }
+    const either = is$1.isRight(input) || is.isLeft(input)
+        ? input
+        : create$1.bool(input);
+    if (isBoolFalsy(either)) {
+        return theFunction(unwrap.unwrap(either));
+    }
+    return either;
+}
+
+exports.boolFalsy = boolFalsy;
+exports.eitherBoolFalsyKind = eitherBoolFalsyKind;
+exports.isBoolFalsy = isBoolFalsy;
+exports.whenIsBoolFalsy = whenIsBoolFalsy;

package/dist/either/bool/falsy.d.ts

@@ -0,0 +1,16 @@
+import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EitherLeft } from "../left";
+import { type EitherRight } from "../right";
+import { bool } from "./create";
+import { type Kind } from "../../common/kind";
+import { eitherBoolKind } from "./base";
+export type BoolFalsyValue = 0 | "" | undefined | null | false;
+export declare const eitherBoolFalsyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-bool-falsy", unknown>>;
+export type EitherBoolFalsy<GenericValue extends BoolFalsyValue = BoolFalsyValue> = (EitherLeft<"bool", GenericValue> & Kind<typeof eitherBoolKind.definition> & Kind<typeof eitherBoolFalsyKind.definition>);
+export declare function boolFalsy<const GenericValue extends BoolFalsyValue = undefined>(value?: GenericValue): EitherBoolFalsy<GenericValue>;
+type Either = EitherRight | EitherLeft;
+export declare function isBoolFalsy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolFalsy>;
+type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;
+export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolFalsy>;
+export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolFalsy>;
+export {};

package/dist/either/bool/falsy.mjs

@@ -0,0 +1,39 @@
+import { createKind } from '../../common/kind.mjs';
+import { unwrap } from '../../common/unwrap.mjs';
+import { left } from '../left/create.mjs';
+import { isLeft } from '../left/is.mjs';
+import { isRight } from '../right/is.mjs';
+import { bool } from './create.mjs';
+import { eitherBoolKind } from './base.mjs';
+
+const eitherBoolFalsyKind = createKind("either-bool-falsy");
+function boolFalsy(value = undefined) {
+    return eitherBoolKind.addTo(eitherBoolFalsyKind.addTo(left("bool", value)));
+}
+function isBoolFalsy(input) {
+    return isLeft(input)
+        && eitherBoolKind.has(input)
+        && eitherBoolFalsyKind.has(input);
+}
+function whenIsBoolFalsy(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsBoolFalsy(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isRight(input)) {
+        return input;
+    }
+    else if (!isBoolFalsy(input) && isLeft(input)) {
+        return input;
+    }
+    const either = isRight(input) || isLeft(input)
+        ? input
+        : bool(input);
+    if (isBoolFalsy(either)) {
+        return theFunction(unwrap(either));
+    }
+    return either;
+}
+
+export { boolFalsy, eitherBoolFalsyKind, isBoolFalsy, whenIsBoolFalsy };

package/dist/either/bool/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./create";
+export * from "./falsy";
+export * from "./truthy";
+export * from "./base";

package/dist/either/bool/truthy.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var unwrap = require('../../common/unwrap.cjs');
+var is$1 = require('../left/is.cjs');
+var create = require('../right/create.cjs');
+var is = require('../right/is.cjs');
+var create$1 = require('./create.cjs');
+var base = require('./base.cjs');
+
+const eitherBoolTruthyKind = kind.createKind("either-bool-truthy");
+function boolTruthy(value) {
+    return base.eitherBoolKind.addTo(eitherBoolTruthyKind.addTo(create.right("bool", value)));
+}
+function isBoolTruthy(input) {
+    return is.isRight(input)
+        && base.eitherBoolKind.has(input)
+        && eitherBoolTruthyKind.has(input);
+}
+function whenIsBoolTruthy(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsBoolTruthy(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is$1.isLeft(input)) {
+        return input;
+    }
+    else if (!isBoolTruthy(input) && is.isRight(input)) {
+        return input;
+    }
+    const either = is.isRight(input) || is$1.isLeft(input)
+        ? input
+        : create$1.bool(input);
+    if (isBoolTruthy(either)) {
+        return theFunction(unwrap.unwrap(either));
+    }
+    return either;
+}
+
+exports.boolTruthy = boolTruthy;
+exports.eitherBoolTruthyKind = eitherBoolTruthyKind;
+exports.isBoolTruthy = isBoolTruthy;
+exports.whenIsBoolTruthy = whenIsBoolTruthy;

package/dist/either/bool/truthy.d.ts

@@ -0,0 +1,15 @@
+import { type EitherRight } from "../right";
+import { bool } from "./create";
+import { type EitherLeft } from "../left";
+import { type Kind } from "../../common/kind";
+import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { eitherBoolKind } from "./base";
+export declare const eitherBoolTruthyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-bool-truthy", unknown>>;
+export type EitherBoolTruthy<GenericValue extends unknown = unknown> = (EitherRight<"bool", GenericValue> & Kind<typeof eitherBoolKind.definition> & Kind<typeof eitherBoolTruthyKind.definition>);
+export declare function boolTruthy<const GenericValue extends unknown>(value: GenericValue): EitherBoolTruthy<GenericValue>;
+type Either = EitherRight | EitherLeft;
+export declare function isBoolTruthy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolTruthy>;
+type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;
+export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolTruthy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolTruthy>;
+export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolTruthy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolTruthy>;
+export {};

package/dist/either/bool/truthy.mjs

@@ -0,0 +1,39 @@
+import { createKind } from '../../common/kind.mjs';
+import { unwrap } from '../../common/unwrap.mjs';
+import { isLeft } from '../left/is.mjs';
+import { right } from '../right/create.mjs';
+import { isRight } from '../right/is.mjs';
+import { bool } from './create.mjs';
+import { eitherBoolKind } from './base.mjs';
+
+const eitherBoolTruthyKind = createKind("either-bool-truthy");
+function boolTruthy(value) {
+    return eitherBoolKind.addTo(eitherBoolTruthyKind.addTo(right("bool", value)));
+}
+function isBoolTruthy(input) {
+    return isRight(input)
+        && eitherBoolKind.has(input)
+        && eitherBoolTruthyKind.has(input);
+}
+function whenIsBoolTruthy(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsBoolTruthy(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isLeft(input)) {
+        return input;
+    }
+    else if (!isBoolTruthy(input) && isRight(input)) {
+        return input;
+    }
+    const either = isRight(input) || isLeft(input)
+        ? input
+        : bool(input);
+    if (isBoolTruthy(either)) {
+        return theFunction(unwrap(either));
+    }
+    return either;
+}
+
+export { boolTruthy, eitherBoolTruthyKind, isBoolTruthy, whenIsBoolTruthy };

package/dist/either/future/MaybeFutureEither.d.ts

@@ -0,0 +1,2 @@
+import { type Future } from "./create";
+export type MaybeFutureEither<GenericValue extends unknown> = Future<GenericValue> | GenericValue;

package/dist/either/future/base.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+
+const eitherFutureKind = kind.createKind("either-future");
+
+exports.eitherFutureKind = eitherFutureKind;

package/dist/either/future/base.d.ts

@@ -0,0 +1 @@
+export declare const eitherFutureKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-future", unknown>>;

package/dist/either/future/base.mjs

@@ -0,0 +1,5 @@
+import { createKind } from '../../common/kind.mjs';
+
+const eitherFutureKind = createKind("either-future");
+
+export { eitherFutureKind };

package/dist/either/future/create.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+var is$1 = require('../left/is.cjs');
+var success = require('./success.cjs');
+var error = require('./error.cjs');
+var is = require('../right/is.cjs');
+
+const kind = "kind-future-either";
+class Future extends Promise {
+    constructor(value) {
+        super((resolve) => void resolve((value instanceof Promise
+            ? value
+            : Promise.resolve(value))
+            .then((value) => {
+            if (is.isRight(value)) {
+                return value;
+            }
+            else if (is$1.isLeft(value)) {
+                return value;
+            }
+            else {
+                return success.futureSuccess(value);
+            }
+        })
+            .catch((error$1) => error.futureError(error$1))));
+    }
+    [kind] = null;
+    // @ts-expect-error override signature error
+    then(theFunction) {
+        return new Future(super.then(theFunction));
+    }
+    static get [Symbol.species]() {
+        return Promise;
+    }
+    static instanceof(value) {
+        return typeof value === "object"
+            && value?.constructor?.name === "Future"
+            && kind in value;
+    }
+    static all(values) {
+        return new Future(Promise.all(values.map((value) => new Future(value))));
+    }
+}
+function future(value) {
+    return new Future(value);
+}
+
+exports.Future = Future;
+exports.future = future;

package/dist/either/future/create.d.ts

@@ -0,0 +1,25 @@
+import { type EitherLeft } from "../left";
+import { type EitherRight } from "../right";
+import { type EitherFutureSuccess } from "./success";
+import { type EitherFutureError } from "./error";
+import { type IsEqual } from "../../common/types/isEqual";
+import { type MaybePromise } from "../../common/types/maybePromise";
+import { type AnyValue } from "../../common";
+type Either = EitherRight | EitherLeft;
+type ComputeEitherFutureSuccessResult<GenericValue extends unknown> = IsEqual<never, Exclude<GenericValue, Either>> extends false ? EitherFutureSuccess<Exclude<GenericValue, Either>> : never;
+type ComputeEitherFutureErrorResult<GenericValue extends unknown> = GenericValue extends Promise<unknown> ? EitherFutureError : never;
+type ComputeFutureEitherResult<GenericValue extends unknown = unknown> = Extract<Awaited<GenericValue>, Either> | ComputeEitherFutureSuccessResult<Awaited<GenericValue>> | ComputeEitherFutureErrorResult<GenericValue>;
+export type FutureEitherAllResult<GenericArray extends readonly unknown[] | []> = Future<{
+    -readonly [Prop in keyof GenericArray]: Awaited<Future<GenericArray[Prop]>>;
+}>;
+declare const kind = "kind-future-either";
+export declare class Future<const GenericValue extends unknown = unknown> extends Promise<ComputeFutureEitherResult<GenericValue>> {
+    constructor(value: GenericValue);
+    [kind]: unknown;
+    then<const GenericOutput extends AnyValue>(theFunction: (result: Extract<ComputeFutureEitherResult<GenericValue>, any>) => MaybePromise<GenericOutput>): Future<GenericOutput>;
+    static get [Symbol.species](): PromiseConstructor;
+    static instanceof<GenericValue extends unknown>(value: GenericValue): value is Extract<GenericValue, Future<any>>;
+    static all<const GenericValue extends unknown, GenericArray extends readonly GenericValue[] | []>(values: GenericArray): FutureEitherAllResult<GenericArray>;
+}
+export declare function future<const GenericEither extends unknown>(value: GenericEither): Future<GenericEither>;
+export {};

package/dist/either/future/create.mjs

@@ -0,0 +1,46 @@
+import { isLeft } from '../left/is.mjs';
+import { futureSuccess } from './success.mjs';
+import { futureError } from './error.mjs';
+import { isRight } from '../right/is.mjs';
+
+const kind = "kind-future-either";
+class Future extends Promise {
+    constructor(value) {
+        super((resolve) => void resolve((value instanceof Promise
+            ? value
+            : Promise.resolve(value))
+            .then((value) => {
+            if (isRight(value)) {
+                return value;
+            }
+            else if (isLeft(value)) {
+                return value;
+            }
+            else {
+                return futureSuccess(value);
+            }
+        })
+            .catch((error) => futureError(error))));
+    }
+    [kind] = null;
+    // @ts-expect-error override signature error
+    then(theFunction) {
+        return new Future(super.then(theFunction));
+    }
+    static get [Symbol.species]() {
+        return Promise;
+    }
+    static instanceof(value) {
+        return typeof value === "object"
+            && value?.constructor?.name === "Future"
+            && kind in value;
+    }
+    static all(values) {
+        return new Future(Promise.all(values.map((value) => new Future(value))));
+    }
+}
+function future(value) {
+    return new Future(value);
+}
+
+export { Future, future };

package/dist/either/future/error.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var create = require('../left/create.cjs');
+var base = require('./base.cjs');
+
+const eitherFutureErrorKind = kind.createKind("either-future-error");
+function futureError(value) {
+    return base.eitherFutureKind.addTo(eitherFutureErrorKind.addTo(create.left("future", value)));
+}
+
+exports.eitherFutureErrorKind = eitherFutureErrorKind;
+exports.futureError = futureError;

package/dist/either/future/error.d.ts

@@ -0,0 +1,6 @@
+import { type Kind } from "../../common/kind";
+import { type EitherLeft } from "../left";
+import { eitherFutureKind } from "./base";
+export declare const eitherFutureErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"either-future-error", unknown>>;
+export type EitherFutureError = (EitherLeft<"future", unknown> & Kind<typeof eitherFutureKind.definition> & Kind<typeof eitherFutureErrorKind.definition>);
+export declare function futureError(value: unknown): EitherFutureError;

package/dist/either/future/error.mjs

@@ -0,0 +1,10 @@
+import { createKind } from '../../common/kind.mjs';
+import { left } from '../left/create.mjs';
+import { eitherFutureKind } from './base.mjs';
+
+const eitherFutureErrorKind = createKind("either-future-error");
+function futureError(value) {
+    return eitherFutureKind.addTo(eitherFutureErrorKind.addTo(left("future", value)));
+}
+
+export { eitherFutureErrorKind, futureError };

package/dist/either/future/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./create";
+export * from "./error";
+export * from "./success";
+export * from "./base";

package/dist/either/future/success.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var base = require('./base.cjs');
+var create = require('../right/create.cjs');
+
+const eitherFutureSuccessKind = kind.createKind("either-future-success");
+function futureSuccess(value) {
+    return base.eitherFutureKind.addTo(eitherFutureSuccessKind.addTo(create.right("future", value)));
+}
+
+exports.eitherFutureSuccessKind = eitherFutureSuccessKind;
+exports.futureSuccess = futureSuccess;

package/dist/either/future/success.d.ts

@@ -0,0 +1,6 @@
+import { type EitherRight } from "../right";
+import { type Kind } from "../../common/kind";
+import { eitherFutureKind } from "./base";
+export declare const eitherFutureSuccessKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"either-future-success", unknown>>;
+export type EitherFutureSuccess<GenericValue extends unknown = unknown> = (EitherRight<"future", GenericValue> & Kind<typeof eitherFutureKind.definition> & Kind<typeof eitherFutureSuccessKind.definition>);
+export declare function futureSuccess<const GenericValue extends unknown>(value: GenericValue): EitherFutureSuccess<GenericValue>;

package/dist/either/future/success.mjs

@@ -0,0 +1,10 @@
+import { createKind } from '../../common/kind.mjs';
+import { eitherFutureKind } from './base.mjs';
+import { right } from '../right/create.mjs';
+
+const eitherFutureSuccessKind = createKind("either-future-success");
+function futureSuccess(value) {
+    return eitherFutureKind.addTo(eitherFutureSuccessKind.addTo(right("future", value)));
+}
+
+export { eitherFutureSuccessKind, futureSuccess };

package/dist/either/hasInformation.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var base = require('./base.cjs');
+
+function hasInformation(input, information) {
+    return base.eitherInformationKind.has(input)
+        && base.eitherInformationKind.getValue(input) === information;
+}
+
+exports.hasInformation = hasInformation;

package/dist/either/hasInformation.d.ts

@@ -0,0 +1,7 @@
+import { type Kind } from "../common";
+import { type EitherLeft } from "./left";
+import { type EitherRight } from "./right";
+import { eitherInformationKind } from "./base";
+type Either = EitherRight | EitherLeft;
+export declare function hasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never)>(input: GenericInput, information: GenericInformation): input is Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
+export {};

package/dist/either/hasInformation.mjs

@@ -0,0 +1,8 @@
+import { eitherInformationKind } from './base.mjs';
+
+function hasInformation(input, information) {
+    return eitherInformationKind.has(input)
+        && eitherInformationKind.getValue(input) === information;
+}
+
+export { hasInformation };

package/dist/either/index.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+var create = require('./bool/create.cjs');
+var falsy = require('./bool/falsy.cjs');
+var truthy = require('./bool/truthy.cjs');
+var base = require('./bool/base.cjs');
+var create$1 = require('./future/create.cjs');
+var error = require('./future/error.cjs');
+var success = require('./future/success.cjs');
+var base$1 = require('./future/base.cjs');
+var create$2 = require('./left/create.cjs');
+var error$1 = require('./left/error.cjs');
+var fail = require('./left/fail.cjs');
+var is = require('./left/is.cjs');
+var when = require('./left/when.cjs');
+var create$3 = require('./nullable/create.cjs');
+var empty = require('./nullable/empty.cjs');
+var filled = require('./nullable/filled.cjs');
+var base$2 = require('./nullable/base.cjs');
+var create$4 = require('./nullish/create.cjs');
+var empty$1 = require('./nullish/empty.cjs');
+var filled$1 = require('./nullish/filled.cjs');
+var base$3 = require('./nullish/base.cjs');
+var create$5 = require('./optional/create.cjs');
+var empty$2 = require('./optional/empty.cjs');
+var filled$2 = require('./optional/filled.cjs');
+var base$4 = require('./optional/base.cjs');
+var asyncPipe = require('./right/asyncPipe.cjs');
+var create$6 = require('./right/create.cjs');
+var is$1 = require('./right/is.cjs');
+var ok = require('./right/ok.cjs');
+var pipe = require('./right/pipe.cjs');
+var success$1 = require('./right/success.cjs');
+var when$1 = require('./right/when.cjs');
+var hasInformation = require('./hasInformation.cjs');
+var whenHasInformation = require('./whenHasInformation.cjs');
+var base$5 = require('./base.cjs');
+
+
+
+exports.bool = create.bool;
+exports.boolFalsy = falsy.boolFalsy;
+exports.eitherBoolFalsyKind = falsy.eitherBoolFalsyKind;
+exports.isBoolFalsy = falsy.isBoolFalsy;
+exports.whenIsBoolFalsy = falsy.whenIsBoolFalsy;
+exports.boolTruthy = truthy.boolTruthy;
+exports.eitherBoolTruthyKind = truthy.eitherBoolTruthyKind;
+exports.isBoolTruthy = truthy.isBoolTruthy;
+exports.whenIsBoolTruthy = truthy.whenIsBoolTruthy;
+exports.eitherBoolKind = base.eitherBoolKind;
+exports.Future = create$1.Future;
+exports.future = create$1.future;
+exports.eitherFutureErrorKind = error.eitherFutureErrorKind;
+exports.futureError = error.futureError;
+exports.eitherFutureSuccessKind = success.eitherFutureSuccessKind;
+exports.futureSuccess = success.futureSuccess;
+exports.eitherFutureKind = base$1.eitherFutureKind;
+exports.eitherLeftKind = create$2.eitherLeftKind;
+exports.left = create$2.left;
+exports.eitherErrorKind = error$1.eitherErrorKind;
+exports.error = error$1.error;
+exports.eitherFailKind = fail.eitherFailKind;
+exports.fail = fail.fail;
+exports.isLeft = is.isLeft;
+exports.whenIsLeft = when.whenIsLeft;
+exports.nullable = create$3.nullable;
+exports.eitherNullableEmptyKind = empty.eitherNullableEmptyKind;
+exports.isNullableEmpty = empty.isNullableEmpty;
+exports.nullableEmpty = empty.nullableEmpty;
+exports.whenIsNullableEmpty = empty.whenIsNullableEmpty;
+exports.eitherNullableFilledKind = filled.eitherNullableFilledKind;
+exports.isNullableFilled = filled.isNullableFilled;
+exports.nullableFilled = filled.nullableFilled;
+exports.whenIsNullableFilled = filled.whenIsNullableFilled;
+exports.eitherNullableKind = base$2.eitherNullableKind;
+exports.nullish = create$4.nullish;
+exports.eitherNullishEmptyKind = empty$1.eitherNullishEmptyKind;
+exports.isNullishEmpty = empty$1.isNullishEmpty;
+exports.nullishEmpty = empty$1.nullishEmpty;
+exports.whenIsNullishEmpty = empty$1.whenIsNullishEmpty;
+exports.eitherNullishFilledKind = filled$1.eitherNullishFilledKind;
+exports.isNullishFilled = filled$1.isNullishFilled;
+exports.nullishFilled = filled$1.nullishFilled;
+exports.whenIsNullishFilled = filled$1.whenIsNullishFilled;
+exports.eitherNullishKind = base$3.eitherNullishKind;
+exports.optional = create$5.optional;
+exports.eitherOptionalEmptyKind = empty$2.eitherOptionalEmptyKind;
+exports.isOptionalEmpty = empty$2.isOptionalEmpty;
+exports.optionalEmpty = empty$2.optionalEmpty;
+exports.whenIsOptionalEmpty = empty$2.whenIsOptionalEmpty;
+exports.eitherOptionalFilledKind = filled$2.eitherOptionalFilledKind;
+exports.isOptionalFilled = filled$2.isOptionalFilled;
+exports.optionalFilled = filled$2.optionalFilled;
+exports.whenIsOptionalFilled = filled$2.whenIsOptionalFilled;
+exports.eitherOptionalKind = base$4.eitherOptionalKind;
+exports.rightAsyncPipe = asyncPipe.rightAsyncPipe;
+exports.eitherRightKind = create$6.eitherRightKind;
+exports.right = create$6.right;
+exports.isRight = is$1.isRight;
+exports.eitherOkKind = ok.eitherOkKind;
+exports.ok = ok.ok;
+exports.rightPipe = pipe.rightPipe;
+exports.eitherSuccessKind = success$1.eitherSuccessKind;
+exports.success = success$1.success;
+exports.whenIsRight = when$1.whenIsRight;
+exports.hasInformation = hasInformation.hasInformation;
+exports.whenHasInformation = whenHasInformation.whenHasInformation;
+exports.eitherInformationKind = base$5.eitherInformationKind;

package/dist/either/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./bool";
+export * from "./future";
+export * from "./left";
+export * from "./nullable";
+export * from "./nullish";
+export * from "./optional";
+export * from "./right";
+export * from "./hasInformation";
+export * from "./whenHasInformation";
+export * from "./base";