@duplojs/utils 1.0.6 → 1.1.7

package/dist/either/left/create.cjs

@@ -6,7 +6,7 @@ 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));
+    return eitherLeftKind.setTo(base.eitherInformationKind.setTo(wrapValue.wrapValue(value), information));
 }
 
 exports.eitherLeftKind = eitherLeftKind;

package/dist/either/left/create.mjs

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

package/dist/either/left/error.cjs

@@ -5,7 +5,7 @@ var create = require('./create.cjs');
 
 const eitherErrorKind = kind.createKind("either-error");
 function error(value) {
-    return eitherErrorKind.addTo(create.left("error", value));
+    return eitherErrorKind.setTo(create.left("error", value));
 }
 
 exports.eitherErrorKind = eitherErrorKind;

package/dist/either/left/error.mjs

@@ -3,7 +3,7 @@ import { left } from './create.mjs';
 
 const eitherErrorKind = createKind("either-error");
 function error(value) {
-    return eitherErrorKind.addTo(left("error", value));
+    return eitherErrorKind.setTo(left("error", value));
 }
 
 export { eitherErrorKind, error };

package/dist/either/left/fail.cjs

@@ -5,7 +5,7 @@ var create = require('./create.cjs');
 
 const eitherFailKind = kind.createKind("either-fail");
 function fail() {
-    return eitherFailKind.addTo(create.left("fail", undefined));
+    return eitherFailKind.setTo(create.left("fail", undefined));
 }
 
 exports.eitherFailKind = eitherFailKind;

package/dist/either/left/fail.mjs

@@ -3,7 +3,7 @@ import { left } from './create.mjs';
 
 const eitherFailKind = createKind("either-fail");
 function fail() {
-    return eitherFailKind.addTo(left("fail", undefined));
+    return eitherFailKind.setTo(left("fail", undefined));
 }
 
 export { eitherFailKind, fail };

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

@@ -1,4 +1,4 @@
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } 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>(theFunction: (eitherValue: Unwrap<Extract<GenericInput, EitherLeft>>) => GenericOutput): (input: GenericInput) => Exclude<BreakGenericLink<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/nullable/empty.cjs

@@ -10,7 +10,7 @@ var base = require('./base.cjs');
 
 const eitherNullableEmptyKind = kind.createKind("either-nullable-empty");
 function nullableEmpty() {
-    return base.eitherNullableKind.addTo(eitherNullableEmptyKind.addTo(create.left("nullable", null)));
+    return base.eitherNullableKind.setTo(eitherNullableEmptyKind.setTo(create.left("nullable", null)));
 }
 function isNullableEmpty(input) {
     return is.isLeft(input)

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

@@ -1,4 +1,4 @@
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+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";
@@ -13,5 +13,5 @@ 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 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<BreakGenericLink<GenericInput>>, EitherNullableEmpty>;
 export {};

package/dist/either/nullable/empty.mjs

@@ -8,7 +8,7 @@ import { eitherNullableKind } from './base.mjs';
 
 const eitherNullableEmptyKind = createKind("either-nullable-empty");
 function nullableEmpty() {
-    return eitherNullableKind.addTo(eitherNullableEmptyKind.addTo(left("nullable", null)));
+    return eitherNullableKind.setTo(eitherNullableEmptyKind.setTo(left("nullable", null)));
 }
 function isNullableEmpty(input) {
     return isLeft(input)

package/dist/either/nullable/filled.cjs

@@ -10,7 +10,7 @@ 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)));
+    return base.eitherNullableKind.setTo(eitherNullableFilledKind.setTo(create.right("nullable", value)));
 }
 function isNullableFilled(input) {
     return is.isRight(input)

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

@@ -1,4 +1,4 @@
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+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";
@@ -12,6 +12,6 @@ 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>(theFunction: (eitherValue: Unwrap<Extract<ToEither<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<GenericInput>, EitherNullableFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableFilled>;
 export {};

package/dist/either/nullable/filled.mjs

@@ -8,7 +8,7 @@ import { eitherNullableKind } from './base.mjs';
 
 const eitherNullableFilledKind = createKind("either-nullable-filled");
 function nullableFilled(value) {
-    return eitherNullableKind.addTo(eitherNullableFilledKind.addTo(right("nullable", value)));
+    return eitherNullableKind.setTo(eitherNullableFilledKind.setTo(right("nullable", value)));
 }
 function isNullableFilled(input) {
     return isRight(input)

package/dist/either/nullish/empty.cjs

@@ -10,7 +10,7 @@ var base = require('./base.cjs');
 
 const eitherNullishEmptyKind = kind.createKind("either-nullish-empty");
 function nullishEmpty(value = undefined) {
-    return base.eitherNullishKind.addTo(eitherNullishEmptyKind.addTo(create.left("nullish", value)));
+    return base.eitherNullishKind.setTo(eitherNullishEmptyKind.setTo(create.left("nullish", value)));
 }
 function isNullishEmpty(input) {
     return is.isLeft(input)

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

@@ -1,4 +1,4 @@
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
 import { nullish } from "./create";
@@ -13,6 +13,6 @@ export declare function nullishEmpty<const GenericValue extends NullishValue = u
 type Either = EitherRight | EitherLeft;
 export declare function isNullishEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullishEmpty>;
 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<GenericInput>, EitherNullishEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishEmpty>;
+export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<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<GenericInput>, EitherNullishEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishEmpty>;
 export {};

package/dist/either/nullish/empty.mjs

@@ -8,7 +8,7 @@ import { eitherNullishKind } from './base.mjs';
 
 const eitherNullishEmptyKind = createKind("either-nullish-empty");
 function nullishEmpty(value = undefined) {
-    return eitherNullishKind.addTo(eitherNullishEmptyKind.addTo(left("nullish", value)));
+    return eitherNullishKind.setTo(eitherNullishEmptyKind.setTo(left("nullish", value)));
 }
 function isNullishEmpty(input) {
     return isLeft(input)

package/dist/either/nullish/filled.cjs

@@ -10,7 +10,7 @@ var base = require('./base.cjs');
 
 const eitherNullishFilledKind = kind.createKind("either-nullish-filled");
 function nullishFilled(value) {
-    return base.eitherNullishKind.addTo(eitherNullishFilledKind.addTo(create.right("nullish", value)));
+    return base.eitherNullishKind.setTo(eitherNullishFilledKind.setTo(create.right("nullish", value)));
 }
 function isNullishFilled(input) {
     return is.isRight(input)

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

@@ -2,7 +2,7 @@ import { type EitherRight } from "../right";
 import { type EitherLeft } from "../left";
 import { nullish } from "./create";
 import { type Kind } from "../../common/kind";
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { eitherNullishKind } from "./base";
 export declare const eitherNullishFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-nullish-filled", unknown>>;
 type _EitherNullishFilled<GenericValue extends unknown = unknown> = (EitherRight<"nullish", GenericValue> & Kind<typeof eitherNullishKind.definition> & Kind<typeof eitherNullishFilledKind.definition>);
@@ -12,6 +12,6 @@ export declare function nullishFilled<const GenericValue extends unknown>(value:
 type Either = EitherRight | EitherLeft;
 export declare function isNullishFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullishFilled>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullish<GenericValue>>;
-export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishFilled>;
+export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullishFilled>;
 export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishFilled>;
 export {};

package/dist/either/nullish/filled.mjs

@@ -8,7 +8,7 @@ import { eitherNullishKind } from './base.mjs';
 
 const eitherNullishFilledKind = createKind("either-nullish-filled");
 function nullishFilled(value) {
-    return eitherNullishKind.addTo(eitherNullishFilledKind.addTo(right("nullish", value)));
+    return eitherNullishKind.setTo(eitherNullishFilledKind.setTo(right("nullish", value)));
 }
 function isNullishFilled(input) {
     return isRight(input)

package/dist/either/optional/empty.cjs

@@ -9,7 +9,7 @@ var base = require('./base.cjs');
 
 const eitherOptionalEmptyKind = kind.createKind("either-optional-empty");
 function optionalEmpty() {
-    return base.eitherOptionalKind.addTo(eitherOptionalEmptyKind.addTo(create.left("optional", undefined)));
+    return base.eitherOptionalKind.setTo(eitherOptionalEmptyKind.setTo(create.left("optional", undefined)));
 }
 function isOptionalEmpty(input) {
     return is.isLeft(input)

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

@@ -1,4 +1,4 @@
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+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";
@@ -12,6 +12,6 @@ type Either = EitherRight | EitherLeft;
 export declare function optionalEmpty(): EitherOptionalEmpty;
 export declare function isOptionalEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherOptionalEmpty>;
 type ToOptionalEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof optional<GenericValue>>;
-export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalEmpty>;
+export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalEmpty>;
 export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalEmpty>>) => GenericOutput): GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalEmpty>;
 export {};

package/dist/either/optional/empty.mjs

@@ -7,7 +7,7 @@ import { eitherOptionalKind } from './base.mjs';
 
 const eitherOptionalEmptyKind = createKind("either-optional-empty");
 function optionalEmpty() {
-    return eitherOptionalKind.addTo(eitherOptionalEmptyKind.addTo(left("optional", undefined)));
+    return eitherOptionalKind.setTo(eitherOptionalEmptyKind.setTo(left("optional", undefined)));
 }
 function isOptionalEmpty(input) {
     return isLeft(input)

package/dist/either/optional/filled.cjs

@@ -10,7 +10,7 @@ var base = require('./base.cjs');
 
 const eitherOptionalFilledKind = kind.createKind("either-optional-filled");
 function optionalFilled(value) {
-    return base.eitherOptionalKind.addTo(eitherOptionalFilledKind.addTo(create.right("optional", value)));
+    return base.eitherOptionalKind.setTo(eitherOptionalFilledKind.setTo(create.right("optional", value)));
 }
 function isOptionalFilled(input) {
     return is.isRight(input)

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

@@ -1,4 +1,4 @@
-import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+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";
@@ -12,6 +12,6 @@ type Either = EitherRight | EitherLeft;
 export declare function optionalFilled<const GenericValue extends unknown>(value: GenericValue): EitherOptionalFilled<GenericValue>;
 export declare function isOptionalFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherOptionalFilled>;
 type ToOptionalEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof optional<GenericValue>>;
-export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalFilled>;
+export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalFilled>;
 export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalFilled>>) => GenericOutput): GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalFilled>;
 export {};

package/dist/either/optional/filled.mjs

@@ -8,7 +8,7 @@ import { eitherOptionalKind } from './base.mjs';
 
 const eitherOptionalFilledKind = createKind("either-optional-filled");
 function optionalFilled(value) {
-    return eitherOptionalKind.addTo(eitherOptionalFilledKind.addTo(right("optional", value)));
+    return eitherOptionalKind.setTo(eitherOptionalFilledKind.setTo(right("optional", value)));
 }
 function isOptionalFilled(input) {
     return isRight(input)

package/dist/either/right/asyncPipe.d.ts

@@ -5,8 +5,8 @@ import { type Future } from "../future";
 import { type EitherSuccess } from "./success";
 import { type AnyValue, type Unwrap } from "../../common";
 type Either = EitherRight | EitherLeft;
-export type EitherRightAsyncPipeFunction<GenericInput extends AnyValue = AnyValue, GenericOutput extends MaybeFutureEither<AnyValue> = MaybeFutureEither<AnyValue>> = (input: Awaited<GenericInput> extends infer InferredInput extends Either ? Unwrap<Exclude<Awaited<InferredInput>, EitherLeft>> : Exclude<Awaited<GenericInput>, Either>) => GenericOutput;
-export type EitherRightAsyncPipeResult<GenericPipeOutputs extends AnyValue, GenericLastPipeOutput extends AnyValue> = Extract<Awaited<GenericPipeOutputs>, EitherLeft> | Exclude<Awaited<GenericLastPipeOutput> extends Either ? Awaited<GenericLastPipeOutput> : EitherSuccess<Awaited<GenericLastPipeOutput>>, EitherLeft>;
+export type EitherRightAsyncPipeFunction<GenericInput extends AnyValue = AnyValue, GenericOutput extends MaybeFutureEither<AnyValue> = MaybeFutureEither<AnyValue>> = (input: Awaited<GenericInput> extends infer InferredInput ? InferredInput extends Either ? Unwrap<Exclude<InferredInput, EitherLeft>> : InferredInput : never) => GenericOutput;
+export type EitherRightAsyncPipeResult<GenericPipeOutputs extends AnyValue, GenericLastPipeOutput extends AnyValue> = Extract<Awaited<GenericPipeOutputs>, EitherLeft> | (Awaited<GenericLastPipeOutput> extends infer InferredLastResult ? Exclude<InferredLastResult extends Either ? InferredLastResult : EitherSuccess<InferredLastResult>, EitherLeft> : never);
 export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends MaybeFutureEither<AnyValue>>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<GenericInput, GenericOutputPipe1>): Future<Extract<EitherRightAsyncPipeResult<GenericInput | GenericOutputPipe1, GenericOutputPipe1>, any>>;
 export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends MaybeFutureEither<AnyValue>, GenericOutputPipe2 extends MaybeFutureEither<AnyValue>>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<GenericInput, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<GenericOutputPipe1, GenericOutputPipe2>): Future<Extract<EitherRightAsyncPipeResult<GenericInput | GenericOutputPipe1 | GenericOutputPipe2, GenericOutputPipe2>, any>>;
 export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends MaybeFutureEither<AnyValue>, GenericOutputPipe2 extends MaybeFutureEither<AnyValue>, GenericOutputPipe3 extends MaybeFutureEither<AnyValue>>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<GenericInput, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<GenericOutputPipe1, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<GenericOutputPipe2, GenericOutputPipe3>): Future<Extract<EitherRightAsyncPipeResult<GenericInput | GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3, GenericOutputPipe3>, any>>;

package/dist/either/right/create.cjs

@@ -6,7 +6,7 @@ var base = require('../base.cjs');
 
 const eitherRightKind = kind.createKind("either-right");
 function right(information, value = undefined) {
-    return eitherRightKind.addTo(base.eitherInformationKind.addTo(wrapValue.wrapValue(value), information));
+    return eitherRightKind.setTo(base.eitherInformationKind.setTo(wrapValue.wrapValue(value), information));
 }
 
 exports.eitherRightKind = eitherRightKind;

package/dist/either/right/create.mjs

@@ -4,7 +4,7 @@ import { eitherInformationKind } from '../base.mjs';
 
 const eitherRightKind = createKind("either-right");
 function right(information, value = undefined) {
-    return eitherRightKind.addTo(eitherInformationKind.addTo(wrapValue(value), information));
+    return eitherRightKind.setTo(eitherInformationKind.setTo(wrapValue(value), information));
 }
 
 export { eitherRightKind, right };

package/dist/either/right/ok.cjs

@@ -5,7 +5,7 @@ var create = require('./create.cjs');
 
 const eitherOkKind = kind.createKind("either-ok");
 function ok() {
-    return eitherOkKind.addTo(create.right("ok", undefined));
+    return eitherOkKind.setTo(create.right("ok", undefined));
 }
 
 exports.eitherOkKind = eitherOkKind;

package/dist/either/right/ok.mjs

@@ -3,7 +3,7 @@ import { right } from './create.mjs';
 
 const eitherOkKind = createKind("either-ok");
 function ok() {
-    return eitherOkKind.addTo(right("ok", undefined));
+    return eitherOkKind.setTo(right("ok", undefined));
 }
 
 export { eitherOkKind, ok };

package/dist/either/right/success.cjs

@@ -5,7 +5,7 @@ var kind = require('../../common/kind.cjs');
 
 const eitherSuccessKind = kind.createKind("either-success");
 function success(value) {
-    return eitherSuccessKind.addTo(create.right("success", value));
+    return eitherSuccessKind.setTo(create.right("success", value));
 }
 
 exports.eitherSuccessKind = eitherSuccessKind;

package/dist/either/right/success.mjs

@@ -3,7 +3,7 @@ import { createKind } from '../../common/kind.mjs';
 
 const eitherSuccessKind = createKind("either-success");
 function success(value) {
-    return eitherSuccessKind.addTo(right("success", value));
+    return eitherSuccessKind.setTo(right("success", value));
 }
 
 export { eitherSuccessKind, success };

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

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

package/dist/either/whenHasInformation.d.ts

@@ -1,8 +1,8 @@
-import { type Kind, type WrappedValue, type AnyValue, type Unwrap } from "../common";
+import { type Kind, type WrappedValue, type AnyValue, type Unwrap, type BreakGenericLink } from "../common";
 import { type EitherRight } from "./right";
 import { type EitherLeft } from "./left";
 import { eitherInformationKind } from "./base";
 type Either = EitherRight | EitherLeft;
-export declare function whenHasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never), const GenericOutput extends AnyValue>(information: GenericInformation | GenericInformation[], theFunction: (value: Unwrap<Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
+export declare function whenHasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never), const GenericOutput extends AnyValue>(information: GenericInformation | GenericInformation[], theFunction: (value: Unwrap<Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<BreakGenericLink<GenericInput>, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
 export declare function whenHasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never), const GenericOutput extends AnyValue>(input: GenericInput, information: GenericInformation | GenericInformation[], theFunction: (value: Unwrap<Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue>>) => GenericOutput): GenericOutput | Exclude<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
 export {};

package/dist/generator/reduce.cjs

@@ -7,7 +7,7 @@ var override = require('../object/override.cjs');
 
 const generatorReduceFromKind = kind.createKind("generator-reduce-from");
 function reduceFrom(value) {
-    return generatorReduceFromKind.addTo(wrapValue.wrapValue(value));
+    return generatorReduceFromKind.setTo(wrapValue.wrapValue(value));
 }
 function reduce(...args) {
     if (args.length === 2) {

package/dist/generator/reduce.mjs

@@ -5,7 +5,7 @@ import { override } from '../object/override.mjs';
 
 const generatorReduceFromKind = createKind("generator-reduce-from");
 function reduceFrom(value) {
-    return generatorReduceFromKind.addTo(wrapValue(value));
+    return generatorReduceFromKind.setTo(wrapValue(value));
 }
 function reduce(...args) {
     if (args.length === 2) {

package/dist/index.cjs

@@ -33,6 +33,10 @@ var not = require('./common/not.cjs');
 var isType = require('./common/isType.cjs');
 var and = require('./common/and.cjs');
 var or = require('./common/or.cjs');
+var whenElse = require('./common/whenElse.cjs');
+var justReturn = require('./common/justReturn.cjs');
+var memo = require('./common/memo.cjs');
+var instanceOf = require('./common/instanceOf.cjs');
 var index = require('./array/index.cjs');
 var index$1 = require('./number/index.cjs');
 var index$2 = require('./either/index.cjs');
@@ -40,6 +44,9 @@ var index$3 = require('./object/index.cjs');
 var index$4 = require('./string/index.cjs');
 var index$5 = require('./generator/index.cjs');
 var index$6 = require('./pattern/index.cjs');
+var index$7 = require('./dataParser/index.cjs');
+var index$8 = require('./dataParser/parsers/coerce/index.cjs');
+var index$9 = require('./dataParser/extended/index.cjs');
 
 
 
@@ -52,6 +59,7 @@ exports.createExternalPromise = externalPromise.createExternalPromise;
 exports.createInterpolation = interpolation.createInterpolation;
 exports.createKind = kind.createKind;
 exports.keyKindPrefix = kind.keyKindPrefix;
+exports.kindHeritage = kind.kindHeritage;
 exports.pipe = pipe.pipe;
 exports.promiseObject = promiseObject.promiseObject;
 exports.simpleClone = simpleClone.simpleClone;
@@ -82,6 +90,10 @@ exports.not = not.not;
 exports.isType = isType.isType;
 exports.and = and.and;
 exports.or = or.or;
+exports.whenElse = whenElse.whenElse;
+exports.justReturn = justReturn.justReturn;
+exports.memo = memo.memo;
+exports.instanceOf = instanceOf.instanceOf;
 exports.A = index;
 exports.DArray = index;
 exports.DNumber = index$1;
@@ -96,3 +108,9 @@ exports.DGenerator = index$5;
 exports.G = index$5;
 exports.DPattern = index$6;
 exports.P = index$6;
+exports.DDataParser = index$7;
+exports.DP = index$7;
+exports.DDataParserCoerce = index$8;
+exports.DPC = index$8;
+exports.DDataParserExtended = index$9;
+exports.DPE = index$9;

package/dist/index.d.ts

@@ -13,3 +13,9 @@ export * as G from "./generator";
 export * as DGenerator from "./generator";
 export * as P from "./pattern";
 export * as DPattern from "./pattern";
+export * as DP from "./dataParser";
+export * as DDataParser from "./dataParser";
+export * as DPC from "./dataParser/parsers/coerce";
+export * as DDataParserCoerce from "./dataParser/parsers/coerce";
+export * as DPE from "./dataParser/extended";
+export * as DDataParserExtended from "./dataParser/extended";

package/dist/index.mjs

@@ -5,7 +5,7 @@ export { createEnum } from './common/enum.mjs';
 export { escapeRegExp } from './common/escapeRegExp.mjs';
 export { createExternalPromise } from './common/externalPromise.mjs';
 export { createInterpolation } from './common/interpolation.mjs';
-export { createKind, keyKindPrefix } from './common/kind.mjs';
+export { createKind, keyKindPrefix, kindHeritage } from './common/kind.mjs';
 export { pipe } from './common/pipe.mjs';
 export { promiseObject } from './common/promiseObject.mjs';
 export { simpleClone } from './common/simpleClone.mjs';
@@ -31,6 +31,10 @@ export { not } from './common/not.mjs';
 export { isType } from './common/isType.mjs';
 export { and } from './common/and.mjs';
 export { or } from './common/or.mjs';
+export { whenElse } from './common/whenElse.mjs';
+export { justReturn } from './common/justReturn.mjs';
+export { memo } from './common/memo.mjs';
+export { instanceOf } from './common/instanceOf.mjs';
 import * as index from './array/index.mjs';
 export { index as A };
 export { index as DArray };
@@ -52,3 +56,12 @@ export { index$5 as G };
 import * as index$6 from './pattern/index.mjs';
 export { index$6 as DPattern };
 export { index$6 as P };
+import * as index$7 from './dataParser/index.mjs';
+export { index$7 as DDataParser };
+export { index$7 as DP };
+import * as index$8 from './dataParser/parsers/coerce/index.mjs';
+export { index$8 as DDataParserCoerce };
+export { index$8 as DPC };
+import * as index$9 from './dataParser/extended/index.mjs';
+export { index$9 as DDataParserExtended };
+export { index$9 as DPE };

package/dist/object/entry.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function entry(key, value) {
+    return [key, value];
+}
+
+exports.entry = entry;

package/dist/object/entry.d.ts

@@ -0,0 +1,2 @@
+import { type AnyValue, type ObjectKey } from "../common";
+export declare function entry<GenericKey extends ObjectKey, GenericValue extends AnyValue>(key: GenericKey, value: GenericValue): readonly [GenericKey, GenericValue];

package/dist/object/entry.mjs

@@ -0,0 +1,5 @@
+function entry(key, value) {
+    return [key, value];
+}
+
+export { entry };

package/dist/object/fromEntries.d.ts

@@ -2,5 +2,5 @@ import { type ObjectEntry, type ObjectKey, type AnyValue, type SimplifyTopLevel
 type ComputeEntries<GenericEntry extends ObjectEntry> = SimplifyTopLevel<{
     [Entry in GenericEntry as Entry[0]]?: Entry[1];
 }>;
-export declare function fromEntries<GenericKey extends ObjectKey, GenericValue extends AnyValue, GenericEntry extends [GenericKey, GenericValue]>(entries: GenericEntry[]): ComputeEntries<GenericEntry>;
+export declare function fromEntries<GenericKey extends ObjectKey, GenericValue extends AnyValue, GenericEntry extends readonly [GenericKey, GenericValue]>(entries: readonly GenericEntry[]): ComputeEntries<GenericEntry>;
 export {};

package/dist/object/index.cjs

@@ -16,6 +16,7 @@ var pick = require('./pick.cjs');
 var deepDiscriminate = require('./deepDiscriminate.cjs');
 var getDeepProperty = require('./getDeepProperty.cjs');
 var discriminate = require('./discriminate.cjs');
+var entry = require('./entry.cjs');
 
 
 
@@ -35,3 +36,4 @@ exports.pick = pick.pick;
 exports.deepDiscriminate = deepDiscriminate.deepDiscriminate;
 exports.getDeepProperty = getDeepProperty.getDeepProperty;
 exports.discriminate = discriminate.discriminate;
+exports.entry = entry.entry;

package/dist/object/index.d.ts

@@ -15,3 +15,4 @@ export * from "./pick";
 export * from "./deepDiscriminate";
 export * from "./getDeepProperty";
 export * from "./discriminate";
+export * from "./entry";

package/dist/object/index.mjs

@@ -14,3 +14,4 @@ export { pick } from './pick.mjs';
 export { deepDiscriminate } from './deepDiscriminate.mjs';
 export { getDeepProperty } from './getDeepProperty.mjs';
 export { discriminate } from './discriminate.mjs';
+export { entry } from './entry.mjs';

package/dist/object/keys.cjs

@@ -1,7 +1,10 @@
 'use strict';
 
+var wrapValue = require('../common/wrapValue.cjs');
+
 function keys(object) {
-    return Object.keys(object);
+    return Object.keys(object)
+        .filter((key) => !key.startsWith(wrapValue.keyWrappedValue));
 }
 
 exports.keys = keys;

package/dist/object/keys.d.ts

@@ -1 +1 @@
-export declare function keys<GenericObject extends object>(object: GenericObject): (keyof GenericObject)[];
+export declare function keys<GenericObject extends object>(object: GenericObject): (Exclude<keyof GenericObject, symbol>)[];

package/dist/object/keys.mjs

@@ -1,5 +1,8 @@
+import { keyWrappedValue } from '../common/wrapValue.mjs';
+
 function keys(object) {
-    return Object.keys(object);
+    return Object.keys(object)
+        .filter((key) => !key.startsWith(keyWrappedValue));
 }
 
 export { keys };

package/dist/object/types/getPropsWithValueExtends.d.ts

@@ -1,3 +1,3 @@
 export type GetPropsWithValueExtends<GenericObject extends object, GenericValue extends unknown> = {
-    [Prop in keyof GenericObject]: GenericObject[Prop] extends GenericValue ? Prop : never;
+    [Prop in keyof GenericObject]: GenericObject[Prop] extends infer InferredValue ? InferredValue extends GenericValue ? Prop : never : never;
 }[keyof GenericObject];

package/dist/pattern/result.cjs

@@ -5,7 +5,7 @@ var wrapValue = require('../common/wrapValue.cjs');
 
 const patternResultKind = kind.createKind("pattern-result");
 function result(value) {
-    return patternResultKind.addTo(wrapValue.wrapValue(value));
+    return patternResultKind.setTo(wrapValue.wrapValue(value));
 }
 const isResult = patternResultKind.has;