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

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

@@ -0,0 +1,26 @@
+/**
+ * @title DChrono.lessThanDate
+ *
+ * Comparer deux dates avec une relation strictement inférieure.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-01");
+const threshold = DChrono.createDate("2021-01-15");
+const result = DChrono.lessThanDate(date, threshold);
+
+// La comparaison produit true pour ces deux valeurs.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// La forme curifiée fixe la seconde valeur dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.lessThanDate(threshold),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les formes sérialisées peuvent être comparées directement.
+const serializedResult = DChrono.lessThanDate("date1609459200000+", "date1609545600000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+

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

@@ -0,0 +1,26 @@
+/**
+ * @title DChrono.lessThanOrEqualDate
+ *
+ * Comparer deux dates avec une relation inférieure ou égale.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const threshold = DChrono.createDate("2021-01-15");
+const result = DChrono.lessThanOrEqualDate(date, threshold);
+
+// La comparaison produit true pour ces deux valeurs.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// La forme curifiée fixe la seconde valeur dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.lessThanOrEqualDate(threshold),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les formes sérialisées peuvent être comparées directement.
+const serializedResult = DChrono.lessThanOrEqualDate("date1609459200000+", "date1609459200000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+

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

@@ -0,0 +1,26 @@
+/**
+ * @title DChrono.lessThanOrEqualTime
+ *
+ * Comparer deux durées avec une relation inférieure ou égale.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const time = DChrono.createTimeOrThrow(2_000);
+const threshold = DChrono.createTimeOrThrow(2_000);
+const result = DChrono.lessThanOrEqualTime(time, threshold);
+
+// La comparaison produit true pour ces deux valeurs.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// La forme curifiée fixe la seconde valeur dans le pipe.
+const piped = DCommon.pipe(
+	time,
+	DChrono.lessThanOrEqualTime(threshold),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les formes sérialisées peuvent être comparées directement.
+const serializedResult = DChrono.lessThanOrEqualTime("time2000+", "time2000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+

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

@@ -0,0 +1,26 @@
+/**
+ * @title DChrono.lessThanTime
+ *
+ * Comparer deux durées avec une relation strictement inférieure.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const time = DChrono.createTimeOrThrow(1_000);
+const threshold = DChrono.createTimeOrThrow(2_000);
+const result = DChrono.lessThanTime(time, threshold);
+
+// La comparaison produit true pour ces deux valeurs.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// La forme curifiée fixe la seconde valeur dans le pipe.
+const piped = DCommon.pipe(
+	time,
+	DChrono.lessThanTime(threshold),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les formes sérialisées peuvent être comparées directement.
+const serializedResult = DChrono.lessThanTime("time1000+", "time2000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+

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

@@ -0,0 +1,19 @@
+/**
+ * @title DChrono.makeSafeTimeValue
+ *
+ * Ramener une durée vers un entier compris dans l’intervalle sûr de TheTime.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const rounded = DChrono.makeSafeTimeValue(90_000.4);
+const fromNaN = DChrono.makeSafeTimeValue(Number.NaN);
+const fromTooLarge = DChrono.makeSafeTimeValue(DChrono.maxTimeValue + 1);
+const fromTooSmall = DChrono.makeSafeTimeValue(DChrono.minTimeValue - 1);
+
+// Les fractions sont arrondies et NaN devient zéro.
+type _CheckRounded = DCommon.ExpectType<typeof rounded, number, "strict">;
+type _CheckNaN = DCommon.ExpectType<typeof fromNaN, number, "strict">;
+type _CheckTooLarge = DCommon.ExpectType<typeof fromTooLarge, number, "strict">;
+type _CheckTooSmall = DCommon.ExpectType<typeof fromTooSmall, number, "strict">;
+

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

@@ -0,0 +1,19 @@
+/**
+ * @title DChrono.makeSafeTimestamp
+ *
+ * Ramener un timestamp vers un entier compris dans l’intervalle sûr de TheDate.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const rounded = DChrono.makeSafeTimestamp(1_609_459_200_000.4);
+const fromNaN = DChrono.makeSafeTimestamp(Number.NaN);
+const fromTooLarge = DChrono.makeSafeTimestamp(DChrono.maxTimestamp + 1);
+const fromTooSmall = DChrono.makeSafeTimestamp(DChrono.minTimestamp - 1);
+
+// Les fractions sont arrondies et NaN devient zéro.
+type _CheckRounded = DCommon.ExpectType<typeof rounded, number, "strict">;
+type _CheckNaN = DCommon.ExpectType<typeof fromNaN, number, "strict">;
+type _CheckTooLarge = DCommon.ExpectType<typeof fromTooLarge, number, "strict">;
+type _CheckTooSmall = DCommon.ExpectType<typeof fromTooSmall, number, "strict">;
+

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

@@ -0,0 +1,19 @@
+/**
+ * @title DChrono.maxDate
+ *
+ * Retourner la date la plus éloignée dans le futur parmi plusieurs dates.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+declare const dates: [DChrono.TheDate, DChrono.TheDate];
+const latest = DChrono.maxDate(dates);
+
+// La valeur obtenue est la date du 15 janvier.
+type _CheckLatest = DCommon.ExpectType<typeof latest, DChrono.TheDate, "strict">;
+
+// Les éléments peuvent être un mélange de TheDate et de dates sérialisées.
+declare const mixedDates: [DChrono.TheDate | DChrono.SerializedTheDate, DChrono.TheDate | DChrono.SerializedTheDate];
+const latestMixed = DChrono.maxDate(mixedDates);
+type _CheckMixed = DCommon.ExpectType<typeof latestMixed, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,19 @@
+/**
+ * @title DChrono.maxTime
+ *
+ * Retourner la durée de valeur maximale parmi plusieurs durées.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+declare const times: [DChrono.TheTime, DChrono.TheTime];
+const longest = DChrono.maxTime(times);
+
+// La valeur obtenue représente 2 000 millisecondes.
+type _CheckLongest = DCommon.ExpectType<typeof longest, DChrono.TheTime, "strict">;
+
+// Les éléments peuvent être un mélange de TheTime et de durées sérialisées.
+declare const mixedTimes: [DChrono.TheTime | DChrono.SerializedTheTime, DChrono.TheTime | DChrono.SerializedTheTime];
+const longestMixed = DChrono.maxTime(mixedTimes);
+type _CheckMixed = DCommon.ExpectType<typeof longestMixed, DChrono.TheTime, "strict">;
+

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

@@ -0,0 +1,19 @@
+/**
+ * @title DChrono.minDate
+ *
+ * Retourner la date la plus éloignée dans le passé parmi plusieurs dates.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+declare const dates: [DChrono.TheDate, DChrono.TheDate];
+const earliest = DChrono.minDate(dates);
+
+// La valeur obtenue est la date du 1er janvier.
+type _CheckEarliest = DCommon.ExpectType<typeof earliest, DChrono.TheDate, "strict">;
+
+// Les éléments peuvent être un mélange de TheDate et de dates sérialisées.
+declare const mixedDates: [DChrono.TheDate | DChrono.SerializedTheDate, DChrono.TheDate | DChrono.SerializedTheDate];
+const earliestMixed = DChrono.minDate(mixedDates);
+type _CheckMixed = DCommon.ExpectType<typeof earliestMixed, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,19 @@
+/**
+ * @title DChrono.minTime
+ *
+ * Retourner la durée de valeur minimale parmi plusieurs durées.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+declare const times: [DChrono.TheTime, DChrono.TheTime];
+const shortest = DChrono.minTime(times);
+
+// La valeur obtenue représente 1 000 millisecondes.
+type _CheckShortest = DCommon.ExpectType<typeof shortest, DChrono.TheTime, "strict">;
+
+// Les éléments peuvent être un mélange de TheTime et de durées sérialisées.
+declare const mixedTimes: [DChrono.TheTime | DChrono.SerializedTheTime, DChrono.TheTime | DChrono.SerializedTheTime];
+const shortestMixed = DChrono.minTime(mixedTimes);
+type _CheckMixed = DCommon.ExpectType<typeof shortestMixed, DChrono.TheTime, "strict">;
+

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

@@ -0,0 +1,13 @@
+/**
+ * @title DChrono.now
+ *
+ * Créer une TheDate représentant l’instant courant.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const current = DChrono.now();
+
+// La valeur dépend de l’horloge au moment de l’appel, mais reste une TheDate.
+type _CheckCurrent = DCommon.ExpectType<typeof current, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,41 @@
+/**
+ * @title DChrono.round
+ *
+ * Ramener une date au début de l’unité UTC demandée.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDateOrThrow({
+	value: "2021-01-15",
+	hour: 12,
+	minute: 34,
+	second: 56,
+	millisecond: 789,
+});
+const rounded = DChrono.round(date, "day");
+
+// La sortie représente le début du 15 janvier en UTC.
+type _CheckRounded = DCommon.ExpectType<typeof rounded, DChrono.TheDate, "strict">;
+
+// Sans unité, le jour est utilisé par défaut.
+const defaultRounded = DChrono.round(date);
+type _CheckDefault = DCommon.ExpectType<typeof defaultRounded, DChrono.TheDate, "strict">;
+
+// Les autres unités de RoundUnit ramènent la date au début de leur période UTC.
+const roundedSecond = DChrono.round(date, "second");
+const roundedMinute = DChrono.round(date, "minute");
+const roundedHour = DChrono.round(date, "hour");
+const roundedMonth = DChrono.round(date, "month");
+const roundedYear = DChrono.round(date, "year");
+
+type _CheckUnits = DCommon.ExpectType<
+	[typeof roundedSecond, typeof roundedMinute, typeof roundedHour, typeof roundedMonth, typeof roundedYear],
+	[DChrono.TheDate, DChrono.TheDate, DChrono.TheDate, DChrono.TheDate, DChrono.TheDate],
+	"strict"
+>;
+
+// Une date sérialisée peut aussi être arrondie.
+const roundedSerialized = DChrono.round("date1610714096789+", "hour");
+type _CheckSerialized = DCommon.ExpectType<typeof roundedSerialized, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,23 @@
+/**
+ * @title DChrono.serialize
+ *
+ * Convertir une TheDate ou une TheTime en chaîne sérialisée.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const serializedDate = DChrono.serialize(DChrono.createDate("2021-01-01"));
+const serializedTime = DChrono.serialize(DChrono.createTimeOrThrow(2_500));
+
+// Les résultats portent respectivement les formats SerializedTheDate et SerializedTheTime.
+type _CheckDate = DCommon.ExpectType<typeof serializedDate, DChrono.SerializedTheDate, "strict">;
+type _CheckTime = DCommon.ExpectType<typeof serializedTime, DChrono.SerializedTheTime, "strict">;
+
+// Le signe encode aussi les valeurs antérieures à l’époque Unix.
+const serializedPastDate = DChrono.serialize(DChrono.createDateOrThrow(-1_000));
+const serializedNegativeTime = DChrono.serialize(DChrono.createTimeOrThrow(-2_500));
+
+// Les résultats restent respectivement des chaînes de date et de durée sérialisées.
+type _CheckPastDate = DCommon.ExpectType<typeof serializedPastDate, DChrono.SerializedTheDate, "strict">;
+type _CheckNegativeTime = DCommon.ExpectType<typeof serializedNegativeTime, DChrono.SerializedTheTime, "strict">;
+

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

@@ -0,0 +1,30 @@
+/**
+ * @title DChrono.sortDates
+ *
+ * Trier des dates par ordre croissant ou décroissant.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const dates: readonly [DChrono.TheDate, DChrono.TheDate];
+const ascending = DChrono.sortDates(dates, "ASC");
+
+// La nouvelle collection est triée du 1er au 15 janvier.
+type _CheckAscending = DCommon.ExpectType<typeof ascending, DChrono.TheDate[], "strict">;
+
+// La forme curifiée fixe l’ordre dans le pipe.
+const descending = DCommon.pipe(
+	dates,
+	DChrono.sortDates("DSC"),
+);
+type _CheckDescending = DCommon.ExpectType<typeof descending, DChrono.TheDate[], "strict">;
+
+// Une collection peut mélanger dates sérialisées et TheDate.
+declare const mixedDates: readonly [
+	DChrono.TheDate | DChrono.SerializedTheDate,
+	DChrono.TheDate | DChrono.SerializedTheDate,
+];
+const mixed = DChrono.sortDates(mixedDates, "ASC");
+type _CheckMixed = DCommon.ExpectType<typeof mixed, DChrono.TheDate[], "strict">;
+

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

@@ -0,0 +1,29 @@
+/**
+ * @title DChrono.sortTimes
+ *
+ * Trier des durées par ordre croissant ou décroissant.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const times: readonly [DChrono.TheTime, DChrono.TheTime];
+const ascending = DChrono.sortTimes(times, "ASC");
+
+// La nouvelle collection est triée de 1 000 à 2 000 millisecondes.
+type _CheckAscending = DCommon.ExpectType<typeof ascending, DChrono.TheTime[], "strict">;
+
+// La forme curifiée fixe l’ordre dans le pipe.
+const descending = DCommon.pipe(
+	times,
+	DChrono.sortTimes("DSC"),
+);
+type _CheckDescending = DCommon.ExpectType<typeof descending, DChrono.TheTime[], "strict">;
+
+// Une collection peut mélanger durées sérialisées et TheTime.
+declare const mixedTimes: readonly [
+	DChrono.TheTime | DChrono.SerializedTheTime,
+	DChrono.TheTime | DChrono.SerializedTheTime,
+];
+const mixed = DChrono.sortTimes(mixedTimes, "ASC");
+type _CheckMixed = DCommon.ExpectType<typeof mixed, DChrono.TheTime[], "strict">;
+

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

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractDays
+ *
+ * Soustraire 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.subtractDays(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 day vers le passé.
+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.subtractDays(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractDays("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractHours
+ *
+ * Soustraire 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.subtractHours(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 hour vers le passé.
+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.subtractHours(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractHours("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractMilliseconds
+ *
+ * Soustraire 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.subtractMilliseconds(date, 1_000);
+
+// La sortie est une nouvelle TheDate décalée de 1_000 millisecond vers le passé.
+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.subtractMilliseconds(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.subtractMilliseconds("date1609459200000+", 1000);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractMinutes
+ *
+ * Soustraire 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.subtractMinutes(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 minute vers le passé.
+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.subtractMinutes(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractMinutes("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractMonths
+ *
+ * Soustraire 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.subtractMonths(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 month vers le passé.
+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.subtractMonths(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractMonths("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractSeconds
+ *
+ * Soustraire 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.subtractSeconds(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 second vers le passé.
+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.subtractSeconds(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractSeconds("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,38 @@
+/**
+ * @title DChrono.subtractTime
+ *
+ * Soustraire 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.subtractTime("date1000+", "time500+");
+const timeResult = DChrono.subtractTime("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(
+	"date1000+",
+	DChrono.subtractTime("time500+"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Les instances TheDate et TheTime peuvent être combinées avec une TheTime.
+const dateInstanceResult = DChrono.subtractTime(
+	DChrono.createDate("2021-01-01"),
+	DChrono.createTimeOrThrow(1_000),
+);
+const timeInstanceResult = DChrono.subtractTime(
+	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-subtractWeeks.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractWeeks
+ *
+ * Soustraire 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.subtractWeeks(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 week vers le passé.
+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.subtractWeeks(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractWeeks("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractYears
+ *
+ * Soustraire 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.subtractYears(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 year vers le passé.
+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.subtractYears(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractYears("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,17 @@
+/**
+ * @title DChrono.toDateISOString
+ *
+ * Convertir une date en chaîne ISO UTC.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const iso = DChrono.toDateISOString(DChrono.createDate("2021-01-01"));
+
+// La valeur obtenue est « 2021-01-01T00:00:00.000Z ».
+type _CheckIso = DCommon.ExpectType<typeof iso, string, "strict">;
+
+// Une date sérialisée est convertie de la même manière.
+const serializedIso = DChrono.toDateISOString("date1609459200000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedIso, string, "strict">;
+