nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/cli/sysexits.js

@@ -0,0 +1,34 @@
+//#region src/cli/sysexits.ts
+/**
+* Codes de sortie standardisés — convention BSD `sysexits.h` (FreeBSD
+* `sysexits(3)`). Ce n'est PAS un RFC, mais le standard de facto Unix pour des
+* exit codes porteurs de sens, au-delà du binaire POSIX `0`/non-zéro. Permet à un
+* script appelant de distinguer un « mauvais usage » d'une « erreur interne » ou
+* d'une « config invalide ».
+*
+* Nodefony n'utilise qu'un sous-ensemble pertinent côté CLI ; les valeurs sont
+* celles de `sysexits.h` (ne pas les renuméroter).
+*/
+let SysExit = /* @__PURE__ */ function(SysExit) {
+	/** Succès. */
+	SysExit[SysExit["OK"] = 0] = "OK";
+	/** Mauvais usage : commande inconnue, arguments/options invalides. */
+	SysExit[SysExit["USAGE"] = 64] = "USAGE";
+	/** Donnée d'entrée incorrecte (format/contenu). */
+	SysExit[SysExit["DATAERR"] = 65] = "DATAERR";
+	/** Entrée requise introuvable (fichier/ressource absent). */
+	SysExit[SysExit["NOINPUT"] = 66] = "NOINPUT";
+	/** Service requis indisponible (dépendance non démarrée/enregistrée). */
+	SysExit[SysExit["UNAVAILABLE"] = 69] = "UNAVAILABLE";
+	/** Sortie impossible à créer (dossier cible existant non vide, droits). */
+	SysExit[SysExit["CANTCREAT"] = 73] = "CANTCREAT";
+	/** Erreur interne du logiciel (bug, exception non gérée au boot). */
+	SysExit[SysExit["SOFTWARE"] = 70] = "SOFTWARE";
+	/** Permission refusée : l'appelant est connu, son rôle ne suffit pas. */
+	SysExit[SysExit["NOPERM"] = 77] = "NOPERM";
+	/** Erreur de configuration. */
+	SysExit[SysExit["CONFIG"] = 78] = "CONFIG";
+	return SysExit;
+}({});
+//#endregion
+export { SysExit, SysExit as default };

package/dist/node/cli/tableReport.js

@@ -0,0 +1,184 @@
+import { createPalette, wrap } from "../kernel/checks/report.js";
+//#region src/cli/tableReport.ts
+/**
+* Un tableau de données rendu pour un TERMINAL — pur, et borné à sa largeur.
+*
+* 🔴 `console.table` rend toutes les colonnes à leur largeur naturelle, ajoute
+* un index, et entoure chaque valeur de guillemets. Mesuré sur ce dépôt :
+* `nodefony inspect routes` sortait des lignes de **900 colonnes**. Un tableau
+* plus large que l'écran n'est pas un tableau — le terminal le replie, chaque
+* ligne en occupe dix, et l'alignement qui justifiait la forme a disparu.
+*
+* Ce module ne connaît ni le terminal ni les données : la largeur lui est
+* DONNÉE, les colonnes sont dérivées des objets reçus. Il rend des lignes.
+*
+* @module
+*/
+/** En deçà, une colonne ne porte plus d'information — elle porte une ellipse. */
+const MIN_COLUMN = 6;
+/**
+* Au-delà, une colonne n'a pas besoin de plus pour se lire.
+*
+* Sert à décider si un jeu de colonnes TIENT : une colonne de chemins longs ne
+* réclame pas soixante caractères pour être utile, et la compter à sa largeur
+* naturelle ferait renoncer à des colonnes qui tenaient très bien.
+*/
+const USABLE_WIDTH = 28;
+/** Ce qu'une cellule doit à son lecteur : lisible, jamais du JSON brut. */
+function formatCell(value) {
+	if (value === null || value === void 0) return "—";
+	if (typeof value === "boolean") return value ? "oui" : "non";
+	if (Array.isArray(value)) return value.map((v) => formatCell(v)).join(", ");
+	if (typeof value === "object") {
+		const clés = Object.keys(value);
+		return clés.length ? `{${clés.join(", ")}}` : "{}";
+	}
+	return String(value);
+}
+/** Tronque en gardant une marque de troncature — jamais en silence. */
+function tronquer(text, width) {
+	if (text.length <= width) return text;
+	return width <= 1 ? "…" : `${text.slice(0, width - 1)}…`;
+}
+/**
+* Les colonnes présentes dans les données, dans l'ordre de rencontre.
+*
+* @param rows - les lignes.
+* @returns les noms de colonnes, sans doublon.
+*/
+function columnsOf(rows) {
+	const vues = [];
+	for (const row of rows) for (const clé of Object.keys(row)) if (!vues.includes(clé)) vues.push(clé);
+	return vues;
+}
+/**
+* Répartit la largeur disponible entre les colonnes.
+*
+* Chacune reçoit ce qu'elle demande tant que le total tient. Au-delà, on rogne
+* les PLUS LARGES d'abord, par paliers : rogner uniformément punirait une
+* colonne de six caractères autant qu'une de soixante, et c'est la première
+* qu'on rend illisible.
+*
+* @param requested - largeur idéale de chaque colonne.
+* @param available - place totale pour les contenus (séparateurs déduits).
+* @returns la largeur retenue pour chaque colonne, dans le même ordre.
+*/
+function repartir(requested, available) {
+	const selected = [...requested];
+	let total = selected.reduce((n, x) => n + x, 0);
+	if (total <= available) return selected;
+	while (total > available) {
+		let plusLarge = 0;
+		for (let i = 1; i < selected.length; i++) if ((selected[i] ?? 0) > (selected[plusLarge] ?? 0)) plusLarge = i;
+		if ((selected[plusLarge] ?? 0) <= MIN_COLUMN) break;
+		selected[plusLarge] = (selected[plusLarge] ?? 0) - 1;
+		total -= 1;
+	}
+	return selected;
+}
+/**
+* Rend les données en FICHES — une entrée par bloc `clé : valeur`.
+*
+* C'est le repli quand un tableau ne peut plus tenir : trop de colonnes, ou un
+* terminal trop étroit. Une fiche reste lisible à n'importe quelle largeur, là
+* où un tableau comprimé ne dit plus rien.
+*
+* @param rows - les lignes.
+* @param columns - les colonnes à rendre.
+* @param width - largeur utile.
+* @param p - la peinture.
+* @returns les lignes à écrire.
+*/
+function fiches(rows, columns, width, p) {
+	const lines = [];
+	const col = Math.min(Math.max(...columns.map((c) => c.length)), Math.max(MIN_COLUMN, Math.floor(width / 3)));
+	for (const [i, row] of rows.entries()) {
+		if (i > 0) lines.push("");
+		for (const clé of columns) {
+			const value = formatCell(row[clé]);
+			lines.push(`  ${p.dim(tronquer(clé, col).padEnd(col))}  ${tronquer(value, Math.max(1, width - col - 4))}`);
+		}
+	}
+	return lines;
+}
+/**
+* Le tableau, ligne par ligne, sans retour chariot final.
+*
+* @param rows - les données ; une clé absente d'une ligne rend une cellule vide.
+* @param opts - le décor (largeur, couleur, colonnes retenues).
+* @returns les lignes à écrire, dans l'ordre.
+*/
+function renderTable(rows, opts) {
+	const { width, color } = opts;
+	const p = createPalette(color);
+	if (rows.length === 0) return [];
+	const columns = opts.columns ? [...opts.columns] : columnsOf(rows);
+	if (columns.length === 0) return [];
+	const { kept, constants, omitted } = elaguer(rows, columns, width);
+	const cells = rows.map((row) => kept.map((clé) => formatCell(row[clé])));
+	const requested = kept.map((clé, i) => Math.max(clé.length, ...cells.map((c) => (c[i] ?? "").length)));
+	const separators = 2 * (kept.length - 1) + 2;
+	const available = width - separators;
+	if (available < kept.length * MIN_COLUMN) return fiches(rows, columns, width, p);
+	const selected = repartir(requested, available);
+	const cols = kept;
+	const line = (values, teinte) => `  ${values.map((v, i) => tronquer(v, selected[i] ?? 0).padEnd(selected[i] ?? 0)).join("  ").trimEnd()}`.replace(/^ {2}/u, "  ").split("\n").map((l) => teinte(l)).join("\n");
+	const lines = [line(cols, p.strong)];
+	const occupée = Math.min(width, selected.reduce((n, x) => n + x, 0) + separators);
+	lines.push(p.dim(`  ${"─".repeat(Math.max(0, occupée - 2))}`));
+	for (const c of cells) lines.push(line(c, (t) => t));
+	const notes = [];
+	if (constants.length) notes.push(`identique partout : ${constants.map(({ clé, value }) => `${clé} = ${value}`).join(" · ")}`);
+	if (omitted.length) notes.push(`non affiché faute de place : ${omitted.join(" · ")} (--json)`);
+	for (const note of notes) for (const l of wrap(note, width - 2, "")) lines.push(p.dim(`  ${l}`));
+	return lines;
+}
+/**
+* Écarte les colonnes qui ne DISTINGUENT rien, quand la place manque.
+*
+* Une colonne constante sur l'ensemble des lignes coûte sa largeur et
+* n'apprend rien qu'une phrase ne dise mieux. On ne la retire pourtant que si
+* le tableau ne tient pas sans cela : sur un écran large, tout se voit, et
+* cacher une donnée qu'on aurait pu montrer serait un choix à la place du
+* lecteur.
+*
+* @param rows - les lignes.
+* @param columns - toutes les colonnes candidates.
+* @param width - largeur utile.
+* @returns les colonnes gardées, et celles retirées avec leur valeur unique.
+*/
+function elaguer(rows, columns, width) {
+	const request = (clé) => Math.max(clé.length, ...rows.map((r) => formatCell(r[clé]).length));
+	const fits = (list) => list.reduce((n, clé) => n + Math.min(request(clé), USABLE_WIDTH), 0) + 2 * (list.length - 1) + 2 <= width;
+	if (fits(columns)) return {
+		kept: [...columns],
+		constants: [],
+		omitted: []
+	};
+	const constants = [];
+	let remaining = [];
+	for (const clé of columns) {
+		const values = new Set(rows.map((r) => formatCell(r[clé])));
+		if (values.size === 1 && remaining.length > 0) {
+			constants.push({
+				clé,
+				value: [...values][0] ?? ""
+			});
+			continue;
+		}
+		remaining.push(clé);
+	}
+	const omitted = [];
+	while (remaining.length > 1 && !fits(remaining)) {
+		const last = remaining.at(-1);
+		omitted.unshift(last);
+		remaining = remaining.slice(0, -1);
+	}
+	return {
+		kept: remaining,
+		constants,
+		omitted
+	};
+}
+//#endregion
+export { columnsOf, formatCell, renderTable, repartir };

package/dist/node/cli/usageReport.js

@@ -0,0 +1,144 @@
+import { createPalette, sectionTitle, shouldColorize, usableWidth, wrap } from "../kernel/checks/report.js";
+//#region src/cli/usageReport.ts
+/**
+* La page d'aide d'UNE commande — le socle que toutes les commandes partagent.
+*
+* **Pourquoi un socle.** Le pied de `nodefony --help` promet
+* `nodefony <commande> --help`. Dix commandes ne tenaient pas cette promesse :
+* sept répondaient « option inconnue : --help » avec le code 64, trois
+* l'ignoraient et S'EXÉCUTAIENT — `nodefony stop --help` arrêtait réellement le
+* serveur. Écrire dix pages à la main aurait rendu dix mises en page
+* différentes, dont on n'aurait corrigé qu'une à chaque fois qu'un défaut y
+* serait trouvé : l'aide de `doctor` avait déjà tout ce qu'il faut, et c'est
+* elle qu'on a extraite ici plutôt que de la recopier.
+*
+* **Le rendu est PUR** ({@link renderUsage}) : la largeur et les couleurs lui
+* sont DONNÉES. C'est ce qui le rend éprouvable ailleurs que dans le terminal
+* où il tourne — donc en intégration continue, où il n'y en a pas.
+*
+* **Ce qu'une page doit dire**, et dans cet ordre : ce que la commande fait,
+* comment on l'appelle, ce que chaque option change, au moins un exemple, et
+* ses codes de sortie. Les deux derniers sont ceux qu'on oublie : un exemple
+* répond plus vite qu'un paragraphe, et personne d'autre ne dit à un script
+* comment lire le retour.
+*
+* @module
+*/
+/** La largeur de la colonne des termes, dans OPTIONS et CODES DE SORTIE. */
+const TERM_COLUMN = 20;
+/**
+* Rend la page complète, retour chariot final compris.
+*
+* @param page - ce qu'il y a à dire.
+* @param p - la peinture (une palette sans couleur rend du texte nu).
+* @param width - la largeur utile, déjà bornée.
+* @returns le texte de la page.
+*/
+function renderUsage(page, p, width = usableWidth(80)) {
+	const out = [];
+	const entry = (term, text, column) => {
+		const margin = " ".repeat(column + 4);
+		const [first, ...rest] = wrap(text, width - margin.length, "");
+		out.push(`  ${p.action(term.padEnd(column, " "))}  ${first ?? ""}`);
+		for (const line of rest) out.push(`${margin}${line}`);
+	};
+	const section = (name) => {
+		const { title, divider } = sectionTitle(name, width);
+		out.push("", `${p.strong(title)}${p.dim(divider)}`, "");
+	};
+	const paragraph = (text) => {
+		for (const line of wrap(text, width - 4, "  ")) out.push(line);
+	};
+	out.push("", `  ${p.strong(page.command)}`);
+	for (const line of wrap(page.tagline, width - 4, "  ")) out.push(p.dim(line));
+	out.push("");
+	const forms = page.synopsis ?? [`${page.command} [options]`];
+	for (const [i, form] of forms.entries()) out.push(i === 0 ? `  usage : ${form}` : `          ${form}`);
+	if (page.aliases?.length) {
+		const alias = `alias : ${page.aliases.join(", ")}`;
+		const inline = `  usage : ${forms[0] ?? ""}        ${alias}`;
+		if (forms.length === 1 && inline.length <= width) out[out.length - 1] = `  usage : ${forms[0]}${p.dim(`        ${alias}`)}`;
+		else out.push(p.dim(`  ${alias}`));
+	}
+	for (const s of page.sections ?? []) {
+		section(s.title);
+		if (s.paragraph) paragraph(s.paragraph);
+		for (const line of s.lines ?? []) out.push(`  ${line}`);
+		for (const e of s.entries ?? []) entry(e.term, e.text, TERM_COLUMN);
+	}
+	if (page.options.length > 0) {
+		section("OPTIONS");
+		const column = Math.min(TERM_COLUMN, Math.max(0, ...page.options.map((o) => o.term.length)));
+		for (const o of page.options) entry(o.term, o.text, column);
+	}
+	if (page.examples.length > 0) {
+		section("EXEMPLES");
+		const widest = Math.max(...page.examples.map((e) => e.term.length));
+		const twoColumns = width - widest - 4 >= 24;
+		for (const e of page.examples) {
+			if (!twoColumns) {
+				out.push(`  ${p.action(e.term)}`);
+				for (const l of wrap(e.text, width - 6, "      ")) out.push(p.dim(l));
+				continue;
+			}
+			const indent = " ".repeat(widest + 4);
+			const [first, ...rest] = wrap(e.text, width - indent.length, "");
+			out.push(`  ${p.action(e.term.padEnd(widest, " "))}  ${p.dim(first ?? "")}`);
+			for (const l of rest) out.push(`${indent}${p.dim(l)}`);
+		}
+	}
+	section("CODES DE SORTIE");
+	const codes = [
+		{
+			term: "0",
+			text: "succès"
+		},
+		...page.exitCodes ?? [],
+		{
+			term: "64",
+			text: "option inconnue ou mauvais usage (EX_USAGE)"
+		}
+	].sort((a, b) => Number(a.term) - Number(b.term));
+	for (const c of codes) entry(c.term, c.text, 4);
+	if (page.footer) {
+		out.push("");
+		for (const line of wrap(page.footer, width - 4, "  ")) out.push(p.dim(line));
+	}
+	out.push("");
+	return `${out.join("\n")}\n`;
+}
+/**
+* Écrit la page sur la sortie standard — la réponse à `--help`.
+*
+* Sur **stdout** et avec le code **0** : `--help` est une réponse, pas une
+* erreur. Un `nodefony env --help | less` doit voir la page, et un script ne
+* doit pas la lire comme un échec.
+*
+* @param page - la page à rendre.
+* @returns le code de sortie, toujours 0.
+*/
+function printUsage(page) {
+	process.stdout.write(renderUsage(page, createPalette(shouldColorize(process.env, Boolean(process.stdout.isTTY))), usableWidth(process.stdout.columns)));
+	return 0;
+}
+/**
+* Écrit un refus PUIS la page, sur la sortie d'erreur.
+*
+* La page suit le refus parce que les deux questions arrivent ensemble : on
+* vient de se tromper de drapeau, et ce qu'on veut lire tout de suite est la
+* liste de ceux qui existent.
+*
+* @param page - la page à rendre.
+* @param message - ce qui a été refusé, sans le nom de la commande.
+* @returns le code de sortie, toujours 64 (EX_USAGE).
+*/
+function printUsageError(page, message) {
+	const p = createPalette(shouldColorize(process.env, Boolean(process.stderr.isTTY)));
+	const width = usableWidth(process.stderr.columns);
+	const name = page.command.replace(/^nodefony\s+/u, "");
+	for (const line of wrap(`${name} : ${message}`, width, "  ")) process.stderr.write(`${p.failure(line)}\n`);
+	process.stderr.write(renderUsage(page, p, width));
+	return 64;
+}
+//#endregion
+export { printUsage, printUsageError, renderUsage };

package/dist/node/colors.js

@@ -0,0 +1,63 @@
+import { styleText } from "node:util";
+//#region src/colors.ts
+const VALID = /* @__PURE__ */ new Set([
+	"reset",
+	"bold",
+	"dim",
+	"italic",
+	"underline",
+	"inverse",
+	"strikethrough",
+	"black",
+	"red",
+	"green",
+	"yellow",
+	"blue",
+	"magenta",
+	"cyan",
+	"white",
+	"gray",
+	"blackBright",
+	"redBright",
+	"greenBright",
+	"yellowBright",
+	"blueBright",
+	"magentaBright",
+	"cyanBright",
+	"whiteBright",
+	"bgBlack",
+	"bgRed",
+	"bgGreen",
+	"bgYellow",
+	"bgBlue",
+	"bgMagenta",
+	"bgCyan",
+	"bgWhite",
+	"bgGray"
+]);
+/** Séquence ANSI de remise à zéro — exposée brute par `clc.reset` (parité cli-color). */
+const RESET = "\x1B[0m";
+/**
+* Construit une `ColorFn` figée pour la liste de styles donnée. Le Proxy ne
+* piège QUE l'accès de propriété (chaînage) — l'appel forward directement vers
+* la fonction cible (aucun surcoût de trap à l'invocation, hot path préservé).
+*/
+function make(styles) {
+	const apply = (s) => {
+		const str = String(s);
+		if (styles.length === 0) return str;
+		try {
+			return styleText(styles, str, { validateStream: false });
+		} catch {
+			return str;
+		}
+	};
+	return new Proxy(apply, { get(target, prop, receiver) {
+		if (prop === "reset") return RESET;
+		if (typeof prop === "string" && VALID.has(prop)) return make([...styles, prop]);
+		return Reflect.get(target, prop, receiver);
+	} });
+}
+const clc = make([]);
+//#endregion
+export { clc as default };

package/dist/node/command/Builder.js

@@ -0,0 +1,153 @@
+import { extend, typeOf } from "../Tools.js";
+import FileClass from "../FileClass.js";
+import Service from "../Service.js";
+import File from "../finder/File.js";
+import fs from "node:fs";
+import path from "node:path";
+import fsp from "node:fs/promises";
+import { Eta } from "eta";
+//#region src/command/Builder.ts
+const etaOptions = {
+	views: process.cwd(),
+	autoEscape: false,
+	useWith: true,
+	cache: false
+};
+var Builder = class extends Service {
+	force = false;
+	command;
+	cli;
+	response = {};
+	debug = false;
+	interactive = false;
+	location = process.cwd();
+	eta = new Eta(etaOptions);
+	constructor(command) {
+		super("Builder", command?.container, command?.notificationsCenter);
+		this.command = command;
+		this.getCliOptions();
+	}
+	getCliOptions() {
+		this.cli = this.command?.cli;
+		this.debug = this.cli?.commander?.opts().debug;
+		this.interactive = this.cli?.commander?.opts().interactive;
+		this.response = extend(true, {}, this.cli?.response || {});
+	}
+	async run(...args) {
+		return Promise.resolve(args);
+	}
+	async generate() {
+		return this.cli?.response;
+	}
+	setLocation(location) {
+		if (location instanceof FileClass) return this.location = location.path;
+		return this.location = path.resolve(location);
+	}
+	async removeInteractivePath(file) {
+		if (!this.command) throw new Error(`Command not found`);
+		await this.command.loadPrompts();
+		const response = await this.command.prompts.confirm({
+			message: `Do You Want Remove : ${file}?`,
+			default: false
+		});
+		if (response) {
+			if (!fs.existsSync(file)) throw new Error(`${file} not exist`);
+			await fsp.rm(file, {
+				recursive: true,
+				force: true
+			});
+		}
+		return response;
+	}
+	async buildSkeleton(skeleton, parse, data) {
+		const skelete = skeleton instanceof FileClass ? skeleton : new FileClass(skeleton);
+		if (skelete.type !== "File") throw new Error(` skeleton must be file !!! : ${skelete.path}`);
+		const skelPath = skelete.path;
+		if (parse) {
+			const src = await fsp.readFile(skelPath, { encoding: "utf8" });
+			return this.eta.renderStringAsync(src, data);
+		}
+		return fsp.readFile(skelPath, { encoding: "utf8" });
+	}
+	async createFile(myPath, skeleton, parse = true, params = {}) {
+		const mode = params.mode || "644";
+		const data = skeleton ? await this.buildSkeleton(skeleton, parse, params) : "";
+		await fsp.writeFile(myPath, data, { mode });
+		return new File(myPath);
+	}
+	async createDirectory(myPath, mode, force = false) {
+		try {
+			await fsp.mkdir(myPath, mode);
+			return new File(myPath);
+		} catch (e) {
+			if (e.code === "EEXIST" && force) return new File(myPath);
+			throw e;
+		}
+	}
+	async build(obj, parent = new File(process.cwd()), force = false) {
+		let child = null;
+		try {
+			if (!(parent instanceof File)) parent = new File(parent instanceof FileClass ? parent.path : parent);
+			if (typeOf(obj) === "array") {
+				for (const element of obj) await this.build(element, parent, force);
+				return child;
+			}
+			if (typeOf(obj) !== "object") {
+				this.log("generate build error arguments: ", "ERROR");
+				return child;
+			}
+			const myobj = obj;
+			const name = myobj.name;
+			const parentPath = parent.path;
+			switch (myobj.type) {
+				case "directory": {
+					const dirPath = path.resolve(parentPath, name);
+					child = await this.createDirectory(dirPath, myobj.params || { mode: 493 }, force);
+					parent.childrens.push(child);
+					this.log(`${force ? "Force Create" : "Create"} Directory: ${child?.name}`);
+					break;
+				}
+				case "file": {
+					const filePath = path.resolve(parentPath, name);
+					await this.createFile(filePath, myobj.skeleton, myobj.parse, myobj.params);
+					this.log(`Create File: ${filePath}`);
+					if (myobj.chmod) await fsp.chmod(filePath, myobj.chmod);
+					child = new File(filePath, parent);
+					parent.childrens.push(child);
+					break;
+				}
+				case "symlink": {
+					const { source, dest } = myobj.params;
+					const sourcePath = path.resolve(parentPath, source);
+					const destPath = path.resolve(parentPath, dest);
+					if (force && fs.existsSync(destPath)) await fsp.unlink(destPath);
+					await fsp.symlink(sourcePath, destPath);
+					this.log(`Create symbolic link: ${name}`);
+					child = new File(destPath, parent);
+					parent.childrens.push(child);
+					break;
+				}
+				case "copy": {
+					const copyParams = myobj.params;
+					const destPath = path.resolve(parentPath, name);
+					await fsp.cp(myobj.path, destPath, {
+						recursive: copyParams?.recurse ?? false,
+						force: true
+					});
+					this.log(`Copy: ${name}`);
+					if (myobj.chmod) await fsp.chmod(destPath, myobj.chmod);
+					child = new File(destPath, parent);
+					parent.childrens.push(child);
+					break;
+				}
+			}
+			if (myobj.childs?.length) await this.build(myobj.childs, child, force);
+		} catch (e) {
+			this.log(e, "ERROR");
+			throw e;
+		}
+		return child;
+	}
+};
+//#endregion
+export { Builder as default };