@nuxt/cli-nightly 3.29.4-20251009-171833-0915ec9 → 3.29.4-20251021-190716-bbf70fc

package/dist/dev-L7lhoThJ.mjs

@@ -0,0 +1,438 @@
+import { t as clearBuildDir } from "./fs-ewAp6tjM.mjs";
+import { t as loadKit } from "./kit-xFxVGu6d.mjs";
+import { a as writeNuxtManifest, i as resolveNuxtManifest, n as loadNuxtManifest } from "./nuxt-Cc9ZTk7m.mjs";
+import process from "node:process";
+import { provider } from "std-env";
+import { pathToFileURL } from "node:url";
+import defu from "defu";
+import { listen } from "listhen";
+import { Server } from "node:http";
+import { cleanSocket, getSocketAddress } from "get-port-please";
+import EventEmitter from "node:events";
+import { existsSync, statSync, watch } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { resolveModulePath } from "exsolve";
+import { toNodeListener } from "h3";
+import { resolve } from "pathe";
+import { debounce } from "perfect-debounce";
+import { joinURL } from "ufo";
+import { Youch } from "youch";
+
+//#region ../nuxi/src/dev/socket.ts
+function formatSocketURL(socketPath, ssl = false) {
+	return `${ssl ? "https" : "http"}+unix://${process.platform === "win32" ? encodeURIComponent(socketPath) : socketPath.replace(/\//g, "%2F")}`;
+}
+function isSocketURL(url) {
+	return url.startsWith("http+unix://") || url.startsWith("https+unix://");
+}
+function parseSocketURL(url) {
+	if (!isSocketURL(url)) throw new Error(`Invalid socket URL: ${url}`);
+	const ssl = url.startsWith("https+unix://");
+	const path = url.slice(ssl ? 13 : 12);
+	return {
+		socketPath: decodeURIComponent(path.replace(/%2F/g, "/")),
+		protocol: ssl ? "https" : "http"
+	};
+}
+async function createSocketListener(handler, proxyAddress) {
+	const socketPath = getSocketAddress({
+		name: "nuxt-dev",
+		random: true
+	});
+	const server = new Server(handler);
+	await cleanSocket(socketPath);
+	await new Promise((resolve$1) => server.listen({ path: socketPath }, resolve$1));
+	const url = formatSocketURL(socketPath);
+	return {
+		url,
+		address: {
+			address: "localhost",
+			port: 3e3,
+			...proxyAddress,
+			socketPath
+		},
+		async close() {
+			try {
+				server.removeAllListeners();
+				await new Promise((resolve$1, reject) => server.close((err) => err ? reject(err) : resolve$1()));
+			} finally {
+				await cleanSocket(socketPath);
+			}
+		},
+		getURLs: async () => [{
+			url,
+			type: "network"
+		}],
+		https: false,
+		server
+	};
+}
+
+//#endregion
+//#region ../nuxi/src/dev/error.ts
+async function renderError(req, res, error) {
+	if (res.headersSent) {
+		if (!res.writableEnded) res.end();
+		return;
+	}
+	const youch = new Youch();
+	res.statusCode = 500;
+	res.setHeader("Content-Type", "text/html");
+	const html = await youch.toHTML(error, { request: {
+		url: req.url,
+		method: req.method,
+		headers: req.headers
+	} });
+	res.end(html);
+}
+
+//#endregion
+//#region ../nuxi/src/dev/utils.ts
+const RESTART_RE = /^(?:nuxt\.config\.[a-z0-9]+|\.nuxtignore|\.nuxtrc|\.config\/nuxt(?:\.config)?\.[a-z0-9]+)$/;
+var FileChangeTracker = class {
+	mtimes = /* @__PURE__ */ new Map();
+	shouldEmitChange(filePath) {
+		try {
+			const currentMtime = statSync(filePath).mtimeMs;
+			const lastMtime = this.mtimes.get(filePath);
+			this.mtimes.set(filePath, currentMtime);
+			return lastMtime === void 0 || currentMtime !== lastMtime;
+		} catch {
+			this.mtimes.delete(filePath);
+			return true;
+		}
+	}
+};
+var NuxtDevServer = class extends EventEmitter {
+	_handler;
+	_distWatcher;
+	_configWatcher;
+	_currentNuxt;
+	_loadingMessage;
+	_loadingError;
+	_fileChangeTracker = new FileChangeTracker();
+	cwd;
+	loadDebounced;
+	handler;
+	listener;
+	constructor(options) {
+		super();
+		this.options = options;
+		this.loadDebounced = debounce(this.load);
+		let _initResolve;
+		const _initPromise = new Promise((resolve$1) => {
+			_initResolve = resolve$1;
+		});
+		this.once("ready", () => {
+			_initResolve();
+		});
+		this.cwd = options.cwd;
+		this.handler = async (req, res) => {
+			if (this._loadingError) {
+				this._renderError(req, res);
+				return;
+			}
+			await _initPromise;
+			if (this._handler) this._handler(req, res);
+			else this._renderLoadingScreen(req, res);
+		};
+		this.listener = void 0;
+	}
+	_renderError(req, res) {
+		renderError(req, res, this._loadingError);
+	}
+	async _renderLoadingScreen(req, res) {
+		if (res.headersSent) {
+			if (!res.writableEnded) res.end();
+			return;
+		}
+		res.statusCode = 503;
+		res.setHeader("Content-Type", "text/html");
+		const loadingTemplate = this.options.loadingTemplate || this._currentNuxt?.options.devServer.loadingTemplate || await resolveLoadingTemplate(this.cwd);
+		res.end(loadingTemplate({ loading: this._loadingMessage || "Loading..." }));
+	}
+	async init() {
+		await this.load();
+		this._watchConfig();
+	}
+	closeWatchers() {
+		this._distWatcher?.close();
+		this._configWatcher?.();
+	}
+	async load(reload, reason) {
+		try {
+			this.closeWatchers();
+			await this._load(reload, reason);
+			this._watchConfig();
+			this._loadingError = void 0;
+		} catch (error) {
+			console.error(`Cannot ${reload ? "restart" : "start"} nuxt: `, error);
+			this._handler = void 0;
+			this._loadingError = error;
+			this._loadingMessage = "Error while loading Nuxt. Please check console and fix errors.";
+			this.emit("loading:error", error);
+		}
+	}
+	async close() {
+		if (this._currentNuxt) await this._currentNuxt.close();
+	}
+	async _load(reload, reason) {
+		const action = reload ? "Restarting" : "Starting";
+		this._loadingMessage = `${reason ? `${reason}. ` : ""}${action} Nuxt...`;
+		this._handler = void 0;
+		this.emit("loading", this._loadingMessage);
+		if (reload) console.info(this._loadingMessage);
+		await this.close();
+		const kit = await loadKit(this.options.cwd);
+		const devServerDefaults = resolveDevServerDefaults({}, await this.listener.getURLs().then((r) => r.map((r$1) => r$1.url)));
+		this._currentNuxt = await kit.loadNuxt({
+			cwd: this.options.cwd,
+			dev: true,
+			ready: false,
+			envName: this.options.envName,
+			dotenv: {
+				cwd: this.options.cwd,
+				fileName: this.options.dotenv.fileName
+			},
+			defaults: defu(this.options.defaults, devServerDefaults),
+			overrides: {
+				logLevel: this.options.logLevel,
+				...this.options.overrides,
+				vite: {
+					clearScreen: this.options.clear,
+					...this.options.overrides.vite
+				}
+			}
+		});
+		if (!process.env.NUXI_DISABLE_VITE_HMR) this._currentNuxt.hooks.hook("vite:extend", ({ config }) => {
+			if (config.server) config.server.hmr = {
+				protocol: void 0,
+				...config.server.hmr,
+				port: void 0,
+				host: void 0,
+				server: this.listener.server
+			};
+		});
+		this._currentNuxt.hooks.hookOnce("close", () => {
+			this.listener.server.removeAllListeners("upgrade");
+		});
+		if (!reload) {
+			const previousManifest = await loadNuxtManifest(this._currentNuxt.options.buildDir);
+			const newManifest = resolveNuxtManifest(this._currentNuxt);
+			const promise = writeNuxtManifest(this._currentNuxt, newManifest);
+			this._currentNuxt.hooks.hookOnce("ready", async () => {
+				await promise;
+			});
+			if (previousManifest && newManifest && previousManifest._hash !== newManifest._hash) await clearBuildDir(this._currentNuxt.options.buildDir);
+		}
+		await this._currentNuxt.ready();
+		const unsub = this._currentNuxt.hooks.hook("restart", async (options) => {
+			unsub();
+			if (options?.hard) {
+				this.emit("restart");
+				return;
+			}
+			await this.load(true);
+		});
+		if (this._currentNuxt.server && "upgrade" in this._currentNuxt.server) this.listener.server.on("upgrade", (req, socket, head) => {
+			const nuxt = this._currentNuxt;
+			if (!nuxt || !nuxt.server) return;
+			const viteHmrPath = joinURL(nuxt.options.app.baseURL.startsWith("./") ? nuxt.options.app.baseURL.slice(1) : nuxt.options.app.baseURL, nuxt.options.app.buildAssetsDir);
+			if (req.url?.startsWith(viteHmrPath)) return;
+			nuxt.server.upgrade(req, socket, head);
+		});
+		await this._currentNuxt.hooks.callHook("listen", this.listener.server, this.listener);
+		const addr = this.listener.address;
+		this._currentNuxt.options.devServer.host = addr.address;
+		this._currentNuxt.options.devServer.port = addr.port;
+		this._currentNuxt.options.devServer.url = getAddressURL(addr, !!this.listener.https);
+		this._currentNuxt.options.devServer.https = this.options.devContext.proxy?.https;
+		if (this.listener.https && !process.env.NODE_TLS_REJECT_UNAUTHORIZED) console.warn("You might need `NODE_TLS_REJECT_UNAUTHORIZED=0` environment variable to make https work.");
+		await Promise.all([kit.writeTypes(this._currentNuxt).catch(console.error), kit.buildNuxt(this._currentNuxt)]);
+		if (!this._currentNuxt.server) throw new Error("Nitro server has not been initialized.");
+		const distDir = resolve(this._currentNuxt.options.buildDir, "dist");
+		await mkdir(distDir, { recursive: true });
+		this._distWatcher = watch(distDir);
+		this._distWatcher.on("change", (_event, file) => {
+			if (!this._fileChangeTracker.shouldEmitChange(resolve(distDir, file || ""))) return;
+			this.loadDebounced(true, ".nuxt/dist directory has been removed");
+		});
+		this._handler = toNodeListener(this._currentNuxt.server.app);
+		this.emit("ready", "socketPath" in addr ? formatSocketURL(addr.socketPath, !!this.listener.https) : `http://127.0.0.1:${addr.port}`);
+	}
+	_watchConfig() {
+		this._configWatcher = createConfigWatcher(this.cwd, this.options.dotenv.fileName, () => this.emit("restart"), (file) => this.loadDebounced(true, `${file} updated`));
+	}
+};
+function getAddressURL(addr, https) {
+	const proto = https ? "https" : "http";
+	let host = addr.address.includes(":") ? `[${addr.address}]` : addr.address;
+	if (host === "[::]") host = "localhost";
+	const port = addr.port || 3e3;
+	return `${proto}://${host}:${port}/`;
+}
+function resolveDevServerOverrides(listenOptions) {
+	if (listenOptions.public || provider === "codesandbox") return {
+		devServer: { cors: { origin: "*" } },
+		vite: { server: { allowedHosts: true } }
+	};
+	return {};
+}
+function resolveDevServerDefaults(listenOptions, urls = []) {
+	const defaultConfig = {};
+	if (urls) defaultConfig.vite = { server: { allowedHosts: urls.filter((u) => !isSocketURL(u)).map((u) => new URL(u).hostname) } };
+	if (listenOptions.hostname) {
+		defaultConfig.devServer = { cors: { origin: [`${listenOptions.https ? "https" : "http"}://${listenOptions.hostname}`, ...urls] } };
+		defaultConfig.vite = defu(defaultConfig.vite, { server: { allowedHosts: [listenOptions.hostname] } });
+	}
+	return defaultConfig;
+}
+function createConfigWatcher(cwd, dotenvFileName = ".env", onRestart, onReload) {
+	const configWatcher = watch(cwd);
+	let configDirWatcher = existsSync(resolve(cwd, ".config")) ? createConfigDirWatcher(cwd, onReload) : void 0;
+	const dotenvFileNames = new Set(Array.isArray(dotenvFileName) ? dotenvFileName : [dotenvFileName]);
+	const fileWatcher = new FileChangeTracker();
+	configWatcher.on("change", (_event, file) => {
+		if (!fileWatcher.shouldEmitChange(resolve(cwd, file))) return;
+		if (dotenvFileNames.has(file)) onRestart();
+		if (RESTART_RE.test(file)) onReload(file);
+		if (file === ".config") configDirWatcher ||= createConfigDirWatcher(cwd, onReload);
+	});
+	return () => {
+		configWatcher.close();
+		configDirWatcher?.();
+	};
+}
+function createConfigDirWatcher(cwd, onReload) {
+	const configDir = resolve(cwd, ".config");
+	const fileWatcher = new FileChangeTracker();
+	const configDirWatcher = watch(configDir);
+	configDirWatcher.on("change", (_event, file) => {
+		if (!fileWatcher.shouldEmitChange(resolve(configDir, file))) return;
+		if (RESTART_RE.test(file)) onReload(file);
+	});
+	return () => configDirWatcher.close();
+}
+async function resolveLoadingTemplate(cwd) {
+	return (await import(pathToFileURL(resolveModulePath("@nuxt/ui-templates", { from: resolveModulePath("nuxt", {
+		from: cwd,
+		try: true
+	}) || cwd })).href)).loading || ((params) => `<h2>${params.loading}</h2>`);
+}
+
+//#endregion
+//#region ../nuxi/src/dev/index.ts
+const start = Date.now();
+process.env.NODE_ENV = "development";
+var IPC = class {
+	enabled = !!process.send && !process.title?.includes("vitest") && process.env.__NUXT__FORK;
+	constructor() {
+		if (this.enabled) process.once("unhandledRejection", (reason) => {
+			this.send({
+				type: "nuxt:internal:dev:rejection",
+				message: reason instanceof Error ? reason.toString() : "Unhandled Rejection"
+			});
+			process.exit();
+		});
+		process.on("message", (message) => {
+			if (message.type === "nuxt:internal:dev:context") initialize(message.context, {}, message.socket ? void 0 : true);
+		});
+		this.send({ type: "nuxt:internal:dev:fork-ready" });
+	}
+	send(message) {
+		if (this.enabled) process.send?.(message);
+	}
+};
+const ipc = new IPC();
+async function initialize(devContext, ctx = {}, _listenOptions) {
+	const devServerOverrides = resolveDevServerOverrides({ public: devContext.public });
+	const devServerDefaults = resolveDevServerDefaults({
+		hostname: devContext.hostname,
+		https: devContext.proxy?.https
+	}, devContext.publicURLs);
+	const devServer = new NuxtDevServer({
+		cwd: devContext.cwd,
+		overrides: defu(ctx.data?.overrides, { extends: devContext.args.extends }, devServerOverrides),
+		defaults: devServerDefaults,
+		logLevel: devContext.args.logLevel,
+		clear: devContext.args.clear,
+		dotenv: {
+			cwd: devContext.cwd,
+			fileName: devContext.args.dotenv
+		},
+		envName: devContext.args.envName,
+		devContext: { proxy: devContext.proxy }
+	});
+	const listenOptions = _listenOptions === true || process.env._PORT ? {
+		port: process.env._PORT ?? 0,
+		hostname: "127.0.0.1",
+		showURL: false
+	} : _listenOptions;
+	devServer.listener = listenOptions ? await listen(devServer.handler, listenOptions) : await createSocketListener(devServer.handler, devContext.proxy?.addr);
+	if (process.env.DEBUG) console.debug(`Using ${listenOptions ? "network" : "socket"} listener for Nuxt dev server.`);
+	devServer.listener._url = devServer.listener.url;
+	if (devContext.proxy?.url) devServer.listener.url = devContext.proxy.url;
+	if (devContext.proxy?.urls) {
+		const _getURLs = devServer.listener.getURLs.bind(devServer.listener);
+		devServer.listener.getURLs = async () => Array.from(new Set([...devContext.proxy?.urls || [], ...await _getURLs()]));
+	}
+	let address;
+	if (ipc.enabled) {
+		devServer.on("loading:error", (_error) => {
+			ipc.send({
+				type: "nuxt:internal:dev:loading:error",
+				error: {
+					message: _error.message,
+					stack: _error.stack,
+					name: _error.name,
+					code: "code" in _error ? _error.code : void 0
+				}
+			});
+		});
+		devServer.on("loading", (message) => {
+			ipc.send({
+				type: "nuxt:internal:dev:loading",
+				message
+			});
+		});
+		devServer.on("restart", () => {
+			ipc.send({ type: "nuxt:internal:dev:restart" });
+		});
+		devServer.on("ready", (payload) => {
+			ipc.send({
+				type: "nuxt:internal:dev:ready",
+				address: payload
+			});
+		});
+	} else devServer.on("ready", (payload) => {
+		address = payload;
+	});
+	await devServer.init();
+	if (process.env.DEBUG) console.debug(`Dev server (internal) initialized in ${Date.now() - start}ms`);
+	return {
+		listener: devServer.listener,
+		close: async () => {
+			devServer.closeWatchers();
+			await devServer.close();
+		},
+		onReady: (callback) => {
+			if (address) callback(address);
+			else devServer.once("ready", (payload) => callback(payload));
+		},
+		onRestart: (callback) => {
+			let restarted = false;
+			function restart() {
+				if (!restarted) {
+					restarted = true;
+					callback(devServer);
+				}
+			}
+			devServer.once("restart", restart);
+			process.once("uncaughtException", restart);
+			process.once("unhandledRejection", restart);
+		}
+	};
+}
+
+//#endregion
+export { parseSocketURL as a, isSocketURL as i, resolveLoadingTemplate as n, renderError as r, initialize as t };

package/dist/dev-child-CSiX6Uyv.mjs

@@ -0,0 +1,37 @@
+import { a as legacyRootDirArgs, n as dotEnvArgs, o as logLevelArgs, r as envNameArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import { isTest } from "std-env";
+import { resolve } from "pathe";
+
+//#region ../nuxi/src/commands/dev-child.ts
+var dev_child_default = defineCommand({
+	meta: {
+		name: "_dev",
+		description: "Run Nuxt development server (internal command to start child process)"
+	},
+	args: {
+		...cwdArgs,
+		...logLevelArgs,
+		...envNameArgs,
+		...dotEnvArgs,
+		...legacyRootDirArgs,
+		clear: {
+			type: "boolean",
+			description: "Clear console on restart",
+			negativeDescription: "Disable clear console on restart"
+		}
+	},
+	async run(ctx) {
+		if (!process.send && !isTest) console.warn("`nuxi _dev` is an internal command and should not be used directly. Please use `nuxi dev` instead.");
+		const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
+		const { initialize } = await import("./dev-CnQwDUaD.mjs");
+		await initialize({
+			cwd,
+			args: ctx.args
+		}, ctx);
+	}
+});
+
+//#endregion
+export { dev_child_default as default };

package/dist/devtools-BLGzUSNU.mjs

@@ -0,0 +1,44 @@
+import { a as legacyRootDirArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
+import { t as logger } from "./logger-Dk0gkCkX.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import { resolve } from "pathe";
+import { x } from "tinyexec";
+
+//#region ../nuxi/src/commands/devtools.ts
+var devtools_default = defineCommand({
+	meta: {
+		name: "devtools",
+		description: "Enable or disable devtools in a Nuxt project"
+	},
+	args: {
+		...cwdArgs,
+		command: {
+			type: "positional",
+			description: "Command to run",
+			valueHint: "enable|disable"
+		},
+		...legacyRootDirArgs
+	},
+	async run(ctx) {
+		const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
+		if (!["enable", "disable"].includes(ctx.args.command)) {
+			logger.error(`Unknown command \`${ctx.args.command}\`.`);
+			process.exit(1);
+		}
+		await x("npx", [
+			"@nuxt/devtools-wizard@latest",
+			ctx.args.command,
+			cwd
+		], {
+			throwOnError: true,
+			nodeOptions: {
+				stdio: "inherit",
+				cwd
+			}
+		});
+	}
+});
+
+//#endregion
+export { devtools_default as default };

package/dist/env-Dz4K_NkM.mjs

@@ -0,0 +1,12 @@
+import { t as logger } from "./logger-Dk0gkCkX.mjs";
+import process from "node:process";
+
+//#region ../nuxi/src/utils/env.ts
+function overrideEnv(targetEnv) {
+	const currentEnv = process.env.NODE_ENV;
+	if (currentEnv && currentEnv !== targetEnv) logger.warn(`Changing \`NODE_ENV\` from \`${currentEnv}\` to \`${targetEnv}\`, to avoid unintended behavior.`);
+	process.env.NODE_ENV = targetEnv;
+}
+
+//#endregion
+export { overrideEnv as t };

package/dist/fs-ewAp6tjM.mjs

@@ -0,0 +1,40 @@
+import { t as logger } from "./logger-Dk0gkCkX.mjs";
+import { existsSync, promises } from "node:fs";
+import { join } from "pathe";
+
+//#region ../nuxi/src/utils/fs.ts
+async function clearDir(path, exclude) {
+	if (!exclude) await promises.rm(path, {
+		recursive: true,
+		force: true
+	});
+	else if (existsSync(path)) {
+		const files = await promises.readdir(path);
+		await Promise.all(files.map(async (name) => {
+			if (!exclude.includes(name)) await promises.rm(join(path, name), {
+				recursive: true,
+				force: true
+			});
+		}));
+	}
+	await promises.mkdir(path, { recursive: true });
+}
+function clearBuildDir(path) {
+	return clearDir(path, [
+		"cache",
+		"analyze",
+		"nuxt.json"
+	]);
+}
+async function rmRecursive(paths) {
+	await Promise.all(paths.filter((p) => typeof p === "string").map(async (path) => {
+		logger.debug("Removing recursive path", path);
+		await promises.rm(path, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+	}));
+}
+
+//#endregion
+export { clearDir as n, rmRecursive as r, clearBuildDir as t };

package/dist/generate-CGy3-x2K.mjs

@@ -0,0 +1,35 @@
+import { a as legacyRootDirArgs, i as extendsArgs, n as dotEnvArgs, o as logLevelArgs, r as envNameArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
+import "./logger-Dk0gkCkX.mjs";
+import "./fs-ewAp6tjM.mjs";
+import "./kit-xFxVGu6d.mjs";
+import "./env-Dz4K_NkM.mjs";
+import "./banner-CqfM_0Qo.mjs";
+import { t as build_default } from "./build-BSxJLNs_.mjs";
+import { defineCommand } from "citty";
+
+//#region ../nuxi/src/commands/generate.ts
+var generate_default = defineCommand({
+	meta: {
+		name: "generate",
+		description: "Build Nuxt and prerender all routes"
+	},
+	args: {
+		...cwdArgs,
+		...logLevelArgs,
+		preset: {
+			type: "string",
+			description: "Nitro server preset"
+		},
+		...dotEnvArgs,
+		...envNameArgs,
+		...extendsArgs,
+		...legacyRootDirArgs
+	},
+	async run(ctx) {
+		ctx.args.prerender = true;
+		await build_default.run(ctx);
+	}
+});
+
+//#endregion
+export { generate_default as default };

package/dist/index.d.mts

@@ -1,23 +1,14 @@
-import * as citty from 'citty';
-
-declare const main: citty.CommandDef<{
-    command: {
-        type: "positional";
-        required: false;
-    };
-    cwd: {
-        readonly type: "string";
-        readonly description: "Specify the working directory";
-        readonly valueHint: "directory";
-        readonly default: ".";
-    };
-}>;
+import { CommandDef } from "citty";
 
+//#region src/main.d.ts
+declare const main: CommandDef<any>;
+//#endregion
+//#region src/run.d.ts
 declare const runMain: () => Promise<void>;
 declare function runCommand(name: string, argv?: string[], data?: {
-    overrides?: Record<string, any>;
+  overrides?: Record<string, any>;
 }): Promise<{
-    result: unknown;
+  result: unknown;
 }>;
-
-export { main, runCommand, runMain };
+//#endregion
+export { main, runCommand, runMain };