@duplojs/lang 0.0.0 → 0.0.1-beta.10

package/dist/dataStructure/structure/types/value.d.ts

@@ -2,4 +2,4 @@ import { structureKind, Structure } from '../base';
 import { StructureConstraintsValue } from './constraintsValue';
 import type * as DKind from '../../../kind';
 export type StructureValue<GenericStructure extends Structure> = DKind.GetValue<typeof structureKind, GenericStructure>;
-export type StructureInitialValue<GenericStructure extends Structure> = GenericStructure extends Structure<infer InferredValue> ? InferredValue extends (infer InferredInitialValue) & StructureConstraintsValue<GenericStructure["definition"]["constraints"][number]> ? InferredInitialValue : InferredValue : never;
+export type StructureInitialValue<GenericStructure extends Structure, GenericStructureValue = StructureValue<GenericStructure>> = GenericStructureValue extends unknown ? GenericStructureValue extends (infer InferredInitialValue) & StructureConstraintsValue<GenericStructure["definition"]["constraints"][number]> ? InferredInitialValue : GenericStructureValue : never;

package/dist/dataStructure/type/base.cjs

@@ -1,20 +1,33 @@
 const require_callThen = require("../../common/callThen.cjs");
+const require_simpleClone = require("../../common/simpleClone.cjs");
 const require_kind = require("../kind.cjs");
 const require_resultSymbol = require("../common/resultSymbol.cjs");
 //#region scripts/dataStructure/type/base.ts
 const typeKind = require_kind.createKind("type");
 function createType(fundamentalType, kindHandler, createConstructor) {
-	return createConstructor({ init: (definition, { executeCheck, isAsynchronous }) => {
+	const init = (definition, { executeCheck, isAsynchronous }) => {
 		const self = {
+			fundamentalType,
 			definition,
-			executeCheck: (data, errorHandler) => require_callThen.callThen(self.fundamentalType.executeCheck(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : executeCheck(self, data, errorHandler)),
+			executeCheck: (data) => require_callThen.callThen(self.fundamentalType.executeCheck(data), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : executeCheck(self, data)),
 			isAsynchronous: () => isAsynchronous(self),
-			fundamentalType,
+			clone: () => init(require_simpleClone.simpleClone(definition), {
+				executeCheck,
+				isAsynchronous
+			}),
+			setMessage: (message) => {
+				self.definition.message = message;
+				return self;
+			},
+			addMessage: (message) => {
+				return self.clone().setMessage(message);
+			},
 			[typeKind.runTimeKey]: null,
 			[kindHandler.runTimeKey]: null
 		};
 		return self;
-	} });
+	};
+	return createConstructor({ init });
 }
 //#endregion
 exports.createType = createType;

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

@@ -1,18 +1,22 @@
 import { FundamentalType, FundamentalTypeValue } from '../fundamentalType';
-import { ErrorSymbol, GetErrorHandler, SuccessSymbol } from '../common';
+import { ErrorSymbol, SuccessSymbol } from '../common';
 import type * as DKind from '../../kind';
 import * as DCommon from '../../common';
 export declare const typeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", unknown>>;
 export interface TypeDefinition {
+    readonly message?: string;
 }
 export interface Type<GenericFundamentalType extends FundamentalType = FundamentalType, GenericValue extends FundamentalTypeValue<GenericFundamentalType> = FundamentalTypeValue<GenericFundamentalType>, GenericDefinition extends TypeDefinition = TypeDefinition> extends DKind.Kind<typeof typeKind, GenericValue> {
     readonly fundamentalType: GenericFundamentalType;
     readonly definition: GenericDefinition;
-    executeCheck(data: unknown, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
+    executeCheck(data: unknown): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     isAsynchronous(): boolean;
+    clone(): this;
+    setMessage(massage: string): this;
+    addMessage(massage: string): this;
 }
 export interface CreateTypeInitParams<GenericType extends Type = Type, GenericFundamentalType extends FundamentalType = FundamentalType> {
-    executeCheck(self: GenericType, data: FundamentalTypeValue<GenericFundamentalType>, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
+    executeCheck(self: GenericType, data: FundamentalTypeValue<GenericFundamentalType>): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     isAsynchronous(self: GenericType): boolean;
 }
 export interface CreateTypeConstructorParams<GenericFundamentalType extends FundamentalType = FundamentalType, GenericKindHandler extends DKind.Handler = DKind.Handler> {

package/dist/dataStructure/type/base.mjs

@@ -1,20 +1,33 @@
 import { callThen } from "../../common/callThen.mjs";
+import { simpleClone } from "../../common/simpleClone.mjs";
 import { createKind } from "../kind.mjs";
 import { ErrorSymbol } from "../common/resultSymbol.mjs";
 //#region scripts/dataStructure/type/base.ts
 const typeKind = createKind("type");
 function createType(fundamentalType, kindHandler, createConstructor) {
-	return createConstructor({ init: (definition, { executeCheck, isAsynchronous }) => {
+	const init = (definition, { executeCheck, isAsynchronous }) => {
 		const self = {
+			fundamentalType,
 			definition,
-			executeCheck: (data, errorHandler) => callThen(self.fundamentalType.executeCheck(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : executeCheck(self, data, errorHandler)),
+			executeCheck: (data) => callThen(self.fundamentalType.executeCheck(data), (result) => result === ErrorSymbol ? ErrorSymbol : executeCheck(self, data)),
 			isAsynchronous: () => isAsynchronous(self),
-			fundamentalType,
+			clone: () => init(simpleClone(definition), {
+				executeCheck,
+				isAsynchronous
+			}),
+			setMessage: (message) => {
+				self.definition.message = message;
+				return self;
+			},
+			addMessage: (message) => {
+				return self.clone().setMessage(message);
+			},
 			[typeKind.runTimeKey]: null,
 			[kindHandler.runTimeKey]: null
 		};
 		return self;
-	} });
+	};
+	return createConstructor({ init });
 }
 //#endregion
 export { createType, typeKind };

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

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

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 };