@duplojs/lang 0.0.0 → 0.0.1-beta.10

package/dist/path/resolveRelative.cjs

@@ -1,26 +1,23 @@
 //#region scripts/path/resolveRelative.ts
-const segmentTrailingRegex = /\/$/;
-const segmentRelativeRegex = /^(.\/)/;
-function resolveRelative(segments) {
-	let clearedPath = "";
-	for (const segment of segments) {
-		if (segment.length === 0) continue;
-		else if (segment === "/") {
-			clearedPath = segment;
-			continue;
+function resolveRelative(paths) {
+	let absolute = false;
+	const result = [];
+	for (const path of paths) {
+		if (path === ".") continue;
+		if (path.startsWith("/")) {
+			absolute = true;
+			result.length = 0;
+		}
+		for (const segment of path.split("/")) {
+			if (segment === "") continue;
+			if (segment === "..") {
+				if (result.length && result.at(-1) !== "..") result.pop();
+				else if (!absolute) result.push("..");
+			} else result.push(segment);
 		}
-		const formattedSegment = segment.replace(segmentTrailingRegex, "").replace(segmentRelativeRegex, "");
-		if (formattedSegment.startsWith("/") || clearedPath === "") clearedPath = formattedSegment;
-		else if (clearedPath === "/") clearedPath += formattedSegment;
-		else clearedPath += `/${formattedSegment}`;
 	}
-	const dotResult = [];
-	const result = [];
-	for (const element of clearedPath.split("/")) if (element === "..") {
-		if (!result.pop()) dotResult.push(element);
-	} else result.push(element);
-	if (dotResult.length === 0) return result.join("/");
-	return `${dotResult.join("/")}/${result.join("/")}`;
+	if (absolute) return `/${result.join("/")}`;
+	return result.join("/") || ".";
 }
 //#endregion
 exports.resolveRelative = resolveRelative;

package/dist/path/resolveRelative.d.ts

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

package/dist/path/resolveRelative.mjs

@@ -1,26 +1,23 @@
 //#region scripts/path/resolveRelative.ts
-const segmentTrailingRegex = /\/$/;
-const segmentRelativeRegex = /^(.\/)/;
-function resolveRelative(segments) {
-	let clearedPath = "";
-	for (const segment of segments) {
-		if (segment.length === 0) continue;
-		else if (segment === "/") {
-			clearedPath = segment;
-			continue;
+function resolveRelative(paths) {
+	let absolute = false;
+	const result = [];
+	for (const path of paths) {
+		if (path === ".") continue;
+		if (path.startsWith("/")) {
+			absolute = true;
+			result.length = 0;
+		}
+		for (const segment of path.split("/")) {
+			if (segment === "") continue;
+			if (segment === "..") {
+				if (result.length && result.at(-1) !== "..") result.pop();
+				else if (!absolute) result.push("..");
+			} else result.push(segment);
 		}
-		const formattedSegment = segment.replace(segmentTrailingRegex, "").replace(segmentRelativeRegex, "");
-		if (formattedSegment.startsWith("/") || clearedPath === "") clearedPath = formattedSegment;
-		else if (clearedPath === "/") clearedPath += formattedSegment;
-		else clearedPath += `/${formattedSegment}`;
 	}
-	const dotResult = [];
-	const result = [];
-	for (const element of clearedPath.split("/")) if (element === "..") {
-		if (!result.pop()) dotResult.push(element);
-	} else result.push(element);
-	if (dotResult.length === 0) return result.join("/");
-	return `${dotResult.join("/")}/${result.join("/")}`;
+	if (absolute) return `/${result.join("/")}`;
+	return result.join("/") || ".";
 }
 //#endregion
 export { resolveRelative };

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

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

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

@@ -0,0 +1,2 @@
+import { IsLiteralPath } from './isLiteralPath';
+export type IsLiteralAbsolutePath<GenericValue extends string> = IsLiteralPath<GenericValue> extends true ? GenericValue extends `/${string}` ? true : false : false;

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;