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

package/dist/string/index.mjs

@@ -9,12 +9,12 @@ import { extractAll } from "./extractAll.mjs";
 import { first } from "./first.mjs";
 import { includes } from "./includes.mjs";
 import { indexOf } from "./indexOf.mjs";
-import { infer } from "./infer.mjs";
 import { isComposedOf } from "./isComposedOf.mjs";
 import { emailRegex, isEmail } from "./isEmail.mjs";
 import { isIn } from "./isIn.mjs";
 import { isKeyof } from "./isKeyof.mjs";
 import { isNotEmpty } from "./isNotEmpty.mjs";
+import { isNumber } from "./isNumber.mjs";
 import { isUrl } from "./isUrl.mjs";
 import { isUuid, uuidRegex } from "./isUuid.mjs";
 import { join } from "./join.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({
@@ -62,12 +63,13 @@ var string_exports = /* @__PURE__ */ __exportAll({
 	first: () => first,
 	includes: () => includes,
 	indexOf: () => indexOf,
-	infer: () => infer,
 	isComposedOf: () => isComposedOf,
 	isEmail: () => isEmail,
 	isIn: () => isIn,
 	isKeyof: () => isKeyof,
 	isNotEmpty: () => isNotEmpty,
+	isNumber: () => isNumber,
+	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, isComposedOf, isEmail, isIn, isKeyof, isNotEmpty, isNumber, 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/isComposedOf.cjs

@@ -3,7 +3,6 @@ const require_coalescing = require("../array/coalescing.cjs");
 const charactersRangeStore = /* @__PURE__ */ new Map([
 	["a-z", "a-z"],
 	["A-Z", "A-Z"],
-	["A-z", "A-z"],
 	["0-9", "0-9"]
 ]);
 function isComposedOf(...args) {

package/dist/string/isComposedOf.d.ts

@@ -2,13 +2,10 @@ import { AllowedCharacters, CharactersRange } from './constraints';
 import type * as DCommon from '../common';
 declare module "./constraints" {
     interface CharactersRangeStore {
-        "a-z": true;
-        "A-Z": true;
-        "A-z": true;
-        "0-9": true;
+        "a-z": "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
+        "A-Z": "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z";
+        "0-9": "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
     }
 }
-type ContainsIsComposedOf<GenericValue extends string, GenericCharactersRange extends CharactersRange> = DCommon.UnionToIntersection<(GenericCharactersRange extends any ? AllowedCharacters<GenericCharactersRange> : never)> extends infer InferredConstraints extends DCommon.Constraint ? GenericValue extends InferredConstraints ? GenericValue : GenericValue & InferredConstraints : never;
-export declare function isComposedOf<GenericValue extends string, GenericCharactersRange extends CharactersRange>(charactersRange: DCommon.MaybeArray<GenericCharactersRange>): (value: GenericValue) => value is ContainsIsComposedOf<GenericValue, GenericCharactersRange>;
-export declare function isComposedOf<GenericValue extends string, GenericCharactersRange extends CharactersRange>(value: GenericValue, charactersRange: DCommon.MaybeArray<GenericCharactersRange>): value is ContainsIsComposedOf<GenericValue, GenericCharactersRange>;
-export {};
+export declare function isComposedOf<GenericCharactersRange extends CharactersRange>(charactersRange: DCommon.MaybeArray<GenericCharactersRange>): (value: string) => value is string & AllowedCharacters<GenericCharactersRange>;
+export declare function isComposedOf<GenericCharactersRange extends CharactersRange>(value: string, charactersRange: DCommon.MaybeArray<GenericCharactersRange>): value is string & AllowedCharacters<GenericCharactersRange>;

package/dist/string/isComposedOf.mjs

@@ -3,7 +3,6 @@ import { coalescing } from "../array/coalescing.mjs";
 const charactersRangeStore = /* @__PURE__ */ new Map([
 	["a-z", "a-z"],
 	["A-Z", "A-Z"],
-	["A-z", "A-z"],
 	["0-9", "0-9"]
 ]);
 function isComposedOf(...args) {

package/dist/string/isNumber.cjs

@@ -0,0 +1,7 @@
+//#region scripts/string/isNumber.ts
+const numberRegex = /^-?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?$/i;
+function isNumber(string) {
+	return numberRegex.test(string);
+}
+//#endregion
+exports.isNumber = isNumber;

package/dist/string/isNumber.d.ts

@@ -0,0 +1,5 @@
+import { Number } from './constraints';
+import { NumberInString } from './types';
+type ComputeResult<GenericValue extends string> = GenericValue extends Number ? GenericValue : GenericValue extends NumberInString ? GenericValue : GenericValue & Number;
+export declare function isNumber<GenericValue extends string>(string: GenericValue): string is ComputeResult<GenericValue>;
+export {};

package/dist/string/isNumber.mjs

@@ -0,0 +1,7 @@
+//#region scripts/string/isNumber.ts
+const numberRegex = /^-?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?$/i;
+function isNumber(string) {
+	return numberRegex.test(string);
+}
+//#endregion
+export { isNumber };

package/dist/string/isUrl.cjs

@@ -1,16 +1,7 @@
 //#region scripts/string/isUrl.ts
-const regexRemoveDote = /:$/;
-function isUrl(string, params) {
+function isUrl(string) {
 	try {
-		const url = new URL(string);
-		if (params?.hostname) {
-			params.hostname.lastIndex = 0;
-			if (!params.hostname.test(url.hostname)) return false;
-		}
-		if (params?.protocol) {
-			params.protocol.lastIndex = 0;
-			if (!params.protocol.test(url.protocol.replace(regexRemoveDote, ""))) return false;
-		}
+		new URL(string);
 		return true;
 	} catch {
 		return false;

package/dist/string/isUrl.d.ts

@@ -1,6 +1,2 @@
 import { Url } from './constraints';
-export interface IsUrlParams {
-    hostname?: RegExp;
-    protocol?: RegExp;
-}
-export declare function isUrl<GenericValue extends string>(string: GenericValue, params?: IsUrlParams): string is GenericValue & Url;
+export declare function isUrl<GenericValue extends string>(string: GenericValue): string is GenericValue & Url;

package/dist/string/isUrl.mjs

@@ -1,16 +1,7 @@
 //#region scripts/string/isUrl.ts
-const regexRemoveDote = /:$/;
-function isUrl(string, params) {
+function isUrl(string) {
 	try {
-		const url = new URL(string);
-		if (params?.hostname) {
-			params.hostname.lastIndex = 0;
-			if (!params.hostname.test(url.hostname)) return false;
-		}
-		if (params?.protocol) {
-			params.protocol.lastIndex = 0;
-			if (!params.protocol.test(url.protocol.replace(regexRemoveDote, ""))) return false;
-		}
+		new URL(string);
 		return true;
 	} catch {
 		return false;

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/to.d.ts

@@ -1,3 +1,10 @@
-type Primitive = (string | boolean | null | number | undefined | bigint);
-export declare function to<GenericValue extends Primitive>(value: GenericValue): `${GenericValue}`;
+import { Number } from './constraints';
+import type * as DNumber from '../number';
+type Stringifyable = (null | undefined | {
+    toString(): string;
+});
+type ComputeResult<GenericValue extends Stringifyable> = GenericValue extends number ? DNumber.IsLiteral<GenericValue> extends true ? `${GenericValue}` : string & Number : GenericValue extends (string | boolean | null | undefined | bigint) ? `${GenericValue}` : GenericValue extends {
+    toString(): string;
+} ? ReturnType<GenericValue["toString"]> : never;
+export declare function to<GenericValue extends Stringifyable>(value: GenericValue): ComputeResult<GenericValue>;
 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/dist/string/types/IsAllowedString.d.ts

@@ -0,0 +1,5 @@
+import { IsLiteral } from './isLiteral';
+type _IsAllowedTail<GenericValue extends string, GenericAllowed extends string> = GenericValue extends `${infer Char}${infer Rest}` ? Char extends GenericAllowed ? _IsAllowedTail<Rest, GenericAllowed> : false : true;
+type _IsAllowedString<GenericValue extends string, GenericAllowed extends string> = GenericValue extends `${infer InferredA}${infer InferredB}${infer InferredC}${infer InferredD}${infer InferredE}${infer InferredF}${infer InferredG}${infer InferredH}${infer InferredRest}` ? (InferredA | InferredB | InferredC | InferredD | InferredE | InferredF | InferredG | InferredH) extends GenericAllowed ? IsAllowedString<InferredRest, GenericAllowed> : false : _IsAllowedTail<GenericValue, GenericAllowed>;
+export type IsAllowedString<GenericValue extends string, GenericAllowed extends string> = IsLiteral<GenericValue> extends true ? _IsAllowedString<GenericValue, GenericAllowed> : false;
+export {};

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

@@ -1,3 +1,5 @@
+export type * from './IsAllowedString';
+export type * from './at';
 export type * from './countMinCharacters';
 export type * from './digit';
 export type * from './endsWith';
@@ -5,12 +7,14 @@ export type * from './first';
 export type * from './forbiddenContain';
 export type * from './forbiddenString';
 export type * from './includes';
+export type * from './isKeyPattern';
 export type * from './isLiteral';
+export type * from './isTemplateLiteral';
 export type * from './join';
 export type * from './last';
 export type * from './length';
 export type * from './normalizeForm';
-export type * from './number';
+export type * from './numberInString';
 export type * from './pop';
 export type * from './replace';
 export type * from './requireLiteral';
@@ -18,7 +22,3 @@ export type * from './requireSimpleLiteral';
 export type * from './shift';
 export type * from './split';
 export type * from './startsWith';
-export type * from './isKeyPattern';
-export type * from './at';
-export type * from './first';
-export type * from './last';

package/dist/string/types/numberInString.d.ts

@@ -0,0 +1 @@
+export type NumberInString = `${number}`;

package/dist/string/types/split.d.ts

@@ -2,7 +2,7 @@ import { Includes } from './includes';
 import { IsKeyPattern } from './isKeyPattern';
 import type * as DCommon from '../../common';
 import type * as DTuple from '../../tuple';
-type _Split<GenericString extends string, GenericSeparator extends string, GenericLimit extends number = number, GenericLastResult extends readonly string[] = []> = GenericString extends `${infer InferredBefore}${GenericSeparator}${infer InferredAfter}` ? IsKeyPattern<InferredBefore> extends true ? GenericLastResult : readonly [...GenericLastResult, InferredBefore] extends infer InferredResult extends readonly any[] ? DCommon.IsEqual<InferredAfter, ""> extends true ? InferredResult : DCommon.IsEqual<InferredResult["length"], 250> extends true ? Includes<InferredAfter, GenericSeparator> extends true ? readonly [...InferredResult, ...string[]] : InferredResult : DCommon.IsEqual<InferredResult["length"], GenericLimit> extends true ? InferredResult : _Split<InferredAfter, GenericSeparator, GenericLimit, InferredResult> : never : readonly [...GenericLastResult, GenericString];
+type _Split<GenericString extends string, GenericSeparator extends string, GenericLimit extends number = number, GenericLastResult extends readonly string[] = []> = GenericString extends `${infer InferredBefore}${GenericSeparator}${infer InferredAfter}` ? IsKeyPattern<InferredBefore> extends true ? GenericLastResult : readonly [...GenericLastResult, InferredBefore] extends infer InferredResult extends readonly any[] ? DCommon.IsEqual<InferredAfter, ""> extends true ? DCommon.IsEqual<GenericSeparator, ""> extends true ? InferredResult : readonly [...InferredResult, InferredAfter] : DCommon.IsEqual<InferredResult["length"], 250> extends true ? Includes<InferredAfter, GenericSeparator> extends true ? readonly [...InferredResult, ...string[]] : InferredResult : DCommon.IsEqual<InferredResult["length"], GenericLimit> extends true ? InferredResult : _Split<InferredAfter, GenericSeparator, GenericLimit, InferredResult> : never : readonly [...GenericLastResult, GenericString];
 export type Split<GenericString extends string, GenericSeparator extends string, GenericLimit extends number = number> = DCommon.IsEqual<GenericLimit, 0> extends true ? readonly [] : IsKeyPattern<GenericSeparator> extends true ? readonly [string, ...string[]] : IsKeyPattern<GenericString> extends true ? readonly [
     ...DTuple.Create<string, DTuple.CountMinElement<_Split<GenericString, GenericSeparator, GenericLimit>>>,
     ...string[]

package/dist/tuple/from.cjs

@@ -0,0 +1,6 @@
+//#region scripts/tuple/from.ts
+function from(source) {
+	return source;
+}
+//#endregion
+exports.from = from;

package/dist/tuple/from.d.ts

@@ -0,0 +1,8 @@
+import { Create } from './types';
+import type * as DArray from '../array';
+type FromOutput<GenericArray extends readonly unknown[]> = DArray.ExtractLengthEqual<GenericArray, unknown> extends DArray.LengthEqual<infer InferredLength extends number> ? DArray.ReapplyCompatiblesConstraints<GenericArray, Create<GenericArray[number], InferredLength>, "maxElements"> : DArray.ExtractMinElements<GenericArray, unknown> extends DArray.MinElements<infer InferredMin extends number> ? DArray.ReapplyCompatiblesConstraints<GenericArray, readonly [
+    ...Create<GenericArray[number], InferredMin>,
+    ...GenericArray[number][]
+], "maxElements"> : GenericArray;
+export declare function from<GenericArray extends readonly unknown[]>(source: GenericArray): FromOutput<GenericArray>;
+export {};

package/dist/tuple/from.mjs

@@ -0,0 +1,6 @@
+//#region scripts/tuple/from.ts
+function from(source) {
+	return source;
+}
+//#endregion
+export { from };

package/dist/tuple/index.cjs

@@ -1,8 +1,13 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_map = require("./map.cjs");
+const require_from = require("./from.cjs");
 //#region scripts/tuple/index.ts
-var tuple_exports = /* @__PURE__ */ require_runtime.__exportAll({ map: () => require_map.map });
+var tuple_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	from: () => require_from.from,
+	map: () => require_map.map
+});
 //#endregion
+exports.from = require_from.from;
 exports.map = require_map.map;
 Object.defineProperty(exports, "tuple_exports", {
 	enumerable: true,

package/dist/tuple/index.d.ts

@@ -1,2 +1,3 @@
 export type * from './types';
 export * from './map';
+export * from './from';

package/dist/tuple/index.mjs

@@ -1,6 +1,10 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { map } from "./map.mjs";
+import { from } from "./from.mjs";
 //#region scripts/tuple/index.ts
-var tuple_exports = /* @__PURE__ */ __exportAll({ map: () => map });
+var tuple_exports = /* @__PURE__ */ __exportAll({
+	from: () => from,
+	map: () => map
+});
 //#endregion
-export { map, tuple_exports };
+export { from, map, tuple_exports };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/lang",
-  "version": "0.0.1-beta.1",
+  "version": "0.0.1-beta.11",
   "license": "MIT",
   "type": "module",
   "author": {
@@ -19,6 +19,7 @@
     "test:ut:watch": "./.commands/test-ut.sh --watch",
     "test:ut:update": "./.commands/test-ut.sh --update",
     "test:types": "./.commands/test-types.sh",
+    "test:types:lib": "./.commands/test-types-lib.sh",
     "test:types:target": "./.commands/test-types-target.sh",
     "test:lint": "./.commands/test-lint.sh",
     "test:lint:fix": "./.commands/test-lint.sh --fix",
@@ -128,7 +129,6 @@
     "@vitest/coverage-istanbul": "4.1.10"
   },
   "workspaces": [
-    "integrations",
     "docs"
   ],
   "files": [

package/dist/array/infer.d.ts

@@ -1,14 +0,0 @@
-import { MaxElements, MinElements, LengthEqual, ComputeMaxElementsCompatibility, ComputeMinElementsCompatibility, ComputeLengthEqualCompatibility } from './constraints';
-import type * as DCommon from '../common';
-import type * as DTuple from '../tuple';
-type ComputeCompatibilityOutputConstraint<GenericOutput extends readonly unknown[], GenericInput extends readonly unknown[]> = (DCommon.Or<[
-    DCommon.IsNever<GenericOutput>,
-    DCommon.IsNever<GenericInput>
-]> extends true ? unknown : GenericOutput extends unknown ? ((ComputeMaxElementsCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? MaxElements<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MaxElements<${InferredResult["to"]}> because constraint MaxElements<${InferredResult["from"]}> from the value is more than.`> : never) | (ComputeMinElementsCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? MinElements<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MinElements<${InferredResult["to"]}> because constraint MinElements<${InferredResult["from"]}> from the value is less than.`> : never) | (ComputeLengthEqualCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? LengthEqual<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on LengthEqual<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is not equal.`> : never)) extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.ComputedTypeError<string>> extends true ? Extract<InferredResult, DCommon.ComputedTypeError<string>> : DCommon.UnionToIntersection<InferredResult> : never : never) extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.BaseConstraint> extends true ? Extract<InferredResult, DCommon.BaseConstraint> : InferredResult : never;
-export declare function infer<GenericOutput extends readonly unknown[], const GenericInput extends readonly [
-    ...Extract<DCommon.RemoveConstraint<GenericOutput>, readonly unknown[]>
-] = never, GenericConstraint = ComputeCompatibilityOutputConstraint<GenericOutput, GenericInput>>(input: (GenericInput & DTuple.Require<GenericInput> & DCommon.ForbiddenUnion<GenericInput> & DCommon.BreakGenericLink<DCommon.ContainExtends<GenericConstraint, DCommon.ComputedTypeError<string>> extends true ? GenericConstraint : unknown>)): DCommon.Or<[
-    DCommon.IsNever<GenericInput>,
-    DCommon.ContainExtends<GenericConstraint, DCommon.ComputedTypeError<string>>
-]> extends true ? GenericOutput : DCommon.BreakGenericLink<GenericInput & GenericConstraint>;
-export {};

package/dist/array/infer.mjs

@@ -1,6 +0,0 @@
-//#region scripts/array/infer.ts
-function infer(input) {
-	return input;
-}
-//#endregion
-export { infer };

package/dist/dataStructure/common/codec.cjs

@@ -1,28 +0,0 @@
-const require_callThen = require("../../common/callThen.cjs");
-const require_memo = require("../../common/memo.cjs");
-const require_kind = require("../kind.cjs");
-const require_resultSymbol = require("./resultSymbol.cjs");
-//#region scripts/dataStructure/common/codec.ts
-const codecKind = require_kind.createKind("codec");
-const codecsKind = require_kind.createKind("codecs");
-function createCodec(fundamentalType, predicateEncode, encode, decode) {
-	return {
-		fundamentalType,
-		predicateEncode,
-		encode: (data, errorHandler) => errorHandler?.().setCurrentContext("encode") ?? require_callThen.callThen(encode(data, errorHandler), (encodedData) => encodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(predicateEncode(encodedData, errorHandler), (result) => errorHandler?.().setCurrentContext("default") ?? (result === false ? require_resultSymbol.ErrorSymbol : encodedData))),
-		decode: (data, errorHandler) => errorHandler?.().setCurrentContext("decode") ?? require_callThen.callThen(predicateEncode(data, errorHandler), (result) => result === false ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(decode(data, errorHandler), (result) => errorHandler?.().setCurrentContext("default") ?? result)),
-		[codecKind.runTimeKey]: null
-	};
-}
-function createCodecs(definition) {
-	return {
-		context: require_memo.memo(() => new Map(Object.values(definition).map((codec) => [codec.fundamentalType, codec]))),
-		definition,
-		[codecsKind.runTimeKey]: null
-	};
-}
-//#endregion
-exports.codecKind = codecKind;
-exports.codecsKind = codecsKind;
-exports.createCodec = createCodec;
-exports.createCodecs = createCodecs;

package/dist/dataStructure/common/codec.mjs

@@ -1,25 +0,0 @@
-import { callThen } from "../../common/callThen.mjs";
-import { memo } from "../../common/memo.mjs";
-import { createKind } from "../kind.mjs";
-import { ErrorSymbol } from "./resultSymbol.mjs";
-//#region scripts/dataStructure/common/codec.ts
-const codecKind = createKind("codec");
-const codecsKind = createKind("codecs");
-function createCodec(fundamentalType, predicateEncode, encode, decode) {
-	return {
-		fundamentalType,
-		predicateEncode,
-		encode: (data, errorHandler) => errorHandler?.().setCurrentContext("encode") ?? callThen(encode(data, errorHandler), (encodedData) => encodedData === ErrorSymbol ? ErrorSymbol : callThen(predicateEncode(encodedData, errorHandler), (result) => errorHandler?.().setCurrentContext("default") ?? (result === false ? ErrorSymbol : encodedData))),
-		decode: (data, errorHandler) => errorHandler?.().setCurrentContext("decode") ?? callThen(predicateEncode(data, errorHandler), (result) => result === false ? ErrorSymbol : callThen(decode(data, errorHandler), (result) => errorHandler?.().setCurrentContext("default") ?? result)),
-		[codecKind.runTimeKey]: null
-	};
-}
-function createCodecs(definition) {
-	return {
-		context: memo(() => new Map(Object.values(definition).map((codec) => [codec.fundamentalType, codec]))),
-		definition,
-		[codecsKind.runTimeKey]: null
-	};
-}
-//#endregion
-export { codecKind, codecsKind, createCodec, createCodecs };

package/dist/dataStructure/common/error.cjs

@@ -1,53 +0,0 @@
-//#region scripts/dataStructure/common/error.ts
-function createErrorHandler() {
-	let currentStagePath = -1;
-	const issues = [];
-	let currentPath = [];
-	let currentStage = void 0;
-	let context = "default";
-	return {
-		currentPath,
-		issues,
-		createPathStage: () => {
-			if (currentStage === void 0) currentStage = {
-				setCurrentPath: (path) => {
-					currentPath[currentStagePath] = path;
-				},
-				close: () => {
-					if (currentStagePath === -1) return;
-					if (currentPath.length !== currentStagePath) currentPath.pop();
-					currentStagePath--;
-				}
-			};
-			currentStagePath++;
-			return currentStage;
-		},
-		setCurrentContext: (newContext) => {
-			context = newContext;
-		},
-		addIssue: (source, data) => {
-			issues.push({
-				context,
-				data,
-				path: currentPath.join("."),
-				getSource: () => source
-			});
-		},
-		createError: () => ({ issues }),
-		importIssues: (errorHandler) => void errorHandler.forEach((value) => void issues.push(...typeof value === "function" ? value().issues : value.issues)),
-		usePath: (path) => {
-			currentPath = [...path];
-			currentStagePath = currentPath.length - 1;
-		}
-	};
-}
-function createGetErrorHandler() {
-	let errorHandler = void 0;
-	return () => {
-		if (errorHandler === void 0) errorHandler = createErrorHandler();
-		return errorHandler;
-	};
-}
-//#endregion
-exports.createErrorHandler = createErrorHandler;
-exports.createGetErrorHandler = createGetErrorHandler;