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

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

@@ -0,0 +1,20 @@
+import type * as DCommon from '../../common';
+import type * as DString from '../../string';
+type CheckSegment<GenericSegment extends readonly string[], GenericDotIsPass extends boolean, GenericIsFirst extends boolean = true> = GenericSegment extends readonly [] ? true : GenericSegment extends readonly [
+    infer InferredFirst extends string,
+    ...infer InferredRest extends readonly string[]
+] ? DCommon.Or<[
+    DCommon.IsEqual<".", InferredFirst>,
+    DString.Includes<InferredFirst, "/">,
+    DString.Includes<InferredFirst, "\0">,
+    DCommon.And<[
+        DCommon.IsEqual<GenericIsFirst, false>,
+        DCommon.IsEqual<"", InferredFirst>
+    ]>,
+    DCommon.And<[
+        DCommon.IsEqual<GenericDotIsPass, true>,
+        DCommon.IsEqual<"..", InferredFirst>
+    ]>
+]> extends true ? false : CheckSegment<InferredRest, DCommon.Not<DCommon.IsEqual<InferredFirst, "..">>, false> : false;
+export type IsLiteralPath<GenericValue extends string> = DString.IsLiteral<GenericValue> extends true ? GenericValue extends "" ? false : GenericValue extends "/" ? true : GenericValue extends "." ? true : DString.Split<GenericValue, "/"> extends infer InferredResult extends readonly string[] ? CheckSegment<InferredResult, false> : never : false;
+export {};

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

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

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

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

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

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

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

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

package/dist/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/matchWithNumber.d.ts

@@ -1,9 +1,9 @@
 import type * as DCommon from '../common';
 import type * as DNumber from '../number/types';
-type ComputeMatcher<GenericInput extends number> = {
+type ComputeMatcher<GenericInput extends number> = DCommon.SimplifyType<{
     [Prop in GenericInput]: (value: Prop) => unknown;
-};
+}>;
 type ForbiddenMoreKey<GenericInput extends number, GenericMatcher extends ComputeMatcher<GenericInput>> = Exclude<keyof GenericMatcher, GenericInput> extends infer InferredKey ? DCommon.IsEqual<InferredKey, never> extends true ? unknown : DCommon.ComputedTypeError<`Key "${Extract<InferredKey, number>}" is forbidden.`> : never;
-export declare function matchWithNumber<GenericInput extends number, GenericMatcher extends ComputeMatcher<GenericInput>>(matcher: GenericMatcher & ComputeMatcher<NoInfer<GenericInput>> & ForbiddenMoreKey<NoInfer<GenericInput>, GenericMatcher>): (input: GenericInput & DNumber.RequireSimpleLiteral<GenericInput>) => ReturnType<NoInfer<GenericMatcher>[keyof GenericMatcher]>;
-export declare function matchWithNumber<GenericInput extends number, GenericMatcher extends ComputeMatcher<GenericInput>>(input: GenericInput & DNumber.RequireSimpleLiteral<GenericInput>, matcher: DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericInput>, GenericMatcher> & ForbiddenMoreKey<GenericInput, GenericMatcher>): ReturnType<GenericMatcher[keyof GenericMatcher]>;
+export declare function matchWithNumber<GenericInput extends number, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, number>, GenericMatcher extends ComputeMatcher<GenericClearInput>>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>)): (input: GenericInput & DNumber.RequireSimpleLiteral<GenericClearInput>) => ReturnType<GenericMatcher[keyof GenericMatcher]>;
+export declare function matchWithNumber<GenericInput extends number, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, number>, GenericMatcher extends ComputeMatcher<GenericClearInput>>(input: GenericInput & DNumber.RequireSimpleLiteral<GenericClearInput>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>)): ReturnType<GenericMatcher[keyof GenericMatcher]>;
 export {};

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;

package/dist/pattern/matchWithNumberOtherwise.d.ts

@@ -1,11 +1,11 @@
 import type * as DCommon from '../common';
 import type * as DNumber from '../number/types';
 import type * as DObject from '../object';
-type ComputeMatcher<GenericInput extends number> = {
+type ComputeMatcher<GenericInput extends number> = DCommon.SimplifyType<{
     [Prop in GenericInput]?: (value: Prop) => unknown;
-};
+}>;
 type ForbiddenMoreKey<GenericInput extends number, GenericMatcher extends ComputeMatcher<GenericInput>> = Exclude<keyof GenericMatcher, GenericInput> extends infer InferredKey ? DCommon.IsEqual<InferredKey, never> extends true ? unknown : DCommon.ComputedTypeError<`Key "${Extract<InferredKey, number>}" is forbidden.`> : never;
 type HandledKeys<GenericMatcher extends object> = Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, number>;
-export declare function matchWithNumberOtherwise<GenericInput extends number, GenericMatcher extends ComputeMatcher<GenericInput>, GenericOutput>(matcher: GenericMatcher & ComputeMatcher<NoInfer<GenericInput>> & ForbiddenMoreKey<NoInfer<GenericInput>, GenericMatcher>, otherwise: (value: Exclude<GenericInput, HandledKeys<GenericMatcher>>) => GenericOutput): (input: GenericInput & DNumber.RequireSimpleLiteral<GenericInput>) => (ReturnType<Extract<NoInfer<GenericMatcher>[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
-export declare function matchWithNumberOtherwise<GenericInput extends number, GenericMatcher extends ComputeMatcher<GenericInput>, GenericOutput>(input: GenericInput & DNumber.RequireSimpleLiteral<GenericInput>, matcher: DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericInput>, GenericMatcher> & ForbiddenMoreKey<GenericInput, GenericMatcher>, otherwise: (value: Exclude<GenericInput, HandledKeys<GenericMatcher>>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithNumberOtherwise<GenericInput extends number, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, number>, GenericMatcher extends ComputeMatcher<GenericClearInput>, GenericOutput extends unknown>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>), otherwise: (value: Exclude<GenericInput, HandledKeys<GenericMatcher>>) => GenericOutput): (input: GenericInput & DNumber.RequireSimpleLiteral<GenericClearInput>) => (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithNumberOtherwise<GenericInput extends number, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, number>, GenericMatcher extends ComputeMatcher<GenericClearInput>, GenericOutput extends unknown>(input: GenericInput & DNumber.RequireSimpleLiteral<GenericClearInput>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>), otherwise: (value: Exclude<GenericInput, HandledKeys<GenericMatcher>>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
 export {};

package/dist/pattern/matchWithNumberOtherwise.mjs

@@ -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
 export { matchWithNumberOtherwise };

package/dist/pattern/matchWithString.d.ts

@@ -1,10 +1,10 @@
 import type * as DCommon from '../common';
 import type * as DObject from '../object';
 import type * as DString from '../string/types';
-type ComputeMatcher<GenericInput extends string> = {
+type ComputeMatcher<GenericInput extends string> = DCommon.SimplifyType<{
     [Prop in GenericInput]: (value: Prop) => unknown;
-};
+}>;
 type ForbiddenMoreKey<GenericInput extends string, GenericMatcher extends ComputeMatcher<GenericInput>> = DObject.ForbiddenKey<GenericMatcher, Extract<Exclude<keyof GenericMatcher, GenericInput>, string>>;
-export declare function matchWithString<GenericInput extends string, GenericMatcher extends ComputeMatcher<GenericInput>>(matcher: GenericMatcher & ComputeMatcher<NoInfer<GenericInput>> & ForbiddenMoreKey<NoInfer<GenericInput>, GenericMatcher>): (input: GenericInput & DString.RequireSimpleLiteral<GenericInput>) => ReturnType<NoInfer<GenericMatcher>[keyof GenericMatcher]>;
-export declare function matchWithString<GenericInput extends string, GenericMatcher extends ComputeMatcher<GenericInput>>(input: GenericInput & DString.RequireSimpleLiteral<GenericInput>, matcher: DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericInput>, GenericMatcher> & ForbiddenMoreKey<GenericInput, GenericMatcher>): ReturnType<GenericMatcher[keyof GenericMatcher]>;
+export declare function matchWithString<GenericInput extends string, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, string>, GenericMatcher extends ComputeMatcher<GenericClearInput>>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>)): (input: GenericInput & DString.RequireSimpleLiteral<GenericClearInput>) => ReturnType<GenericMatcher[keyof GenericMatcher]>;
+export declare function matchWithString<GenericInput extends string, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, string>, GenericMatcher extends ComputeMatcher<GenericClearInput>>(input: GenericInput & DString.RequireSimpleLiteral<GenericClearInput>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>)): ReturnType<GenericMatcher[keyof GenericMatcher]>;
 export {};

package/dist/pattern/matchWithStringOtherwise.cjs

@@ -1,15 +1,11 @@
 //#region scripts/pattern/matchWithStringOtherwise.ts
-function execute(input, matcher, otherwise) {
-	const callback = matcher[input];
-	return callback === void 0 ? otherwise(input) : callback(input);
-}
 function matchWithStringOtherwise(...args) {
 	if (args.length === 2) {
 		const [matcher, otherwise] = args;
-		return (input) => execute(input, matcher, otherwise);
+		return (input) => matchWithStringOtherwise(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.matchWithStringOtherwise = matchWithStringOtherwise;

package/dist/pattern/matchWithStringOtherwise.d.ts

@@ -1,11 +1,11 @@
 import type * as DCommon from '../common';
 import type * as DObject from '../object';
-import type * as DString from '../string/types';
-type ComputeMatcher<GenericInput extends string> = {
+import type * as DString from '../string';
+type ComputeMatcher<GenericInput extends string> = DCommon.SimplifyType<{
     [Prop in GenericInput]?: (value: Prop) => unknown;
-};
+}>;
 type ForbiddenMoreKey<GenericInput extends string, GenericMatcher extends ComputeMatcher<GenericInput>> = DObject.ForbiddenKey<GenericMatcher, Extract<Exclude<keyof GenericMatcher, GenericInput>, string>>;
 type HandledKeys<GenericMatcher extends object> = Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, string>;
-export declare function matchWithStringOtherwise<GenericInput extends string, GenericMatcher extends ComputeMatcher<GenericInput>, GenericOutput>(matcher: GenericMatcher & ComputeMatcher<NoInfer<GenericInput>> & ForbiddenMoreKey<NoInfer<GenericInput>, GenericMatcher>, otherwise: (value: Exclude<GenericInput, HandledKeys<GenericMatcher>>) => GenericOutput): (input: GenericInput & DString.RequireSimpleLiteral<GenericInput>) => (ReturnType<Extract<NoInfer<GenericMatcher>[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
-export declare function matchWithStringOtherwise<GenericInput extends string, GenericMatcher extends ComputeMatcher<GenericInput>, GenericOutput>(input: GenericInput & DString.RequireSimpleLiteral<GenericInput>, matcher: DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericInput>, GenericMatcher> & ForbiddenMoreKey<GenericInput, GenericMatcher>, otherwise: (value: Exclude<GenericInput, HandledKeys<GenericMatcher>>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithStringOtherwise<GenericInput extends string, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, string>, GenericMatcher extends ComputeMatcher<GenericClearInput>, GenericOutput extends unknown>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>), otherwise: (value: Exclude<GenericInput, HandledKeys<GenericMatcher>>) => GenericOutput): (input: GenericInput & DString.RequireSimpleLiteral<GenericClearInput>) => (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithStringOtherwise<GenericInput extends string, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, string>, GenericMatcher extends ComputeMatcher<GenericClearInput>, GenericOutput extends unknown>(input: GenericInput & DString.RequireSimpleLiteral<GenericClearInput>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>), otherwise: (value: Exclude<GenericInput, HandledKeys<GenericMatcher>>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
 export {};

package/dist/pattern/matchWithStringOtherwise.mjs

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

package/dist/pattern/matchWithTaggedObject.cjs

@@ -0,0 +1,12 @@
+const require_helper = require("../modeling/taggedObject/helper.cjs");
+//#region scripts/pattern/matchWithTaggedObject.ts
+function matchWithTaggedObject(...args) {
+	if (args.length === 1) {
+		const [matcher] = args;
+		return (input) => matcher[require_helper.getTagValue(input)](input);
+	}
+	const [input, matcher] = args;
+	return matcher[require_helper.getTagValue(input)](input);
+}
+//#endregion
+exports.matchWithTaggedObject = matchWithTaggedObject;

package/dist/pattern/matchWithTaggedObject.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<GenericTaggedObject extends DModeling.ObjectTag> = {
+    [TaggedObject in GenericTaggedObject as DModeling.GetTagValue<TaggedObject>]: (value: TaggedObject) => unknown;
+};
+type ForbiddenMoreKey<GenericTaggedObject extends DModeling.ObjectTag, GenericMatcher extends ComputeMatcher<GenericTaggedObject>> = DObject.ForbiddenKey<GenericMatcher, Extract<Exclude<keyof GenericMatcher, DModeling.GetTagValue<GenericTaggedObject>>, string>>;
+type RequireSimpleTag<GenericTaggedObject extends DModeling.ObjectTag> = DString.RequireSimpleLiteral<DModeling.GetTagValue<GenericTaggedObject>>;
+export declare function matchWithTaggedObject<GenericTaggedObject extends DModeling.ObjectTag, GenericMatcher extends ComputeMatcher<GenericTaggedObject>>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericTaggedObject>, GenericMatcher> & ForbiddenMoreKey<NoInfer<GenericTaggedObject>, GenericMatcher>)): (input: GenericTaggedObject & RequireSimpleTag<GenericTaggedObject>) => ReturnType<Extract<NoInfer<GenericMatcher>[keyof GenericMatcher], DCommon.AnyFunction>>;
+export declare function matchWithTaggedObject<GenericTaggedObject extends DModeling.ObjectTag, GenericMatcher extends ComputeMatcher<GenericTaggedObject>>(input: GenericTaggedObject & RequireSimpleTag<GenericTaggedObject>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericTaggedObject>, GenericMatcher> & ForbiddenMoreKey<GenericTaggedObject, GenericMatcher>)): ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>>;
+export {};

package/dist/pattern/matchWithTaggedObject.mjs

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

package/dist/pattern/matchWithTaggedObjectOtherwise.cjs

@@ -0,0 +1,13 @@
+const require_helper = require("../modeling/taggedObject/helper.cjs");
+//#region scripts/pattern/matchWithTaggedObjectOtherwise.ts
+function matchWithTaggedObjectOtherwise(...args) {
+	if (args.length === 2) {
+		const [matcher, otherwise] = args;
+		return (input) => matchWithTaggedObjectOtherwise(input, matcher, otherwise);
+	}
+	const [input, matcher, otherwise] = args;
+	const tagValue = require_helper.getTagValue(input);
+	return matcher[tagValue] === void 0 ? otherwise(input) : matcher[tagValue](input);
+}
+//#endregion
+exports.matchWithTaggedObjectOtherwise = matchWithTaggedObjectOtherwise;

package/dist/pattern/matchWithTaggedObjectOtherwise.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<GenericTaggedObject extends DModeling.ObjectTag> = {
+    [TaggedObject in GenericTaggedObject as DModeling.GetTagValue<TaggedObject>]?: (value: TaggedObject) => unknown;
+};
+type ForbiddenMoreKey<GenericTaggedObject extends DModeling.ObjectTag, GenericMatcher extends ComputeMatcher<GenericTaggedObject>> = DObject.ForbiddenKey<GenericMatcher, Extract<Exclude<keyof GenericMatcher, DModeling.GetTagValue<GenericTaggedObject>>, string>>;
+type HandledKeys<GenericMatcher extends object> = Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, string>;
+type UnhandledTaggedObject<GenericTaggedObject extends DModeling.ObjectTag, GenericMatcher extends object> = Exclude<GenericTaggedObject, DModeling.ObjectTag<HandledKeys<GenericMatcher>>>;
+type RequireLiteralTag<GenericTaggedObject extends DModeling.ObjectTag> = DString.RequireSimpleLiteral<DModeling.GetTagValue<GenericTaggedObject>>;
+export declare function matchWithTaggedObjectOtherwise<GenericTaggedObject extends DModeling.ObjectTag, GenericMatcher extends ComputeMatcher<GenericTaggedObject>, GenericOutput>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericTaggedObject>, GenericMatcher> & ForbiddenMoreKey<NoInfer<GenericTaggedObject>, GenericMatcher>), otherwise: (value: UnhandledTaggedObject<GenericTaggedObject, GenericMatcher>) => GenericOutput): (input: GenericTaggedObject & RequireLiteralTag<GenericTaggedObject>) => (ReturnType<Extract<NoInfer<GenericMatcher>[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithTaggedObjectOtherwise<GenericTaggedObject extends DModeling.ObjectTag, GenericMatcher extends ComputeMatcher<GenericTaggedObject>, GenericOutput>(input: GenericTaggedObject & RequireLiteralTag<GenericTaggedObject>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericTaggedObject>, GenericMatcher> & ForbiddenMoreKey<GenericTaggedObject, GenericMatcher>), otherwise: (value: UnhandledTaggedObject<GenericTaggedObject, GenericMatcher>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export {};

package/dist/pattern/matchWithTaggedObjectOtherwise.mjs

@@ -0,0 +1,13 @@
+import { getTagValue } from "../modeling/taggedObject/helper.mjs";
+//#region scripts/pattern/matchWithTaggedObjectOtherwise.ts
+function matchWithTaggedObjectOtherwise(...args) {
+	if (args.length === 2) {
+		const [matcher, otherwise] = args;
+		return (input) => matchWithTaggedObjectOtherwise(input, matcher, otherwise);
+	}
+	const [input, matcher, otherwise] = args;
+	const tagValue = getTagValue(input);
+	return matcher[tagValue] === void 0 ? otherwise(input) : matcher[tagValue](input);
+}
+//#endregion
+export { matchWithTaggedObjectOtherwise };

package/dist/string/at.d.ts

@@ -1,3 +1,3 @@
 import { At } from './types';
-export declare function at<GenericString extends string, GenericIndex extends number>(index: GenericIndex): (string: GenericString) => At<GenericString, GenericIndex>;
-export declare function at<GenericString extends string, GenericIndex extends number>(string: GenericString, index: GenericIndex): At<GenericString, GenericIndex>;
+export declare function at<GenericString extends string, GenericIndex extends number>(index: GenericIndex): (string: GenericString) => GenericString extends string ? At<GenericString, GenericIndex> : never;
+export declare function at<GenericString extends string, GenericIndex extends number>(string: GenericString, index: GenericIndex): GenericString extends string ? At<GenericString, GenericIndex> : never;

package/dist/string/constraints/allowedCharacters.d.ts

@@ -2,8 +2,8 @@ import type * as DCommon from '../../common';
 import type * as DObject from '../../object';
 export interface CharactersRangeStore {
 }
-export type CharactersRange = Extract<DObject.GetPropsWithValue<CharactersRangeStore, true>, string>;
+export type CharactersRange = Extract<DObject.GetPropsWithValueExtends<CharactersRangeStore, string>, string>;
 export type AllowedCharactersConstraintName = "string-allowed-characters";
-export interface AllowedCharacters<GenericCharactersRange extends CharactersRange = never> extends DCommon.Constraint<AllowedCharactersConstraintName, Record<GenericCharactersRange, unknown>> {
+export interface AllowedCharacters<GenericCharactersRange extends CharactersRange = never> extends DCommon.Constraint<AllowedCharactersConstraintName, () => Partial<Record<GenericCharactersRange, GenericCharactersRange>>> {
 }
-export type ExtractAllowedCharacters<GenericConstraint extends unknown, GenericDefault extends unknown = never> = GenericConstraint extends AllowedCharacters ? (keyof GenericConstraint[DCommon.ConstraintSymbol][AllowedCharactersConstraintName]) extends infer InferredResult extends CharactersRange ? DCommon.UnionToIntersection<InferredResult extends any ? AllowedCharacters<InferredResult> : never> : GenericDefault : GenericDefault;
+export type ExtractAllowedCharacters<GenericConstraint extends unknown, GenericDefault extends unknown = never> = GenericConstraint extends AllowedCharacters ? (keyof ReturnType<GenericConstraint[DCommon.ConstraintSymbol][AllowedCharactersConstraintName]>) extends infer InferredResult extends CharactersRange ? DCommon.UnionToIntersection<InferredResult extends any ? DCommon.IsNever<InferredResult> extends true ? AllowedCharacters : AllowedCharacters<InferredResult> : never> : GenericDefault : GenericDefault;

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

@@ -1,4 +1,3 @@
-export type * from './types';
 export type * from './allowedCharacters';
 export type * from './email';
 export type * from './format';
@@ -6,6 +5,8 @@ export type * from './lengthEqual';
 export type * from './maxCharacters';
 export type * from './minCharacters';
 export type * from './notEmpty';
+export type * from './number';
 export type * from './trimmed';
+export type * from './types';
 export type * from './url';
 export type * from './uuid';

package/dist/string/constraints/number.d.ts

@@ -0,0 +1,4 @@
+import { NumberInString } from '../types';
+import { Format } from './format';
+export interface Number extends Format<"number", NumberInString> {
+}

package/dist/string/first.d.ts

@@ -1,2 +1,2 @@
 import { First } from './types';
-export declare function first<GenericString extends string>(string: GenericString): First<GenericString>;
+export declare function first<GenericString extends string>(string: GenericString): GenericString extends unknown ? First<GenericString> : never;

package/dist/string/index.cjs

@@ -9,12 +9,12 @@ const require_extractAll = require("./extractAll.cjs");
 const require_first = require("./first.cjs");
 const require_includes = require("./includes.cjs");
 const require_indexOf = require("./indexOf.cjs");
-const require_infer = require("./infer.cjs");
 const require_isComposedOf = require("./isComposedOf.cjs");
 const require_isEmail = require("./isEmail.cjs");
 const require_isIn = require("./isIn.cjs");
 const require_isKeyof = require("./isKeyof.cjs");
 const require_isNotEmpty = require("./isNotEmpty.cjs");
+const require_isNumber = require("./isNumber.cjs");
 const require_isUrl = require("./isUrl.cjs");
 const require_isUuid = require("./isUuid.cjs");
 const require_join = require("./join.cjs");
@@ -48,6 +48,7 @@ const require_toUpperCase = require("./toUpperCase.cjs");
 const require_default = require("./trim/default.cjs");
 const require_end = require("./trim/end.cjs");
 const require_start = require("./trim/start.cjs");
+const require_is = require("./trim/is.cjs");
 const require_uncapitalize = require("./uncapitalize.cjs");
 //#region scripts/string/index.ts
 var string_exports = /* @__PURE__ */ require_runtime.__exportAll({
@@ -62,12 +63,13 @@ var string_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	first: () => require_first.first,
 	includes: () => require_includes.includes,
 	indexOf: () => require_indexOf.indexOf,
-	infer: () => require_infer.infer,
 	isComposedOf: () => require_isComposedOf.isComposedOf,
 	isEmail: () => require_isEmail.isEmail,
 	isIn: () => require_isIn.isIn,
 	isKeyof: () => require_isKeyof.isKeyof,
 	isNotEmpty: () => require_isNotEmpty.isNotEmpty,
+	isNumber: () => require_isNumber.isNumber,
+	isTrimmed: () => require_is.isTrimmed,
 	isUrl: () => require_isUrl.isUrl,
 	isUuid: () => require_isUuid.isUuid,
 	join: () => require_join.join,
@@ -116,12 +118,13 @@ exports.extractAll = require_extractAll.extractAll;
 exports.first = require_first.first;
 exports.includes = require_includes.includes;
 exports.indexOf = require_indexOf.indexOf;
-exports.infer = require_infer.infer;
 exports.isComposedOf = require_isComposedOf.isComposedOf;
 exports.isEmail = require_isEmail.isEmail;
 exports.isIn = require_isIn.isIn;
 exports.isKeyof = require_isKeyof.isKeyof;
 exports.isNotEmpty = require_isNotEmpty.isNotEmpty;
+exports.isNumber = require_isNumber.isNumber;
+exports.isTrimmed = require_is.isTrimmed;
 exports.isUrl = require_isUrl.isUrl;
 exports.isUuid = require_isUuid.isUuid;
 exports.join = require_join.join;

package/dist/string/index.d.ts

@@ -9,12 +9,12 @@ export * from './extractAll';
 export * from './first';
 export * from './includes';
 export * from './indexOf';
-export * from './infer';
 export * from './isComposedOf';
 export * from './isEmail';
 export * from './isIn';
 export * from './isKeyof';
 export * from './isNotEmpty';
+export * from './isNumber';
 export * from './isUrl';
 export * from './isUuid';
 export * from './join';