@rollipop/core 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as __require, t as __export } from "./chunk-BYW8Mqxw.js";
+import { n as __export, r as __require, t as __commonJSMin } from "./chunk-DJulfCLt.js";
 import fs from "node:fs";
 import path from "node:path";
 import { DEV_SERVER_ASSET_PATH, FileStorage, Logger, Logo, chalk, getCachePath } from "@rollipop/common";
@@ -19,6 +19,18 @@ import flowRemoveTypes from "flow-remove-types";
 import * as hermesParser from "hermes-parser";
 import { imageSize } from "image-size";
 import { transform } from "@svgr/core";
+import url from "url";
+import { createDevServerMiddleware } from "@react-native-community/cli-server-api";
+import { createDevMiddleware } from "@react-native/dev-middleware";
+import Fastify from "fastify";
+import http from "node:http";
+import EventEmitter from "node:events";
+import { SourceMapConsumer } from "source-map";
+import fp from "fastify-plugin";
+import { asConst } from "json-schema-to-ts";
+import mime from "mime";
+import Ajv from "ajv";
+import * as ws from "ws";
 import * as c12 from "c12";
 
 //#region src/utils/build-options.ts
@@ -35,7 +47,7 @@ function resolveBuildOptions(projectRoot, buildOptions) {
 
 //#endregion
 //#region src/constants.ts
-const ROLLIPOP_VERSION = "0.1.0-alpha.1";
+const ROLLIPOP_VERSION = "0.1.0-alpha.2";
 const GLOBAL_IDENTIFIER = "__ROLLIPOP_GLOBAL__";
 /**
 * Unlike the Metro bundler configuration, this prioritizes resolving module(ESM) fields first.
@@ -134,7 +146,7 @@ function createId(config, buildOptions) {
 
 //#endregion
 //#region src/logger.ts
-const logger = new Logger("bundler");
+const logger$1 = new Logger("bundler");
 
 //#endregion
 //#region src/core/cache/file-system-cache.ts
@@ -142,7 +154,7 @@ var FileSystemCache = class {
 	constructor(cacheDirectory) {
 		this.cacheDirectory = cacheDirectory;
 		this.ensureCacheDirectory();
-		logger.debug("cache directory:", cacheDirectory);
+		logger$1.debug("cache directory:", cacheDirectory);
 	}
 	ensureCacheDirectory() {
 		if (!fs.existsSync(this.cacheDirectory)) fs.mkdirSync(this.cacheDirectory, { recursive: true });
@@ -158,7 +170,7 @@ var FileSystemCache = class {
 		try {
 			fs.writeFileSync(path.join(this.cacheDirectory, key), value);
 		} catch {
-			logger.error("Failed to write cache file", key);
+			logger$1.error("Failed to write cache file", key);
 		}
 	}
 	clear() {
@@ -483,7 +495,7 @@ function progressBar(reporter, context, label) {
 					renderProgress(id, totalModules, transformedModules);
 					break;
 				case Boolean(flags & ProgressFlags.WATCH_CHANGE):
-					logger.debug("Transformed changed file", { id });
+					logger$1.debug("Transformed changed file", { id });
 					break;
 			}
 		},
@@ -495,12 +507,12 @@ function progressBar(reporter, context, label) {
 function compat(reporter) {
 	return withReporter(reporter, {
 		onStart() {
-			logger.info("Build started...");
+			logger$1.info("Build started...");
 		},
 		onEnd({ totalModules, duration }) {
 			const time = chalk.blue(`${duration.toFixed(2)}ms`);
 			const modules = chalk.blue(`(${totalModules} modules)`);
-			logger.info(`Build finished in ${time} ${modules}`);
+			logger$1.info(`Build finished in ${time} ${modules}`);
 		}
 	});
 }
@@ -906,14 +918,14 @@ function getCacheKey(id, buildHash) {
 /**
 * Enhance a plugin to cache the result. (transform hook only)
 */
-function cacheable(plugin) {
-	const originalTransform = plugin.transform;
-	if (typeof originalTransform === "function") plugin.transform = function(code, id, meta) {
+function cacheable(plugin$3) {
+	const originalTransform = plugin$3.transform;
+	if (typeof originalTransform === "function") plugin$3.transform = function(code, id, meta) {
 		const moduleInfo = this.getModuleInfo(id);
 		if (moduleInfo && isCacheHit(moduleInfo.meta)) return;
 		return originalTransform.call(this, code, id, meta);
 	};
-	if (typeof originalTransform === "object") plugin.transform = {
+	if (typeof originalTransform === "object") plugin$3.transform = {
 		...originalTransform,
 		handler(code, id, meta) {
 			const moduleInfo = this.getModuleInfo(id);
@@ -921,7 +933,7 @@ function cacheable(plugin) {
 			return originalTransform.handler.call(this, code, id, meta);
 		}
 	};
-	return plugin;
+	return plugin$3;
 }
 const PluginUtils = Object.freeze({ cacheable });
 
@@ -1260,17 +1272,17 @@ function jsonPlugin() {
 }
 function jsonToEsm(data) {
 	const declarations = [];
-	const exports = [];
+	const exports$1 = [];
 	const exportDefaultMappings = [];
 	Object.entries(data).forEach(([key, value], index) => {
 		const identifier = `_${index}`;
 		declarations.push(`const ${identifier} = ${JSON.stringify(value)};`);
-		exports.push(`export { ${identifier} as "${key}" };`);
+		exports$1.push(`export { ${identifier} as "${key}" };`);
 		exportDefaultMappings.push(`"${key}":${identifier}`);
 	});
 	return [
 		...declarations,
-		...exports,
+		...exports$1,
 		`export default {${exportDefaultMappings.join(",")}};`
 	].join("\n");
 }
@@ -1321,9 +1333,30 @@ var plugins_exports = /* @__PURE__ */ __export({
 	svg: () => svgPlugin
 });
 
+//#endregion
+//#region src/core/plugins/context.ts
+const pluginLogger = new Logger();
+function createPluginContext(name) {
+	return {
+		debug: (log) => {
+			printPluginLog("debug", log, name);
+		},
+		info: (log) => {
+			printPluginLog("info", log, name);
+		},
+		warn: (log) => {
+			printPluginLog("warn", log, name);
+		}
+	};
+}
+function printPluginLog(level, log, pluginName = "unknown") {
+	const pluginLabel = chalk.magenta(`plugin:${pluginName}`);
+	if (typeof log === "string") pluginLogger[level](pluginLabel, log);
+	else pluginLogger[level](pluginLabel, log.stack ?? log.message);
+}
+
 //#endregion
 //#region src/core/rolldown.ts
-const rolldownLogger = new Logger("rolldown");
 resolveRolldownOptions.cache = /* @__PURE__ */ new Map();
 async function resolveRolldownOptions(context, config, buildOptions) {
 	const cachedOptions = resolveRolldownOptions.cache.get(context.id);
@@ -1393,20 +1426,9 @@ async function resolveRolldownOptions(context, config, buildOptions) {
 			pluginTimings: false
 		},
 		logLevel: isDebugEnabled() ? "debug" : "info",
-		onLog(level, log) {
-			const { message, code } = log;
-			const logArgs = [code, message].filter(isNotNil);
-			switch (level) {
-				case "debug":
-					rolldownLogger.debug(...logArgs);
-					break;
-				case "info":
-					rolldownLogger.info(...logArgs);
-					break;
-				case "warn":
-					rolldownLogger.warn(...logArgs);
-					break;
-			}
+		onLog(level, log, defaultHandler) {
+			if (log.code?.startsWith("PLUGIN_")) printPluginLog(level, log, log.plugin);
+			else defaultHandler(level, log);
 		}
 	}, {
 		postBanner: [...getGlobalVariables(dev$1, context.mode)].join("\n"),
@@ -1518,6 +1540,2348 @@ var Bundler = class Bundler {
 	}
 };
 
+//#endregion
+//#region src/server/logger.ts
+const logger = new Logger("dev-server");
+var DevServerLogger = class {
+	level = "trace";
+	trace(...args) {
+		logger.trace(...args);
+	}
+	debug(...args) {
+		logger.debug(...args);
+	}
+	info(...args) {
+		logger.info(...args);
+	}
+	warn(...args) {
+		logger.warn(...args);
+	}
+	error(...args) {
+		logger.error(...args);
+	}
+	silent(...args) {
+		logger.trace(chalk.gray("(silent)"), ...args);
+	}
+	fatal(...args) {
+		logger.error(chalk.magenta("(fatal)"), ...args);
+	}
+	child(_bindings) {
+		return this;
+	}
+};
+
+//#endregion
+//#region src/utils/dev-server.ts
+async function assertDevServerStatus(options) {
+	const { devServerUrl, projectRoot, port } = options;
+	const status = await getDevServerStatus(devServerUrl, projectRoot);
+	let shouldExit = false;
+	switch (status) {
+		case DevServerStatus.MATCHED_SERVER_RUNNING:
+			logger.warn(`A dev server is already running for this project on port ${port}. Exiting.`);
+			shouldExit = true;
+			break;
+		case DevServerStatus.PORT_TAKEN:
+			logger.error(`Another process is running on port ${port}. Please terminate this process and try again, or use another port with "--port".`);
+			shouldExit = true;
+			break;
+	}
+	if (shouldExit) process.exit(1);
+}
+var DevServerStatus = /* @__PURE__ */ function(DevServerStatus$1) {
+	DevServerStatus$1[DevServerStatus$1["NOT_RUNNING"] = 0] = "NOT_RUNNING";
+	DevServerStatus$1[DevServerStatus$1["MATCHED_SERVER_RUNNING"] = 1] = "MATCHED_SERVER_RUNNING";
+	DevServerStatus$1[DevServerStatus$1["PORT_TAKEN"] = 2] = "PORT_TAKEN";
+	DevServerStatus$1[DevServerStatus$1["UNKNOWN"] = 3] = "UNKNOWN";
+	return DevServerStatus$1;
+}(DevServerStatus || {});
+async function getDevServerStatus(devServerUrl, projectRoot) {
+	const { hostname, port } = new URL(devServerUrl);
+	try {
+		if (!await isPortOccupied(hostname, port)) return DevServerStatus.NOT_RUNNING;
+		const statusResponse = await fetch(`${devServerUrl}/status`);
+		return await statusResponse.text() === "packager-status:running" && statusResponse.headers.get("X-React-Native-Project-Root") === projectRoot ? DevServerStatus.MATCHED_SERVER_RUNNING : DevServerStatus.PORT_TAKEN;
+	} catch {
+		return DevServerStatus.UNKNOWN;
+	}
+}
+async function isPortOccupied(host, port) {
+	let result = false;
+	const server = http.createServer();
+	return new Promise((resolve, reject) => {
+		server.once("error", (error) => {
+			server.close();
+			if (error.code === "EADDRINUSE") result = true;
+			else reject(error);
+		});
+		server.once("listening", () => {
+			result = false;
+			server.close();
+		});
+		server.once("close", () => resolve(result));
+		server.listen({
+			host,
+			port
+		});
+	});
+}
+
+//#endregion
+//#region src/utils/bundle.ts
+function getBaseBundleName(name) {
+	return name.replace(/^\//, "").replace(/\.bundle$/, "");
+}
+
+//#endregion
+//#region src/utils/config.ts
+function bindReporter(config, eventSource) {
+	const originalReporter = config.reporter;
+	config.reporter = { update(event) {
+		switch (event.type) {
+			case "bundle_build_started":
+				eventSource.emit("buildStart");
+				break;
+			case "bundle_build_done":
+				eventSource.emit("buildDone");
+				break;
+			case "bundle_build_failed":
+				eventSource.emit("buildFailed", event.error);
+				break;
+			case "transform":
+				eventSource.emit("transform", event.id, event.totalModules, event.transformedModules);
+				break;
+			case "watch_change":
+				eventSource.emit("watchChange", event.id);
+				break;
+		}
+		originalReporter.update(event);
+	} };
+	return config;
+}
+
+//#endregion
+//#region src/utils/promise.ts
+function taskHandler() {
+	let resolver;
+	let rejector;
+	return {
+		task: new Promise((resolve, reject) => {
+			resolver = resolve;
+			rejector = reject;
+		}),
+		resolve: () => resolver?.(void 0),
+		reject: (reason) => rejector?.(reason)
+	};
+}
+
+//#endregion
+//#region src/utils/source-map.ts
+function replaceSourceMappingURL(code, sourceMappingURL) {
+	const marker = "//# sourceMappingURL=";
+	const lastIndex = code.lastIndexOf(marker);
+	if (lastIndex === -1) return code;
+	let endIndex = code.indexOf("\n", lastIndex);
+	if (endIndex === -1) endIndex = code.length;
+	return [
+		code.slice(0, lastIndex),
+		`${marker}${sourceMappingURL}`,
+		code.slice(endIndex)
+	].join("");
+}
+
+//#endregion
+//#region src/server/bundle.ts
+var InMemoryBundle = class {
+	lazySourceMapConsumer = null;
+	constructor(_code, _sourceMap, sourceMappingURL) {
+		this._code = _code;
+		this._sourceMap = _sourceMap;
+		this._code = replaceSourceMappingURL(this._code, sourceMappingURL);
+	}
+	get code() {
+		return this._code;
+	}
+	get sourceMap() {
+		return this._sourceMap;
+	}
+	get sourceMapConsumer() {
+		invariant(this._sourceMap, "Source map is not available");
+		if (this.lazySourceMapConsumer == null) this.lazySourceMapConsumer = new SourceMapConsumer(this._sourceMap);
+		return this.lazySourceMapConsumer;
+	}
+};
+
+//#endregion
+//#region src/server/bundler-pool.ts
+var BundlerDevEngine = class extends EventEmitter {
+	initializeHandle;
+	_id;
+	bundle = null;
+	_devEngine = null;
+	_state = "idle";
+	constructor(options, config, buildOptions) {
+		super();
+		this.options = options;
+		this.config = config;
+		this.buildOptions = buildOptions;
+		this._id = Bundler.createId(config, buildOptions);
+		this.initializeHandle = taskHandler();
+		this.initialize();
+	}
+	get id() {
+		return this._id;
+	}
+	get devEngine() {
+		invariant(this._devEngine, "DevEngine is not initialized");
+		return this._devEngine;
+	}
+	get ensureInitialized() {
+		return this.initializeHandle.task;
+	}
+	get sourceMappingURL() {
+		const { host, port } = this.options.server;
+		const { platform, dev: dev$1 } = this.buildOptions;
+		const [name] = this.config.entry.split(".");
+		return `http://${host}:${port}/${name}.bundle.map?platform=${platform}&dev=${dev$1}`;
+	}
+	async initialize() {
+		if (this._state !== "idle" || this._devEngine != null) return this;
+		this._state = "initializing";
+		const devEngine = await Bundler.devEngine(bindReporter(this.config, this), this.buildOptions, {
+			host: this.options.server.host,
+			port: this.options.server.port,
+			onHmrUpdates: (errorOrResult) => {
+				if (errorOrResult instanceof Error) logger.error("Failed to handle HMR updates", {
+					bundlerId: this.id,
+					error: errorOrResult
+				});
+				else {
+					logger.trace("Detected changed files", {
+						bundlerId: this.id,
+						changedFiles: errorOrResult.changedFiles
+					});
+					this.emit("hmrUpdates", errorOrResult.updates);
+				}
+			},
+			onOutput: (errorOrResult) => {
+				if (errorOrResult instanceof Error) logger.error("Failed to build bundle", {
+					bundlerId: this.id,
+					error: errorOrResult
+				});
+				else {
+					const output = errorOrResult.output[0];
+					const sourceMap = output.map?.toString();
+					this.bundle = new InMemoryBundle(output.code, sourceMap, this.sourceMappingURL);
+					logger.debug("Build completed", {
+						bundlerId: this.id,
+						bundleName: output.name
+					});
+				}
+			},
+			rebuildStrategy: "auto",
+			watch: this.config.watcher
+		});
+		await devEngine.run();
+		this._devEngine = devEngine;
+		this._state = "ready";
+		this.initializeHandle.resolve();
+	}
+	async getBundle() {
+		await this.ensureInitialized;
+		if ((await this.devEngine.getBundleState()).hasStaleOutput || this.bundle == null) await this.devEngine.ensureLatestBuildOutput();
+		invariant(this.bundle, "Bundle is not available");
+		return this.bundle;
+	}
+};
+var BundlerPool = class BundlerPool {
+	static instances = /* @__PURE__ */ new Map();
+	constructor(config, resolvedServerOptions) {
+		this.config = config;
+		this.resolvedServerOptions = resolvedServerOptions;
+	}
+	instanceKey(bundleName, buildOptions) {
+		return `${bundleName}-${Bundler.createId(this.config, buildOptions)}`;
+	}
+	get(bundleName, buildOptions) {
+		const key = this.instanceKey(getBaseBundleName(bundleName), buildOptions);
+		const instance = BundlerPool.instances.get(key);
+		if (instance) return instance;
+		else {
+			logger.debug("Preparing new bundler instance", {
+				bundleName,
+				key
+			});
+			const instance$1 = new BundlerDevEngine({ server: this.resolvedServerOptions }, this.config, buildOptions);
+			logger.debug("Setting new bundler instance", { key });
+			BundlerPool.instances.set(key, instance$1);
+			return instance$1;
+		}
+	}
+};
+
+//#endregion
+//#region src/server/constants.ts
+const DEFAULT_PORT = 8081;
+const DEFAULT_HOST = "localhost";
+
+//#endregion
+//#region src/server/error.ts
+function errorHandler(error, request, reply) {
+	logger.error(`An error occurred while processing the request (${request.method} ${request.url}):`, error.message);
+	logger.debug(error);
+	reply.status(500).send("Internal Server Error");
+}
+
+//#endregion
+//#region src/server/middlewares/serve-assets.ts
+const queryParamSchema = asConst({
+	type: "object",
+	properties: {
+		platform: { type: "string" },
+		hash: { type: "string" }
+	},
+	required: ["platform"]
+});
+const plugin$2 = fp((fastify, options) => {
+	const { projectRoot, host, port, https, preferNativePlatform } = options;
+	const baseUrl = https ? `https://${host}:${port}` : `http://${host}:${port}`;
+	function resolveAsset(asset) {
+		return path.resolve(projectRoot, asset);
+	}
+	fastify.get(`/${DEV_SERVER_ASSET_PATH}/*`, {
+		schema: { querystring: queryParamSchema },
+		async handler(request, reply) {
+			const { url: url$1, query } = request;
+			const { pathname } = new URL(url$1, baseUrl);
+			const assetPath = resolveAsset(pathname.replace(/* @__PURE__ */ new RegExp(`^/${DEV_SERVER_ASSET_PATH}/?`), ""));
+			let handle = null;
+			try {
+				handle = await fs.promises.open(resolveAssetPath(assetPath, {
+					platform: query.platform,
+					preferNativePlatform
+				}, 1), "r");
+				const assetData = await handle.readFile();
+				const { size } = await handle.stat();
+				await reply.header("Content-Type", mime.getType(assetPath) ?? "").header("Content-Length", size).send(assetData);
+			} catch (error) {
+				fastify.log.error(error, "Failed to serve asset (scale assets resolving is not implemented yet)");
+				await reply.status(500).send();
+			} finally {
+				await handle?.close();
+			}
+		}
+	});
+}, { name: "serve-assets" });
+
+//#endregion
+//#region src/utils/response.ts
+var BundleResponse = class BundleResponse {
+	static CRLF = "\r\n";
+	static THROTTLE_DELAY = 10;
+	done = 0;
+	total = 0;
+	boundary;
+	throttleTimer = null;
+	constructor(reply) {
+		this.reply = reply;
+		const boundary = performance.now().toString();
+		this.boundary = boundary;
+		this.reply.raw.writeHead(200, { "Content-Type": `multipart/mixed; boundary="${boundary}"` });
+	}
+	writeChunk(data, headers, end = false) {
+		if (this.reply.raw.writableEnded) return;
+		const CRLF = BundleResponse.CRLF;
+		this.reply.raw.write(`${CRLF}--${this.boundary}${CRLF}`);
+		this.reply.raw.write(Object.entries(headers).map(([key, value]) => `${key}: ${value}`).join(CRLF) + CRLF + CRLF);
+		if (data) this.reply.raw.write(data);
+		if (end) {
+			this.reply.raw.write(`${CRLF}--${this.boundary}--${CRLF}`);
+			this.reply.raw.end();
+		}
+	}
+	/**
+	* Sample
+	*
+	* ```
+	* --boundary
+	*
+	* Content-Type: application/json
+	*
+	* {"done":10,"total":100}
+	* ```
+	*/
+	writeBundleState(done, total) {
+		const previousProgress = this.done / this.total;
+		const currentProgress = done / total;
+		this.done = done;
+		this.total = total;
+		if (total < 10 || this.throttleTimer != null || previousProgress >= currentProgress) return;
+		this.writeChunk(JSON.stringify({
+			done,
+			total
+		}), { "Content-Type": "application/json" });
+		this.throttleTimer = setTimeout(() => {
+			this.throttleTimer = null;
+		}, BundleResponse.THROTTLE_DELAY);
+	}
+	/**
+	* Sample
+	*
+	* ```
+	* --boundary
+	*
+	* X-Metro-Files-Changed-Count: 0
+	* Content-Type: application/json
+	* Content-Length: 100
+	* Last-Modified: Thu, 10 Aug 2023 12:00:00 GMT
+	*
+	* <bundle result>
+	* ```
+	*/
+	endWithBundle(bundle) {
+		this.writeChunk(JSON.stringify({
+			done: this.total,
+			total: this.total
+		}), { "Content-Type": "application/json" });
+		this.writeChunk(bundle, {
+			"X-Metro-Files-Changed-Count": String(0),
+			"Content-Type": "application/javascript; charset=UTF-8",
+			"Content-Length": String(Buffer.byteLength(bundle)),
+			"Last-Modified": (/* @__PURE__ */ new Date()).toUTCString()
+		}, true);
+	}
+	endWithError(error) {
+		const errorData = JSON.stringify({
+			type: error?.name ?? "InternalError",
+			message: error?.message ?? "internal error",
+			errors: []
+		});
+		this.writeChunk(errorData, {
+			"Content-Type": "application/json",
+			"X-Http-Status": "500"
+		}, true);
+	}
+};
+
+//#endregion
+//#region src/server/common/schema.ts
+const bundleRequestSchema = asConst({
+	type: "object",
+	properties: {
+		platform: { type: "string" },
+		app: { type: "string" },
+		dev: { type: "boolean" },
+		minify: { type: "boolean" },
+		runModule: { type: "boolean" },
+		inlineSourceMap: { type: "boolean" },
+		modulesOnly: { type: "boolean" }
+	},
+	required: ["platform"]
+});
+const validateBundleRequest = new Ajv().compile(bundleRequestSchema);
+
+//#endregion
+//#region src/server/middlewares/serve-bundle.ts
+const routeParamSchema = asConst({
+	type: "object",
+	properties: { name: { type: "string" } }
+});
+const plugin$1 = fp((fastify, options) => {
+	const { getBundler } = options;
+	fastify.get("/:name.bundle", {
+		schema: {
+			params: routeParamSchema,
+			querystring: bundleRequestSchema
+		},
+		async handler(request, reply) {
+			const { params, query: buildOptions, headers: { accept } } = request;
+			if (!params.name) {
+				await reply.status(400).send("invalid bundle name");
+				return;
+			}
+			const bundler = getBundler(params.name, buildOptions);
+			if (accept?.includes("multipart/mixed") ?? false) {
+				const bundleResponse = new BundleResponse(reply);
+				const transformHandler = (_id, totalModules = 0, transformedModules) => {
+					bundleResponse.writeBundleState(transformedModules, totalModules);
+				};
+				bundler.on("transform", transformHandler);
+				await bundler.getBundle().then((bundle) => bundleResponse.endWithBundle(bundle.code)).catch((error) => {
+					bundleResponse.endWithError(error);
+					throw error;
+				}).finally(() => bundler.off("transform", transformHandler));
+			} else {
+				this.log.debug(`client is not support multipart/mixed content: ${accept ?? "<empty>"}`);
+				const code = (await bundler.getBundle()).code;
+				await reply.header("Content-Type", "application/javascript").header("Content-Length", Buffer.byteLength(code)).status(200).send(code);
+			}
+		}
+	});
+	fastify.get("/:name.map", {
+		schema: {
+			params: routeParamSchema,
+			querystring: bundleRequestSchema
+		},
+		async handler(request, reply) {
+			const { params, query: buildOptions } = request;
+			if (!params.name) {
+				await reply.status(400).send("invalid bundle name");
+				return;
+			}
+			const sourceMap = (await getBundler(params.name, buildOptions).getBundle()).sourceMap;
+			invariant(sourceMap, "Source map is not available");
+			await reply.header("Access-Control-Allow-Origin", "devtools://devtools").header("Content-Type", "application/json").header("Content-Length", Buffer.byteLength(sourceMap)).status(200).send(sourceMap);
+		}
+	});
+}, { name: "serve-bundle" });
+
+//#endregion
+//#region node_modules/picocolors/picocolors.js
+var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index);
+		return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+}));
+
+//#endregion
+//#region node_modules/js-tokens/index.js
+var require_js_tokens = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = /((['"])(?:(?!\2|\\).|\\(?:\r\n|[\s\S]))*(\2)?|`(?:[^`\\$]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{[^}]*\}?)*\}?)*(`)?)|(\/\/.*)|(\/\*(?:[^*]|\*(?!\/))*(\*\/)?)|(\/(?!\*)(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\]\\]).|\\.)+\/(?:(?!\s*(?:\b|[\u0080-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyus]{1,6}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|\/(?![\/*])))))|(0[xX][\da-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?)|((?!\d)(?:(?!\s)[$\w\u0080-\uFFFF]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+)|(--|\+\+|&&|\|\||=>|\.{3}|(?:[+\-\/%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2})=?|[?~.,:;[\](){}])|(\s+)|(^$|[\s\S])/g;
+	exports.matchToToken = function(match) {
+		var token = {
+			type: "invalid",
+			value: match[0],
+			closed: void 0
+		};
+		if (match[1]) token.type = "string", token.closed = !!(match[3] || match[4]);
+		else if (match[5]) token.type = "comment";
+		else if (match[6]) token.type = "comment", token.closed = !!match[7];
+		else if (match[8]) token.type = "regex";
+		else if (match[9]) token.type = "number";
+		else if (match[10]) token.type = "name";
+		else if (match[11]) token.type = "punctuator";
+		else if (match[12]) token.type = "whitespace";
+		return token;
+	};
+}));
+
+//#endregion
+//#region node_modules/@babel/helper-validator-identifier/lib/identifier.js
+var require_identifier = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.isIdentifierChar = isIdentifierChar;
+	exports.isIdentifierName = isIdentifierName;
+	exports.isIdentifierStart = isIdentifierStart;
+	let nonASCIIidentifierStartChars = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ";
+	let nonASCIIidentifierChars = "·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･";
+	const nonASCIIidentifierStart = /* @__PURE__ */ new RegExp("[" + nonASCIIidentifierStartChars + "]");
+	const nonASCIIidentifier = /* @__PURE__ */ new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+	nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+	const astralIdentifierStartCodes = [
+		0,
+		11,
+		2,
+		25,
+		2,
+		18,
+		2,
+		1,
+		2,
+		14,
+		3,
+		13,
+		35,
+		122,
+		70,
+		52,
+		268,
+		28,
+		4,
+		48,
+		48,
+		31,
+		14,
+		29,
+		6,
+		37,
+		11,
+		29,
+		3,
+		35,
+		5,
+		7,
+		2,
+		4,
+		43,
+		157,
+		19,
+		35,
+		5,
+		35,
+		5,
+		39,
+		9,
+		51,
+		13,
+		10,
+		2,
+		14,
+		2,
+		6,
+		2,
+		1,
+		2,
+		10,
+		2,
+		14,
+		2,
+		6,
+		2,
+		1,
+		4,
+		51,
+		13,
+		310,
+		10,
+		21,
+		11,
+		7,
+		25,
+		5,
+		2,
+		41,
+		2,
+		8,
+		70,
+		5,
+		3,
+		0,
+		2,
+		43,
+		2,
+		1,
+		4,
+		0,
+		3,
+		22,
+		11,
+		22,
+		10,
+		30,
+		66,
+		18,
+		2,
+		1,
+		11,
+		21,
+		11,
+		25,
+		7,
+		25,
+		39,
+		55,
+		7,
+		1,
+		65,
+		0,
+		16,
+		3,
+		2,
+		2,
+		2,
+		28,
+		43,
+		28,
+		4,
+		28,
+		36,
+		7,
+		2,
+		27,
+		28,
+		53,
+		11,
+		21,
+		11,
+		18,
+		14,
+		17,
+		111,
+		72,
+		56,
+		50,
+		14,
+		50,
+		14,
+		35,
+		39,
+		27,
+		10,
+		22,
+		251,
+		41,
+		7,
+		1,
+		17,
+		5,
+		57,
+		28,
+		11,
+		0,
+		9,
+		21,
+		43,
+		17,
+		47,
+		20,
+		28,
+		22,
+		13,
+		52,
+		58,
+		1,
+		3,
+		0,
+		14,
+		44,
+		33,
+		24,
+		27,
+		35,
+		30,
+		0,
+		3,
+		0,
+		9,
+		34,
+		4,
+		0,
+		13,
+		47,
+		15,
+		3,
+		22,
+		0,
+		2,
+		0,
+		36,
+		17,
+		2,
+		24,
+		20,
+		1,
+		64,
+		6,
+		2,
+		0,
+		2,
+		3,
+		2,
+		14,
+		2,
+		9,
+		8,
+		46,
+		39,
+		7,
+		3,
+		1,
+		3,
+		21,
+		2,
+		6,
+		2,
+		1,
+		2,
+		4,
+		4,
+		0,
+		19,
+		0,
+		13,
+		4,
+		31,
+		9,
+		2,
+		0,
+		3,
+		0,
+		2,
+		37,
+		2,
+		0,
+		26,
+		0,
+		2,
+		0,
+		45,
+		52,
+		19,
+		3,
+		21,
+		2,
+		31,
+		47,
+		21,
+		1,
+		2,
+		0,
+		185,
+		46,
+		42,
+		3,
+		37,
+		47,
+		21,
+		0,
+		60,
+		42,
+		14,
+		0,
+		72,
+		26,
+		38,
+		6,
+		186,
+		43,
+		117,
+		63,
+		32,
+		7,
+		3,
+		0,
+		3,
+		7,
+		2,
+		1,
+		2,
+		23,
+		16,
+		0,
+		2,
+		0,
+		95,
+		7,
+		3,
+		38,
+		17,
+		0,
+		2,
+		0,
+		29,
+		0,
+		11,
+		39,
+		8,
+		0,
+		22,
+		0,
+		12,
+		45,
+		20,
+		0,
+		19,
+		72,
+		200,
+		32,
+		32,
+		8,
+		2,
+		36,
+		18,
+		0,
+		50,
+		29,
+		113,
+		6,
+		2,
+		1,
+		2,
+		37,
+		22,
+		0,
+		26,
+		5,
+		2,
+		1,
+		2,
+		31,
+		15,
+		0,
+		24,
+		43,
+		261,
+		18,
+		16,
+		0,
+		2,
+		12,
+		2,
+		33,
+		125,
+		0,
+		80,
+		921,
+		103,
+		110,
+		18,
+		195,
+		2637,
+		96,
+		16,
+		1071,
+		18,
+		5,
+		26,
+		3994,
+		6,
+		582,
+		6842,
+		29,
+		1763,
+		568,
+		8,
+		30,
+		18,
+		78,
+		18,
+		29,
+		19,
+		47,
+		17,
+		3,
+		32,
+		20,
+		6,
+		18,
+		433,
+		44,
+		212,
+		63,
+		33,
+		24,
+		3,
+		24,
+		45,
+		74,
+		6,
+		0,
+		67,
+		12,
+		65,
+		1,
+		2,
+		0,
+		15,
+		4,
+		10,
+		7381,
+		42,
+		31,
+		98,
+		114,
+		8702,
+		3,
+		2,
+		6,
+		2,
+		1,
+		2,
+		290,
+		16,
+		0,
+		30,
+		2,
+		3,
+		0,
+		15,
+		3,
+		9,
+		395,
+		2309,
+		106,
+		6,
+		12,
+		4,
+		8,
+		8,
+		9,
+		5991,
+		84,
+		2,
+		70,
+		2,
+		1,
+		3,
+		0,
+		3,
+		1,
+		3,
+		3,
+		2,
+		11,
+		2,
+		0,
+		2,
+		6,
+		2,
+		64,
+		2,
+		3,
+		3,
+		7,
+		2,
+		6,
+		2,
+		27,
+		2,
+		3,
+		2,
+		4,
+		2,
+		0,
+		4,
+		6,
+		2,
+		339,
+		3,
+		24,
+		2,
+		24,
+		2,
+		30,
+		2,
+		24,
+		2,
+		30,
+		2,
+		24,
+		2,
+		30,
+		2,
+		24,
+		2,
+		30,
+		2,
+		24,
+		2,
+		7,
+		1845,
+		30,
+		7,
+		5,
+		262,
+		61,
+		147,
+		44,
+		11,
+		6,
+		17,
+		0,
+		322,
+		29,
+		19,
+		43,
+		485,
+		27,
+		229,
+		29,
+		3,
+		0,
+		208,
+		30,
+		2,
+		2,
+		2,
+		1,
+		2,
+		6,
+		3,
+		4,
+		10,
+		1,
+		225,
+		6,
+		2,
+		3,
+		2,
+		1,
+		2,
+		14,
+		2,
+		196,
+		60,
+		67,
+		8,
+		0,
+		1205,
+		3,
+		2,
+		26,
+		2,
+		1,
+		2,
+		0,
+		3,
+		0,
+		2,
+		9,
+		2,
+		3,
+		2,
+		0,
+		2,
+		0,
+		7,
+		0,
+		5,
+		0,
+		2,
+		0,
+		2,
+		0,
+		2,
+		2,
+		2,
+		1,
+		2,
+		0,
+		3,
+		0,
+		2,
+		0,
+		2,
+		0,
+		2,
+		0,
+		2,
+		0,
+		2,
+		1,
+		2,
+		0,
+		3,
+		3,
+		2,
+		6,
+		2,
+		3,
+		2,
+		3,
+		2,
+		0,
+		2,
+		9,
+		2,
+		16,
+		6,
+		2,
+		2,
+		4,
+		2,
+		16,
+		4421,
+		42719,
+		33,
+		4381,
+		3,
+		5773,
+		3,
+		7472,
+		16,
+		621,
+		2467,
+		541,
+		1507,
+		4938,
+		6,
+		8489
+	];
+	const astralIdentifierCodes = [
+		509,
+		0,
+		227,
+		0,
+		150,
+		4,
+		294,
+		9,
+		1368,
+		2,
+		2,
+		1,
+		6,
+		3,
+		41,
+		2,
+		5,
+		0,
+		166,
+		1,
+		574,
+		3,
+		9,
+		9,
+		7,
+		9,
+		32,
+		4,
+		318,
+		1,
+		78,
+		5,
+		71,
+		10,
+		50,
+		3,
+		123,
+		2,
+		54,
+		14,
+		32,
+		10,
+		3,
+		1,
+		11,
+		3,
+		46,
+		10,
+		8,
+		0,
+		46,
+		9,
+		7,
+		2,
+		37,
+		13,
+		2,
+		9,
+		6,
+		1,
+		45,
+		0,
+		13,
+		2,
+		49,
+		13,
+		9,
+		3,
+		2,
+		11,
+		83,
+		11,
+		7,
+		0,
+		3,
+		0,
+		158,
+		11,
+		6,
+		9,
+		7,
+		3,
+		56,
+		1,
+		2,
+		6,
+		3,
+		1,
+		3,
+		2,
+		10,
+		0,
+		11,
+		1,
+		3,
+		6,
+		4,
+		4,
+		68,
+		8,
+		2,
+		0,
+		3,
+		0,
+		2,
+		3,
+		2,
+		4,
+		2,
+		0,
+		15,
+		1,
+		83,
+		17,
+		10,
+		9,
+		5,
+		0,
+		82,
+		19,
+		13,
+		9,
+		214,
+		6,
+		3,
+		8,
+		28,
+		1,
+		83,
+		16,
+		16,
+		9,
+		82,
+		12,
+		9,
+		9,
+		7,
+		19,
+		58,
+		14,
+		5,
+		9,
+		243,
+		14,
+		166,
+		9,
+		71,
+		5,
+		2,
+		1,
+		3,
+		3,
+		2,
+		0,
+		2,
+		1,
+		13,
+		9,
+		120,
+		6,
+		3,
+		6,
+		4,
+		0,
+		29,
+		9,
+		41,
+		6,
+		2,
+		3,
+		9,
+		0,
+		10,
+		10,
+		47,
+		15,
+		199,
+		7,
+		137,
+		9,
+		54,
+		7,
+		2,
+		7,
+		17,
+		9,
+		57,
+		21,
+		2,
+		13,
+		123,
+		5,
+		4,
+		0,
+		2,
+		1,
+		2,
+		6,
+		2,
+		0,
+		9,
+		9,
+		49,
+		4,
+		2,
+		1,
+		2,
+		4,
+		9,
+		9,
+		55,
+		9,
+		266,
+		3,
+		10,
+		1,
+		2,
+		0,
+		49,
+		6,
+		4,
+		4,
+		14,
+		10,
+		5350,
+		0,
+		7,
+		14,
+		11465,
+		27,
+		2343,
+		9,
+		87,
+		9,
+		39,
+		4,
+		60,
+		6,
+		26,
+		9,
+		535,
+		9,
+		470,
+		0,
+		2,
+		54,
+		8,
+		3,
+		82,
+		0,
+		12,
+		1,
+		19628,
+		1,
+		4178,
+		9,
+		519,
+		45,
+		3,
+		22,
+		543,
+		4,
+		4,
+		5,
+		9,
+		7,
+		3,
+		6,
+		31,
+		3,
+		149,
+		2,
+		1418,
+		49,
+		513,
+		54,
+		5,
+		49,
+		9,
+		0,
+		15,
+		0,
+		23,
+		4,
+		2,
+		14,
+		1361,
+		6,
+		2,
+		16,
+		3,
+		6,
+		2,
+		1,
+		2,
+		4,
+		101,
+		0,
+		161,
+		6,
+		10,
+		9,
+		357,
+		0,
+		62,
+		13,
+		499,
+		13,
+		245,
+		1,
+		2,
+		9,
+		233,
+		0,
+		3,
+		0,
+		8,
+		1,
+		6,
+		0,
+		475,
+		6,
+		110,
+		6,
+		6,
+		9,
+		4759,
+		9,
+		787719,
+		239
+	];
+	function isInAstralSet(code, set) {
+		let pos = 65536;
+		for (let i = 0, length = set.length; i < length; i += 2) {
+			pos += set[i];
+			if (pos > code) return false;
+			pos += set[i + 1];
+			if (pos >= code) return true;
+		}
+		return false;
+	}
+	function isIdentifierStart(code) {
+		if (code < 65) return code === 36;
+		if (code <= 90) return true;
+		if (code < 97) return code === 95;
+		if (code <= 122) return true;
+		if (code <= 65535) return code >= 170 && nonASCIIidentifierStart.test(String.fromCharCode(code));
+		return isInAstralSet(code, astralIdentifierStartCodes);
+	}
+	function isIdentifierChar(code) {
+		if (code < 48) return code === 36;
+		if (code < 58) return true;
+		if (code < 65) return false;
+		if (code <= 90) return true;
+		if (code < 97) return code === 95;
+		if (code <= 122) return true;
+		if (code <= 65535) return code >= 170 && nonASCIIidentifier.test(String.fromCharCode(code));
+		return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+	}
+	function isIdentifierName(name) {
+		let isFirst = true;
+		for (let i = 0; i < name.length; i++) {
+			let cp = name.charCodeAt(i);
+			if ((cp & 64512) === 55296 && i + 1 < name.length) {
+				const trail = name.charCodeAt(++i);
+				if ((trail & 64512) === 56320) cp = 65536 + ((cp & 1023) << 10) + (trail & 1023);
+			}
+			if (isFirst) {
+				isFirst = false;
+				if (!isIdentifierStart(cp)) return false;
+			} else if (!isIdentifierChar(cp)) return false;
+		}
+		return !isFirst;
+	}
+}));
+
+//#endregion
+//#region node_modules/@babel/helper-validator-identifier/lib/keyword.js
+var require_keyword = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.isKeyword = isKeyword;
+	exports.isReservedWord = isReservedWord;
+	exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
+	exports.isStrictBindReservedWord = isStrictBindReservedWord;
+	exports.isStrictReservedWord = isStrictReservedWord;
+	const reservedWords = {
+		keyword: [
+			"break",
+			"case",
+			"catch",
+			"continue",
+			"debugger",
+			"default",
+			"do",
+			"else",
+			"finally",
+			"for",
+			"function",
+			"if",
+			"return",
+			"switch",
+			"throw",
+			"try",
+			"var",
+			"const",
+			"while",
+			"with",
+			"new",
+			"this",
+			"super",
+			"class",
+			"extends",
+			"export",
+			"import",
+			"null",
+			"true",
+			"false",
+			"in",
+			"instanceof",
+			"typeof",
+			"void",
+			"delete"
+		],
+		strict: [
+			"implements",
+			"interface",
+			"let",
+			"package",
+			"private",
+			"protected",
+			"public",
+			"static",
+			"yield"
+		],
+		strictBind: ["eval", "arguments"]
+	};
+	const keywords = new Set(reservedWords.keyword);
+	const reservedWordsStrictSet = new Set(reservedWords.strict);
+	const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
+	function isReservedWord(word, inModule) {
+		return inModule && word === "await" || word === "enum";
+	}
+	function isStrictReservedWord(word, inModule) {
+		return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
+	}
+	function isStrictBindOnlyReservedWord(word) {
+		return reservedWordsStrictBindSet.has(word);
+	}
+	function isStrictBindReservedWord(word, inModule) {
+		return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+	}
+	function isKeyword(word) {
+		return keywords.has(word);
+	}
+}));
+
+//#endregion
+//#region node_modules/@babel/helper-validator-identifier/lib/index.js
+var require_lib$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "isIdentifierChar", {
+		enumerable: true,
+		get: function() {
+			return _identifier.isIdentifierChar;
+		}
+	});
+	Object.defineProperty(exports, "isIdentifierName", {
+		enumerable: true,
+		get: function() {
+			return _identifier.isIdentifierName;
+		}
+	});
+	Object.defineProperty(exports, "isIdentifierStart", {
+		enumerable: true,
+		get: function() {
+			return _identifier.isIdentifierStart;
+		}
+	});
+	Object.defineProperty(exports, "isKeyword", {
+		enumerable: true,
+		get: function() {
+			return _keyword.isKeyword;
+		}
+	});
+	Object.defineProperty(exports, "isReservedWord", {
+		enumerable: true,
+		get: function() {
+			return _keyword.isReservedWord;
+		}
+	});
+	Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
+		enumerable: true,
+		get: function() {
+			return _keyword.isStrictBindOnlyReservedWord;
+		}
+	});
+	Object.defineProperty(exports, "isStrictBindReservedWord", {
+		enumerable: true,
+		get: function() {
+			return _keyword.isStrictBindReservedWord;
+		}
+	});
+	Object.defineProperty(exports, "isStrictReservedWord", {
+		enumerable: true,
+		get: function() {
+			return _keyword.isStrictReservedWord;
+		}
+	});
+	var _identifier = require_identifier();
+	var _keyword = require_keyword();
+}));
+
+//#endregion
+//#region node_modules/@babel/code-frame/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var picocolors = require_picocolors();
+	var jsTokens = require_js_tokens();
+	var helperValidatorIdentifier = require_lib$1();
+	function isColorSupported() {
+		return typeof process === "object" && (process.env.FORCE_COLOR === "0" || process.env.FORCE_COLOR === "false") ? false : picocolors.isColorSupported;
+	}
+	const compose = (f, g) => (v) => f(g(v));
+	function buildDefs(colors) {
+		return {
+			keyword: colors.cyan,
+			capitalized: colors.yellow,
+			jsxIdentifier: colors.yellow,
+			punctuator: colors.yellow,
+			number: colors.magenta,
+			string: colors.green,
+			regex: colors.magenta,
+			comment: colors.gray,
+			invalid: compose(compose(colors.white, colors.bgRed), colors.bold),
+			gutter: colors.gray,
+			marker: compose(colors.red, colors.bold),
+			message: compose(colors.red, colors.bold),
+			reset: colors.reset
+		};
+	}
+	const defsOn = buildDefs(picocolors.createColors(true));
+	const defsOff = buildDefs(picocolors.createColors(false));
+	function getDefs(enabled) {
+		return enabled ? defsOn : defsOff;
+	}
+	const sometimesKeywords = new Set([
+		"as",
+		"async",
+		"from",
+		"get",
+		"of",
+		"set"
+	]);
+	const NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
+	const BRACKET = /^[()[\]{}]$/;
+	let tokenize;
+	{
+		const JSX_TAG = /^[a-z][\w-]*$/i;
+		const getTokenType = function(token, offset, text) {
+			if (token.type === "name") {
+				if (helperValidatorIdentifier.isKeyword(token.value) || helperValidatorIdentifier.isStrictReservedWord(token.value, true) || sometimesKeywords.has(token.value)) return "keyword";
+				if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) === "</")) return "jsxIdentifier";
+				if (token.value[0] !== token.value[0].toLowerCase()) return "capitalized";
+			}
+			if (token.type === "punctuator" && BRACKET.test(token.value)) return "bracket";
+			if (token.type === "invalid" && (token.value === "@" || token.value === "#")) return "punctuator";
+			return token.type;
+		};
+		tokenize = function* (text) {
+			let match;
+			while (match = jsTokens.default.exec(text)) {
+				const token = jsTokens.matchToToken(match);
+				yield {
+					type: getTokenType(token, match.index, text),
+					value: token.value
+				};
+			}
+		};
+	}
+	function highlight(text) {
+		if (text === "") return "";
+		const defs = getDefs(true);
+		let highlighted = "";
+		for (const { type, value } of tokenize(text)) if (type in defs) highlighted += value.split(NEWLINE$1).map((str) => defs[type](str)).join("\n");
+		else highlighted += value;
+		return highlighted;
+	}
+	const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+	function getMarkerLines(loc, source, opts) {
+		const startLoc = Object.assign({
+			column: 0,
+			line: -1
+		}, loc.start);
+		const endLoc = Object.assign({}, startLoc, loc.end);
+		const { linesAbove = 2, linesBelow = 3 } = opts || {};
+		const startLine = startLoc.line;
+		const startColumn = startLoc.column;
+		const endLine = endLoc.line;
+		const endColumn = endLoc.column;
+		let start = Math.max(startLine - (linesAbove + 1), 0);
+		let end = Math.min(source.length, endLine + linesBelow);
+		if (startLine === -1) start = 0;
+		if (endLine === -1) end = source.length;
+		const lineDiff = endLine - startLine;
+		const markerLines = {};
+		if (lineDiff) for (let i = 0; i <= lineDiff; i++) {
+			const lineNumber = i + startLine;
+			if (!startColumn) markerLines[lineNumber] = true;
+			else if (i === 0) markerLines[lineNumber] = [startColumn, source[lineNumber - 1].length - startColumn + 1];
+			else if (i === lineDiff) markerLines[lineNumber] = [0, endColumn];
+			else markerLines[lineNumber] = [0, source[lineNumber - i].length];
+		}
+		else if (startColumn === endColumn) if (startColumn) markerLines[startLine] = [startColumn, 0];
+		else markerLines[startLine] = true;
+		else markerLines[startLine] = [startColumn, endColumn - startColumn];
+		return {
+			start,
+			end,
+			markerLines
+		};
+	}
+	function codeFrameColumns(rawLines, loc, opts = {}) {
+		const shouldHighlight = opts.forceColor || isColorSupported() && opts.highlightCode;
+		const defs = getDefs(shouldHighlight);
+		const { start, end, markerLines } = getMarkerLines(loc, rawLines.split(NEWLINE), opts);
+		const hasColumns = loc.start && typeof loc.start.column === "number";
+		const numberMaxWidth = String(end).length;
+		let frame = (shouldHighlight ? highlight(rawLines) : rawLines).split(NEWLINE, end).slice(start, end).map((line, index) => {
+			const number = start + 1 + index;
+			const gutter = ` ${` ${number}`.slice(-numberMaxWidth)} |`;
+			const hasMarker = markerLines[number];
+			const lastMarkerLine = !markerLines[number + 1];
+			if (hasMarker) {
+				let markerLine = "";
+				if (Array.isArray(hasMarker)) {
+					const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+					const numberOfMarkers = hasMarker[1] || 1;
+					markerLine = [
+						"\n ",
+						defs.gutter(gutter.replace(/\d/g, " ")),
+						" ",
+						markerSpacing,
+						defs.marker("^").repeat(numberOfMarkers)
+					].join("");
+					if (lastMarkerLine && opts.message) markerLine += " " + defs.message(opts.message);
+				}
+				return [
+					defs.marker(">"),
+					defs.gutter(gutter),
+					line.length > 0 ? ` ${line}` : "",
+					markerLine
+				].join("");
+			} else return ` ${defs.gutter(gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+		}).join("\n");
+		if (opts.message && !hasColumns) frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
+		if (shouldHighlight) return defs.reset(frame);
+		else return frame;
+	}
+	exports.codeFrameColumns = codeFrameColumns;
+}));
+
+//#endregion
+//#region src/server/symbolicate.ts
+var import_lib = require_lib();
+/**
+* @see https://github.com/facebook/react-native/blob/0.83-stable/packages/metro-config/src/index.flow.js#L17
+*/
+const INTERNAL_CALLSITES_REGEX = new RegExp([
+	"/Libraries/BatchedBridge/MessageQueue\\.js$",
+	"/Libraries/Core/.+\\.js$",
+	"/Libraries/LogBox/.+\\.js$",
+	"/Libraries/Network/.+\\.js$",
+	"/Libraries/Pressability/.+\\.js$",
+	"/Libraries/Renderer/implementations/.+\\.js$",
+	"/Libraries/Utilities/.+\\.js$",
+	"/Libraries/vendor/.+\\.js$",
+	"/Libraries/WebSocket/.+\\.js$",
+	"/src/private/renderer/errorhandling/.+\\.js$",
+	"/metro-runtime/.+\\.js$",
+	"/node_modules/@babel/runtime/.+\\.js$",
+	"/node_modules/@react-native/js-polyfills/.+\\.js$",
+	"/node_modules/invariant/.+\\.js$",
+	"/node_modules/react-devtools-core/.+\\.js$",
+	"/node_modules/react-native/index.js$",
+	"/node_modules/react-refresh/.+\\.js$",
+	"/node_modules/scheduler/.+\\.js$",
+	"^\\[native code\\]$"
+].map((pathPattern) => pathPattern.replaceAll("/", "[/\\\\]")).join("|"));
+async function symbolicate(bundle, stack) {
+	const sourceMapConsumer = await bundle.sourceMapConsumer;
+	const symbolicatedStack = stack.filter((frame) => frame.file?.startsWith("http")).map((frame) => originalPositionFor(sourceMapConsumer, frame)).map((frame) => collapseFrame(frame));
+	return {
+		stack: symbolicatedStack,
+		codeFrame: getCodeFrame(sourceMapConsumer, symbolicatedStack, bundle)
+	};
+}
+function originalPositionFor(sourceMapConsumer, frame) {
+	if (frame.column == null || frame.lineNumber == null) return frame;
+	const originalPosition = sourceMapConsumer.originalPositionFor({
+		column: frame.column,
+		line: frame.lineNumber
+	});
+	return Object.entries(originalPosition).reduce((frame$1, [key, value]) => {
+		const targetKey = convertFrameKey(key);
+		return {
+			...frame$1,
+			...value ? { [targetKey]: value } : null
+		};
+	}, frame);
+}
+function collapseFrame(frame) {
+	return {
+		...frame,
+		collapse: Boolean(frame.file && INTERNAL_CALLSITES_REGEX.test(frame.file))
+	};
+}
+function isCollapsed(frame) {
+	return "collapse" in frame && frame.collapse;
+}
+function convertFrameKey(key) {
+	if (key === "line") return "lineNumber";
+	else if (key === "source") return "file";
+	else if (key === "name") return "methodName";
+	return key;
+}
+function getCodeFrame(sourceMapConsumer, frames, bundle) {
+	const frame = frames.find((frame$1) => {
+		return frame$1.lineNumber != null && frame$1.column != null && !isCollapsed(frame$1);
+	});
+	if (frame?.file == null || frame.column == null || frame.lineNumber == null) return null;
+	try {
+		const { lineNumber, column, file } = frame;
+		const unresolved = file.startsWith("http");
+		const source = unresolved ? bundle.code : sourceMapConsumer.sourceContentFor(frame.file);
+		const fileName = unresolved ? url.parse(file).pathname ?? "unknown" : file;
+		let content = "";
+		if (source) content = (0, import_lib.codeFrameColumns)(source, { start: {
+			column,
+			line: lineNumber
+		} }, { highlightCode: true });
+		return {
+			content,
+			fileName,
+			location: {
+				column,
+				row: lineNumber
+			}
+		};
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/server/middlewares/symbolicate.ts
+const bodySchema = asConst({
+	type: "object",
+	properties: {
+		stack: {
+			type: "array",
+			items: {}
+		},
+		extraData: {}
+	},
+	required: ["stack"]
+});
+const plugin = fp((fastify, options) => {
+	const { getBundler } = options;
+	fastify.post("/symbolicate", {
+		schema: { body: bodySchema },
+		async handler(request, reply) {
+			const { stack } = request.body;
+			const bundleUrl = stack.find((frame) => frame.file?.startsWith("http"));
+			invariant(bundleUrl?.file, "No bundle URL found in stack frames");
+			const { pathname, query } = url.parse(bundleUrl.file, true);
+			invariant(pathname, "No pathname found in bundle URL");
+			invariant(query.platform, "No platform found in query");
+			invariant(query.dev, "No dev found in query");
+			const bundle = await getBundler(getBaseBundleName(pathname), {
+				platform: query.platform,
+				dev: query.dev === "true"
+			}).getBundle();
+			await reply.header("Content-Type", "application/json").send(await symbolicate(bundle, stack));
+		}
+	});
+}, { name: "symbolicate" });
+
+//#endregion
+//#region src/server/wss/server.ts
+var WebSocketServer = class extends EventEmitter {
+	clientId = 0;
+	wss;
+	logger;
+	constructor(name, options) {
+		super();
+		const logger$2 = logger.child(name);
+		const wss = new ws.WebSocketServer(options);
+		wss.on("connection", (socket) => {
+			const client = Object.defineProperty(socket, "id", {
+				value: this.clientId++,
+				writable: false
+			});
+			this.onConnection(client);
+			this.emit("connection", client);
+			client.on("message", (data) => {
+				this.onMessage(client, data);
+				this.emit("message", client, data);
+			});
+			client.on("error", (error) => {
+				this.onError(client, error);
+				this.emit("error", client, error);
+			});
+			client.on("close", () => {
+				this.onClose(client);
+				this.emit("close", client);
+			});
+		});
+		this.wss = wss;
+		this.logger = logger$2;
+	}
+	get server() {
+		return this.wss;
+	}
+	send(client, data) {
+		if (client.readyState === ws.WebSocket.OPEN) client.send(data);
+	}
+	sendAll(data) {
+		this.wss.clients.forEach((client) => {
+			if (client.readyState === ws.WebSocket.OPEN) client.send(data);
+		});
+	}
+	rawDataToString(data) {
+		if (Buffer.isBuffer(data)) return data.toString("utf8");
+		if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
+		return Buffer.from(data).toString("utf8");
+	}
+};
+function getWebSocketUpgradeHandler(websocketEndpoints) {
+	return (request, socket, head) => {
+		if (request.url == null) {
+			socket.destroy();
+			return;
+		}
+		const { pathname } = url.parse(request.url, true);
+		if (pathname != null && websocketEndpoints[pathname]) {
+			const wss = websocketEndpoints[pathname];
+			wss.handleUpgrade(request, socket, head, (socket$1) => {
+				wss.emit("connection", socket$1, request);
+			});
+		} else socket.destroy();
+	};
+}
+
+//#endregion
+//#region src/server/wss/hmr-server.ts
+var HMRServer = class extends WebSocketServer {
+	bundlerPool;
+	reportEvent;
+	instances = /* @__PURE__ */ new Map();
+	bindings = /* @__PURE__ */ new Map();
+	constructor({ bundlerPool, reportEvent }) {
+		super("hmr", { noServer: true });
+		this.bundlerPool = bundlerPool;
+		this.reportEvent = reportEvent;
+	}
+	parseClientMessage(data) {
+		const parsedData = JSON.parse(this.rawDataToString(data));
+		const clientMessage = "type" in parsedData ? parsedData : null;
+		invariant(clientMessage, "Invalid HMR client message");
+		return clientMessage;
+	}
+	async handleConnected(client, platform, bundleEntry) {
+		try {
+			this.logger.trace(`HMR client connected (clientId: ${client.id})`, {
+				platform,
+				bundleEntry
+			});
+			const devEngineInstance = this.bundlerPool.get(bundleEntry, {
+				platform,
+				dev: true
+			});
+			this.bindEvents(client, devEngineInstance);
+			this.instances.set(client.id, devEngineInstance);
+			this.logger.trace(`Bundler instance prepared (bundlerId: ${devEngineInstance.id})`);
+		} catch (error) {
+			this.logger.error(`Failed to prepare bundler instance`, error);
+		}
+	}
+	bindEvents(client, instance) {
+		if (this.bindings.get(client.id) == null) {
+			const handleHmrUpdates = (updates) => {
+				this.handleUpdates(client, updates);
+			};
+			const handleWatchChange = () => {
+				this.send(client, JSON.stringify({ type: "hmr:update-start" }));
+			};
+			instance.addListener("hmrUpdates", handleHmrUpdates);
+			instance.addListener("watchChange", handleWatchChange);
+			this.bindings.set(client.id, {
+				hmrUpdates: handleHmrUpdates,
+				watchChange: handleWatchChange
+			});
+			this.logger.trace(`HMR event binding established (clientId: ${client.id})`);
+		}
+	}
+	async handleModuleRegistered(client, modules) {
+		try {
+			const instance = this.instances.get(client.id);
+			invariant(instance != null, `Bundler instance not found for client clientId: ${client.id}`);
+			await instance.ensureInitialized;
+			await instance.devEngine.registerModules(client.id.toString(), modules);
+		} catch (error) {
+			this.logger.error(`Failed to handle module registered`, error);
+		}
+	}
+	async handleInvalidate(client, moduleId) {
+		try {
+			const instance = this.instances.get(client.id);
+			invariant(instance != null, `Bundler instance not found for client clientId: ${client.id}`);
+			await instance.ensureInitialized;
+			const updates = await instance.devEngine.invalidate(moduleId);
+			await this.handleUpdates(client, updates);
+		} catch (error) {
+			this.logger.error(`Failed to handle invalidate`, error);
+		}
+	}
+	async handleUpdates(client, updates) {
+		this.logger.trace(`HMR updates found (clientId: ${client.id})`, { updatesCount: updates.length });
+		for (const clientUpdate of updates) {
+			const update = clientUpdate.update;
+			switch (update.type) {
+				case "Patch":
+					this.sendUpdateToClient(client, update);
+					break;
+				case "FullReload":
+					this.sendReloadToClient(client);
+					break;
+				case "Noop":
+					this.logger.warn(`Client ${clientUpdate.clientId} received noop update`);
+					break;
+			}
+		}
+	}
+	sendUpdateToClient(client, update) {
+		invariant(update.type === "Patch", "Invalid HMR update type");
+		const updateMessage = {
+			type: "hmr:update",
+			code: update.code
+		};
+		this.send(client, JSON.stringify(updateMessage));
+		this.send(client, JSON.stringify({ type: "hmr:update-done" }));
+		this.done(client);
+	}
+	sendReloadToClient(client) {
+		this.logger.trace(`Sending HMR reload message to client (clientId: ${client.id})`);
+		this.send(client, JSON.stringify({ type: "hmr:reload" }));
+		this.done(client);
+	}
+	done(client) {
+		this.send(client, JSON.stringify({ type: "hmr:update-done" }));
+	}
+	sendError(client, error) {
+		try {
+			this.send(client, JSON.stringify(error));
+		} catch (error$1) {
+			this.logger.error(`Failed to send HMR error message to client (clientId: ${client.id})`, error$1);
+		}
+	}
+	cleanup(client) {
+		this.logger.trace(`HMR client cleanup (clientId: ${client.id})`);
+		const binding = this.bindings.get(client.id);
+		const instance = this.instances.get(client.id);
+		if (binding != null && instance != null) {
+			instance.removeListener("hmrUpdates", binding.hmrUpdates);
+			instance.removeListener("watchChange", binding.watchChange);
+		}
+		if (instance != null) instance.devEngine.removeClient(String(client.id));
+		this.bindings.delete(client.id);
+		this.instances.delete(client.id);
+	}
+	onMessage(client, data) {
+		let message;
+		try {
+			message = this.parseClientMessage(data);
+			this.logger.trace("HMR client message received", message);
+		} catch (error) {
+			const message$1 = "Failed to parse HMR client message";
+			this.logger.error(message$1, error);
+			this.sendError(client, {
+				type: "InternalError",
+				errors: [{ description: error instanceof Error ? error.message : String(error) }],
+				message: message$1
+			});
+			return;
+		}
+		switch (message.type) {
+			case "hmr:connected":
+				this.handleConnected(client, message.platform, message.bundleEntry);
+				break;
+			case "hmr:module-registered":
+				this.handleModuleRegistered(client, message.modules);
+				break;
+			case "hmr:invalidate":
+				this.handleInvalidate(client, message.moduleId);
+				break;
+			case "hmr:log":
+				this.reportEvent({
+					type: "client_log",
+					level: message.level,
+					data: message.data
+				});
+				break;
+		}
+	}
+	onConnection(client) {
+		this.logger.trace(`connection established (clientId: ${client.id})`);
+	}
+	onError(client, error) {
+		this.logger.error(`connection error (clientId: ${client.id})`, error);
+		this.cleanup(client);
+	}
+	onClose(client) {
+		this.logger.trace(`connection closed (clientId: ${client.id})`);
+		this.cleanup(client);
+	}
+};
+
+//#endregion
+//#region src/server/create-dev-server.ts
+async function createDevServer(config, options) {
+	const projectRoot = config.root;
+	const { port = DEFAULT_PORT, host = DEFAULT_HOST, https = false, onDeviceConnected, onDeviceMessage, onDeviceConnectionError, onDeviceDisconnected } = options ?? {};
+	if (https) throw new Error("HTTPS is not supported yet");
+	const serverBaseUrl = url.format({
+		protocol: https ? "https" : "http",
+		hostname: host,
+		port
+	});
+	await assertDevServerStatus({
+		devServerUrl: serverBaseUrl,
+		projectRoot,
+		port
+	});
+	const fastify = Fastify({
+		loggerInstance: new DevServerLogger(),
+		disableRequestLogging: true
+	});
+	const bundlerPool = new BundlerPool(config, {
+		host,
+		port
+	});
+	const getBundler = (bundleName, buildOptions) => {
+		return bundlerPool.get(bundleName, buildOptions);
+	};
+	const { middleware: communityMiddleware, websocketEndpoints: communityWebsocketEndpoints, messageSocketEndpoint: { server: messageServer, broadcast }, eventsSocketEndpoint: { server: eventsServer, reportEvent } } = createDevServerMiddleware({
+		port,
+		host,
+		watchFolders: []
+	});
+	const { middleware: devMiddleware, websocketEndpoints } = createDevMiddleware({
+		serverBaseUrl,
+		logger: {
+			info(...args) {
+				if (args[0].includes("JavaScript logs have moved")) return;
+				logger.info(...args);
+			},
+			warn: logger.warn.bind(logger),
+			error: logger.error.bind(logger)
+		},
+		unstable_experiments: {
+			enableNetworkInspector: true,
+			enableStandaloneFuseboxShell: true
+		}
+	});
+	const hmrServer = new HMRServer({
+		bundlerPool,
+		reportEvent: (event) => {
+			reportEvent?.(event);
+			config.reporter.update(event);
+		}
+	}).on("connection", (client) => onDeviceConnected?.(client)).on("message", (client, data) => onDeviceMessage?.(client, data)).on("error", (client, error) => onDeviceConnectionError?.(client, error)).on("close", (client) => onDeviceDisconnected?.(client));
+	await fastify.register(import("@fastify/middie"));
+	const devServer = {
+		config,
+		instance: fastify,
+		middlewares: { use: fastify.use.bind(fastify) },
+		message: Object.assign(messageServer, { broadcast }),
+		events: Object.assign(eventsServer, { reportEvent }),
+		hot: Object.assign(hmrServer.server, {
+			send: hmrServer.send.bind(hmrServer),
+			sendAll: hmrServer.sendAll.bind(hmrServer)
+		})
+	};
+	const { invokePostConfigureServer } = await invokeConfigureServer(devServer, config.plugins ?? []);
+	fastify.use(communityMiddleware).use(devMiddleware).register(plugin, { getBundler }).register(plugin$1, { getBundler }).register(plugin$2, {
+		projectRoot,
+		host,
+		port,
+		https,
+		preferNativePlatform: config.resolver.preferNativePlatform
+	}).setErrorHandler(errorHandler);
+	fastify.server.on("upgrade", getWebSocketUpgradeHandler({
+		...communityWebsocketEndpoints,
+		...websocketEndpoints,
+		"/hot": hmrServer.server
+	}));
+	await invokePostConfigureServer();
+	return devServer;
+}
+async function invokeConfigureServer(server, plugins) {
+	const postConfigureServerHandlers = [];
+	for (const plugin$3 of plugins) {
+		const context = createPluginContext(plugin$3.name);
+		const result = await plugin$3.configureServer?.call(context, server);
+		if (typeof result === "function") postConfigureServerHandlers.push(result);
+	}
+	return { invokePostConfigureServer: async () => {
+		for (const handler of postConfigureServerHandlers) await handler();
+	} };
+}
+
 //#endregion
 //#region src/reporter.ts
 var TerminalReporter = class {
@@ -1538,18 +3902,17 @@ var TerminalReporter = class {
 function resolvePackagePath(basePath, packageName) {
 	let packagePath = null;
 	try {
-		packagePath = resolvePackagePathWithNodeRequire(basePath, packageName);
+		packagePath = resolvePackagePathWithNodeRequire(basePath, packageName, "package.json");
 		if (packagePath) return packagePath;
 	} catch {}
 	try {
-		packagePath = resolvePackagePathWithNodeRequire(basePath, packageName, "");
+		packagePath = resolvePackagePathWithNodeRequire(basePath, packageName);
 		if (packagePath) return packagePath;
 	} catch {}
 	throw new Error(`Failed to resolve package path for '${packageName}'`);
 }
-function resolvePackagePathWithNodeRequire(basePath, packageName, lookupSubpath = "package.json") {
-	const lookupPath = lookupSubpath ? `/${lookupSubpath}` : "";
-	const resolvedPath = __require.resolve(`${packageName}${lookupPath}`, { paths: [basePath] });
+function resolvePackagePathWithNodeRequire(basePath, packageName, subpath) {
+	const resolvedPath = __require.resolve(subpath ? `${packageName}/${subpath}` : packageName, { paths: [basePath] });
 	const root = path.parse(resolvedPath).root;
 	let currentPath = path.dirname(resolvedPath);
 	while (currentPath !== root) {
@@ -1646,20 +4009,26 @@ async function loadConfig(options = {}) {
 		...commonOptions
 	});
 	const resolvedConfig = mergeConfig(defaultConfig, userConfig, await resolvePluginConfig(userConfig, userConfig.plugins ?? []));
-	await invokePluginConfigResolved(resolvedConfig, userConfig.plugins ?? []);
+	await invokeConfigResolved(resolvedConfig, userConfig.plugins ?? []);
 	return resolvedConfig;
 }
 async function resolvePluginConfig(baseConfig, plugins) {
 	let mergedConfig = omit(baseConfig, ["plugins", "dangerously_overrideRolldownOptions"]);
-	for (const plugin of plugins) if (typeof plugin.config === "function") {
-		const config = await plugin.config(mergedConfig);
-		if (config != null) mergedConfig = mergeConfig(mergedConfig, config);
-	} else if (typeof plugin.config === "object") mergedConfig = mergeConfig(mergedConfig, plugin.config);
+	for (const plugin$3 of plugins) {
+		const context = createPluginContext(plugin$3.name);
+		if (typeof plugin$3.config === "function") {
+			const config = await plugin$3.config.call(context, mergedConfig);
+			if (config != null) mergedConfig = mergeConfig(mergedConfig, config);
+		} else if (typeof plugin$3.config === "object") mergedConfig = mergeConfig(mergedConfig, plugin$3.config);
+	}
 	return mergedConfig;
 }
-async function invokePluginConfigResolved(config, plugins) {
-	for (const plugin of plugins) await plugin.configResolved?.(config);
+async function invokeConfigResolved(config, plugins) {
+	await Promise.all(plugins.map((plugin$3) => {
+		const context = createPluginContext(plugin$3.name);
+		return plugin$3.configResolved?.call(context, config);
+	}));
 }
 
 //#endregion
-export { assets_exports as AssetUtils, Bundler, TerminalReporter as DefaultReporter, PluginUtils, defineConfig, getDefaultConfig, invokePluginConfigResolved, loadConfig, mergeConfig, plugins_exports as plugins, resolvePluginConfig, rolldown, rolldownExperimental };
+export { assets_exports as AssetUtils, Bundler, DEFAULT_HOST, DEFAULT_PORT, TerminalReporter as DefaultReporter, PluginUtils, createDevServer, defineConfig, getDefaultConfig, invokeConfigResolved, loadConfig, mergeConfig, plugins_exports as plugins, resolvePluginConfig, rolldown, rolldownExperimental };