@duplojs/utils 1.0.6 → 1.0.7

package/dist/common/index.d.ts

@@ -32,3 +32,5 @@ export * from "./not";
 export * from "./isType";
 export * from "./and";
 export * from "./or";
+export * from "./whenElse";
+export * from "./justReturn";

package/dist/common/justReturn.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function justReturn(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return () => justReturn(undefined, value);
+    }
+    const [, value] = args;
+    return value;
+}
+
+exports.justReturn = justReturn;

package/dist/common/justReturn.d.ts

@@ -0,0 +1,3 @@
+import { type AnyValue } from "./types";
+export declare function justReturn<GenericValue extends AnyValue>(value: GenericValue): (input: unknown) => GenericValue;
+export declare function justReturn<GenericValue extends AnyValue>(input: unknown, value: GenericValue): GenericValue;

package/dist/common/justReturn.mjs

@@ -0,0 +1,10 @@
+function justReturn(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return () => justReturn(undefined, value);
+    }
+    const [, value] = args;
+    return value;
+}
+
+export { justReturn };

package/dist/common/kind.d.ts

@@ -1,4 +1,4 @@
-import { type Or, type IsEqual } from "./types";
+import { type Or, type IsEqual, type BreakGenericLink } from "./types";
 export interface KindHandler<GenericKindDefinition extends KindDefinition> {
     definition: GenericKindDefinition;
     runTimeKey: string;
@@ -7,7 +7,7 @@ export interface KindHandler<GenericKindDefinition extends KindDefinition> {
         IsEqual<GenericValue, never>,
         IsEqual<GenericValue, unknown>,
         IsEqual<GenericValue, any>
-    ]> extends true ? [input: GenericInput, value?: GenericValue] : [input: GenericInput, value: GenericValue]): Kind<GenericKindDefinition, GenericValue> & GenericInput;
+    ]> extends true ? [input: GenericInput, value?: GenericValue] : [input: GenericInput, value: GenericValue]): Kind<GenericKindDefinition, GenericValue> & BreakGenericLink<GenericInput>;
     getValue<GenericKind extends Kind<GenericKindDefinition, GenericKindDefinition["value"]>>(input: GenericKind): GenericKind[SymbolKind][GenericKindDefinition["name"]];
 }
 export interface KindDefinition<GenericName extends string = string, GenericValue extends unknown = unknown> {

package/dist/common/when.d.ts

@@ -1,5 +1,5 @@
-import { type EscapeVoid, type AnyValue } from "./types";
-export declare function when<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<GenericInput, GenericPredicatedInput>;
+import { type EscapeVoid, type AnyValue, type BreakGenericLink } from "./types";
+export declare function when<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<BreakGenericLink<GenericInput>, GenericPredicatedInput>;
 export declare function when<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): GenericOutput | Exclude<GenericInput, GenericPredicatedInput>;
 export declare function when<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): (input: GenericInput) => GenericOutput | GenericInput;
 export declare function when<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): GenericOutput | GenericInput;

package/dist/common/whenElse.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function whenElse(...args) {
+    if (args.length === 3) {
+        const [ifFunction, theFunction, elseFunction] = args;
+        return (input) => whenElse(input, ifFunction, theFunction, elseFunction);
+    }
+    const [input, ifFunction, theFunction, elseFunction] = args;
+    if (ifFunction(input)) {
+        return theFunction(input);
+    }
+    else {
+        return elseFunction(input);
+    }
+}
+
+exports.whenElse = whenElse;

package/dist/common/whenElse.d.ts

@@ -0,0 +1,5 @@
+import { type EscapeVoid, type AnyValue, type BreakGenericLink } from "./types";
+export declare function whenElse<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(predicate: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput1, elseFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput2): (input: GenericInput) => BreakGenericLink<GenericOutput1> | BreakGenericLink<GenericOutput2>;
+export declare function whenElse<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(input: GenericInput, predicate: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput1, elseFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput2): GenericOutput1 | GenericOutput2;
+export declare function whenElse<GenericInput extends AnyValue, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(predicate: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput1, elseFunction: (predicatedInput: GenericInput) => GenericOutput2): (input: GenericInput) => GenericOutput1 | GenericOutput2;
+export declare function whenElse<GenericInput extends AnyValue, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(input: GenericInput, predicate: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput1, elseFunction: (predicatedInput: GenericInput) => GenericOutput2): BreakGenericLink<GenericOutput1> | BreakGenericLink<GenericOutput2>;

package/dist/common/whenElse.mjs

@@ -0,0 +1,15 @@
+function whenElse(...args) {
+    if (args.length === 3) {
+        const [ifFunction, theFunction, elseFunction] = args;
+        return (input) => whenElse(input, ifFunction, theFunction, elseFunction);
+    }
+    const [input, ifFunction, theFunction, elseFunction] = args;
+    if (ifFunction(input)) {
+        return theFunction(input);
+    }
+    else {
+        return elseFunction(input);
+    }
+}
+
+export { whenElse };

package/dist/common/whenNot.d.ts

@@ -1,5 +1,5 @@
-import { type EscapeVoid, type AnyValue } from "./types";
-export declare function whenNot<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput): (input: GenericInput) => GenericOutput | GenericPredicatedInput;
+import { type EscapeVoid, type AnyValue, type BreakGenericLink } from "./types";
+export declare function whenNot<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput): (input: GenericInput) => GenericOutput | BreakGenericLink<GenericPredicatedInput>;
 export declare function whenNot<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput): GenericOutput | GenericPredicatedInput;
 export declare function whenNot<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): (input: GenericInput) => GenericOutput | GenericInput;
 export declare function whenNot<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): GenericOutput | GenericInput;

package/dist/either/bool/falsy.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 { bool } from "./create";
@@ -13,6 +13,6 @@ export declare function boolFalsy<const GenericValue extends BoolFalsyValue = un
 type Either = EitherRight | EitherLeft;
 export declare function isBoolFalsy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolFalsy>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;
-export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolFalsy>;
+export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherBoolFalsy>;
 export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolFalsy>;
 export {};

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

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

package/dist/either/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.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/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/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/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/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/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/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/index.cjs

@@ -33,6 +33,8 @@ 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 index = require('./array/index.cjs');
 var index$1 = require('./number/index.cjs');
 var index$2 = require('./either/index.cjs');
@@ -82,6 +84,8 @@ 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.A = index;
 exports.DArray = index;
 exports.DNumber = index$1;

package/dist/index.mjs

@@ -31,6 +31,8 @@ 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';
 import * as index from './array/index.mjs';
 export { index as A };
 export { index as DArray };

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/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/pattern/result.d.ts

@@ -1,6 +1,6 @@
 import { type Kind, type WrappedValue } from "../common";
 declare const patternResultKind: import("../common").KindHandler<import("../common").KindDefinition<"pattern-result", unknown>>;
-export interface PatternResult<GenericValue extends unknown = unknown> extends Kind<typeof patternResultKind.definition>, WrappedValue<GenericValue> {
+export interface PatternResult<GenericValue extends unknown = any> extends Kind<typeof patternResultKind.definition>, WrappedValue<GenericValue> {
 }
 export declare function result<const GenericValue extends unknown>(value: GenericValue): PatternResult<GenericValue>;
 export declare const isResult: <GenericInput extends unknown>(input: GenericInput) => input is Extract<GenericInput, Kind<import("../common").KindDefinition<"pattern-result", unknown>, unknown>>;

package/dist/pattern/when.d.ts

@@ -1,6 +1,6 @@
-import { type AnyValue } from "../common";
+import { type AnyValue, type BreakGenericLink } from "../common";
 import { type PatternResult } from "./result";
-export declare function when<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericPredicatedInput extends GenericInputValue, GenericOutput extends AnyValue>(predicate: (input: GenericInputValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (input: (GenericInput | GenericInputPatternResult | GenericInputValue)) => (GenericInputPatternResult | Exclude<GenericInputValue, GenericPredicatedInput> | PatternResult<GenericOutput>);
+export declare function when<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericPredicatedInput extends GenericInputValue, GenericOutput extends AnyValue>(predicate: (input: GenericInputValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (input: (GenericInput | GenericInputPatternResult | GenericInputValue)) => (GenericInputPatternResult | Exclude<BreakGenericLink<GenericInputValue>, GenericPredicatedInput> | PatternResult<GenericOutput>);
 export declare function when<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericOutput extends AnyValue>(predicate: (input: GenericInputValue) => boolean, theFunction: (predicatedInput: GenericInputValue) => GenericOutput): (input: (GenericInput | GenericInputPatternResult | GenericInputValue)) => (GenericInputPatternResult | GenericInputValue | PatternResult<GenericOutput>);
 export declare function when<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericPredicatedInput extends GenericInputValue, GenericOutput extends AnyValue>(input: (GenericInput | GenericInputPatternResult | GenericInputValue), predicate: (input: GenericInputValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (GenericInputPatternResult | Exclude<GenericInputValue, GenericPredicatedInput> | PatternResult<GenericOutput>);
 export declare function when<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericOutput extends AnyValue>(input: (GenericInput | GenericInputPatternResult | GenericInputValue), predicate: (input: GenericInputValue) => boolean, theFunction: (predicatedInput: GenericInputValue) => GenericOutput): (GenericInputPatternResult | GenericInputValue | PatternResult<GenericOutput>);

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",
-  "repository": "https://github.com/duplojs/utils",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/duplojs/utils.git"
+  },
   "scripts": {
     "build": "rollup --config && tsc-alias -p tsconfig.build.json",
     "test:tu": "vitest --coverage",
@@ -46,7 +49,9 @@
     "vite-tsconfig-paths": "5.1.4",
     "vitest": "3.2.4"
   },
-  "workspaces": ["integration"],
+  "workspaces": [
+    "integration"
+  ],
   "keywords": [],
   "engines": {
     "node": ">=22.15.1"