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

package/docs/API/10-lang/10-generator/10-chunk.ts

@@ -0,0 +1,44 @@
+/**
+ * @title DGenerator.chunk
+ *
+ * Regrouper les valeurs d’un itérable en sous-itérables de taille bornée.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+
+const input: number[] = [1, 2, 3, 4, 5];
+
+// Appel classique : les valeurs sont produites dans des groupes d’au plus deux éléments.
+const result = DGenerator.chunk(input, 2);
+
+// La sortie est un générateur qui produit [[1, 2], [3, 4], [5]].
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	Generator<
+		& readonly number[]
+		& DArray.MinElements<1>
+		& DArray.MaxElements<2>,
+		unknown,
+		unknown
+	>,
+	"strict"
+>;
+
+// Appel curifié : la taille est configurée dans l’étape du pipe.
+const piped = DCommon.pipe(
+	input,
+	DGenerator.chunk(3),
+	DArray.from,
+);
+
+// La sortie vaut [[1, 2, 3], [4, 5]].
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	readonly (
+		& readonly number[]
+		& DArray.MinElements<1>
+		& DArray.MaxElements<3>
+	)[],
+	"strict"
+>;

package/docs/API/10-lang/10-generator/10-concat.ts

@@ -0,0 +1,37 @@
+/**
+ * @title DGenerator.concat
+ *
+ * Enchaîner plusieurs itérables dans un générateur synchrone.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DArray from "@duplojs/lang/array";
+import * as DGenerator from "@duplojs/lang/generator";
+
+// Appel classique : les valeurs sont produites dans l’ordre [1, 2, 3, 4].
+const result = DGenerator.concat(
+	[1, 2],
+	[3],
+	[4],
+);
+
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	Generator<1 | 2 | 3 | 4, unknown, unknown>,
+	"strict"
+>;
+
+const tail: Iterable<number> = [3, 4];
+
+// Appel curifié : les itérables ajoutés sont configurés dans l’étape du pipe.
+const piped = DCommon.pipe(
+	[1, 2],
+	DGenerator.concat(tail),
+	DArray.from,
+);
+
+// La sortie vaut [1, 2, 3, 4].
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	readonly number[],
+	"strict"
+>;

package/docs/API/10-lang/10-generator/10-createExternalAsyncGenerator.ts

@@ -0,0 +1,29 @@
+/**
+ * @title DGenerator.createExternalAsyncGenerator
+ *
+ * Créer un générateur asynchrone dont la prochaine valeur ou la fin sont déclenchées de l’extérieur.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+
+const external = DGenerator.createExternalAsyncGenerator<number>();
+
+// L’itérateur attend un appel à `next` et produira ensuite la valeur fournie.
+const nextResult = external.next(12);
+
+type _CheckNext = DCommon.ExpectType<typeof nextResult, undefined, "strict">;
+
+// `exit` termine l’itérateur sans produire de valeur.
+const exitResult = external.exit();
+
+type _CheckExit = DCommon.ExpectType<typeof exitResult, undefined, "strict">;
+
+type _CheckExternal = DCommon.ExpectType<
+	typeof external,
+	{
+		asyncGenerator: AsyncGenerator<number, void, unknown>;
+		next(item: number): undefined;
+		exit(): undefined;
+	},
+	"strict"
+>;

package/docs/API/10-lang/10-generator/10-execute.ts

@@ -0,0 +1,44 @@
+/**
+ * @title DGenerator.execute
+ *
+ * Consommer une génératrice jusqu’à sa fin, en retournant une promesse pour les génératrices asynchrones.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+
+// Appel synchrone : `loop` rappelle sa callback comme une boucle `while`,
+// puis `map` traite chaque valeur avant qu’`execute` ne consomme la génératrice.
+const result = DCommon.pipe(
+	DGenerator.loop(({ count, next, exit }: DGenerator.LoopParams<number>) => {
+		if (count === 3) {
+			return exit();
+		}
+
+		return next(count);
+	}),
+	DGenerator.map(DCommon.forwardLog),
+	DGenerator.execute,
+);
+
+// La génératrice est consommée jusqu’à sa fin et chaque valeur est transmise à `forwardLog`.
+type _CheckResult = DCommon.ExpectType<typeof result, void, "strict">;
+
+// Appel asynchrone : `asyncLoop` produit une génératrice asynchrone,
+// et `execute` retourne une promesse résolue après le traitement de chaque valeur.
+const asyncResult = DCommon.pipe(
+	DGenerator.asyncLoop(async({ count, next, exit }: DGenerator.LoopParams<number>) => {
+		await DCommon.timeout();
+
+		return count === 3
+			? exit()
+			: next(count);
+	}),
+	DGenerator.asyncMap(DCommon.forwardLog),
+	DGenerator.execute,
+);
+
+type _CheckAsyncResult = DCommon.ExpectType<
+	typeof asyncResult,
+	Promise<void>,
+	"strict"
+>;

package/docs/API/10-lang/10-generator/10-filter.ts

@@ -0,0 +1,35 @@
+/**
+ * @title DGenerator.filter
+ *
+ * Conserver dans un générateur les valeurs acceptées par un prédicat.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DArray from "@duplojs/lang/array";
+import * as DGenerator from "@duplojs/lang/generator";
+import * as DNumber from "@duplojs/lang/number";
+
+const input: number[] = [1, 2, 3, 4];
+
+// Appel classique : seuls les nombres supérieurs à deux sont produits.
+const result = DGenerator.filter(input, DNumber.greaterThan(2));
+
+// La sortie est un générateur qui produit [3, 4] et conserve l’affinement du prédicat.
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	Generator<number & DNumber.GreaterThan<2>, unknown, unknown>,
+	"strict"
+>;
+
+// Appel curifié : le prédicat est configuré dans l’étape du pipe.
+const piped = DCommon.pipe(
+	input,
+	DGenerator.filter(DNumber.isEven),
+	DArray.from,
+);
+
+// La sortie vaut [2, 4].
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	readonly (number & DNumber.Even)[],
+	"strict"
+>;

package/docs/API/10-lang/10-generator/10-flat.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DGenerator.flat
+ *
+ * Aplatir récursivement les valeurs itérables jusqu’à une profondeur donnée.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+
+// Profondeur par défaut : un seul niveau est aplati et la sortie contient [1, 2, 3].
+const result = DGenerator.flat([[1, 2], [3]]);
+
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	Generator<1 | 2 | 3, void, unknown>,
+	"strict"
+>;
+
+// Une profondeur de deux aplati deux niveaux et produit également [1, 2, 3].
+const deeplyFlattened = DGenerator.flat([[[1], [2]], [[3]]], 2);
+
+type _CheckDeeplyFlattened = DCommon.ExpectType<
+	typeof deeplyFlattened,
+	Generator<1 | 2 | 3, void, unknown>,
+	"strict"
+>;

package/docs/API/10-lang/10-generator/10-group.ts

@@ -0,0 +1,44 @@
+/**
+ * @title DGenerator.group
+ *
+ * Regrouper les valeurs d’un itérable selon les sorties nommées d’une callback.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+import * as DString from "@duplojs/lang/string";
+
+const input: string[] = ["a", "bb", "c"];
+
+// Appel classique : chaque valeur est ajoutée au groupe dont le nom dépend de sa longueur.
+// Le ternaire porte sur la structure entière : `group` devient un discriminant littéral.
+const result = DGenerator.group(
+	input,
+	(item, params) => DString.lengthEqual(item, 1)
+		? params.output("short", item)
+		: params.output("long", item),
+);
+
+// La sortie vaut { short: ["a", "c"], long: ["bb"] }.
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	{
+		readonly long?: readonly [string, ...string[]] | undefined;
+		readonly short?: readonly [string & DString.LengthEqual<1>, ...(string & DString.LengthEqual<1>)[]] | undefined;
+	},
+	"strict"
+>;
+
+// Appel curifié : le regroupement est configuré dans l’étape du pipe.
+const piped = DCommon.pipe(
+	input,
+	DGenerator.group((item, params) => params.output("value", item)),
+);
+
+// La sortie vaut { value: ["a", "bb", "c"] }.
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	{
+		readonly value?: readonly [string, ...string[]] | undefined;
+	},
+	"strict"
+>;

package/docs/API/10-lang/10-generator/10-groupOutput.ts

@@ -0,0 +1,48 @@
+/**
+ * @title DGenerator.groupOutput
+ *
+ * Construire une sortie nommée destinée à la fonction de regroupement.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DString from "@duplojs/lang/string";
+
+declare const value: number;
+
+// Appel classique : associer directement la valeur au groupe `even`.
+const result = DGenerator.groupOutput("even", value);
+
+// La sortie associe le groupe `even` à la valeur fournie.
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	DGenerator.GroupOutputResult<"even", number>,
+	"strict"
+>;
+
+// Composition dans un pipe : le pattern `when` sélectionne le premier groupe,
+// puis `otherwise` traite le reste sans ouvrir de callback intermédiaire.
+const input: string[] = ["a", "bb", "c"];
+
+const piped = DCommon.pipe(
+	input,
+	DGenerator.group(
+		DCommon.innerPipe(
+			DPattern.when(
+				DString.lengthEqual(1),
+				DGenerator.groupOutput("short"),
+			),
+			DPattern.otherwise(DGenerator.groupOutput("long")),
+		),
+	),
+);
+
+// La sortie vaut { short: ["a", "c"], long: ["bb"] }.
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	{
+		readonly long?: readonly [string, ...string[]] | undefined;
+		readonly short?: readonly [string & DString.LengthEqual<1>, ...(string & DString.LengthEqual<1>)[]] | undefined;
+	},
+	"strict"
+>;

package/docs/API/10-lang/10-generator/10-loop.ts

@@ -0,0 +1,55 @@
+/**
+ * @title DGenerator.loop
+ *
+ * Produire une séquence dans un pipe en distinguant l’arrêt avec ou sans dernière valeur émise.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+import * as DNumber from "@duplojs/lang/number";
+
+// Arrêt sans dernière valeur : `exit()` termine la boucle sans émettre d’élément supplémentaire.
+const withoutExitValue = DCommon.pipe(
+	DGenerator.loop(({ previousOutput, next, exit }: DGenerator.LoopParams<number>) => {
+		if (previousOutput === 3) {
+			return exit();
+		}
+
+		return next(
+			previousOutput === undefined
+				? 1
+				: DNumber.sum([previousOutput, 1]),
+		);
+	}),
+	DArray.from,
+);
+
+// La sortie vaut [1, 2, 3] : `next` émet les valeurs intermédiaires, mais `exit()` n’en émet aucune.
+type _CheckWithoutExitValue = DCommon.ExpectType<
+	typeof withoutExitValue,
+	readonly number[],
+	"strict"
+>;
+
+// Arrêt avec dernière valeur : `exit(value)` termine la boucle en émettant cette valeur.
+const withExitValue = DCommon.pipe(
+	DGenerator.loop(({ previousOutput, next, exit }: DGenerator.LoopParams<number>) => {
+		if (previousOutput === 3) {
+			return exit(4);
+		}
+
+		return next(
+			previousOutput === undefined
+				? 1
+				: DNumber.sum([previousOutput, 1]),
+		);
+	}),
+	DArray.from,
+);
+
+// La sortie vaut [1, 2, 3, 4] : `exit(4)` ajoute la dernière valeur à la séquence.
+type _CheckWithExitValue = DCommon.ExpectType<
+	typeof withExitValue,
+	readonly number[],
+	"strict"
+>;

package/docs/API/10-lang/10-generator/10-map.ts

@@ -0,0 +1,35 @@
+/**
+ * @title DGenerator.map
+ *
+ * Transformer chaque valeur d’un itérable dans un générateur.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DArray from "@duplojs/lang/array";
+import * as DGenerator from "@duplojs/lang/generator";
+import * as DNumber from "@duplojs/lang/number";
+
+const input = [1, 2, 3];
+
+// Appel classique : chaque nombre est doublé.
+const result = DGenerator.map(input, (item) => DNumber.sum([item, item]));
+
+// La sortie est un générateur qui produit [2, 4, 6].
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	Generator<number, unknown, unknown>,
+	"strict"
+>;
+
+// Appel curifié : la transformation est configurée dans l’étape du pipe.
+const piped = DCommon.pipe(
+	input,
+	DGenerator.map((item) => DNumber.sum([item, item, item])),
+	DArray.from,
+);
+
+// La sortie vaut [3, 6, 9].
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	readonly number[],
+	"strict"
+>;

package/docs/API/10-lang/10-generator/10-reduce.ts

@@ -0,0 +1,51 @@
+/**
+ * @title DGenerator.reduce
+ *
+ * Réduire un itérable avec un accumulateur et des sorties next ou exit.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+import * as DNumber from "@duplojs/lang/number";
+
+const input = [1, 2, 3];
+
+// Appel classique : le nombre initial est directement inféré comme accumulateur numérique.
+const result = DGenerator.reduce(
+	input,
+	0,
+	({ lastValue, item, next }) => next(DNumber.sum([lastValue, item])),
+);
+
+// La sortie vaut 6 et le type de l’accumulateur est inféré comme number.
+type _CheckResult = DCommon.ExpectType<typeof result, number, "strict">;
+
+type Accumulator =
+	| { total: number }
+	| { values: readonly number[] };
+
+// Appel curifié : le générique porté par reduceFrom décrit une union sans utiliser `as`.
+const piped = DCommon.pipe(
+	input,
+	DGenerator.reduce(
+		DGenerator.reduceFrom<Accumulator>({ total: 0 }),
+		({ lastValue, next }) => next(lastValue),
+	),
+);
+
+// La sortie conserve l’union { total: number } | { values: readonly number[] }.
+type _CheckPiped = DCommon.ExpectType<typeof piped, Accumulator, "strict">;
+
+// Une sortie exit interrompt la réduction : son type string est indépendant de l’accumulateur number.
+const stopped = DGenerator.reduce(
+	input,
+	0,
+	({ item, lastValue, next, exit }) => item === 2
+		? exit("stop")
+		: next(DNumber.sum([lastValue, item])),
+);
+
+type _CheckStopped = DCommon.ExpectType<
+	typeof stopped,
+	number | string,
+	"strict"
+>;

package/docs/API/10-lang/10-generator/10-reduceFrom.ts

@@ -0,0 +1,30 @@
+/**
+ * @title DGenerator.reduceFrom
+ *
+ * Marquer une valeur initiale, éventuellement élargie par un générique, pour une réduction.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+
+// Pour une valeur primitive, son type est inféré directement.
+const numberInitial = DGenerator.reduceFrom(0);
+
+type _CheckNumberInitial = DCommon.ExpectType<
+	typeof numberInitial,
+	DGenerator.ReduceFromResult<number>,
+	"strict"
+>;
+
+type Accumulator =
+	| { total: number }
+	| { values: readonly number[] };
+
+// Pour une structure plus large, le générique de reduceFrom fixe la shape ou l’union sans utiliser `as`.
+const result = DGenerator.reduce(
+	[1, 2, 3],
+	DGenerator.reduceFrom<Accumulator>({ total: 0 }),
+	({ lastValue, next }) => next(lastValue),
+);
+
+// La réduction désempaquette l’accumulateur et conserve l’union définie par reduceFrom.
+type _CheckResult = DCommon.ExpectType<typeof result, Accumulator, "strict">;

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

@@ -0,0 +1,84 @@
+## DGenerator
+
+Création et composition de génératrices synchrones ou asynchrones pour produire, transformer, filtrer, réduire et consommer des séquences de valeurs.
+
+### [DGenerator.asyncChunk](10-asyncChunk.ts)
+
+Regrouper les valeurs d’un itérable asynchrone en sous-itérables de taille bornée.
+ 
+### [DGenerator.asyncConcat](10-asyncConcat.ts)
+
+Enchaîner plusieurs itérables synchrones ou asynchrones dans un générateur asynchrone.
+ 
+### [DGenerator.asyncFilter](10-asyncFilter.ts)
+
+Conserver dans un générateur asynchrone les valeurs acceptées par un prédicat.
+ 
+### [DGenerator.asyncFlat](10-asyncFlat.ts)
+
+Aplatir récursivement les valeurs itérables d’un générateur asynchrone jusqu’à une profondeur donnée.
+ 
+### [DGenerator.asyncGroup](10-asyncGroup.ts)
+
+Regrouper les valeurs d’un itérable asynchrone selon les sorties nommées d’une callback.
+ 
+### [DGenerator.asyncLoop](10-asyncLoop.ts)
+
+Produire une séquence asynchrone dans un pipe en distinguant l’arrêt avec ou sans dernière valeur émise.
+ 
+### [DGenerator.asyncMap](10-asyncMap.ts)
+
+Transformer chaque valeur dans un générateur asynchrone, en autorisant une callback synchrone ou asynchrone.
+ 
+### [DGenerator.asyncReduce](10-asyncReduce.ts)
+
+Réduire un itérable avec un accumulateur et des sorties next ou exit dans une promesse.
+ 
+### [DGenerator.chunk](10-chunk.ts)
+
+Regrouper les valeurs d’un itérable en sous-itérables de taille bornée.
+ 
+### [DGenerator.concat](10-concat.ts)
+
+Enchaîner plusieurs itérables dans un générateur synchrone.
+ 
+### [DGenerator.createExternalAsyncGenerator](10-createExternalAsyncGenerator.ts)
+
+Créer un générateur asynchrone dont la prochaine valeur ou la fin sont déclenchées de l’extérieur.
+ 
+### [DGenerator.execute](10-execute.ts)
+
+Consommer une génératrice jusqu’à sa fin, en retournant une promesse pour les génératrices asynchrones.
+ 
+### [DGenerator.filter](10-filter.ts)
+
+Conserver dans un générateur les valeurs acceptées par un prédicat.
+ 
+### [DGenerator.flat](10-flat.ts)
+
+Aplatir récursivement les valeurs itérables jusqu’à une profondeur donnée.
+ 
+### [DGenerator.group](10-group.ts)
+
+Regrouper les valeurs d’un itérable selon les sorties nommées d’une callback.
+ 
+### [DGenerator.groupOutput](10-groupOutput.ts)
+
+Construire une sortie nommée destinée à la fonction de regroupement.
+ 
+### [DGenerator.loop](10-loop.ts)
+
+Produire une séquence dans un pipe en distinguant l’arrêt avec ou sans dernière valeur émise.
+ 
+### [DGenerator.map](10-map.ts)
+
+Transformer chaque valeur d’un itérable dans un générateur.
+ 
+### [DGenerator.reduce](10-reduce.ts)
+
+Réduire un itérable avec un accumulateur et des sorties next ou exit.
+ 
+### [DGenerator.reduceFrom](10-reduceFrom.ts)
+
+Marquer une valeur initiale, éventuellement élargie par un générique, pour une réduction.
+ 

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

@@ -0,0 +1,3 @@
+## DGenerator
+
+Création et composition de génératrices synchrones ou asynchrones pour produire, transformer, filtrer, réduire et consommer des séquences de valeurs.

package/docs/API/10-lang/10-number/10-betweenThan.ts

@@ -0,0 +1,43 @@
+/**
+ * @title DNumber.betweenThan
+ *
+ * Vérifier qu’un nombre est strictement compris entre deux bornes.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const result = DNumber.betweenThan(5, 1, 10);
+// Appel classique : tester directement une valeur.
+// La valeur obtenue est true, car 5 est strictement entre 1 et 10.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: number;
+
+if (DNumber.betweenThan(value, 1, 10)) {
+	type _CheckIfValue = DCommon.ExpectType<
+		typeof value,
+		number & DNumber.GreaterThan<1> & DNumber.LessThan<10>,
+		"strict"
+	>;
+	const sum = DNumber.sum([value]);
+	type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;
+}
+
+// Appel curifié : passer le predicate directement à DCommon.when.
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.betweenThan(1, 10),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<
+				typeof value,
+				number & DNumber.GreaterThan<1> & DNumber.LessThan<10>,
+				"strict"
+			>;
+
+			return DNumber.sum([value]);
+		},
+	),
+);
+// La valeur est le nombre d’entrée lorsqu’il satisfait l’intervalle.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, number, "strict">;

package/docs/API/10-lang/10-number/10-betweenThanOrEqual.ts

@@ -0,0 +1,43 @@
+/**
+ * @title DNumber.betweenThanOrEqual
+ *
+ * Vérifier qu’un nombre appartient à un intervalle fermé.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const result = DNumber.betweenThanOrEqual(5, 5, 10);
+// Appel classique : tester directement une valeur.
+// La valeur obtenue est true, car les bornes sont inclusives.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: number;
+
+if (DNumber.betweenThanOrEqual(value, 5, 10)) {
+	type _CheckIfValue = DCommon.ExpectType<
+		typeof value,
+		number & DNumber.GreaterThanOrEqual<5> & DNumber.LessThanOrEqual<10>,
+		"strict"
+	>;
+	const sum = DNumber.sum([value]);
+	type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;
+}
+
+// Appel curifié : passer le predicate directement à DCommon.when.
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.betweenThanOrEqual(5, 10),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<
+				typeof value,
+				number & DNumber.GreaterThanOrEqual<5> & DNumber.LessThanOrEqual<10>,
+				"strict"
+			>;
+
+			return DNumber.sum([value]);
+		},
+	),
+);
+// La valeur est le nombre d’entrée lorsqu’il satisfait l’intervalle.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, number, "strict">;