@duplojs/lang 0.0.0 → 0.0.1-beta.2

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;

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/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,6 +1,6 @@
 import type * as DCommon from '../common';
 import type * as DObject from '../object';
-import type * as DString from '../string/types';
+import type * as DString from '../string';
 type ComputeMatcher<GenericInput extends string> = {
     [Prop in GenericInput]?: (value: Prop) => unknown;
 };

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/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

@@ -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({
@@ -68,6 +69,7 @@ var string_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	isIn: () => require_isIn.isIn,
 	isKeyof: () => require_isKeyof.isKeyof,
 	isNotEmpty: () => require_isNotEmpty.isNotEmpty,
+	isTrimmed: () => require_is.isTrimmed,
 	isUrl: () => require_isUrl.isUrl,
 	isUuid: () => require_isUuid.isUuid,
 	join: () => require_join.join,
@@ -122,6 +124,7 @@ exports.isEmail = require_isEmail.isEmail;
 exports.isIn = require_isIn.isIn;
 exports.isKeyof = require_isKeyof.isKeyof;
 exports.isNotEmpty = require_isNotEmpty.isNotEmpty;
+exports.isTrimmed = require_is.isTrimmed;
 exports.isUrl = require_isUrl.isUrl;
 exports.isUuid = require_isUuid.isUuid;
 exports.join = require_join.join;

package/dist/string/index.mjs

@@ -48,6 +48,7 @@ import { toUpperCase } from "./toUpperCase.mjs";
 import { trim } from "./trim/default.mjs";
 import { trimEnd } from "./trim/end.mjs";
 import { trimStart } from "./trim/start.mjs";
+import { isTrimmed } from "./trim/is.mjs";
 import { uncapitalize } from "./uncapitalize.mjs";
 //#region scripts/string/index.ts
 var string_exports = /* @__PURE__ */ __exportAll({
@@ -68,6 +69,7 @@ var string_exports = /* @__PURE__ */ __exportAll({
 	isIn: () => isIn,
 	isKeyof: () => isKeyof,
 	isNotEmpty: () => isNotEmpty,
+	isTrimmed: () => isTrimmed,
 	isUrl: () => isUrl,
 	isUuid: () => isUuid,
 	join: () => join,
@@ -105,4 +107,4 @@ var string_exports = /* @__PURE__ */ __exportAll({
 	uuidRegex: () => uuidRegex
 });
 //#endregion
-export { at, capitalize, charAt, concat, emailRegex, endsWith, extract, extractAll, first, includes, indexOf, infer, isComposedOf, isEmail, isIn, isKeyof, isNotEmpty, isUrl, isUuid, join, last, lastIndexOf, length, lengthEqual, maxCharacters, minCharacters, normalize, padEnd, padStart, pop, prepend, repeat, replace, replaceAll, search, shift, slice, sort, sortCompare, split, startsWith, string_exports, stringify, substring, test, to, toLowerCase, toUpperCase, trim, trimEnd, trimStart, uncapitalize, uuidRegex };
+export { at, capitalize, charAt, concat, emailRegex, endsWith, extract, extractAll, first, includes, indexOf, infer, isComposedOf, isEmail, isIn, isKeyof, isNotEmpty, isTrimmed, isUrl, isUuid, join, last, lastIndexOf, length, lengthEqual, maxCharacters, minCharacters, normalize, padEnd, padStart, pop, prepend, repeat, replace, replaceAll, search, shift, slice, sort, sortCompare, split, startsWith, string_exports, stringify, substring, test, to, toLowerCase, toUpperCase, trim, trimEnd, trimStart, uncapitalize, uuidRegex };

package/dist/string/last.d.ts

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

package/dist/string/lengthEqual.d.ts

@@ -6,7 +6,7 @@ type RequireMinCharactersConstraint<GenericString extends string, GenericLength
 type RequireMaxCharactersConstraint<GenericString extends string, GenericLength extends number> = ExtractMaxCharacters<GenericString, unknown> extends MaxCharacters<infer InferredMax> ? DNumber.IsGreaterOrEqual<InferredMax, GenericLength> extends true ? unknown : DCommon.ComputedTypeError<`Cannot apply LengthEqual<${GenericLength}> on MaxCharacters<${InferredMax}>.`> : unknown;
 type RequireApplyLengthEqual<GenericString extends string, GenericLength extends number> = (DNumber.ForbiddenNegative<GenericLength> & DNumber.RequireSimpleLiteral<GenericLength> & RequireLengthEqualConstraint<GenericString, GenericLength> & RequireMinCharactersConstraint<GenericString, GenericLength> & RequireMaxCharactersConstraint<GenericString, GenericLength>);
 type RequireApplyLengthEqualBoolean<GenericString extends string, GenericLength extends number> = DCommon.IsEqual<GenericLength, number> extends true ? unknown : RequireApplyLengthEqual<GenericString, GenericLength>;
-type LengthEqualOutput<GenericString extends string, GenericLength extends number> = GenericString extends unknown ? IsImpossibleToApplyLengthEqual<GenericString, LengthEqual<GenericLength>> extends true ? never : ComputeLengthEqualCompatibility<GenericString, LengthEqual<GenericLength>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericString : GenericString & LengthEqual<GenericLength> : never : never;
+type LengthEqualOutput<GenericString extends string, GenericLength extends number> = GenericString extends unknown ? IsImpossibleToApplyLengthEqual<GenericString, LengthEqual<GenericLength>> extends true ? never : ComputeLengthEqualCompatibility<GenericString, LengthEqual<GenericLength>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.CompatibilityConstraintResult<true>> extends true ? GenericString : GenericString & LengthEqual<GenericLength> : never : never;
 export declare function lengthEqual<GenericString extends string, const GenericLength extends number>(length: GenericLength & RequireApplyLengthEqual<GenericString, GenericLength>): (string: GenericString) => string is LengthEqualOutput<GenericString, GenericLength>;
 export declare function lengthEqual<GenericString extends string, const GenericLength extends number>(length: GenericLength & RequireApplyLengthEqualBoolean<GenericString, GenericLength>): (string: GenericString) => boolean;
 export declare function lengthEqual<GenericString extends string, const GenericLength extends number>(string: GenericString, length: GenericLength & RequireApplyLengthEqual<GenericString, GenericLength>): string is LengthEqualOutput<GenericString, GenericLength>;