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

package/docs/API/10-lang/10-array/10-unshift.ts

@@ -0,0 +1,34 @@
+/**
+ * @title DArray.unshift
+ *
+ * Ajouter une ou plusieurs valeurs au début d’un tableau dans une nouvelle copie.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+const numbers = [3, 4];
+
+// Appel classique : les valeurs sont ajoutées dans l’ordre fourni.
+const result = DArray.unshift(numbers, 1, 2);
+
+// La valeur obtenue est [1, 2, 3, 4] ; numbers reste inchangé.
+type _CheckResult = DCommon.ExpectType<typeof result, readonly number[], "strict">;
+
+// Appel curifié : les valeurs sont configurées dans l’étape du pipe.
+const piped = DCommon.pipe(
+	numbers,
+	DArray.unshift(1),
+);
+
+// La valeur obtenue est [1, 3, 4].
+type _CheckPiped = DCommon.ExpectType<typeof piped, readonly number[], "strict">;
+
+// L’ajout conserve la borne minimale connue du tableau source.
+declare const constrained: readonly number[] & DArray.MinElements<2>;
+const constrainedResult = DArray.unshift(constrained, 0);
+
+type _CheckConstrained = DCommon.ExpectType<
+	typeof constrainedResult,
+	readonly number[] & DArray.MinElements<2>,
+	"strict"
+>;

package/docs/API/10-lang/10-array/index.llms.md

@@ -0,0 +1,220 @@
+## DArray
+
+Opérations immuables de lecture, transformation, sélection, réduction et modification de tableaux, avec prise en compte de leurs contraintes de typage.
+
+### [DArray.at](10-at.ts)
+
+Lire l’élément situé à un index en reflétant dans le type la possibilité d’une absence.
+ 
+### [DArray.chunk](10-chunk.ts)
+
+Découper un tableau en sous-tableaux dont la taille ne dépasse pas la limite donnée.
+ 
+### [DArray.coalescing](10-coalescing.ts)
+
+Convertir une valeur en tableau sans ré-encapsuler une valeur déjà contenue dans un tableau.
+ 
+### [DArray.concat](10-concat.ts)
+
+Ajouter les éléments d’un ou plusieurs tableaux à la fin sans muter le tableau d’entrée.
+ 
+### [DArray.copyWithin](10-copyWithin.ts)
+
+Copier une portion d’un tableau vers une autre position dans une nouvelle copie.
+ 
+### [DArray.every](10-every.ts)
+
+Vérifier que tous les éléments d’un tableau satisfont un prédicat.
+ 
+### [DArray.fill](10-fill.ts)
+
+Remplacer une plage d’éléments par une valeur dans une nouvelle copie du tableau.
+ 
+### [DArray.fillAll](10-fillAll.ts)
+
+Remplacer tous les éléments d’un tableau par une même valeur dans une nouvelle copie.
+ 
+### [DArray.filter](10-filter.ts)
+
+Construire un nouveau tableau avec les éléments qui satisfont un prédicat.
+ 
+### [DArray.find](10-find.ts)
+
+Lire le premier élément satisfaisant un prédicat, ou undefined si aucun ne convient.
+ 
+### [DArray.findAndReplace](10-findAndReplace.ts)
+
+Remplacer le premier élément satisfaisant un prédicat dans une nouvelle copie, ou retourner undefined.
+ 
+### [DArray.findAndSpliceDelete](10-findAndSpliceDelete.ts)
+
+Supprimer plusieurs éléments à partir du premier élément satisfaisant un prédicat.
+ 
+### [DArray.findAndSpliceInsert](10-findAndSpliceInsert.ts)
+
+Insérer des éléments avant le premier élément satisfaisant un prédicat.
+ 
+### [DArray.findAndSpliceReplace](10-findAndSpliceReplace.ts)
+
+Remplacer la portion commençant au premier élément satisfaisant un prédicat.
+ 
+### [DArray.findDuplicates](10-findDuplicates.ts)
+
+Trouver les valeurs primitives ou temporelles apparaissant plusieurs fois dans un tableau.
+ 
+### [DArray.findIndex](10-findIndex.ts)
+
+Lire l’index du premier élément satisfaisant un prédicat, ou undefined.
+ 
+### [DArray.findLast](10-findLast.ts)
+
+Lire le dernier élément satisfaisant un prédicat, ou undefined si aucun ne convient.
+ 
+### [DArray.findLastIndex](10-findLastIndex.ts)
+
+Lire l’index du dernier élément satisfaisant un prédicat, ou undefined.
+ 
+### [DArray.first](10-first.ts)
+
+Lire le premier élément d’un tableau en conservant les garanties de son type.
+ 
+### [DArray.flat](10-flat.ts)
+
+Aplatir les niveaux imbriqués d’un tableau selon une profondeur donnée.
+ 
+### [DArray.flatMap](10-flatMap.ts)
+
+Transformer chaque élément puis aplatir le niveau de tableau produit.
+ 
+### [DArray.from](10-from.ts)
+
+Convertir une source array-like, itérable ou asynchrone en tableau.
+ 
+### [DArray.group](10-group.ts)
+
+Regrouper les valeurs produites par une fonction selon un nom de groupe.
+ 
+### [DArray.groupOutput](10-groupOutput.ts)
+
+Construire le résultat nommé attendu par DArray.group pour associer une valeur à un groupe.
+ 
+### [DArray.includes](10-includes.ts)
+
+Vérifier qu’un tableau contient une valeur.
+ 
+### [DArray.indexOf](10-indexOf.ts)
+
+Lire l’index de la première occurrence d’une valeur, ou undefined.
+ 
+### [DArray.insert](10-insert.ts)
+
+Ajouter une valeur à la fin d’un tableau dans une nouvelle copie.
+ 
+### [DArray.is](10-is.ts)
+
+Vérifier au runtime qu’une valeur est un tableau et affiner son type TypeScript.
+ 
+### [DArray.isLastIndex](10-isLastIndex.ts)
+
+Vérifier qu’un index désigne le dernier élément du tableau.
+ 
+### [DArray.last](10-last.ts)
+
+Lire le dernier élément d’un tableau en conservant les garanties de son type.
+ 
+### [DArray.lastIndexOf](10-lastIndexOf.ts)
+
+Lire l’index de la dernière occurrence d’une valeur, ou undefined.
+ 
+### [DArray.length](10-length.ts)
+
+Lire la longueur d’un tableau avec les contraintes de cardinalité présentes dans son type.
+ 
+### [DArray.lengthEqual](10-lengthEqual.ts)
+
+Vérifier qu’un tableau possède exactement un nombre donné d’éléments et établir cette contrainte.
+ 
+### [DArray.map](10-map.ts)
+
+Transformer chaque élément d’un tableau dans une nouvelle collection.
+ 
+### [DArray.maxElements](10-maxElements.ts)
+
+Vérifier qu’un tableau contient au plus un nombre donné d’éléments et établir cette contrainte.
+ 
+### [DArray.minElements](10-minElements.ts)
+
+Vérifier qu’un tableau contient au moins un nombre donné d’éléments et établir cette contrainte.
+ 
+### [DArray.notIncludes](10-notIncludes.ts)
+
+Vérifier qu’un tableau ne contient pas une valeur.
+ 
+### [DArray.pop](10-pop.ts)
+
+Retirer le dernier élément d’un tableau dans une nouvelle copie.
+ 
+### [DArray.prepend](10-prepend.ts)
+
+Ajouter les éléments d’un ou plusieurs tableaux au début sans muter le tableau d’entrée.
+ 
+### [DArray.push](10-push.ts)
+
+Ajouter une ou plusieurs valeurs à la fin d’un tableau dans une nouvelle copie.
+ 
+### [DArray.reduce](10-reduce.ts)
+
+Réduire un tableau avec un accumulateur explicite et les sorties next ou exit.
+ 
+### [DArray.reduceFrom](10-reduceFrom.ts)
+
+Marquer explicitement la valeur initiale d’un reduce pour préserver sa forme de valeur.
+ 
+### [DArray.reduceRight](10-reduceRight.ts)
+
+Réduire un tableau de droite à gauche avec le contrat explicite de DArray.reduce.
+ 
+### [DArray.reverse](10-reverse.ts)
+
+Inverser l’ordre d’un tableau dans une nouvelle copie.
+ 
+### [DArray.select](10-select.ts)
+
+Transformer sélectivement les éléments avec select et ignorer les autres avec skip.
+ 
+### [DArray.set](10-set.ts)
+
+Remplacer la valeur à un index dans une nouvelle copie du tableau.
+ 
+### [DArray.shift](10-shift.ts)
+
+Retirer le premier élément d’un tableau dans une nouvelle copie.
+ 
+### [DArray.slice](10-slice.ts)
+
+Extraire une portion d’un tableau dans une nouvelle collection.
+ 
+### [DArray.some](10-some.ts)
+
+Vérifier qu’au moins un élément d’un tableau satisfait un prédicat.
+ 
+### [DArray.sort](10-sort.ts)
+
+Trier une copie du tableau avec une fonction de comparaison.
+ 
+### [DArray.spliceDelete](10-spliceDelete.ts)
+
+Supprimer une portion d’un tableau dans une nouvelle copie.
+ 
+### [DArray.spliceInsert](10-spliceInsert.ts)
+
+Insérer des éléments à un index dans une nouvelle copie.
+ 
+### [DArray.spliceReplace](10-spliceReplace.ts)
+
+Remplacer une portion d’un tableau dans une nouvelle copie.
+ 
+### [DArray.unshift](10-unshift.ts)
+
+Ajouter une ou plusieurs valeurs au début d’un tableau dans une nouvelle copie.
+ 

package/docs/API/10-lang/10-array/index.md

@@ -0,0 +1,3 @@
+## DArray
+
+Opérations immuables de lecture, transformation, sélection, réduction et modification de tableaux, avec prise en compte de leurs contraintes de typage.

package/docs/API/10-lang/10-chrono/10-addDays.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.addDays
+ *
+ * Ajouter un nombre de jours à une date.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const result = DChrono.addDays(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 day.
+type _CheckResult = DCommon.ExpectType<typeof result, DChrono.TheDate, "strict">;
+
+// La forme curifiée fixe le décalage dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.addDays(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.addDays("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

package/docs/API/10-lang/10-chrono/10-addHours.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.addHours
+ *
+ * Ajouter un nombre d’heures à une date.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const result = DChrono.addHours(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 hour.
+type _CheckResult = DCommon.ExpectType<typeof result, DChrono.TheDate, "strict">;
+
+// La forme curifiée fixe le décalage dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.addHours(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.addHours("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

package/docs/API/10-lang/10-chrono/10-addMilliseconds.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.addMilliseconds
+ *
+ * Ajouter un nombre de millisecondes à une date.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const result = DChrono.addMilliseconds(date, 1_000);
+
+// La sortie est une nouvelle TheDate décalée de 1_000 millisecond.
+type _CheckResult = DCommon.ExpectType<typeof result, DChrono.TheDate, "strict">;
+
+// La forme curifiée fixe le décalage dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.addMilliseconds(1_000),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.addMilliseconds("date1609459200000+", 1000);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

package/docs/API/10-lang/10-chrono/10-addMinutes.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.addMinutes
+ *
+ * Ajouter un nombre de minutes à une date.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const result = DChrono.addMinutes(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 minute.
+type _CheckResult = DCommon.ExpectType<typeof result, DChrono.TheDate, "strict">;
+
+// La forme curifiée fixe le décalage dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.addMinutes(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.addMinutes("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

package/docs/API/10-lang/10-chrono/10-addMonths.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.addMonths
+ *
+ * Ajouter un nombre de mois à une date en UTC.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const result = DChrono.addMonths(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 month.
+type _CheckResult = DCommon.ExpectType<typeof result, DChrono.TheDate, "strict">;
+
+// La forme curifiée fixe le décalage dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.addMonths(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.addMonths("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

package/docs/API/10-lang/10-chrono/10-addSeconds.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.addSeconds
+ *
+ * Ajouter un nombre de secondes à une date.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const result = DChrono.addSeconds(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 second.
+type _CheckResult = DCommon.ExpectType<typeof result, DChrono.TheDate, "strict">;
+
+// La forme curifiée fixe le décalage dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.addSeconds(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.addSeconds("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

package/docs/API/10-lang/10-chrono/10-addTime.ts

@@ -0,0 +1,38 @@
+/**
+ * @title DChrono.addTime
+ *
+ * Ajouter une durée à une date ou à une autre durée en conservant la nature de l’entrée.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const dateResult = DChrono.addTime("date0+", "time1000+");
+const timeResult = DChrono.addTime("time1000+", "time500+");
+
+// Une date reste une TheDate et une durée reste une TheTime.
+type _CheckDate = DCommon.ExpectType<typeof dateResult, DChrono.TheDate, "strict">;
+type _CheckTime = DCommon.ExpectType<typeof timeResult, DChrono.TheTime, "strict">;
+
+// La forme curifiée s’applique aussi dans un pipe.
+const piped = DCommon.pipe(
+	"time1000+" as const,
+	DChrono.addTime("time500+"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheTime, "strict">;
+
+// Les instances TheDate et TheTime peuvent être combinées avec une TheTime.
+const dateInstanceResult = DChrono.addTime(
+	DChrono.createDate("2021-01-01"),
+	DChrono.createTimeOrThrow(1_000),
+);
+const timeInstanceResult = DChrono.addTime(
+	DChrono.createTimeOrThrow(1_000),
+	DChrono.createTimeOrThrow(500),
+);
+
+type _CheckInstances = DCommon.ExpectType<
+	[typeof dateInstanceResult, typeof timeInstanceResult],
+	[DChrono.TheDate, DChrono.TheTime],
+	"strict"
+>;
+

package/docs/API/10-lang/10-chrono/10-addWeeks.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.addWeeks
+ *
+ * Ajouter un nombre de semaines à une date.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const result = DChrono.addWeeks(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 week.
+type _CheckResult = DCommon.ExpectType<typeof result, DChrono.TheDate, "strict">;
+
+// La forme curifiée fixe le décalage dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.addWeeks(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.addWeeks("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

package/docs/API/10-lang/10-chrono/10-addYears.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.addYears
+ *
+ * Ajouter un nombre d’années à une date en UTC.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const result = DChrono.addYears(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 year.
+type _CheckResult = DCommon.ExpectType<typeof result, DChrono.TheDate, "strict">;
+
+// La forme curifiée fixe le décalage dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.addYears(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.addYears("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

package/docs/API/10-lang/10-chrono/10-applyTimezone.ts

@@ -0,0 +1,29 @@
+/**
+ * @title DChrono.applyTimezone
+ *
+ * Décaler une date pour l’exprimer dans un fuseau horaire donné.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const shifted = DChrono.applyTimezone(date, "America/New_York");
+
+// La sortie est une nouvelle TheDate représentant la date décalée selon le fuseau.
+type _CheckShifted = DCommon.ExpectType<typeof shifted, DChrono.TheDate, "strict">;
+
+// La forme curifiée fixe le fuseau dans une étape de pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.applyTimezone("America/New_York"),
+);
+
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est également acceptée comme entrée.
+const shiftedSerialized = DChrono.applyTimezone(
+	"date1609459200000+",
+	"Europe/Paris",
+);
+type _CheckSerialized = DCommon.ExpectType<typeof shiftedSerialized, DChrono.TheDate, "strict">;
+

package/docs/API/10-lang/10-chrono/10-betweenThanDate.ts

@@ -0,0 +1,27 @@
+/**
+ * @title DChrono.betweenThanDate
+ *
+ * Vérifier qu’une date est strictement comprise entre deux bornes.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const greater = DChrono.createDate("2021-01-01");
+const less = DChrono.createDate("2021-01-31");
+const result = DChrono.betweenThanDate(date, greater, less);
+
+// La valeur est acceptée par la relation de bornes.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// La forme curifiée fixe les deux bornes dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.betweenThanDate(greater, less),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les trois bornes peuvent être des dates ou durées sérialisées selon le domaine.
+const serializedResult = DChrono.betweenThanDate("date1609545600000+", "date1609459200000+", "date1620000000000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+

package/docs/API/10-lang/10-chrono/10-betweenThanOrEqualDate.ts

@@ -0,0 +1,27 @@
+/**
+ * @title DChrono.betweenThanOrEqualDate
+ *
+ * Vérifier qu’une date est comprise entre deux bornes inclusives.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const greater = DChrono.createDate("2021-01-15");
+const less = DChrono.createDate("2021-01-31");
+const result = DChrono.betweenThanOrEqualDate(date, greater, less);
+
+// La valeur est acceptée par la relation de bornes.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// La forme curifiée fixe les deux bornes dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.betweenThanOrEqualDate(greater, less),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les trois bornes peuvent être des dates ou durées sérialisées selon le domaine.
+const serializedResult = DChrono.betweenThanOrEqualDate("date1609459200000+", "date1609459200000+", "date1620000000000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+

package/docs/API/10-lang/10-chrono/10-betweenThanOrEqualTime.ts

@@ -0,0 +1,27 @@
+/**
+ * @title DChrono.betweenThanOrEqualTime
+ *
+ * Vérifier qu’une durée est comprise entre deux bornes inclusives.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const time = DChrono.createTimeOrThrow(2_000);
+const greater = DChrono.createTimeOrThrow(2_000);
+const less = DChrono.createTimeOrThrow(3_000);
+const result = DChrono.betweenThanOrEqualTime(time, greater, less);
+
+// La valeur est acceptée par la relation de bornes.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// La forme curifiée fixe les deux bornes dans le pipe.
+const piped = DCommon.pipe(
+	time,
+	DChrono.betweenThanOrEqualTime(greater, less),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les trois bornes peuvent être des dates ou durées sérialisées selon le domaine.
+const serializedResult = DChrono.betweenThanOrEqualTime("time2000+", "time2000+", "time3000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+

package/docs/API/10-lang/10-chrono/10-betweenThanTime.ts

@@ -0,0 +1,27 @@
+/**
+ * @title DChrono.betweenThanTime
+ *
+ * Vérifier qu’une durée est strictement comprise entre deux bornes.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const time = DChrono.createTimeOrThrow(2_000);
+const greater = DChrono.createTimeOrThrow(1_000);
+const less = DChrono.createTimeOrThrow(3_000);
+const result = DChrono.betweenThanTime(time, greater, less);
+
+// La valeur est acceptée par la relation de bornes.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// La forme curifiée fixe les deux bornes dans le pipe.
+const piped = DCommon.pipe(
+	time,
+	DChrono.betweenThanTime(greater, less),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les trois bornes peuvent être des dates ou durées sérialisées selon le domaine.
+const serializedResult = DChrono.betweenThanTime("time2000+", "time1000+", "time3000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+