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

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

package/dist/string/maxCharacters.d.ts

@@ -5,7 +5,7 @@ type RequireLengthEqualConstraint<GenericString extends string, GenericMax exten
 type RequireMinCharactersConstraint<GenericString extends string, GenericMax extends number> = ExtractMinCharacters<GenericString, unknown> extends MinCharacters<infer InferredMin> ? DNumber.IsGreaterOrEqual<GenericMax, InferredMin> extends true ? unknown : DCommon.ComputedTypeError<`Cannot apply MaxCharacters<${GenericMax}> on MinCharacters<${InferredMin}>.`> : unknown;
 type RequireApplyMaxCharacters<GenericString extends string, GenericMax extends number> = (DNumber.ForbiddenNegative<GenericMax> & DNumber.RequireSimpleLiteral<GenericMax> & RequireLengthEqualConstraint<GenericString, GenericMax> & RequireMinCharactersConstraint<GenericString, GenericMax>);
 type RequireApplyMaxCharactersBoolean<GenericString extends string, GenericMax extends number> = DCommon.IsEqual<GenericMax, number> extends true ? unknown : RequireApplyMaxCharacters<GenericString, GenericMax>;
-type MaxCharactersOutput<GenericString extends string, GenericMax extends number> = GenericString extends unknown ? IsImpossibleToApplyMaxCharacters<GenericString, MaxCharacters<GenericMax>> extends true ? never : ComputeMaxCharactersCompatibility<GenericString, MaxCharacters<GenericMax>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericString : GenericString & MaxCharacters<GenericMax> : never : never;
+type MaxCharactersOutput<GenericString extends string, GenericMax extends number> = GenericString extends unknown ? IsImpossibleToApplyMaxCharacters<GenericString, MaxCharacters<GenericMax>> extends true ? never : ComputeMaxCharactersCompatibility<GenericString, MaxCharacters<GenericMax>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.CompatibilityConstraintResult<true>> extends true ? GenericString : GenericString & MaxCharacters<GenericMax> : never : never;
 export declare function maxCharacters<GenericString extends string, const GenericMax extends number>(max: GenericMax & RequireApplyMaxCharacters<GenericString, GenericMax>): (string: GenericString) => string is MaxCharactersOutput<GenericString, GenericMax>;
 export declare function maxCharacters<GenericString extends string, const GenericMax extends number>(max: GenericMax & RequireApplyMaxCharactersBoolean<GenericString, GenericMax>): (string: GenericString) => boolean;
 export declare function maxCharacters<GenericString extends string, const GenericMax extends number>(string: GenericString, max: GenericMax & RequireApplyMaxCharacters<GenericString, GenericMax>): string is MaxCharactersOutput<GenericString, GenericMax>;

package/dist/string/minCharacters.d.ts

@@ -5,7 +5,7 @@ type RequireLengthEqualConstraint<GenericString extends string, GenericMin exten
 type RequireMaxCharactersConstraint<GenericString extends string, GenericMin extends number> = ExtractMaxCharacters<GenericString, unknown> extends MaxCharacters<infer InferredMax> ? DNumber.IsGreaterOrEqual<InferredMax, GenericMin> extends true ? unknown : DCommon.ComputedTypeError<`Cannot apply MinCharacters<${GenericMin}> on MaxCharacters<${InferredMax}>.`> : unknown;
 type RequireApplyMinCharacters<GenericString extends string, GenericMin extends number> = (DNumber.ForbiddenNegative<GenericMin> & DNumber.RequireSimpleLiteral<GenericMin> & RequireLengthEqualConstraint<GenericString, GenericMin> & RequireMaxCharactersConstraint<GenericString, GenericMin>);
 type RequireApplyMinCharactersBoolean<GenericString extends string, GenericMin extends number> = DCommon.IsEqual<GenericMin, number> extends true ? unknown : RequireApplyMinCharacters<GenericString, GenericMin>;
-type MinCharactersOutput<GenericString extends string, GenericMin extends number> = GenericString extends unknown ? IsImpossibleToApplyMinCharacters<GenericString, MinCharacters<GenericMin>> extends true ? never : ComputeMinCharactersCompatibility<GenericString, MinCharacters<GenericMin>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericString : GenericString & MinCharacters<GenericMin> : never : never;
+type MinCharactersOutput<GenericString extends string, GenericMin extends number> = GenericString extends unknown ? IsImpossibleToApplyMinCharacters<GenericString, MinCharacters<GenericMin>> extends true ? never : ComputeMinCharactersCompatibility<GenericString, MinCharacters<GenericMin>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.CompatibilityConstraintResult<true>> extends true ? GenericString : GenericString & MinCharacters<GenericMin> : never : never;
 export declare function minCharacters<GenericString extends string, const GenericMin extends number>(min: GenericMin & RequireApplyMinCharacters<GenericString, GenericMin>): (string: GenericString) => string is MinCharactersOutput<GenericString, GenericMin>;
 export declare function minCharacters<GenericString extends string, const GenericMin extends number>(min: GenericMin & RequireApplyMinCharactersBoolean<GenericString, GenericMin>): (string: GenericString) => boolean;
 export declare function minCharacters<GenericString extends string, const GenericMin extends number>(string: GenericString, min: GenericMin & RequireApplyMinCharacters<GenericString, GenericMin>): string is MinCharactersOutput<GenericString, GenericMin>;

package/dist/string/padEnd.d.ts

@@ -1,6 +1,6 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
 import type * as DNumber from '../number';
-type PadEndOutput<GenericString extends string> = ReapplyCompatiblesConstraints<GenericString, string, "minCharacters">;
+type PadEndOutput<GenericString extends string> = GenericString extends unknown ? ReapplyCompatiblesConstraints<GenericString, string, "minCharacters"> : never;
 export declare function padEnd<GenericString extends string, GenericTargetLength extends number>(targetLength: GenericTargetLength & DNumber.RequirePositiveInteger<GenericTargetLength>, padString: string): (string: GenericString) => PadEndOutput<GenericString>;
 export declare function padEnd<GenericString extends string, GenericTargetLength extends number>(string: GenericString, targetLength: GenericTargetLength & DNumber.RequirePositiveInteger<GenericTargetLength>, padString: string): PadEndOutput<GenericString>;
 export {};

package/dist/string/padStart.d.ts

@@ -1,6 +1,6 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
 import type * as DNumber from '../number';
-type PadStartOutput<GenericString extends string> = ReapplyCompatiblesConstraints<GenericString, string, "minCharacters">;
+type PadStartOutput<GenericString extends string> = GenericString extends unknown ? ReapplyCompatiblesConstraints<GenericString, string, "minCharacters"> : never;
 export declare function padStart<GenericString extends string, GenericTargetLength extends number>(targetLength: GenericTargetLength & DNumber.RequirePositiveInteger<GenericTargetLength>, padString: string): (string: GenericString) => PadStartOutput<GenericString>;
 export declare function padStart<GenericString extends string, GenericTargetLength extends number>(string: GenericString, targetLength: GenericTargetLength & DNumber.RequirePositiveInteger<GenericTargetLength>, padString: string): PadStartOutput<GenericString>;
 export {};

package/dist/string/pop.d.ts

@@ -1,4 +1,4 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
-type PopOutput<GenericString extends string> = ReapplyCompatiblesConstraints<GenericString, string, "maxCharacters">;
+type PopOutput<GenericString extends string> = GenericString extends unknown ? ReapplyCompatiblesConstraints<GenericString, string, "maxCharacters"> : never;
 export declare function pop<GenericString extends string>(string: GenericString): PopOutput<GenericString>;
 export {};

package/dist/string/shift.d.ts

@@ -1,4 +1,4 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
-type ShiftOutput<GenericString extends string> = ReapplyCompatiblesConstraints<GenericString, string, "maxCharacters">;
+type ShiftOutput<GenericString extends string> = GenericString extends unknown ? ReapplyCompatiblesConstraints<GenericString, string, "maxCharacters"> : never;
 export declare function shift<GenericString extends string>(string: GenericString): ShiftOutput<GenericString>;
 export {};

package/dist/string/slice.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyAllowedCharacters, ReapplyCompatiblesConstraints } from './constraints';
-type SliceOutput<GenericString extends string> = ReapplyAllowedCharacters<GenericString, ReapplyCompatiblesConstraints<GenericString, string, "maxCharacters">>;
+type SliceOutput<GenericString extends string> = GenericString extends unknown ? ReapplyAllowedCharacters<GenericString, ReapplyCompatiblesConstraints<GenericString, string, "maxCharacters">> : never;
 export declare function slice<GenericString extends string>(start: number, end: number): (string: GenericString) => SliceOutput<GenericString>;
 export declare function slice<GenericString extends string>(string: GenericString, start: number, end: number): SliceOutput<GenericString>;
 export {};

package/dist/string/substring.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyAllowedCharacters, ReapplyCompatiblesConstraints } from './constraints';
-type SubstringOutput<GenericString extends string> = ReapplyAllowedCharacters<GenericString, ReapplyCompatiblesConstraints<GenericString, string, "maxCharacters">>;
+type SubstringOutput<GenericString extends string> = GenericString extends unknown ? ReapplyAllowedCharacters<GenericString, ReapplyCompatiblesConstraints<GenericString, string, "maxCharacters">> : never;
 export declare function substring<GenericString extends string>(start: number, end?: number): (string: GenericString) => SubstringOutput<GenericString>;
 export declare function substring<GenericString extends string>(string: GenericString, start: number, end?: number): SubstringOutput<GenericString>;
 export {};

package/dist/string/trim/default.d.ts

@@ -1,4 +1,4 @@
 import { ReapplyCompatiblesConstraints, Trimmed } from '../constraints';
-type TrimOutput<GenericString extends string> = ReapplyCompatiblesConstraints<GenericString, string & Trimmed, "maxCharacters">;
+type TrimOutput<GenericString extends string> = GenericString extends unknown ? ReapplyCompatiblesConstraints<GenericString, string & Trimmed, "maxCharacters"> : never;
 export declare function trim<GenericString extends string>(string: GenericString): TrimOutput<GenericString>;
 export {};

package/dist/string/trim/end.d.ts

@@ -1,4 +1,4 @@
 import { ReapplyCompatiblesConstraints } from '../constraints';
-type TrimEndOutput<GenericString extends string> = ReapplyCompatiblesConstraints<GenericString, string, "maxCharacters">;
+type TrimEndOutput<GenericString extends string> = GenericString extends unknown ? ReapplyCompatiblesConstraints<GenericString, string, "maxCharacters"> : never;
 export declare function trimEnd<GenericString extends string>(string: GenericString): TrimEndOutput<GenericString>;
 export {};

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

@@ -1,3 +1,4 @@
 export * from './default';
 export * from './end';
 export * from './start';
+export * from './is';

package/dist/string/trim/is.cjs

@@ -0,0 +1,6 @@
+//#region scripts/string/trim/is.ts
+function isTrimmed(input) {
+	return input.trim() === input;
+}
+//#endregion
+exports.isTrimmed = isTrimmed;

package/dist/string/trim/is.d.ts

@@ -0,0 +1,2 @@
+import { Trimmed } from '../constraints';
+export declare function isTrimmed<GenericString extends string>(input: GenericString): input is GenericString & Trimmed;

package/dist/string/trim/is.mjs

@@ -0,0 +1,6 @@
+//#region scripts/string/trim/is.ts
+function isTrimmed(input) {
+	return input.trim() === input;
+}
+//#endregion
+export { isTrimmed };

package/dist/string/trim/start.d.ts

@@ -1,4 +1,4 @@
 import { ReapplyCompatiblesConstraints } from '../constraints';
-type TrimStartOutput<GenericString extends string> = ReapplyCompatiblesConstraints<GenericString, string, "maxCharacters">;
+type TrimStartOutput<GenericString extends string> = GenericString extends unknown ? ReapplyCompatiblesConstraints<GenericString, string, "maxCharacters"> : never;
 export declare function trimStart<GenericString extends string>(string: GenericString): TrimStartOutput<GenericString>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/lang",
-  "version": "0.0.1-beta.1",
+  "version": "0.0.1-beta.2",
   "license": "MIT",
   "type": "module",
   "author": {

package/dist/modeling/entity/entityName.cjs

@@ -1,13 +0,0 @@
-const require_resultSymbol = require("../../dataStructure/common/resultSymbol.cjs");
-const require_base = require("../../dataStructure/structure/base.cjs");
-//#region scripts/modeling/entity/entityName.ts
-const entityNameStructureKind = require("../kind.cjs").createKind("entity-name-structure");
-const EntityNameStructure = require_base.createStructure(entityNameStructureKind, ({ init }) => (name) => init({ constraints: [] }, {
-	executeCheck: (self, data, errorHandler) => data === name ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
-	executeEncode: (self, codecContext, data, errorHandler) => data === name ? data : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
-	executeDecode: (self, codecContext, data, errorHandler) => data === name ? data : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
-	isAsynchronous: () => false
-}, { name }));
-//#endregion
-exports.EntityNameStructure = EntityNameStructure;
-exports.entityNameStructureKind = entityNameStructureKind;

package/dist/modeling/entity/entityName.d.ts

@@ -1,13 +0,0 @@
-import type * as DKind from '../../kind';
-import type * as DCommon from '../../common';
-import * as DDataStructure from '../../dataStructure';
-declare module '../../dataStructure' {
-    interface StructuresStore {
-        entityName: EntityNameStructure;
-    }
-}
-export declare const entityNameStructureKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/entity-name-structure", unknown>>;
-export interface EntityNameStructure extends DCommon.UnionToIntersection<DDataStructure.Structure<unknown> & DKind.Kind<typeof entityNameStructureKind>> {
-    readonly name: string;
-}
-export declare const EntityNameStructure: (name: string) => EntityNameStructure;

package/dist/modeling/entity/entityName.mjs

@@ -1,13 +0,0 @@
-import { ErrorSymbol, SuccessSymbol } from "../../dataStructure/common/resultSymbol.mjs";
-import { createStructure } from "../../dataStructure/structure/base.mjs";
-import { createKind } from "../kind.mjs";
-//#region scripts/modeling/entity/entityName.ts
-const entityNameStructureKind = createKind("entity-name-structure");
-const EntityNameStructure = createStructure(entityNameStructureKind, ({ init }) => (name) => init({ constraints: [] }, {
-	executeCheck: (self, data, errorHandler) => data === name ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
-	executeEncode: (self, codecContext, data, errorHandler) => data === name ? data : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
-	executeDecode: (self, codecContext, data, errorHandler) => data === name ? data : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
-	isAsynchronous: () => false
-}, { name }));
-//#endregion
-export { EntityNameStructure, entityNameStructureKind };