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

package/dist/modeling/index.cjs

@@ -1,42 +1,50 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_kind = require("./kind.cjs");
-const require_entityName = require("./entity/entityName.cjs");
 const require_base = require("./entity/base.cjs");
 const require_helper = require("./entity/helper.cjs");
 const require_base$1 = require("./newType/base.cjs");
 const require_helper$1 = require("./newType/helper.cjs");
 const require_base$2 = require("./flag/base.cjs");
 const require_namespace = require("./entity/namespace.cjs");
+const require_base$3 = require("./taggedObject/base.cjs");
+const require_helper$2 = require("./taggedObject/helper.cjs");
 //#region scripts/modeling/index.ts
 var modeling_exports = /* @__PURE__ */ require_runtime.__exportAll({
-	EntityNameStructure: () => require_entityName.EntityNameStructure,
 	EntityStructure: () => require_base.EntityStructure,
 	NewTypeStructure: () => require_base$1.NewTypeStructure,
+	TaggedObjectStructure: () => require_base$3.TaggedObjectStructure,
 	createEntity: () => require_helper.createEntity,
 	createEntityNamespace: () => require_namespace.createEntityNamespace,
 	createFlag: () => require_base$2.createFlag,
 	createKind: () => require_kind.createKind,
 	createNewEntity: () => require_helper$1.createNewEntity,
+	createTaggedObject: () => require_helper$2.createTaggedObject,
 	entityKind: () => require_base.entityKind,
-	entityNameStructureKind: () => require_entityName.entityNameStructureKind,
 	entityStructureKind: () => require_base.entityStructureKind,
 	flagKind: () => require_base$2.flagKind,
+	getTagValue: () => require_helper$2.getTagValue,
+	hasTagValue: () => require_helper$2.hasTagValue,
 	namespaceKind: () => require_namespace.namespaceKind,
-	newTypeStructureKind: () => require_base$1.newTypeStructureKind
+	newTypeStructureKind: () => require_base$1.newTypeStructureKind,
+	objectTagKind: () => require_base$3.objectTagKind,
+	taggedObject: () => require_helper$2.taggedObject,
+	taggedObjectStructureKind: () => require_base$3.taggedObjectStructureKind
 });
 //#endregion
-exports.EntityNameStructure = require_entityName.EntityNameStructure;
 exports.EntityStructure = require_base.EntityStructure;
 exports.NewTypeStructure = require_base$1.NewTypeStructure;
+exports.TaggedObjectStructure = require_base$3.TaggedObjectStructure;
 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.createTaggedObject = require_helper$2.createTaggedObject;
 exports.entityKind = require_base.entityKind;
-exports.entityNameStructureKind = require_entityName.entityNameStructureKind;
 exports.entityStructureKind = require_base.entityStructureKind;
 exports.flagKind = require_base$2.flagKind;
+exports.getTagValue = require_helper$2.getTagValue;
+exports.hasTagValue = require_helper$2.hasTagValue;
 Object.defineProperty(exports, "modeling_exports", {
 	enumerable: true,
 	get: function() {
@@ -45,3 +53,6 @@ Object.defineProperty(exports, "modeling_exports", {
 });
 exports.namespaceKind = require_namespace.namespaceKind;
 exports.newTypeStructureKind = require_base$1.newTypeStructureKind;
+exports.objectTagKind = require_base$3.objectTagKind;
+exports.taggedObject = require_helper$2.taggedObject;
+exports.taggedObjectStructureKind = require_base$3.taggedObjectStructureKind;

package/dist/modeling/index.d.ts

@@ -2,3 +2,4 @@ export * from './entity';
 export * from './flag';
 export * from './kind';
 export * from './newType';
+export * from './taggedObject';

package/dist/modeling/index.mjs

@@ -1,28 +1,34 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { createKind } from "./kind.mjs";
-import { EntityNameStructure, entityNameStructureKind } from "./entity/entityName.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 { createFlag, flagKind } from "./flag/base.mjs";
 import { createEntityNamespace, namespaceKind } from "./entity/namespace.mjs";
+import { TaggedObjectStructure, objectTagKind, taggedObjectStructureKind } from "./taggedObject/base.mjs";
+import { createTaggedObject, getTagValue, hasTagValue, taggedObject } from "./taggedObject/helper.mjs";
 //#region scripts/modeling/index.ts
 var modeling_exports = /* @__PURE__ */ __exportAll({
-	EntityNameStructure: () => EntityNameStructure,
 	EntityStructure: () => EntityStructure,
 	NewTypeStructure: () => NewTypeStructure,
+	TaggedObjectStructure: () => TaggedObjectStructure,
 	createEntity: () => createEntity,
 	createEntityNamespace: () => createEntityNamespace,
 	createFlag: () => createFlag,
 	createKind: () => createKind,
 	createNewEntity: () => createNewEntity,
+	createTaggedObject: () => createTaggedObject,
 	entityKind: () => entityKind,
-	entityNameStructureKind: () => entityNameStructureKind,
 	entityStructureKind: () => entityStructureKind,
 	flagKind: () => flagKind,
+	getTagValue: () => getTagValue,
+	hasTagValue: () => hasTagValue,
 	namespaceKind: () => namespaceKind,
-	newTypeStructureKind: () => newTypeStructureKind
+	newTypeStructureKind: () => newTypeStructureKind,
+	objectTagKind: () => objectTagKind,
+	taggedObject: () => taggedObject,
+	taggedObjectStructureKind: () => taggedObjectStructureKind
 });
 //#endregion
-export { EntityNameStructure, EntityStructure, NewTypeStructure, createEntity, createEntityNamespace, createFlag, createKind, createNewEntity, entityKind, entityNameStructureKind, entityStructureKind, flagKind, modeling_exports, namespaceKind, newTypeStructureKind };
+export { EntityStructure, NewTypeStructure, TaggedObjectStructure, createEntity, createEntityNamespace, createFlag, createKind, createNewEntity, createTaggedObject, entityKind, entityStructureKind, flagKind, getTagValue, hasTagValue, modeling_exports, namespaceKind, newTypeStructureKind, objectTagKind, taggedObject, taggedObjectStructureKind };

package/dist/modeling/newType/base.cjs

@@ -7,14 +7,17 @@ const require_error = require("../../dataStructure/common/error.cjs");
 const require_base = require("../../dataStructure/structure/base.cjs");
 //#region scripts/modeling/newType/base.ts
 const newTypeStructureKind = require("../kind.cjs").createKind("new-type-structure");
+function executeNewTypeConstraints(structure, data, errorHandler) {
+	return structure.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(constraint.executeCheck(data), (constraintResult) => constraintResult === require_resultSymbol.ErrorSymbol ? errorHandler?.().addIssue(structure, data, constraint) ?? require_resultSymbol.ErrorSymbol : require_resultSymbol.SuccessSymbol)), require_resultSymbol.SuccessSymbol);
+}
 const NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ init }) => (name, structure, newTypeConstraints) => init({
 	constraints: [],
 	newTypeConstraints,
 	inner: structure
 }, {
-	executeCheck: (self, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : self.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : constraint.executeCheck(data, errorHandler)), require_resultSymbol.SuccessSymbol)),
-	executeEncode: (self, codec, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeEncode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : constraint.executeCheck(data, errorHandler)), require_resultSymbol.SuccessSymbol), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
-	executeDecode: (self, codec, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeDecode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : constraint.executeCheck(awaitedInnerResult, errorHandler)), require_resultSymbol.SuccessSymbol), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
+	executeCheck: (self, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : executeNewTypeConstraints(self, data, errorHandler)),
+	executeEncode: (self, codec, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeEncode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(executeNewTypeConstraints(self, data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
+	executeDecode: (self, codec, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeDecode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(executeNewTypeConstraints(self, awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous() || self.definition.newTypeConstraints.some((value) => value.isAsynchronous())
 }, {
 	name,

package/dist/modeling/newType/base.mjs

@@ -8,14 +8,17 @@ import { createStructure } from "../../dataStructure/structure/base.mjs";
 import { createKind } from "../kind.mjs";
 //#region scripts/modeling/newType/base.ts
 const newTypeStructureKind = createKind("new-type-structure");
+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,

package/dist/modeling/taggedObject/base.cjs

@@ -0,0 +1,23 @@
+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");
+const require_kind = require("../kind.cjs");
+//#region scripts/modeling/taggedObject/base.ts
+const objectTagKind = require_kind.createKind("object-tag");
+const taggedObjectStructureKind = require_kind.createKind("tagged-object-structure");
+const TaggedObjectStructure = require_base.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 }));
+//#endregion
+exports.TaggedObjectStructure = TaggedObjectStructure;
+exports.objectTagKind = objectTagKind;
+exports.taggedObjectStructureKind = taggedObjectStructureKind;

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

@@ -0,0 +1,32 @@
+import { Codecs, EncodedValue } from '../../dataStructure/common';
+import type * as DKind from '../../kind';
+import type * as DCommon from '../../common';
+import * as DDataStructure from '../../dataStructure';
+declare module '../../dataStructure' {
+    interface StructuresStore {
+        taggedObject: TaggedObjectStructure;
+    }
+}
+declare module '../../dataStructure/common' {
+    interface EncodeStructure<GenericValue extends unknown, GenericCodecs extends Codecs> {
+        taggedObject: GenericValue extends ObjectTag<infer InferredName> ? (ObjectTag<InferredName> & {
+            [Prop in Exclude<keyof GenericValue, DKind.KeySymbol>]: 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 interface TaggedObjectStructure<GenericTaggedObject extends ObjectTag = ObjectTag> extends DCommon.UnionToIntersection<DDataStructure.Structure<GenericTaggedObject, TaggedObjectStructureDefinition> & DKind.Kind<typeof taggedObjectStructureKind>> {
+    readonly name: GetTagValue<GenericTaggedObject>;
+}
+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

@@ -0,0 +1,21 @@
+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";
+//#region scripts/modeling/taggedObject/base.ts
+const objectTagKind = createKind("object-tag");
+const taggedObjectStructureKind = createKind("tagged-object-structure");
+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 }));
+//#endregion
+export { TaggedObjectStructure, objectTagKind, taggedObjectStructureKind };

package/dist/modeling/taggedObject/helper.cjs

@@ -0,0 +1,29 @@
+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(name) {
+	return (shape) => 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,14 @@
+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>;

package/dist/modeling/taggedObject/helper.mjs

@@ -0,0 +1,26 @@
+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(name) {
+	return (shape) => 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/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 {};

package/dist/pattern/index.cjs

@@ -12,6 +12,10 @@ const require_matchWithString = require("./matchWithString.cjs");
 const require_matchWithNumber = require("./matchWithNumber.cjs");
 const require_matchWithStringOtherwise = require("./matchWithStringOtherwise.cjs");
 const require_matchWithNumberOtherwise = require("./matchWithNumberOtherwise.cjs");
+const require_matchWithTaggedObject = require("./matchWithTaggedObject.cjs");
+const require_matchWithTaggedObjectOtherwise = require("./matchWithTaggedObjectOtherwise.cjs");
+const require_matchWithEntity = require("./matchWithEntity.cjs");
+const require_matchWithEntityOtherwise = require("./matchWithEntityOtherwise.cjs");
 //#region scripts/pattern/index.ts
 var pattern_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	InvalidExhaustivePatternError: () => require_builder.InvalidExhaustivePatternError,
@@ -20,10 +24,14 @@ var pattern_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	isResult: () => require_result.isResult,
 	match: () => require_index.match,
 	matchBuilder: () => require_builder.matchBuilder,
+	matchWithEntity: () => require_matchWithEntity.matchWithEntity,
+	matchWithEntityOtherwise: () => require_matchWithEntityOtherwise.matchWithEntityOtherwise,
 	matchWithNumber: () => require_matchWithNumber.matchWithNumber,
 	matchWithNumberOtherwise: () => require_matchWithNumberOtherwise.matchWithNumberOtherwise,
 	matchWithString: () => require_matchWithString.matchWithString,
 	matchWithStringOtherwise: () => require_matchWithStringOtherwise.matchWithStringOtherwise,
+	matchWithTaggedObject: () => require_matchWithTaggedObject.matchWithTaggedObject,
+	matchWithTaggedObjectOtherwise: () => require_matchWithTaggedObjectOtherwise.matchWithTaggedObjectOtherwise,
 	otherwise: () => require_otherwise.otherwise,
 	result: () => require_result.result,
 	union: () => require_union.union,
@@ -37,10 +45,14 @@ exports.isMatch = require_isMatch.isMatch;
 exports.isResult = require_result.isResult;
 exports.match = require_index.match;
 exports.matchBuilder = require_builder.matchBuilder;
+exports.matchWithEntity = require_matchWithEntity.matchWithEntity;
+exports.matchWithEntityOtherwise = require_matchWithEntityOtherwise.matchWithEntityOtherwise;
 exports.matchWithNumber = require_matchWithNumber.matchWithNumber;
 exports.matchWithNumberOtherwise = require_matchWithNumberOtherwise.matchWithNumberOtherwise;
 exports.matchWithString = require_matchWithString.matchWithString;
 exports.matchWithStringOtherwise = require_matchWithStringOtherwise.matchWithStringOtherwise;
+exports.matchWithTaggedObject = require_matchWithTaggedObject.matchWithTaggedObject;
+exports.matchWithTaggedObjectOtherwise = require_matchWithTaggedObjectOtherwise.matchWithTaggedObjectOtherwise;
 exports.otherwise = require_otherwise.otherwise;
 Object.defineProperty(exports, "pattern_exports", {
 	enumerable: true,

package/dist/pattern/index.d.ts

@@ -11,3 +11,7 @@ export * from './matchWithString';
 export * from './matchWithNumber';
 export * from './matchWithStringOtherwise';
 export * from './matchWithNumberOtherwise';
+export * from './matchWithTaggedObject';
+export * from './matchWithTaggedObjectOtherwise';
+export * from './matchWithEntity';
+export * from './matchWithEntityOtherwise';

package/dist/pattern/index.mjs

@@ -12,6 +12,10 @@ import { matchWithString } from "./matchWithString.mjs";
 import { matchWithNumber } from "./matchWithNumber.mjs";
 import { matchWithStringOtherwise } from "./matchWithStringOtherwise.mjs";
 import { matchWithNumberOtherwise } from "./matchWithNumberOtherwise.mjs";
+import { matchWithTaggedObject } from "./matchWithTaggedObject.mjs";
+import { matchWithTaggedObjectOtherwise } from "./matchWithTaggedObjectOtherwise.mjs";
+import { matchWithEntity } from "./matchWithEntity.mjs";
+import { matchWithEntityOtherwise } from "./matchWithEntityOtherwise.mjs";
 //#region scripts/pattern/index.ts
 var pattern_exports = /* @__PURE__ */ __exportAll({
 	InvalidExhaustivePatternError: () => InvalidExhaustivePatternError,
@@ -20,10 +24,14 @@ var pattern_exports = /* @__PURE__ */ __exportAll({
 	isResult: () => isResult,
 	match: () => match,
 	matchBuilder: () => matchBuilder,
+	matchWithEntity: () => matchWithEntity,
+	matchWithEntityOtherwise: () => matchWithEntityOtherwise,
 	matchWithNumber: () => matchWithNumber,
 	matchWithNumberOtherwise: () => matchWithNumberOtherwise,
 	matchWithString: () => matchWithString,
 	matchWithStringOtherwise: () => matchWithStringOtherwise,
+	matchWithTaggedObject: () => matchWithTaggedObject,
+	matchWithTaggedObjectOtherwise: () => matchWithTaggedObjectOtherwise,
 	otherwise: () => otherwise,
 	result: () => result,
 	union: () => union,
@@ -31,4 +39,4 @@ var pattern_exports = /* @__PURE__ */ __exportAll({
 	whenNot: () => whenNot
 });
 //#endregion
-export { InvalidExhaustivePatternError, exhaustive, isMatch, isResult, match, matchBuilder, matchWithNumber, matchWithNumberOtherwise, matchWithString, matchWithStringOtherwise, otherwise, pattern_exports, result, union, when, whenNot };
+export { InvalidExhaustivePatternError, exhaustive, isMatch, isResult, match, matchBuilder, matchWithEntity, matchWithEntityOtherwise, matchWithNumber, matchWithNumberOtherwise, matchWithString, matchWithStringOtherwise, matchWithTaggedObject, matchWithTaggedObjectOtherwise, otherwise, pattern_exports, result, union, when, whenNot };

package/dist/pattern/matchWithEntity.cjs

@@ -0,0 +1,12 @@
+const require_base = require("../modeling/entity/base.cjs");
+//#region scripts/pattern/matchWithEntity.ts
+function matchWithEntity(...args) {
+	if (args.length === 1) {
+		const [matcher] = args;
+		return (input) => matcher[require_base.entityKind.getValue(input)](input);
+	}
+	const [input, matcher] = args;
+	return matcher[require_base.entityKind.getValue(input)](input);
+}
+//#endregion
+exports.matchWithEntity = matchWithEntity;

package/dist/pattern/matchWithEntity.d.ts

@@ -0,0 +1,12 @@
+import type * as DCommon from '../common';
+import * as DModeling from '../modeling';
+import type * as DObject from '../object';
+import type * as DString from '../string';
+type ComputeMatcher<GenericEntity extends DModeling.Entity> = {
+    [Entity in GenericEntity as DModeling.GetEntityName<Entity>]: (value: Entity) => unknown;
+};
+type ForbiddenMoreKey<GenericEntity extends DModeling.Entity, GenericMatcher extends ComputeMatcher<GenericEntity>> = DObject.ForbiddenKey<GenericMatcher, Extract<Exclude<keyof GenericMatcher, DModeling.GetEntityName<GenericEntity>>, string>>;
+type RequireSimpleName<GenericEntity extends DModeling.Entity> = DString.RequireSimpleLiteral<DModeling.GetEntityName<GenericEntity>>;
+export declare function matchWithEntity<GenericEntity extends DModeling.Entity, GenericMatcher extends ComputeMatcher<GenericEntity>>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericEntity>, GenericMatcher> & ForbiddenMoreKey<NoInfer<GenericEntity>, GenericMatcher>)): (input: GenericEntity & RequireSimpleName<GenericEntity>) => ReturnType<Extract<NoInfer<GenericMatcher>[keyof GenericMatcher], DCommon.AnyFunction>>;
+export declare function matchWithEntity<GenericEntity extends DModeling.Entity, GenericMatcher extends ComputeMatcher<GenericEntity>>(input: GenericEntity & RequireSimpleName<GenericEntity>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericEntity>, GenericMatcher> & ForbiddenMoreKey<GenericEntity, GenericMatcher>)): ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>>;
+export {};

package/dist/pattern/matchWithEntity.mjs

@@ -0,0 +1,12 @@
+import { entityKind } from "../modeling/entity/base.mjs";
+//#region scripts/pattern/matchWithEntity.ts
+function matchWithEntity(...args) {
+	if (args.length === 1) {
+		const [matcher] = args;
+		return (input) => matcher[entityKind.getValue(input)](input);
+	}
+	const [input, matcher] = args;
+	return matcher[entityKind.getValue(input)](input);
+}
+//#endregion
+export { matchWithEntity };

package/dist/pattern/matchWithEntityOtherwise.cjs

@@ -0,0 +1,13 @@
+const require_base = require("../modeling/entity/base.cjs");
+//#region scripts/pattern/matchWithEntityOtherwise.ts
+function matchWithEntityOtherwise(...args) {
+	if (args.length === 2) {
+		const [matcher, otherwise] = args;
+		return (input) => matchWithEntityOtherwise(input, matcher, otherwise);
+	}
+	const [input, matcher, otherwise] = args;
+	const entityName = require_base.entityKind.getValue(input);
+	return matcher[entityName] === void 0 ? otherwise(input) : matcher[entityName](input);
+}
+//#endregion
+exports.matchWithEntityOtherwise = matchWithEntityOtherwise;

package/dist/pattern/matchWithEntityOtherwise.d.ts

@@ -0,0 +1,14 @@
+import type * as DCommon from '../common';
+import * as DModeling from '../modeling';
+import type * as DObject from '../object';
+import type * as DString from '../string';
+type ComputeMatcher<GenericEntity extends DModeling.Entity> = {
+    [Entity in GenericEntity as DModeling.GetEntityName<Entity>]?: (value: Entity) => unknown;
+};
+type ForbiddenMoreKey<GenericEntity extends DModeling.Entity, GenericMatcher extends ComputeMatcher<GenericEntity>> = DObject.ForbiddenKey<GenericMatcher, Extract<Exclude<keyof GenericMatcher, DModeling.GetEntityName<GenericEntity>>, string>>;
+type HandledKeys<GenericMatcher extends object> = Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, string>;
+type UnhandledEntity<GenericEntity extends DModeling.Entity, GenericMatcher extends object> = Exclude<GenericEntity, DModeling.ExtractByEntityName<GenericEntity, HandledKeys<GenericMatcher>>>;
+type RequireSimpleName<GenericEntity extends DModeling.Entity> = DString.RequireSimpleLiteral<DModeling.GetEntityName<GenericEntity>>;
+export declare function matchWithEntityOtherwise<GenericEntity extends DModeling.Entity, GenericMatcher extends ComputeMatcher<GenericEntity>, GenericOutput>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericEntity>, GenericMatcher> & ForbiddenMoreKey<NoInfer<GenericEntity>, GenericMatcher>), otherwise: (value: UnhandledEntity<GenericEntity, GenericMatcher>) => GenericOutput): (input: GenericEntity & RequireSimpleName<GenericEntity>) => (ReturnType<Extract<NoInfer<GenericMatcher>[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithEntityOtherwise<GenericEntity extends DModeling.Entity, GenericMatcher extends ComputeMatcher<GenericEntity>, GenericOutput>(input: GenericEntity & RequireSimpleName<GenericEntity>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericEntity>, GenericMatcher> & ForbiddenMoreKey<GenericEntity, GenericMatcher>), otherwise: (value: UnhandledEntity<GenericEntity, GenericMatcher>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export {};

package/dist/pattern/matchWithEntityOtherwise.mjs

@@ -0,0 +1,13 @@
+import { entityKind } from "../modeling/entity/base.mjs";
+//#region scripts/pattern/matchWithEntityOtherwise.ts
+function matchWithEntityOtherwise(...args) {
+	if (args.length === 2) {
+		const [matcher, otherwise] = args;
+		return (input) => matchWithEntityOtherwise(input, matcher, otherwise);
+	}
+	const [input, matcher, otherwise] = args;
+	const entityName = entityKind.getValue(input);
+	return matcher[entityName] === void 0 ? otherwise(input) : matcher[entityName](input);
+}
+//#endregion
+export { matchWithEntityOtherwise };

package/dist/pattern/matchWithNumberOtherwise.cjs

@@ -1,15 +1,11 @@
 //#region scripts/pattern/matchWithNumberOtherwise.ts
-function execute(input, matcher, otherwise) {
-	const callback = matcher[input];
-	return callback === void 0 ? otherwise(input) : callback(input);
-}
 function matchWithNumberOtherwise(...args) {
 	if (args.length === 2) {
 		const [matcher, otherwise] = args;
-		return (input) => execute(input, matcher, otherwise);
+		return (input) => matchWithNumberOtherwise(input, matcher, otherwise);
 	}
 	const [input, matcher, otherwise] = args;
-	return execute(input, matcher, otherwise);
+	return matcher[input] === void 0 ? otherwise(input) : matcher[input](input);
 }
 //#endregion
 exports.matchWithNumberOtherwise = matchWithNumberOtherwise;