@duplojs/utils 1.0.7 → 1.1.8

package/dist/either/kind.mjs

@@ -0,0 +1,6 @@
+import { createKindNamespace } from '../common/kind.mjs';
+
+const createEitherKind = createKindNamespace("Either");
+const eitherInformationKind = createEitherKind("information");
+
+export { createEitherKind, eitherInformationKind };

package/dist/either/left/create.cjs

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

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

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

package/dist/either/left/create.mjs

@@ -1,10 +1,9 @@
-import { createKind } from '../../common/kind.mjs';
 import { wrapValue } from '../../common/wrapValue.mjs';
-import { eitherInformationKind } from '../base.mjs';
+import { createEitherKind, eitherInformationKind } from '../kind.mjs';
 
-const eitherLeftKind = createKind("either-left");
+const eitherLeftKind = createEitherKind("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

@@ -1,11 +1,11 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
+var kind = require('../kind.cjs');
 var create = require('./create.cjs');
 
-const eitherErrorKind = kind.createKind("either-error");
+const eitherErrorKind = kind.createEitherKind("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.d.ts

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

package/dist/either/left/error.mjs

@@ -1,9 +1,9 @@
-import { createKind } from '../../common/kind.mjs';
+import { createEitherKind } from '../kind.mjs';
 import { left } from './create.mjs';
 
-const eitherErrorKind = createKind("either-error");
+const eitherErrorKind = createEitherKind("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

@@ -1,11 +1,11 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
+var kind = require('../kind.cjs');
 var create = require('./create.cjs');
 
-const eitherFailKind = kind.createKind("either-fail");
+const eitherFailKind = kind.createEitherKind("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.d.ts

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

package/dist/either/left/fail.mjs

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

package/dist/either/left/is.cjs

@@ -2,11 +2,11 @@
 
 var create = require('./create.cjs');
 var wrapValue = require('../../common/wrapValue.cjs');
-var base = require('../base.cjs');
+var kind = require('../kind.cjs');
 
 function isLeft(input) {
     return create.eitherLeftKind.has(input)
-        && base.eitherInformationKind.has(input)
+        && kind.eitherInformationKind.has(input)
         && wrapValue.isWrappedValue(input);
 }
 

package/dist/either/left/is.mjs

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

package/dist/either/nullable/base.cjs

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

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

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

package/dist/either/nullable/base.mjs

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

package/dist/either/nullable/empty.cjs

@@ -1,16 +1,16 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 var create = require('../left/create.cjs');
+var kind = require('../kind.cjs');
 var is = require('../left/is.cjs');
 var is$1 = require('../right/is.cjs');
 var create$1 = require('./create.cjs');
 var base = require('./base.cjs');
 
-const eitherNullableEmptyKind = kind.createKind("either-nullable-empty");
+const eitherNullableEmptyKind = kind.createEitherKind("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

@@ -4,7 +4,7 @@ import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
 import { nullable } from "./create";
 import { eitherNullableKind } from "./base";
-export declare const eitherNullableEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-nullable-empty", unknown>>;
+export declare const eitherNullableEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@Either/nullable-empty", unknown>>;
 type _EitherNullableEmpty = (EitherLeft<"nullable", null> & Kind<typeof eitherNullableKind.definition> & Kind<typeof eitherNullableEmptyKind.definition>);
 export interface EitherNullableEmpty extends _EitherNullableEmpty {
 }

package/dist/either/nullable/empty.mjs

@@ -1,14 +1,14 @@
-import { createKind } from '../../common/kind.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 import { left } from '../left/create.mjs';
+import { createEitherKind } from '../kind.mjs';
 import { isLeft } from '../left/is.mjs';
 import { isRight } from '../right/is.mjs';
 import { nullable } from './create.mjs';
 import { eitherNullableKind } from './base.mjs';
 
-const eitherNullableEmptyKind = createKind("either-nullable-empty");
+const eitherNullableEmptyKind = createEitherKind("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

@@ -1,16 +1,16 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
 var unwrap = require('../../common/unwrap.cjs');
+var kind = require('../kind.cjs');
 var is$1 = require('../left/is.cjs');
 var create = require('../right/create.cjs');
 var is = require('../right/is.cjs');
 var create$1 = require('./create.cjs');
 var base = require('./base.cjs');
 
-const eitherNullableFilledKind = kind.createKind("either-nullable-filled");
+const eitherNullableFilledKind = kind.createEitherKind("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

@@ -4,7 +4,7 @@ import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
 import { nullable } from "./create";
 import { eitherNullableKind } from "./base";
-export declare const eitherNullableFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-nullable-filled", unknown>>;
+export declare const eitherNullableFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@Either/nullable-filled", unknown>>;
 type _EitherNullableFilled<GenericValue extends unknown = unknown> = (EitherRight<"nullable", GenericValue> & Kind<typeof eitherNullableKind.definition> & Kind<typeof eitherNullableFilledKind.definition>);
 export interface EitherNullableFilled<GenericValue extends unknown = unknown> extends _EitherNullableFilled<GenericValue> {
 }

package/dist/either/nullable/filled.mjs

@@ -1,14 +1,14 @@
-import { createKind } from '../../common/kind.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
+import { createEitherKind } from '../kind.mjs';
 import { isLeft } from '../left/is.mjs';
 import { right } from '../right/create.mjs';
 import { isRight } from '../right/is.mjs';
 import { nullable } from './create.mjs';
 import { eitherNullableKind } from './base.mjs';
 
-const eitherNullableFilledKind = createKind("either-nullable-filled");
+const eitherNullableFilledKind = createEitherKind("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/base.cjs

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

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

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

package/dist/either/nullish/base.mjs

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

package/dist/either/nullish/empty.cjs

@@ -1,16 +1,16 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
 var unwrap = require('../../common/unwrap.cjs');
+var kind = require('../kind.cjs');
 var create = require('../left/create.cjs');
 var is = require('../left/is.cjs');
 var is$1 = require('../right/is.cjs');
 var create$1 = require('./create.cjs');
 var base = require('./base.cjs');
 
-const eitherNullishEmptyKind = kind.createKind("either-nullish-empty");
+const eitherNullishEmptyKind = kind.createEitherKind("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,11 +1,11 @@
 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 { nullish } from "./create";
-import { type Kind } from "../../common/kind";
 import { eitherNullishKind } from "./base";
 export type NullishValue = null | undefined;
-export declare const eitherNullishEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-nullish-empty", unknown>>;
+export declare const eitherNullishEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@Either/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> {
 }

package/dist/either/nullish/empty.mjs

@@ -1,14 +1,14 @@
-import { createKind } from '../../common/kind.mjs';
 import { unwrap } from '../../common/unwrap.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 { nullish } from './create.mjs';
 import { eitherNullishKind } from './base.mjs';
 
-const eitherNullishEmptyKind = createKind("either-nullish-empty");
+const eitherNullishEmptyKind = createEitherKind("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

@@ -1,16 +1,16 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
-var unwrap = require('../../common/unwrap.cjs');
+var kind = require('../kind.cjs');
 var is$1 = require('../left/is.cjs');
+var unwrap = require('../../common/unwrap.cjs');
 var create = require('../right/create.cjs');
 var is = require('../right/is.cjs');
 var create$1 = require('./create.cjs');
 var base = require('./base.cjs');
 
-const eitherNullishFilledKind = kind.createKind("either-nullish-filled");
+const eitherNullishFilledKind = kind.createEitherKind("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

@@ -4,7 +4,7 @@ import { nullish } from "./create";
 import { type Kind } from "../../common/kind";
 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>>;
+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>);
 export interface EitherNullishFilled<GenericValue extends unknown = unknown> extends _EitherNullishFilled<GenericValue> {
 }

package/dist/either/nullish/filled.mjs

@@ -1,14 +1,14 @@
-import { createKind } from '../../common/kind.mjs';
-import { unwrap } from '../../common/unwrap.mjs';
+import { createEitherKind } from '../kind.mjs';
 import { isLeft } from '../left/is.mjs';
+import { unwrap } from '../../common/unwrap.mjs';
 import { right } from '../right/create.mjs';
 import { isRight } from '../right/is.mjs';
 import { nullish } from './create.mjs';
 import { eitherNullishKind } from './base.mjs';
 
-const eitherNullishFilledKind = createKind("either-nullish-filled");
+const eitherNullishFilledKind = createEitherKind("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/base.cjs

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

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

@@ -1 +1 @@
-export declare const eitherOptionalKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-optional", unknown>>;
+export declare const eitherOptionalKind: import("../..").KindHandler<import("../..").KindDefinition<"@Either/optional", unknown>>;

package/dist/either/optional/base.mjs

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

package/dist/either/optional/empty.cjs

@@ -1,15 +1,15 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
+var kind = require('../kind.cjs');
+var base = require('./base.cjs');
+var create$1 = require('./create.cjs');
 var create = require('../left/create.cjs');
 var is = require('../left/is.cjs');
 var is$1 = require('../right/is.cjs');
-var create$1 = require('./create.cjs');
-var base = require('./base.cjs');
 
-const eitherOptionalEmptyKind = kind.createKind("either-optional-empty");
+const eitherOptionalEmptyKind = kind.createEitherKind("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,10 +1,10 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type Kind } from "../../common/kind";
+import { eitherOptionalKind } from "./base";
+import { optional } from "./create";
 import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
-import { optional } from "./create";
-import { eitherOptionalKind } from "./base";
-export declare const eitherOptionalEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-optional-empty", unknown>>;
+export declare const eitherOptionalEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@Either/optional-empty", unknown>>;
 type _EitherOptionalEmpty = (EitherLeft<"optional", undefined> & Kind<typeof eitherOptionalKind.definition> & Kind<typeof eitherOptionalEmptyKind.definition>);
 export interface EitherOptionalEmpty extends _EitherOptionalEmpty {
 }

package/dist/either/optional/empty.mjs

@@ -1,13 +1,13 @@
-import { createKind } from '../../common/kind.mjs';
+import { createEitherKind } from '../kind.mjs';
+import { eitherOptionalKind } from './base.mjs';
+import { optional } from './create.mjs';
 import { left } from '../left/create.mjs';
 import { isLeft } from '../left/is.mjs';
 import { isRight } from '../right/is.mjs';
-import { optional } from './create.mjs';
-import { eitherOptionalKind } from './base.mjs';
 
-const eitherOptionalEmptyKind = createKind("either-optional-empty");
+const eitherOptionalEmptyKind = createEitherKind("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

@@ -1,16 +1,16 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
 var unwrap = require('../../common/unwrap.cjs');
+var kind = require('../kind.cjs');
+var base = require('./base.cjs');
+var create$1 = require('./create.cjs');
 var is$1 = require('../left/is.cjs');
 var create = require('../right/create.cjs');
 var is = require('../right/is.cjs');
-var create$1 = require('./create.cjs');
-var base = require('./base.cjs');
 
-const eitherOptionalFilledKind = kind.createKind("either-optional-filled");
+const eitherOptionalFilledKind = kind.createEitherKind("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,10 +1,10 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type Kind } from "../../common/kind";
+import { eitherOptionalKind } from "./base";
+import { optional } from "./create";
 import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
-import { optional } from "./create";
-import { eitherOptionalKind } from "./base";
-export declare const eitherOptionalFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-optional-filled", unknown>>;
+export declare const eitherOptionalFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@Either/optional-filled", unknown>>;
 type _EitherOptionalFilled<GenericValue extends unknown = unknown> = (EitherRight<"optional", GenericValue> & Kind<typeof eitherOptionalKind.definition> & Kind<typeof eitherOptionalFilledKind.definition>);
 export interface EitherOptionalFilled<GenericValue extends unknown = unknown> extends _EitherOptionalFilled<GenericValue> {
 }

package/dist/either/optional/filled.mjs

@@ -1,14 +1,14 @@
-import { createKind } from '../../common/kind.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
+import { createEitherKind } from '../kind.mjs';
+import { eitherOptionalKind } from './base.mjs';
+import { optional } from './create.mjs';
 import { isLeft } from '../left/is.mjs';
 import { right } from '../right/create.mjs';
 import { isRight } from '../right/is.mjs';
-import { optional } from './create.mjs';
-import { eitherOptionalKind } from './base.mjs';
 
-const eitherOptionalFilledKind = createKind("either-optional-filled");
+const eitherOptionalFilledKind = createEitherKind("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

@@ -1,12 +1,11 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
 var wrapValue = require('../../common/wrapValue.cjs');
-var base = require('../base.cjs');
+var kind = require('../kind.cjs');
 
-const eitherRightKind = kind.createKind("either-right");
+const eitherRightKind = kind.createEitherKind("right");
 function right(information, value = undefined) {
-    return eitherRightKind.addTo(base.eitherInformationKind.addTo(wrapValue.wrapValue(value), information));
+    return eitherRightKind.setTo(kind.eitherInformationKind.setTo(wrapValue.wrapValue(value), information));
 }
 
 exports.eitherRightKind = eitherRightKind;

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

@@ -1,7 +1,7 @@
 import { type Kind } from "../../common/kind";
 import { type WrappedValue } from "../../common/wrapValue";
-import { eitherInformationKind } from "../base";
-export declare const eitherRightKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"either-right", unknown>>;
+import { eitherInformationKind } from "../kind";
+export declare const eitherRightKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@Either/right", unknown>>;
 type _EitherRight<GenericInformation extends string = string, GenericValue extends unknown = unknown> = (Kind<typeof eitherRightKind.definition> & Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue<GenericValue>);
 export interface EitherRight<GenericInformation extends string = string, GenericValue extends unknown = unknown> extends _EitherRight<GenericInformation, GenericValue> {
 }