@voidzero-dev/vite-plus-core 0.2.7 → 0.2.9

package/dist/vite/client/bundledDevClient.mjs

@@ -0,0 +1,1781 @@
+import "@vite/env";
+//#region ../../node_modules/.pnpm/nanoid@5.1.16/node_modules/nanoid/non-secure/index.js
+let urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+let nanoid = (size = 21) => {
+	let id = "";
+	let i = size | 0;
+	while (i-- > 0) id += urlAlphabet[Math.random() * 64 | 0];
+	return id;
+};
+//#endregion
+//#region ../../rolldown/packages/rolldown/dist/experimental-runtime-base.mjs
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+//#endregion
+//#region \0@oxc-project+runtime@0.143.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.143.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.143.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.143.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region ../../rolldown/packages/rolldown/dist/experimental-runtime.mjs
+var Module = class {
+	/**
+	* @param {string} id
+	*/
+	constructor(id) {
+		_defineProperty(
+			this,
+			/**
+			* @type {{ exports: any }}
+			*/
+			"exportsHolder",
+			{ exports: null }
+		);
+		_defineProperty(
+			this,
+			/**
+			* @type {string}
+			*/
+			"id",
+			void 0
+		);
+		this.id = id;
+	}
+	get exports() {
+		return this.exportsHolder.exports;
+	}
+};
+/**
+* Compiler-emitted module-graph delta — pure topology (static + dynamic edges).
+* `ids[0, localCount)` are the modules this payload carries; `ids[localCount, …)` are foreign edge targets.
+* `edges[i]` / `dynamicEdges[i]` are the static / dynamic-`import()` out-edges of `ids[i]`.
+* @typedef {{ ids: string[], localCount: number, edges: number[][], dynamicEdges?: number[][] }} ModuleGraphDelta
+* @typedef {{ createModuleHotContext(moduleId: string): any, onModuleCacheRemoval(moduleId: string): void }} DevRuntimeHooks
+*/
+var MissingFactoryError = class extends Error {
+	/**
+	* @param {string} id
+	*/
+	constructor(id) {
+		super(`No factory registered for module ${id}`);
+		this.id = id;
+	}
+};
+var DevRuntime = class {
+	/**
+	* @param {string} clientId
+	*/
+	constructor(clientId) {
+		_defineProperty(
+			this,
+			/**
+			* Client ID generated at runtime initialization, used for lazy compilation requests.
+			* @type {string}
+			*/
+			"clientId",
+			void 0
+		);
+		_defineProperty(
+			this,
+			/**
+			* Static import edges from `registerGraph` — entries persist across `removeModuleCache`
+			* and change only by replacement from a newer payload (last write wins).
+			* @type {Map<string, { edges: string[] }>}
+			*/
+			"staticImports",
+			/* @__PURE__ */ new Map()
+		);
+		_defineProperty(
+			this,
+			/**
+			* Reverse index over the static imports.
+			* @type {Map<string, Set<string>>}
+			*/
+			"importers",
+			/* @__PURE__ */ new Map()
+		);
+		_defineProperty(
+			this,
+			/**
+			* Dynamic `import()` edges from `registerGraph`, keyed by importer — mirror of
+			* `staticImports` for the dynamic reverse index.
+			* @type {Map<string, { edges: string[] }>}
+			*/
+			"dynamicImports",
+			/* @__PURE__ */ new Map()
+		);
+		_defineProperty(
+			this,
+			/**
+			* Reverse index over the dynamic imports.
+			* @type {Map<string, Set<string>>}
+			*/
+			"dynamicImporters",
+			/* @__PURE__ */ new Map()
+		);
+		_defineProperty(
+			this,
+			/**
+			* The module cache. Membership means "this module's side effects ran in this tab" —
+			* registration is emitted ahead of every module body, and nothing un-registers on
+			* unwind, so a factory that throws mid-body stays registered. A `Map` rather than a
+			* plain object: HMR eviction deletes entries, and a `delete` on an object drops V8
+			* into dictionary mode, taxing every later lookup on the hottest read path.
+			* @type {Map<string, Module>}
+			*/
+			"moduleCache",
+			/* @__PURE__ */ new Map()
+		);
+		_defineProperty(
+			this,
+			/**
+			* Re-runnable factories from HMR patches and lazy chunks. The initial bundle stays
+			* scope-hoisted and contributes none.
+			* @type {Map<string, { kind: 'esm' | 'cjs', fn: (id: string) => void }>}
+			*/
+			"factories",
+			/* @__PURE__ */ new Map()
+		);
+		_defineProperty(
+			this,
+			/**
+			* Installed by the dev client at boot. The runtime is a store + executor and makes
+			* no HMR decisions; accepting, disposing, and reloading live behind these hooks.
+			* @type {DevRuntimeHooks | null}
+			*/
+			"hooks",
+			null
+		);
+		_defineProperty(
+			this,
+			/** @internal */
+			"__toESM",
+			__toESM
+		);
+		_defineProperty(
+			this,
+			/** @internal */
+			"__toCommonJS",
+			__toCommonJS
+		);
+		_defineProperty(
+			this,
+			/** @internal */
+			"__exportAll",
+			__exportAll
+		);
+		_defineProperty(
+			this,
+			/**
+			* @param {boolean} [isNodeMode]
+			* @returns {(mod: any) => any}
+			* @internal
+			*/
+			"__toDynamicImportESM",
+			(isNodeMode) => (mod) => __toESM(mod.default, isNodeMode)
+		);
+		_defineProperty(
+			this,
+			/** @internal */
+			"__reExport",
+			__reExport
+		);
+		this.clientId = clientId;
+	}
+	/**
+	* @param {ModuleGraphDelta} delta
+	*/
+	registerGraph(delta) {
+		for (let i = 0; i < delta.localCount; i++) {
+			const id = delta.ids[i];
+			const edges = delta.edges[i].map((j) => delta.ids[j]);
+			for (const target of this.staticImports.get(id)?.edges ?? []) this.importers.get(target)?.delete(id);
+			for (const target of edges) {
+				let importerSet = this.importers.get(target);
+				if (!importerSet) {
+					importerSet = /* @__PURE__ */ new Set();
+					this.importers.set(target, importerSet);
+				}
+				importerSet.add(id);
+			}
+			this.staticImports.set(id, { edges });
+			const dynamicEdges = (delta.dynamicEdges?.[i] ?? []).map((j) => delta.ids[j]);
+			for (const target of this.dynamicImports.get(id)?.edges ?? []) this.dynamicImporters.get(target)?.delete(id);
+			for (const target of dynamicEdges) {
+				let importerSet = this.dynamicImporters.get(target);
+				if (!importerSet) {
+					importerSet = /* @__PURE__ */ new Set();
+					this.dynamicImporters.set(target, importerSet);
+				}
+				importerSet.add(id);
+			}
+			this.dynamicImports.set(id, { edges: dynamicEdges });
+		}
+	}
+	/**
+	* @param {string} id
+	* @param {'esm' | 'cjs'} kind
+	* @param {(id: string) => void} fn
+	*/
+	registerFactory(id, kind, fn) {
+		this.factories.set(id, {
+			kind,
+			fn
+		});
+	}
+	/**
+	* @param {string} id
+	* @param {{ exports: any }} exportsHolder
+	*/
+	registerModule(id, exportsHolder) {
+		const module = new Module(id);
+		module.exportsHolder = exportsHolder;
+		this.moduleCache.set(id, module);
+	}
+	/**
+	* @param {string} id
+	* @returns {string[]}
+	*/
+	getImporters(id) {
+		const dynamic = this.dynamicImporters.get(id);
+		if (!dynamic || dynamic.size === 0) return [...this.importers.get(id) ?? []];
+		return [.../* @__PURE__ */ new Set([...this.importers.get(id) ?? [], ...dynamic])];
+	}
+	/**
+	* @param {string} id
+	*/
+	isExecuted(id) {
+		return this.moduleCache.has(id);
+	}
+	/**
+	* @param {string} id
+	*/
+	hasFactory(id) {
+		return this.factories.has(id);
+	}
+	/**
+	* Module-cache delete only — static imports and factories persist. Removal is what
+	* re-arms a cache-gated factory for `initModule`.
+	* @param {string} id
+	*/
+	removeModuleCache(id) {
+		this.moduleCache.delete(id);
+		this.hooks?.onModuleCacheRemoval(id);
+	}
+	/**
+	* The one re-execution gate: registered → return the live exports; otherwise run the
+	* mapped factory (which registers itself first, then runs the body).
+	* @param {string} id
+	*/
+	initModule(id) {
+		if (this.moduleCache.has(id)) return this.loadExports(id);
+		const factory = this.factories.get(id);
+		if (!factory) throw new MissingFactoryError(id);
+		factory.fn(id);
+		return this.loadExports(id);
+	}
+	/**
+	* @param {string} id
+	*/
+	loadExports(id) {
+		const module = this.moduleCache.get(id);
+		if (module) return module.exportsHolder.exports;
+		else {
+			console.warn(`Module ${id} not found`);
+			return {};
+		}
+	}
+	/**
+	* @param {string} moduleId
+	*/
+	createModuleHotContext(moduleId) {
+		if (this.hooks) return this.hooks.createModuleHotContext(moduleId);
+		throw new Error("createModuleHotContext requires installed hooks or an override");
+	}
+};
+//#endregion
+//#region ../../vite/packages/vite/src/shared/hmr.ts
+var HMRContext = class {
+	constructor(hmrClient, ownerPath) {
+		this.hmrClient = hmrClient;
+		this.ownerPath = ownerPath;
+		_defineProperty(this, "newListeners", void 0);
+		if (!hmrClient.dataMap.has(ownerPath)) hmrClient.dataMap.set(ownerPath, {});
+		const mod = hmrClient.hotModulesMap.get(ownerPath);
+		if (mod) mod.callbacks = [];
+		const staleListeners = hmrClient.ctxToListenersMap.get(ownerPath);
+		if (staleListeners) for (const [event, staleFns] of staleListeners) {
+			const listeners = hmrClient.customListenersMap.get(event);
+			if (listeners) hmrClient.customListenersMap.set(event, listeners.filter((l) => !staleFns.includes(l)));
+		}
+		this.newListeners = /* @__PURE__ */ new Map();
+		hmrClient.ctxToListenersMap.set(ownerPath, this.newListeners);
+	}
+	get data() {
+		return this.hmrClient.dataMap.get(this.ownerPath);
+	}
+	accept(deps, callback) {
+		if (typeof deps === "function" || !deps) this.acceptDeps([this.ownerPath], ([mod]) => deps?.(mod));
+		else if (typeof deps === "string") this.acceptDeps([deps], ([mod]) => callback?.(mod));
+		else if (Array.isArray(deps)) this.acceptDeps(deps, callback);
+		else throw new Error(`invalid hot.accept() usage.`);
+	}
+	acceptExports(_, callback) {
+		this.acceptDeps([this.ownerPath], ([mod]) => callback?.(mod));
+	}
+	dispose(cb) {
+		this.hmrClient.disposeMap.set(this.ownerPath, cb);
+	}
+	prune(cb) {
+		this.hmrClient.pruneMap.set(this.ownerPath, cb);
+	}
+	decline() {}
+	invalidate(message) {
+		const firstInvalidatedBy = this.hmrClient.currentFirstInvalidatedBy ?? this.ownerPath;
+		this.hmrClient.notifyListeners("vite:invalidate", {
+			path: this.ownerPath,
+			message,
+			firstInvalidatedBy
+		});
+		this.send("vite:invalidate", {
+			path: this.ownerPath,
+			message,
+			firstInvalidatedBy
+		});
+		this.hmrClient.logger.debug(`invalidate ${this.ownerPath}${message ? `: ${message}` : ""}`);
+	}
+	on(event, cb) {
+		const addToMap = (map) => {
+			const existing = map.get(event) || [];
+			existing.push(cb);
+			map.set(event, existing);
+		};
+		addToMap(this.hmrClient.customListenersMap);
+		addToMap(this.newListeners);
+	}
+	off(event, cb) {
+		const removeFromMap = (map) => {
+			const existing = map.get(event);
+			if (existing === void 0) return;
+			const pruned = existing.filter((l) => l !== cb);
+			if (pruned.length === 0) {
+				map.delete(event);
+				return;
+			}
+			map.set(event, pruned);
+		};
+		removeFromMap(this.hmrClient.customListenersMap);
+		removeFromMap(this.newListeners);
+	}
+	send(event, data) {
+		this.hmrClient.send({
+			type: "custom",
+			event,
+			data
+		});
+	}
+	acceptDeps(deps, callback = () => {}) {
+		const mod = this.hmrClient.hotModulesMap.get(this.ownerPath) || {
+			id: this.ownerPath,
+			callbacks: []
+		};
+		mod.callbacks.push({
+			deps,
+			fn: callback
+		});
+		this.hmrClient.hotModulesMap.set(this.ownerPath, mod);
+	}
+};
+var HMRClient = class {
+	constructor(logger, transport, importUpdatedModule) {
+		this.logger = logger;
+		this.transport = transport;
+		this.importUpdatedModule = importUpdatedModule;
+		_defineProperty(this, "hotModulesMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "disposeMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "pruneMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "dataMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "customListenersMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "ctxToListenersMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "currentFirstInvalidatedBy", void 0);
+		_defineProperty(this, "updateQueue", []);
+		_defineProperty(this, "pendingUpdateQueue", false);
+	}
+	async notifyListeners(event, data) {
+		const cbs = this.customListenersMap.get(event);
+		if (cbs) await Promise.allSettled(cbs.map((cb) => cb(data)));
+	}
+	send(payload) {
+		this.transport.send(payload).catch((err) => {
+			this.logger.error(err);
+		});
+	}
+	clear() {
+		this.hotModulesMap.clear();
+		this.disposeMap.clear();
+		this.pruneMap.clear();
+		this.dataMap.clear();
+		this.customListenersMap.clear();
+		this.ctxToListenersMap.clear();
+	}
+	async prunePaths(paths) {
+		try {
+			await Promise.all(paths.map((path) => {
+				const disposer = this.disposeMap.get(path);
+				if (disposer) return disposer(this.dataMap.get(path));
+			}));
+			await Promise.all(paths.map((path) => {
+				const fn = this.pruneMap.get(path);
+				if (fn) return fn(this.dataMap.get(path));
+			}));
+		} finally {
+			paths.forEach((path) => this.dataMap.delete(path));
+		}
+	}
+	warnFailedUpdate(err, path) {
+		if (!(err instanceof Error) || !err.message.includes("fetch")) this.logger.error(err);
+		this.logger.error(`Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`);
+	}
+	/**
+	* buffer multiple hot updates triggered by the same src change
+	* so that they are invoked in the same order they were sent.
+	* (otherwise the order may be inconsistent because of the http request round trip)
+	*/
+	async queueUpdate(payload) {
+		this.updateQueue.push(this.fetchUpdate(payload));
+		if (!this.pendingUpdateQueue) {
+			this.pendingUpdateQueue = true;
+			await Promise.resolve();
+			this.pendingUpdateQueue = false;
+			const loading = [...this.updateQueue];
+			this.updateQueue = [];
+			(await Promise.all(loading)).forEach((fn) => fn && fn());
+		}
+	}
+	async fetchUpdate(update) {
+		const { path, acceptedPath, firstInvalidatedBy } = update;
+		const mod = this.hotModulesMap.get(path);
+		if (!mod) return;
+		let fetchedModule;
+		const isSelfUpdate = path === acceptedPath;
+		const qualifiedCallbacks = mod.callbacks.filter(({ deps }) => deps.includes(acceptedPath));
+		if (isSelfUpdate || qualifiedCallbacks.length > 0) {
+			const disposer = this.disposeMap.get(acceptedPath);
+			if (disposer) await disposer(this.dataMap.get(acceptedPath));
+			try {
+				fetchedModule = await this.importUpdatedModule(update);
+			} catch (e) {
+				this.warnFailedUpdate(e, acceptedPath);
+			}
+		}
+		return () => {
+			try {
+				this.currentFirstInvalidatedBy = firstInvalidatedBy;
+				for (const { deps, fn } of qualifiedCallbacks) fn(deps.map((dep) => dep === acceptedPath ? fetchedModule : void 0));
+				const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
+				this.logger.debug(`hot updated: ${loggedPath}`);
+			} finally {
+				this.currentFirstInvalidatedBy = void 0;
+			}
+		};
+	}
+};
+//#endregion
+//#region ../../vite/packages/vite/src/client/bundledDevHmrClient.ts
+var BundledDevHMRClient = class extends HMRClient {
+	constructor(logger, transport, runtime, options) {
+		super(logger, transport, async () => {
+			throw new Error("unreachable: full-bundle mode applies patches through its own queue");
+		});
+		this.runtime = runtime;
+		this.options = options;
+		_defineProperty(this, "applyQueue", Promise.resolve());
+		_defineProperty(this, "lastSeq", 0);
+		_defineProperty(this, "reloadPending", false);
+	}
+	isSelfAccepted(id) {
+		return this.hotModulesMap.get(id)?.callbacks.some((c) => c.deps.includes(id)) ?? false;
+	}
+	acceptsDep(parent, id) {
+		return this.hotModulesMap.get(parent)?.callbacks.some((c) => c.deps.includes(id)) ?? false;
+	}
+	computeHmrUpdate(changedIds, opts) {
+		const boundaries = [];
+		const updateSet = /* @__PURE__ */ new Set();
+		const traversedModules = /* @__PURE__ */ new Set();
+		for (const changed of changedIds) {
+			if (!this.runtime.isExecuted(changed)) continue;
+			const fullReload = this.bubble(changed, [changed], updateSet, boundaries, opts?.firstInvalidatedBy, traversedModules);
+			if (fullReload) return fullReload;
+		}
+		return boundaries.length ? {
+			type: "boundaries",
+			boundaries,
+			updateSet: [...updateSet]
+		} : { type: "noop" };
+	}
+	bubble(id, stack, updateSet, boundaries, firstInvalidatedBy, traversedModules) {
+		if (traversedModules.has(id)) return;
+		traversedModules.add(id);
+		updateSet.add(id);
+		if (firstInvalidatedBy !== void 0 && id === firstInvalidatedBy) return {
+			type: "full-reload",
+			reason: `update propagated back to ${firstInvalidatedBy}, which already called \`import.meta.hot.invalidate()\``
+		};
+		if (this.isSelfAccepted(id)) {
+			boundaries.push([id, id]);
+			return;
+		}
+		const parents = this.runtime.getImporters(id).filter((p) => this.runtime.isExecuted(p));
+		if (!parents.length) return {
+			type: "full-reload",
+			reason: `no hmr boundary found for module \`${id}\``
+		};
+		for (const parent of parents) {
+			if (this.acceptsDep(parent, id)) {
+				boundaries.push([parent, id]);
+				continue;
+			}
+			if (stack.includes(parent)) return {
+				type: "full-reload",
+				reason: `circular import chain between \`${id}\` and \`${parent}\``
+			};
+			const fullReload = this.bubble(parent, [...stack, parent], updateSet, boundaries, firstInvalidatedBy, traversedModules);
+			if (fullReload) return fullReload;
+		}
+	}
+	handlePush(payload) {
+		this.applyQueue = this.applyQueue.then(() => this.applyPush(payload)).catch((err) => {
+			this.warnFailedUpdate(err, payload.changedIds);
+		});
+	}
+	invalidateLocally(id, message) {
+		this.logger.debug(`invalidate ${id}${message ? `: ${message}` : ""}`);
+		this.applyQueue = this.applyQueue.then(() => this.applyInvalidate(id)).catch((err) => {
+			this.warnFailedUpdate(err, id);
+		});
+	}
+	handleModuleCacheRemoval(id) {
+		const disposer = this.disposeMap.get(id);
+		if (disposer) disposer(this.dataMap.get(id));
+	}
+	async applyPush({ changedIds, url, seq }) {
+		if (this.reloadPending) return;
+		if (seq !== this.lastSeq + 1) {
+			this.requestFullReload(`hmr update sequence gap (expected ${this.lastSeq + 1}, got ${seq})`);
+			return;
+		}
+		this.lastSeq = seq;
+		const update = this.computeHmrUpdate(changedIds);
+		if (update.type === "noop") return;
+		if (update.type === "full-reload") {
+			this.requestFullReload(update.reason);
+			return;
+		}
+		const listenerPayload = this.toUpdatePayload(update.boundaries, void 0);
+		await this.notifyListeners("vite:beforeUpdate", listenerPayload);
+		if (this.options.beforeApply() === "reload") return;
+		try {
+			await import(
+				/* @vite-ignore */
+				this.options.base + url
+);
+		} catch {
+			this.requestFullReload(`failed to import hmr patch ${url}`);
+			return;
+		}
+		await this.applyUpdate(update);
+		await this.notifyListeners("vite:afterUpdate", listenerPayload);
+	}
+	async applyInvalidate(id) {
+		if (this.reloadPending) return;
+		const firstInvalidatedBy = this.currentFirstInvalidatedBy ?? id;
+		const importers = this.runtime.getImporters(id).filter((p) => this.runtime.isExecuted(p));
+		if (!importers.length) {
+			this.requestFullReload(`no importers to handle \`import.meta.hot.invalidate()\` called by \`${id}\``);
+			return;
+		}
+		const update = this.computeHmrUpdate(importers, { firstInvalidatedBy });
+		if (update.type === "noop") return;
+		if (update.type === "full-reload") {
+			this.requestFullReload(update.reason);
+			return;
+		}
+		const listenerPayload = this.toUpdatePayload(update.boundaries, firstInvalidatedBy);
+		await this.notifyListeners("vite:beforeUpdate", listenerPayload);
+		if (this.options.beforeApply() === "reload") return;
+		await this.applyUpdate(update, firstInvalidatedBy);
+		await this.notifyListeners("vite:afterUpdate", listenerPayload);
+	}
+	async applyUpdate(update, firstInvalidatedBy) {
+		for (const id of update.updateSet) if (!this.runtime.hasFactory(id)) {
+			this.requestFullReload(`no factory for module \`${id}\``);
+			return;
+		}
+		const applies = update.boundaries.map(([boundary, acceptedVia]) => ({
+			boundary,
+			acceptedVia,
+			callbacks: this.hotModulesMap.get(boundary)?.callbacks.filter((c) => c.deps.includes(acceptedVia)) ?? []
+		}));
+		for (const id of update.updateSet) this.runtime.removeModuleCache(id);
+		for (const { boundary, acceptedVia, callbacks } of applies) {
+			this.runtime.initModule(acceptedVia);
+			const fresh = this.runtime.loadExports(acceptedVia);
+			try {
+				this.currentFirstInvalidatedBy = firstInvalidatedBy;
+				for (const { deps, fn } of callbacks) fn(deps.map((dep) => dep === acceptedVia ? fresh : void 0));
+			} finally {
+				this.currentFirstInvalidatedBy = void 0;
+			}
+			this.logger.debug(`hot updated: ${boundary === acceptedVia ? boundary : `${acceptedVia} via ${boundary}`}`);
+		}
+	}
+	toUpdatePayload(boundaries, firstInvalidatedBy) {
+		return {
+			type: "update",
+			updates: boundaries.map(([boundary, acceptedVia]) => ({
+				type: "js-update",
+				path: boundary,
+				acceptedPath: acceptedVia,
+				timestamp: Date.now(),
+				firstInvalidatedBy
+			}))
+		};
+	}
+	requestFullReload(reason) {
+		if (this.reloadPending) return;
+		this.reloadPending = true;
+		this.logger.debug(`full reload needed: ${reason}`);
+		this.send({
+			type: "custom",
+			event: "vite:bundled-dev:reload-needed",
+			data: { reason }
+		});
+	}
+};
+var BundledDevHMRContext = class extends HMRContext {
+	constructor(bundledDevClient, owner) {
+		super(bundledDevClient, owner);
+		this.bundledDevClient = bundledDevClient;
+		this.owner = owner;
+	}
+	invalidate(message) {
+		this.bundledDevClient.notifyListeners("vite:invalidate", {
+			path: this.owner,
+			message,
+			firstInvalidatedBy: this.bundledDevClient.currentFirstInvalidatedBy ?? this.owner
+		});
+		this.bundledDevClient.invalidateLocally(this.owner, message);
+	}
+};
+//#endregion
+//#region ../../vite/packages/vite/src/shared/constants.ts
+let SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+typeof process !== "undefined" && process.platform;
+(async function() {}).constructor;
+function promiseWithResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((_resolve, _reject) => {
+			resolve = _resolve;
+			reject = _reject;
+		}),
+		resolve,
+		reject
+	};
+}
+//#endregion
+//#region ../../vite/packages/vite/src/shared/moduleRunnerTransport.ts
+function reviveInvokeError(e) {
+	const error = new Error(e.message || "Unknown invoke error");
+	Object.assign(error, e, { runnerError: /* @__PURE__ */ new Error("RunnerError") });
+	return error;
+}
+const createInvokeableTransport = (transport) => {
+	if (transport.invoke) return {
+		...transport,
+		async invoke(name, data) {
+			const result = await transport.invoke({
+				type: "custom",
+				event: "vite:invoke",
+				data: {
+					id: "send",
+					name,
+					data
+				}
+			});
+			if ("error" in result) throw reviveInvokeError(result.error);
+			return result.result;
+		}
+	};
+	if (!transport.send || !transport.connect) throw new Error("transport must implement send and connect when invoke is not implemented");
+	const rpcPromises = /* @__PURE__ */ new Map();
+	return {
+		...transport,
+		connect({ onMessage, onDisconnection }) {
+			return transport.connect({
+				onMessage(payload) {
+					if (payload.type === "custom" && payload.event === "vite:invoke") {
+						const data = payload.data;
+						if (data.id.startsWith("response:")) {
+							const invokeId = data.id.slice(9);
+							const promise = rpcPromises.get(invokeId);
+							if (!promise) return;
+							if (promise.timeoutId) clearTimeout(promise.timeoutId);
+							rpcPromises.delete(invokeId);
+							const { error, result } = data.data;
+							if (error) promise.reject(error);
+							else promise.resolve(result);
+							return;
+						}
+					}
+					onMessage(payload);
+				},
+				onDisconnection
+			});
+		},
+		disconnect() {
+			rpcPromises.forEach((promise) => {
+				promise.reject(/* @__PURE__ */ new Error(`transport was disconnected, cannot call ${JSON.stringify(promise.name)}`));
+			});
+			rpcPromises.clear();
+			return transport.disconnect?.();
+		},
+		send(data) {
+			return transport.send(data);
+		},
+		async invoke(name, data) {
+			const promiseId = nanoid();
+			const wrappedData = {
+				type: "custom",
+				event: "vite:invoke",
+				data: {
+					name,
+					id: `send:${promiseId}`,
+					data
+				}
+			};
+			const sendPromise = transport.send(wrappedData);
+			const { promise, resolve, reject } = promiseWithResolvers();
+			const timeout = transport.timeout ?? 6e4;
+			let timeoutId;
+			if (timeout > 0) {
+				timeoutId = setTimeout(() => {
+					rpcPromises.delete(promiseId);
+					reject(/* @__PURE__ */ new Error(`transport invoke timed out after ${timeout}ms (data: ${JSON.stringify(wrappedData)})`));
+				}, timeout);
+				timeoutId?.unref?.();
+			}
+			rpcPromises.set(promiseId, {
+				resolve,
+				reject,
+				name,
+				timeoutId
+			});
+			if (sendPromise) sendPromise.catch((err) => {
+				clearTimeout(timeoutId);
+				rpcPromises.delete(promiseId);
+				reject(err);
+			});
+			try {
+				return await promise;
+			} catch (err) {
+				throw reviveInvokeError(err);
+			}
+		}
+	};
+};
+const normalizeModuleRunnerTransport = (transport) => {
+	const invokeableTransport = createInvokeableTransport(transport);
+	let isConnected = !invokeableTransport.connect;
+	let connectingPromise;
+	return {
+		...transport,
+		...invokeableTransport.connect ? { async connect(onMessage) {
+			if (isConnected) return;
+			if (connectingPromise) {
+				await connectingPromise;
+				return;
+			}
+			const maybePromise = invokeableTransport.connect({
+				onMessage: onMessage ?? (() => {}),
+				onDisconnection() {
+					isConnected = false;
+				}
+			});
+			if (maybePromise) {
+				connectingPromise = maybePromise;
+				await connectingPromise;
+				connectingPromise = void 0;
+			}
+			isConnected = true;
+		} } : {},
+		...invokeableTransport.disconnect ? { async disconnect() {
+			if (!isConnected) return;
+			if (connectingPromise) await connectingPromise;
+			isConnected = false;
+			await invokeableTransport.disconnect();
+		} } : {},
+		async send(data) {
+			if (!invokeableTransport.send) return;
+			if (!isConnected) {
+				if (connectingPromise) await connectingPromise;
+				else throw new SendBeforeConnectError("send was called before connect");
+			}
+			await invokeableTransport.send(data);
+		},
+		async invoke(name, data) {
+			if (!isConnected) {
+				if (connectingPromise) await connectingPromise;
+				else throw new SendBeforeConnectError("invoke was called before connect");
+			}
+			return invokeableTransport.invoke(name, data);
+		}
+	};
+};
+var SendBeforeConnectError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SendBeforeConnectError";
+	}
+};
+const createWebSocketModuleRunnerTransport = (options) => {
+	const pingInterval = options.pingInterval ?? 3e4;
+	let ws;
+	let pingIntervalId;
+	return {
+		async connect({ onMessage, onDisconnection }) {
+			const socket = options.createConnection();
+			socket.addEventListener("message", ({ data }) => {
+				onMessage(JSON.parse(data));
+			});
+			let isOpened = socket.readyState === socket.OPEN;
+			if (!isOpened) await new Promise((resolve, reject) => {
+				socket.addEventListener("open", () => {
+					isOpened = true;
+					resolve();
+				}, { once: true });
+				socket.addEventListener("close", () => {
+					if (!isOpened) {
+						reject(/* @__PURE__ */ new Error("WebSocket closed without opened."));
+						return;
+					}
+					onMessage({
+						type: "custom",
+						event: "vite:ws:disconnect",
+						data: { webSocket: socket }
+					});
+					onDisconnection();
+				});
+			});
+			onMessage({
+				type: "custom",
+				event: "vite:ws:connect",
+				data: { webSocket: socket }
+			});
+			ws = socket;
+			pingIntervalId = setInterval(() => {
+				if (socket.readyState === socket.OPEN) socket.send(JSON.stringify({ type: "ping" }));
+			}, pingInterval);
+		},
+		disconnect() {
+			clearInterval(pingIntervalId);
+			ws?.close();
+		},
+		send(data) {
+			ws.send(JSON.stringify(data));
+		}
+	};
+};
+//#endregion
+//#region ../../vite/packages/vite/src/shared/hmrHandler.ts
+function createHMRHandler(handler) {
+	const queue = new Queue();
+	return (payload) => queue.enqueue(() => handler(payload));
+}
+var Queue = class {
+	constructor() {
+		_defineProperty(this, "queue", []);
+		_defineProperty(this, "pending", false);
+	}
+	enqueue(promise) {
+		return new Promise((resolve, reject) => {
+			this.queue.push({
+				promise,
+				resolve,
+				reject
+			});
+			this.dequeue();
+		});
+	}
+	dequeue() {
+		if (this.pending) return false;
+		const item = this.queue.shift();
+		if (!item) return false;
+		this.pending = true;
+		item.promise().then(item.resolve).catch(item.reject).finally(() => {
+			this.pending = false;
+			this.dequeue();
+		});
+		return true;
+	}
+};
+//#endregion
+//#region ../../vite/packages/vite/src/shared/forwardConsole.ts
+function setupForwardConsoleHandler(transport, options, console = globalThis.console) {
+	if (!options.enabled) return;
+	async function sendError(type, error) {
+		await transport.send({
+			type: "custom",
+			event: "vite:forward-console",
+			data: {
+				type,
+				data: {
+					name: error?.name || "Unknown Error",
+					message: error?.message || String(error),
+					stack: error?.stack
+				}
+			}
+		});
+	}
+	async function sendLog(level, args) {
+		try {
+			await transport.send({
+				type: "custom",
+				event: "vite:forward-console",
+				data: {
+					type: "log",
+					data: {
+						level,
+						message: formatConsoleArgs(args)
+					}
+				}
+			});
+		} catch (err) {
+			try {
+				await sendError("unhandled-rejection", err);
+			} catch (err) {
+				if (!(err instanceof SendBeforeConnectError)) originalConsoleError("Failed to send error to Vite server:", err);
+			}
+		}
+	}
+	const originalConsoleError = console.error;
+	for (const level of options.logLevels) {
+		const original = console[level];
+		if (typeof original !== "function") continue;
+		console[level] = (...args) => {
+			original(...args);
+			sendLog(level, args);
+		};
+	}
+	if (options.unhandledErrors && typeof window !== "undefined") {
+		window.addEventListener("error", async (event) => {
+			const error = event.error ?? (event.message ? new Error(event.message) : event);
+			try {
+				await sendError("error", error);
+			} catch (err) {
+				if (!(err instanceof SendBeforeConnectError)) originalConsoleError("Failed to send error to Vite server:", err);
+			}
+		});
+		window.addEventListener("unhandledrejection", async (event) => {
+			try {
+				await sendError("unhandled-rejection", event.reason);
+			} catch (err) {
+				if (!(err instanceof SendBeforeConnectError)) originalConsoleError("Failed to send error to Vite server:", err);
+			}
+		});
+	}
+}
+function formatConsoleArgs(args) {
+	if (args.length === 0) return "";
+	if (typeof args[0] !== "string") return args.map((arg) => stringifyConsoleArg(arg)).join(" ");
+	const len = args.length;
+	let i = 1;
+	let message = args[0].replace(/%[sdjifoOc%]/g, (specifier) => {
+		if (specifier === "%%") return "%";
+		if (i >= len) return specifier;
+		const arg = args[i++];
+		switch (specifier) {
+			case "%s":
+				if (typeof arg === "bigint") return `${arg.toString()}n`;
+				return typeof arg === "object" && arg != null ? stringifyConsoleArg(arg) : String(arg);
+			case "%d":
+				if (typeof arg === "bigint") return `${arg.toString()}n`;
+				if (typeof arg === "symbol") return "NaN";
+				return Number(arg).toString();
+			case "%i":
+				if (typeof arg === "bigint") return `${arg.toString()}n`;
+				return Number.parseInt(String(arg), 10).toString();
+			case "%f": return Number.parseFloat(String(arg)).toString();
+			case "%o":
+			case "%O": return stringifyConsoleArg(arg);
+			case "%j": try {
+				return JSON.stringify(arg) ?? "undefined";
+			} catch {
+				return "[Circular]";
+			}
+			case "%c": return "";
+			default: return specifier;
+		}
+	});
+	for (let arg = args[i]; i < len; arg = args[++i]) if (arg == null || typeof arg !== "object") message += ` ${typeof arg === "symbol" ? arg.toString() : String(arg)}`;
+	else message += ` ${stringifyConsoleArg(arg)}`;
+	return message;
+}
+function stringifyConsoleArg(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "undefined") return String(value);
+	if (typeof value === "symbol") return value.toString();
+	if (typeof value === "function") return value.name ? `[Function: ${value.name}]` : "[Function]";
+	if (value instanceof Error) return value.stack || `${value.name}: ${value.message}`;
+	if (typeof value === "bigint") return `${value}n`;
+	const seen = /* @__PURE__ */ new WeakSet();
+	try {
+		return JSON.stringify(value, (_, nested) => {
+			if (typeof nested === "bigint") return `${nested}n`;
+			if (nested instanceof Error) return {
+				name: nested.name,
+				message: nested.message,
+				stack: nested.stack
+			};
+			if (nested && typeof nested === "object") {
+				if (seen.has(nested)) return "[Circular]";
+				seen.add(nested);
+			}
+			return nested;
+		}) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+//#endregion
+//#region ../../vite/packages/vite/src/client/overlay.ts
+const hmrConfigName = __HMR_CONFIG_NAME__;
+const base$1 = __BASE__ || "/";
+const cspNonce = "document" in globalThis ? document.querySelector("meta[property=csp-nonce]")?.nonce : void 0;
+function h(e, attrs = {}, ...children) {
+	const elem = document.createElement(e);
+	for (const [k, v] of Object.entries(attrs)) if (v !== void 0) elem.setAttribute(k, v);
+	elem.append(...children);
+	return elem;
+}
+const templateStyle = `
+:host {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  z-index: 99999;
+  --monospace: 'SFMono-Regular', Consolas,
+  'Liberation Mono', Menlo, Courier, monospace;
+  --red: #ff5555;
+  --yellow: #e2aa53;
+  --purple: #cfa4ff;
+  --cyan: #2dd9da;
+  --dim: #c9c9c9;
+
+  --window-background: #181818;
+  --window-color: #d8d8d8;
+}
+
+.backdrop {
+  position: fixed;
+  z-index: 99999;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  overflow-y: scroll;
+  margin: 0;
+  background: rgba(0, 0, 0, 0.66);
+}
+
+.window {
+  font-family: var(--monospace);
+  line-height: 1.5;
+  max-width: 80vw;
+  color: var(--window-color);
+  box-sizing: border-box;
+  margin: 30px auto;
+  padding: 2.5vh 4vw;
+  position: relative;
+  background: var(--window-background);
+  border-radius: 6px 6px 8px 8px;
+  box-shadow: 0 19px 38px rgba(0,0,0,0.30), 0 15px 12px rgba(0,0,0,0.22);
+  overflow: hidden;
+  border-top: 8px solid var(--red);
+  direction: ltr;
+  text-align: left;
+}
+
+pre {
+  font-family: var(--monospace);
+  font-size: 16px;
+  margin-top: 0;
+  margin-bottom: 1em;
+  overflow-x: scroll;
+  scrollbar-width: none;
+}
+
+pre::-webkit-scrollbar {
+  display: none;
+}
+
+pre.frame::-webkit-scrollbar {
+  display: block;
+  height: 5px;
+}
+
+pre.frame::-webkit-scrollbar-thumb {
+  background: #999;
+  border-radius: 5px;
+}
+
+pre.frame {
+  scrollbar-width: thin;
+}
+
+.message {
+  line-height: 1.3;
+  font-weight: 400;
+  white-space: pre-wrap;
+}
+
+.message-body {
+  color: var(--red);
+}
+
+.plugin {
+  color: var(--purple);
+}
+
+.file {
+  color: var(--cyan);
+  margin-bottom: 0;
+  white-space: pre-wrap;
+  word-break: break-all;
+}
+
+.frame {
+  color: var(--yellow);
+}
+
+.stack {
+  font-size: 13px;
+  color: var(--dim);
+}
+
+.tip {
+  font-size: 13px;
+  color: #999;
+  border-top: 1px dotted #999;
+  padding-top: 13px;
+  line-height: 1.8;
+}
+
+code {
+  font-size: 13px;
+  font-family: var(--monospace);
+  color: var(--yellow);
+}
+
+.file-link {
+  text-decoration: underline;
+  cursor: pointer;
+}
+
+kbd {
+  line-height: 1.5;
+  font-family: ui-monospace, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  font-size: 0.75rem;
+  font-weight: 700;
+  background-color: rgb(38, 40, 44);
+  color: rgb(166, 167, 171);
+  padding: 0.15rem 0.3rem;
+  border-radius: 0.25rem;
+  border-width: 0.0625rem 0.0625rem 0.1875rem;
+  border-style: solid;
+  border-color: rgb(54, 57, 64);
+  border-image: initial;
+}
+`;
+const createTemplate = () => h("div", {
+	class: "backdrop",
+	part: "backdrop"
+}, h("div", {
+	class: "window",
+	part: "window"
+}, h("pre", {
+	class: "message",
+	part: "message"
+}, h("span", {
+	class: "plugin",
+	part: "plugin"
+}), h("span", {
+	class: "message-body",
+	part: "message-body"
+})), h("pre", {
+	class: "file",
+	part: "file"
+}), h("pre", {
+	class: "frame",
+	part: "frame"
+}), h("pre", {
+	class: "stack",
+	part: "stack"
+}), h("div", {
+	class: "tip",
+	part: "tip"
+}, "Click outside, press ", h("kbd", {}, "Esc"), " key, or fix the code to dismiss.", h("br"), "You can also disable this overlay by setting ", h("code", { part: "config-option-name" }, "server.hmr.overlay"), " to ", h("code", { part: "config-option-value" }, "false"), " in ", h("code", { part: "config-file-name" }, hmrConfigName), ".")), h("style", { nonce: cspNonce }, templateStyle));
+const fileRE = /(?:file:\/\/)?(?:[a-zA-Z]:\\|\/).*?:\d+:\d+/g;
+const codeframeRE = /^(?:>?\s*\d+\s+\|.*|\s+\|\s*\^.*)\r?\n/gm;
+const { HTMLElement = class {} } = globalThis;
+var ErrorOverlay = class extends HTMLElement {
+	constructor(err, links = true) {
+		super();
+		_defineProperty(this, "root", void 0);
+		_defineProperty(this, "closeOnEsc", void 0);
+		this.root = this.attachShadow({ mode: "open" });
+		this.root.appendChild(createTemplate());
+		codeframeRE.lastIndex = 0;
+		const hasFrame = err.frame && codeframeRE.test(err.frame);
+		const message = hasFrame ? err.message.replace(codeframeRE, "") : err.message;
+		if (err.plugin) this.text(".plugin", `[plugin:${err.plugin}] `);
+		this.text(".message-body", message.trim());
+		const [file] = (err.loc?.file || err.id || "unknown file").split(`?`);
+		if (err.loc) this.text(".file", `${file}:${err.loc.line}:${err.loc.column}`, links);
+		else if (err.id) this.text(".file", file);
+		if (hasFrame) this.text(".frame", err.frame.trim());
+		this.text(".stack", err.stack, links);
+		this.root.querySelector(".window").addEventListener("click", (e) => {
+			e.stopPropagation();
+		});
+		this.addEventListener("click", () => {
+			this.close();
+		});
+		this.closeOnEsc = (e) => {
+			if (e.key === "Escape" || e.code === "Escape") this.close();
+		};
+		document.addEventListener("keydown", this.closeOnEsc);
+	}
+	text(selector, text, linkFiles = false) {
+		const el = this.root.querySelector(selector);
+		if (!linkFiles) el.textContent = text;
+		else {
+			let curIndex = 0;
+			let match;
+			fileRE.lastIndex = 0;
+			while (match = fileRE.exec(text)) {
+				const { 0: file, index } = match;
+				const frag = text.slice(curIndex, index);
+				el.appendChild(document.createTextNode(frag));
+				const link = document.createElement("a");
+				link.textContent = file;
+				link.className = "file-link";
+				link.onclick = () => {
+					fetch(new URL(`${base$1}__open-in-editor?file=${encodeURIComponent(file)}`, import.meta.url));
+				};
+				el.appendChild(link);
+				curIndex += frag.length + file.length;
+			}
+			if (curIndex < text.length) el.appendChild(document.createTextNode(text.slice(curIndex)));
+		}
+	}
+	close() {
+		this.parentNode?.removeChild(this);
+		document.removeEventListener("keydown", this.closeOnEsc);
+	}
+};
+const overlayId = "vite-error-overlay";
+const { customElements } = globalThis;
+if (customElements && !customElements.get("vite-error-overlay")) customElements.define(overlayId, ErrorOverlay);
+//#endregion
+//#region ../../vite/packages/vite/src/client/client.ts
+console.debug("[vite] connecting...");
+const importMetaUrl = new URL(import.meta.url);
+const serverHost = __SERVER_HOST__;
+const socketProtocol = __HMR_PROTOCOL__ || (importMetaUrl.protocol === "https:" ? "wss" : "ws");
+const hmrPort = __HMR_PORT__;
+const socketHost = `${__HMR_HOSTNAME__ || importMetaUrl.hostname}:${hmrPort || importMetaUrl.port}${__HMR_BASE__}`;
+const directSocketHost = __HMR_DIRECT_TARGET__;
+const base = __BASE__ || "/";
+const hmrTimeout = __HMR_TIMEOUT__;
+const wsToken = __WS_TOKEN__;
+const forwardConsole = __SERVER_FORWARD_CONSOLE__;
+const transport = normalizeModuleRunnerTransport((() => {
+	let wsTransport = createWebSocketModuleRunnerTransport({
+		createConnection: () => new WebSocket(`${socketProtocol}://${socketHost}?token=${wsToken}`, "vite-hmr"),
+		pingInterval: hmrTimeout
+	});
+	return {
+		async connect(handlers) {
+			try {
+				await wsTransport.connect(handlers);
+			} catch (e) {
+				if (!hmrPort) {
+					wsTransport = createWebSocketModuleRunnerTransport({
+						createConnection: () => new WebSocket(`${socketProtocol}://${directSocketHost}?token=${wsToken}`, "vite-hmr"),
+						pingInterval: hmrTimeout
+					});
+					try {
+						await wsTransport.connect(handlers);
+						console.info("[vite] Direct websocket connection fallback. Check out https://vite.dev/config/server-options.html#server-hmr to remove the previous connection error.");
+					} catch (e) {
+						if (e instanceof Error && e.message.includes("WebSocket closed without opened.")) {
+							const currentScriptHostURL = new URL(import.meta.url);
+							const currentScriptHost = currentScriptHostURL.host + currentScriptHostURL.pathname.replace(/@vite\/client$/, "");
+							console.error(`[vite] failed to connect to websocket.
+your current setup:
+  (browser) ${currentScriptHost} <--[HTTP]--> ${serverHost} (server)\n  (browser) ${socketHost} <--[WebSocket (failing)]--> ${directSocketHost} (server)\nCheck out your Vite / network configuration and https://vite.dev/config/server-options.html#server-hmr .`);
+						}
+					}
+					return;
+				}
+				console.error(`[vite] failed to connect to websocket (${e}). `);
+				throw e;
+			}
+		},
+		async disconnect() {
+			await wsTransport.disconnect();
+		},
+		send(data) {
+			wsTransport.send(data);
+		}
+	};
+})());
+let willUnload = false;
+if (typeof window !== "undefined") window.addEventListener?.("beforeunload", () => {
+	willUnload = true;
+});
+function cleanUrl(pathname) {
+	const url = new URL(pathname, "http://vite.dev");
+	url.searchParams.delete("direct");
+	return url.pathname + url.search;
+}
+let isFirstUpdate = true;
+const outdatedLinkTags = /* @__PURE__ */ new WeakSet();
+const debounceReload = (time) => {
+	let timer;
+	return () => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = null;
+		}
+		timer = setTimeout(() => {
+			location.reload();
+		}, time);
+	};
+};
+const pageReload = debounceReload(20);
+const hmrClient = new HMRClient({
+	error: (err) => console.error("[vite]", err),
+	debug: (...msg) => console.debug("[vite]", ...msg)
+}, transport, async function importUpdatedModule({ acceptedPath, timestamp, explicitImportRequired, isWithinCircularImport }) {
+	const [acceptedPathWithoutQuery, query] = acceptedPath.split(`?`);
+	const importPromise = import(
+		/* @vite-ignore */
+		base + acceptedPathWithoutQuery.slice(1) + `?${explicitImportRequired ? "import&" : ""}t=${timestamp}${query ? `&${query}` : ""}`
+);
+	if (isWithinCircularImport) importPromise.catch(() => {
+		console.info(`[hmr] ${acceptedPath} failed to apply HMR as it's within a circular import. Reloading page to reset the execution order. To debug and break the circular import, you can run \`vite --debug hmr\` to log the circular dependency path if a file change triggered it.`);
+		pageReload();
+	});
+	return await importPromise;
+});
+let bundledDevClient;
+function registerBundledDevClient(client) {
+	bundledDevClient = client;
+}
+transport.connect(createHMRHandler(handleMessage));
+setupForwardConsoleHandler(transport, forwardConsole);
+function clearOverlayOrReloadOnFirstUpdate() {
+	if (hasDocument) {
+		if (isFirstUpdate && hasErrorOverlay()) {
+			location.reload();
+			return "reload";
+		}
+		if (enableOverlay) clearErrorOverlay();
+		isFirstUpdate = false;
+	}
+	return "continue";
+}
+async function handleMessage(payload) {
+	const activeHmrClient = bundledDevClient ?? hmrClient;
+	switch (payload.type) {
+		case "connected":
+			console.debug(`[vite] connected.`);
+			break;
+		case "bundled-dev-update":
+			bundledDevClient.handlePush(payload);
+			break;
+		case "update":
+			await activeHmrClient.notifyListeners("vite:beforeUpdate", payload);
+			if (clearOverlayOrReloadOnFirstUpdate() === "reload") return;
+			await Promise.all(payload.updates.map(async (update) => {
+				if (update.type === "js-update") return hmrClient.queueUpdate(update);
+				const { path, timestamp } = update;
+				const searchUrl = cleanUrl(path);
+				const el = Array.from(document.querySelectorAll("link")).find((e) => !outdatedLinkTags.has(e) && cleanUrl(e.href).includes(searchUrl));
+				if (!el) return;
+				const newPath = `${base}${searchUrl.slice(1)}${searchUrl.includes("?") ? "&" : "?"}t=${timestamp}`;
+				return new Promise((resolve) => {
+					const newLinkTag = el.cloneNode();
+					newLinkTag.href = new URL(newPath, el.href).href;
+					const removeOldEl = () => {
+						el.remove();
+						console.debug(`[vite] css hot updated: ${searchUrl}`);
+						resolve();
+					};
+					newLinkTag.addEventListener("load", removeOldEl);
+					newLinkTag.addEventListener("error", removeOldEl);
+					outdatedLinkTags.add(el);
+					el.after(newLinkTag);
+				});
+			}));
+			await activeHmrClient.notifyListeners("vite:afterUpdate", payload);
+			break;
+		case "custom":
+			await activeHmrClient.notifyListeners(payload.event, payload.data);
+			if (payload.event === "vite:ws:disconnect") {
+				if (hasDocument && !willUnload) {
+					console.log(`[vite] server connection lost. Polling for restart...`);
+					const socket = payload.data.webSocket;
+					const url = new URL(socket.url);
+					url.search = "";
+					await waitForSuccessfulPing(url.href);
+					location.reload();
+				}
+			}
+			break;
+		case "full-reload":
+			if (payload.ifFallback && !globalThis.__vite_is_fallback_page__) break;
+			await activeHmrClient.notifyListeners("vite:beforeFullReload", payload);
+			if (hasDocument) {
+				if (payload.path && payload.path.endsWith(".html")) {
+					const pagePath = decodeURI(location.pathname);
+					const payloadPath = base + payload.path.slice(1);
+					if (pagePath === payloadPath || payload.path === "/index.html" || pagePath.endsWith("/") && pagePath + "index.html" === payloadPath) pageReload();
+					return;
+				} else pageReload();
+			}
+			break;
+		case "prune":
+			await activeHmrClient.notifyListeners("vite:beforePrune", payload);
+			await activeHmrClient.prunePaths(payload.paths);
+			break;
+		case "error":
+			await activeHmrClient.notifyListeners("vite:error", payload);
+			if (hasDocument) {
+				const err = payload.err;
+				if (enableOverlay) createErrorOverlay(err);
+				else console.error(`[vite] Internal Server Error\n${err.message}\n${err.stack}`);
+			}
+			break;
+		case "ping": break;
+		default: return payload;
+	}
+}
+const enableOverlay = __HMR_ENABLE_OVERLAY__;
+const hasDocument = "document" in globalThis;
+function createErrorOverlay(err) {
+	clearErrorOverlay();
+	const { customElements } = globalThis;
+	if (customElements) {
+		const ErrorOverlayConstructor = customElements.get(overlayId);
+		document.body.appendChild(new ErrorOverlayConstructor(err));
+	}
+}
+function clearErrorOverlay() {
+	document.querySelectorAll(overlayId).forEach((n) => n.close());
+}
+function hasErrorOverlay() {
+	return document.querySelectorAll(overlayId).length;
+}
+function waitForSuccessfulPing(socketUrl) {
+	if (typeof SharedWorker === "undefined") {
+		const visibilityManager = {
+			currentState: document.visibilityState,
+			listeners: /* @__PURE__ */ new Set()
+		};
+		const onVisibilityChange = () => {
+			visibilityManager.currentState = document.visibilityState;
+			for (const listener of visibilityManager.listeners) listener(visibilityManager.currentState);
+		};
+		document.addEventListener("visibilitychange", onVisibilityChange);
+		return waitForSuccessfulPingInternal(socketUrl, visibilityManager);
+	}
+	const blob = new Blob([
+		"\"use strict\";",
+		`const waitForSuccessfulPingInternal = ${waitForSuccessfulPingInternal.toString()};`,
+		`const fn = ${pingWorkerContentMain.toString()};`,
+		`fn(${JSON.stringify(socketUrl)})`
+	], { type: "application/javascript" });
+	const objURL = URL.createObjectURL(blob);
+	const sharedWorker = new SharedWorker(objURL);
+	return new Promise((resolve, reject) => {
+		const onVisibilityChange = () => {
+			sharedWorker.port.postMessage({ visibility: document.visibilityState });
+		};
+		document.addEventListener("visibilitychange", onVisibilityChange);
+		sharedWorker.port.addEventListener("message", (event) => {
+			document.removeEventListener("visibilitychange", onVisibilityChange);
+			sharedWorker.port.close();
+			const data = event.data;
+			if (data.type === "error") {
+				reject(data.error);
+				return;
+			}
+			resolve();
+		});
+		onVisibilityChange();
+		sharedWorker.port.start();
+	});
+}
+function pingWorkerContentMain(socketUrl) {
+	self.addEventListener("connect", (_event) => {
+		const port = _event.ports[0];
+		if (!socketUrl) {
+			port.postMessage({
+				type: "error",
+				error: /* @__PURE__ */ new Error("socketUrl not found")
+			});
+			return;
+		}
+		const visibilityManager = {
+			currentState: "visible",
+			listeners: /* @__PURE__ */ new Set()
+		};
+		port.addEventListener("message", (event) => {
+			const { visibility } = event.data;
+			visibilityManager.currentState = visibility;
+			console.debug("[vite] new window visibility", visibility);
+			for (const listener of visibilityManager.listeners) listener(visibility);
+		});
+		port.start();
+		console.debug("[vite] connected from window");
+		waitForSuccessfulPingInternal(socketUrl, visibilityManager).then(() => {
+			console.debug("[vite] ping successful");
+			try {
+				port.postMessage({ type: "success" });
+			} catch (error) {
+				port.postMessage({
+					type: "error",
+					error
+				});
+			}
+		}, (error) => {
+			console.debug("[vite] error happened", error);
+			try {
+				port.postMessage({
+					type: "error",
+					error
+				});
+			} catch (error) {
+				port.postMessage({
+					type: "error",
+					error
+				});
+			}
+		});
+	});
+}
+async function waitForSuccessfulPingInternal(socketUrl, visibilityManager, ms = 1e3) {
+	function wait(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+	async function ping() {
+		try {
+			const socket = new WebSocket(socketUrl, "vite-ping");
+			return new Promise((resolve) => {
+				function onOpen() {
+					resolve(true);
+					close();
+				}
+				function onError() {
+					resolve(false);
+					close();
+				}
+				function close() {
+					socket.removeEventListener("open", onOpen);
+					socket.removeEventListener("error", onError);
+					socket.close();
+				}
+				socket.addEventListener("open", onOpen);
+				socket.addEventListener("error", onError);
+			});
+		} catch {
+			return false;
+		}
+	}
+	function waitForWindowShow(visibilityManager) {
+		return new Promise((resolve) => {
+			const onChange = (newVisibility) => {
+				if (newVisibility === "visible") {
+					resolve();
+					visibilityManager.listeners.delete(onChange);
+				}
+			};
+			visibilityManager.listeners.add(onChange);
+		});
+	}
+	if (await ping()) return;
+	await wait(ms);
+	while (true) if (visibilityManager.currentState === "visible") {
+		if (await ping()) break;
+		await wait(ms);
+	} else await waitForWindowShow(visibilityManager);
+}
+const sheetsMap = /* @__PURE__ */ new Map();
+const linkSheetsMap = /* @__PURE__ */ new Map();
+if ("document" in globalThis) {
+	document.querySelectorAll("style[data-vite-dev-id]").forEach((el) => {
+		sheetsMap.set(el.getAttribute("data-vite-dev-id"), el);
+	});
+	document.querySelectorAll("link[rel=\"stylesheet\"][data-vite-dev-id]").forEach((el) => {
+		linkSheetsMap.set(el.getAttribute("data-vite-dev-id"), el);
+	});
+}
+let lastInsertedStyle;
+function updateStyle(id, content) {
+	if (linkSheetsMap.has(id)) return;
+	let style = sheetsMap.get(id);
+	if (!style) {
+		style = document.createElement("style");
+		style.setAttribute("type", "text/css");
+		style.setAttribute("data-vite-dev-id", id);
+		style.textContent = content;
+		if (cspNonce) style.setAttribute("nonce", cspNonce);
+		if (!lastInsertedStyle) {
+			document.head.appendChild(style);
+			setTimeout(() => {
+				lastInsertedStyle = void 0;
+			}, 0);
+		} else lastInsertedStyle.insertAdjacentElement("afterend", style);
+		lastInsertedStyle = style;
+	} else style.textContent = content;
+	sheetsMap.set(id, style);
+}
+function removeStyle(id) {
+	if (linkSheetsMap.has(id)) {
+		document.querySelectorAll(`link[rel="stylesheet"][data-vite-dev-id="${CSS.escape(id)}"]`).forEach((el) => el.remove());
+		linkSheetsMap.delete(id);
+	}
+	const style = sheetsMap.get(id);
+	if (style) {
+		document.head.removeChild(style);
+		sheetsMap.delete(id);
+	}
+}
+function createHotContext(ownerPath) {
+	return new HMRContext(hmrClient, ownerPath);
+}
+/**
+* urls here are dynamic import() urls that couldn't be statically analyzed
+*/
+function injectQuery(url, queryToInject) {
+	if (url[0] !== "." && url[0] !== "/") return url;
+	const pathname = url.replace(/[?#].*$/, "");
+	const { search, hash } = new URL(url, "http://vite.dev");
+	return `${pathname}?${queryToInject}${search ? `&` + search.slice(1) : ""}${hash || ""}`;
+}
+//#endregion
+//#region ../../vite/packages/vite/src/client/bundledDevClient.ts
+if (typeof DevRuntime !== "undefined") {
+	var _ref;
+	class ViteDevRuntime extends DevRuntime {
+		createModuleHotContext(moduleId) {
+			const ctx = new BundledDevHMRContext(bundledDevHmrClient, moduleId);
+			ctx._internal = {
+				updateStyle,
+				removeStyle
+			};
+			return ctx;
+		}
+	}
+	const clientId = nanoid();
+	transport.send({
+		type: "custom",
+		event: "vite:client-connected",
+		data: { clientId }
+	});
+	const runtime = (_ref = globalThis).__rolldown_runtime__ ?? (_ref.__rolldown_runtime__ = new ViteDevRuntime(clientId));
+	const bundledDevHmrClient = new BundledDevHMRClient({
+		error: (err) => console.error("[vite]", err),
+		debug: (...msg) => console.debug("[vite]", ...msg)
+	}, transport, runtime, {
+		base,
+		beforeApply: clearOverlayOrReloadOnFirstUpdate
+	});
+	registerBundledDevClient(bundledDevHmrClient);
+	runtime.hooks = {
+		createModuleHotContext: (id) => runtime.createModuleHotContext(id),
+		onModuleCacheRemoval: (id) => bundledDevHmrClient.handleModuleCacheRemoval(id)
+	};
+}
+//#endregion
+export { ErrorOverlay, createHotContext, injectQuery, removeStyle, updateStyle };