@duplojs/lang 0.0.1-beta.5 → 0.0.1-beta.7

package/dist/common/constraint/cast/string.d.ts

@@ -9,10 +9,14 @@ export interface ComputeCastConstraintStringRule<GenericValue extends string, Ge
     lengthEqual: GenericExpectedConstraint extends DString.LengthEqual<number> ? DCommon.NeverCoalescing<(DString.ComputeLengthEqualCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : CastError<`Impossible to cast on LengthEqual<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is not equal.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on LengthEqual because value does not have LengthEqual constraint.", GenericValue, GenericExpectedConstraint>> : never;
     path: DCommon.IsExtends<GenericExpectedConstraint, DPath.Path> extends true ? DCommon.Or<[
         DPath.IsLiteralPath<GenericValue>,
-        DCommon.IsExtends<GenericValue, DPath.Path | DPath.Absolute>
+        DCommon.IsExtends<GenericValue, DPath.Path | DPath.Absolute | DPath.Segment>
     ]> extends true ? unknown : CastError<`Impossible to cast on Path because value ${GenericValue} is not path.`, GenericValue, GenericExpectedConstraint> : never;
     absolutePath: DCommon.IsExtends<GenericExpectedConstraint, DPath.Absolute> extends true ? DCommon.Or<[
         DPath.IsLiteralAbsolutePath<GenericValue>,
         DCommon.IsExtends<GenericValue, DPath.Absolute>
-    ]> extends true ? unknown : CastError<`Impossible to cast on Absolute Path because value ${GenericValue} is not absolute path.`, GenericValue, GenericExpectedConstraint> : never;
+    ]> extends true ? unknown : CastError<`Impossible to cast on AbsolutePath because value ${GenericValue} is not absolute path.`, GenericValue, GenericExpectedConstraint> : never;
+    segment: DCommon.IsExtends<GenericExpectedConstraint, DPath.Segment> extends true ? DCommon.Or<[
+        DPath.IsLiteralSegmentPath<GenericValue>,
+        DCommon.IsExtends<GenericValue, DPath.Segment>
+    ]> extends true ? unknown : CastError<`Impossible to cast on SegmentPath because value ${GenericValue} is not segment path.`, GenericValue, GenericExpectedConstraint> : never;
 }

package/dist/common/constraint/infer/string.d.ts

@@ -5,6 +5,7 @@ export interface ComputeInferConstraintStringRule<GenericInput extends string, G
     maxCharacters: DString.ComputeMaxCharactersCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.MaxCharacters<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MaxCharacters<${InferredResult["to"]}> because constraint MaxCharacters<${InferredResult["from"]}> from the value is more than.`> : never;
     minCharacters: DString.ComputeMinCharactersCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.MinCharacters<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MinCharacters<${InferredResult["to"]}> because constraint MinCharacters<${InferredResult["from"]}> from the value is less than.`> : never;
     lengthEqual: DString.ComputeLengthEqualCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.LengthEqual<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on LengthEqual<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is not equal.`> : never;
-    path: DCommon.IsExtends<GenericOutput, DPath.Path | DPath.Absolute> extends true ? DPath.IsLiteralPath<GenericInput> extends true ? DPath.Path : DCommon.ComputedTypeError<`Impossible to cast on Path because value ${GenericInput} is not path.`> : never;
-    absolutePath: DCommon.IsExtends<GenericOutput, DPath.Absolute> extends true ? DPath.IsLiteralAbsolutePath<GenericInput> extends true ? DPath.Absolute : DCommon.ComputedTypeError<`Impossible to cast on Absolute Path because value ${GenericInput} is not absolute path.`> : never;
+    path: DCommon.IsExtends<GenericOutput, DPath.Path> extends true ? DPath.IsLiteralPath<GenericInput> extends true ? DPath.Path : DCommon.ComputedTypeError<`Impossible to cast on Path because value ${GenericInput} is not path.`> : never;
+    absolutePath: DCommon.IsExtends<GenericOutput, DPath.Absolute> extends true ? DPath.IsLiteralAbsolutePath<GenericInput> extends true ? DPath.Absolute : DCommon.ComputedTypeError<`Impossible to cast on AbsolutePath because value ${GenericInput} is not absolute path.`> : never;
+    segment: DCommon.IsExtends<GenericOutput, DPath.Segment> extends true ? DPath.IsLiteralSegmentPath<GenericInput> extends true ? DPath.Segment : DCommon.ComputedTypeError<`Impossible to cast on SegmentPath because value ${GenericInput} is not segment path.`> : never;
 }

package/dist/common/types/json.d.ts

@@ -1,4 +1,4 @@
 import { MaybeArray } from './maybeArray';
 export type Json = MaybeArray<string | undefined | boolean | number | null | {
-    [key: string]: Json;
+    readonly [key: string]: Json;
 }>;

package/dist/dataStructure/constraint/base.cjs

@@ -1,9 +1,24 @@
+const require_bindPrototypeMethods = require("../../common/bindPrototypeMethods.cjs");
 const require_simpleClone = require("../../common/simpleClone.cjs");
 //#region scripts/dataStructure/constraint/base.ts
 const constraintKind = require("../kind.cjs").createKind("constraint");
+var ConstraintBase = class ConstraintBase {
+	constructor() {}
+	static init(params) {
+		const self = new ConstraintBase();
+		require_bindPrototypeMethods.bindPrototypeMethods(self);
+		for (const key in params) self[key] = params[key];
+		return self;
+	}
+	static addToPrototype(prop, value) {
+		ConstraintBase.prototype[prop] = typeof value === "function" ? function(...args) {
+			return value(this, ...args);
+		} : value;
+	}
+};
 function createConstraint(kindHandler, createConstructor) {
 	const init = (definition, { executeCheck, isAsynchronous }) => {
-		const self = {
+		const self = ConstraintBase.init({
 			definition,
 			executeCheck: (data) => executeCheck(self, data),
 			isAsynchronous: () => isAsynchronous(self),
@@ -20,11 +35,12 @@ function createConstraint(kindHandler, createConstructor) {
 			},
 			[constraintKind.runTimeKey]: null,
 			[kindHandler.runTimeKey]: null
-		};
+		});
 		return self;
 	};
 	return createConstructor({ init });
 }
 //#endregion
+exports.ConstraintBase = ConstraintBase;
 exports.constraintKind = constraintKind;
 exports.createConstraint = createConstraint;

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

@@ -19,6 +19,11 @@ export interface CreateConstraintInitParams<GenericConstraint extends Constraint
     executeCheck(self: GenericConstraint, data: Parameters<GenericConstraint["executeCheck"]>[0]): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     isAsynchronous(self: GenericConstraint): boolean;
 }
+export declare class ConstraintBase {
+    private constructor();
+    static init(params: DKind.Remove<Constraint>): Constraint;
+    static addToPrototype<GenericProp extends keyof Constraint>(prop: GenericProp, value: Constraint[GenericProp] extends infer InferredValue ? InferredValue extends DCommon.AnyFunction ? (self: Constraint, ...rest: Parameters<InferredValue>) => ReturnType<InferredValue> : Constraint[GenericProp] : never): void;
+}
 export interface CreateConstraintConstructorParams<GenericKindHandler extends DKind.Handler = DKind.Handler> {
     init<GenericConstraint extends (Constraint & DKind.Kind<GenericKindHandler>)>(definition: GenericConstraint["definition"], params: CreateConstraintInitParams<GenericConstraint>): GenericConstraint;
 }

package/dist/dataStructure/constraint/base.mjs

@@ -1,10 +1,25 @@
+import { bindPrototypeMethods } from "../../common/bindPrototypeMethods.mjs";
 import { simpleClone } from "../../common/simpleClone.mjs";
 import { createKind } from "../kind.mjs";
 //#region scripts/dataStructure/constraint/base.ts
 const constraintKind = createKind("constraint");
+var ConstraintBase = class ConstraintBase {
+	constructor() {}
+	static init(params) {
+		const self = new ConstraintBase();
+		bindPrototypeMethods(self);
+		for (const key in params) self[key] = params[key];
+		return self;
+	}
+	static addToPrototype(prop, value) {
+		ConstraintBase.prototype[prop] = typeof value === "function" ? function(...args) {
+			return value(this, ...args);
+		} : value;
+	}
+};
 function createConstraint(kindHandler, createConstructor) {
 	const init = (definition, { executeCheck, isAsynchronous }) => {
-		const self = {
+		const self = ConstraintBase.init({
 			definition,
 			executeCheck: (data) => executeCheck(self, data),
 			isAsynchronous: () => isAsynchronous(self),
@@ -21,10 +36,10 @@ function createConstraint(kindHandler, createConstructor) {
 			},
 			[constraintKind.runTimeKey]: null,
 			[kindHandler.runTimeKey]: null
-		};
+		});
 		return self;
 	};
 	return createConstructor({ init });
 }
 //#endregion
-export { constraintKind, createConstraint };
+export { ConstraintBase, constraintKind, createConstraint };

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

@@ -23,6 +23,7 @@ export * from './path';
 export * from './positive';
 export * from './refine';
 export * from './safe';
+export * from './segmentPath';
 export * from './strictNegative';
 export * from './strictPositive';
 export * from './stringLengthEqual';

package/dist/dataStructure/constraint/defaults/segmentPath.cjs

@@ -0,0 +1,13 @@
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+const require_base = require("../base.cjs");
+const require_isSegment = require("../../../path/isSegment.cjs");
+//#region scripts/dataStructure/constraint/defaults/segmentPath.ts
+const segmentPathConstraintKind = require_kind.createKind("segment-path-constraint");
+const SegmentPathConstraint = require_base.createConstraint(segmentPathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => require_isSegment.isSegment(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.SegmentPathConstraint = SegmentPathConstraint;
+exports.segmentPathConstraintKind = segmentPathConstraintKind;

package/dist/dataStructure/constraint/defaults/segmentPath.d.ts

@@ -0,0 +1,10 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+import * as DPath from '../../../path';
+export declare const segmentPathConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/segment-path-constraint", unknown>>;
+export interface SegmentPathConstraintDefinition extends ConstraintDefinition {
+}
+export interface SegmentPathConstraint extends DCommon.Forward<Constraint<string, string & DPath.Segment, SegmentPathConstraintDefinition> & DKind.Kind<typeof segmentPathConstraintKind>> {
+}
+export declare const SegmentPathConstraint: () => SegmentPathConstraint;

package/dist/dataStructure/constraint/defaults/segmentPath.mjs

@@ -0,0 +1,12 @@
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+import { createConstraint } from "../base.mjs";
+import { isSegment } from "../../../path/isSegment.mjs";
+//#region scripts/dataStructure/constraint/defaults/segmentPath.ts
+const segmentPathConstraintKind = createKind("segment-path-constraint");
+const SegmentPathConstraint = createConstraint(segmentPathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => isSegment(data) ? SuccessSymbol : ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { SegmentPathConstraint, segmentPathConstraintKind };

package/dist/dataStructure/constraint/types/constraints.d.ts

@@ -1,7 +1,6 @@
 import { Constraint } from '../base';
 import type * as DDefaults from "../defaults";
 export interface ConstraintsStore {
-    absolutePath: DDefaults.AbsolutePathConstraint;
     allowedCharacters: DDefaults.AllowedCharactersConstraint;
     email: DDefaults.EmailConstraint;
     url: DDefaults.UrlConstraint;
@@ -31,7 +30,9 @@ export interface ConstraintsStore {
     greaterThanOrEqual: DDefaults.GreaterThanOrEqualConstraint;
     lessThan: DDefaults.LessThanConstraint;
     lessThanOrEqual: DDefaults.LessThanOrEqualConstraint;
+    absolutePath: DDefaults.AbsolutePathConstraint;
     path: DDefaults.PathConstraint;
+    segmentPath: DDefaults.SegmentPathConstraint;
     refine: DDefaults.RefineConstraint;
 }
 export type Constraints = Extract<ConstraintsStore[keyof ConstraintsStore], Constraint>;

package/dist/dataStructure/helpers/index.d.ts

@@ -40,6 +40,7 @@ export * from './record';
 export * from './refine';
 export * from './required';
 export * from './safe';
+export * from './segmentPath';
 export * from './string';
 export * from './strictNegative';
 export * from './strictPositive';

package/dist/dataStructure/helpers/segmentPath.cjs

@@ -0,0 +1,7 @@
+const require_segmentPath = require("../constraint/defaults/segmentPath.cjs");
+//#region scripts/dataStructure/helpers/segmentPath.ts
+function segmentPath() {
+	return require_segmentPath.SegmentPathConstraint();
+}
+//#endregion
+exports.segmentPath = segmentPath;

package/dist/dataStructure/helpers/segmentPath.d.ts

@@ -0,0 +1,2 @@
+import { SegmentPathConstraint } from '../constraint';
+export declare function segmentPath(): SegmentPathConstraint;

package/dist/dataStructure/helpers/segmentPath.mjs

@@ -0,0 +1,7 @@
+import { SegmentPathConstraint } from "../constraint/defaults/segmentPath.mjs";
+//#region scripts/dataStructure/helpers/segmentPath.ts
+function segmentPath() {
+	return SegmentPathConstraint();
+}
+//#endregion
+export { segmentPath };

package/dist/dataStructure/index.cjs

@@ -30,6 +30,7 @@ const require_path = require("./constraint/defaults/path.cjs");
 const require_positive = require("./constraint/defaults/positive.cjs");
 const require_refine = require("./constraint/defaults/refine.cjs");
 const require_safe = require("./constraint/defaults/safe.cjs");
+const require_segmentPath = require("./constraint/defaults/segmentPath.cjs");
 const require_strictNegative = require("./constraint/defaults/strictNegative.cjs");
 const require_strictPositive = require("./constraint/defaults/strictPositive.cjs");
 const require_stringLengthEqual = require("./constraint/defaults/stringLengthEqual.cjs");
@@ -115,6 +116,7 @@ const require_record$1 = require("./helpers/record.cjs");
 const require_refine$1 = require("./helpers/refine.cjs");
 const require_required = require("./helpers/required.cjs");
 const require_safe$1 = require("./helpers/safe.cjs");
+const require_segmentPath$1 = require("./helpers/segmentPath.cjs");
 const require_string$2 = require("./helpers/string.cjs");
 const require_strictNegative$1 = require("./helpers/strictNegative.cjs");
 const require_strictPositive$1 = require("./helpers/strictPositive.cjs");
@@ -136,6 +138,7 @@ var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	BigintType: () => require_bigint$1.BigintType,
 	BooleanLiteralType: () => require_booleanLiteral.BooleanLiteralType,
 	BooleanType: () => require_boolean$1.BooleanType,
+	ConstraintBase: () => require_base.ConstraintBase,
 	DateType: () => require_date$1.DateType,
 	EmailConstraint: () => require_email.EmailConstraint,
 	ErrorSymbol: () => require_resultSymbol.ErrorSymbol,
@@ -166,6 +169,7 @@ var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	RefineConstraint: () => require_refine.RefineConstraint,
 	RegexConstraint: () => require_regex.RegexConstraint,
 	SafeConstraint: () => require_safe.SafeConstraint,
+	SegmentPathConstraint: () => require_segmentPath.SegmentPathConstraint,
 	StrictNegativeConstraint: () => require_strictNegative.StrictNegativeConstraint,
 	StrictPositiveConstraint: () => require_strictPositive.StrictPositiveConstraint,
 	StringLengthEqualConstraint: () => require_stringLengthEqual.StringLengthEqualConstraint,
@@ -294,6 +298,8 @@ var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	required: () => require_required.required,
 	safe: () => require_safe$1.safe,
 	safeConstraintKind: () => require_safe.safeConstraintKind,
+	segmentPath: () => require_segmentPath$1.segmentPath,
+	segmentPathConstraintKind: () => require_segmentPath.segmentPathConstraintKind,
 	strictNegative: () => require_strictNegative$1.strictNegative,
 	strictNegativeConstraintKind: () => require_strictNegative.strictNegativeConstraintKind,
 	strictPositive: () => require_strictPositive$1.strictPositive,
@@ -335,6 +341,7 @@ exports.BigintLiteralType = require_bigintLiteral.BigintLiteralType;
 exports.BigintType = require_bigint$1.BigintType;
 exports.BooleanLiteralType = require_booleanLiteral.BooleanLiteralType;
 exports.BooleanType = require_boolean$1.BooleanType;
+exports.ConstraintBase = require_base.ConstraintBase;
 exports.DateType = require_date$1.DateType;
 exports.EmailConstraint = require_email.EmailConstraint;
 exports.ErrorSymbol = require_resultSymbol.ErrorSymbol;
@@ -365,6 +372,7 @@ exports.RecordStructure = require_record.RecordStructure;
 exports.RefineConstraint = require_refine.RefineConstraint;
 exports.RegexConstraint = require_regex.RegexConstraint;
 exports.SafeConstraint = require_safe.SafeConstraint;
+exports.SegmentPathConstraint = require_segmentPath.SegmentPathConstraint;
 exports.StrictNegativeConstraint = require_strictNegative.StrictNegativeConstraint;
 exports.StrictPositiveConstraint = require_strictPositive.StrictPositiveConstraint;
 exports.StringLengthEqualConstraint = require_stringLengthEqual.StringLengthEqualConstraint;
@@ -499,6 +507,8 @@ exports.regexConstraintKind = require_regex.regexConstraintKind;
 exports.required = require_required.required;
 exports.safe = require_safe$1.safe;
 exports.safeConstraintKind = require_safe.safeConstraintKind;
+exports.segmentPath = require_segmentPath$1.segmentPath;
+exports.segmentPathConstraintKind = require_segmentPath.segmentPathConstraintKind;
 exports.strictNegative = require_strictNegative$1.strictNegative;
 exports.strictNegativeConstraintKind = require_strictNegative.strictNegativeConstraintKind;
 exports.strictPositive = require_strictPositive$1.strictPositive;

package/dist/dataStructure/index.mjs

@@ -4,7 +4,7 @@ import { ErrorSymbol, SuccessSymbol } from "./common/resultSymbol.mjs";
 import { codecKind, codecsKind, createCodec, createCodecs } from "./common/codec.mjs";
 import { createErrorHandler, createGetErrorHandler, decodeIssueKind, encodeIssueKind, issueKind } from "./common/error.mjs";
 import { createErrorInterpreter } from "./common/errorInterpreter.mjs";
-import { constraintKind, createConstraint } from "./constraint/base.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";
@@ -30,6 +30,7 @@ import { PathConstraint, pathConstraintKind } from "./constraint/defaults/path.m
 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";
@@ -115,6 +116,7 @@ import { record } from "./helpers/record.mjs";
 import { refine } from "./helpers/refine.mjs";
 import { required } from "./helpers/required.mjs";
 import { safe } from "./helpers/safe.mjs";
+import { segmentPath } from "./helpers/segmentPath.mjs";
 import { string } from "./helpers/string.mjs";
 import { strictNegative } from "./helpers/strictNegative.mjs";
 import { strictPositive } from "./helpers/strictPositive.mjs";
@@ -136,6 +138,7 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	BigintType: () => BigintType,
 	BooleanLiteralType: () => BooleanLiteralType,
 	BooleanType: () => BooleanType,
+	ConstraintBase: () => ConstraintBase,
 	DateType: () => DateType,
 	EmailConstraint: () => EmailConstraint,
 	ErrorSymbol: () => ErrorSymbol,
@@ -166,6 +169,7 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	RefineConstraint: () => RefineConstraint,
 	RegexConstraint: () => RegexConstraint,
 	SafeConstraint: () => SafeConstraint,
+	SegmentPathConstraint: () => SegmentPathConstraint,
 	StrictNegativeConstraint: () => StrictNegativeConstraint,
 	StrictPositiveConstraint: () => StrictPositiveConstraint,
 	StringLengthEqualConstraint: () => StringLengthEqualConstraint,
@@ -294,6 +298,8 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	required: () => required,
 	safe: () => safe,
 	safeConstraintKind: () => safeConstraintKind,
+	segmentPath: () => segmentPath,
+	segmentPathConstraintKind: () => segmentPathConstraintKind,
 	strictNegative: () => strictNegative,
 	strictNegativeConstraintKind: () => strictNegativeConstraintKind,
 	strictPositive: () => strictPositive,
@@ -325,4 +331,4 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	uuidConstraintKind: () => uuidConstraintKind
 });
 //#endregion
-export { AbsolutePathConstraint, 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, NonEncodableStringStructure, NotEmptyConstraint, NotZeroConstraint, NullType, NumberLiteralType, NumberType, ObjectStructure, OddConstraint, PathConstraint, PositiveConstraint, RecordStructure, RefineConstraint, RegexConstraint, SafeConstraint, 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, codecsKind, 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, 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, numberLiteralTypeKind, numberTypeKind, object, objectStructureKind, odd, oddConstraintKind, optional, partial, path, pathConstraintKind, positive, positiveConstraintKind, record, recordStructureKind, refine, refineConstraintKind, regex, regexConstraintKind, required, safe, safeConstraintKind, 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, url, urlConstraintKind, uuid, uuidConstraintKind };
+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, 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, codecsKind, 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, 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, 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, url, urlConstraintKind, uuid, uuidConstraintKind };

package/dist/modeling/entity/base.d.ts

@@ -24,14 +24,14 @@ export declare const entityStructureKind: DKind.Handler<DKind.Definition<"@Duplo
 export interface EntityStructureDefinition extends DDataStructure.StructureDefinition<readonly []> {
     readonly inner: DCommon.Memoized<DDataStructure.ObjectStructure>;
 }
-export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.RemoveConstraint<GenericValue>> = GenericRawValue extends NewType ? NewTypeMap<GenericRawValue> : GenericRawValue extends Entity ? GenericRawValue : GenericRawValue extends object ? DCommon.Or<[
+export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.RemoveConstraint<GenericValue>> = GenericRawValue extends NewType ? NewTypeMap<GenericRawValue> : GenericRawValue extends object ? DCommon.Or<[
     DCommon.IsExtends<GenericRawValue, readonly any[]>,
     DCommon.And<[
         DCommon.IsExtends<keyof GenericRawValue, string>,
         DCommon.Not<DCommon.IsExtends<DCommon.AnyFunction, GenericRawValue[keyof GenericRawValue]>>
     ]>
 ]> extends true ? {
-    [Prop in keyof GenericRawValue]: NewTypeMap<GenericRawValue[Prop]>;
+    [Prop in keyof GenericRawValue]: EntityMap<GenericRawValue[Prop]>;
 } : GenericRawValue : GenericRawValue;
 export interface EntityStructure<GenericName extends string = string, GenericProperties extends Record<string, unknown> = Record<string, unknown>> extends DCommon.Forward<DDataStructure.Structure<Entity<GenericName> & GenericProperties, EntityStructureDefinition> & DKind.Kind<typeof entityStructureKind>> {
     readonly name: GenericName;

package/dist/modeling/entity/namespace.cjs

@@ -7,7 +7,7 @@ const namespaceKind = require_kind.createKind("namespace");
 function createEntityNamespace(entityName) {
 	return {
 		name: entityName,
-		createNewType: (name, structure, newTypeConstraints = []) => require_helper$1.createNewEntity(`${entityName}${name}`, structure, newTypeConstraints),
+		createNewType: (name, structure, newTypeConstraints = []) => require_helper$1.createNewType(`${entityName}${name}`, structure, newTypeConstraints),
 		createEntity: (shape) => require_helper.createEntity(entityName, shape),
 		createFlag: (entityStructure, name, valueStructure) => require_base.createFlag(entityStructure, `${entityName}${name}`, valueStructure),
 		[namespaceKind.runTimeKey]: null

package/dist/modeling/entity/namespace.mjs

@@ -1,13 +1,13 @@
 import { createKind } from "../kind.mjs";
 import { createEntity } from "./helper.mjs";
-import { createNewEntity } from "../newType/helper.mjs";
+import { createNewType } from "../newType/helper.mjs";
 import { createFlag } from "../flag/base.mjs";
 //#region scripts/modeling/entity/namespace.ts
 const namespaceKind = createKind("namespace");
 function createEntityNamespace(entityName) {
 	return {
 		name: entityName,
-		createNewType: (name, structure, newTypeConstraints = []) => createNewEntity(`${entityName}${name}`, structure, newTypeConstraints),
+		createNewType: (name, structure, newTypeConstraints = []) => createNewType(`${entityName}${name}`, structure, newTypeConstraints),
 		createEntity: (shape) => createEntity(entityName, shape),
 		createFlag: (entityStructure, name, valueStructure) => createFlag(entityStructure, `${entityName}${name}`, valueStructure),
 		[namespaceKind.runTimeKey]: null

package/dist/modeling/index.cjs

@@ -17,7 +17,7 @@ var modeling_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	createEntityNamespace: () => require_namespace.createEntityNamespace,
 	createFlag: () => require_base$2.createFlag,
 	createKind: () => require_kind.createKind,
-	createNewEntity: () => require_helper$1.createNewEntity,
+	createNewType: () => require_helper$1.createNewType,
 	createTaggedObject: () => require_helper$2.createTaggedObject,
 	entityKind: () => require_base.entityKind,
 	entityStructureKind: () => require_base.entityStructureKind,
@@ -38,7 +38,7 @@ exports.createEntity = require_helper.createEntity;
 exports.createEntityNamespace = require_namespace.createEntityNamespace;
 exports.createFlag = require_base$2.createFlag;
 exports.createKind = require_kind.createKind;
-exports.createNewEntity = require_helper$1.createNewEntity;
+exports.createNewType = require_helper$1.createNewType;
 exports.createTaggedObject = require_helper$2.createTaggedObject;
 exports.entityKind = require_base.entityKind;
 exports.entityStructureKind = require_base.entityStructureKind;

package/dist/modeling/index.mjs

@@ -3,7 +3,7 @@ import { createKind } from "./kind.mjs";
 import { EntityStructure, entityKind, entityStructureKind } from "./entity/base.mjs";
 import { createEntity } from "./entity/helper.mjs";
 import { NewTypeStructure, newTypeStructureKind } from "./newType/base.mjs";
-import { createNewEntity } from "./newType/helper.mjs";
+import { createNewType } from "./newType/helper.mjs";
 import { createFlag, flagKind } from "./flag/base.mjs";
 import { createEntityNamespace, namespaceKind } from "./entity/namespace.mjs";
 import { TaggedObjectStructure, objectTagKind, taggedObjectStructureKind } from "./taggedObject/base.mjs";
@@ -17,7 +17,7 @@ var modeling_exports = /* @__PURE__ */ __exportAll({
 	createEntityNamespace: () => createEntityNamespace,
 	createFlag: () => createFlag,
 	createKind: () => createKind,
-	createNewEntity: () => createNewEntity,
+	createNewType: () => createNewType,
 	createTaggedObject: () => createTaggedObject,
 	entityKind: () => entityKind,
 	entityStructureKind: () => entityStructureKind,
@@ -31,4 +31,4 @@ var modeling_exports = /* @__PURE__ */ __exportAll({
 	taggedObjectStructureKind: () => taggedObjectStructureKind
 });
 //#endregion
-export { EntityStructure, NewTypeStructure, TaggedObjectStructure, createEntity, createEntityNamespace, createFlag, createKind, createNewEntity, createTaggedObject, entityKind, entityStructureKind, flagKind, getTagValue, hasTagValue, modeling_exports, namespaceKind, newTypeStructureKind, objectTagKind, taggedObject, taggedObjectStructureKind };
+export { EntityStructure, NewTypeStructure, TaggedObjectStructure, createEntity, createEntityNamespace, createFlag, createKind, createNewType, createTaggedObject, entityKind, entityStructureKind, flagKind, getTagValue, hasTagValue, modeling_exports, namespaceKind, newTypeStructureKind, objectTagKind, taggedObject, taggedObjectStructureKind };

package/dist/modeling/newType/helper.cjs

@@ -1,7 +1,7 @@
 const require_base = require("./base.cjs");
 //#region scripts/modeling/newType/helper.ts
-function createNewEntity(name, structure, newTypeConstraints = []) {
+function createNewType(name, structure, newTypeConstraints = []) {
 	return require_base.NewTypeStructure(name, structure, newTypeConstraints);
 }
 //#endregion
-exports.createNewEntity = createNewEntity;
+exports.createNewType = createNewType;

package/dist/modeling/newType/helper.d.ts

@@ -2,4 +2,4 @@ import { NewType, NewTypeStructure } from './base';
 import type * as DCommon from '../../common';
 import type * as DDataStructure from '../../dataStructure';
 export type ForbiddenTopLevelNewType<GenericValue extends unknown> = GenericValue extends NewType ? DCommon.ComputedTypeError<"NewType on top level of NewType declaration is forbidden."> : never;
-export declare function createNewEntity<GenericName extends Capitalize<string>, GenericStructure extends DDataStructure.Structure, const GenericNewTypeConstraint extends readonly DDataStructure.Constraint<DDataStructure.StructureValue<GenericStructure>>[] = readonly []>(name: (GenericName & DCommon.NeverCoalescing<ForbiddenTopLevelNewType<DDataStructure.StructureValue<GenericStructure>>, unknown>), structure: GenericStructure, newTypeConstraints?: GenericNewTypeConstraint): NewTypeStructure<GenericName & DCommon.NeverCoalescing<ForbiddenTopLevelNewType<DDataStructure.StructureValue<GenericStructure>>, unknown>, DDataStructure.StructureValue<GenericStructure>, GenericNewTypeConstraint>;
+export declare function createNewType<GenericName extends Capitalize<string>, GenericStructure extends DDataStructure.Structure, const GenericNewTypeConstraint extends readonly DDataStructure.Constraint<DDataStructure.StructureValue<GenericStructure>>[] = readonly []>(name: (GenericName & DCommon.NeverCoalescing<ForbiddenTopLevelNewType<DDataStructure.StructureValue<GenericStructure>>, unknown>), structure: GenericStructure, newTypeConstraints?: GenericNewTypeConstraint): NewTypeStructure<GenericName & DCommon.NeverCoalescing<ForbiddenTopLevelNewType<DDataStructure.StructureValue<GenericStructure>>, unknown>, DDataStructure.StructureValue<GenericStructure>, GenericNewTypeConstraint>;

package/dist/modeling/newType/helper.mjs

@@ -1,7 +1,7 @@
 import { NewTypeStructure } from "./base.mjs";
 //#region scripts/modeling/newType/helper.ts
-function createNewEntity(name, structure, newTypeConstraints = []) {
+function createNewType(name, structure, newTypeConstraints = []) {
 	return NewTypeStructure(name, structure, newTypeConstraints);
 }
 //#endregion
-export { createNewEntity };
+export { createNewType };

package/dist/modeling/taggedObject/base.cjs

@@ -1,3 +1,9 @@
+const require_isSimple = require("../../object/isSimple.cjs");
+const require_create = require("../../either/left/create.cjs");
+const require_create$1 = require("../../either/right/create.cjs");
+const require_justExec = require("../../common/justExec.cjs");
+const require_resultSymbol = require("../../dataStructure/common/resultSymbol.cjs");
+const require_error = require("../../dataStructure/common/error.cjs");
 const require_base = require("../../dataStructure/structure/base.cjs");
 const require_nonEncodableString = require("../../dataStructure/structure/defaults/nonEncodableString.cjs");
 const require_object = require("../../dataStructure/structure/defaults/object.cjs");
@@ -16,7 +22,64 @@ const TaggedObjectStructure = require_base.createStructure(taggedObjectStructure
 	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.executeEncode(codecContext, data, errorHandler),
 	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.executeDecode(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous()
-}, { name }));
+}, {
+	name,
+	new: (self, properties) => ({
+		...properties,
+		[objectTagKind.runTimeKey]: name
+	}),
+	decodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.decodeMap(codecs, value);
+		}
+		const errorHandler = require_error.createGetErrorHandler();
+		const [codecs, data] = args;
+		const result = self.executeDecode(codecs.context.value, require_isSimple.isSimple(data) ? {
+			...data,
+			[objectTagKind.runTimeKey]: name
+		} : data, errorHandler);
+		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
+		return require_create$1.right("map-success", result);
+	},
+	map: (self, data) => {
+		const errorHandler = require_error.createGetErrorHandler();
+		const formattedData = require_isSimple.isSimple(data) ? {
+			...data,
+			[objectTagKind.runTimeKey]: name
+		} : data;
+		const result = self.executeCheck(formattedData, errorHandler);
+		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
+		return require_create$1.right("map-success", formattedData);
+	},
+	asyncDecodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.asyncDecodeMap(codecs, value);
+		}
+		return require_justExec.justExec(async () => {
+			const errorHandler = require_error.createGetErrorHandler();
+			const [codecs, data] = args;
+			const result = await self.executeDecode(codecs.context.value, require_isSimple.isSimple(data) ? {
+				...data,
+				[objectTagKind.runTimeKey]: name
+			} : data, errorHandler);
+			if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
+			return require_create$1.right("map-success", result);
+		});
+	},
+	asyncMap: (self, data) => require_justExec.justExec(async () => {
+		const errorHandler = require_error.createGetErrorHandler();
+		const formattedData = require_isSimple.isSimple(data) ? {
+			...data,
+			[objectTagKind.runTimeKey]: name
+		} : data;
+		if (await self.executeCheck(formattedData, errorHandler) === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
+		return require_create$1.right("map-success", formattedData);
+	})
+}));
 //#endregion
 exports.TaggedObjectStructure = TaggedObjectStructure;
 exports.objectTagKind = objectTagKind;

package/dist/modeling/taggedObject/base.d.ts

@@ -1,5 +1,7 @@
+import { NewType, NewTypeMap } from '../newType';
 import type * as DKind from '../../kind';
-import type * as DCommon from '../../common';
+import * as DCommon from '../../common';
+import * as DEither from '../../either';
 import * as DDataStructure from '../../dataStructure';
 declare module '../../dataStructure' {
     interface StructuresStore {
@@ -25,7 +27,23 @@ export declare const taggedObjectStructureKind: DKind.Handler<DKind.Definition<"
 export interface TaggedObjectStructureDefinition extends DDataStructure.StructureDefinition<readonly []> {
     readonly inner: DDataStructure.ObjectStructure;
 }
+export type TaggedObjectMap<GenericValue extends unknown, GenericRawValue = DCommon.RemoveConstraint<GenericValue>> = GenericRawValue extends NewType ? NewTypeMap<GenericRawValue> : GenericRawValue extends object ? DCommon.Or<[
+    DCommon.IsExtends<GenericRawValue, readonly any[]>,
+    DCommon.And<[
+        DCommon.IsExtends<keyof GenericRawValue, string>,
+        DCommon.Not<DCommon.IsExtends<DCommon.AnyFunction, GenericRawValue[keyof GenericRawValue]>>
+    ]>
+]> extends true ? {
+    [Prop in keyof GenericRawValue]: TaggedObjectMap<GenericRawValue[Prop]>;
+} : GenericRawValue : GenericRawValue;
 export interface TaggedObjectStructure<GenericTaggedObject extends ObjectTag = ObjectTag> extends DCommon.Forward<DDataStructure.Structure<GenericTaggedObject, TaggedObjectStructureDefinition> & DKind.Kind<typeof taggedObjectStructureKind>> {
     readonly name: GetTagValue<GenericTaggedObject>;
+    "new"(properties: DCommon.SimplifyTopLevel<DKind.Remove<GenericTaggedObject>>): GenericTaggedObject;
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>) => (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
+    map(data: TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>) => Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncMap(data: TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
 }
 export declare const TaggedObjectStructure: <GenericTaggedObject extends ObjectTag, GenericName extends string = never, GenericShape extends DDataStructure.ShapeObjectStructure = never>(name: GetTagValue<GenericTaggedObject> | GenericName, shape: ShapeTaggedObjectStructure<GenericTaggedObject> | GenericShape) => TaggedObjectStructure<ObjectTag extends GenericTaggedObject ? (ObjectTag<GenericName> & DDataStructure.ShapeObjectStructureValue<GenericShape>) : GenericTaggedObject>;

package/dist/modeling/taggedObject/base.mjs

@@ -1,3 +1,9 @@
+import { isSimple } from "../../object/isSimple.mjs";
+import { left } from "../../either/left/create.mjs";
+import { right } from "../../either/right/create.mjs";
+import { justExec } from "../../common/justExec.mjs";
+import { ErrorSymbol } from "../../dataStructure/common/resultSymbol.mjs";
+import { createGetErrorHandler } from "../../dataStructure/common/error.mjs";
 import { createStructure } from "../../dataStructure/structure/base.mjs";
 import { NonEncodableStringStructure } from "../../dataStructure/structure/defaults/nonEncodableString.mjs";
 import { ObjectStructure } from "../../dataStructure/structure/defaults/object.mjs";
@@ -16,6 +22,63 @@ const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init
 	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.executeEncode(codecContext, data, errorHandler),
 	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.executeDecode(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous()
-}, { name }));
+}, {
+	name,
+	new: (self, properties) => ({
+		...properties,
+		[objectTagKind.runTimeKey]: name
+	}),
+	decodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.decodeMap(codecs, value);
+		}
+		const errorHandler = createGetErrorHandler();
+		const [codecs, data] = args;
+		const result = self.executeDecode(codecs.context.value, isSimple(data) ? {
+			...data,
+			[objectTagKind.runTimeKey]: name
+		} : data, errorHandler);
+		if (result instanceof Promise) return left("async-error", void 0);
+		if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
+		return right("map-success", result);
+	},
+	map: (self, data) => {
+		const errorHandler = createGetErrorHandler();
+		const formattedData = isSimple(data) ? {
+			...data,
+			[objectTagKind.runTimeKey]: name
+		} : data;
+		const result = self.executeCheck(formattedData, errorHandler);
+		if (result instanceof Promise) return left("async-error", void 0);
+		if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
+		return right("map-success", formattedData);
+	},
+	asyncDecodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.asyncDecodeMap(codecs, value);
+		}
+		return justExec(async () => {
+			const errorHandler = createGetErrorHandler();
+			const [codecs, data] = args;
+			const result = await self.executeDecode(codecs.context.value, isSimple(data) ? {
+				...data,
+				[objectTagKind.runTimeKey]: name
+			} : data, errorHandler);
+			if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
+			return right("map-success", result);
+		});
+	},
+	asyncMap: (self, data) => justExec(async () => {
+		const errorHandler = createGetErrorHandler();
+		const formattedData = isSimple(data) ? {
+			...data,
+			[objectTagKind.runTimeKey]: name
+		} : data;
+		if (await self.executeCheck(formattedData, errorHandler) === ErrorSymbol) return left("map-error", errorHandler().createError());
+		return right("map-success", formattedData);
+	})
+}));
 //#endregion
 export { TaggedObjectStructure, objectTagKind, taggedObjectStructureKind };

package/dist/modeling/taggedObject/helper.cjs

@@ -19,8 +19,13 @@ function taggedObject(tag, props) {
 		[require_base.objectTagKind.runTimeKey]: tag
 	};
 }
-function createTaggedObject(name) {
-	return (shape) => require_base.TaggedObjectStructure(name, shape);
+function createTaggedObject(...args) {
+	if (args.length === 1) {
+		const [name] = args;
+		return (shape) => createTaggedObject(name, shape);
+	}
+	const [name, shape] = args;
+	return require_base.TaggedObjectStructure(name, shape);
 }
 //#endregion
 exports.createTaggedObject = createTaggedObject;

package/dist/modeling/taggedObject/helper.d.ts

@@ -12,3 +12,4 @@ export declare function taggedObject<GenericTaggedObject extends ObjectTag>(...a
 ] : never): GenericTaggedObject;
 export type RequireTaggedObjectSameShape<GenericTaggedObject extends ObjectTag, GenericTaggedObjectShape extends ShapeTaggedObjectStructure> = DCommon.IsEqual<DCommon.SimplifyTopLevel<DObject.DeepReadonly<DKind.Remove<GenericTaggedObject>>>, DCommon.SimplifyTopLevel<DObject.DeepReadonly<DDataStructure.ShapeObjectStructureValue<GenericTaggedObjectShape>>>> extends true ? unknown : DCommon.ComputedTypeError<"Shape do not match.">;
 export declare function createTaggedObject<GenericTaggedObject extends ObjectTag>(name: GetTagValue<GenericTaggedObject>): <GenericShape extends ShapeTaggedObjectStructure<GenericTaggedObject>>(shape: (GenericShape & RequireTaggedObjectSameShape<GenericTaggedObject, GenericShape>)) => TaggedObjectStructure<GenericTaggedObject>;
+export declare function createTaggedObject<GenericTaggedObject extends ObjectTag, GenericName extends string = never, GenericShape extends DDataStructure.ShapeObjectStructure = never>(name: GetTagValue<GenericTaggedObject> | GenericName, shape: ShapeTaggedObjectStructure<GenericTaggedObject> | GenericShape): TaggedObjectStructure<ObjectTag extends GenericTaggedObject ? (ObjectTag<GenericName> & DDataStructure.ShapeObjectStructureValue<GenericShape>) : GenericTaggedObject>;

package/dist/modeling/taggedObject/helper.mjs

@@ -19,8 +19,13 @@ function taggedObject(tag, props) {
 		[objectTagKind.runTimeKey]: tag
 	};
 }
-function createTaggedObject(name) {
-	return (shape) => TaggedObjectStructure(name, shape);
+function createTaggedObject(...args) {
+	if (args.length === 1) {
+		const [name] = args;
+		return (shape) => createTaggedObject(name, shape);
+	}
+	const [name, shape] = args;
+	return TaggedObjectStructure(name, shape);
 }
 //#endregion
 export { createTaggedObject, getTagValue, hasTagValue, taggedObject };

package/dist/path/constraints/index.d.ts

@@ -1,2 +1,3 @@
-export type * from './path';
 export type * from './absolute';
+export type * from './path';
+export type * from './segment';

package/dist/path/constraints/segment.d.ts

@@ -0,0 +1,3 @@
+import type * as DCommon from '../../common';
+export interface Segment extends DCommon.Constraint<"path-segment"> {
+}

package/dist/path/getBaseName.cjs

@@ -1,10 +1,12 @@
+const require_isSegment = require("./isSegment.cjs");
 //#region scripts/path/getBaseName.ts
 const baseNameRegex = /([^/]+)$/;
 const extensionNameRegex = /(?<!^)\.[^./]+$/;
 function getBaseName(path, params) {
 	const baseName = baseNameRegex.exec(path)?.[1];
 	if (baseName === void 0) return null;
-	return params?.removeExtension ? baseName.replace(extensionNameRegex, "") : baseName;
+	const result = params?.removeExtension ? baseName.replace(extensionNameRegex, "") : baseName;
+	return require_isSegment.isSegment(result) ? result : null;
 }
 //#endregion
 exports.getBaseName = getBaseName;

package/dist/path/getBaseName.d.ts

@@ -1,5 +1,5 @@
-import { Absolute, Path } from './constraints';
+import { Absolute, Path, Segment } from './constraints';
 export interface GetBaseNameParams {
     removeExtension?: boolean;
 }
-export declare function getBaseName<GenericPath extends string & (Path | Absolute)>(path: GenericPath, params?: GetBaseNameParams): string | null;
+export declare function getBaseName<GenericPath extends string & (Path | Absolute | Segment)>(path: GenericPath, params?: GetBaseNameParams): (string & Segment) | null;

package/dist/path/getBaseName.mjs

@@ -1,10 +1,12 @@
+import { isSegment } from "./isSegment.mjs";
 //#region scripts/path/getBaseName.ts
 const baseNameRegex = /([^/]+)$/;
 const extensionNameRegex = /(?<!^)\.[^./]+$/;
 function getBaseName(path, params) {
 	const baseName = baseNameRegex.exec(path)?.[1];
 	if (baseName === void 0) return null;
-	return params?.removeExtension ? baseName.replace(extensionNameRegex, "") : baseName;
+	const result = params?.removeExtension ? baseName.replace(extensionNameRegex, "") : baseName;
+	return isSegment(result) ? result : null;
 }
 //#endregion
 export { getBaseName };

package/dist/path/getExtensionName.cjs

@@ -1,3 +1,4 @@
+const require_isSegment = require("./isSegment.cjs");
 //#region scripts/path/getExtensionName.ts
 const basenameRegex = /([^/]+)$/;
 function getExtensionName(path, params) {
@@ -6,7 +7,8 @@ function getExtensionName(path, params) {
 	const dotIndex = baseName.lastIndexOf(".");
 	if (dotIndex <= 0 || dotIndex === baseName.length - 1) return null;
 	const extension = baseName.slice(dotIndex + 1);
-	return params?.withDot ? `.${extension}` : extension;
+	const result = params?.withDot ? `.${extension}` : extension;
+	return require_isSegment.isSegment(result) ? result : null;
 }
 //#endregion
 exports.getExtensionName = getExtensionName;

package/dist/path/getExtensionName.d.ts

@@ -1,5 +1,5 @@
-import { Absolute, Path } from './constraints';
+import { Absolute, Path, Segment } from './constraints';
 export interface GetExtensionNameParams {
     withDot?: boolean;
 }
-export declare function getExtensionName<GenericPath extends string & (Path | Absolute)>(path: GenericPath, params?: GetExtensionNameParams): string | null;
+export declare function getExtensionName<GenericPath extends string & (Path | Absolute | Segment)>(path: GenericPath, params?: GetExtensionNameParams): (string & Segment) | null;

package/dist/path/getExtensionName.mjs

@@ -1,3 +1,4 @@
+import { isSegment } from "./isSegment.mjs";
 //#region scripts/path/getExtensionName.ts
 const basenameRegex = /([^/]+)$/;
 function getExtensionName(path, params) {
@@ -6,7 +7,8 @@ function getExtensionName(path, params) {
 	const dotIndex = baseName.lastIndexOf(".");
 	if (dotIndex <= 0 || dotIndex === baseName.length - 1) return null;
 	const extension = baseName.slice(dotIndex + 1);
-	return params?.withDot ? `.${extension}` : extension;
+	const result = params?.withDot ? `.${extension}` : extension;
+	return isSegment(result) ? result : null;
 }
 //#endregion
 export { getExtensionName };

package/dist/path/getParentFolderPath.cjs

@@ -1,9 +1,13 @@
 //#region scripts/path/getParentFolderPath.ts
 const parentFolderPathRegex = /^([^]*)\/[^/]+$/;
-const onlyParentsRegex = /^(?:\.\.)(?:\/\.\.)*$/;
+const onlyParentSegmentsRegex = /^(?:\.\.)(?:\/\.\.)*$/;
 function getParentFolderPath(path) {
+	if (path === "/") return null;
+	if (path === ".") return "..";
+	if (onlyParentSegmentsRegex.test(path)) return `${path}/..`;
 	const parent = parentFolderPathRegex.exec(path)?.[1];
-	if (parent === void 0 || parent === "" || onlyParentsRegex.test(parent)) return path.startsWith("/") && parent === "" ? "/" : null;
+	if (parent === void 0) return ".";
+	if (parent === "") return "/";
 	return parent;
 }
 //#endregion

package/dist/path/getParentFolderPath.d.ts

@@ -1,2 +1,2 @@
 import { Absolute, Path } from './constraints';
-export declare function getParentFolderPath<GenericPath extends string & (Path | Absolute)>(path: GenericPath): string | null;
+export declare function getParentFolderPath<GenericPath extends string & (Path | Absolute)>(path: GenericPath): (string & Path) | null;

package/dist/path/getParentFolderPath.mjs

@@ -1,9 +1,13 @@
 //#region scripts/path/getParentFolderPath.ts
 const parentFolderPathRegex = /^([^]*)\/[^/]+$/;
-const onlyParentsRegex = /^(?:\.\.)(?:\/\.\.)*$/;
+const onlyParentSegmentsRegex = /^(?:\.\.)(?:\/\.\.)*$/;
 function getParentFolderPath(path) {
+	if (path === "/") return null;
+	if (path === ".") return "..";
+	if (onlyParentSegmentsRegex.test(path)) return `${path}/..`;
 	const parent = parentFolderPathRegex.exec(path)?.[1];
-	if (parent === void 0 || parent === "" || onlyParentsRegex.test(parent)) return path.startsWith("/") && parent === "" ? "/" : null;
+	if (parent === void 0) return ".";
+	if (parent === "") return "/";
 	return parent;
 }
 //#endregion

package/dist/path/index.cjs

@@ -1,5 +1,6 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_computeRelative = require("./computeRelative.cjs");
+const require_isSegment = require("./isSegment.cjs");
 const require_getBaseName = require("./getBaseName.cjs");
 const require_getExtensionName = require("./getExtensionName.cjs");
 const require_getParentFolderPath = require("./getParentFolderPath.cjs");
@@ -16,6 +17,7 @@ var path_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	getParentFolderPath: () => require_getParentFolderPath.getParentFolderPath,
 	is: () => require_is.is,
 	isAbsolute: () => require_isAbsolute.isAbsolute,
+	isSegment: () => require_isSegment.isSegment,
 	normalize: () => require_normalize.normalize,
 	resolveFrom: () => require_resolveFrom.resolveFrom,
 	resolveRelative: () => require_resolveRelative.resolveRelative
@@ -27,6 +29,7 @@ exports.getExtensionName = require_getExtensionName.getExtensionName;
 exports.getParentFolderPath = require_getParentFolderPath.getParentFolderPath;
 exports.is = require_is.is;
 exports.isAbsolute = require_isAbsolute.isAbsolute;
+exports.isSegment = require_isSegment.isSegment;
 exports.normalize = require_normalize.normalize;
 Object.defineProperty(exports, "path_exports", {
 	enumerable: true,

package/dist/path/index.d.ts

@@ -5,6 +5,7 @@ export * from './getExtensionName';
 export * from './getParentFolderPath';
 export * from './is';
 export * from './isAbsolute';
+export * from './isSegment';
 export * from './normalize';
 export * from './resolveFrom';
 export * from './resolveRelative';

package/dist/path/index.mjs

@@ -1,5 +1,6 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { computeRelative } from "./computeRelative.mjs";
+import { isSegment } from "./isSegment.mjs";
 import { getBaseName } from "./getBaseName.mjs";
 import { getExtensionName } from "./getExtensionName.mjs";
 import { getParentFolderPath } from "./getParentFolderPath.mjs";
@@ -16,9 +17,10 @@ var path_exports = /* @__PURE__ */ __exportAll({
 	getParentFolderPath: () => getParentFolderPath,
 	is: () => is,
 	isAbsolute: () => isAbsolute,
+	isSegment: () => isSegment,
 	normalize: () => normalize,
 	resolveFrom: () => resolveFrom,
 	resolveRelative: () => resolveRelative
 });
 //#endregion
-export { computeRelative, getBaseName, getExtensionName, getParentFolderPath, is, isAbsolute, normalize, path_exports, resolveFrom, resolveRelative };
+export { computeRelative, getBaseName, getExtensionName, getParentFolderPath, is, isAbsolute, isSegment, normalize, path_exports, resolveFrom, resolveRelative };

package/dist/path/isSegment.cjs

@@ -0,0 +1,6 @@
+//#region scripts/path/isSegment.ts
+function isSegment(value) {
+	return value !== "" && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\0");
+}
+//#endregion
+exports.isSegment = isSegment;

package/dist/path/isSegment.d.ts

@@ -0,0 +1,4 @@
+import { Segment } from './constraints';
+import { IsLiteralSegmentPath } from './types';
+import type * as DString from '../string';
+export declare function isSegment<GenericValue extends string>(value: GenericValue): value is (GenericValue extends Segment ? GenericValue : IsLiteralSegmentPath<GenericValue> extends true ? GenericValue : DString.IsLiteral<GenericValue> extends true ? never : GenericValue & Segment);

package/dist/path/isSegment.mjs

@@ -0,0 +1,6 @@
+//#region scripts/path/isSegment.ts
+function isSegment(value) {
+	return value !== "" && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\0");
+}
+//#endregion
+export { isSegment };

package/dist/path/resolveFrom.d.ts

@@ -1,10 +1,10 @@
-import { Absolute, Path } from './constraints';
+import { Absolute, Path, Segment } from './constraints';
 import { RequireSegments } from './types';
 import type * as DCommon from '../common';
 export interface ResolveFromParams {
     stayInOrigin?: boolean;
 }
-export declare function resolveFrom<const GenericSegments extends readonly (string & (Path | Absolute))[], const GenericParams extends ResolveFromParams>(origin: string & Absolute, segments: GenericSegments & RequireSegments<GenericSegments>, params?: GenericParams): (string & Absolute) | (DCommon.BreakGenericLink<DCommon.Or<[
+export declare function resolveFrom<const GenericSegments extends readonly (string & (Path | Absolute | Segment))[], const GenericParams extends ResolveFromParams>(origin: string & Absolute, segments: GenericSegments & RequireSegments<GenericSegments>, params?: GenericParams): (string & Absolute) | (DCommon.BreakGenericLink<DCommon.Or<[
     DCommon.IsEqual<GenericParams["stayInOrigin"], ResolveFromParams["stayInOrigin"]>,
     DCommon.IsEqual<GenericParams["stayInOrigin"], false>,
     DCommon.IsEqual<GenericParams["stayInOrigin"], unknown>

package/dist/path/resolveRelative.d.ts

@@ -1,10 +1,10 @@
-import { Absolute, Path } from './constraints';
+import { Absolute, Path, Segment } from './constraints';
 import { RequireSegments } from './types';
 import type * as DCommon from '../common';
-type HasAbsolutePath<GenericSegments extends readonly (string & (Path | Absolute))[]> = DCommon.ContainExtends<{
+type HasAbsolutePath<GenericSegments extends readonly (string & (Path | Absolute | Segment))[]> = DCommon.ContainExtends<{
     [Prop in keyof GenericSegments]: [DCommon.IsExtends<GenericSegments[Prop], Absolute>];
 }[Extract<keyof GenericSegments, number>], [
     true
 ]>;
-export declare function resolveRelative<const GenericSegments extends readonly (string & (Path | Absolute))[]>(segments: GenericSegments & RequireSegments<GenericSegments>): string & Path & (DCommon.BreakGenericLink<HasAbsolutePath<GenericSegments> extends true ? Absolute : unknown>);
+export declare function resolveRelative<const GenericSegments extends readonly (string & (Path | Absolute | Segment))[]>(segments: GenericSegments & RequireSegments<GenericSegments>): string & Path & (DCommon.BreakGenericLink<HasAbsolutePath<GenericSegments> extends true ? Absolute : unknown>);
 export {};

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

@@ -1,5 +1,7 @@
 export type * from './isLiteralAbsolutePath';
 export type * from './isLiteralPath';
+export type * from './isLiteralSegmentPath';
 export type * from './requireLiteralAbsolutePath';
 export type * from './requireLiteralPath';
+export type * from './requireLiteralSegmentPath';
 export type * from './requireSegments';

package/dist/path/types/isLiteralSegmentPath.d.ts

@@ -0,0 +1,9 @@
+import type * as DCommon from '../../common';
+import type * as DString from '../../string';
+export type IsLiteralSegmentPath<GenericValue extends string> = DString.IsLiteral<GenericValue> extends true ? DCommon.Not<DCommon.Or<[
+    DCommon.IsEqual<GenericValue, ".">,
+    DCommon.IsEqual<GenericValue, "..">,
+    DCommon.IsEqual<GenericValue, "">,
+    DString.Includes<GenericValue, "/">,
+    DString.Includes<GenericValue, "\0">
+]>> : false;

package/dist/path/types/requireLiteralSegmentPath.d.ts

@@ -0,0 +1,3 @@
+import { IsLiteralSegmentPath } from './isLiteralSegmentPath';
+import type * as DCommon from '../../common';
+export type RequireLiteralSegmentPath<GenericValue extends string> = IsLiteralSegmentPath<GenericValue> extends true ? unknown : DCommon.ComputedTypeError<"Value is not a segment path.">;

package/dist/tuple/from.cjs

@@ -0,0 +1,6 @@
+//#region scripts/tuple/from.ts
+function from(source) {
+	return source;
+}
+//#endregion
+exports.from = from;

package/dist/tuple/from.d.ts

@@ -0,0 +1,8 @@
+import { Create } from './types';
+import type * as DArray from '../array';
+type FromOutput<GenericArray extends readonly unknown[]> = DArray.ExtractLengthEqual<GenericArray, unknown> extends DArray.LengthEqual<infer InferredLength extends number> ? DArray.ReapplyCompatiblesConstraints<GenericArray, Create<GenericArray[number], InferredLength>, "maxElements"> : DArray.ExtractMinElements<GenericArray, unknown> extends DArray.MinElements<infer InferredMin extends number> ? DArray.ReapplyCompatiblesConstraints<GenericArray, readonly [
+    ...Create<GenericArray[number], InferredMin>,
+    ...GenericArray[number][]
+], "maxElements"> : GenericArray;
+export declare function from<GenericArray extends readonly unknown[]>(source: GenericArray): FromOutput<GenericArray>;
+export {};

package/dist/tuple/from.mjs

@@ -0,0 +1,6 @@
+//#region scripts/tuple/from.ts
+function from(source) {
+	return source;
+}
+//#endregion
+export { from };

package/dist/tuple/index.cjs

@@ -1,8 +1,13 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_map = require("./map.cjs");
+const require_from = require("./from.cjs");
 //#region scripts/tuple/index.ts
-var tuple_exports = /* @__PURE__ */ require_runtime.__exportAll({ map: () => require_map.map });
+var tuple_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	from: () => require_from.from,
+	map: () => require_map.map
+});
 //#endregion
+exports.from = require_from.from;
 exports.map = require_map.map;
 Object.defineProperty(exports, "tuple_exports", {
 	enumerable: true,

package/dist/tuple/index.d.ts

@@ -1,2 +1,3 @@
 export type * from './types';
 export * from './map';
+export * from './from';

package/dist/tuple/index.mjs

@@ -1,6 +1,10 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { map } from "./map.mjs";
+import { from } from "./from.mjs";
 //#region scripts/tuple/index.ts
-var tuple_exports = /* @__PURE__ */ __exportAll({ map: () => map });
+var tuple_exports = /* @__PURE__ */ __exportAll({
+	from: () => from,
+	map: () => map
+});
 //#endregion
-export { map, tuple_exports };
+export { from, map, tuple_exports };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/lang",
-  "version": "0.0.1-beta.5",
+  "version": "0.0.1-beta.7",
   "license": "MIT",
   "type": "module",
   "author": {