@duplojs/lang 0.0.1-beta.9 → 0.1.0-beta.1

package/dist/dataStructure/structure/defaults/record.cjs

@@ -1,4 +1,5 @@
 const require_callThen = require("../../../common/callThen.cjs");
+const require_isSimple = require("../../../object/isSimple.cjs");
 const require_isType = require("../../../common/isType.cjs");
 const require_memo = require("../../../common/memo.cjs");
 const require_kind = require("../../kind.cjs");
@@ -26,7 +27,7 @@ const RecordStructure = require_base.createStructure(recordStructureKind, ({ ini
 	})
 }, {
 	executeCheck: (self, data, errorHandler) => {
-		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
+		if (!require_isSimple.isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const keyData = Object.keys(data);
 		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
@@ -38,31 +39,43 @@ const RecordStructure = require_base.createStructure(recordStructureKind, ({ ini
 		});
 	},
 	executeEncode: (self, codecContext, data, errorHandler) => {
-		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
+		if (!require_isSimple.isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const keyData = Object.keys(data);
 		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		const encodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? require_callThen.callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? require_callThen.callThen(self.definition.value.executeEncode(codecContext, data[key], errorHandler), (encodedValue) => {
+		const encodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => key === "__proto__" ? accumulator : require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? require_callThen.callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? require_callThen.callThen(self.definition.value.executeEncode(codecContext, data[key], errorHandler), (encodedValue) => {
 			if (keyResult === require_resultSymbol.ErrorSymbol || encodedValue === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
-			awaitedAccumulator[key] = encodedValue;
+			if (encodedValue !== void 0) awaitedAccumulator[key] = encodedValue;
 			return awaitedAccumulator;
 		}))), {});
 		return require_callThen.callThen(encodedData, (awaitedEncodedData) => pathStage?.close() ?? (awaitedEncodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedEncodedData)));
 	},
 	executeDecode: (self, codecContext, data, errorHandler) => {
-		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
+		if (!require_isSimple.isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const keyData = Object.keys(data);
 		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		const decodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? require_callThen.callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? require_callThen.callThen(self.definition.value.executeDecode(codecContext, data[key], errorHandler), (decodedValue) => {
+		const decodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => key === "__proto__" ? accumulator : require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? require_callThen.callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? require_callThen.callThen(self.definition.value.executeDecode(codecContext, data[key], errorHandler), (decodedValue) => {
 			if (keyResult === require_resultSymbol.ErrorSymbol || decodedValue === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
-			awaitedAccumulator[key] = decodedValue;
+			if (decodedValue !== void 0) awaitedAccumulator[key] = decodedValue;
 			return awaitedAccumulator;
 		}))), {});
 		return require_callThen.callThen(decodedData, (awaitedDecodedData) => pathStage?.close() ?? (awaitedDecodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedDecodedData)));
 	},
+	executeParse: (self, codecContext, data, errorHandler) => {
+		if (!require_isSimple.isSimple(data)) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
+		const keyData = Object.keys(data);
+		const requiredKeys = self.definition.requiredKeys.value;
+		const pathStage = errorHandler?.().createPathStage();
+		const parsedData = (requiredKeys ?? keyData).reduce((accumulator, key) => key === "__proto__" ? accumulator : require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? require_callThen.callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? require_callThen.callThen(self.definition.value.executeParse(codecContext, data[key], errorHandler), (parsedValue) => {
+			if (keyResult === require_resultSymbol.ErrorSymbol || parsedValue === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
+			if (parsedValue !== void 0) awaitedAccumulator[key] = parsedValue;
+			return awaitedAccumulator;
+		}))), {});
+		return require_callThen.callThen(parsedData, (awaitedParsedData) => pathStage?.close() ?? (awaitedParsedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedParsedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedParsedData)));
+	},
 	isAsynchronous: (self) => self.definition.key.isAsynchronous() || self.definition.value.isAsynchronous()
 }));
 //#endregion

package/dist/dataStructure/structure/defaults/record.mjs

@@ -1,4 +1,5 @@
 import { callThen } from "../../../common/callThen.mjs";
+import { isSimple } from "../../../object/isSimple.mjs";
 import { isType } from "../../../common/isType.mjs";
 import { memo } from "../../../common/memo.mjs";
 import { createKind } from "../../kind.mjs";
@@ -26,7 +27,7 @@ const RecordStructure = createStructure(recordStructureKind, ({ init }) => (key,
 	})
 }, {
 	executeCheck: (self, data, errorHandler) => {
-		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
+		if (!isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const keyData = Object.keys(data);
 		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
@@ -38,31 +39,43 @@ const RecordStructure = createStructure(recordStructureKind, ({ init }) => (key,
 		});
 	},
 	executeEncode: (self, codecContext, data, errorHandler) => {
-		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
+		if (!isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const keyData = Object.keys(data);
 		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		const encodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? callThen(self.definition.value.executeEncode(codecContext, data[key], errorHandler), (encodedValue) => {
+		const encodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => key === "__proto__" ? accumulator : callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? callThen(self.definition.value.executeEncode(codecContext, data[key], errorHandler), (encodedValue) => {
 			if (keyResult === ErrorSymbol || encodedValue === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
-			awaitedAccumulator[key] = encodedValue;
+			if (encodedValue !== void 0) awaitedAccumulator[key] = encodedValue;
 			return awaitedAccumulator;
 		}))), {});
 		return callThen(encodedData, (awaitedEncodedData) => pathStage?.close() ?? (awaitedEncodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedEncodedData)));
 	},
 	executeDecode: (self, codecContext, data, errorHandler) => {
-		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
+		if (!isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const keyData = Object.keys(data);
 		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		const decodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? callThen(self.definition.value.executeDecode(codecContext, data[key], errorHandler), (decodedValue) => {
+		const decodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => key === "__proto__" ? accumulator : callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? callThen(self.definition.value.executeDecode(codecContext, data[key], errorHandler), (decodedValue) => {
 			if (keyResult === ErrorSymbol || decodedValue === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
-			awaitedAccumulator[key] = decodedValue;
+			if (decodedValue !== void 0) awaitedAccumulator[key] = decodedValue;
 			return awaitedAccumulator;
 		}))), {});
 		return callThen(decodedData, (awaitedDecodedData) => pathStage?.close() ?? (awaitedDecodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedDecodedData)));
 	},
+	executeParse: (self, codecContext, data, errorHandler) => {
+		if (!isSimple(data)) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
+		const keyData = Object.keys(data);
+		const requiredKeys = self.definition.requiredKeys.value;
+		const pathStage = errorHandler?.().createPathStage();
+		const parsedData = (requiredKeys ?? keyData).reduce((accumulator, key) => key === "__proto__" ? accumulator : callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? callThen(self.definition.value.executeParse(codecContext, data[key], errorHandler), (parsedValue) => {
+			if (keyResult === ErrorSymbol || parsedValue === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
+			if (parsedValue !== void 0) awaitedAccumulator[key] = parsedValue;
+			return awaitedAccumulator;
+		}))), {});
+		return callThen(parsedData, (awaitedParsedData) => pathStage?.close() ?? (awaitedParsedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedParsedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedParsedData)));
+	},
 	isAsynchronous: (self) => self.definition.key.isAsynchronous() || self.definition.value.isAsynchronous()
 }));
 //#endregion

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

@@ -18,6 +18,7 @@ const TypeStructure = require_base.createStructure(typeStructureKind, ({ init })
 		const codec = codecContext.get(self.definition.type.fundamentalType);
 		return require_callThen.callThen(codec ? codec.decode(data, errorHandler) : data, (decodedData) => decodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeCheck(decodedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : decodedData));
 	},
+	executeParse: (self, codecContext, data, errorHandler) => self.executeDecode(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.type.isAsynchronous()
 }));
 //#endregion

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

@@ -18,6 +18,7 @@ const TypeStructure = createStructure(typeStructureKind, ({ init }) => (type, co
 		const codec = codecContext.get(self.definition.type.fundamentalType);
 		return callThen(codec ? codec.decode(data, errorHandler) : data, (decodedData) => decodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeCheck(decodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : decodedData));
 	},
+	executeParse: (self, codecContext, data, errorHandler) => self.executeDecode(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.type.isAsynchronous()
 }));
 //#endregion

package/dist/dataStructure/structure/defaults/union.cjs

@@ -2,13 +2,13 @@ const require_callThen = require("../../../common/callThen.cjs");
 const require_memo = require("../../../common/memo.cjs");
 const require_kind = require("../../kind.cjs");
 const require_resultSymbol = require("../../common/resultSymbol.cjs");
-const require_error = require("../../common/error.cjs");
-const require_base = require("../base.cjs");
+const require_base = require("../../common/error/base.cjs");
+const require_base$1 = require("../base.cjs");
 const require_identifier = require("../identifier.cjs");
 const require_lazy = require("./lazy.cjs");
 //#region scripts/dataStructure/structure/defaults/union.ts
 const unionStructureKind = require_kind.createKind("union-structure");
-const UnionStructure = require_base.createStructure(unionStructureKind, ({ init }) => (values, constraints) => init({
+const UnionStructure = require_base$1.createStructure(unionStructureKind, ({ init }) => (values, constraints) => init({
 	values: require_memo.memo(() => values.flatMap((value) => (function flatUnion(structure) {
 		if (require_identifier.structureIdentifier(structure, unionStructureKind)) return structure.definition.values.value.flatMap(flatUnion);
 		if (require_identifier.structureIdentifier(structure, require_lazy.lazyStructureKind)) return flatUnion(structure.definition.getter.value);
@@ -20,7 +20,7 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		const errorHandlers = errorHandler ? [] : void 0;
 		const result = self.definition.values.value.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator === require_resultSymbol.SuccessSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : require_base.createGetErrorHandler(errorHandler().currentPath);
 			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
@@ -40,7 +40,7 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		const errorHandlers = errorHandler ? [] : void 0;
 		const encodedData = self.definition.values.value.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator !== require_resultSymbol.ErrorSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : require_base.createGetErrorHandler(errorHandler().currentPath);
 			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
@@ -60,7 +60,7 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		const errorHandlers = errorHandler ? [] : void 0;
 		const decodedData = self.definition.values.value.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator !== require_resultSymbol.ErrorSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : require_base.createGetErrorHandler(errorHandler().currentPath);
 			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
@@ -76,6 +76,26 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 			return require_callThen.callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedDecodedData);
 		});
 	},
+	executeParse: (self, codecContext, data, errorHandler) => {
+		const errorHandlers = errorHandler ? [] : void 0;
+		const parsedData = self.definition.values.value.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
+			if (awaitedAccumulator !== require_resultSymbol.ErrorSymbol) return awaitedAccumulator;
+			const subErrorHandler = errorHandler === void 0 ? void 0 : require_base.createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
+				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
+				errorHandlers.push(subErrorHandler);
+			}
+			return value.executeParse(codecContext, data, subErrorHandler);
+		}), require_resultSymbol.ErrorSymbol);
+		return require_callThen.callThen(parsedData, (awaitedParsedData) => {
+			if (awaitedParsedData === require_resultSymbol.ErrorSymbol) {
+				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
+				return require_resultSymbol.ErrorSymbol;
+			}
+			return require_callThen.callThen(self.executeConstraints(awaitedParsedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedParsedData);
+		});
+	},
 	isAsynchronous: (self) => self.definition.values.value.some((value) => value.isAsynchronous())
 }));
 //#endregion

package/dist/dataStructure/structure/defaults/union.mjs

@@ -2,7 +2,7 @@ import { callThen } from "../../../common/callThen.mjs";
 import { memo } from "../../../common/memo.mjs";
 import { createKind } from "../../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
-import { createGetErrorHandler } from "../../common/error.mjs";
+import { createGetErrorHandler } from "../../common/error/base.mjs";
 import { createStructure } from "../base.mjs";
 import { structureIdentifier } from "../identifier.mjs";
 import { lazyStructureKind } from "./lazy.mjs";
@@ -76,6 +76,26 @@ const UnionStructure = createStructure(unionStructureKind, ({ init }) => (values
 			return callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedDecodedData);
 		});
 	},
+	executeParse: (self, codecContext, data, errorHandler) => {
+		const errorHandlers = errorHandler ? [] : void 0;
+		const parsedData = self.definition.values.value.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
+			if (awaitedAccumulator !== ErrorSymbol) return awaitedAccumulator;
+			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
+				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
+				errorHandlers.push(subErrorHandler);
+			}
+			return value.executeParse(codecContext, data, subErrorHandler);
+		}), ErrorSymbol);
+		return callThen(parsedData, (awaitedParsedData) => {
+			if (awaitedParsedData === ErrorSymbol) {
+				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
+				return ErrorSymbol;
+			}
+			return callThen(self.executeConstraints(awaitedParsedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedParsedData);
+		});
+	},
 	isAsynchronous: (self) => self.definition.values.value.some((value) => value.isAsynchronous())
 }));
 //#endregion

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

@@ -1,5 +1,7 @@
 import { structureKind, Structure } from '../base';
 import { StructureConstraintsValue } from './constraintsValue';
+import { Constraint } from '../../constraint';
 import type * as DKind from '../../../kind';
 export type StructureValue<GenericStructure extends Structure> = DKind.GetValue<typeof structureKind, GenericStructure>;
 export type StructureInitialValue<GenericStructure extends Structure, GenericStructureValue = StructureValue<GenericStructure>> = GenericStructureValue extends unknown ? GenericStructureValue extends (infer InferredInitialValue) & StructureConstraintsValue<GenericStructure["definition"]["constraints"][number]> ? InferredInitialValue : GenericStructureValue : never;
+export type ComputeStructureValue<GenericValue extends unknown, GenericConstraints extends readonly Constraint[]> = Extract<GenericValue & StructureConstraintsValue<GenericConstraints[number]>, any>;

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

@@ -1,6 +1,7 @@
 import { Type } from '../base';
 import { BigintLiteralType, BigintType, BooleanLiteralType, BooleanType, DateType, NullType, NumberLiteralType, NumberType, StringLiteralType, StringType, TimeType, UndefinedType } from '../defaults';
 export interface TypesStore {
+    base: Type;
     bigint: BigintType;
     bigintLiteral: BigintLiteralType;
     boolean: BooleanType;

package/dist/either/index.cjs

@@ -4,13 +4,13 @@ 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_asyncGroup = require("./right/asyncGroup.cjs");
+const require_create$1 = require("./right/create.cjs");
 const require_success = require("./right/success.cjs");
 const require_is$1 = require("./right/is.cjs");
 const require_asyncPipe = require("./right/asyncPipe.cjs");

package/dist/either/index.mjs

@@ -4,13 +4,13 @@ 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 { asyncGroup } from "./right/asyncGroup.mjs";
+import { right, rightKind } from "./right/create.mjs";
 import { success, successKind } from "./right/success.mjs";
 import { isRight } from "./right/is.mjs";
 import { rightAsyncPipe } from "./right/asyncPipe.mjs";

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

@@ -4,5 +4,6 @@ export declare const leftKind: DKind.Handler<DKind.Definition<"@DuplojsLangEithe
 type _Left<GenericInformation extends string = string, GenericValue extends unknown = unknown> = (DKind.Kind<typeof leftKind> & DKind.Kind<typeof informationKind, GenericInformation> & DKind.Kind<typeof valueKind, GenericValue>);
 export interface Left<GenericInformation extends string = string, GenericValue extends unknown = unknown> extends _Left<GenericInformation, GenericValue> {
 }
-export declare function left<GenericInformation extends string, const GenericValue extends unknown = undefined>(information: GenericInformation, value?: GenericValue): Left<GenericInformation, GenericValue>;
+export declare function left<GenericInformation extends string>(information: GenericInformation): Left<GenericInformation, undefined>;
+export declare function left<GenericInformation extends string, const GenericValue extends unknown>(information: GenericInformation, value: GenericValue): Left<GenericInformation, GenericValue>;
 export {};

package/dist/either/left/none.cjs

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

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

@@ -1,7 +1,7 @@
-import { Right } from '../right/create';
+import { Left } from './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 interface None extends DCommon.Forward<DKind.Kind<typeof noneKind> & Left<"none", null>> {
 }
 export declare function none(): None;

package/dist/either/left/none.mjs

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

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

@@ -4,5 +4,6 @@ export declare const rightKind: DKind.Handler<DKind.Definition<"@DuplojsLangEith
 type _Right<GenericInformation extends string = string, GenericValue extends unknown = unknown> = (DKind.Kind<typeof rightKind> & DKind.Kind<typeof informationKind, GenericInformation> & DKind.Kind<typeof valueKind, GenericValue>);
 export interface Right<GenericInformation extends string = string, GenericValue extends unknown = unknown> extends _Right<GenericInformation, GenericValue> {
 }
-export declare function right<GenericInformation extends string, const GenericValue extends unknown = undefined>(information: GenericInformation, value?: GenericValue): Right<GenericInformation, GenericValue>;
+export declare function right<GenericInformation extends string>(information: GenericInformation): Right<GenericInformation, undefined>;
+export declare function right<GenericInformation extends string, const GenericValue extends unknown>(information: GenericInformation, value: GenericValue): Right<GenericInformation, GenericValue>;
 export {};

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

@@ -1,2 +1,3 @@
 export type * from './getInformation';
 export type * from './getValue';
+export type * from './mayBe';

package/dist/either/types/mayBe.d.ts

@@ -1,3 +1,3 @@
 import { None } from '../left';
 import { Some } from '../right';
-export type MayBe<GenericValue extends unknown> = (Some<GenericValue> | None);
+export type Maybe<GenericValue extends unknown> = (Some<GenericValue> | None);

package/dist/invocation/evidence.d.ts

@@ -14,5 +14,5 @@ export interface EvidenceResult<GenericInformation extends string, GenericValue
  */
 export declare function evidenceResult<GenericInformation extends string, GenericValue extends object>(information: GenericInformation): (value: GenericValue) => EvidenceResult<GenericInformation, GenericValue>;
 export declare function evidenceResult<GenericInformation extends string, GenericValue extends object>(information: GenericInformation, value: GenericValue): EvidenceResult<GenericInformation, GenericValue>;
-export type FindEvidence<GenericValue extends unknown> = (GenericValue extends Evidence ? GenericValue : GenericValue extends Promise<unknown> ? FindEvidence<Awaited<GenericValue>> : GenericValue extends DEither.Right | DEither.Left ? FindEvidence<DEither.GetValue<GenericValue>> : never) extends infer InferredResult extends Evidence ? InferredResult : never;
+export type FindEvidence<GenericValue extends unknown> = (GenericValue extends Evidence ? GenericValue : GenericValue extends Promise<unknown> ? FindEvidence<Awaited<GenericValue>> : GenericValue extends DEither.Right | DEither.Left ? FindEvidence<DEither.GetValue<GenericValue>> : GenericValue extends Generator<infer InferredYeldValue, infer InferredResult> ? (FindEvidence<InferredYeldValue> | FindEvidence<InferredResult>) : GenericValue extends AsyncGenerator<infer InferredYeldValue, infer InferredResult> ? (FindEvidence<InferredYeldValue> | FindEvidence<InferredResult>) : never) extends infer InferredResult extends Evidence ? InferredResult : never;
 export type GetEvidenceResult<GenericFunction extends DCommon.AnyFunction, EvidenceName extends Extract<keyof FindEvidence<ReturnType<GenericFunction>>[DCommon.ConstraintSymbol]["evidence"], string>> = Extract<FindEvidence<ReturnType<GenericFunction>>, EvidenceName extends unknown ? Evidence<EvidenceName> : never>;

package/dist/invocation/flow/base.cjs

@@ -4,14 +4,14 @@ const require_base = require("./controller/base.cjs");
 //#region scripts/invocation/flow/base.ts
 function flow(...args) {
 	const accumulateFunction = args.reduce((accumulator, currentValue) => {
-		if (require_base.flowControllerKind.has(currentValue)) return (arg) => currentValue.exec(() => accumulator(arg));
+		if (require_base.flowControllerKind.has(currentValue)) return (input, argument) => currentValue.exec(() => accumulator(input, argument));
 		else {
-			const preparedResultTreatment = (result) => require_base.flowControllerExitKind.has(result) ? result : currentValue(result);
-			return (arg) => require_callThen.callThen(accumulator(arg), preparedResultTreatment);
+			const preparedResultTreatment = (result, argument) => require_base.flowControllerExitKind.has(result) ? result : currentValue(result, argument);
+			return (input, argument) => require_callThen.callThen(accumulator(input, argument), (result) => preparedResultTreatment(result, argument));
 		}
 	}, require_forward.forward);
 	const preparedResultTreatment = (result) => require_base.flowControllerExitKind.has(result) ? require_base.flowControllerExitKind.getValue(result) : result;
-	return (arg) => require_callThen.callThen(accumulateFunction(arg), preparedResultTreatment);
+	return (input) => require_callThen.callThen(accumulateFunction(input, input), preparedResultTreatment);
 }
 //#endregion
 exports.flow = flow;

package/dist/invocation/flow/base.d.ts

@@ -5,7 +5,7 @@ type ComputeLastUsableValue<GenericAccumulator extends DCommon.AnyTuple> = Gener
     ...infer InferredRest,
     infer InferredLast
 ] ? InferredLast extends FlowControllerResult<infer InferredFlowControllerResult> ? Exclude<Awaited<InferredFlowControllerResult>, FlowControllerPreviousFunctionResult | FlowControllerExit> extends infer InferredOutputValue ? DCommon.HasSomething<InferredOutputValue> extends true ? InferredOutputValue : InferredRest extends DCommon.AnyTuple ? ComputeLastUsableValue<InferredRest> : never : never : InferredLast : never;
-type Pipe<GenericAccumulator extends DCommon.AnyTuple, GenericOutput extends unknown> = (this: never, input: Awaited<ComputeLastUsableValue<GenericAccumulator>>) => GenericOutput;
+type Pipe<GenericAccumulator extends DCommon.AnyTuple, GenericOutput extends unknown> = (this: never, input: Awaited<ComputeLastUsableValue<GenericAccumulator>>, argument: GenericAccumulator[0]) => GenericOutput;
 type IsMaybePromise<GenericAccumulator extends DCommon.AnyTuple> = {
     [Index in keyof GenericAccumulator]: UnwrapFlowControllerResult<GenericAccumulator[Index]> extends infer InferredResult ? DCommon.IsExtends<InferredResult, Promise<unknown>> extends true ? false : DCommon.ContainExtends<InferredResult, Promise<any>> : never;
 }[number] extends false ? false : true;

package/dist/invocation/flow/base.mjs

@@ -4,14 +4,14 @@ import { flowControllerExitKind, flowControllerKind } from "./controller/base.mj
 //#region scripts/invocation/flow/base.ts
 function flow(...args) {
 	const accumulateFunction = args.reduce((accumulator, currentValue) => {
-		if (flowControllerKind.has(currentValue)) return (arg) => currentValue.exec(() => accumulator(arg));
+		if (flowControllerKind.has(currentValue)) return (input, argument) => currentValue.exec(() => accumulator(input, argument));
 		else {
-			const preparedResultTreatment = (result) => flowControllerExitKind.has(result) ? result : currentValue(result);
-			return (arg) => callThen(accumulator(arg), preparedResultTreatment);
+			const preparedResultTreatment = (result, argument) => flowControllerExitKind.has(result) ? result : currentValue(result, argument);
+			return (input, argument) => callThen(accumulator(input, argument), (result) => preparedResultTreatment(result, argument));
 		}
 	}, forward);
 	const preparedResultTreatment = (result) => flowControllerExitKind.has(result) ? flowControllerExitKind.getValue(result) : result;
-	return (arg) => callThen(accumulateFunction(arg), preparedResultTreatment);
+	return (input) => callThen(accumulateFunction(input, input), preparedResultTreatment);
 }
 //#endregion
 export { flow };

package/dist/invocation/flow/controller/defaults/debounce.cjs

@@ -16,7 +16,7 @@ const debounce = require_base.createFlowController(flowControllerDebounceKind, (
 		lastEvent?.resolve(false);
 		lastEvent = require_externalPromise.createExternalPromise();
 		lastTimeout = setTimeout(() => lastEvent?.resolve(true), formattedDebounceTime);
-		if (!await lastEvent.promise) return exitFlow(require_create.left("debounce-reject"));
+		if (!await lastEvent.promise) return exitFlow(require_create.left("debounce-reject", void 0));
 		return result;
 	});
 });

package/dist/invocation/flow/controller/defaults/debounce.mjs

@@ -16,7 +16,7 @@ const debounce = createFlowController(flowControllerDebounceKind, ({ init, exitF
 		lastEvent?.resolve(false);
 		lastEvent = createExternalPromise();
 		lastTimeout = setTimeout(() => lastEvent?.resolve(true), formattedDebounceTime);
-		if (!await lastEvent.promise) return exitFlow(left("debounce-reject"));
+		if (!await lastEvent.promise) return exitFlow(left("debounce-reject", void 0));
 		return result;
 	});
 });

package/dist/invocation/flow/controller/defaults/throttling.cjs

@@ -15,7 +15,7 @@ const throttling = require_base.createFlowController(flowControllerThrottlingKin
 		if (Date.now() - lastTime < formattedThrottlingTime) {
 			lastEvent?.resolve(false);
 			lastEvent = require_externalPromise.createExternalPromise();
-			if (!await lastEvent.promise) return exitFlow(require_create.left("throttling-reject"));
+			if (!await lastEvent.promise) return exitFlow(require_create.left("throttling-reject", void 0));
 		}
 		setTimeout(() => lastEvent?.resolve(true), formattedThrottlingTime);
 		lastTime = Date.now();

package/dist/invocation/flow/controller/defaults/throttling.mjs

@@ -15,7 +15,7 @@ const throttling = createFlowController(flowControllerThrottlingKind, ({ init, e
 		if (Date.now() - lastTime < formattedThrottlingTime) {
 			lastEvent?.resolve(false);
 			lastEvent = createExternalPromise();
-			if (!await lastEvent.promise) return exitFlow(left("throttling-reject"));
+			if (!await lastEvent.promise) return exitFlow(left("throttling-reject", void 0));
 		}
 		setTimeout(() => lastEvent?.resolve(true), formattedThrottlingTime);
 		lastTime = Date.now();

package/dist/invocation/index.cjs

@@ -11,6 +11,8 @@ const require_timeout = require("./flow/controller/defaults/timeout.cjs");
 const require_base$1 = require("./flow/base.cjs");
 const require_port = require("./port.cjs");
 const require_reader = require("./reader.cjs");
+const require_resolver = require("./resolver.cjs");
+const require_signature = require("./signature.cjs");
 //#region scripts/invocation/index.ts
 var invocation_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	AbortErrorFlowController: () => require_aborter.AbortErrorFlowController,
@@ -20,6 +22,7 @@ var invocation_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	createKind: () => require_kind.createKind,
 	createPort: () => require_port.createPort,
 	createReader: () => require_reader.createReader,
+	createResolver: () => require_resolver.createResolver,
 	debounce: () => require_debounce.debounce,
 	evidenceResult: () => require_evidence.evidenceResult,
 	filter: () => require_filter.filter,
@@ -35,7 +38,10 @@ var invocation_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	portHandlerKind: () => require_port.portHandlerKind,
 	readerKind: () => require_reader.readerKind,
 	resolveReaders: () => require_reader.resolveReaders,
+	resolverKind: () => require_resolver.resolverKind,
 	retry: () => require_retry.retry,
+	signatureKind: () => require_signature.signatureKind,
+	signedFunction: () => require_signature.signedFunction,
 	throttling: () => require_throttling.throttling,
 	timeout: () => require_timeout.timeout
 });
@@ -47,6 +53,7 @@ exports.createFlowController = require_base.createFlowController;
 exports.createKind = require_kind.createKind;
 exports.createPort = require_port.createPort;
 exports.createReader = require_reader.createReader;
+exports.createResolver = require_resolver.createResolver;
 exports.debounce = require_debounce.debounce;
 exports.evidenceResult = require_evidence.evidenceResult;
 exports.filter = require_filter.filter;
@@ -68,6 +75,9 @@ Object.defineProperty(exports, "invocation_exports", {
 exports.portHandlerKind = require_port.portHandlerKind;
 exports.readerKind = require_reader.readerKind;
 exports.resolveReaders = require_reader.resolveReaders;
+exports.resolverKind = require_resolver.resolverKind;
 exports.retry = require_retry.retry;
+exports.signatureKind = require_signature.signatureKind;
+exports.signedFunction = require_signature.signedFunction;
 exports.throttling = require_throttling.throttling;
 exports.timeout = require_timeout.timeout;

package/dist/invocation/index.d.ts

@@ -3,3 +3,5 @@ export * from './flow';
 export * from './kind';
 export * from './port';
 export * from './reader';
+export * from './resolver';
+export * from './signature';

package/dist/invocation/index.mjs

@@ -11,6 +11,8 @@ import { flowControllerTimeoutKind, timeout } from "./flow/controller/defaults/t
 import { flow } from "./flow/base.mjs";
 import { createPort, portHandlerKind } from "./port.mjs";
 import { createReader, readerKind, resolveReaders } from "./reader.mjs";
+import { createResolver, resolverKind } from "./resolver.mjs";
+import { signatureKind, signedFunction } from "./signature.mjs";
 //#region scripts/invocation/index.ts
 var invocation_exports = /* @__PURE__ */ __exportAll({
 	AbortErrorFlowController: () => AbortErrorFlowController,
@@ -20,6 +22,7 @@ var invocation_exports = /* @__PURE__ */ __exportAll({
 	createKind: () => createKind,
 	createPort: () => createPort,
 	createReader: () => createReader,
+	createResolver: () => createResolver,
 	debounce: () => debounce,
 	evidenceResult: () => evidenceResult,
 	filter: () => filter,
@@ -35,9 +38,12 @@ var invocation_exports = /* @__PURE__ */ __exportAll({
 	portHandlerKind: () => portHandlerKind,
 	readerKind: () => readerKind,
 	resolveReaders: () => resolveReaders,
+	resolverKind: () => resolverKind,
 	retry: () => retry,
+	signatureKind: () => signatureKind,
+	signedFunction: () => signedFunction,
 	throttling: () => throttling,
 	timeout: () => timeout
 });
 //#endregion
-export { AbortErrorFlowController, aborter, appendEvidence, createFlowController, createKind, createPort, createReader, debounce, evidenceResult, filter, flow, flowControllerAborterKind, flowControllerDebounceKind, flowControllerExitKind, flowControllerFilterKind, flowControllerKind, flowControllerRetryKind, flowControllerThrottlingKind, flowControllerTimeoutKind, invocation_exports, portHandlerKind, readerKind, resolveReaders, retry, throttling, timeout };
+export { AbortErrorFlowController, aborter, appendEvidence, createFlowController, createKind, createPort, createReader, createResolver, debounce, evidenceResult, filter, flow, flowControllerAborterKind, flowControllerDebounceKind, flowControllerExitKind, flowControllerFilterKind, flowControllerKind, flowControllerRetryKind, flowControllerThrottlingKind, flowControllerTimeoutKind, invocation_exports, portHandlerKind, readerKind, resolveReaders, resolverKind, retry, signatureKind, signedFunction, throttling, timeout };

package/dist/invocation/reader.cjs

@@ -4,14 +4,18 @@ const require_fromEntries = require("../object/fromEntries.cjs");
 const require_map = require("../array/map.cjs");
 const require_forward = require("../common/forward.cjs");
 const require_pipe = require("../common/pipe.cjs");
+const require_replace = require("../string/replace.cjs");
 const require_uncapitalize = require("../string/uncapitalize.cjs");
 //#region scripts/invocation/reader.ts
 const readerKind = require("./kind.cjs").createKind("reader");
+function formatPortName(value) {
+	return require_pipe.pipe(value, require_uncapitalize.uncapitalize, require_replace.replace(/Port$/, ""));
+}
 function createReader(dependencies, read) {
 	return {
 		dependencies,
 		run: (injectedDependencies) => read(require_pipe.pipe(require_forward.forward(dependencies), require_entries.entries, require_map.map(([key, value]) => {
-			const formattedKey = require_uncapitalize.uncapitalize(key);
+			const formattedKey = readerKind.has(value) ? require_uncapitalize.uncapitalize(key) : formatPortName(key);
 			return require_entry.entry(formattedKey, readerKind.has(value) && !injectedDependencies[formattedKey] ? value.run(injectedDependencies) : injectedDependencies[formattedKey]);
 		}), require_fromEntries.fromEntries)),
 		[readerKind.runTimeKey]: null