@duplojs/utils 0.3.1 → 1.0.1

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";

package/dist/either/index.mjs

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

package/dist/either/left/create.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var wrapValue = require('../../common/wrapValue.cjs');
+var base = require('../base.cjs');
+
+const eitherLeftKind = kind.createKind("either-left");
+function left(information, value = undefined) {
+    return eitherLeftKind.addTo(base.eitherInformationKind.addTo(wrapValue.wrapValue(value), information));
+}
+
+exports.eitherLeftKind = eitherLeftKind;
+exports.left = left;

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

@@ -0,0 +1,9 @@
+import { type Kind } from "../../common/kind";
+import { type WrappedValue } from "../../common/wrapValue";
+import { eitherInformationKind } from "../base";
+export declare const eitherLeftKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"either-left", unknown>>;
+type _EitherLeft<GenericInformation extends string = string, GenericValue extends unknown = unknown> = (Kind<typeof eitherLeftKind.definition> & Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue<GenericValue>);
+export interface EitherLeft<GenericInformation extends string = string, GenericValue extends unknown = unknown> extends _EitherLeft<GenericInformation, GenericValue> {
+}
+export declare function left<GenericInformation extends string, const GenericValue extends unknown = undefined>(information: GenericInformation, value?: GenericValue): EitherLeft<GenericInformation, GenericValue>;
+export {};

package/dist/either/left/create.mjs

@@ -0,0 +1,10 @@
+import { createKind } from '../../common/kind.mjs';
+import { wrapValue } from '../../common/wrapValue.mjs';
+import { eitherInformationKind } from '../base.mjs';
+
+const eitherLeftKind = createKind("either-left");
+function left(information, value = undefined) {
+    return eitherLeftKind.addTo(eitherInformationKind.addTo(wrapValue(value), information));
+}
+
+export { eitherLeftKind, left };

package/dist/either/left/error.cjs

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

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

@@ -0,0 +1,8 @@
+import { type Kind } from "../../common/kind";
+import { type EitherLeft } from "./create";
+export declare const eitherErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"either-error", unknown>>;
+type _EitherError<GenericValue extends unknown = unknown> = (EitherLeft<"error", GenericValue> & Kind<typeof eitherErrorKind.definition>);
+export interface EitherError<GenericValue extends unknown = unknown> extends _EitherError<GenericValue> {
+}
+export declare function error<const GenericValue extends unknown>(value: GenericValue): EitherError<GenericValue>;
+export {};

package/dist/either/left/error.mjs

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

package/dist/either/left/fail.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var create = require('./create.cjs');
+
+const eitherFailKind = kind.createKind("either-fail");
+function fail() {
+    return eitherFailKind.addTo(create.left("fail", undefined));
+}
+
+exports.eitherFailKind = eitherFailKind;
+exports.fail = fail;

package/dist/either/left/fail.d.ts

@@ -0,0 +1,8 @@
+import { type Kind } from "../../common/kind";
+import { type EitherLeft } from "./create";
+export declare const eitherFailKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"either-fail", unknown>>;
+type _EitherFail = (EitherLeft<"fail", never> & Kind<typeof eitherFailKind.definition>);
+export interface EitherFail extends _EitherFail {
+}
+export declare function fail(): EitherFail;
+export {};

package/dist/either/left/fail.mjs

@@ -0,0 +1,9 @@
+import { createKind } from '../../common/kind.mjs';
+import { left } from './create.mjs';
+
+const eitherFailKind = createKind("either-fail");
+function fail() {
+    return eitherFailKind.addTo(left("fail", undefined));
+}
+
+export { eitherFailKind, fail };

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

@@ -0,0 +1,5 @@
+export * from "./create";
+export * from "./error";
+export * from "./fail";
+export * from "./is";
+export * from "./when";

package/dist/either/left/is.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var create = require('./create.cjs');
+var wrapValue = require('../../common/wrapValue.cjs');
+var base = require('../base.cjs');
+
+function isLeft(input) {
+    return create.eitherLeftKind.has(input)
+        && base.eitherInformationKind.has(input)
+        && wrapValue.isWrappedValue(input);
+}
+
+exports.isLeft = isLeft;

package/dist/either/left/is.d.ts

@@ -0,0 +1,2 @@
+import { type EitherLeft } from "./create";
+export declare function isLeft<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherLeft>;

package/dist/either/left/is.mjs

@@ -0,0 +1,11 @@
+import { eitherLeftKind } from './create.mjs';
+import { isWrappedValue } from '../../common/wrapValue.mjs';
+import { eitherInformationKind } from '../base.mjs';
+
+function isLeft(input) {
+    return eitherLeftKind.has(input)
+        && eitherInformationKind.has(input)
+        && isWrappedValue(input);
+}
+
+export { isLeft };

package/dist/either/left/when.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var unwrap = require('../../common/unwrap.cjs');
+var is = require('./is.cjs');
+
+function whenIsLeft(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsLeft(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is.isLeft(input)) {
+        return theFunction(unwrap.unwrap(input));
+    }
+    return input;
+}
+
+exports.whenIsLeft = whenIsLeft;

package/dist/either/left/when.d.ts

@@ -0,0 +1,4 @@
+import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EitherLeft } from "./create";
+export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<GenericInput, EitherLeft>>) => GenericOutput): (input: GenericInput) => Exclude<GenericInput, EitherLeft> | GenericOutput;
+export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<GenericInput, EitherLeft>>) => GenericOutput): Exclude<GenericInput, EitherLeft> | GenericOutput;

package/dist/either/left/when.mjs

@@ -0,0 +1,16 @@
+import { unwrap } from '../../common/unwrap.mjs';
+import { isLeft } from './is.mjs';
+
+function whenIsLeft(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsLeft(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isLeft(input)) {
+        return theFunction(unwrap(input));
+    }
+    return input;
+}
+
+export { whenIsLeft };

package/dist/either/nullable/base.cjs

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

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

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

package/dist/either/nullable/base.mjs

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

package/dist/either/nullable/create.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var empty = require('./empty.cjs');
+var filled = require('./filled.cjs');
+
+function nullable(value) {
+    return value === null
+        ? empty.nullableEmpty()
+        : filled.nullableFilled(value);
+}
+
+exports.nullable = nullable;

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

@@ -0,0 +1,3 @@
+import { type EitherNullableEmpty } from "./empty";
+import { type EitherNullableFilled } from "./filled";
+export declare function nullable<const GenericValue extends unknown = null>(value: GenericValue): GenericValue extends null ? EitherNullableEmpty : EitherNullableFilled<GenericValue>;

package/dist/either/nullable/create.mjs

@@ -0,0 +1,10 @@
+import { nullableEmpty } from './empty.mjs';
+import { nullableFilled } from './filled.mjs';
+
+function nullable(value) {
+    return value === null
+        ? nullableEmpty()
+        : nullableFilled(value);
+}
+
+export { nullable };

package/dist/either/nullable/empty.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 eitherNullableEmptyKind = kind.createKind("either-nullable-empty");
+function nullableEmpty() {
+    return base.eitherNullableKind.addTo(eitherNullableEmptyKind.addTo(create.left("nullable", null)));
+}
+function isNullableEmpty(input) {
+    return is.isLeft(input)
+        && base.eitherNullableKind.has(input)
+        && eitherNullableEmptyKind.has(input);
+}
+function whenIsNullableEmpty(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsNullableEmpty(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is$1.isRight(input)) {
+        return input;
+    }
+    else if (!isNullableEmpty(input) && is.isLeft(input)) {
+        return input;
+    }
+    const either = is$1.isRight(input) || is.isLeft(input)
+        ? input
+        : create$1.nullable(input);
+    if (isNullableEmpty(either)) {
+        return theFunction(unwrap.unwrap(either));
+    }
+    return either;
+}
+
+exports.eitherNullableEmptyKind = eitherNullableEmptyKind;
+exports.isNullableEmpty = isNullableEmpty;
+exports.nullableEmpty = nullableEmpty;
+exports.whenIsNullableEmpty = whenIsNullableEmpty;

package/dist/either/nullable/empty.d.ts

@@ -0,0 +1,17 @@
+import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type Kind } from "../../common/kind";
+import { type EitherLeft } from "../left";
+import { type EitherRight } from "../right";
+import { nullable } from "./create";
+import { eitherNullableKind } from "./base";
+export declare const eitherNullableEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-nullable-empty", unknown>>;
+type _EitherNullableEmpty = (EitherLeft<"nullable", null> & Kind<typeof eitherNullableKind.definition> & Kind<typeof eitherNullableEmptyKind.definition>);
+export interface EitherNullableEmpty extends _EitherNullableEmpty {
+}
+type Either = EitherRight | EitherLeft;
+export declare function nullableEmpty(): EitherNullableEmpty;
+export declare function isNullableEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullableEmpty>;
+type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullable<GenericValue>>;
+export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableEmpty>;
+export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableEmpty>;
+export {};

package/dist/either/nullable/empty.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 { nullable } from './create.mjs';
+import { eitherNullableKind } from './base.mjs';
+
+const eitherNullableEmptyKind = createKind("either-nullable-empty");
+function nullableEmpty() {
+    return eitherNullableKind.addTo(eitherNullableEmptyKind.addTo(left("nullable", null)));
+}
+function isNullableEmpty(input) {
+    return isLeft(input)
+        && eitherNullableKind.has(input)
+        && eitherNullableEmptyKind.has(input);
+}
+function whenIsNullableEmpty(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsNullableEmpty(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isRight(input)) {
+        return input;
+    }
+    else if (!isNullableEmpty(input) && isLeft(input)) {
+        return input;
+    }
+    const either = isRight(input) || isLeft(input)
+        ? input
+        : nullable(input);
+    if (isNullableEmpty(either)) {
+        return theFunction(unwrap(either));
+    }
+    return either;
+}
+
+export { eitherNullableEmptyKind, isNullableEmpty, nullableEmpty, whenIsNullableEmpty };

package/dist/either/nullable/filled.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 eitherNullableFilledKind = kind.createKind("either-nullable-filled");
+function nullableFilled(value) {
+    return base.eitherNullableKind.addTo(eitherNullableFilledKind.addTo(create.right("nullable", value)));
+}
+function isNullableFilled(input) {
+    return is.isRight(input)
+        && base.eitherNullableKind.has(input)
+        && eitherNullableFilledKind.has(input);
+}
+function whenIsNullableFilled(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsNullableFilled(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is$1.isLeft(input)) {
+        return input;
+    }
+    else if (!isNullableFilled(input) && is.isRight(input)) {
+        return input;
+    }
+    const either = is.isRight(input) || is$1.isLeft(input)
+        ? input
+        : create$1.nullable(input);
+    if (isNullableFilled(either)) {
+        return theFunction(unwrap.unwrap(either));
+    }
+    return either;
+}
+
+exports.eitherNullableFilledKind = eitherNullableFilledKind;
+exports.isNullableFilled = isNullableFilled;
+exports.nullableFilled = nullableFilled;
+exports.whenIsNullableFilled = whenIsNullableFilled;

package/dist/either/nullable/filled.d.ts

@@ -0,0 +1,17 @@
+import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type Kind } from "../../common/kind";
+import { type EitherLeft } from "../left";
+import { type EitherRight } from "../right";
+import { nullable } from "./create";
+import { eitherNullableKind } from "./base";
+export declare const eitherNullableFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-nullable-filled", unknown>>;
+type _EitherNullableFilled<GenericValue extends unknown = unknown> = (EitherRight<"nullable", GenericValue> & Kind<typeof eitherNullableKind.definition> & Kind<typeof eitherNullableFilledKind.definition>);
+export interface EitherNullableFilled<GenericValue extends unknown = unknown> extends _EitherNullableFilled<GenericValue> {
+}
+type Either = EitherRight | EitherLeft;
+export declare function nullableFilled<const GenericValue extends unknown>(value: GenericValue): EitherNullableFilled<GenericValue>;
+export declare function isNullableFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullableFilled>;
+type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullable<GenericValue>>;
+export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableFilled>;
+export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableFilled>;
+export {};

package/dist/either/nullable/filled.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 { nullable } from './create.mjs';
+import { eitherNullableKind } from './base.mjs';
+
+const eitherNullableFilledKind = createKind("either-nullable-filled");
+function nullableFilled(value) {
+    return eitherNullableKind.addTo(eitherNullableFilledKind.addTo(right("nullable", value)));
+}
+function isNullableFilled(input) {
+    return isRight(input)
+        && eitherNullableKind.has(input)
+        && eitherNullableFilledKind.has(input);
+}
+function whenIsNullableFilled(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsNullableFilled(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isLeft(input)) {
+        return input;
+    }
+    else if (!isNullableFilled(input) && isRight(input)) {
+        return input;
+    }
+    const either = isRight(input) || isLeft(input)
+        ? input
+        : nullable(input);
+    if (isNullableFilled(either)) {
+        return theFunction(unwrap(either));
+    }
+    return either;
+}
+
+export { eitherNullableFilledKind, isNullableFilled, nullableFilled, whenIsNullableFilled };

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

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

package/dist/either/nullish/base.cjs

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

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

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

package/dist/either/nullish/base.mjs

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

package/dist/either/nullish/create.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var empty = require('./empty.cjs');
+var filled = require('./filled.cjs');
+
+function nullish(value) {
+    return value === null || value === undefined
+        ? empty.nullishEmpty(value)
+        : filled.nullishFilled(value);
+}
+
+exports.nullish = nullish;