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

package/dist/dataStructure/index.mjs

@@ -14,8 +14,9 @@ import { TheUndefined, undefinedFundamentalTypeKind } from "./fundamentalType/de
 import { fundamentalTypeIdentifier } from "./fundamentalType/identifier.mjs";
 import { codecsJson } from "./common/codec/defaults/json.mjs";
 import { codecsString } from "./common/codec/defaults/string.mjs";
-import { createErrorHandler, createGetErrorHandler, decodeIssueKind, encodeIssueKind, issueKind } from "./common/error.mjs";
-import { createErrorInterpreter } from "./common/errorInterpreter.mjs";
+import { Error, ErrorPromise, createErrorHandler, createGetErrorHandler, decodeIssueKind, encodeIssueKind, issueKind } from "./common/error/base.mjs";
+import { createErrorInterpreter } from "./common/error/interpreter.mjs";
+import { defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary } from "./common/error/defaultInterpreter.mjs";
 import { ConstraintBase, constraintKind, createConstraint } from "./constraint/base.mjs";
 import { AbsolutePathConstraint, absolutePathConstraintKind } from "./constraint/defaults/absolutePath.mjs";
 import { AllowedCharactersConstraint, allowedCharactersConstraintKind } from "./constraint/defaults/allowedCharacters.mjs";
@@ -130,6 +131,7 @@ import { string } from "./helpers/string.mjs";
 import { stringLengthEqual } from "./helpers/stringLengthEqual.mjs";
 import { time } from "./helpers/time.mjs";
 import { trimmed } from "./helpers/trimmed.mjs";
+import { typeStructureIdentifier } from "./helpers/typeStructureIdentifier.mjs";
 import { unwrapLazy } from "./helpers/unwrapLazy.mjs";
 import { url } from "./helpers/url.mjs";
 import { uuid } from "./helpers/uuid.mjs";
@@ -148,6 +150,8 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	ConstraintBase: () => ConstraintBase,
 	DateType: () => DateType,
 	EmailConstraint: () => EmailConstraint,
+	Error: () => Error,
+	ErrorPromise: () => ErrorPromise,
 	ErrorSymbol: () => ErrorSymbol,
 	EvenConstraint: () => EvenConstraint,
 	GreaterThanConstraint: () => GreaterThanConstraint,
@@ -240,6 +244,8 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	dateFundamentalTypeKind: () => dateFundamentalTypeKind,
 	dateTypeKind: () => dateTypeKind,
 	decodeIssueKind: () => decodeIssueKind,
+	defaultErrorInterpreterCodecDictionary: () => defaultErrorInterpreterCodecDictionary,
+	defaultErrorInterpreterDataStructureDictionary: () => defaultErrorInterpreterDataStructureDictionary,
 	email: () => email,
 	emailConstraintKind: () => emailConstraintKind,
 	encodeIssueKind: () => encodeIssueKind,
@@ -333,6 +339,7 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	trimmedConstraintKind: () => trimmedConstraintKind,
 	typeIdentifier: () => typeIdentifier,
 	typeKind: () => typeKind,
+	typeStructureIdentifier: () => typeStructureIdentifier,
 	typeStructureKind: () => typeStructureKind,
 	undefined: () => undefinedHelper,
 	undefinedFundamentalTypeKind: () => undefinedFundamentalTypeKind,
@@ -346,4 +353,4 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	uuidConstraintKind: () => uuidConstraintKind
 });
 //#endregion
-export { AbsolutePathConstraint, AllowedCharactersConstraint, ArrayLengthEqualConstraint, ArrayStructure, BetweenThanConstraint, BetweenThanOrEqualConstraint, BigintLiteralType, BigintType, BooleanLiteralType, BooleanType, ConstraintBase, DateType, EmailConstraint, ErrorSymbol, EvenConstraint, GreaterThanConstraint, GreaterThanOrEqualConstraint, IntegerConstraint, LazyStructure, LessThanConstraint, LessThanOrEqualConstraint, MaxCharactersConstraint, MaxElementsConstraint, MinCharactersConstraint, MinElementsConstraint, MultipleOfConstraint, NegativeConstraint, NonEncodableStringStructure, NotEmptyConstraint, NotZeroConstraint, NullType, NumberInStringConstraint, NumberLiteralType, NumberType, ObjectStructure, OddConstraint, PathConstraint, PositiveConstraint, RecordStructure, RefineConstraint, RegexConstraint, SafeConstraint, SegmentPathConstraint, StrictNegativeConstraint, StrictPositiveConstraint, StringLengthEqualConstraint, StringLiteralType, StringType, StructureClass, SuccessSymbol, TheBigint, TheBoolean, TheDate, TheNull, TheNumber, TheString, TheTime, TheUndefined, TimeType, TrimmedConstraint, TypeStructure, UndefinedType, UnionStructure, UrlConstraint, UuidConstraint, absolutePath, absolutePathConstraintKind, allowedCharacters, allowedCharactersConstraintKind, array, arrayLengthEqual, arrayLengthEqualConstraintKind, arrayStructureKind, betweenThan, betweenThanConstraintKind, betweenThanOrEqual, betweenThanOrEqualConstraintKind, bigint, bigintFundamentalTypeKind, bigintLiteralTypeKind, bigintTypeKind, boolean, booleanFundamentalTypeKind, booleanLiteralTypeKind, booleanTypeKind, codecKind, codecsJson, codecsKind, codecsString, constraintIdentifier, constraintKind, createCodec, createCodecs, createConstraint, createErrorHandler, createErrorInterpreter, createFundamentalType, createGetErrorHandler, createKind, createStructure, createType, dataStructure_exports, date, dateFundamentalTypeKind, dateTypeKind, decodeIssueKind, email, emailConstraintKind, encodeIssueKind, even, evenConstraintKind, extend, fundamentalTypeIdentifier, fundamentalTypeKind, greaterThan, greaterThanConstraintKind, greaterThanOrEqual, greaterThanOrEqualConstraintKind, integer, integerConstraintKind, isNullStructure, isNullable, isOptional, isUndefinedStructure, issueKind, lazy, lazyStructureKind, lessThan, lessThanConstraintKind, lessThanOrEqual, lessThanOrEqualConstraintKind, literal, maxCharacters, maxCharactersConstraintKind, maxElements, maxElementsConstraintKind, minCharacters, minCharactersConstraintKind, minElements, minElementsConstraintKind, multipleOf, multipleOfConstraintKind, negative, negativeConstraintKind, nonEncodableStringStructureKind, notEmpty, notEmptyConstraintKind, notZero, notZeroConstraintKind, nullHelper as null, nullFundamentalTypeKind, nullTypeKind, nullable, number, numberFundamentalTypeKind, numberInString, numberInStringConstraintKind, numberLiteralTypeKind, numberTypeKind, object, objectStructureKind, odd, oddConstraintKind, optional, partial, path, pathConstraintKind, positive, positiveConstraintKind, record, recordStructureKind, refine, refineConstraintKind, regex, regexConstraintKind, required, safe, safeConstraintKind, segmentPath, segmentPathConstraintKind, strictNegative, strictNegativeConstraintKind, strictPositive, strictPositiveConstraintKind, string, stringFundamentalTypeKind, stringLengthEqual, stringLengthEqualConstraintKind, stringLiteralTypeKind, stringTypeKind, structureIdentifier, structureKind, time, timeFundamentalTypeKind, timeTypeKind, trimmed, trimmedConstraintKind, typeIdentifier, typeKind, typeStructureKind, undefinedHelper as undefined, undefinedFundamentalTypeKind, undefinedTypeKind, union, unionStructureKind, unwrapLazy, url, urlConstraintKind, uuid, uuidConstraintKind };
+export { AbsolutePathConstraint, AllowedCharactersConstraint, ArrayLengthEqualConstraint, ArrayStructure, BetweenThanConstraint, BetweenThanOrEqualConstraint, BigintLiteralType, BigintType, BooleanLiteralType, BooleanType, ConstraintBase, DateType, EmailConstraint, Error, ErrorPromise, ErrorSymbol, EvenConstraint, GreaterThanConstraint, GreaterThanOrEqualConstraint, IntegerConstraint, LazyStructure, LessThanConstraint, LessThanOrEqualConstraint, MaxCharactersConstraint, MaxElementsConstraint, MinCharactersConstraint, MinElementsConstraint, MultipleOfConstraint, NegativeConstraint, NonEncodableStringStructure, NotEmptyConstraint, NotZeroConstraint, NullType, NumberInStringConstraint, NumberLiteralType, NumberType, ObjectStructure, OddConstraint, PathConstraint, PositiveConstraint, RecordStructure, RefineConstraint, RegexConstraint, SafeConstraint, SegmentPathConstraint, StrictNegativeConstraint, StrictPositiveConstraint, StringLengthEqualConstraint, StringLiteralType, StringType, StructureClass, SuccessSymbol, TheBigint, TheBoolean, TheDate, TheNull, TheNumber, TheString, TheTime, TheUndefined, TimeType, TrimmedConstraint, TypeStructure, UndefinedType, UnionStructure, UrlConstraint, UuidConstraint, absolutePath, absolutePathConstraintKind, allowedCharacters, allowedCharactersConstraintKind, array, arrayLengthEqual, arrayLengthEqualConstraintKind, arrayStructureKind, betweenThan, betweenThanConstraintKind, betweenThanOrEqual, betweenThanOrEqualConstraintKind, bigint, bigintFundamentalTypeKind, bigintLiteralTypeKind, bigintTypeKind, boolean, booleanFundamentalTypeKind, booleanLiteralTypeKind, booleanTypeKind, codecKind, codecsJson, codecsKind, codecsString, constraintIdentifier, constraintKind, createCodec, createCodecs, createConstraint, createErrorHandler, createErrorInterpreter, createFundamentalType, createGetErrorHandler, createKind, createStructure, createType, dataStructure_exports, date, dateFundamentalTypeKind, dateTypeKind, decodeIssueKind, defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary, email, emailConstraintKind, encodeIssueKind, even, evenConstraintKind, extend, fundamentalTypeIdentifier, fundamentalTypeKind, greaterThan, greaterThanConstraintKind, greaterThanOrEqual, greaterThanOrEqualConstraintKind, integer, integerConstraintKind, isNullStructure, isNullable, isOptional, isUndefinedStructure, issueKind, lazy, lazyStructureKind, lessThan, lessThanConstraintKind, lessThanOrEqual, lessThanOrEqualConstraintKind, literal, maxCharacters, maxCharactersConstraintKind, maxElements, maxElementsConstraintKind, minCharacters, minCharactersConstraintKind, minElements, minElementsConstraintKind, multipleOf, multipleOfConstraintKind, negative, negativeConstraintKind, nonEncodableStringStructureKind, notEmpty, notEmptyConstraintKind, notZero, notZeroConstraintKind, nullHelper as null, nullFundamentalTypeKind, nullTypeKind, nullable, number, numberFundamentalTypeKind, numberInString, numberInStringConstraintKind, numberLiteralTypeKind, numberTypeKind, object, objectStructureKind, odd, oddConstraintKind, optional, partial, path, pathConstraintKind, positive, positiveConstraintKind, record, recordStructureKind, refine, refineConstraintKind, regex, regexConstraintKind, required, safe, safeConstraintKind, segmentPath, segmentPathConstraintKind, strictNegative, strictNegativeConstraintKind, strictPositive, strictPositiveConstraintKind, string, stringFundamentalTypeKind, stringLengthEqual, stringLengthEqualConstraintKind, stringLiteralTypeKind, stringTypeKind, structureIdentifier, structureKind, time, timeFundamentalTypeKind, timeTypeKind, trimmed, trimmedConstraintKind, typeIdentifier, typeKind, typeStructureIdentifier, typeStructureKind, undefinedHelper as undefined, undefinedFundamentalTypeKind, undefinedTypeKind, union, unionStructureKind, unwrapLazy, url, urlConstraintKind, uuid, uuidConstraintKind };

package/dist/dataStructure/structure/base.cjs

@@ -5,7 +5,7 @@ const require_create$1 = require("../../either/right/create.cjs");
 const require_simpleClone = require("../../common/simpleClone.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("../common/error/base.cjs");
 //#region scripts/dataStructure/structure/base.ts
 var StructureClass = class StructureClass {
 	constructor() {}
@@ -23,7 +23,7 @@ var StructureClass = class StructureClass {
 };
 const structureKind = require_kind.createKind("structure");
 function createStructure(kindHandler, createConstructor) {
-	const init = (definition, { executeCheck, executeEncode, executeDecode, isAsynchronous }, ...rest) => {
+	const init = (definition, { executeCheck, executeEncode, executeDecode, executeParse, isAsynchronous }, ...rest) => {
 		let cachedIsAsynchronous = void 0;
 		const self = StructureClass.init({
 			...Object.fromEntries(Object.entries(rest[0] ?? {}).map(([key, prop]) => typeof prop === "function" ? [key, (...args) => prop(self, ...args)] : [key, prop])),
@@ -35,12 +35,14 @@ function createStructure(kindHandler, createConstructor) {
 				executeCheck,
 				executeEncode,
 				executeDecode,
+				executeParse,
 				isAsynchronous
 			}, ...rest),
 			executeConstraints: (data, errorHandler) => definition.constraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(constraint.executeCheck(data), (constraintResult) => constraintResult === require_resultSymbol.ErrorSymbol ? errorHandler?.().addIssue(self, data, constraint) ?? require_resultSymbol.ErrorSymbol : require_resultSymbol.SuccessSymbol)), require_resultSymbol.SuccessSymbol),
 			executeCheck: (data, errorHandler) => require_callThen.callThen(executeCheck(self, data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : self.executeConstraints(data, errorHandler)),
 			executeEncode: (codecContext, data, errorHandler) => executeEncode(self, codecContext, data, errorHandler),
 			executeDecode: (codecContext, data, errorHandler) => executeDecode(self, codecContext, data, errorHandler),
+			executeParse: (codecContext, data, errorHandler) => executeParse(self, codecContext, data, errorHandler),
 			isAsynchronous: () => {
 				if (cachedIsAsynchronous !== void 0) return cachedIsAsynchronous;
 				cachedIsAsynchronous = false;
@@ -50,14 +52,14 @@ function createStructure(kindHandler, createConstructor) {
 				return cachedIsAsynchronous;
 			},
 			check: (data) => {
-				const errorHandler = require_error.createGetErrorHandler();
+				const errorHandler = require_base.createGetErrorHandler();
 				const result = self.executeCheck(data, errorHandler);
-				if (result instanceof Promise) return require_create.left("async-error", void 0);
+				if (result instanceof Promise) return require_create.left("async-error", new require_base.ErrorPromise());
 				if (result === require_resultSymbol.ErrorSymbol) return require_create.left("check-error", errorHandler().createError());
 				return require_create$1.right("check-success", data);
 			},
 			asyncCheck: async (data) => {
-				const errorHandler = require_error.createGetErrorHandler();
+				const errorHandler = require_base.createGetErrorHandler();
 				if (await self.executeCheck(data, errorHandler) === require_resultSymbol.ErrorSymbol) return require_create.left("check-error", errorHandler().createError());
 				return require_create$1.right("check-success", data);
 			},
@@ -66,41 +68,51 @@ function createStructure(kindHandler, createConstructor) {
 				if (result instanceof Promise || result === require_resultSymbol.ErrorSymbol) return false;
 				return true;
 			},
-			encode: (codecs, data) => self.unsafeEncode(codecs, data),
-			asyncEncode: (codecs, data) => self.asyncUnsafeEncode(codecs, data),
-			unsafeEncode: (codecs, data) => {
-				const errorHandler = require_error.createGetErrorHandler();
+			encode: (codecs, data) => {
+				const errorHandler = require_base.createGetErrorHandler();
 				const result = self.executeEncode(codecs.context.value, data, errorHandler);
-				if (result instanceof Promise) return require_create.left("async-error", void 0);
+				if (result instanceof Promise) return require_create.left("async-error", new require_base.ErrorPromise());
 				if (result === require_resultSymbol.ErrorSymbol) return require_create.left("encode-error", errorHandler().createError());
 				return require_create$1.right("encode-success", result);
 			},
-			asyncUnsafeEncode: async (codecs, data) => {
-				const errorHandler = require_error.createGetErrorHandler();
+			asyncEncode: async (codecs, data) => {
+				const errorHandler = require_base.createGetErrorHandler();
 				const result = await self.executeEncode(codecs.context.value, data, errorHandler);
 				if (result === require_resultSymbol.ErrorSymbol) return require_create.left("encode-error", errorHandler().createError());
 				return require_create$1.right("encode-success", result);
 			},
-			decode: (codecs, data) => self.unsafeDecode(codecs, data),
-			asyncDecode: (codecs, data) => self.asyncUnsafeDecode(codecs, data),
-			unsafeDecode: (codecs, data) => {
-				const errorHandler = require_error.createGetErrorHandler();
+			decode: (codecs, data) => {
+				const errorHandler = require_base.createGetErrorHandler();
 				const result = self.executeDecode(codecs.context.value, data, errorHandler);
-				if (result instanceof Promise) return require_create.left("async-error", void 0);
+				if (result instanceof Promise) return require_create.left("async-error", new require_base.ErrorPromise());
 				if (result === require_resultSymbol.ErrorSymbol) return require_create.left("decode-error", errorHandler().createError());
 				return require_create$1.right("decode-success", result);
 			},
-			asyncUnsafeDecode: async (codecs, data) => {
-				const errorHandler = require_error.createGetErrorHandler();
+			asyncDecode: async (codecs, data) => {
+				const errorHandler = require_base.createGetErrorHandler();
 				const result = await self.executeDecode(codecs.context.value, data, errorHandler);
 				if (result === require_resultSymbol.ErrorSymbol) return require_create.left("decode-error", errorHandler().createError());
 				return require_create$1.right("decode-success", result);
 			},
+			parse: (data, codecs) => {
+				const errorHandler = require_base.createGetErrorHandler();
+				const result = self.executeParse(codecs?.context.value ?? /* @__PURE__ */ new Map(), data, errorHandler);
+				if (result instanceof Promise) return require_create.left("async-error", new require_base.ErrorPromise());
+				if (result === require_resultSymbol.ErrorSymbol) return require_create.left("parse-error", errorHandler().createError());
+				return require_create$1.right("parse-success", result);
+			},
+			asyncParse: async (data, codecs) => {
+				const errorHandler = require_base.createGetErrorHandler();
+				const result = await self.executeParse(codecs?.context.value ?? /* @__PURE__ */ new Map(), data, errorHandler);
+				if (result === require_resultSymbol.ErrorSymbol) return require_create.left("parse-error", errorHandler().createError());
+				return require_create$1.right("parse-success", result);
+			},
 			contract: () => self,
 			clone: () => init(require_simpleClone.simpleClone(definition), {
 				executeCheck,
 				executeEncode,
 				executeDecode,
+				executeParse,
 				isAsynchronous
 			}, ...rest),
 			setMessage: (message) => {

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

@@ -1,6 +1,6 @@
-import { ErrorSymbol, GetErrorHandler, SuccessSymbol, EncodedValue, CodecContext, Error, Codecs } from '../common';
+import { ErrorPromise, ErrorSymbol, GetErrorHandler, SuccessSymbol, EncodedValue, CodecContext, Error, Codecs } from '../common';
 import { Constraint } from '../constraint';
-import { StructureConstraintsValue, StructureValue } from './types';
+import { ComputeStructureValue } from './types';
 import type * as DKind from '../../kind';
 import * as DEither from '../../either';
 import * as DCommon from '../../common';
@@ -14,26 +14,25 @@ export interface StructureDefinition<GenericConstraints extends readonly Constra
     readonly message?: string;
     readonly constraints: readonly [...GenericConstraints];
 }
-export interface Structure<out GenericValue extends unknown = unknown, out GenericDefinition extends StructureDefinition<readonly Constraint<GenericValue>[]> = StructureDefinition<readonly Constraint<GenericValue>[]>> extends DKind.Kind<typeof structureKind, (GenericValue & StructureConstraintsValue<GenericDefinition["constraints"][number]>)> {
+export interface Structure<out GenericValue extends unknown = unknown, out GenericDefinition extends StructureDefinition<readonly Constraint<unknown, GenericValue>[]> = StructureDefinition<readonly Constraint<unknown, GenericValue>[]>> extends DKind.Kind<typeof structureKind, ComputeStructureValue<GenericValue, GenericDefinition["constraints"]>> {
     readonly definition: GenericDefinition;
-    addConstraint<const GenericNewConstraints extends DCommon.AnyTuple<Constraint<GenericValue>>>(...args: DCommon.FixDeepFunctionInfer<DCommon.AnyTuple<Constraint<GenericValue>>, GenericNewConstraints>): Structure<StructureValue<this>, StructureDefinition<readonly [...this["definition"]["constraints"], ...GenericNewConstraints]>>;
+    addConstraint<const GenericNewConstraints extends DCommon.AnyTuple<Constraint<GenericValue>>>(...args: DCommon.FixDeepFunctionInfer<DCommon.AnyTuple<Constraint<GenericValue>>, GenericNewConstraints>): Structure<ComputeStructureValue<GenericValue, GenericDefinition["constraints"]>, StructureDefinition<readonly [...this["definition"]["constraints"], ...GenericNewConstraints]>>;
     executeConstraints(data: unknown, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     executeCheck(data: unknown, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     executeEncode(codecContext: CodecContext, data: unknown, errorHandler?: GetErrorHandler): unknown;
     executeDecode(codecContext: CodecContext, data: unknown, errorHandler?: GetErrorHandler): unknown;
+    executeParse(codecContext: CodecContext, data: unknown, errorHandler?: GetErrorHandler): unknown;
     isAsynchronous(): boolean;
-    check(data: unknown): (DEither.Right<"check-success", StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"check-error", Error>);
-    asyncCheck(data: unknown): Promise<DEither.Right<"check-success", StructureValue<this>> | DEither.Left<"check-error", Error>>;
-    is(data: unknown): data is StructureValue<this>;
-    encode<GenericCodecs extends Codecs>(codecs: GenericCodecs, data: StructureValue<this>): (DEither.Right<"encode-success", EncodedValue<StructureValue<this>, GenericCodecs>> | DEither.Left<"async-error", undefined> | DEither.Left<"encode-error", Error>);
-    asyncEncode<GenericCodecs extends Codecs>(codecs: GenericCodecs, data: StructureValue<this>): Promise<DEither.Right<"encode-success", EncodedValue<StructureValue<this>, GenericCodecs>> | DEither.Left<"encode-error", Error>>;
-    unsafeEncode<GenericCodecs extends Codecs>(codecs: GenericCodecs, data: unknown): (DEither.Right<"encode-success", EncodedValue<StructureValue<this>, GenericCodecs>> | DEither.Left<"async-error", undefined> | DEither.Left<"encode-error", Error>);
-    asyncUnsafeEncode<GenericCodecs extends Codecs>(codecs: GenericCodecs, data: unknown): Promise<DEither.Right<"encode-success", EncodedValue<StructureValue<this>, GenericCodecs>> | DEither.Left<"encode-error", Error>>;
-    decode<GenericCodecs extends Codecs>(codecs: GenericCodecs, data: EncodedValue<StructureValue<this>, GenericCodecs>): (DEither.Right<"decode-success", StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"decode-error", Error>);
-    asyncDecode<GenericCodecs extends Codecs>(codecs: GenericCodecs, data: EncodedValue<StructureValue<this>, GenericCodecs>): Promise<DEither.Right<"decode-success", StructureValue<this>> | DEither.Left<"decode-error", Error>>;
-    unsafeDecode(codecs: Codecs, data: unknown): (DEither.Right<"decode-success", StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"decode-error", Error>);
-    asyncUnsafeDecode(codecs: Codecs, data: unknown): Promise<DEither.Right<"decode-success", StructureValue<this>> | DEither.Left<"decode-error", Error>>;
-    contract<GenericValue extends unknown, GenericThis extends this>(...args: DCommon.IsEqual<StructureValue<GenericThis>, GenericValue> extends true ? [] : [] & DCommon.ComputedTypeError<"Contract error.">): Structure<GenericValue>;
+    check(data: unknown): (DEither.Right<"check-success", ComputeStructureValue<GenericValue, GenericDefinition["constraints"]>> | DEither.Left<"async-error", ErrorPromise> | DEither.Left<"check-error", Error>);
+    asyncCheck(data: unknown): Promise<DEither.Right<"check-success", ComputeStructureValue<GenericValue, GenericDefinition["constraints"]>> | DEither.Left<"check-error", Error>>;
+    is(data: unknown): data is ComputeStructureValue<GenericValue, GenericDefinition["constraints"]>;
+    encode<GenericCodecs extends Codecs>(codecs: GenericCodecs, data: unknown): (DEither.Right<"encode-success", EncodedValue<ComputeStructureValue<GenericValue, GenericDefinition["constraints"]>, GenericCodecs>> | DEither.Left<"async-error", ErrorPromise> | DEither.Left<"encode-error", Error>);
+    asyncEncode<GenericCodecs extends Codecs>(codecs: GenericCodecs, data: unknown): Promise<DEither.Right<"encode-success", EncodedValue<ComputeStructureValue<GenericValue, GenericDefinition["constraints"]>, GenericCodecs>> | DEither.Left<"encode-error", Error>>;
+    decode<GenericCodecs extends Codecs>(codecs: GenericCodecs, data: unknown): (DEither.Right<"decode-success", ComputeStructureValue<GenericValue, GenericDefinition["constraints"]>> | DEither.Left<"async-error", ErrorPromise> | DEither.Left<"decode-error", Error>);
+    asyncDecode<GenericCodecs extends Codecs>(codecs: GenericCodecs, data: unknown): Promise<DEither.Right<"decode-success", ComputeStructureValue<GenericValue, GenericDefinition["constraints"]>> | DEither.Left<"decode-error", Error>>;
+    parse(data: unknown, codecs?: Codecs): (DEither.Right<"parse-success", ComputeStructureValue<GenericValue, GenericDefinition["constraints"]>> | DEither.Left<"async-error", ErrorPromise> | DEither.Left<"parse-error", Error>);
+    asyncParse(data: unknown, codecs?: Codecs): Promise<DEither.Right<"parse-success", ComputeStructureValue<GenericValue, GenericDefinition["constraints"]>> | DEither.Left<"parse-error", Error>>;
+    contract<GenericContractValue extends unknown, GenericArgs extends (DCommon.IsEqual<ComputeStructureValue<GenericValue, GenericDefinition["constraints"]>, GenericContractValue> extends true ? [] : [] & DCommon.ComputedTypeError<"Contract error.">) = (DCommon.IsEqual<ComputeStructureValue<GenericValue, GenericDefinition["constraints"]>, GenericContractValue> extends true ? [] : [] & DCommon.ComputedTypeError<"Contract error.">)>(...args: NoInfer<GenericArgs>): Structure<GenericContractValue>;
     clone(): this;
     setMessage(massage: string): this;
     addMessage(massage: string): this;
@@ -42,6 +41,7 @@ export interface CreateStructureInitParams<GenericStructure extends Structure =
     executeCheck(self: GenericStructure, data: unknown, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     executeEncode(self: GenericStructure, codecContext: CodecContext, data: unknown, errorHandler?: GetErrorHandler): unknown;
     executeDecode(self: GenericStructure, codecContext: CodecContext, data: unknown, errorHandler?: GetErrorHandler): unknown;
+    executeParse(self: GenericStructure, codecContext: CodecContext, data: unknown, errorHandler?: GetErrorHandler): unknown;
     isAsynchronous(self: GenericStructure): boolean;
 }
 export type CreateStructureInitRest<GenericStructure extends Structure = Structure> = {

package/dist/dataStructure/structure/base.mjs

@@ -5,7 +5,7 @@ import { right } from "../../either/right/create.mjs";
 import { simpleClone } from "../../common/simpleClone.mjs";
 import { createKind } from "../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../common/resultSymbol.mjs";
-import { createGetErrorHandler } from "../common/error.mjs";
+import { ErrorPromise, createGetErrorHandler } from "../common/error/base.mjs";
 //#region scripts/dataStructure/structure/base.ts
 var StructureClass = class StructureClass {
 	constructor() {}
@@ -23,7 +23,7 @@ var StructureClass = class StructureClass {
 };
 const structureKind = createKind("structure");
 function createStructure(kindHandler, createConstructor) {
-	const init = (definition, { executeCheck, executeEncode, executeDecode, isAsynchronous }, ...rest) => {
+	const init = (definition, { executeCheck, executeEncode, executeDecode, executeParse, isAsynchronous }, ...rest) => {
 		let cachedIsAsynchronous = void 0;
 		const self = StructureClass.init({
 			...Object.fromEntries(Object.entries(rest[0] ?? {}).map(([key, prop]) => typeof prop === "function" ? [key, (...args) => prop(self, ...args)] : [key, prop])),
@@ -35,12 +35,14 @@ function createStructure(kindHandler, createConstructor) {
 				executeCheck,
 				executeEncode,
 				executeDecode,
+				executeParse,
 				isAsynchronous
 			}, ...rest),
 			executeConstraints: (data, errorHandler) => definition.constraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : callThen(constraint.executeCheck(data), (constraintResult) => constraintResult === ErrorSymbol ? errorHandler?.().addIssue(self, data, constraint) ?? ErrorSymbol : SuccessSymbol)), SuccessSymbol),
 			executeCheck: (data, errorHandler) => callThen(executeCheck(self, data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : self.executeConstraints(data, errorHandler)),
 			executeEncode: (codecContext, data, errorHandler) => executeEncode(self, codecContext, data, errorHandler),
 			executeDecode: (codecContext, data, errorHandler) => executeDecode(self, codecContext, data, errorHandler),
+			executeParse: (codecContext, data, errorHandler) => executeParse(self, codecContext, data, errorHandler),
 			isAsynchronous: () => {
 				if (cachedIsAsynchronous !== void 0) return cachedIsAsynchronous;
 				cachedIsAsynchronous = false;
@@ -52,7 +54,7 @@ function createStructure(kindHandler, createConstructor) {
 			check: (data) => {
 				const errorHandler = createGetErrorHandler();
 				const result = self.executeCheck(data, errorHandler);
-				if (result instanceof Promise) return left("async-error", void 0);
+				if (result instanceof Promise) return left("async-error", new ErrorPromise());
 				if (result === ErrorSymbol) return left("check-error", errorHandler().createError());
 				return right("check-success", data);
 			},
@@ -66,41 +68,51 @@ function createStructure(kindHandler, createConstructor) {
 				if (result instanceof Promise || result === ErrorSymbol) return false;
 				return true;
 			},
-			encode: (codecs, data) => self.unsafeEncode(codecs, data),
-			asyncEncode: (codecs, data) => self.asyncUnsafeEncode(codecs, data),
-			unsafeEncode: (codecs, data) => {
+			encode: (codecs, data) => {
 				const errorHandler = createGetErrorHandler();
 				const result = self.executeEncode(codecs.context.value, data, errorHandler);
-				if (result instanceof Promise) return left("async-error", void 0);
+				if (result instanceof Promise) return left("async-error", new ErrorPromise());
 				if (result === ErrorSymbol) return left("encode-error", errorHandler().createError());
 				return right("encode-success", result);
 			},
-			asyncUnsafeEncode: async (codecs, data) => {
+			asyncEncode: async (codecs, data) => {
 				const errorHandler = createGetErrorHandler();
 				const result = await self.executeEncode(codecs.context.value, data, errorHandler);
 				if (result === ErrorSymbol) return left("encode-error", errorHandler().createError());
 				return right("encode-success", result);
 			},
-			decode: (codecs, data) => self.unsafeDecode(codecs, data),
-			asyncDecode: (codecs, data) => self.asyncUnsafeDecode(codecs, data),
-			unsafeDecode: (codecs, data) => {
+			decode: (codecs, data) => {
 				const errorHandler = createGetErrorHandler();
 				const result = self.executeDecode(codecs.context.value, data, errorHandler);
-				if (result instanceof Promise) return left("async-error", void 0);
+				if (result instanceof Promise) return left("async-error", new ErrorPromise());
 				if (result === ErrorSymbol) return left("decode-error", errorHandler().createError());
 				return right("decode-success", result);
 			},
-			asyncUnsafeDecode: async (codecs, data) => {
+			asyncDecode: async (codecs, data) => {
 				const errorHandler = createGetErrorHandler();
 				const result = await self.executeDecode(codecs.context.value, data, errorHandler);
 				if (result === ErrorSymbol) return left("decode-error", errorHandler().createError());
 				return right("decode-success", result);
 			},
+			parse: (data, codecs) => {
+				const errorHandler = createGetErrorHandler();
+				const result = self.executeParse(codecs?.context.value ?? /* @__PURE__ */ new Map(), data, errorHandler);
+				if (result instanceof Promise) return left("async-error", new ErrorPromise());
+				if (result === ErrorSymbol) return left("parse-error", errorHandler().createError());
+				return right("parse-success", result);
+			},
+			asyncParse: async (data, codecs) => {
+				const errorHandler = createGetErrorHandler();
+				const result = await self.executeParse(codecs?.context.value ?? /* @__PURE__ */ new Map(), data, errorHandler);
+				if (result === ErrorSymbol) return left("parse-error", errorHandler().createError());
+				return right("parse-success", result);
+			},
 			contract: () => self,
 			clone: () => init(simpleClone(definition), {
 				executeCheck,
 				executeEncode,
 				executeDecode,
+				executeParse,
 				isAsynchronous
 			}, ...rest),
 			setMessage: (message) => {

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

@@ -37,6 +37,16 @@ const ArrayStructure = require_base.createStructure(arrayStructureKind, ({ init
 		})), []);
 		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 (!Array.isArray(data)) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
+		const pathStage = errorHandler?.().createPathStage();
+		const parsedData = data.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`[array: ${index}]`) ?? require_callThen.callThen(self.definition.element.executeParse(codecContext, value, errorHandler), (parsedData) => {
+			if (parsedData === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
+			awaitedAccumulator[index] = parsedData;
+			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.element.isAsynchronous()
 }));
 //#endregion

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

@@ -37,6 +37,16 @@ const ArrayStructure = createStructure(arrayStructureKind, ({ init }) => (elemen
 		})), []);
 		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 (!Array.isArray(data)) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
+		const pathStage = errorHandler?.().createPathStage();
+		const parsedData = data.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`[array: ${index}]`) ?? callThen(self.definition.element.executeParse(codecContext, value, errorHandler), (parsedData) => {
+			if (parsedData === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
+			awaitedAccumulator[index] = parsedData;
+			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.element.isAsynchronous()
 }));
 //#endregion

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

@@ -17,6 +17,7 @@ const LazyStructure = require_base.createStructure(lazyStructureKind, ({ init })
 	executeCheck: (self, data, errorHandler) => self.definition.getter.value.executeCheck(data, errorHandler),
 	executeEncode: (self, codecContext, data, errorHandler) => require_callThen.callThen(self.definition.getter.value.executeEncode(codecContext, data, errorHandler), (encodedData) => encodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : encodedData)),
 	executeDecode: (self, codecContext, data, errorHandler) => require_callThen.callThen(self.definition.getter.value.executeDecode(codecContext, data, errorHandler), (decodedData) => decodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(decodedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : decodedData)),
+	executeParse: (self, codecContext, data, errorHandler) => require_callThen.callThen(self.definition.getter.value.executeParse(codecContext, data, errorHandler), (parsedData) => parsedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(parsedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : parsedData)),
 	isAsynchronous: (self) => self.definition.getter.value.isAsynchronous()
 }));
 //#endregion

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

@@ -17,6 +17,7 @@ const LazyStructure = createStructure(lazyStructureKind, ({ init }) => (getStruc
 	executeCheck: (self, data, errorHandler) => self.definition.getter.value.executeCheck(data, errorHandler),
 	executeEncode: (self, codecContext, data, errorHandler) => callThen(self.definition.getter.value.executeEncode(codecContext, data, errorHandler), (encodedData) => encodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : encodedData)),
 	executeDecode: (self, codecContext, data, errorHandler) => callThen(self.definition.getter.value.executeDecode(codecContext, data, errorHandler), (decodedData) => decodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(decodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : decodedData)),
+	executeParse: (self, codecContext, data, errorHandler) => callThen(self.definition.getter.value.executeParse(codecContext, data, errorHandler), (parsedData) => parsedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(parsedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : parsedData)),
 	isAsynchronous: (self) => self.definition.getter.value.isAsynchronous()
 }));
 //#endregion

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

@@ -10,6 +10,7 @@ const NonEncodableStringStructure = require_base.createStructure(nonEncodableStr
 	executeCheck: (self, data, errorHandler) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
 	executeEncode: (self, codecContext, data, errorHandler) => data === self.definition.value ? data : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
 	executeDecode: (self, codecContext, data, errorHandler) => data === self.definition.value ? data : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeParse: (self, codecContext, data, errorHandler) => self.executeDecode(codecContext, data, errorHandler),
 	isAsynchronous: () => false
 }));
 //#endregion

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

@@ -10,6 +10,7 @@ const NonEncodableStringStructure = createStructure(nonEncodableStringStructureK
 	executeCheck: (self, data, errorHandler) => data === self.definition.value ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
 	executeEncode: (self, codecContext, data, errorHandler) => data === self.definition.value ? data : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
 	executeDecode: (self, codecContext, data, errorHandler) => data === self.definition.value ? data : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeParse: (self, codecContext, data, errorHandler) => self.executeDecode(codecContext, data, errorHandler),
 	isAsynchronous: () => false
 }));
 //#endregion

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

@@ -7,10 +7,11 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/structure/defaults/object.ts
 const objectStructureKind = require_kind.createKind("object-structure");
 const ObjectStructure = require_base.createStructure(objectStructureKind, ({ init }) => (shape, constraints) => init({
-	shape: require_memo.memo(() => Object.entries(shape).map(([key, value]) => ({
+	optimizedShape: require_memo.memo(() => Object.entries(shape).map(([key, value]) => ({
 		key,
 		value
 	}))),
+	shape,
 	keys: Object.keys(shape),
 	constraints
 }, {
@@ -18,7 +19,7 @@ const ObjectStructure = require_base.createStructure(objectStructureKind, ({ ini
 		if (!require_isSimple.isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		if (Object.keys(data).some((value) => !self.definition.keys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		const result = self.definition.shape.value.reduce((accumulator, entry) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? require_callThen.callThen(entry.value.executeCheck(data[entry.key], errorHandler), (result) => result === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_resultSymbol.SuccessSymbol)), require_resultSymbol.SuccessSymbol);
+		const result = self.definition.optimizedShape.value.reduce((accumulator, entry) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? require_callThen.callThen(entry.value.executeCheck(data[entry.key], errorHandler), (result) => result === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_resultSymbol.SuccessSymbol)), require_resultSymbol.SuccessSymbol);
 		return require_callThen.callThen(result, (awaitedResult) => {
 			pathStage?.close();
 			return awaitedResult;
@@ -28,9 +29,9 @@ const ObjectStructure = require_base.createStructure(objectStructureKind, ({ ini
 		if (!require_isSimple.isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		if (Object.keys(data).some((value) => !self.definition.keys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		const encodedData = self.definition.shape.value.reduce((accumulator, entry) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? require_callThen.callThen(entry.value.executeEncode(codecContext, data[entry.key], errorHandler), (encodedData) => {
+		const encodedData = self.definition.optimizedShape.value.reduce((accumulator, entry) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? require_callThen.callThen(entry.value.executeEncode(codecContext, data[entry.key], errorHandler), (encodedData) => {
 			if (encodedData === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
-			awaitedAccumulator[entry.key] = encodedData;
+			if (encodedData !== void 0) awaitedAccumulator[entry.key] = encodedData;
 			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)));
@@ -39,14 +40,24 @@ const ObjectStructure = require_base.createStructure(objectStructureKind, ({ ini
 		if (!require_isSimple.isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		if (Object.keys(data).some((value) => !self.definition.keys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		const decodedData = self.definition.shape.value.reduce((accumulator, entry) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? require_callThen.callThen(entry.value.executeDecode(codecContext, data[entry.key], errorHandler), (decodedData) => {
+		const decodedData = self.definition.optimizedShape.value.reduce((accumulator, entry) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? require_callThen.callThen(entry.value.executeDecode(codecContext, data[entry.key], errorHandler), (decodedData) => {
 			if (decodedData === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
-			awaitedAccumulator[entry.key] = decodedData;
+			if (decodedData !== void 0) awaitedAccumulator[entry.key] = decodedData;
 			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)));
 	},
-	isAsynchronous: (self) => self.definition.shape.value.some((entry) => entry.value.isAsynchronous())
+	executeParse: (self, codecContext, data, errorHandler) => {
+		if (!require_isSimple.isSimple(data)) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
+		const pathStage = errorHandler?.().createPathStage();
+		const parsedData = self.definition.optimizedShape.value.reduce((accumulator, entry) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? require_callThen.callThen(entry.value.executeParse(codecContext, data[entry.key], errorHandler), (parsedData) => {
+			if (parsedData === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
+			if (parsedData !== void 0) awaitedAccumulator[entry.key] = parsedData;
+			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.optimizedShape.value.some((entry) => entry.value.isAsynchronous())
 }));
 //#endregion
 exports.ObjectStructure = ObjectStructure;

package/dist/dataStructure/structure/defaults/object.d.ts

@@ -22,7 +22,8 @@ export type ShapeObjectStructureValue<GenericShape extends ShapeObjectStructure>
 } extends infer InferredResult extends Record<string, unknown> ? DObject.PartialKeys<InferredResult, DObject.GetPropsWithValueExtends<InferredResult, undefined>> : never;
 export declare const objectStructureKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/object-structure", unknown>>;
 export interface ObjectStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
-    readonly shape: DCommon.Memoized<readonly EntryShapeObjectStructure[]>;
+    readonly optimizedShape: DCommon.Memoized<readonly EntryShapeObjectStructure[]>;
+    readonly shape: Readonly<Record<string, Structure>>;
     readonly keys: readonly string[];
 }
 export interface ObjectStructure<out GenericValue extends Record<string, unknown> = Record<string, unknown>, out GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, ObjectStructureDefinition<GenericConstraints>> & DKind.Kind<typeof objectStructureKind>> {

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

@@ -7,10 +7,11 @@ import { createStructure } from "../base.mjs";
 //#region scripts/dataStructure/structure/defaults/object.ts
 const objectStructureKind = createKind("object-structure");
 const ObjectStructure = createStructure(objectStructureKind, ({ init }) => (shape, constraints) => init({
-	shape: memo(() => Object.entries(shape).map(([key, value]) => ({
+	optimizedShape: memo(() => Object.entries(shape).map(([key, value]) => ({
 		key,
 		value
 	}))),
+	shape,
 	keys: Object.keys(shape),
 	constraints
 }, {
@@ -18,7 +19,7 @@ const ObjectStructure = createStructure(objectStructureKind, ({ init }) => (shap
 		if (!isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		if (Object.keys(data).some((value) => !self.definition.keys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		const result = self.definition.shape.value.reduce((accumulator, entry) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? callThen(entry.value.executeCheck(data[entry.key], errorHandler), (result) => result === ErrorSymbol || awaitedAccumulator === ErrorSymbol ? ErrorSymbol : SuccessSymbol)), SuccessSymbol);
+		const result = self.definition.optimizedShape.value.reduce((accumulator, entry) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? callThen(entry.value.executeCheck(data[entry.key], errorHandler), (result) => result === ErrorSymbol || awaitedAccumulator === ErrorSymbol ? ErrorSymbol : SuccessSymbol)), SuccessSymbol);
 		return callThen(result, (awaitedResult) => {
 			pathStage?.close();
 			return awaitedResult;
@@ -28,9 +29,9 @@ const ObjectStructure = createStructure(objectStructureKind, ({ init }) => (shap
 		if (!isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		if (Object.keys(data).some((value) => !self.definition.keys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		const encodedData = self.definition.shape.value.reduce((accumulator, entry) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? callThen(entry.value.executeEncode(codecContext, data[entry.key], errorHandler), (encodedData) => {
+		const encodedData = self.definition.optimizedShape.value.reduce((accumulator, entry) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? callThen(entry.value.executeEncode(codecContext, data[entry.key], errorHandler), (encodedData) => {
 			if (encodedData === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
-			awaitedAccumulator[entry.key] = encodedData;
+			if (encodedData !== void 0) awaitedAccumulator[entry.key] = encodedData;
 			return awaitedAccumulator;
 		})), {});
 		return callThen(encodedData, (awaitedEncodedData) => pathStage?.close() ?? (awaitedEncodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedEncodedData)));
@@ -39,14 +40,24 @@ const ObjectStructure = createStructure(objectStructureKind, ({ init }) => (shap
 		if (!isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		if (Object.keys(data).some((value) => !self.definition.keys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		const decodedData = self.definition.shape.value.reduce((accumulator, entry) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? callThen(entry.value.executeDecode(codecContext, data[entry.key], errorHandler), (decodedData) => {
+		const decodedData = self.definition.optimizedShape.value.reduce((accumulator, entry) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? callThen(entry.value.executeDecode(codecContext, data[entry.key], errorHandler), (decodedData) => {
 			if (decodedData === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
-			awaitedAccumulator[entry.key] = decodedData;
+			if (decodedData !== void 0) awaitedAccumulator[entry.key] = decodedData;
 			return awaitedAccumulator;
 		})), {});
 		return callThen(decodedData, (awaitedDecodedData) => pathStage?.close() ?? (awaitedDecodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedDecodedData)));
 	},
-	isAsynchronous: (self) => self.definition.shape.value.some((entry) => entry.value.isAsynchronous())
+	executeParse: (self, codecContext, data, errorHandler) => {
+		if (!isSimple(data)) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
+		const pathStage = errorHandler?.().createPathStage();
+		const parsedData = self.definition.optimizedShape.value.reduce((accumulator, entry) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? callThen(entry.value.executeParse(codecContext, data[entry.key], errorHandler), (parsedData) => {
+			if (parsedData === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
+			if (parsedData !== void 0) awaitedAccumulator[entry.key] = parsedData;
+			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.optimizedShape.value.some((entry) => entry.value.isAsynchronous())
 }));
 //#endregion
 export { ObjectStructure, objectStructureKind };