@duplojs/lang 0.0.0 → 0.0.1-beta.10

package/dist/modeling/newType/base.mjs

@@ -1,21 +1,35 @@
+import { parentClass } from "../../kind/parentClass.mjs";
 import { callThen } from "../../common/callThen.mjs";
 import { left } from "../../either/left/create.mjs";
+import { isLeft } from "../../either/left/is.mjs";
 import { right } from "../../either/right/create.mjs";
+import { unwrapLeft } from "../../either/left/unwrap.mjs";
+import { unwrapRight } from "../../either/right/unwrap.mjs";
 import { justExec } from "../../common/justExec.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../dataStructure/common/resultSymbol.mjs";
-import { createGetErrorHandler } from "../../dataStructure/common/error.mjs";
+import { createGetErrorHandler } from "../../dataStructure/common/error/base.mjs";
 import { createStructure } from "../../dataStructure/structure/base.mjs";
 import { createKind } from "../kind.mjs";
 //#region scripts/modeling/newType/base.ts
 const newTypeStructureKind = createKind("new-type-structure");
+var EncodeNewTypeError = class extends parentClass(createKind("encode-new-type-error"), Error) {
+	error;
+	constructor(error) {
+		super(void 0, "An error occurred while encoding a NewType. This can only happen if you are bypassing the type system.");
+		this.error = error;
+	}
+};
+function executeNewTypeConstraints(structure, data, errorHandler) {
+	return structure.definition.newTypeConstraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : callThen(constraint.executeCheck(data), (constraintResult) => constraintResult === ErrorSymbol ? errorHandler?.().addIssue(structure, data, constraint) ?? ErrorSymbol : SuccessSymbol)), SuccessSymbol);
+}
 const NewTypeStructure = createStructure(newTypeStructureKind, ({ init }) => (name, structure, newTypeConstraints) => init({
 	constraints: [],
 	newTypeConstraints,
 	inner: structure
 }, {
-	executeCheck: (self, data, errorHandler) => callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : self.definition.newTypeConstraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : constraint.executeCheck(data, errorHandler)), SuccessSymbol)),
-	executeEncode: (self, codec, data, errorHandler) => callThen(self.definition.inner.executeEncode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(self.definition.newTypeConstraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : constraint.executeCheck(data, errorHandler)), SuccessSymbol), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
-	executeDecode: (self, codec, data, errorHandler) => callThen(self.definition.inner.executeDecode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(self.definition.newTypeConstraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : constraint.executeCheck(awaitedInnerResult, errorHandler)), SuccessSymbol), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
+	executeCheck: (self, data, errorHandler) => callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : executeNewTypeConstraints(self, data, errorHandler)),
+	executeEncode: (self, codec, data, errorHandler) => callThen(self.definition.inner.executeEncode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(executeNewTypeConstraints(self, data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
+	executeDecode: (self, codec, data, errorHandler) => callThen(self.definition.inner.executeDecode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(executeNewTypeConstraints(self, awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous() || self.definition.newTypeConstraints.some((value) => value.isAsynchronous())
 }, {
 	name,
@@ -51,11 +65,16 @@ const NewTypeStructure = createStructure(newTypeStructureKind, ({ init }) => (na
 			return right("map-success", result);
 		});
 	},
-	asyncMap: (self, data) => justExec(async () => {
+	asyncMap: async (self, data) => {
 		const errorHandler = createGetErrorHandler();
 		if (await self.executeCheck(data, errorHandler) === ErrorSymbol) return left("map-error", errorHandler().createError());
 		return right("map-success", data);
-	})
+	},
+	encodeNewType: async (self, codec, data) => {
+		const result = await self.asyncEncode(codec, data);
+		if (isLeft(result)) throw new EncodeNewTypeError(unwrapLeft(result));
+		return unwrapRight(result);
+	}
 }));
 //#endregion
-export { NewTypeStructure, newTypeStructureKind };
+export { EncodeNewTypeError, NewTypeStructure, newTypeStructureKind };

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

@@ -0,0 +1,113 @@
+const require_parentClass = require("../../kind/parentClass.cjs");
+const require_isSimple = require("../../object/isSimple.cjs");
+const require_override = require("../../object/override.cjs");
+const require_create = require("../../either/left/create.cjs");
+const require_is = require("../../either/left/is.cjs");
+const require_create$1 = require("../../either/right/create.cjs");
+const require_unwrap = require("../../either/left/unwrap.cjs");
+const require_unwrap$1 = require("../../either/right/unwrap.cjs");
+const require_justExec = require("../../common/justExec.cjs");
+const require_resultSymbol = require("../../dataStructure/common/resultSymbol.cjs");
+const require_base = require("../../dataStructure/common/error/base.cjs");
+const require_base$1 = require("../../dataStructure/structure/base.cjs");
+const require_nonEncodableString = require("../../dataStructure/structure/defaults/nonEncodableString.cjs");
+const require_object = require("../../dataStructure/structure/defaults/object.cjs");
+const require_kind = require("../kind.cjs");
+const require_base$2 = require("../entity/base.cjs");
+//#region scripts/modeling/taggedObject/base.ts
+const objectTagKind = require_kind.createKind("object-tag");
+const taggedObjectStructureKind = require_kind.createKind("tagged-object-structure");
+var EncodeTaggedObjectError = class extends require_parentClass.parentClass(require_kind.createKind("encode-tagged-object-error"), Error) {
+	error;
+	constructor(error) {
+		super(void 0, "An error occurred while encoding a TaggedObject. This can only happen if you are bypassing the type system.");
+		this.error = error;
+	}
+};
+const TaggedObjectStructure = require_base$1.createStructure(taggedObjectStructureKind, ({ init }) => (name, shape) => init({
+	inner: require_object.ObjectStructure({
+		...shape,
+		[objectTagKind.runTimeKey]: require_nonEncodableString.NonEncodableStringStructure(name)
+	}, []),
+	constraints: []
+}, {
+	executeCheck: (self, data, errorHandler) => self.definition.inner.executeCheck(data, errorHandler),
+	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,
+	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_base.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_base.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_base.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: async (self, data) => {
+		const errorHandler = require_base.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);
+	},
+	encodeTaggedObject: async (self, codecs, data) => {
+		const result = await self.asyncEncode(codecs, data);
+		if (require_is.isLeft(result)) throw new EncodeTaggedObjectError(require_unwrap.unwrapLeft(result));
+		return require_unwrap$1.unwrapRight(result);
+	},
+	update: (self, ...args) => {
+		if (args.length === 1) {
+			const [update] = args;
+			return (input) => self.update(input, update);
+		}
+		const [input, { [require_base$2.entityKind.runTimeKey]: __, ...update }] = args;
+		return require_override.override(input, update);
+	}
+}));
+//#endregion
+exports.EncodeTaggedObjectError = EncodeTaggedObjectError;
+exports.TaggedObjectStructure = TaggedObjectStructure;
+exports.objectTagKind = objectTagKind;
+exports.taggedObjectStructureKind = taggedObjectStructureKind;

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

@@ -0,0 +1,61 @@
+import { NewType, NewTypeMap } from '../newType';
+import * as DKind from '../../kind';
+import * as DCommon from '../../common';
+import * as DEither from '../../either';
+import * as DDataStructure from '../../dataStructure';
+declare module '../../dataStructure' {
+    interface StructuresStore {
+        taggedObject: TaggedObjectStructure;
+    }
+}
+declare module '../../dataStructure/common' {
+    interface EncodeStructure<GenericValue extends unknown, GenericCodecs extends DDataStructure.Codecs> {
+        taggedObject: GenericValue extends ObjectTag<infer InferredName> ? (ObjectTag<InferredName> & {
+            [Prop in Exclude<keyof GenericValue, DKind.KeySymbol>]: DDataStructure.EncodedValue<GenericValue[Prop], GenericCodecs>;
+        }) : never;
+    }
+}
+export declare const objectTagKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/object-tag", string>>;
+export interface ObjectTag<GenericValue extends string = string> extends DKind.Kind<typeof objectTagKind, GenericValue> {
+}
+export type GetTagValue<GenericTaggedObject extends ObjectTag> = DKind.GetValue<typeof objectTagKind, GenericTaggedObject>;
+export type ExtractByTagValue<GenericValue extends unknown, GenericTagValue extends string> = GenericValue extends ObjectTag<GenericTagValue> ? GenericValue : never;
+export type ShapeTaggedObjectStructure<GenericTaggedObject extends ObjectTag = ObjectTag> = {
+    [Prop in Extract<keyof GenericTaggedObject, string>]: DDataStructure.Structure<GenericTaggedObject[Prop]>;
+};
+export declare const taggedObjectStructureKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/tagged-object-structure", unknown>>;
+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 type TaggedObjectUpdate<GenericTaggedObject extends ObjectTag, GenericNewProperties extends object> = Extract<(ObjectTag<GetTagValue<GenericTaggedObject>> & DCommon.SimplifyTopLevel<DKind.Remove<GenericTaggedObject> extends infer InferredProperties ? {
+    [Prop in keyof InferredProperties]: Prop extends keyof GenericNewProperties ? GenericNewProperties[Prop] extends infer InferredNewValue ? InferredNewValue extends undefined ? InferredProperties[Prop] : InferredNewValue : never : InferredProperties[Prop];
+} : never>), any>;
+export interface TaggedObjectStructure<out 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>>;
+    encodeTaggedObject<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.StructureValue<this>): Promise<DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>>;
+    update<GenericInput extends GenericTaggedObject, const GenericPayload extends Partial<DKind.Remove<GenericTaggedObject>>>(update: GenericPayload): (input: GenericInput) => TaggedObjectUpdate<GenericInput, GenericPayload>;
+    update<GenericInput extends GenericTaggedObject, const GenericPayload extends Partial<DKind.Remove<GenericTaggedObject>>>(input: GenericInput, update: GenericPayload): TaggedObjectUpdate<GenericInput, GenericPayload>;
+}
+declare const EncodeTaggedObjectError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangModeling/encode-tagged-object-error", unknown>>, ErrorConstructor>;
+export declare class EncodeTaggedObjectError extends EncodeTaggedObjectError_base {
+    error: DDataStructure.Error;
+    constructor(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>;
+export {};

package/dist/modeling/taggedObject/base.mjs

@@ -0,0 +1,110 @@
+import { parentClass } from "../../kind/parentClass.mjs";
+import { isSimple } from "../../object/isSimple.mjs";
+import { override } from "../../object/override.mjs";
+import { left } from "../../either/left/create.mjs";
+import { isLeft } from "../../either/left/is.mjs";
+import { right } from "../../either/right/create.mjs";
+import { unwrapLeft } from "../../either/left/unwrap.mjs";
+import { unwrapRight } from "../../either/right/unwrap.mjs";
+import { justExec } from "../../common/justExec.mjs";
+import { ErrorSymbol } from "../../dataStructure/common/resultSymbol.mjs";
+import { createGetErrorHandler } from "../../dataStructure/common/error/base.mjs";
+import { createStructure } from "../../dataStructure/structure/base.mjs";
+import { NonEncodableStringStructure } from "../../dataStructure/structure/defaults/nonEncodableString.mjs";
+import { ObjectStructure } from "../../dataStructure/structure/defaults/object.mjs";
+import { createKind } from "../kind.mjs";
+import { entityKind } from "../entity/base.mjs";
+//#region scripts/modeling/taggedObject/base.ts
+const objectTagKind = createKind("object-tag");
+const taggedObjectStructureKind = createKind("tagged-object-structure");
+var EncodeTaggedObjectError = class extends parentClass(createKind("encode-tagged-object-error"), Error) {
+	error;
+	constructor(error) {
+		super(void 0, "An error occurred while encoding a TaggedObject. This can only happen if you are bypassing the type system.");
+		this.error = error;
+	}
+};
+const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init }) => (name, shape) => init({
+	inner: ObjectStructure({
+		...shape,
+		[objectTagKind.runTimeKey]: NonEncodableStringStructure(name)
+	}, []),
+	constraints: []
+}, {
+	executeCheck: (self, data, errorHandler) => self.definition.inner.executeCheck(data, errorHandler),
+	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,
+	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: async (self, data) => {
+		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);
+	},
+	encodeTaggedObject: async (self, codecs, data) => {
+		const result = await self.asyncEncode(codecs, data);
+		if (isLeft(result)) throw new EncodeTaggedObjectError(unwrapLeft(result));
+		return unwrapRight(result);
+	},
+	update: (self, ...args) => {
+		if (args.length === 1) {
+			const [update] = args;
+			return (input) => self.update(input, update);
+		}
+		const [input, { [entityKind.runTimeKey]: __, ...update }] = args;
+		return override(input, update);
+	}
+}));
+//#endregion
+export { EncodeTaggedObjectError, TaggedObjectStructure, objectTagKind, taggedObjectStructureKind };

package/dist/modeling/taggedObject/helper.cjs

@@ -0,0 +1,34 @@
+const require_base = require("./base.cjs");
+//#region scripts/modeling/taggedObject/helper.ts
+function getTagValue(objectTag) {
+	return require_base.objectTagKind.getValue(objectTag);
+}
+function hasTagValue(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (input) => hasTagValue(input, value);
+	}
+	const [input, value] = args;
+	if (!require_base.objectTagKind.has(input)) return false;
+	const tagValue = require_base.objectTagKind.getValue(input);
+	return Array.isArray(value) ? value.includes(tagValue) : tagValue === value;
+}
+function taggedObject(tag, props) {
+	return {
+		...props,
+		[require_base.objectTagKind.runTimeKey]: tag
+	};
+}
+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;
+exports.getTagValue = getTagValue;
+exports.hasTagValue = hasTagValue;
+exports.taggedObject = taggedObject;

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

@@ -0,0 +1,15 @@
+import { ExtractByTagValue, GetTagValue, ShapeTaggedObjectStructure, TaggedObjectStructure, ObjectTag } from './base';
+import type * as DKind from '../../kind';
+import type * as DCommon from '../../common';
+import type * as DDataStructure from '../../dataStructure';
+import type * as DObject from '../../object';
+export declare function getTagValue<GenericObjectTag extends ObjectTag>(objectTag: GenericObjectTag): GetTagValue<GenericObjectTag>;
+export declare function hasTagValue<GenericInput extends unknown, GenericTagValue extends (GenericInput extends ObjectTag ? GetTagValue<GenericInput> : never)>(value: DCommon.MaybeArray<GenericTagValue>): (input: GenericInput) => input is ExtractByTagValue<GenericInput, GenericTagValue>;
+export declare function hasTagValue<GenericInput extends unknown, GenericTagValue extends (GenericInput extends ObjectTag ? GetTagValue<GenericInput> : never)>(input: GenericInput, value: DCommon.MaybeArray<GenericTagValue>): input is ExtractByTagValue<GenericInput, GenericTagValue>;
+export declare function taggedObject<GenericTaggedObject extends ObjectTag>(...args: GenericTaggedObject extends unknown ? [
+    tag: NoInfer<GetTagValue<GenericTaggedObject>>,
+    props: NoInfer<DCommon.SimplifyTopLevel<DKind.Remove<ExtractByTagValue<GenericTaggedObject, GetTagValue<GenericTaggedObject>>>>>
+] : 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

@@ -0,0 +1,31 @@
+import { TaggedObjectStructure, objectTagKind } from "./base.mjs";
+//#region scripts/modeling/taggedObject/helper.ts
+function getTagValue(objectTag) {
+	return objectTagKind.getValue(objectTag);
+}
+function hasTagValue(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (input) => hasTagValue(input, value);
+	}
+	const [input, value] = args;
+	if (!objectTagKind.has(input)) return false;
+	const tagValue = objectTagKind.getValue(input);
+	return Array.isArray(value) ? value.includes(tagValue) : tagValue === value;
+}
+function taggedObject(tag, props) {
+	return {
+		...props,
+		[objectTagKind.runTimeKey]: tag
+	};
+}
+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/modeling/taggedObject/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base';
+export * from './helper';

package/dist/number/betweenThan.d.ts

@@ -1,8 +1,8 @@
 import { ComputeGreaterThanCompatibility, ComputeLessThanCompatibility, GreaterThan, IsImpossibleToApplyGreaterThan, IsImpossibleToApplyLessThan, LessThan } from './constraints';
 import { RequireSimpleLiteral } from './types';
 import type * as DCommon from '../common';
-type ApplyGreaterThan<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyGreaterThan<GenericValue, GreaterThan<GenericThreshold>> extends true ? never : ComputeGreaterThanCompatibility<GenericValue, GreaterThan<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericValue : GenericValue & GreaterThan<GenericThreshold> : never : never;
-type ApplyLessThan<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyLessThan<GenericValue, LessThan<GenericThreshold>> extends true ? never : ComputeLessThanCompatibility<GenericValue, LessThan<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericValue : GenericValue & LessThan<GenericThreshold> : never : never;
+type ApplyGreaterThan<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyGreaterThan<GenericValue, GreaterThan<GenericThreshold>> extends true ? never : ComputeGreaterThanCompatibility<GenericValue, GreaterThan<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.CompatibilityConstraintResult<true>> extends true ? GenericValue : GenericValue & GreaterThan<GenericThreshold> : never : never;
+type ApplyLessThan<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyLessThan<GenericValue, LessThan<GenericThreshold>> extends true ? never : ComputeLessThanCompatibility<GenericValue, LessThan<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.CompatibilityConstraintResult<true>> extends true ? GenericValue : GenericValue & LessThan<GenericThreshold> : never : never;
 type BetweenThanOutput<GenericValue extends number, GenericGreater extends number, GenericLess extends number> = ApplyLessThan<ApplyGreaterThan<GenericValue, GenericGreater>, GenericLess>;
 type RequireApplyBetweenThan<GenericNumber extends number> = RequireSimpleLiteral<GenericNumber>;
 type RequireApplyBetweenThanBoolean<GenericNumber extends number> = DCommon.IsEqual<GenericNumber, number> extends true ? unknown : RequireApplyBetweenThan<GenericNumber>;

package/dist/number/betweenThanOrEqual.d.ts

@@ -1,8 +1,8 @@
 import { ComputeGreaterThanOrEqualCompatibility, ComputeLessThanOrEqualCompatibility, GreaterThanOrEqual, IsImpossibleToApplyGreaterThanOrEqual, IsImpossibleToApplyLessThanOrEqual, LessThanOrEqual } from './constraints';
 import { RequireSimpleLiteral } from './types';
 import type * as DCommon from '../common';
-type ApplyGreaterThanOrEqual<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyGreaterThanOrEqual<GenericValue, GreaterThanOrEqual<GenericThreshold>> extends true ? never : ComputeGreaterThanOrEqualCompatibility<GenericValue, GreaterThanOrEqual<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericValue : GenericValue & GreaterThanOrEqual<GenericThreshold> : never : never;
-type ApplyLessThanOrEqual<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyLessThanOrEqual<GenericValue, LessThanOrEqual<GenericThreshold>> extends true ? never : ComputeLessThanOrEqualCompatibility<GenericValue, LessThanOrEqual<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericValue : GenericValue & LessThanOrEqual<GenericThreshold> : never : never;
+type ApplyGreaterThanOrEqual<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyGreaterThanOrEqual<GenericValue, GreaterThanOrEqual<GenericThreshold>> extends true ? never : ComputeGreaterThanOrEqualCompatibility<GenericValue, GreaterThanOrEqual<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.CompatibilityConstraintResult<true>> extends true ? GenericValue : GenericValue & GreaterThanOrEqual<GenericThreshold> : never : never;
+type ApplyLessThanOrEqual<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyLessThanOrEqual<GenericValue, LessThanOrEqual<GenericThreshold>> extends true ? never : ComputeLessThanOrEqualCompatibility<GenericValue, LessThanOrEqual<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.CompatibilityConstraintResult<true>> extends true ? GenericValue : GenericValue & LessThanOrEqual<GenericThreshold> : never : never;
 type BetweenThanOrEqualOutput<GenericValue extends number, GenericGreater extends number, GenericLess extends number> = ApplyLessThanOrEqual<ApplyGreaterThanOrEqual<GenericValue, GenericGreater>, GenericLess>;
 type RequireApplyBetweenThanOrEqual<GenericNumber extends number> = RequireSimpleLiteral<GenericNumber>;
 type RequireApplyBetweenThanOrEqualBoolean<GenericNumber extends number> = DCommon.IsEqual<GenericNumber, number> extends true ? unknown : RequireApplyBetweenThanOrEqual<GenericNumber>;

package/dist/number/greaterThan.d.ts

@@ -1,7 +1,7 @@
 import { ComputeGreaterThanCompatibility, GreaterThan, IsImpossibleToApplyGreaterThan } from './constraints';
 import { RequireSimpleLiteral } from './types';
 import type * as DCommon from '../common';
-type GreaterThanOutput<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyGreaterThan<GenericValue, GreaterThan<GenericThreshold>> extends true ? never : ComputeGreaterThanCompatibility<GenericValue, GreaterThan<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericValue : GenericValue & GreaterThan<GenericThreshold> : never : never;
+type GreaterThanOutput<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyGreaterThan<GenericValue, GreaterThan<GenericThreshold>> extends true ? never : ComputeGreaterThanCompatibility<GenericValue, GreaterThan<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.CompatibilityConstraintResult<true>> extends true ? GenericValue : GenericValue & GreaterThan<GenericThreshold> : never : never;
 type RequireApplyGreaterThan<GenericThreshold extends number> = RequireSimpleLiteral<GenericThreshold>;
 type RequireApplyGreaterThanBoolean<GenericThreshold extends number> = DCommon.IsEqual<GenericThreshold, number> extends true ? unknown : RequireApplyGreaterThan<GenericThreshold>;
 export declare function greaterThan<GenericValue extends number, const GenericThreshold extends number>(threshold: GenericThreshold & RequireApplyGreaterThan<GenericThreshold>): (value: GenericValue) => value is GreaterThanOutput<GenericValue, GenericThreshold>;

package/dist/number/greaterThanOrEqual.d.ts

@@ -1,7 +1,7 @@
 import { ComputeGreaterThanOrEqualCompatibility, GreaterThanOrEqual, IsImpossibleToApplyGreaterThanOrEqual } from './constraints';
 import { RequireSimpleLiteral } from './types';
 import type * as DCommon from '../common';
-type GreaterThanOrEqualOutput<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyGreaterThanOrEqual<GenericValue, GreaterThanOrEqual<GenericThreshold>> extends true ? never : ComputeGreaterThanOrEqualCompatibility<GenericValue, GreaterThanOrEqual<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericValue : GenericValue & GreaterThanOrEqual<GenericThreshold> : never : never;
+type GreaterThanOrEqualOutput<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyGreaterThanOrEqual<GenericValue, GreaterThanOrEqual<GenericThreshold>> extends true ? never : ComputeGreaterThanOrEqualCompatibility<GenericValue, GreaterThanOrEqual<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.CompatibilityConstraintResult<true>> extends true ? GenericValue : GenericValue & GreaterThanOrEqual<GenericThreshold> : never : never;
 type RequireApplyGreaterThanOrEqual<GenericThreshold extends number> = RequireSimpleLiteral<GenericThreshold>;
 type RequireApplyGreaterThanOrEqualBoolean<GenericThreshold extends number> = DCommon.IsEqual<GenericThreshold, number> extends true ? unknown : RequireApplyGreaterThanOrEqual<GenericThreshold>;
 export declare function greaterThanOrEqual<GenericValue extends number, const GenericThreshold extends number>(threshold: GenericThreshold & RequireApplyGreaterThanOrEqual<GenericThreshold>): (value: GenericValue) => value is GreaterThanOrEqualOutput<GenericValue, GenericThreshold>;

package/dist/number/index.cjs

@@ -3,7 +3,6 @@ const require_betweenThan = require("./betweenThan.cjs");
 const require_betweenThanOrEqual = require("./betweenThanOrEqual.cjs");
 const require_greaterThan = require("./greaterThan.cjs");
 const require_greaterThanOrEqual = require("./greaterThanOrEqual.cjs");
-const require_infer = require("./infer.cjs");
 const require_isEven = require("./isEven.cjs");
 const require_isInteger = require("./isInteger.cjs");
 const require_isMultipleOf = require("./isMultipleOf.cjs");
@@ -28,7 +27,6 @@ var number_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	betweenThanOrEqual: () => require_betweenThanOrEqual.betweenThanOrEqual,
 	greaterThan: () => require_greaterThan.greaterThan,
 	greaterThanOrEqual: () => require_greaterThanOrEqual.greaterThanOrEqual,
-	infer: () => require_infer.infer,
 	isEven: () => require_isEven.isEven,
 	isInteger: () => require_isInteger.isInteger,
 	isMultipleOf: () => require_isMultipleOf.isMultipleOf,
@@ -53,7 +51,6 @@ exports.betweenThan = require_betweenThan.betweenThan;
 exports.betweenThanOrEqual = require_betweenThanOrEqual.betweenThanOrEqual;
 exports.greaterThan = require_greaterThan.greaterThan;
 exports.greaterThanOrEqual = require_greaterThanOrEqual.greaterThanOrEqual;
-exports.infer = require_infer.infer;
 exports.isEven = require_isEven.isEven;
 exports.isInteger = require_isInteger.isInteger;
 exports.isMultipleOf = require_isMultipleOf.isMultipleOf;

package/dist/number/index.d.ts

@@ -3,7 +3,6 @@ export * from './betweenThanOrEqual';
 export type * from './constraints';
 export * from './greaterThan';
 export * from './greaterThanOrEqual';
-export * from './infer';
 export * from './isEven';
 export * from './isInteger';
 export * from './isMultipleOf';

package/dist/number/index.mjs

@@ -3,7 +3,6 @@ import { betweenThan } from "./betweenThan.mjs";
 import { betweenThanOrEqual } from "./betweenThanOrEqual.mjs";
 import { greaterThan } from "./greaterThan.mjs";
 import { greaterThanOrEqual } from "./greaterThanOrEqual.mjs";
-import { infer } from "./infer.mjs";
 import { isEven } from "./isEven.mjs";
 import { isInteger } from "./isInteger.mjs";
 import { isMultipleOf } from "./isMultipleOf.mjs";
@@ -28,7 +27,6 @@ var number_exports = /* @__PURE__ */ __exportAll({
 	betweenThanOrEqual: () => betweenThanOrEqual,
 	greaterThan: () => greaterThan,
 	greaterThanOrEqual: () => greaterThanOrEqual,
-	infer: () => infer,
 	isEven: () => isEven,
 	isInteger: () => isInteger,
 	isMultipleOf: () => isMultipleOf,
@@ -49,4 +47,4 @@ var number_exports = /* @__PURE__ */ __exportAll({
 	sum: () => sum
 });
 //#endregion
-export { betweenThan, betweenThanOrEqual, greaterThan, greaterThanOrEqual, infer, isEven, isInteger, isMultipleOf, isNegative, isNotZero, isOdd, isPositive, isSafe, isStrictNegative, isStrictPositive, lessThan, lessThanOrEqual, max, maxOf, min, minOf, number_exports, sort, sum };
+export { betweenThan, betweenThanOrEqual, greaterThan, greaterThanOrEqual, isEven, isInteger, isMultipleOf, isNegative, isNotZero, isOdd, isPositive, isSafe, isStrictNegative, isStrictPositive, lessThan, lessThanOrEqual, max, maxOf, min, minOf, number_exports, sort, sum };

package/dist/number/lessThan.d.ts

@@ -1,7 +1,7 @@
 import { ComputeLessThanCompatibility, IsImpossibleToApplyLessThan, LessThan } from './constraints';
 import { RequireSimpleLiteral } from './types';
 import type * as DCommon from '../common';
-type LessThanOutput<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyLessThan<GenericValue, LessThan<GenericThreshold>> extends true ? never : ComputeLessThanCompatibility<GenericValue, LessThan<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericValue : GenericValue & LessThan<GenericThreshold> : never : never;
+type LessThanOutput<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyLessThan<GenericValue, LessThan<GenericThreshold>> extends true ? never : ComputeLessThanCompatibility<GenericValue, LessThan<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.CompatibilityConstraintResult<true>> extends true ? GenericValue : GenericValue & LessThan<GenericThreshold> : never : never;
 type RequireApplyLessThan<GenericThreshold extends number> = RequireSimpleLiteral<GenericThreshold>;
 type RequireApplyLessThanBoolean<GenericThreshold extends number> = DCommon.IsEqual<GenericThreshold, number> extends true ? unknown : RequireApplyLessThan<GenericThreshold>;
 export declare function lessThan<GenericValue extends number, const GenericThreshold extends number>(threshold: GenericThreshold & RequireApplyLessThan<GenericThreshold>): (value: GenericValue) => value is LessThanOutput<GenericValue, GenericThreshold>;

package/dist/number/lessThanOrEqual.d.ts

@@ -1,7 +1,7 @@
 import { ComputeLessThanOrEqualCompatibility, IsImpossibleToApplyLessThanOrEqual, LessThanOrEqual } from './constraints';
 import { RequireSimpleLiteral } from './types';
 import type * as DCommon from '../common';
-type LessThanOrEqualOutput<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyLessThanOrEqual<GenericValue, LessThanOrEqual<GenericThreshold>> extends true ? never : ComputeLessThanOrEqualCompatibility<GenericValue, LessThanOrEqual<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericValue : GenericValue & LessThanOrEqual<GenericThreshold> : never : never;
+type LessThanOrEqualOutput<GenericValue extends number, GenericThreshold extends number> = GenericValue extends unknown ? IsImpossibleToApplyLessThanOrEqual<GenericValue, LessThanOrEqual<GenericThreshold>> extends true ? never : ComputeLessThanOrEqualCompatibility<GenericValue, LessThanOrEqual<GenericThreshold>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.CompatibilityConstraintResult<true>> extends true ? GenericValue : GenericValue & LessThanOrEqual<GenericThreshold> : never : never;
 type RequireApplyLessThanOrEqual<GenericThreshold extends number> = RequireSimpleLiteral<GenericThreshold>;
 type RequireApplyLessThanOrEqualBoolean<GenericThreshold extends number> = DCommon.IsEqual<GenericThreshold, number> extends true ? unknown : RequireApplyLessThanOrEqual<GenericThreshold>;
 export declare function lessThanOrEqual<GenericValue extends number, const GenericThreshold extends number>(threshold: GenericThreshold & RequireApplyLessThanOrEqual<GenericThreshold>): (value: GenericValue) => value is LessThanOrEqualOutput<GenericValue, GenericThreshold>;

package/dist/number/sort.d.ts

@@ -1,6 +1,6 @@
 import type * as DArray from '../array';
 import type * as DCommon from '../common';
-type SortOutput<GenericArray extends readonly number[]> = DArray.ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][]>;
+type SortOutput<GenericArray extends readonly number[]> = GenericArray extends unknown ? DArray.ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][]> : never;
 export declare function sort<GenericArray extends readonly number[]>(type: DCommon.SortType): (array: GenericArray) => SortOutput<GenericArray>;
 export declare function sort<GenericArray extends readonly number[]>(array: GenericArray, type: DCommon.SortType): SortOutput<GenericArray>;
 export {};