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

package/dist/dataStructure/index.mjs

@@ -1,9 +1,24 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { createKind } from "./kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "./common/resultSymbol.mjs";
-import { codecKind, codecsKind, createCodec, createCodecs } from "./common/codec.mjs";
-import { createErrorHandler, createGetErrorHandler } from "./common/error.mjs";
-import { constraintKind, createConstraint } from "./constraint/base.mjs";
+import { codecKind, codecsKind, createCodec, createCodecs } from "./common/codec/base.mjs";
+import { createFundamentalType, fundamentalTypeKind } from "./fundamentalType/base.mjs";
+import { TheBigint, bigintFundamentalTypeKind } from "./fundamentalType/defaults/bigint.mjs";
+import { TheBoolean, booleanFundamentalTypeKind } from "./fundamentalType/defaults/boolean.mjs";
+import { TheDate, dateFundamentalTypeKind } from "./fundamentalType/defaults/date.mjs";
+import { TheNull, nullFundamentalTypeKind } from "./fundamentalType/defaults/null.mjs";
+import { TheNumber, numberFundamentalTypeKind } from "./fundamentalType/defaults/number.mjs";
+import { TheString, stringFundamentalTypeKind } from "./fundamentalType/defaults/string.mjs";
+import { TheTime, timeFundamentalTypeKind } from "./fundamentalType/defaults/time.mjs";
+import { TheUndefined, undefinedFundamentalTypeKind } from "./fundamentalType/defaults/undefined.mjs";
+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/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";
 import { ArrayLengthEqualConstraint, arrayLengthEqualConstraintKind } from "./constraint/defaults/arrayLengthEqual.mjs";
 import { BetweenThanConstraint, betweenThanConstraintKind } from "./constraint/defaults/betweenThan.mjs";
@@ -17,38 +32,35 @@ import { LessThanConstraint, lessThanConstraintKind } from "./constraint/default
 import { LessThanOrEqualConstraint, lessThanOrEqualConstraintKind } from "./constraint/defaults/lessThanOrEqual.mjs";
 import { MaxCharactersConstraint, maxCharactersConstraintKind } from "./constraint/defaults/maxCharacters.mjs";
 import { MaxElementsConstraint, maxElementsConstraintKind } from "./constraint/defaults/maxElements.mjs";
-import { MinCharactersConstraint, stringMinConstraintKind } from "./constraint/defaults/minCharacters.mjs";
+import { MinCharactersConstraint, minCharactersConstraintKind } from "./constraint/defaults/minCharacters.mjs";
 import { MinElementsConstraint, minElementsConstraintKind } from "./constraint/defaults/minElements.mjs";
 import { MultipleOfConstraint, multipleOfConstraintKind } from "./constraint/defaults/multipleOf.mjs";
 import { NegativeConstraint, negativeConstraintKind } from "./constraint/defaults/negative.mjs";
 import { NotEmptyConstraint, notEmptyConstraintKind } from "./constraint/defaults/notEmpty.mjs";
 import { NotZeroConstraint, notZeroConstraintKind } from "./constraint/defaults/notZero.mjs";
+import { NumberInStringConstraint, numberInStringConstraintKind } from "./constraint/defaults/numberInString.mjs";
 import { OddConstraint, oddConstraintKind } from "./constraint/defaults/odd.mjs";
+import { PathConstraint, pathConstraintKind } from "./constraint/defaults/path.mjs";
 import { PositiveConstraint, positiveConstraintKind } from "./constraint/defaults/positive.mjs";
 import { RefineConstraint, refineConstraintKind } from "./constraint/defaults/refine.mjs";
 import { SafeConstraint, safeConstraintKind } from "./constraint/defaults/safe.mjs";
+import { SegmentPathConstraint, segmentPathConstraintKind } from "./constraint/defaults/segmentPath.mjs";
 import { StrictNegativeConstraint, strictNegativeConstraintKind } from "./constraint/defaults/strictNegative.mjs";
 import { StrictPositiveConstraint, strictPositiveConstraintKind } from "./constraint/defaults/strictPositive.mjs";
 import { StringLengthEqualConstraint, stringLengthEqualConstraintKind } from "./constraint/defaults/stringLengthEqual.mjs";
+import { TrimmedConstraint, trimmedConstraintKind } from "./constraint/defaults/trimmed.mjs";
 import { UrlConstraint, urlConstraintKind } from "./constraint/defaults/url.mjs";
-import { UuidConstraint, uuidConstraintKind, uuidRegex } from "./constraint/defaults/uuid.mjs";
+import { UuidConstraint, uuidConstraintKind } from "./constraint/defaults/uuid.mjs";
+import { RegexConstraint, regexConstraintKind } from "./constraint/defaults/regex.mjs";
 import { constraintIdentifier } from "./constraint/identifier.mjs";
-import { createFundamentalType, fundamentalTypeKind } from "./fundamentalType/base.mjs";
-import { TheBigint } from "./fundamentalType/defaults/bigint.mjs";
-import { TheBoolean } from "./fundamentalType/defaults/boolean.mjs";
-import { TheDate } from "./fundamentalType/defaults/date.mjs";
-import { TheNull } from "./fundamentalType/defaults/null.mjs";
-import { TheNumber } from "./fundamentalType/defaults/number.mjs";
-import { TheString } from "./fundamentalType/defaults/string.mjs";
-import { TheTime } from "./fundamentalType/defaults/time.mjs";
-import { TheUndefined } from "./fundamentalType/defaults/undefined.mjs";
-import { fundamentalTypeIdentifier } from "./fundamentalType/identifier.mjs";
+import { absolutePath } from "./helpers/absolutePath.mjs";
 import { allowedCharacters } from "./helpers/allowedCharacters.mjs";
 import { StructureClass, createStructure, structureKind } from "./structure/base.mjs";
 import { ArrayStructure, arrayStructureKind } from "./structure/defaults/array.mjs";
+import { structureIdentifier } from "./structure/identifier.mjs";
 import { LazyStructure, lazyStructureKind } from "./structure/defaults/lazy.mjs";
+import { NonEncodableStringStructure, nonEncodableStringStructureKind } from "./structure/defaults/nonEncodableString.mjs";
 import { ObjectStructure, objectStructureKind } from "./structure/defaults/object.mjs";
-import { structureIdentifier } from "./structure/identifier.mjs";
 import { UnionStructure, unionStructureKind } from "./structure/defaults/union.mjs";
 import { TypeStructure, typeStructureKind } from "./structure/defaults/type.mjs";
 import { createType, typeKind } from "./type/base.mjs";
@@ -80,7 +92,9 @@ import { greaterThan } from "./helpers/greaterThan.mjs";
 import { greaterThanOrEqual } from "./helpers/greaterThanOrEqual.mjs";
 import { integer } from "./helpers/integer.mjs";
 import { isNullStructure } from "./helpers/isNullStructure.mjs";
+import { isNullable } from "./helpers/isNullable.mjs";
 import { isUndefinedStructure } from "./helpers/isUndefinedStructure.mjs";
+import { isOptional } from "./helpers/isOptional.mjs";
 import { lazy } from "./helpers/lazy.mjs";
 import { lessThan } from "./helpers/lessThan.mjs";
 import { lessThanOrEqual } from "./helpers/lessThanOrEqual.mjs";
@@ -97,25 +111,32 @@ import { notZero } from "./helpers/notZero.mjs";
 import { null as nullHelper } from "./helpers/null.mjs";
 import { nullable } from "./helpers/nullable.mjs";
 import { number } from "./helpers/number.mjs";
+import { numberInString } from "./helpers/numberInString.mjs";
 import { object } from "./helpers/object.mjs";
 import { odd } from "./helpers/odd.mjs";
 import { undefined as undefinedHelper } from "./helpers/undefined.mjs";
 import { optional } from "./helpers/optional.mjs";
 import { partial } from "./helpers/partial.mjs";
+import { path } from "./helpers/path.mjs";
 import { positive } from "./helpers/positive.mjs";
 import { record } from "./helpers/record.mjs";
 import { refine } from "./helpers/refine.mjs";
+import { regex } from "./helpers/regex.mjs";
 import { required } from "./helpers/required.mjs";
 import { safe } from "./helpers/safe.mjs";
-import { string } from "./helpers/string.mjs";
+import { segmentPath } from "./helpers/segmentPath.mjs";
 import { strictNegative } from "./helpers/strictNegative.mjs";
 import { strictPositive } from "./helpers/strictPositive.mjs";
+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 { unwrapLazy } from "./helpers/unwrapLazy.mjs";
 import { url } from "./helpers/url.mjs";
 import { uuid } from "./helpers/uuid.mjs";
 //#region scripts/dataStructure/index.ts
 var dataStructure_exports = /* @__PURE__ */ __exportAll({
+	AbsolutePathConstraint: () => AbsolutePathConstraint,
 	AllowedCharactersConstraint: () => AllowedCharactersConstraint,
 	ArrayLengthEqualConstraint: () => ArrayLengthEqualConstraint,
 	ArrayStructure: () => ArrayStructure,
@@ -125,6 +146,7 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	BigintType: () => BigintType,
 	BooleanLiteralType: () => BooleanLiteralType,
 	BooleanType: () => BooleanType,
+	ConstraintBase: () => ConstraintBase,
 	DateType: () => DateType,
 	EmailConstraint: () => EmailConstraint,
 	ErrorSymbol: () => ErrorSymbol,
@@ -141,17 +163,22 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	MinElementsConstraint: () => MinElementsConstraint,
 	MultipleOfConstraint: () => MultipleOfConstraint,
 	NegativeConstraint: () => NegativeConstraint,
+	NonEncodableStringStructure: () => NonEncodableStringStructure,
 	NotEmptyConstraint: () => NotEmptyConstraint,
 	NotZeroConstraint: () => NotZeroConstraint,
 	NullType: () => NullType,
+	NumberInStringConstraint: () => NumberInStringConstraint,
 	NumberLiteralType: () => NumberLiteralType,
 	NumberType: () => NumberType,
 	ObjectStructure: () => ObjectStructure,
 	OddConstraint: () => OddConstraint,
+	PathConstraint: () => PathConstraint,
 	PositiveConstraint: () => PositiveConstraint,
 	RecordStructure: () => RecordStructure,
 	RefineConstraint: () => RefineConstraint,
+	RegexConstraint: () => RegexConstraint,
 	SafeConstraint: () => SafeConstraint,
+	SegmentPathConstraint: () => SegmentPathConstraint,
 	StrictNegativeConstraint: () => StrictNegativeConstraint,
 	StrictPositiveConstraint: () => StrictPositiveConstraint,
 	StringLengthEqualConstraint: () => StringLengthEqualConstraint,
@@ -168,11 +195,14 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	TheTime: () => TheTime,
 	TheUndefined: () => TheUndefined,
 	TimeType: () => TimeType,
+	TrimmedConstraint: () => TrimmedConstraint,
 	TypeStructure: () => TypeStructure,
 	UndefinedType: () => UndefinedType,
 	UnionStructure: () => UnionStructure,
 	UrlConstraint: () => UrlConstraint,
 	UuidConstraint: () => UuidConstraint,
+	absolutePath: () => absolutePath,
+	absolutePathConstraintKind: () => absolutePathConstraintKind,
 	allowedCharacters: () => allowedCharacters,
 	allowedCharactersConstraintKind: () => allowedCharactersConstraintKind,
 	array: () => array,
@@ -184,28 +214,38 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	betweenThanOrEqual: () => betweenThanOrEqual,
 	betweenThanOrEqualConstraintKind: () => betweenThanOrEqualConstraintKind,
 	bigint: () => bigint,
+	bigintFundamentalTypeKind: () => bigintFundamentalTypeKind,
 	bigintLiteralTypeKind: () => bigintLiteralTypeKind,
 	bigintTypeKind: () => bigintTypeKind,
 	boolean: () => boolean,
+	booleanFundamentalTypeKind: () => booleanFundamentalTypeKind,
 	booleanLiteralTypeKind: () => booleanLiteralTypeKind,
 	booleanTypeKind: () => booleanTypeKind,
 	codecKind: () => codecKind,
+	codecsJson: () => codecsJson,
 	codecsKind: () => codecsKind,
+	codecsString: () => codecsString,
 	constraintIdentifier: () => constraintIdentifier,
 	constraintKind: () => constraintKind,
 	createCodec: () => createCodec,
 	createCodecs: () => createCodecs,
 	createConstraint: () => createConstraint,
 	createErrorHandler: () => createErrorHandler,
+	createErrorInterpreter: () => createErrorInterpreter,
 	createFundamentalType: () => createFundamentalType,
 	createGetErrorHandler: () => createGetErrorHandler,
 	createKind: () => createKind,
 	createStructure: () => createStructure,
 	createType: () => createType,
 	date: () => date,
+	dateFundamentalTypeKind: () => dateFundamentalTypeKind,
 	dateTypeKind: () => dateTypeKind,
+	decodeIssueKind: () => decodeIssueKind,
+	defaultErrorInterpreterCodecDictionary: () => defaultErrorInterpreterCodecDictionary,
+	defaultErrorInterpreterDataStructureDictionary: () => defaultErrorInterpreterDataStructureDictionary,
 	email: () => email,
 	emailConstraintKind: () => emailConstraintKind,
+	encodeIssueKind: () => encodeIssueKind,
 	even: () => even,
 	evenConstraintKind: () => evenConstraintKind,
 	extend: () => extend,
@@ -218,7 +258,10 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	integer: () => integer,
 	integerConstraintKind: () => integerConstraintKind,
 	isNullStructure: () => isNullStructure,
+	isNullable: () => isNullable,
+	isOptional: () => isOptional,
 	isUndefinedStructure: () => isUndefinedStructure,
+	issueKind: () => issueKind,
 	lazy: () => lazy,
 	lazyStructureKind: () => lazyStructureKind,
 	lessThan: () => lessThan,
@@ -231,20 +274,26 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	maxElements: () => maxElements,
 	maxElementsConstraintKind: () => maxElementsConstraintKind,
 	minCharacters: () => minCharacters,
+	minCharactersConstraintKind: () => minCharactersConstraintKind,
 	minElements: () => minElements,
 	minElementsConstraintKind: () => minElementsConstraintKind,
 	multipleOf: () => multipleOf,
 	multipleOfConstraintKind: () => multipleOfConstraintKind,
 	negative: () => negative,
 	negativeConstraintKind: () => negativeConstraintKind,
+	nonEncodableStringStructureKind: () => nonEncodableStringStructureKind,
 	notEmpty: () => notEmpty,
 	notEmptyConstraintKind: () => notEmptyConstraintKind,
 	notZero: () => notZero,
 	notZeroConstraintKind: () => notZeroConstraintKind,
 	null: () => nullHelper,
+	nullFundamentalTypeKind: () => nullFundamentalTypeKind,
 	nullTypeKind: () => nullTypeKind,
 	nullable: () => nullable,
 	number: () => number,
+	numberFundamentalTypeKind: () => numberFundamentalTypeKind,
+	numberInString: () => numberInString,
+	numberInStringConstraintKind: () => numberInStringConstraintKind,
 	numberLiteralTypeKind: () => numberLiteralTypeKind,
 	numberTypeKind: () => numberTypeKind,
 	object: () => object,
@@ -253,41 +302,51 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	oddConstraintKind: () => oddConstraintKind,
 	optional: () => optional,
 	partial: () => partial,
+	path: () => path,
+	pathConstraintKind: () => pathConstraintKind,
 	positive: () => positive,
 	positiveConstraintKind: () => positiveConstraintKind,
 	record: () => record,
 	recordStructureKind: () => recordStructureKind,
 	refine: () => refine,
 	refineConstraintKind: () => refineConstraintKind,
+	regex: () => regex,
+	regexConstraintKind: () => regexConstraintKind,
 	required: () => required,
 	safe: () => safe,
 	safeConstraintKind: () => safeConstraintKind,
+	segmentPath: () => segmentPath,
+	segmentPathConstraintKind: () => segmentPathConstraintKind,
 	strictNegative: () => strictNegative,
 	strictNegativeConstraintKind: () => strictNegativeConstraintKind,
 	strictPositive: () => strictPositive,
 	strictPositiveConstraintKind: () => strictPositiveConstraintKind,
 	string: () => string,
+	stringFundamentalTypeKind: () => stringFundamentalTypeKind,
 	stringLengthEqual: () => stringLengthEqual,
 	stringLengthEqualConstraintKind: () => stringLengthEqualConstraintKind,
 	stringLiteralTypeKind: () => stringLiteralTypeKind,
-	stringMinConstraintKind: () => stringMinConstraintKind,
 	stringTypeKind: () => stringTypeKind,
 	structureIdentifier: () => structureIdentifier,
 	structureKind: () => structureKind,
 	time: () => time,
+	timeFundamentalTypeKind: () => timeFundamentalTypeKind,
 	timeTypeKind: () => timeTypeKind,
+	trimmed: () => trimmed,
+	trimmedConstraintKind: () => trimmedConstraintKind,
 	typeIdentifier: () => typeIdentifier,
 	typeKind: () => typeKind,
 	typeStructureKind: () => typeStructureKind,
 	undefined: () => undefinedHelper,
+	undefinedFundamentalTypeKind: () => undefinedFundamentalTypeKind,
 	undefinedTypeKind: () => undefinedTypeKind,
 	union: () => union,
 	unionStructureKind: () => unionStructureKind,
+	unwrapLazy: () => unwrapLazy,
 	url: () => url,
 	urlConstraintKind: () => urlConstraintKind,
 	uuid: () => uuid,
-	uuidConstraintKind: () => uuidConstraintKind,
-	uuidRegex: () => uuidRegex
+	uuidConstraintKind: () => uuidConstraintKind
 });
 //#endregion
-export { AllowedCharactersConstraint, ArrayLengthEqualConstraint, ArrayStructure, BetweenThanConstraint, BetweenThanOrEqualConstraint, BigintLiteralType, BigintType, BooleanLiteralType, BooleanType, DateType, EmailConstraint, ErrorSymbol, EvenConstraint, GreaterThanConstraint, GreaterThanOrEqualConstraint, IntegerConstraint, LazyStructure, LessThanConstraint, LessThanOrEqualConstraint, MaxCharactersConstraint, MaxElementsConstraint, MinCharactersConstraint, MinElementsConstraint, MultipleOfConstraint, NegativeConstraint, NotEmptyConstraint, NotZeroConstraint, NullType, NumberLiteralType, NumberType, ObjectStructure, OddConstraint, PositiveConstraint, RecordStructure, RefineConstraint, SafeConstraint, StrictNegativeConstraint, StrictPositiveConstraint, StringLengthEqualConstraint, StringLiteralType, StringType, StructureClass, SuccessSymbol, TheBigint, TheBoolean, TheDate, TheNull, TheNumber, TheString, TheTime, TheUndefined, TimeType, TypeStructure, UndefinedType, UnionStructure, UrlConstraint, UuidConstraint, allowedCharacters, allowedCharactersConstraintKind, array, arrayLengthEqual, arrayLengthEqualConstraintKind, arrayStructureKind, betweenThan, betweenThanConstraintKind, betweenThanOrEqual, betweenThanOrEqualConstraintKind, bigint, bigintLiteralTypeKind, bigintTypeKind, boolean, booleanLiteralTypeKind, booleanTypeKind, codecKind, codecsKind, constraintIdentifier, constraintKind, createCodec, createCodecs, createConstraint, createErrorHandler, createFundamentalType, createGetErrorHandler, createKind, createStructure, createType, dataStructure_exports, date, dateTypeKind, email, emailConstraintKind, even, evenConstraintKind, extend, fundamentalTypeIdentifier, fundamentalTypeKind, greaterThan, greaterThanConstraintKind, greaterThanOrEqual, greaterThanOrEqualConstraintKind, integer, integerConstraintKind, isNullStructure, isUndefinedStructure, lazy, lazyStructureKind, lessThan, lessThanConstraintKind, lessThanOrEqual, lessThanOrEqualConstraintKind, literal, maxCharacters, maxCharactersConstraintKind, maxElements, maxElementsConstraintKind, minCharacters, minElements, minElementsConstraintKind, multipleOf, multipleOfConstraintKind, negative, negativeConstraintKind, notEmpty, notEmptyConstraintKind, notZero, notZeroConstraintKind, nullHelper as null, nullTypeKind, nullable, number, numberLiteralTypeKind, numberTypeKind, object, objectStructureKind, odd, oddConstraintKind, optional, partial, positive, positiveConstraintKind, record, recordStructureKind, refine, refineConstraintKind, required, safe, safeConstraintKind, strictNegative, strictNegativeConstraintKind, strictPositive, strictPositiveConstraintKind, string, stringLengthEqual, stringLengthEqualConstraintKind, stringLiteralTypeKind, stringMinConstraintKind, stringTypeKind, structureIdentifier, structureKind, time, timeTypeKind, typeIdentifier, typeKind, typeStructureKind, undefinedHelper as undefined, undefinedTypeKind, union, unionStructureKind, url, urlConstraintKind, uuid, uuidConstraintKind, uuidRegex };
+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, 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, typeStructureKind, undefinedHelper as undefined, undefinedFundamentalTypeKind, undefinedTypeKind, union, unionStructureKind, unwrapLazy, url, urlConstraintKind, uuid, uuidConstraintKind };

package/dist/dataStructure/structure/base.cjs

@@ -2,9 +2,10 @@ const require_bindPrototypeMethods = require("../../common/bindPrototypeMethods.
 const require_callThen = require("../../common/callThen.cjs");
 const require_create = require("../../either/left/create.cjs");
 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() {}
@@ -15,7 +16,9 @@ var StructureClass = class StructureClass {
 		return self;
 	}
 	static addToPrototype(prop, value) {
-		StructureClass.prototype[prop] = value;
+		StructureClass.prototype[prop] = typeof value === "function" ? function(...args) {
+			return value(this, ...args);
+		} : value;
 	}
 };
 const structureKind = require_kind.createKind("structure");
@@ -34,7 +37,7 @@ function createStructure(kindHandler, createConstructor) {
 				executeDecode,
 				isAsynchronous
 			}, ...rest),
-			executeConstraints: (data, errorHandler) => definition.constraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : constraint.executeCheck(data, errorHandler)), require_resultSymbol.SuccessSymbol),
+			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),
@@ -47,33 +50,33 @@ 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 === 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);
 			},
-			is: (data, errorHandler) => {
-				const result = self.executeCheck(data, errorHandler);
+			is: (data) => {
+				const result = self.executeCheck(data);
 				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();
+				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 === 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();
+				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);
@@ -81,25 +84,32 @@ function createStructure(kindHandler, createConstructor) {
 			decode: (codecs, data) => self.unsafeDecode(codecs, data),
 			asyncDecode: (codecs, data) => self.asyncUnsafeDecode(codecs, data),
 			unsafeDecode: (codecs, data) => {
-				const errorHandler = require_error.createGetErrorHandler();
+				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 === 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();
+				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);
 			},
 			contract: () => self,
-			clone: () => init(definition, {
+			clone: () => init(require_simpleClone.simpleClone(definition), {
 				executeCheck,
 				executeEncode,
 				executeDecode,
 				isAsynchronous
 			}, ...rest),
+			setMessage: (message) => {
+				self.definition.message = message;
+				return self;
+			},
+			addMessage: (message) => {
+				return self.clone().setMessage(message);
+			},
 			[kindHandler.runTimeKey]: null,
 			[structureKind.runTimeKey]: null
 		});

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

@@ -7,15 +7,16 @@ import * as DCommon from '../../common';
 export declare class StructureClass {
     private constructor();
     static init(params: DKind.Remove<Structure>): Structure;
-    static addToPrototype<GenericProp extends keyof Structure>(prop: GenericProp, value: Structure[GenericProp]): void;
+    static addToPrototype<GenericProp extends keyof Structure>(prop: GenericProp, value: Structure[GenericProp] extends infer InferredValue ? InferredValue extends DCommon.AnyFunction ? (self: Structure, ...rest: Parameters<InferredValue>) => ReturnType<InferredValue> : Structure[GenericProp] : never): void;
 }
 export declare const structureKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", unknown>>;
 export interface StructureDefinition<GenericConstraints extends readonly Constraint<any>[] = readonly Constraint<any>[]> {
+    readonly message?: string;
     readonly constraints: readonly [...GenericConstraints];
 }
-export interface Structure<GenericValue extends unknown = unknown, 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, (GenericValue & StructureConstraintsValue<GenericDefinition["constraints"][number]>)> {
     readonly definition: GenericDefinition;
-    addConstraint<const GenericNewConstraints extends DCommon.AnyTuple<Constraint<GenericValue>>>(...args: DCommon.FixDeepFunctionInfer<DCommon.AnyTuple<Constraint<GenericValue>>, GenericNewConstraints>): Structure<GenericValue, StructureDefinition<readonly [...this["definition"]["constraints"], ...GenericNewConstraints]>>;
+    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]>>;
     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;
@@ -23,7 +24,7 @@ export interface Structure<GenericValue extends unknown = unknown, GenericDefini
     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, errorHandler?: GetErrorHandler): data is StructureValue<this>;
+    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>);
@@ -34,6 +35,8 @@ export interface Structure<GenericValue extends unknown = unknown, GenericDefini
     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>;
     clone(): this;
+    setMessage(massage: string): this;
+    addMessage(massage: string): this;
 }
 export interface CreateStructureInitParams<GenericStructure extends Structure = Structure> {
     executeCheck(self: GenericStructure, data: unknown, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
@@ -45,6 +48,6 @@ export type CreateStructureInitRest<GenericStructure extends Structure = Structu
     [Prop in Exclude<keyof GenericStructure, keyof Structure>]: GenericStructure[Prop] extends DCommon.AnyFunction ? (self: GenericStructure, ...args: Parameters<GenericStructure[Prop]>) => ReturnType<GenericStructure[Prop]> : GenericStructure[Prop];
 };
 export interface CreateStructureConstructorParams<GenericKindHandler extends DKind.Handler = DKind.Handler> {
-    init<GenericStructure extends (Structure & DKind.Kind<GenericKindHandler>)>(definition: GenericStructure["definition"], params: CreateStructureInitParams<GenericStructure>, ...args: DCommon.IsNever<Exclude<keyof GenericStructure, keyof Structure>> extends true ? [] : [rest: CreateStructureInitRest<GenericStructure>]): GenericStructure;
+    init<GenericStructure extends (Structure & DKind.Kind<GenericKindHandler>)>(definition: GenericStructure["definition"], params: CreateStructureInitParams<GenericStructure>, ...args: DCommon.IsNever<Exclude<keyof GenericStructure, keyof Structure>> extends true ? [] : [rest: CreateStructureInitRest<GenericStructure>]): NoInfer<GenericStructure>;
 }
 export declare function createStructure<GenericKindHandler extends DKind.Handler, GenericConstructor extends ((...args: any[]) => (Structure & DKind.Kind<GenericKindHandler>))>(kindHandler: GenericKindHandler, createConstructor: (params: CreateStructureConstructorParams<GenericKindHandler>) => GenericConstructor): GenericConstructor;

package/dist/dataStructure/structure/base.mjs

@@ -2,9 +2,10 @@ import { bindPrototypeMethods } from "../../common/bindPrototypeMethods.mjs";
 import { callThen } from "../../common/callThen.mjs";
 import { left } from "../../either/left/create.mjs";
 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 { createGetErrorHandler } from "../common/error/base.mjs";
 //#region scripts/dataStructure/structure/base.ts
 var StructureClass = class StructureClass {
 	constructor() {}
@@ -15,7 +16,9 @@ var StructureClass = class StructureClass {
 		return self;
 	}
 	static addToPrototype(prop, value) {
-		StructureClass.prototype[prop] = value;
+		StructureClass.prototype[prop] = typeof value === "function" ? function(...args) {
+			return value(this, ...args);
+		} : value;
 	}
 };
 const structureKind = createKind("structure");
@@ -34,7 +37,7 @@ function createStructure(kindHandler, createConstructor) {
 				executeDecode,
 				isAsynchronous
 			}, ...rest),
-			executeConstraints: (data, errorHandler) => definition.constraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : constraint.executeCheck(data, errorHandler)), SuccessSymbol),
+			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),
@@ -58,8 +61,8 @@ function createStructure(kindHandler, createConstructor) {
 				if (await self.executeCheck(data, errorHandler) === ErrorSymbol) return left("check-error", errorHandler().createError());
 				return right("check-success", data);
 			},
-			is: (data, errorHandler) => {
-				const result = self.executeCheck(data, errorHandler);
+			is: (data) => {
+				const result = self.executeCheck(data);
 				if (result instanceof Promise || result === ErrorSymbol) return false;
 				return true;
 			},
@@ -94,12 +97,19 @@ function createStructure(kindHandler, createConstructor) {
 				return right("decode-success", result);
 			},
 			contract: () => self,
-			clone: () => init(definition, {
+			clone: () => init(simpleClone(definition), {
 				executeCheck,
 				executeEncode,
 				executeDecode,
 				isAsynchronous
 			}, ...rest),
+			setMessage: (message) => {
+				self.definition.message = message;
+				return self;
+			},
+			addMessage: (message) => {
+				return self.clone().setMessage(message);
+			},
 			[kindHandler.runTimeKey]: null,
 			[structureKind.runTimeKey]: null
 		});

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

@@ -13,6 +13,6 @@ export declare const arrayStructureKind: DKind.Handler<DKind.Definition<"@Duploj
 export interface ArrayStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
     readonly element: Structure;
 }
-export interface ArrayStructure<GenericValue extends readonly unknown[] = readonly unknown[], GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<Structure<GenericValue, ArrayStructureDefinition<GenericConstraints>> & DKind.Kind<typeof arrayStructureKind>> {
+export interface ArrayStructure<out GenericValue extends readonly unknown[] = readonly unknown[], out GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, ArrayStructureDefinition<GenericConstraints>> & DKind.Kind<typeof arrayStructureKind>> {
 }
-export declare const ArrayStructure: <GenericElement extends Structure, const GenericConstraints extends readonly Constraint<readonly StructureValue<GenericElement>[]>[]>(element: GenericElement, constraints: GenericConstraints) => ArrayStructure<readonly StructureValue<GenericElement>[], readonly [...GenericConstraints]>;
+export declare const ArrayStructure: <GenericElement extends Structure, const GenericConstraints extends readonly Constraint<readonly StructureValue<GenericElement>[]>[]>(element: GenericElement, constraints: GenericConstraints) => NoInfer<ArrayStructure<readonly StructureValue<GenericElement>[], readonly [...GenericConstraints]>>;

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

@@ -1,5 +1,6 @@
 export * from './array';
 export * from './lazy';
+export * from './nonEncodableString';
 export * from './object';
 export * from './record';
 export * from './type';

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

@@ -1,15 +1,22 @@
+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_base = require("../base.cjs");
+const require_identifier = require("../identifier.cjs");
 //#region scripts/dataStructure/structure/defaults/lazy.ts
 const lazyStructureKind = require_kind.createKind("lazy-structure");
 const LazyStructure = require_base.createStructure(lazyStructureKind, ({ init }) => (getStructure, constraints) => init({
-	getter: require_memo.memo(getStructure),
+	getter: require_memo.memo(() => {
+		const dataStructure = getStructure();
+		if (require_identifier.structureIdentifier(dataStructure, lazyStructureKind)) return dataStructure.definition.getter.value;
+		return dataStructure;
+	}),
 	constraints
 }, {
 	executeCheck: (self, data, errorHandler) => self.definition.getter.value.executeCheck(data, errorHandler),
-	executeEncode: (self, codecContext, data, errorHandler) => self.definition.getter.value.executeEncode(codecContext, data, errorHandler),
-	executeDecode: (self, codecContext, data, errorHandler) => self.definition.getter.value.executeDecode(codecContext, 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)),
 	isAsynchronous: (self) => self.definition.getter.value.isAsynchronous()
 }));
 //#endregion

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

@@ -7,6 +7,6 @@ export declare const lazyStructureKind: DKind.Handler<DKind.Definition<"@Duplojs
 export interface LazyStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
     readonly getter: DCommon.Memoized<Structure>;
 }
-export interface LazyStructure<GenericValue extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<Structure<GenericValue, LazyStructureDefinition<GenericConstraints>> & DKind.Kind<typeof lazyStructureKind>> {
+export interface LazyStructure<out GenericValue extends unknown = unknown, out GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, LazyStructureDefinition<GenericConstraints>> & DKind.Kind<typeof lazyStructureKind>> {
 }
-export declare const LazyStructure: <GenericStructure extends Structure, const GenericConstraints extends readonly Constraint<StructureValue<GenericStructure>>[]>(getStructure: () => GenericStructure, constraints: GenericConstraints) => LazyStructure<StructureValue<GenericStructure>, readonly [...GenericConstraints]>;
+export declare const LazyStructure: <GenericStructure extends Structure, const GenericConstraints extends readonly Constraint<StructureValue<GenericStructure>>[]>(getStructure: () => GenericStructure, constraints: GenericConstraints) => NoInfer<LazyStructure<StructureValue<GenericStructure>, readonly [...GenericConstraints]>>;

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

@@ -1,15 +1,22 @@
+import { callThen } from "../../../common/callThen.mjs";
 import { memo } from "../../../common/memo.mjs";
 import { createKind } from "../../kind.mjs";
+import { ErrorSymbol } from "../../common/resultSymbol.mjs";
 import { createStructure } from "../base.mjs";
+import { structureIdentifier } from "../identifier.mjs";
 //#region scripts/dataStructure/structure/defaults/lazy.ts
 const lazyStructureKind = createKind("lazy-structure");
 const LazyStructure = createStructure(lazyStructureKind, ({ init }) => (getStructure, constraints) => init({
-	getter: memo(getStructure),
+	getter: memo(() => {
+		const dataStructure = getStructure();
+		if (structureIdentifier(dataStructure, lazyStructureKind)) return dataStructure.definition.getter.value;
+		return dataStructure;
+	}),
 	constraints
 }, {
 	executeCheck: (self, data, errorHandler) => self.definition.getter.value.executeCheck(data, errorHandler),
-	executeEncode: (self, codecContext, data, errorHandler) => self.definition.getter.value.executeEncode(codecContext, data, errorHandler),
-	executeDecode: (self, codecContext, data, errorHandler) => self.definition.getter.value.executeDecode(codecContext, 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)),
 	isAsynchronous: (self) => self.definition.getter.value.isAsynchronous()
 }));
 //#endregion