@duplojs/agents-kit 0.0.0-stage → 0.1.0-beta.10

package/docs/API/10-lang/10-string/10-join.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.join
+ *
+ * Réunir les chaînes d'une collection avec un séparateur.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+declare const values: readonly ["duplo", "js"];
+const result = DString.join(values, "-");
+// La valeur obtenue est "duplo-js".
+type _CheckResult = DCommon.ExpectType<typeof result, "duplo-js", "strict">;
+
+const piped = DCommon.pipe(
+	values,
+	DString.join("-"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "duplo-js", "strict">;

package/docs/API/10-lang/10-string/10-last.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.last
+ *
+ * Lire le dernier caractère d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.last("hello");
+// La valeur obtenue est "o".
+type _CheckResult = DCommon.ExpectType<typeof result, "o", "strict">;
+
+const piped = DCommon.pipe(
+	"hello",
+	DString.last,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "o", "strict">;

package/docs/API/10-lang/10-string/10-lastIndexOf.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.lastIndexOf
+ *
+ * Retourner la dernière position d'une sous-chaîne, ou `undefined` si elle est absente.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.lastIndexOf("one-two-two", "two");
+// La valeur obtenue est 8.
+type _CheckResult = DCommon.ExpectType<typeof result, number | undefined, "strict">;
+
+const piped = DCommon.pipe(
+	"one-two-two",
+	DString.lastIndexOf("two"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, number | undefined, "strict">;

package/docs/API/10-lang/10-string/10-length.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.length
+ *
+ * Retourner le nombre de caractères d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.length("DuploJS");
+// La valeur obtenue est 7 et elle est toujours strictement positive.
+type _CheckResult = DCommon.ExpectType<typeof result, number & DNumber.Positive, "strict">;
+
+const piped = DCommon.pipe(
+	"DuploJS",
+	DString.length,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, number & DNumber.Positive, "strict">;

package/docs/API/10-lang/10-string/10-lengthEqual.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DString.lengthEqual
+ *
+ * Tester ou établir qu'une chaîne possède exactement un nombre donné de caractères.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.lengthEqual("Duplo", 5);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.lengthEqual(value, 5)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, string & DString.LengthEqual<5>, "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.lengthEqual(5),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, string & DString.LengthEqual<5>, "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la longueur exacte établie par le predicate.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-maxCharacters.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DString.maxCharacters
+ *
+ * Tester ou établir une longueur maximale pour une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.maxCharacters("Duplo", 10);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.maxCharacters(value, 10)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, string & DString.MaxCharacters<10>, "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.maxCharacters(10),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, string & DString.MaxCharacters<10>, "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la longueur maximale établie par le predicate.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-minCharacters.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DString.minCharacters
+ *
+ * Tester ou établir une longueur minimale pour une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.minCharacters("DuploJS", 3);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.minCharacters(value, 3)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, string & DString.MinCharacters<3>, "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.minCharacters(3),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, string & DString.MinCharacters<3>, "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la longueur minimale établie par le predicate.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-normalize.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.normalize
+ *
+ * Normaliser une chaîne selon une forme Unicode.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.normalize("e\u0301", "NFC");
+// La valeur obtenue est la représentation NFC de la chaîne.
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;
+
+const piped = DCommon.pipe(
+	"e\u0301",
+	DString.normalize("NFC"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string, "strict">;

package/docs/API/10-lang/10-string/10-padEnd.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.padEnd
+ *
+ * Compléter une chaîne par la droite jusqu'à une longueur cible.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.padEnd("42", 5, "0");
+// La valeur obtenue est "42000".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MinCharacters<2>, "strict">;
+
+const piped = DCommon.pipe(
+	"42",
+	DString.padEnd(5, "0"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MinCharacters<2>, "strict">;

package/docs/API/10-lang/10-string/10-padStart.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.padStart
+ *
+ * Compléter une chaîne par la gauche jusqu'à une longueur cible.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.padStart("42", 5, "0");
+// La valeur obtenue est "00042".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MinCharacters<2>, "strict">;
+
+const piped = DCommon.pipe(
+	"42",
+	DString.padStart(5, "0"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MinCharacters<2>, "strict">;

package/docs/API/10-lang/10-string/10-pop.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.pop
+ *
+ * Retirer le dernier caractère d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.pop("hello");
+// La valeur obtenue est "hell".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MaxCharacters<5>, "strict">;
+
+const piped = DCommon.pipe(
+	"hello",
+	DString.pop,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MaxCharacters<5>, "strict">;

package/docs/API/10-lang/10-string/10-prepend.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.prepend
+ *
+ * Ajouter une ou plusieurs chaînes au début d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.prepend("hello", "say ");
+// La valeur obtenue est "say hello".
+type _CheckResult = DCommon.ExpectType<typeof result, "say hello", "strict">;
+
+const piped = DCommon.pipe(
+	"hello",
+	DString.prepend("say "),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "say hello", "strict">;

package/docs/API/10-lang/10-string/10-repeat.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.repeat
+ *
+ * Répéter une chaîne un nombre positif de fois.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.repeat("ha", 3);
+// La valeur obtenue est "hahaha".
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;
+
+const piped = DCommon.pipe(
+	"ha",
+	DString.repeat(3),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string, "strict">;

package/docs/API/10-lang/10-string/10-replace.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.replace
+ *
+ * Remplacer la première occurrence d'un motif par une chaîne ou une fonction de remplacement.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.replace("hello world", "world", "DuploJS");
+// La valeur obtenue est "hello DuploJS".
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;
+
+const piped = DCommon.pipe(
+	"hello world",
+	DString.replace("world", ({ matchedValue }) => DString.toUpperCase(matchedValue)),
+);
+// Le replacer reçoit les informations structurées sur la correspondance.
+type _CheckPiped = DCommon.ExpectType<typeof piped, string, "strict">;

package/docs/API/10-lang/10-string/10-replaceAll.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.replaceAll
+ *
+ * Remplacer toutes les occurrences d'un motif par une chaîne ou une fonction de remplacement.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.replaceAll("a-b-c", "-", "/");
+// La valeur obtenue est "a/b/c".
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;
+
+const piped = DCommon.pipe(
+	"a-b-c",
+	DString.replaceAll("-", "/"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string, "strict">;

package/docs/API/10-lang/10-string/10-search.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.search
+ *
+ * Retourner la position d'un motif, ou `undefined` lorsqu'il ne correspond pas.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.search("hello42", /\d+/);
+// La valeur obtenue est 5.
+type _CheckResult = DCommon.ExpectType<typeof result, number | undefined, "strict">;
+
+const piped = DCommon.pipe(
+	"hello42",
+	DString.search(/\d+/),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, number | undefined, "strict">;

package/docs/API/10-lang/10-string/10-shift.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.shift
+ *
+ * Retirer le premier caractère d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.shift("hello");
+// La valeur obtenue est "ello".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MaxCharacters<5>, "strict">;
+
+const piped = DCommon.pipe(
+	"hello",
+	DString.shift,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MaxCharacters<5>, "strict">;

package/docs/API/10-lang/10-string/10-slice.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.slice
+ *
+ * Extraire une portion d'une chaîne entre deux index.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.slice("hello world", 0, 5);
+// La valeur obtenue est "hello".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MaxCharacters<11>, "strict">;
+
+const piped = DCommon.pipe(
+	"hello world",
+	DString.slice(0, 5),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MaxCharacters<11>, "strict">;

package/docs/API/10-lang/10-string/10-sort.ts

@@ -0,0 +1,19 @@
+/**
+ * @title DString.sort
+ *
+ * Trier une copie d'une collection de chaînes dans l'ordre croissant ou décroissant.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const values: readonly string[] = ["b", "a", "c"];
+const result = DString.sort(values, "ASC");
+// La valeur obtenue est une nouvelle collection triée ["a", "b", "c"].
+type _CheckResult = DCommon.ExpectType<typeof result, string[], "strict">;
+
+const piped = DCommon.pipe(
+	values,
+	DString.sort("DSC"),
+);
+// Le pipe retourne une copie triée dans l'ordre décroissant.
+type _CheckPiped = DCommon.ExpectType<typeof piped, string[], "strict">;

package/docs/API/10-lang/10-string/10-sortCompare.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.sortCompare
+ *
+ * Comparer deux chaînes avec l'ordre de tri du domaine String.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.sortCompare("file2", "file10");
+// La valeur obtenue est un nombre négatif car "file2" précède "file10".
+type _CheckResult = DCommon.ExpectType<typeof result, number, "strict">;
+
+const piped = DCommon.pipe(
+	"file2",
+	DString.sortCompare("file10"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, number, "strict">;

package/docs/API/10-lang/10-string/10-split.ts

@@ -0,0 +1,34 @@
+/**
+ * @title DString.split
+ *
+ * Découper une chaîne selon un séparateur, avec une limite facultative.
+ */
+import type * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.split("a,b,c", ",");
+// La valeur obtenue contient exactement trois éléments : ["a", "b", "c"].
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	readonly string[] & DArray.MinElements<3> & DArray.LengthEqual<3> & DArray.MaxElements<3>,
+	"strict"
+>;
+
+const piped = DCommon.pipe(
+	"a,b,c",
+	DString.split(","),
+);
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	readonly string[] & DArray.MinElements<3> & DArray.LengthEqual<3> & DArray.MaxElements<3>,
+	"strict"
+>;
+
+const limited = DString.split("a,b,c", ",", { limit: 2 });
+// La limite réduit la sortie aux deux premiers groupes : ["a", "b"].
+type _CheckLimited = DCommon.ExpectType<
+	typeof limited,
+	readonly string[] & DArray.MinElements<2> & DArray.LengthEqual<2> & DArray.MaxElements<2>,
+	"strict"
+>;

package/docs/API/10-lang/10-string/10-startsWith.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DString.startsWith
+ *
+ * Tester si une chaîne commence par une sous-chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.startsWith("user-api", "user");
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.startsWith(value, "user")) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, `user${string}`, "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.startsWith("user"),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, `user${string}`, "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la chaîne affinée pour calculer sa longueur.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-stringify.ts

@@ -0,0 +1,11 @@
+/**
+ * @title DString.stringify
+ *
+ * Convertir une valeur quelconque en représentation textuelle sans laisser `undefined` au résultat.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.stringify({ status: "ready" });
+// La valeur obtenue est la représentation JSON "{\"status\":\"ready\"}".
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;

package/docs/API/10-lang/10-string/10-substring.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.substring
+ *
+ * Extraire une sous-chaîne selon les règles de `substring`.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.substring("hello world", 6);
+// La valeur obtenue est "world".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MaxCharacters<11>, "strict">;
+
+const piped = DCommon.pipe(
+	"hello world",
+	DString.substring(6),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MaxCharacters<11>, "strict">;

package/docs/API/10-lang/10-string/10-test.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.test
+ *
+ * Tester une chaîne avec une expression régulière.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.test("order-42", /\d+$/);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+const piped = DCommon.pipe(
+	"order-42",
+	DString.test(/\d+$/),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;

package/docs/API/10-lang/10-string/10-to.ts

@@ -0,0 +1,11 @@
+/**
+ * @title DString.to
+ *
+ * Convertir une valeur stringifiable en chaîne en conservant les littéraux connus lorsque c'est possible.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.to(42);
+// La valeur obtenue est "42" et son type reste littéral.
+type _CheckResult = DCommon.ExpectType<typeof result, "42", "strict">;

package/docs/API/10-lang/10-string/10-toLowerCase.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.toLowerCase
+ *
+ * Convertir une chaîne en minuscules.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.toLowerCase("DuploJS");
+// La valeur obtenue est "duplojs".
+type _CheckResult = DCommon.ExpectType<typeof result, "duplojs", "strict">;
+
+const piped = DCommon.pipe(
+	"DuploJS",
+	DString.toLowerCase,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "duplojs", "strict">;

package/docs/API/10-lang/10-string/10-toUpperCase.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.toUpperCase
+ *
+ * Convertir une chaîne en majuscules.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.toUpperCase("DuploJS");
+// La valeur obtenue est "DUPLOJS".
+type _CheckResult = DCommon.ExpectType<typeof result, "DUPLOJS", "strict">;
+
+const piped = DCommon.pipe(
+	"DuploJS",
+	DString.toUpperCase,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "DUPLOJS", "strict">;

package/docs/API/10-lang/10-string/10-trim.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.trim
+ *
+ * Supprimer les espaces au début et à la fin d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.trim("  DuploJS  ");
+// La valeur obtenue est "DuploJS" et elle est marquée comme Trimmed.
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.Trimmed & DString.MaxCharacters<11>, "strict">;
+
+const piped = DCommon.pipe(
+	"  DuploJS  ",
+	DString.trim,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.Trimmed & DString.MaxCharacters<11>, "strict">;

package/docs/API/10-lang/10-string/10-trimEnd.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.trimEnd
+ *
+ * Supprimer les espaces à la fin d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.trimEnd("  DuploJS  ");
+// La valeur obtenue est "  DuploJS".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MaxCharacters<11>, "strict">;
+
+const piped = DCommon.pipe(
+	"  DuploJS  ",
+	DString.trimEnd,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MaxCharacters<11>, "strict">;

package/docs/API/10-lang/10-string/10-trimStart.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.trimStart
+ *
+ * Supprimer les espaces au début d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.trimStart("  DuploJS  ");
+// La valeur obtenue est "DuploJS  ".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MaxCharacters<11>, "strict">;
+
+const piped = DCommon.pipe(
+	"  DuploJS  ",
+	DString.trimStart,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MaxCharacters<11>, "strict">;