@duplojs/lang 0.0.1-beta.1 → 0.0.1-beta.11

package/dist/dataStructure/type/defaults/bigintLiteral.cjs

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/type/defaults/bigintLiteral.ts
 const bigintLiteralTypeKind = require_kind.createKind("bigint-literal-type");
 const BigintLiteralType = require_base.createType(require_bigint.TheBigint, bigintLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/type/defaults/bigintLiteral.d.ts

@@ -6,6 +6,6 @@ export declare const bigintLiteralTypeKind: DKind.Handler<DKind.Definition<"@Dup
 export interface BigintLiteralTypeDefinition extends TypeDefinition {
     value: bigint;
 }
-export interface BigintLiteralType<GenericValue extends bigint = bigint> extends DCommon.UnionToIntersection<Type<FundamentalType.TheBigint, GenericValue, BigintLiteralTypeDefinition> & DKind.Kind<typeof bigintLiteralTypeKind>> {
+export interface BigintLiteralType<GenericValue extends bigint = bigint> extends DCommon.Forward<Type<FundamentalType.TheBigint, GenericValue, BigintLiteralTypeDefinition> & DKind.Kind<typeof bigintLiteralTypeKind>> {
 }
 export declare const BigintLiteralType: <const GenericBigint extends bigint>(value: GenericBigint) => BigintLiteralType<GenericBigint>;

package/dist/dataStructure/type/defaults/bigintLiteral.mjs

@@ -5,7 +5,7 @@ import { createType } from "../base.mjs";
 //#region scripts/dataStructure/type/defaults/bigintLiteral.ts
 const bigintLiteralTypeKind = createKind("bigint-literal-type");
 const BigintLiteralType = createType(TheBigint, bigintLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/type/defaults/boolean.d.ts

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const booleanTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/boolean-type", unknown>>;
 export interface BooleanTypeDefinition extends TypeDefinition {
 }
-export interface BooleanType extends DCommon.UnionToIntersection<Type<FundamentalType.TheBoolean, boolean, BooleanTypeDefinition> & DKind.Kind<typeof booleanTypeKind>> {
+export interface BooleanType extends DCommon.Forward<Type<FundamentalType.TheBoolean, boolean, BooleanTypeDefinition> & DKind.Kind<typeof booleanTypeKind>> {
 }
 export declare const BooleanType: () => BooleanType;

package/dist/dataStructure/type/defaults/booleanLiteral.cjs

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/type/defaults/booleanLiteral.ts
 const booleanLiteralTypeKind = require_kind.createKind("boolean-literal-type");
 const BooleanLiteralType = require_base.createType(require_boolean.TheBoolean, booleanLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/type/defaults/booleanLiteral.d.ts

@@ -6,6 +6,6 @@ export declare const booleanLiteralTypeKind: DKind.Handler<DKind.Definition<"@Du
 export interface BooleanLiteralTypeDefinition extends TypeDefinition {
     value: boolean;
 }
-export interface BooleanLiteralType<GenericValue extends boolean = boolean> extends DCommon.UnionToIntersection<Type<FundamentalType.TheBoolean, GenericValue, BooleanLiteralTypeDefinition> & DKind.Kind<typeof booleanLiteralTypeKind>> {
+export interface BooleanLiteralType<GenericValue extends boolean = boolean> extends DCommon.Forward<Type<FundamentalType.TheBoolean, GenericValue, BooleanLiteralTypeDefinition> & DKind.Kind<typeof booleanLiteralTypeKind>> {
 }
 export declare const BooleanLiteralType: <const GenericBoolean extends boolean>(value: GenericBoolean) => BooleanLiteralType<GenericBoolean>;

package/dist/dataStructure/type/defaults/booleanLiteral.mjs

@@ -5,7 +5,7 @@ import { createType } from "../base.mjs";
 //#region scripts/dataStructure/type/defaults/booleanLiteral.ts
 const booleanLiteralTypeKind = createKind("boolean-literal-type");
 const BooleanLiteralType = createType(TheBoolean, booleanLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/type/defaults/date.d.ts

@@ -6,6 +6,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const dateTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/date-type", unknown>>;
 export interface DateTypeDefinition extends TypeDefinition {
 }
-export interface DateType extends DCommon.UnionToIntersection<Type<FundamentalType.TheDate, DChrono.TheDate, DateTypeDefinition> & DKind.Kind<typeof dateTypeKind>> {
+export interface DateType extends DCommon.Forward<Type<FundamentalType.TheDate, DChrono.TheDate, DateTypeDefinition> & DKind.Kind<typeof dateTypeKind>> {
 }
 export declare const DateType: () => DateType;

package/dist/dataStructure/type/defaults/null.d.ts

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const nullTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/null-type", unknown>>;
 export interface NullTypeDefinition extends TypeDefinition {
 }
-export interface NullType extends DCommon.UnionToIntersection<Type<FundamentalType.TheNull, null, NullTypeDefinition> & DKind.Kind<typeof nullTypeKind>> {
+export interface NullType extends DCommon.Forward<Type<FundamentalType.TheNull, null, NullTypeDefinition> & DKind.Kind<typeof nullTypeKind>> {
 }
 export declare const NullType: () => NullType;

package/dist/dataStructure/type/defaults/number.d.ts

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const numberTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/number-type", unknown>>;
 export interface NumberTypeDefinition extends TypeDefinition {
 }
-export interface NumberType extends DCommon.UnionToIntersection<Type<FundamentalType.TheNumber, number, NumberTypeDefinition> & DKind.Kind<typeof numberTypeKind>> {
+export interface NumberType extends DCommon.Forward<Type<FundamentalType.TheNumber, number, NumberTypeDefinition> & DKind.Kind<typeof numberTypeKind>> {
 }
 export declare const NumberType: () => NumberType;

package/dist/dataStructure/type/defaults/numberLiteral.cjs

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/type/defaults/numberLiteral.ts
 const numberLiteralTypeKind = require_kind.createKind("number-literal-type");
 const NumberLiteralType = require_base.createType(require_number.TheNumber, numberLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/type/defaults/numberLiteral.d.ts

@@ -6,6 +6,6 @@ export declare const numberLiteralTypeKind: DKind.Handler<DKind.Definition<"@Dup
 export interface NumberLiteralTypeDefinition extends TypeDefinition {
     value: number;
 }
-export interface NumberLiteralType<GenericValue extends number = number> extends DCommon.UnionToIntersection<Type<FundamentalType.TheNumber, GenericValue, NumberLiteralTypeDefinition> & DKind.Kind<typeof numberLiteralTypeKind>> {
+export interface NumberLiteralType<GenericValue extends number = number> extends DCommon.Forward<Type<FundamentalType.TheNumber, GenericValue, NumberLiteralTypeDefinition> & DKind.Kind<typeof numberLiteralTypeKind>> {
 }
 export declare const NumberLiteralType: <const GenericNumber extends number>(value: GenericNumber) => NumberLiteralType<GenericNumber>;

package/dist/dataStructure/type/defaults/numberLiteral.mjs

@@ -5,7 +5,7 @@ import { createType } from "../base.mjs";
 //#region scripts/dataStructure/type/defaults/numberLiteral.ts
 const numberLiteralTypeKind = createKind("number-literal-type");
 const NumberLiteralType = createType(TheNumber, numberLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/type/defaults/string.d.ts

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const stringTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/string-type", unknown>>;
 export interface StringTypeDefinition extends TypeDefinition {
 }
-export interface StringType extends DCommon.UnionToIntersection<Type<FundamentalType.TheString, string, StringTypeDefinition> & DKind.Kind<typeof stringTypeKind>> {
+export interface StringType extends DCommon.Forward<Type<FundamentalType.TheString, string, StringTypeDefinition> & DKind.Kind<typeof stringTypeKind>> {
 }
 export declare const StringType: () => StringType;

package/dist/dataStructure/type/defaults/stringLiteral.cjs

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/type/defaults/stringLiteral.ts
 const stringLiteralTypeKind = require_kind.createKind("string-literal-type");
 const StringLiteralType = require_base.createType(require_string.TheString, stringLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/type/defaults/stringLiteral.d.ts

@@ -6,6 +6,6 @@ export declare const stringLiteralTypeKind: DKind.Handler<DKind.Definition<"@Dup
 export interface StringLiteralTypeDefinition extends TypeDefinition {
     value: string;
 }
-export interface StringLiteralType<GenericValue extends string = string> extends DCommon.UnionToIntersection<Type<FundamentalType.TheString, GenericValue, StringLiteralTypeDefinition> & DKind.Kind<typeof stringLiteralTypeKind>> {
+export interface StringLiteralType<GenericValue extends string = string> extends DCommon.Forward<Type<FundamentalType.TheString, GenericValue, StringLiteralTypeDefinition> & DKind.Kind<typeof stringLiteralTypeKind>> {
 }
 export declare const StringLiteralType: <const GenericString extends string>(value: GenericString) => StringLiteralType<GenericString>;

package/dist/dataStructure/type/defaults/stringLiteral.mjs

@@ -5,7 +5,7 @@ import { createType } from "../base.mjs";
 //#region scripts/dataStructure/type/defaults/stringLiteral.ts
 const stringLiteralTypeKind = createKind("string-literal-type");
 const StringLiteralType = createType(TheString, stringLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/type/defaults/time.d.ts

@@ -6,6 +6,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const timeTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/time-type", unknown>>;
 export interface TimeTypeDefinition extends TypeDefinition {
 }
-export interface TimeType extends DCommon.UnionToIntersection<Type<FundamentalType.TheTime, DChrono.TheTime, TimeTypeDefinition> & DKind.Kind<typeof timeTypeKind>> {
+export interface TimeType extends DCommon.Forward<Type<FundamentalType.TheTime, DChrono.TheTime, TimeTypeDefinition> & DKind.Kind<typeof timeTypeKind>> {
 }
 export declare const TimeType: () => TimeType;

package/dist/dataStructure/type/defaults/undefined.d.ts

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const undefinedTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/undefined-type", unknown>>;
 export interface UndefinedTypeDefinition extends TypeDefinition {
 }
-export interface UndefinedType extends DCommon.UnionToIntersection<Type<FundamentalType.TheUndefined, undefined, UndefinedTypeDefinition> & DKind.Kind<typeof undefinedTypeKind>> {
+export interface UndefinedType extends DCommon.Forward<Type<FundamentalType.TheUndefined, undefined, UndefinedTypeDefinition> & DKind.Kind<typeof undefinedTypeKind>> {
 }
 export declare const UndefinedType: () => UndefinedType;

package/dist/dataStructure/type/identifier.d.ts

@@ -1,5 +1,4 @@
 import { Type } from './base';
-export declare const typeIdentifier: {
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/date-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/null-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/time-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/undefined-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", bigint>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", boolean>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheDate>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", null>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", number>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", string>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheTime>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", undefined>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import('../..').UnionContain<GenericInput, Type<import('..').FundamentalType<symbol, unknown>, unknown, import('..').TypeDefinition>> extends true ? Extract<import('..').BigintType, GenericGroupedKind> | Extract<import('..').BooleanType, GenericGroupedKind> | Extract<import('..').DateType, GenericGroupedKind> | Extract<import('..').NullType, GenericGroupedKind> | Extract<import('..').NumberType, GenericGroupedKind> | Extract<import('..').StringType, GenericGroupedKind> | Extract<import('..').TimeType, GenericGroupedKind> | Extract<import('..').UndefinedType, GenericGroupedKind> | Extract<import('..').BigintLiteralType<bigint>, GenericGroupedKind> | Extract<import('..').BooleanLiteralType<boolean>, GenericGroupedKind> | Extract<import('..').NumberLiteralType<number>, GenericGroupedKind> | Extract<import('..').StringLiteralType<string>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/date-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/null-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/time-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/undefined-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", bigint>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", boolean>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheDate>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", null>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", number>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", string>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheTime>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", undefined>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import('../..').UnionContain<GenericInput, Type<import('..').FundamentalType<symbol, unknown>, unknown, import('..').TypeDefinition>> extends true ? Extract<import('..').BigintType, GenericGroupedKind> | Extract<import('..').BooleanType, GenericGroupedKind> | Extract<import('..').DateType, GenericGroupedKind> | Extract<import('..').NullType, GenericGroupedKind> | Extract<import('..').NumberType, GenericGroupedKind> | Extract<import('..').StringType, GenericGroupedKind> | Extract<import('..').TimeType, GenericGroupedKind> | Extract<import('..').UndefinedType, GenericGroupedKind> | Extract<import('..').BigintLiteralType<bigint>, GenericGroupedKind> | Extract<import('..').BooleanLiteralType<boolean>, GenericGroupedKind> | Extract<import('..').NumberLiteralType<number>, GenericGroupedKind> | Extract<import('..').StringLiteralType<string>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-};
+import { Types } from './types';
+import * as DKind from '../../kind';
+export declare const typeIdentifier: DKind.KindIdentifier<Type<import('..').FundamentalType<unknown>, unknown, import('..').TypeDefinition>, Types>;

package/dist/either/index.cjs

@@ -4,23 +4,25 @@ const require_create = require("./left/create.cjs");
 const require_error = require("./left/error.cjs");
 const require_fail = require("./left/fail.cjs");
 const require_is = require("./left/is.cjs");
+const require_create$1 = require("./right/create.cjs");
+const require_none = require("./left/none.cjs");
+const require_unwrap = require("./left/unwrap.cjs");
+const require_unwrapOrThrow = require("./left/unwrapOrThrow.cjs");
 const require_when = require("./left/when.cjs");
 const require_whenOtherwise = require("./left/whenOtherwise.cjs");
-const require_unwrapOrThrow = require("./left/unwrapOrThrow.cjs");
-const require_unwrap = require("./left/unwrap.cjs");
-const require_create$1 = require("./right/create.cjs");
+const require_asyncGroup = require("./right/asyncGroup.cjs");
 const require_success = require("./right/success.cjs");
 const require_is$1 = require("./right/is.cjs");
 const require_asyncPipe = require("./right/asyncPipe.cjs");
+const require_when$1 = require("./right/when.cjs");
+const require_group = require("./right/group.cjs");
 const require_ok = require("./right/ok.cjs");
 const require_pipe = require("./right/pipe.cjs");
-const require_when$1 = require("./right/when.cjs");
-const require_whenOtherwise$1 = require("./right/whenOtherwise.cjs");
 const require_result = require("./right/result.cjs");
-const require_unwrapOrThrow$1 = require("./right/unwrapOrThrow.cjs");
+const require_some = require("./right/some.cjs");
 const require_unwrap$1 = require("./right/unwrap.cjs");
-const require_group = require("./right/group.cjs");
-const require_asyncGroup = require("./right/asyncGroup.cjs");
+const require_unwrapOrThrow$1 = require("./right/unwrapOrThrow.cjs");
+const require_whenOtherwise$1 = require("./right/whenOtherwise.cjs");
 const require_whenHasInformation = require("./whenHasInformation.cjs");
 const require_whenHasInformationOtherwise = require("./whenHasInformationOtherwise.cjs");
 const require_whenIsSelected = require("./whenIsSelected.cjs");
@@ -30,12 +32,16 @@ const require_asyncSafeCallback = require("./asyncSafeCallback.cjs");
 const require_expect = require("./expect.cjs");
 const require_matchInformation = require("./matchInformation.cjs");
 const require_matchInformationOtherwise = require("./matchInformationOtherwise.cjs");
+const require_rewriteInformation = require("./rewriteInformation.cjs");
+const require_toMaybe = require("./toMaybe.cjs");
 const require_unwrapSelection = require("./unwrapSelection.cjs");
 const require_unwrapSelectionOrThrow = require("./unwrapSelectionOrThrow.cjs");
 const require_forwardAssertsSelection = require("./forwardAssertsSelection.cjs");
 const require_hasInformation = require("./hasInformation.cjs");
 const require_unwrapByInformation = require("./unwrapByInformation.cjs");
 const require_unwrapByInformationOrThrow = require("./unwrapByInformationOrThrow.cjs");
+const require_unwrapOr = require("./unwrapOr.cjs");
+const require_unwrapOtherwise = require("./unwrapOtherwise.cjs");
 const require_keepAsRightByInformation = require("./keepAsRightByInformation.cjs");
 const require_keepAsRightSelection = require("./keepAsRightSelection.cjs");
 //#region scripts/either/index.ts
@@ -65,21 +71,29 @@ var either_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	leftKind: () => require_create.leftKind,
 	matchInformation: () => require_matchInformation.matchInformation,
 	matchInformationOtherwise: () => require_matchInformationOtherwise.matchInformationOtherwise,
+	none: () => require_none.none,
+	noneKind: () => require_none.noneKind,
 	ok: () => require_ok.ok,
 	okKind: () => require_ok.okKind,
 	result: () => require_result.result,
 	resultKind: () => require_result.resultKind,
+	rewriteInformation: () => require_rewriteInformation.rewriteInformation,
 	right: () => require_create$1.right,
 	rightAsyncPipe: () => require_asyncPipe.rightAsyncPipe,
 	rightKind: () => require_create$1.rightKind,
 	rightPipe: () => require_pipe.rightPipe,
 	safeCallback: () => require_safeCallback.safeCallback,
+	some: () => require_some.some,
+	someKind: () => require_some.someKind,
 	success: () => require_success.success,
 	successKind: () => require_success.successKind,
+	toMaybe: () => require_toMaybe.toMaybe,
 	unwrapByInformation: () => require_unwrapByInformation.unwrapByInformation,
 	unwrapByInformationOrThrow: () => require_unwrapByInformationOrThrow.unwrapByInformationOrThrow,
 	unwrapLeft: () => require_unwrap.unwrapLeft,
 	unwrapLeftOrThrow: () => require_unwrapOrThrow.unwrapLeftOrThrow,
+	unwrapOr: () => require_unwrapOr.unwrapOr,
+	unwrapOtherwise: () => require_unwrapOtherwise.unwrapOtherwise,
 	unwrapRight: () => require_unwrap$1.unwrapRight,
 	unwrapRightOrThrow: () => require_unwrapOrThrow$1.unwrapRightOrThrow,
 	unwrapSelection: () => require_unwrapSelection.unwrapSelection,
@@ -126,21 +140,29 @@ exports.left = require_create.left;
 exports.leftKind = require_create.leftKind;
 exports.matchInformation = require_matchInformation.matchInformation;
 exports.matchInformationOtherwise = require_matchInformationOtherwise.matchInformationOtherwise;
+exports.none = require_none.none;
+exports.noneKind = require_none.noneKind;
 exports.ok = require_ok.ok;
 exports.okKind = require_ok.okKind;
 exports.result = require_result.result;
 exports.resultKind = require_result.resultKind;
+exports.rewriteInformation = require_rewriteInformation.rewriteInformation;
 exports.right = require_create$1.right;
 exports.rightAsyncPipe = require_asyncPipe.rightAsyncPipe;
 exports.rightKind = require_create$1.rightKind;
 exports.rightPipe = require_pipe.rightPipe;
 exports.safeCallback = require_safeCallback.safeCallback;
+exports.some = require_some.some;
+exports.someKind = require_some.someKind;
 exports.success = require_success.success;
 exports.successKind = require_success.successKind;
+exports.toMaybe = require_toMaybe.toMaybe;
 exports.unwrapByInformation = require_unwrapByInformation.unwrapByInformation;
 exports.unwrapByInformationOrThrow = require_unwrapByInformationOrThrow.unwrapByInformationOrThrow;
 exports.unwrapLeft = require_unwrap.unwrapLeft;
 exports.unwrapLeftOrThrow = require_unwrapOrThrow.unwrapLeftOrThrow;
+exports.unwrapOr = require_unwrapOr.unwrapOr;
+exports.unwrapOtherwise = require_unwrapOtherwise.unwrapOtherwise;
 exports.unwrapRight = require_unwrap$1.unwrapRight;
 exports.unwrapRightOrThrow = require_unwrapOrThrow$1.unwrapRightOrThrow;
 exports.unwrapSelection = require_unwrapSelection.unwrapSelection;

package/dist/either/index.d.ts

@@ -11,11 +11,15 @@ export * from './asyncSafeCallback';
 export * from './expect';
 export * from './matchInformation';
 export * from './matchInformationOtherwise';
+export * from './rewriteInformation';
+export * from './toMaybe';
 export * from './unwrapSelection';
 export * from './unwrapSelectionOrThrow';
 export * from './forwardAssertsSelection';
 export * from './hasInformation';
 export * from './unwrapByInformation';
 export * from './unwrapByInformationOrThrow';
+export * from './unwrapOr';
+export * from './unwrapOtherwise';
 export * from './keepAsRightByInformation';
 export * from './keepAsRightSelection';

package/dist/either/index.mjs

@@ -4,23 +4,25 @@ import { left, leftKind } from "./left/create.mjs";
 import { error, errorKind } from "./left/error.mjs";
 import { fail, failKind } from "./left/fail.mjs";
 import { isLeft } from "./left/is.mjs";
+import { right, rightKind } from "./right/create.mjs";
+import { none, noneKind } from "./left/none.mjs";
+import { unwrapLeft } from "./left/unwrap.mjs";
+import { NotLeftError, unwrapLeftOrThrow } from "./left/unwrapOrThrow.mjs";
 import { whenIsLeft } from "./left/when.mjs";
 import { whenIsLeftOtherwise } from "./left/whenOtherwise.mjs";
-import { NotLeftError, unwrapLeftOrThrow } from "./left/unwrapOrThrow.mjs";
-import { unwrapLeft } from "./left/unwrap.mjs";
-import { right, rightKind } from "./right/create.mjs";
+import { asyncGroup } from "./right/asyncGroup.mjs";
 import { success, successKind } from "./right/success.mjs";
 import { isRight } from "./right/is.mjs";
 import { rightAsyncPipe } from "./right/asyncPipe.mjs";
+import { whenIsRight } from "./right/when.mjs";
+import { group } from "./right/group.mjs";
 import { ok, okKind } from "./right/ok.mjs";
 import { rightPipe } from "./right/pipe.mjs";
-import { whenIsRight } from "./right/when.mjs";
-import { whenIsRightOtherwise } from "./right/whenOtherwise.mjs";
 import { result, resultKind } from "./right/result.mjs";
-import { NotRightError, unwrapRightOrThrow } from "./right/unwrapOrThrow.mjs";
+import { some, someKind } from "./right/some.mjs";
 import { unwrapRight } from "./right/unwrap.mjs";
-import { group } from "./right/group.mjs";
-import { asyncGroup } from "./right/asyncGroup.mjs";
+import { NotRightError, unwrapRightOrThrow } from "./right/unwrapOrThrow.mjs";
+import { whenIsRightOtherwise } from "./right/whenOtherwise.mjs";
 import { whenHasInformation } from "./whenHasInformation.mjs";
 import { whenHasInformationOtherwise } from "./whenHasInformationOtherwise.mjs";
 import { whenIsSelected } from "./whenIsSelected.mjs";
@@ -30,12 +32,16 @@ import { asyncSafeCallback } from "./asyncSafeCallback.mjs";
 import { expect } from "./expect.mjs";
 import { matchInformation } from "./matchInformation.mjs";
 import { matchInformationOtherwise } from "./matchInformationOtherwise.mjs";
+import { rewriteInformation } from "./rewriteInformation.mjs";
+import { toMaybe } from "./toMaybe.mjs";
 import { unwrapSelection } from "./unwrapSelection.mjs";
 import { HasNotSelectedInformationError, unwrapSelectionOrThrow } from "./unwrapSelectionOrThrow.mjs";
 import { ForwardAssertsSelectionError, forwardAssertsSelection } from "./forwardAssertsSelection.mjs";
 import { hasInformation } from "./hasInformation.mjs";
 import { unwrapByInformation } from "./unwrapByInformation.mjs";
 import { HasNotInformationError, unwrapByInformationOrThrow } from "./unwrapByInformationOrThrow.mjs";
+import { unwrapOr } from "./unwrapOr.mjs";
+import { unwrapOtherwise } from "./unwrapOtherwise.mjs";
 import { keepAsRightByInformation } from "./keepAsRightByInformation.mjs";
 import { keepAsRightSelection } from "./keepAsRightSelection.mjs";
 //#region scripts/either/index.ts
@@ -65,21 +71,29 @@ var either_exports = /* @__PURE__ */ __exportAll({
 	leftKind: () => leftKind,
 	matchInformation: () => matchInformation,
 	matchInformationOtherwise: () => matchInformationOtherwise,
+	none: () => none,
+	noneKind: () => noneKind,
 	ok: () => ok,
 	okKind: () => okKind,
 	result: () => result,
 	resultKind: () => resultKind,
+	rewriteInformation: () => rewriteInformation,
 	right: () => right,
 	rightAsyncPipe: () => rightAsyncPipe,
 	rightKind: () => rightKind,
 	rightPipe: () => rightPipe,
 	safeCallback: () => safeCallback,
+	some: () => some,
+	someKind: () => someKind,
 	success: () => success,
 	successKind: () => successKind,
+	toMaybe: () => toMaybe,
 	unwrapByInformation: () => unwrapByInformation,
 	unwrapByInformationOrThrow: () => unwrapByInformationOrThrow,
 	unwrapLeft: () => unwrapLeft,
 	unwrapLeftOrThrow: () => unwrapLeftOrThrow,
+	unwrapOr: () => unwrapOr,
+	unwrapOtherwise: () => unwrapOtherwise,
 	unwrapRight: () => unwrapRight,
 	unwrapRightOrThrow: () => unwrapRightOrThrow,
 	unwrapSelection: () => unwrapSelection,
@@ -95,4 +109,4 @@ var either_exports = /* @__PURE__ */ __exportAll({
 	whenIsSelectedOtherwise: () => whenIsSelectedOtherwise
 });
 //#endregion
-export { ForwardAssertsSelectionError, HasNotInformationError, HasNotSelectedInformationError, NotLeftError, NotRightError, asyncGroup, asyncSafeCallback, createKind, either_exports, error, errorKind, expect, fail, failKind, forwardAssertsSelection, group, hasInformation, informationKind, isLeft, isRight, keepAsRightByInformation, keepAsRightSelection, left, leftKind, matchInformation, matchInformationOtherwise, ok, okKind, result, resultKind, right, rightAsyncPipe, rightKind, rightPipe, safeCallback, success, successKind, unwrapByInformation, unwrapByInformationOrThrow, unwrapLeft, unwrapLeftOrThrow, unwrapRight, unwrapRightOrThrow, unwrapSelection, unwrapSelectionOrThrow, valueKind, whenHasInformation, whenHasInformationOtherwise, whenIsLeft, whenIsLeftOtherwise, whenIsRight, whenIsRightOtherwise, whenIsSelected, whenIsSelectedOtherwise };
+export { ForwardAssertsSelectionError, HasNotInformationError, HasNotSelectedInformationError, NotLeftError, NotRightError, asyncGroup, asyncSafeCallback, createKind, either_exports, error, errorKind, expect, fail, failKind, forwardAssertsSelection, group, hasInformation, informationKind, isLeft, isRight, keepAsRightByInformation, keepAsRightSelection, left, leftKind, matchInformation, matchInformationOtherwise, none, noneKind, ok, okKind, result, resultKind, rewriteInformation, right, rightAsyncPipe, rightKind, rightPipe, safeCallback, some, someKind, success, successKind, toMaybe, unwrapByInformation, unwrapByInformationOrThrow, unwrapLeft, unwrapLeftOrThrow, unwrapOr, unwrapOtherwise, unwrapRight, unwrapRightOrThrow, unwrapSelection, unwrapSelectionOrThrow, valueKind, whenHasInformation, whenHasInformationOtherwise, whenIsLeft, whenIsLeftOtherwise, whenIsRight, whenIsRightOtherwise, whenIsSelected, whenIsSelectedOtherwise };

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

@@ -2,7 +2,8 @@ export * from './create';
 export * from './error';
 export * from './fail';
 export * from './is';
+export * from './none';
+export * from './unwrap';
+export * from './unwrapOrThrow';
 export * from './when';
 export * from './whenOtherwise';
-export * from './unwrapOrThrow';
-export * from './unwrap';

package/dist/either/left/none.cjs

@@ -0,0 +1,15 @@
+const require_kind = require("../kind.cjs");
+const require_create = require("../right/create.cjs");
+//#region scripts/either/left/none.ts
+const noneKind = require_kind.createKind("none");
+function none() {
+	return {
+		[require_create.rightKind.runTimeKey]: null,
+		[require_kind.informationKind.runTimeKey]: "none",
+		[require_kind.valueKind.runTimeKey]: null,
+		[noneKind.runTimeKey]: null
+	};
+}
+//#endregion
+exports.none = none;
+exports.noneKind = noneKind;

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

@@ -0,0 +1,7 @@
+import { Right } from '../right/create';
+import type * as DKind from '../../kind';
+import type * as DCommon from '../../common';
+export declare const noneKind: DKind.Handler<DKind.Definition<"@DuplojsLangEither/none", unknown>>;
+export interface None extends DCommon.Forward<DKind.Kind<typeof noneKind> & Right<"none", null>> {
+}
+export declare function none(): None;

package/dist/either/left/none.mjs

@@ -0,0 +1,14 @@
+import { createKind, informationKind, valueKind } from "../kind.mjs";
+import { rightKind } from "../right/create.mjs";
+//#region scripts/either/left/none.ts
+const noneKind = createKind("none");
+function none() {
+	return {
+		[rightKind.runTimeKey]: null,
+		[informationKind.runTimeKey]: "none",
+		[valueKind.runTimeKey]: null,
+		[noneKind.runTimeKey]: null
+	};
+}
+//#endregion
+export { none, noneKind };

package/dist/either/matchInformationOtherwise.d.ts

@@ -11,5 +11,5 @@ type ComputeMatcher<GenericEither extends Either> = Extract<{
 }, any>;
 type ForbiddenMoreKey<GenericInput extends unknown, GenericMatcher extends ComputeMatcher<Extract<GenericInput, Either>>> = DObject.ForbiddenKey<GenericMatcher, Extract<Exclude<keyof GenericMatcher, GetInformation<Extract<GenericInput, Either>>>, string>>;
 export declare function matchInformationOtherwise<GenericInput extends unknown, GenericMatcher extends ComputeMatcher<Extract<GenericInput, Either>>, GenericOutput extends unknown, GenericError extends ForbiddenMoreKey<GenericInput, GenericMatcher>>(matcher: (ComputeMatcher<Extract<NoInfer<GenericInput>, Either>> & GenericMatcher & NoInfer<GenericError>), otherwise: (value: Exclude<GenericInput, DKind.Kind<typeof informationKind, Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, string>>>) => GenericOutput): (input: GenericInput) => (ReturnType<NoInfer<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>>> | GenericOutput);
-export declare function matchInformationOtherwise<GenericInput extends unknown, GenericMatcher extends ComputeMatcher<Extract<GenericInput, Either>>, GenericOutput extends unknown>(input: GenericInput, matcher: DCommon.FixDeepFunctionInfer<ComputeMatcher<Extract<GenericInput, Either>>, GenericMatcher> & ForbiddenMoreKey<GenericInput, GenericMatcher>, otherwise: (value: Exclude<GenericInput, DKind.Kind<typeof informationKind, Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, string>>>) => GenericOutput): (ReturnType<NoInfer<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>>> | GenericOutput);
+export declare function matchInformationOtherwise<GenericInput extends unknown, GenericMatcher extends ComputeMatcher<Extract<GenericInput, Either>>, GenericOutput extends unknown>(input: GenericInput, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<Extract<GenericInput, Either>>, GenericMatcher> & ForbiddenMoreKey<GenericInput, GenericMatcher> & DObject.ForbiddenUndefinedProps<GenericMatcher>), otherwise: (value: Exclude<GenericInput, DKind.Kind<typeof informationKind, Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, string>>>) => GenericOutput): (ReturnType<NoInfer<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>>> | GenericOutput);
 export {};

package/dist/either/rewriteInformation.cjs

@@ -0,0 +1,22 @@
+const require_kind = require("./kind.cjs");
+const require_create = require("./left/create.cjs");
+const require_is = require("./left/is.cjs");
+const require_create$1 = require("./right/create.cjs");
+const require_is$1 = require("./right/is.cjs");
+//#region scripts/either/rewriteInformation.ts
+function rewriteInformation(...args) {
+	if (args.length === 1) {
+		const [matcher] = args;
+		return (input) => rewriteInformation(input, matcher);
+	}
+	const [input, matcher] = args;
+	const inputIsRight = require_is$1.isRight(input);
+	if (!inputIsRight && !require_is.isLeft(input)) return input;
+	const information = matcher[require_kind.informationKind.getValue(input)];
+	if (information === void 0) return input;
+	const value = require_kind.valueKind.getValue(input);
+	if (inputIsRight) return require_create$1.right(information, value);
+	return require_create.left(information, value);
+}
+//#endregion
+exports.rewriteInformation = rewriteInformation;

package/dist/either/rewriteInformation.d.ts

@@ -0,0 +1,14 @@
+import { Left } from './left';
+import { Right } from './right';
+import { GetInformation, GetValue } from './types';
+import type * as DCommon from '../common';
+import type * as DObject from '../object';
+type Either = Right | Left;
+type ComputeMatcher<GenericInput extends unknown> = {
+    [Prop in GetInformation<Extract<GenericInput, Either>>]?: string;
+};
+type ForbiddenMoreKey<GenericInput extends unknown, GenericMatcher extends ComputeMatcher<GenericInput>> = DObject.ForbiddenKey<GenericMatcher, Extract<Exclude<keyof GenericMatcher, GetInformation<Extract<GenericInput, Either>>>, string>>;
+type ComputeResult<GenericInput extends unknown, GenericMatcher extends ComputeMatcher<GenericInput>> = GenericInput extends Right ? GetInformation<GenericInput> extends keyof GenericMatcher ? Right<Extract<GenericMatcher[GetInformation<GenericInput>], string>, GetValue<GenericInput>> : GenericInput : GenericInput extends Left ? GetInformation<GenericInput> extends keyof GenericMatcher ? Left<Extract<GenericMatcher[GetInformation<GenericInput>], string>, GetValue<GenericInput>> : GenericInput : GenericInput;
+export declare function rewriteInformation<GenericInput extends Either | DCommon.AnyValue, const GenericMatcher extends ComputeMatcher<GenericInput>>(matcher: (GenericMatcher & ForbiddenMoreKey<GenericInput, GenericMatcher> & DObject.ForbiddenUndefinedProps<GenericMatcher>)): (input: GenericInput) => ComputeResult<GenericInput, GenericMatcher>;
+export declare function rewriteInformation<GenericInput extends Either | DCommon.AnyValue, const GenericMatcher extends ComputeMatcher<GenericInput>>(input: GenericInput, matcher: (GenericMatcher & ForbiddenMoreKey<GenericInput, GenericMatcher> & DObject.ForbiddenUndefinedProps<GenericMatcher>)): ComputeResult<GenericInput, GenericMatcher>;
+export {};

package/dist/either/rewriteInformation.mjs

@@ -0,0 +1,22 @@
+import { informationKind, valueKind } from "./kind.mjs";
+import { left } from "./left/create.mjs";
+import { isLeft } from "./left/is.mjs";
+import { right } from "./right/create.mjs";
+import { isRight } from "./right/is.mjs";
+//#region scripts/either/rewriteInformation.ts
+function rewriteInformation(...args) {
+	if (args.length === 1) {
+		const [matcher] = args;
+		return (input) => rewriteInformation(input, matcher);
+	}
+	const [input, matcher] = args;
+	const inputIsRight = isRight(input);
+	if (!inputIsRight && !isLeft(input)) return input;
+	const information = matcher[informationKind.getValue(input)];
+	if (information === void 0) return input;
+	const value = valueKind.getValue(input);
+	if (inputIsRight) return right(information, value);
+	return left(information, value);
+}
+//#endregion
+export { rewriteInformation };

package/dist/either/right/asyncGroup.cjs

@@ -1,10 +1,10 @@
 const require_asyncPipe = require("../../common/asyncPipe.cjs");
 const require_entries = require("../../object/entries.cjs");
 const require_is = require("../left/is.cjs");
-const require_success = require("./success.cjs");
-const require_when = require("./when.cjs");
 const require_reduce = require("../../generator/reduce.cjs");
 const require_asyncReduce = require("../../generator/asyncReduce.cjs");
+const require_success = require("./success.cjs");
+const require_when = require("./when.cjs");
 const require_isType = require("../../common/isType.cjs");
 const require_when$1 = require("../../common/when.cjs");
 const require_whenNot = require("../../common/whenNot.cjs");

package/dist/either/right/asyncGroup.mjs

@@ -1,10 +1,10 @@
 import { asyncPipe } from "../../common/asyncPipe.mjs";
 import { entries } from "../../object/entries.mjs";
 import { isLeft } from "../left/is.mjs";
-import { success } from "./success.mjs";
-import { whenIsRight } from "./when.mjs";
 import { reduceFrom } from "../../generator/reduce.mjs";
 import { asyncReduce } from "../../generator/asyncReduce.mjs";
+import { success } from "./success.mjs";
+import { whenIsRight } from "./when.mjs";
 import { isType } from "../../common/isType.mjs";
 import { when } from "../../common/when.mjs";
 import { whenNot } from "../../common/whenNot.mjs";

package/dist/either/right/group.cjs

@@ -1,8 +1,8 @@
 const require_entries = require("../../object/entries.cjs");
 const require_is = require("../left/is.cjs");
+const require_reduce = require("../../array/reduce.cjs");
 const require_success = require("./success.cjs");
 const require_when = require("./when.cjs");
-const require_reduce = require("../../array/reduce.cjs");
 const require_isType = require("../../common/isType.cjs");
 const require_pipe = require("../../common/pipe.cjs");
 const require_when$1 = require("../../common/when.cjs");