@duplojs/utils 1.4.44 → 1.4.46

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

@@ -1,5 +1,5 @@
-import { type EitherNullableEmpty } from "./empty";
-import { type EitherNullableFilled } from "./filled";
+import { type NullableEmpty } from "./empty";
+import { type NullableFilled } from "./filled";
 /**
  * Wraps a null or non-null value in an Either, while keeping the information on whether it is filled or empty.
  * 
@@ -10,7 +10,7 @@ import { type EitherNullableFilled } from "./filled";
  * ```ts
  * const result = E.nullable(true ? "value" : null);
  * 
- * // type: E.EitherNullableEmpty | E.EitherNullableFilled<"value">
+ * // type: E.NullableEmpty | E.NullableFilled<"value">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/nullable
@@ -18,5 +18,5 @@ import { type EitherNullableFilled } from "./filled";
  * @namespace E
  * 
  */
-export declare function nullable<const GenericValue extends unknown = null>(value: GenericValue): GenericValue extends null ? EitherNullableEmpty : EitherNullableFilled<GenericValue>;
-export type Nullable<GenericValue extends unknown> = EitherNullableFilled<GenericValue> | EitherNullableEmpty;
+export declare function nullable<const GenericValue extends unknown = null>(value: GenericValue): GenericValue extends null ? NullableEmpty : NullableFilled<GenericValue>;
+export type Nullable<GenericValue extends unknown> = NullableFilled<GenericValue> | NullableEmpty;

package/dist/either/nullable/empty.cjs

@@ -8,7 +8,11 @@ var is = require('../left/is.cjs');
 var is$1 = require('../right/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 
-const eitherNullableEmptyKind = kind.createEitherKind("nullable-empty");
+const nullableEmptyKind = kind.createEitherKind("nullable-empty");
+/**
+ * @deprecated use nullableEmptyKind
+ */
+const eitherNullableEmptyKind = nullableEmptyKind;
 /**
  * {@include either/isNullableEmpty/index.md}
  */
@@ -19,12 +23,12 @@ const eitherNullableEmptyKind = kind.createEitherKind("nullable-empty");
  * {@include either/whenIsNullableEmpty/index.md}
  */
 function nullableEmpty() {
-    return base.eitherNullableKind.setTo(eitherNullableEmptyKind.setTo(create.left("nullable", null)));
+    return base.nullableKind.setTo(nullableEmptyKind.setTo(create.left("nullable", null)));
 }
 function isNullableEmpty(input) {
     return is.isLeft(input)
-        && base.eitherNullableKind.has(input)
-        && eitherNullableEmptyKind.has(input);
+        && base.nullableKind.has(input)
+        && nullableEmptyKind.has(input);
 }
 function whenIsNullableEmpty(...args) {
     if (args.length === 1) {
@@ -50,4 +54,5 @@ function whenIsNullableEmpty(...args) {
 exports.eitherNullableEmptyKind = eitherNullableEmptyKind;
 exports.isNullableEmpty = isNullableEmpty;
 exports.nullableEmpty = nullableEmpty;
+exports.nullableEmptyKind = nullableEmptyKind;
 exports.whenIsNullableEmpty = whenIsNullableEmpty;

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

@@ -1,16 +1,24 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type Kind } from "../../common/kind";
-import { type EitherLeft } from "../left";
-import { type EitherRight } from "../right";
+import { type Left } from "../left";
+import { type Right } from "../right";
 import { nullable } from "./create";
-import { eitherNullableKind } from "./base";
+import { nullableKind } from "./base";
+export declare const nullableEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullable-empty", unknown>>;
+/**
+ * @deprecated use nullableEmptyKind
+ */
 export declare const eitherNullableEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullable-empty", unknown>>;
-type _EitherNullableEmpty = (EitherLeft<"nullable", null> & Kind<typeof eitherNullableKind.definition> & Kind<typeof eitherNullableEmptyKind.definition>);
-export interface EitherNullableEmpty extends _EitherNullableEmpty {
+type _NullableEmpty = (Left<"nullable", null> & Kind<typeof nullableKind.definition> & Kind<typeof nullableEmptyKind.definition>);
+export interface NullableEmpty extends _NullableEmpty {
 }
-type Either = EitherRight | EitherLeft;
 /**
- * Type guard that detects an EitherNullableEmpty.
+ * @deprecated use NullableEmpty
+ */
+export type EitherNullableEmpty = NullableEmpty;
+type Either = Right | Left;
+/**
+ * Type guard that detects an NullableEmpty.
  * 
  * Signature: `isNullableEmpty(input)` → returns a value
  * 
@@ -20,7 +28,7 @@ type Either = EitherRight | EitherLeft;
  * const maybeValue = E.nullable(true ? "value" : null);
  * 
  * if (E.isNullableEmpty(maybeValue)) {
- * 	// type: E.EitherNullableEmpty
+ * 	// type: E.NullableEmpty
  * }
  * ```
  * 
@@ -30,14 +38,14 @@ type Either = EitherRight | EitherLeft;
  * 
  */
 /**
- * Explicitly builds an EitherLeft<"nullable"> containing null.
+ * Explicitly builds an Left<"nullable"> containing null.
  * 
  * Signature: `nullableEmpty()` → returns a value
  * 
  * ```ts
  * const result = E.nullableEmpty();
  * 
- * // type: E.EitherNullableEmpty
+ * // type: E.NullableEmpty
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/nullableEmpty
@@ -60,7 +68,7 @@ type Either = EitherRight | EitherLeft;
  * 	E.whenIsNullableEmpty(() => "nullable"),
  * );
  * 
- * // type: "nullable" | E.EitherNullableFilled<"value">
+ * // type: "nullable" | E.NullableFilled<"value">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/whenIsNullableEmpty
@@ -68,9 +76,9 @@ type Either = EitherRight | EitherLeft;
  * @namespace E
  * 
  */
-export declare function nullableEmpty(): EitherNullableEmpty;
-export declare function isNullableEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullableEmpty>;
+export declare function nullableEmpty(): NullableEmpty;
+export declare function isNullableEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, NullableEmpty>;
 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<BreakGenericLink<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<BreakGenericLink<GenericInput>>, EitherNullableEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullableEmpty>;
+export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, NullableEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, NullableEmpty>;
+export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, NullableEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, NullableEmpty>;
 export {};

package/dist/either/nullable/empty.mjs

@@ -1,12 +1,16 @@
 import { nullable } from './create.mjs';
-import { eitherNullableKind } from './base.mjs';
+import { nullableKind } from './base.mjs';
 import { createEitherKind } from '../kind.mjs';
 import { left } from '../left/create.mjs';
 import { isLeft } from '../left/is.mjs';
 import { isRight } from '../right/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 
-const eitherNullableEmptyKind = createEitherKind("nullable-empty");
+const nullableEmptyKind = createEitherKind("nullable-empty");
+/**
+ * @deprecated use nullableEmptyKind
+ */
+const eitherNullableEmptyKind = nullableEmptyKind;
 /**
  * {@include either/isNullableEmpty/index.md}
  */
@@ -17,12 +21,12 @@ const eitherNullableEmptyKind = createEitherKind("nullable-empty");
  * {@include either/whenIsNullableEmpty/index.md}
  */
 function nullableEmpty() {
-    return eitherNullableKind.setTo(eitherNullableEmptyKind.setTo(left("nullable", null)));
+    return nullableKind.setTo(nullableEmptyKind.setTo(left("nullable", null)));
 }
 function isNullableEmpty(input) {
     return isLeft(input)
-        && eitherNullableKind.has(input)
-        && eitherNullableEmptyKind.has(input);
+        && nullableKind.has(input)
+        && nullableEmptyKind.has(input);
 }
 function whenIsNullableEmpty(...args) {
     if (args.length === 1) {
@@ -45,4 +49,4 @@ function whenIsNullableEmpty(...args) {
     return either;
 }
 
-export { eitherNullableEmptyKind, isNullableEmpty, nullableEmpty, whenIsNullableEmpty };
+export { eitherNullableEmptyKind, isNullableEmpty, nullableEmpty, nullableEmptyKind, whenIsNullableEmpty };

package/dist/either/nullable/filled.cjs

@@ -8,7 +8,11 @@ var is = require('../right/is.cjs');
 var is$1 = require('../left/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 
-const eitherNullableFilledKind = kind.createEitherKind("nullable-filled");
+const nullableFilledKind = kind.createEitherKind("nullable-filled");
+/**
+ * @deprecated use nullableFilledKind
+ */
+const eitherNullableFilledKind = nullableFilledKind;
 /**
  * {@include either/isNullableFilled/index.md}
  */
@@ -19,12 +23,12 @@ const eitherNullableFilledKind = kind.createEitherKind("nullable-filled");
  * {@include either/whenIsNullableFilled/index.md}
  */
 function nullableFilled(value) {
-    return base.eitherNullableKind.setTo(eitherNullableFilledKind.setTo(create.right("nullable", value)));
+    return base.nullableKind.setTo(nullableFilledKind.setTo(create.right("nullable", value)));
 }
 function isNullableFilled(input) {
     return is.isRight(input)
-        && base.eitherNullableKind.has(input)
-        && eitherNullableFilledKind.has(input);
+        && base.nullableKind.has(input)
+        && nullableFilledKind.has(input);
 }
 function whenIsNullableFilled(...args) {
     if (args.length === 1) {
@@ -50,4 +54,5 @@ function whenIsNullableFilled(...args) {
 exports.eitherNullableFilledKind = eitherNullableFilledKind;
 exports.isNullableFilled = isNullableFilled;
 exports.nullableFilled = nullableFilled;
+exports.nullableFilledKind = nullableFilledKind;
 exports.whenIsNullableFilled = whenIsNullableFilled;

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

@@ -1,14 +1,22 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type Kind } from "../../common/kind";
-import { type EitherLeft } from "../left";
-import { type EitherRight } from "../right";
+import { type Left } from "../left";
+import { type Right } from "../right";
 import { nullable } from "./create";
-import { eitherNullableKind } from "./base";
+import { nullableKind } from "./base";
+export declare const nullableFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullable-filled", unknown>>;
+/**
+ * @deprecated use nullableFilledKind
+ */
 export declare const eitherNullableFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/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 _NullableFilled<GenericValue extends unknown = unknown> = (Right<"nullable", GenericValue> & Kind<typeof nullableKind.definition> & Kind<typeof nullableFilledKind.definition>);
+export interface NullableFilled<GenericValue extends unknown = unknown> extends _NullableFilled<GenericValue> {
 }
-type Either = EitherRight | EitherLeft;
+/**
+ * @deprecated use NullableFilled
+ */
+export type EitherNullableFilled<GenericValue extends unknown = unknown> = NullableFilled<GenericValue>;
+type Either = Right | Left;
 /**
  * Type guard that checks that the nullable Either actually contains a value.
  * 
@@ -20,7 +28,7 @@ type Either = EitherRight | EitherLeft;
  * const maybeValue = E.nullable(true ? "value" : null);
  * 
  * if (E.isNullableFilled(maybeValue)) {
- * 	// type: E.EitherNullableFilled<"value">
+ * 	// type: E.NullableFilled<"value">
  * }
  * ```
  * 
@@ -30,7 +38,7 @@ type Either = EitherRight | EitherLeft;
  * 
  */
 /**
- * Builds an EitherRight<"nullable"> for a non-null value.
+ * Builds an Right<"nullable"> for a non-null value.
  * 
  * Signature: `nullableFilled(value)` → returns a value
  * 
@@ -39,7 +47,7 @@ type Either = EitherRight | EitherLeft;
  * ```ts
  * const result = E.nullableFilled("value");
  * 
- * // type: E.EitherNullableFilled<"value">
+ * // type: E.NullableFilled<"value">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/nullableFilled
@@ -62,7 +70,7 @@ type Either = EitherRight | EitherLeft;
  * 	E.whenIsNullableFilled(S.capitalize),
  * );
  * 
- * // type: E.EitherNullableEmpty | "Value"
+ * // type: E.NullableEmpty | "Value"
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/whenIsNullableFilled
@@ -70,9 +78,9 @@ type Either = EitherRight | EitherLeft;
  * @namespace E
  * 
  */
-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>;
+export declare function nullableFilled<const GenericValue extends unknown>(value: GenericValue): NullableFilled<GenericValue>;
+export declare function isNullableFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, NullableFilled>;
 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<BreakGenericLink<GenericInput>>, EitherNullableFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullableFilled>;
-export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullableFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableFilled>;
+export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, NullableFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, NullableFilled>;
+export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, NullableFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, NullableFilled>;
 export {};

package/dist/either/nullable/filled.mjs

@@ -1,12 +1,16 @@
 import { nullable } from './create.mjs';
-import { eitherNullableKind } from './base.mjs';
+import { nullableKind } from './base.mjs';
 import { createEitherKind } from '../kind.mjs';
 import { right } from '../right/create.mjs';
 import { isRight } from '../right/is.mjs';
 import { isLeft } from '../left/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 
-const eitherNullableFilledKind = createEitherKind("nullable-filled");
+const nullableFilledKind = createEitherKind("nullable-filled");
+/**
+ * @deprecated use nullableFilledKind
+ */
+const eitherNullableFilledKind = nullableFilledKind;
 /**
  * {@include either/isNullableFilled/index.md}
  */
@@ -17,12 +21,12 @@ const eitherNullableFilledKind = createEitherKind("nullable-filled");
  * {@include either/whenIsNullableFilled/index.md}
  */
 function nullableFilled(value) {
-    return eitherNullableKind.setTo(eitherNullableFilledKind.setTo(right("nullable", value)));
+    return nullableKind.setTo(nullableFilledKind.setTo(right("nullable", value)));
 }
 function isNullableFilled(input) {
     return isRight(input)
-        && eitherNullableKind.has(input)
-        && eitherNullableFilledKind.has(input);
+        && nullableKind.has(input)
+        && nullableFilledKind.has(input);
 }
 function whenIsNullableFilled(...args) {
     if (args.length === 1) {
@@ -45,4 +49,4 @@ function whenIsNullableFilled(...args) {
     return either;
 }
 
-export { eitherNullableFilledKind, isNullableFilled, nullableFilled, whenIsNullableFilled };
+export { eitherNullableFilledKind, isNullableFilled, nullableFilled, nullableFilledKind, whenIsNullableFilled };

package/dist/either/nullish/base.cjs

@@ -2,6 +2,11 @@
 
 var kind = require('../kind.cjs');
 
-const eitherNullishKind = kind.createEitherKind("nullish");
+const nullishKind = kind.createEitherKind("nullish");
+/**
+ * @deprecated use nullishKind
+ */
+const eitherNullishKind = nullishKind;
 
 exports.eitherNullishKind = eitherNullishKind;
+exports.nullishKind = nullishKind;

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

@@ -1 +1,5 @@
+export declare const nullishKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsEither/nullish", unknown>>;
+/**
+ * @deprecated use nullishKind
+ */
 export declare const eitherNullishKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsEither/nullish", unknown>>;

package/dist/either/nullish/base.mjs

@@ -1,5 +1,9 @@
 import { createEitherKind } from '../kind.mjs';
 
-const eitherNullishKind = createEitherKind("nullish");
+const nullishKind = createEitherKind("nullish");
+/**
+ * @deprecated use nullishKind
+ */
+const eitherNullishKind = nullishKind;
 
-export { eitherNullishKind };
+export { eitherNullishKind, nullishKind };

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

@@ -1,5 +1,5 @@
-import { type EitherNullishEmpty, type NullishValue } from "./empty";
-import { type EitherNullishFilled } from "./filled";
+import { type NullishEmpty, type NullishValue } from "./empty";
+import { type NullishFilled } from "./filled";
 /**
  * Transforms a potentially null/undefined value into an Either. Allows propagating presence/absence in a type-safe way.
  * 
@@ -12,7 +12,7 @@ import { type EitherNullishFilled } from "./filled";
  * 
  * const result = E.nullish(mayBeInput);
  * 
- * // type: E.EitherNullishEmpty<undefined> | E.EitherNullishFilled<true>
+ * // type: E.NullishEmpty<undefined> | E.NullishFilled<true>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/nullish
@@ -20,5 +20,5 @@ import { type EitherNullishFilled } from "./filled";
  * @namespace E
  * 
  */
-export declare function nullish<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends NullishValue ? EitherNullishEmpty<GenericValue> : EitherNullishFilled<GenericValue>;
-export type Nullish<GenericValue extends unknown> = EitherNullishFilled<GenericValue> | EitherNullishEmpty;
+export declare function nullish<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends NullishValue ? NullishEmpty<GenericValue> : NullishFilled<GenericValue>;
+export type Nullish<GenericValue extends unknown> = NullishFilled<GenericValue> | NullishEmpty;

package/dist/either/nullish/empty.cjs

@@ -8,7 +8,11 @@ var is = require('../left/is.cjs');
 var is$1 = require('../right/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 
-const eitherNullishEmptyKind = kind.createEitherKind("nullish-empty");
+const nullishEmptyKind = kind.createEitherKind("nullish-empty");
+/**
+ * @deprecated use nullishEmptyKind
+ */
+const eitherNullishEmptyKind = nullishEmptyKind;
 /**
  * {@include either/isNullishEmpty/index.md}
  */
@@ -19,12 +23,12 @@ const eitherNullishEmptyKind = kind.createEitherKind("nullish-empty");
  * {@include either/whenIsNullishEmpty/index.md}
  */
 function nullishEmpty(value = undefined) {
-    return base.eitherNullishKind.setTo(eitherNullishEmptyKind.setTo(create.left("nullish", value)));
+    return base.nullishKind.setTo(nullishEmptyKind.setTo(create.left("nullish", value)));
 }
 function isNullishEmpty(input) {
     return is.isLeft(input)
-        && base.eitherNullishKind.has(input)
-        && eitherNullishEmptyKind.has(input);
+        && base.nullishKind.has(input)
+        && nullishEmptyKind.has(input);
 }
 function whenIsNullishEmpty(...args) {
     if (args.length === 1) {
@@ -50,4 +54,5 @@ function whenIsNullishEmpty(...args) {
 exports.eitherNullishEmptyKind = eitherNullishEmptyKind;
 exports.isNullishEmpty = isNullishEmpty;
 exports.nullishEmpty = nullishEmpty;
+exports.nullishEmptyKind = nullishEmptyKind;
 exports.whenIsNullishEmpty = whenIsNullishEmpty;

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

@@ -1,16 +1,24 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type Kind } from "../../common/kind";
-import { type EitherLeft } from "../left";
-import { type EitherRight } from "../right";
+import { type Left } from "../left";
+import { type Right } from "../right";
 import { nullish } from "./create";
-import { eitherNullishKind } from "./base";
+import { nullishKind } from "./base";
 export type NullishValue = null | undefined;
+export declare const nullishEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullish-empty", unknown>>;
+/**
+ * @deprecated use nullishEmptyKind
+ */
 export declare const eitherNullishEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullish-empty", unknown>>;
-type _EitherNullishEmpty<GenericValue extends NullishValue = NullishValue> = (EitherLeft<"nullish", GenericValue> & Kind<typeof eitherNullishKind.definition> & Kind<typeof eitherNullishEmptyKind.definition>);
-export interface EitherNullishEmpty<GenericValue extends NullishValue = NullishValue> extends _EitherNullishEmpty<GenericValue> {
+type _NullishEmpty<GenericValue extends NullishValue = NullishValue> = (Left<"nullish", GenericValue> & Kind<typeof nullishKind.definition> & Kind<typeof nullishEmptyKind.definition>);
+export interface NullishEmpty<GenericValue extends NullishValue = NullishValue> extends _NullishEmpty<GenericValue> {
 }
 /**
- * Type guard detecting an EitherNullishEmpty.
+ * @deprecated use NullishEmpty
+ */
+export type EitherNullishEmpty<GenericValue extends NullishValue = NullishValue> = NullishEmpty<GenericValue>;
+/**
+ * Type guard detecting an NullishEmpty.
  * 
  * Signature: `isNullishEmpty(input)` → returns a value
  * 
@@ -20,7 +28,7 @@ export interface EitherNullishEmpty<GenericValue extends NullishValue = NullishV
  * const maybeValue = E.nullish(true ? "value" : null);
  * 
  * if (E.isNullishEmpty(maybeValue)) {
- * 	// type: E.EitherNullishEmpty<null>
+ * 	// type: E.NullishEmpty<null>
  * }
  * ```
  * 
@@ -30,7 +38,7 @@ export interface EitherNullishEmpty<GenericValue extends NullishValue = NullishV
  * 
  */
 /**
- * Explicitly builds an EitherLeft<"nullish"> with null or undefined.
+ * Explicitly builds an Left<"nullish"> with null or undefined.
  * 
  * Signature: `nullishEmpty(value)` → returns a value
  * 
@@ -39,7 +47,7 @@ export interface EitherNullishEmpty<GenericValue extends NullishValue = NullishV
  * ```ts
  * const result = E.nullishEmpty();
  * 
- * // type: E.EitherNullishEmpty<undefined>
+ * // type: E.NullishEmpty<undefined>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/nullishEmpty
@@ -62,7 +70,7 @@ export interface EitherNullishEmpty<GenericValue extends NullishValue = NullishV
  * 	E.whenIsNullishEmpty(() => "nullish"),
  * );
  * 
- * // type: "nullish" | E.EitherNullishFilled<"value">
+ * // type: "nullish" | E.NullishFilled<"value">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/whenIsNullishEmpty
@@ -70,10 +78,10 @@ export interface EitherNullishEmpty<GenericValue extends NullishValue = NullishV
  * @namespace E
  * 
  */
-export declare function nullishEmpty<const GenericValue extends NullishValue = undefined>(value?: GenericValue): EitherNullishEmpty<GenericValue>;
-type Either = EitherRight | EitherLeft;
-export declare function isNullishEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullishEmpty>;
+export declare function nullishEmpty<const GenericValue extends NullishValue = undefined>(value?: GenericValue): NullishEmpty<GenericValue>;
+type Either = Right | Left;
+export declare function isNullishEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, NullishEmpty>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullish<GenericValue>>;
-export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullishEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullishEmpty>;
-export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullishEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishEmpty>;
+export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, NullishEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, NullishEmpty>;
+export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, NullishEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, NullishEmpty>;
 export {};

package/dist/either/nullish/empty.mjs

@@ -1,12 +1,16 @@
 import { createEitherKind } from '../kind.mjs';
 import { nullish } from './create.mjs';
-import { eitherNullishKind } from './base.mjs';
+import { nullishKind } from './base.mjs';
 import { left } from '../left/create.mjs';
 import { isLeft } from '../left/is.mjs';
 import { isRight } from '../right/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 
-const eitherNullishEmptyKind = createEitherKind("nullish-empty");
+const nullishEmptyKind = createEitherKind("nullish-empty");
+/**
+ * @deprecated use nullishEmptyKind
+ */
+const eitherNullishEmptyKind = nullishEmptyKind;
 /**
  * {@include either/isNullishEmpty/index.md}
  */
@@ -17,12 +21,12 @@ const eitherNullishEmptyKind = createEitherKind("nullish-empty");
  * {@include either/whenIsNullishEmpty/index.md}
  */
 function nullishEmpty(value = undefined) {
-    return eitherNullishKind.setTo(eitherNullishEmptyKind.setTo(left("nullish", value)));
+    return nullishKind.setTo(nullishEmptyKind.setTo(left("nullish", value)));
 }
 function isNullishEmpty(input) {
     return isLeft(input)
-        && eitherNullishKind.has(input)
-        && eitherNullishEmptyKind.has(input);
+        && nullishKind.has(input)
+        && nullishEmptyKind.has(input);
 }
 function whenIsNullishEmpty(...args) {
     if (args.length === 1) {
@@ -45,4 +49,4 @@ function whenIsNullishEmpty(...args) {
     return either;
 }
 
-export { eitherNullishEmptyKind, isNullishEmpty, nullishEmpty, whenIsNullishEmpty };
+export { eitherNullishEmptyKind, isNullishEmpty, nullishEmpty, nullishEmptyKind, whenIsNullishEmpty };

package/dist/either/nullish/filled.cjs

@@ -8,7 +8,11 @@ var is = require('../right/is.cjs');
 var is$1 = require('../left/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 
-const eitherNullishFilledKind = kind.createEitherKind("nullish-filled");
+const nullishFilledKind = kind.createEitherKind("nullish-filled");
+/**
+ * @deprecated use nullishFilledKind
+ */
+const eitherNullishFilledKind = nullishFilledKind;
 /**
  * {@include either/isNullishFilled/index.md}
  */
@@ -19,12 +23,12 @@ const eitherNullishFilledKind = kind.createEitherKind("nullish-filled");
  * {@include either/whenIsNullishFilled/index.md}
  */
 function nullishFilled(value) {
-    return base.eitherNullishKind.setTo(eitherNullishFilledKind.setTo(create.right("nullish", value)));
+    return base.nullishKind.setTo(nullishFilledKind.setTo(create.right("nullish", value)));
 }
 function isNullishFilled(input) {
     return is.isRight(input)
-        && base.eitherNullishKind.has(input)
-        && base.eitherNullishKind.has(input);
+        && base.nullishKind.has(input)
+        && nullishFilledKind.has(input);
 }
 function whenIsNullishFilled(...args) {
     if (args.length === 1) {
@@ -50,4 +54,5 @@ function whenIsNullishFilled(...args) {
 exports.eitherNullishFilledKind = eitherNullishFilledKind;
 exports.isNullishFilled = isNullishFilled;
 exports.nullishFilled = nullishFilled;
+exports.nullishFilledKind = nullishFilledKind;
 exports.whenIsNullishFilled = whenIsNullishFilled;