New Project

web/node_modules/@vue/devtools-core/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 webfansplz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

web/node_modules/@vue/devtools-core/README.md

@@ -0,0 +1,3 @@
+# @vue/devtools-core
+
+> Internal core functions shared across @vue/devtools packages.

web/node_modules/@vue/devtools-core/dist/chunk.js

@@ -0,0 +1,24 @@
+//#region rolldown:runtime
+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 __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+export {  };

web/node_modules/@vue/devtools-core/dist/index.cjs

@@ -0,0 +1,549 @@
+let __vue_devtools_shared = require("@vue/devtools-shared");
+let __vue_devtools_kit = require("@vue/devtools-kit");
+let vue = require("vue");
+
+//#region src/client.ts
+function setDevToolsClientUrl(url) {
+	__vue_devtools_shared.target.__VUE_DEVTOOLS_CLIENT_URL__ = url;
+}
+function getDevToolsClientUrl() {
+	return __vue_devtools_shared.target.__VUE_DEVTOOLS_CLIENT_URL__ ?? (() => {
+		if (__vue_devtools_shared.isBrowser) {
+			const devtoolsMeta = document.querySelector("meta[name=__VUE_DEVTOOLS_CLIENT_URL__]");
+			if (devtoolsMeta) return devtoolsMeta.getAttribute("content");
+		}
+		return "";
+	})();
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/hookable@5.5.3/node_modules/hookable/dist/index.mjs
+function flatHooks(configHooks, hooks$2 = {}, parentName) {
+	for (const key in configHooks) {
+		const subHook = configHooks[key];
+		const name = parentName ? `${parentName}:${key}` : key;
+		if (typeof subHook === "object" && subHook !== null) flatHooks(subHook, hooks$2, name);
+		else if (typeof subHook === "function") hooks$2[name] = subHook;
+	}
+	return hooks$2;
+}
+const defaultTask = { run: (function_) => function_() };
+const _createTask = () => defaultTask;
+const createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
+function serialTaskCaller(hooks$2, args) {
+	const task = createTask(args.shift());
+	return hooks$2.reduce((promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))), Promise.resolve());
+}
+function parallelTaskCaller(hooks$2, args) {
+	const task = createTask(args.shift());
+	return Promise.all(hooks$2.map((hook) => task.run(() => hook(...args))));
+}
+function callEachWith(callbacks, arg0) {
+	for (const callback of [...callbacks]) callback(arg0);
+}
+var Hookable = class {
+	constructor() {
+		this._hooks = {};
+		this._before = void 0;
+		this._after = void 0;
+		this._deprecatedMessages = void 0;
+		this._deprecatedHooks = {};
+		this.hook = this.hook.bind(this);
+		this.callHook = this.callHook.bind(this);
+		this.callHookWith = this.callHookWith.bind(this);
+	}
+	hook(name, function_, options = {}) {
+		if (!name || typeof function_ !== "function") return () => {};
+		const originalName = name;
+		let dep;
+		while (this._deprecatedHooks[name]) {
+			dep = this._deprecatedHooks[name];
+			name = dep.to;
+		}
+		if (dep && !options.allowDeprecated) {
+			let message = dep.message;
+			if (!message) message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
+			if (!this._deprecatedMessages) this._deprecatedMessages = /* @__PURE__ */ new Set();
+			if (!this._deprecatedMessages.has(message)) {
+				console.warn(message);
+				this._deprecatedMessages.add(message);
+			}
+		}
+		if (!function_.name) try {
+			Object.defineProperty(function_, "name", {
+				get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
+				configurable: true
+			});
+		} catch {}
+		this._hooks[name] = this._hooks[name] || [];
+		this._hooks[name].push(function_);
+		return () => {
+			if (function_) {
+				this.removeHook(name, function_);
+				function_ = void 0;
+			}
+		};
+	}
+	hookOnce(name, function_) {
+		let _unreg;
+		let _function = (...arguments_) => {
+			if (typeof _unreg === "function") _unreg();
+			_unreg = void 0;
+			_function = void 0;
+			return function_(...arguments_);
+		};
+		_unreg = this.hook(name, _function);
+		return _unreg;
+	}
+	removeHook(name, function_) {
+		if (this._hooks[name]) {
+			const index = this._hooks[name].indexOf(function_);
+			if (index !== -1) this._hooks[name].splice(index, 1);
+			if (this._hooks[name].length === 0) delete this._hooks[name];
+		}
+	}
+	deprecateHook(name, deprecated) {
+		this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
+		const _hooks = this._hooks[name] || [];
+		delete this._hooks[name];
+		for (const hook of _hooks) this.hook(name, hook);
+	}
+	deprecateHooks(deprecatedHooks) {
+		Object.assign(this._deprecatedHooks, deprecatedHooks);
+		for (const name in deprecatedHooks) this.deprecateHook(name, deprecatedHooks[name]);
+	}
+	addHooks(configHooks) {
+		const hooks$2 = flatHooks(configHooks);
+		const removeFns = Object.keys(hooks$2).map((key) => this.hook(key, hooks$2[key]));
+		return () => {
+			for (const unreg of removeFns.splice(0, removeFns.length)) unreg();
+		};
+	}
+	removeHooks(configHooks) {
+		const hooks$2 = flatHooks(configHooks);
+		for (const key in hooks$2) this.removeHook(key, hooks$2[key]);
+	}
+	removeAllHooks() {
+		for (const key in this._hooks) delete this._hooks[key];
+	}
+	callHook(name, ...arguments_) {
+		arguments_.unshift(name);
+		return this.callHookWith(serialTaskCaller, name, ...arguments_);
+	}
+	callHookParallel(name, ...arguments_) {
+		arguments_.unshift(name);
+		return this.callHookWith(parallelTaskCaller, name, ...arguments_);
+	}
+	callHookWith(caller, name, ...arguments_) {
+		const event = this._before || this._after ? {
+			name,
+			args: arguments_,
+			context: {}
+		} : void 0;
+		if (this._before) callEachWith(this._before, event);
+		const result = caller(name in this._hooks ? [...this._hooks[name]] : [], arguments_);
+		if (result instanceof Promise) return result.finally(() => {
+			if (this._after && event) callEachWith(this._after, event);
+		});
+		if (this._after && event) callEachWith(this._after, event);
+		return result;
+	}
+	beforeEach(function_) {
+		this._before = this._before || [];
+		this._before.push(function_);
+		return () => {
+			if (this._before !== void 0) {
+				const index = this._before.indexOf(function_);
+				if (index !== -1) this._before.splice(index, 1);
+			}
+		};
+	}
+	afterEach(function_) {
+		this._after = this._after || [];
+		this._after.push(function_);
+		return () => {
+			if (this._after !== void 0) {
+				const index = this._after.indexOf(function_);
+				if (index !== -1) this._after.splice(index, 1);
+			}
+		};
+	}
+};
+function createHooks() {
+	return new Hookable();
+}
+
+//#endregion
+//#region src/rpc/global.ts
+const hooks$1 = createHooks();
+let DevToolsMessagingEvents = /* @__PURE__ */ function(DevToolsMessagingEvents$1) {
+	DevToolsMessagingEvents$1["INSPECTOR_TREE_UPDATED"] = "inspector-tree-updated";
+	DevToolsMessagingEvents$1["INSPECTOR_STATE_UPDATED"] = "inspector-state-updated";
+	DevToolsMessagingEvents$1["DEVTOOLS_STATE_UPDATED"] = "devtools-state-updated";
+	DevToolsMessagingEvents$1["ROUTER_INFO_UPDATED"] = "router-info-updated";
+	DevToolsMessagingEvents$1["TIMELINE_EVENT_UPDATED"] = "timeline-event-updated";
+	DevToolsMessagingEvents$1["INSPECTOR_UPDATED"] = "inspector-updated";
+	DevToolsMessagingEvents$1["ACTIVE_APP_UNMOUNTED"] = "active-app-updated";
+	DevToolsMessagingEvents$1["DESTROY_DEVTOOLS_CLIENT"] = "destroy-devtools-client";
+	DevToolsMessagingEvents$1["RELOAD_DEVTOOLS_CLIENT"] = "reload-devtools-client";
+	return DevToolsMessagingEvents$1;
+}({});
+function getDevToolsState() {
+	const state = __vue_devtools_kit.devtools.ctx.state;
+	return {
+		connected: state.connected,
+		clientConnected: true,
+		vueVersion: state?.activeAppRecord?.version || "",
+		tabs: state.tabs,
+		commands: state.commands,
+		vitePluginDetected: state.vitePluginDetected,
+		appRecords: state.appRecords.map((item) => ({
+			id: item.id,
+			name: item.name,
+			version: item.version,
+			routerId: item.routerId,
+			iframe: item.iframe
+		})),
+		activeAppRecordId: state.activeAppRecordId,
+		timelineLayersState: state.timelineLayersState
+	};
+}
+const functions = {
+	on: (event, handler) => {
+		hooks$1.hook(event, handler);
+	},
+	off: (event, handler) => {
+		hooks$1.removeHook(event, handler);
+	},
+	once: (event, handler) => {
+		hooks$1.hookOnce(event, handler);
+	},
+	emit: (event, ...args) => {
+		hooks$1.callHook(event, ...args);
+	},
+	heartbeat: () => {
+		return true;
+	},
+	devtoolsState: () => {
+		return getDevToolsState();
+	},
+	async getInspectorTree(payload) {
+		return (0, __vue_devtools_kit.stringify)(await __vue_devtools_kit.devtools.ctx.api.getInspectorTree(payload));
+	},
+	async getInspectorState(payload) {
+		const inspector = (0, __vue_devtools_kit.getInspector)(payload.inspectorId);
+		if (inspector) inspector.selectedNodeId = payload.nodeId;
+		return (0, __vue_devtools_kit.stringify)(await __vue_devtools_kit.devtools.ctx.api.getInspectorState(payload));
+	},
+	async editInspectorState(payload) {
+		return await __vue_devtools_kit.devtools.ctx.api.editInspectorState(payload);
+	},
+	sendInspectorState(id) {
+		return __vue_devtools_kit.devtools.ctx.api.sendInspectorState(id);
+	},
+	inspectComponentInspector() {
+		return __vue_devtools_kit.devtools.ctx.api.inspectComponentInspector();
+	},
+	cancelInspectComponentInspector() {
+		return __vue_devtools_kit.devtools.ctx.api.cancelInspectComponentInspector();
+	},
+	getComponentRenderCode(id) {
+		return __vue_devtools_kit.devtools.ctx.api.getComponentRenderCode(id);
+	},
+	scrollToComponent(id) {
+		return __vue_devtools_kit.devtools.ctx.api.scrollToComponent(id);
+	},
+	inspectDOM(id) {
+		return __vue_devtools_kit.devtools.ctx.api.inspectDOM(id);
+	},
+	getInspectorNodeActions(id) {
+		return (0, __vue_devtools_kit.getInspectorNodeActions)(id);
+	},
+	getInspectorActions(id) {
+		return (0, __vue_devtools_kit.getInspectorActions)(id);
+	},
+	updateTimelineLayersState(state) {
+		return (0, __vue_devtools_kit.updateTimelineLayersState)(state);
+	},
+	callInspectorNodeAction(inspectorId, actionIndex, nodeId) {
+		const nodeActions = (0, __vue_devtools_kit.getInspectorNodeActions)(inspectorId);
+		if (nodeActions?.length) nodeActions[actionIndex].action?.(nodeId);
+	},
+	callInspectorAction(inspectorId, actionIndex) {
+		const actions = (0, __vue_devtools_kit.getInspectorActions)(inspectorId);
+		if (actions?.length) actions[actionIndex].action?.();
+	},
+	openInEditor(options) {
+		return __vue_devtools_kit.devtools.ctx.api.openInEditor(options);
+	},
+	async checkVueInspectorDetected() {
+		return !!await __vue_devtools_kit.devtools.ctx.api.getVueInspector();
+	},
+	async enableVueInspector() {
+		const inspector = await __vue_devtools_kit.devtools?.api?.getVueInspector?.();
+		if (inspector) await inspector.enable();
+	},
+	async toggleApp(id, options) {
+		return __vue_devtools_kit.devtools.ctx.api.toggleApp(id, options);
+	},
+	updatePluginSettings(pluginId, key, value) {
+		return __vue_devtools_kit.devtools.ctx.api.updatePluginSettings(pluginId, key, value);
+	},
+	getPluginSettings(pluginId) {
+		return __vue_devtools_kit.devtools.ctx.api.getPluginSettings(pluginId);
+	},
+	getRouterInfo() {
+		return __vue_devtools_kit.devtoolsRouterInfo;
+	},
+	navigate(path) {
+		return __vue_devtools_kit.devtoolsRouter.value?.push(path).catch(() => ({}));
+	},
+	getMatchedRoutes(path) {
+		const c = console.warn;
+		console.warn = () => {};
+		const matched = __vue_devtools_kit.devtoolsRouter.value?.resolve?.({ path: path || "/" }).matched ?? [];
+		console.warn = c;
+		return matched;
+	},
+	toggleClientConnected(state) {
+		(0, __vue_devtools_kit.toggleClientConnected)(state);
+	},
+	getCustomInspector() {
+		return (0, __vue_devtools_kit.getActiveInspectors)();
+	},
+	getInspectorInfo(id) {
+		return (0, __vue_devtools_kit.getInspectorInfo)(id);
+	},
+	highlighComponent(uid) {
+		return __vue_devtools_kit.devtools.ctx.hooks.callHook(__vue_devtools_kit.DevToolsContextHookKeys.COMPONENT_HIGHLIGHT, { uid });
+	},
+	unhighlight() {
+		return __vue_devtools_kit.devtools.ctx.hooks.callHook(__vue_devtools_kit.DevToolsContextHookKeys.COMPONENT_UNHIGHLIGHT);
+	},
+	updateDevToolsClientDetected(params) {
+		(0, __vue_devtools_kit.updateDevToolsClientDetected)(params);
+	},
+	initDevToolsServerListener() {
+		const broadcast = (0, __vue_devtools_kit.getRpcServer)().broadcast;
+		__vue_devtools_kit.devtools.ctx.hooks.hook(__vue_devtools_kit.DevToolsMessagingHookKeys.SEND_INSPECTOR_TREE_TO_CLIENT, (payload) => {
+			broadcast.emit(DevToolsMessagingEvents.INSPECTOR_TREE_UPDATED, (0, __vue_devtools_kit.stringify)(payload));
+		});
+		__vue_devtools_kit.devtools.ctx.hooks.hook(__vue_devtools_kit.DevToolsMessagingHookKeys.SEND_INSPECTOR_STATE_TO_CLIENT, (payload) => {
+			broadcast.emit(DevToolsMessagingEvents.INSPECTOR_STATE_UPDATED, (0, __vue_devtools_kit.stringify)(payload));
+		});
+		__vue_devtools_kit.devtools.ctx.hooks.hook(__vue_devtools_kit.DevToolsMessagingHookKeys.DEVTOOLS_STATE_UPDATED, () => {
+			broadcast.emit(DevToolsMessagingEvents.DEVTOOLS_STATE_UPDATED, getDevToolsState());
+		});
+		__vue_devtools_kit.devtools.ctx.hooks.hook(__vue_devtools_kit.DevToolsMessagingHookKeys.ROUTER_INFO_UPDATED, ({ state }) => {
+			broadcast.emit(DevToolsMessagingEvents.ROUTER_INFO_UPDATED, state);
+		});
+		__vue_devtools_kit.devtools.ctx.hooks.hook(__vue_devtools_kit.DevToolsMessagingHookKeys.SEND_TIMELINE_EVENT_TO_CLIENT, (payload) => {
+			broadcast.emit(DevToolsMessagingEvents.TIMELINE_EVENT_UPDATED, (0, __vue_devtools_kit.stringify)(payload));
+		});
+		__vue_devtools_kit.devtools.ctx.hooks.hook(__vue_devtools_kit.DevToolsMessagingHookKeys.SEND_INSPECTOR_TO_CLIENT, (payload) => {
+			broadcast.emit(DevToolsMessagingEvents.INSPECTOR_UPDATED, payload);
+		});
+		__vue_devtools_kit.devtools.ctx.hooks.hook(__vue_devtools_kit.DevToolsMessagingHookKeys.SEND_ACTIVE_APP_UNMOUNTED_TO_CLIENT, () => {
+			broadcast.emit(DevToolsMessagingEvents.ACTIVE_APP_UNMOUNTED);
+		});
+	}
+};
+const rpc = new Proxy({
+	value: {},
+	functions: {}
+}, { get(target$1, property) {
+	const _rpc = (0, __vue_devtools_kit.getRpcClient)();
+	if (property === "value") return _rpc;
+	else if (property === "functions") return _rpc.$functions;
+} });
+const rpcServer = new Proxy({
+	value: {},
+	functions: {}
+}, { get(target$1, property) {
+	const _rpc = (0, __vue_devtools_kit.getRpcServer)();
+	if (property === "value") return _rpc;
+	else if (property === "functions") return _rpc.functions;
+} });
+function onRpcConnected(callback) {
+	let timer = null;
+	let retryCount = 0;
+	function heartbeat() {
+		rpc.value?.heartbeat?.().then(() => {
+			callback();
+			clearTimeout(timer);
+		}).catch(() => {});
+	}
+	timer = setInterval(() => {
+		if (retryCount >= 30) clearTimeout(timer);
+		retryCount++;
+		heartbeat();
+	}, retryCount * 200 + 200);
+	heartbeat();
+}
+function onRpcSeverReady(callback) {
+	let timer = null;
+	const timeout = 120;
+	function heartbeat() {
+		if (rpcServer.value.clients.length > 0) {
+			callback();
+			clearTimeout(timer);
+		}
+	}
+	timer = setInterval(() => {
+		heartbeat();
+	}, timeout);
+}
+
+//#endregion
+//#region src/rpc/vite.ts
+const hooks = createHooks();
+const viteRpcFunctions = {
+	on: (event, handler) => {
+		hooks.hook(event, handler);
+	},
+	off: (event, handler) => {
+		hooks.removeHook(event, handler);
+	},
+	once: (event, handler) => {
+		hooks.hookOnce(event, handler);
+	},
+	emit: (event, ...args) => {
+		hooks.callHook(event, ...args);
+	},
+	heartbeat: () => {
+		return true;
+	}
+};
+const viteRpc = new Proxy({
+	value: {},
+	functions: {}
+}, { get(target$1, property) {
+	const _rpc = (0, __vue_devtools_kit.getViteRpcClient)();
+	if (property === "value") return _rpc;
+	else if (property === "functions") return _rpc?.$functions;
+} });
+function onViteRpcConnected(callback) {
+	let timer = null;
+	function heartbeat() {
+		viteRpc.value?.heartbeat?.().then(() => {
+			clearTimeout(timer);
+			callback();
+		}).catch(() => ({}));
+		timer = setTimeout(() => {
+			heartbeat();
+		}, 80);
+	}
+	heartbeat();
+}
+function createViteClientRpc() {
+	(0, __vue_devtools_kit.createRpcClient)(viteRpcFunctions, { preset: "vite" });
+}
+function createViteServerRpc(functions$1) {
+	(0, __vue_devtools_kit.createRpcServer)(functions$1, { preset: "vite" });
+}
+
+//#endregion
+//#region src/vue-plugin/devtools-state.ts
+const VueDevToolsStateSymbol = Symbol.for("__VueDevToolsStateSymbol__");
+function VueDevToolsVuePlugin() {
+	return { install(app) {
+		const state = createDevToolsStateContext();
+		state.getDevToolsState();
+		app.provide(VueDevToolsStateSymbol, state);
+		app.config.globalProperties.$getDevToolsState = state.getDevToolsState;
+		app.config.globalProperties.$disconnectDevToolsClient = () => {
+			state.clientConnected.value = false;
+			state.connected.value = false;
+		};
+	} };
+}
+function createDevToolsStateContext() {
+	const connected = (0, vue.ref)(false);
+	const clientConnected = (0, vue.ref)(false);
+	const vueVersion = (0, vue.ref)("");
+	const tabs = (0, vue.ref)([]);
+	const commands = (0, vue.ref)([]);
+	const vitePluginDetected = (0, vue.ref)(false);
+	const appRecords = (0, vue.ref)([]);
+	const activeAppRecordId = (0, vue.ref)("");
+	const timelineLayersState = (0, vue.ref)({});
+	function updateState(data) {
+		connected.value = data.connected;
+		clientConnected.value = data.clientConnected;
+		vueVersion.value = data.vueVersion || "";
+		tabs.value = data.tabs;
+		commands.value = data.commands;
+		vitePluginDetected.value = data.vitePluginDetected;
+		appRecords.value = data.appRecords;
+		activeAppRecordId.value = data.activeAppRecordId;
+		timelineLayersState.value = data.timelineLayersState;
+	}
+	function getDevToolsState$1() {
+		onRpcConnected(() => {
+			rpc.value.devtoolsState().then((data) => {
+				updateState(data);
+			});
+			rpc.functions.off(DevToolsMessagingEvents.DEVTOOLS_STATE_UPDATED, updateState);
+			rpc.functions.on(DevToolsMessagingEvents.DEVTOOLS_STATE_UPDATED, updateState);
+		});
+	}
+	return {
+		getDevToolsState: getDevToolsState$1,
+		connected,
+		clientConnected,
+		vueVersion,
+		tabs,
+		commands,
+		vitePluginDetected,
+		appRecords,
+		activeAppRecordId,
+		timelineLayersState
+	};
+}
+function useDevToolsState() {
+	return (0, vue.inject)(VueDevToolsStateSymbol);
+}
+const fns = [];
+function onDevToolsConnected(fn) {
+	const { connected, clientConnected } = useDevToolsState();
+	fns.push(fn);
+	(0, vue.onUnmounted)(() => {
+		fns.splice(fns.indexOf(fn), 1);
+	});
+	const devtoolsReady = (0, vue.computed)(() => clientConnected.value && connected.value);
+	if (devtoolsReady.value) fn();
+	else {
+		const stop = (0, vue.watch)(devtoolsReady, (v) => {
+			if (v) {
+				fn();
+				stop();
+			}
+		});
+	}
+	return () => {
+		fns.splice(fns.indexOf(fn), 1);
+	};
+}
+function refreshCurrentPageData() {
+	fns.forEach((fn) => fn());
+}
+
+//#endregion
+exports.DevToolsMessagingEvents = DevToolsMessagingEvents;
+exports.VueDevToolsVuePlugin = VueDevToolsVuePlugin;
+exports.createDevToolsStateContext = createDevToolsStateContext;
+exports.createViteClientRpc = createViteClientRpc;
+exports.createViteServerRpc = createViteServerRpc;
+exports.functions = functions;
+exports.getDevToolsClientUrl = getDevToolsClientUrl;
+exports.onDevToolsConnected = onDevToolsConnected;
+exports.onRpcConnected = onRpcConnected;
+exports.onRpcSeverReady = onRpcSeverReady;
+exports.onViteRpcConnected = onViteRpcConnected;
+exports.refreshCurrentPageData = refreshCurrentPageData;
+exports.rpc = rpc;
+exports.rpcServer = rpcServer;
+exports.setDevToolsClientUrl = setDevToolsClientUrl;
+exports.useDevToolsState = useDevToolsState;
+exports.viteRpc = viteRpc;
+exports.viteRpcFunctions = viteRpcFunctions;

web/node_modules/@vue/devtools-core/dist/index.d.cts

@@ -0,0 +1,712 @@
+import * as vue0 from "vue";
+import { App, ComponentInternalInstance, ComponentOptions, Ref, SuspenseBoundary, VNode } from "vue";
+import * as vue_router0 from "vue-router";
+import { RouteLocationNormalizedLoaded, RouteRecordNormalized } from "vue-router";
+import { BirpcGroup, BirpcReturn } from "birpc";
+import { ModuleNode } from "vite";
+
+//#region src/client.d.ts
+declare function setDevToolsClientUrl(url: string): void;
+declare function getDevToolsClientUrl(): any;
+//#endregion
+//#region ../devtools-kit/src/types/app.d.ts
+type App$1 = any;
+type VueAppInstance = ComponentInternalInstance & {
+  type: {
+    _componentTag: string | undefined;
+    components: Record<string, ComponentInternalInstance['type']>;
+    __VUE_DEVTOOLS_COMPONENT_GUSSED_NAME__: string;
+    __isKeepAlive: boolean;
+    devtools: {
+      hide: boolean;
+    };
+    mixins: ComponentOptions[];
+    extends: ComponentOptions;
+    vuex: {
+      getters: Record<string, unknown>;
+    };
+    computed: Record<string, unknown>;
+  };
+  __v_cache: Cache;
+  __VUE_DEVTOOLS_NEXT_UID__: string;
+  _isBeingDestroyed: boolean;
+  _instance: VueAppInstance;
+  _container: {
+    _vnode: {
+      component: VueAppInstance;
+    };
+  };
+  isUnmounted: boolean;
+  parent: VueAppInstance;
+  appContext: {
+    app: VueAppInstance & App$1 & {
+      __VUE_DEVTOOLS_NEXT_APP_RECORD_ID__: string;
+      __VUE_DEVTOOLS_NEXT_APP_RECORD__: AppRecord;
+    };
+  };
+  __VUE_DEVTOOLS_NEXT_APP_RECORD__: AppRecord;
+  suspense: SuspenseBoundary & {
+    suspenseKey: string;
+  };
+  renderContext: Record<string, unknown>;
+  devtoolsRawSetupState: Record<string, unknown>;
+  setupState: Record<string, unknown>;
+  provides: Record<string | symbol, unknown>;
+  ctx: Record<string, unknown>;
+} & App$1;
+interface AppRecord {
+  id: string;
+  name: string;
+  app?: App$1;
+  version?: string;
+  types?: Record<string, string | symbol>;
+  instanceMap: Map<string, VueAppInstance>;
+  perfGroupIds: Map<string, {
+    groupId: number;
+    time: number;
+  }>;
+  rootInstance: VueAppInstance;
+  routerId?: string;
+  iframe?: string;
+}
+//#endregion
+//#region ../devtools-kit/src/types/command.d.ts
+interface CustomCommandAction {
+  type: 'url';
+  /**
+   * Url of the action, if set, execute the action will open the url
+   */
+  src: string;
+}
+interface CustomCommand {
+  /**
+   * The id of the command, should be unique
+   */
+  id: string;
+  title: string;
+  description?: string;
+  /**
+   * Order of the command, bigger number will be shown first
+   * @default 0
+   */
+  order?: number;
+  /**
+   * Icon of the tab, support any Iconify icons, or a url to an image
+   */
+  icon?: string;
+  /**
+   * - action of the command
+   * - __NOTE__: This will be ignored if `children` is set
+   */
+  action?: CustomCommandAction;
+  /**
+   * - children of action, if set, execute the action will show the children
+   */
+  children?: Omit<CustomCommand, 'children'>[];
+}
+//#endregion
+//#region ../devtools-kit/src/types/inspector.d.ts
+interface InspectorNodeTag {
+  label: string;
+  textColor: number;
+  backgroundColor: number;
+  tooltip?: string;
+}
+type EditStatePayload = {
+  value: any;
+  newKey?: string | null;
+  remove?: undefined | false;
+} | {
+  value?: undefined;
+  newKey?: undefined;
+  remove: true;
+};
+interface CustomInspectorNode {
+  id: string;
+  label: string;
+  children?: CustomInspectorNode[];
+  tags?: InspectorNodeTag[];
+  name?: string;
+  file?: string;
+}
+interface CustomInspectorState {
+  [key: string]: (StateBase | Omit<ComponentState, 'type'>)[];
+}
+//#endregion
+//#region ../devtools-kit/src/types/component.d.ts
+type ComponentInstance = any;
+interface ComponentTreeNode {
+  uid: string | number;
+  id: string;
+  name: string;
+  renderKey: string | number;
+  inactive: boolean;
+  isFragment: boolean;
+  hasChildren: boolean;
+  children: ComponentTreeNode[];
+  domOrder?: number[];
+  consoleId?: string;
+  isRouterView?: boolean;
+  macthedRouteSegment?: string;
+  tags: InspectorNodeTag[];
+  autoOpen: boolean;
+  meta?: any;
+}
+type ComponentBuiltinCustomStateTypes = 'function' | 'map' | 'set' | 'reference' | 'component' | 'component-definition' | 'router' | 'store';
+interface ComponentCustomState extends ComponentStateBase {
+  value: CustomState;
+}
+interface StateBase {
+  key: string;
+  value: any;
+  editable?: boolean;
+  objectType?: 'ref' | 'reactive' | 'computed' | 'other';
+  raw?: string;
+}
+interface ComponentStateBase extends StateBase {
+  type: string;
+}
+interface ComponentPropState extends ComponentStateBase {
+  meta?: {
+    type: string;
+    required: boolean;
+    /** Vue 1 only */
+    mode?: 'default' | 'sync' | 'once';
+  };
+}
+interface CustomState {
+  _custom: {
+    type: ComponentBuiltinCustomStateTypes | string;
+    objectType?: string;
+    display?: string;
+    tooltip?: string;
+    value?: any;
+    abstract?: boolean;
+    file?: string;
+    uid?: number;
+    readOnly?: boolean;
+    /** Configure immediate child fields */
+    fields?: {
+      abstract?: boolean;
+    };
+    id?: any;
+    actions?: {
+      icon: string;
+      tooltip?: string;
+      action: () => void | Promise<void>;
+    }[];
+    /** internal */
+    _reviveId?: number;
+  };
+}
+type ComponentState = ComponentStateBase | ComponentPropState | ComponentCustomState;
+interface InspectedComponentData {
+  id: string;
+  name: string;
+  file: string;
+  state: ComponentState[];
+  functional?: boolean;
+}
+//#endregion
+//#region ../devtools-kit/src/ctx/hook.d.ts
+declare enum DevToolsV6PluginAPIHookKeys {
+  VISIT_COMPONENT_TREE = "visitComponentTree",
+  INSPECT_COMPONENT = "inspectComponent",
+  EDIT_COMPONENT_STATE = "editComponentState",
+  GET_INSPECTOR_TREE = "getInspectorTree",
+  GET_INSPECTOR_STATE = "getInspectorState",
+  EDIT_INSPECTOR_STATE = "editInspectorState",
+  INSPECT_TIMELINE_EVENT = "inspectTimelineEvent",
+  TIMELINE_CLEARED = "timelineCleared",
+  SET_PLUGIN_SETTINGS = "setPluginSettings",
+}
+interface DevToolsV6PluginAPIHookPayloads {
+  [DevToolsV6PluginAPIHookKeys.VISIT_COMPONENT_TREE]: {
+    app: App$1;
+    componentInstance: ComponentInstance;
+    treeNode: ComponentTreeNode;
+    filter: string;
+  };
+  [DevToolsV6PluginAPIHookKeys.INSPECT_COMPONENT]: {
+    app: App$1;
+    componentInstance: ComponentInstance;
+    instanceData: InspectedComponentData;
+  };
+  [DevToolsV6PluginAPIHookKeys.EDIT_COMPONENT_STATE]: {
+    app: App$1;
+    inspectorId: string;
+    nodeId: string;
+    path: string[];
+    type: string;
+    state: EditStatePayload;
+    set: (object: any, path?: string | (string[]), value?: any, cb?: (object: any, field: string, value: any) => void) => void;
+  };
+  [DevToolsV6PluginAPIHookKeys.GET_INSPECTOR_TREE]: {
+    app: App$1;
+    inspectorId: string;
+    filter: string;
+    rootNodes: CustomInspectorNode[];
+  };
+  [DevToolsV6PluginAPIHookKeys.GET_INSPECTOR_STATE]: {
+    app: App$1;
+    inspectorId: string;
+    nodeId: string;
+    state: CustomInspectorState;
+  };
+  [DevToolsV6PluginAPIHookKeys.EDIT_INSPECTOR_STATE]: {
+    app: App$1;
+    inspectorId: string;
+    nodeId: string;
+    path: string[];
+    type: string;
+    state: EditStatePayload;
+    set: (object: any, path?: string | (string[]), value?: any, cb?: (object: any, field: string, value: any) => void) => void;
+  };
+  [DevToolsV6PluginAPIHookKeys.INSPECT_TIMELINE_EVENT]: {
+    app: App$1;
+    layerId: string;
+    event: TimelineEvent;
+    all?: boolean;
+    data: any;
+  };
+  [DevToolsV6PluginAPIHookKeys.TIMELINE_CLEARED]: Record<string, never>;
+  [DevToolsV6PluginAPIHookKeys.SET_PLUGIN_SETTINGS]: {
+    app: App$1;
+    pluginId: string;
+    key: string;
+    newValue: any;
+    oldValue: any;
+    settings: any;
+  };
+}
+//#endregion
+//#region ../devtools-kit/src/core/open-in-editor/index.d.ts
+interface OpenInEditorOptions {
+  baseUrl?: string;
+  file?: string;
+  line?: number;
+  column?: number;
+  host?: string;
+}
+//#endregion
+//#region ../devtools-kit/src/types/router.d.ts
+interface RouterInfo {
+  currentRoute: RouteLocationNormalizedLoaded | null | Record<string, any>;
+  routes: RouteRecordNormalized[];
+}
+//#endregion
+//#region ../devtools-kit/src/types/tab.d.ts
+type TabCategory = 'pinned' | 'app' | 'modules' | 'advanced';
+type ModuleView = ModuleIframeView | ModuleVNodeView | ModuleSFCView;
+interface ModuleIframeView {
+  /**
+   * Iframe view
+   */
+  type: 'iframe';
+  /**
+   * Url of the iframe
+   */
+  src: string;
+  /**
+   * Persist the iframe instance even if the tab is not active
+   *
+   * @default true
+   */
+  persistent?: boolean;
+}
+interface ModuleVNodeView {
+  /**
+   * Vue's VNode view
+   */
+  type: 'vnode';
+  /**
+   * Send vnode to the client, they must be static and serializable
+   */
+  vnode: VNode;
+}
+interface ModuleSFCView {
+  /**
+   * SFC view
+   */
+  type: 'sfc';
+  /**
+   * SFC component
+   */
+  sfc: string;
+}
+interface CustomTab {
+  /**
+   * The name of the tab, must be unique
+   */
+  name: string;
+  /**
+   * Icon of the tab, support any Iconify icons, or a url to an image
+   */
+  icon?: string;
+  /**
+   * Title of the tab
+   */
+  title: string;
+  /**
+   * Main view of the tab
+   */
+  view: ModuleView;
+  /**
+   * Category of the tab
+   * @default 'app'
+   */
+  category?: TabCategory;
+}
+//#endregion
+//#region ../devtools-kit/src/types/timeline.d.ts
+interface TimelineEvent<TData = any, TMeta = any> {
+  time: number;
+  data: TData;
+  logType?: 'default' | 'warning' | 'error';
+  meta?: TMeta;
+  groupId?: number | string;
+  title?: string;
+  subtitle?: string;
+}
+//#endregion
+//#region ../devtools-kit/src/messaging/index.d.ts
+declare function getRpcClient<R, L extends object = Record<string, never>>(): BirpcReturn<R, L>;
+declare function getRpcServer<R, L extends object = Record<string, never>>(): BirpcGroup<R, L>;
+declare function getViteRpcClient<R, L extends object = Record<string, never>>(): BirpcReturn<R, L>;
+//#endregion
+//#region src/rpc/global.d.ts
+declare enum DevToolsMessagingEvents {
+  INSPECTOR_TREE_UPDATED = "inspector-tree-updated",
+  INSPECTOR_STATE_UPDATED = "inspector-state-updated",
+  DEVTOOLS_STATE_UPDATED = "devtools-state-updated",
+  ROUTER_INFO_UPDATED = "router-info-updated",
+  TIMELINE_EVENT_UPDATED = "timeline-event-updated",
+  INSPECTOR_UPDATED = "inspector-updated",
+  ACTIVE_APP_UNMOUNTED = "active-app-updated",
+  DESTROY_DEVTOOLS_CLIENT = "destroy-devtools-client",
+  RELOAD_DEVTOOLS_CLIENT = "reload-devtools-client",
+}
+declare const functions: {
+  on: (event: string, handler: Function) => void;
+  off: (event: string, handler: Function) => void;
+  once: (event: string, handler: Function) => void;
+  emit: (event: string, ...args: any[]) => void;
+  heartbeat: () => boolean;
+  devtoolsState: () => {
+    connected: boolean;
+    clientConnected: boolean;
+    vueVersion: string;
+    tabs: CustomTab[];
+    commands: CustomCommand[];
+    vitePluginDetected: boolean;
+    appRecords: {
+      id: string;
+      name: string;
+      version: string | undefined;
+      routerId: string | undefined;
+      iframe: string | undefined;
+    }[];
+    activeAppRecordId: string;
+    timelineLayersState: Record<string, boolean>;
+  };
+  getInspectorTree(payload: Pick<DevToolsV6PluginAPIHookPayloads[DevToolsV6PluginAPIHookKeys.GET_INSPECTOR_TREE], "inspectorId" | "filter">): Promise<string>;
+  getInspectorState(payload: Pick<DevToolsV6PluginAPIHookPayloads[DevToolsV6PluginAPIHookKeys.GET_INSPECTOR_STATE], "inspectorId" | "nodeId">): Promise<string>;
+  editInspectorState(payload: DevToolsV6PluginAPIHookPayloads[DevToolsV6PluginAPIHookKeys.EDIT_INSPECTOR_STATE]): Promise<void>;
+  sendInspectorState(id: string): void;
+  inspectComponentInspector(): Promise<string>;
+  cancelInspectComponentInspector(): void;
+  getComponentRenderCode(id: string): any;
+  scrollToComponent(id: string): void;
+  inspectDOM(id: string): void;
+  getInspectorNodeActions(id: string): {
+    icon: string;
+    tooltip?: string;
+    action: (nodeId: string) => void | Promise<void>;
+  }[] | undefined;
+  getInspectorActions(id: string): {
+    icon: string;
+    tooltip?: string;
+    action: () => void | Promise<void>;
+  }[] | undefined;
+  updateTimelineLayersState(state: Record<string, boolean>): void;
+  callInspectorNodeAction(inspectorId: string, actionIndex: number, nodeId: string): void;
+  callInspectorAction(inspectorId: string, actionIndex: number): void;
+  openInEditor(options: OpenInEditorOptions): void;
+  checkVueInspectorDetected(): Promise<boolean>;
+  enableVueInspector(): Promise<void>;
+  toggleApp(id: string, options?: {
+    inspectingComponent?: boolean;
+  }): Promise<void>;
+  updatePluginSettings(pluginId: string, key: string, value: string): void;
+  getPluginSettings(pluginId: string): {
+    options: Record<string, {
+      label: string;
+      description?: string;
+    } & ({
+      type: "boolean";
+      defaultValue: boolean;
+    } | {
+      type: "choice";
+      defaultValue: string | number;
+      options: {
+        value: string | number;
+        label: string;
+      }[];
+      component?: "select" | "button-group";
+    } | {
+      type: "text";
+      defaultValue: string;
+    })> | null;
+    values: any;
+  };
+  getRouterInfo(): RouterInfo;
+  navigate(path: string): Promise<void | vue_router0.NavigationFailure | {} | undefined>;
+  getMatchedRoutes(path: string): vue_router0.RouteRecordNormalized[];
+  toggleClientConnected(state: boolean): void;
+  getCustomInspector(): {
+    id: string;
+    label: string;
+    logo: string;
+    icon: string;
+    packageName: string | undefined;
+    homepage: string | undefined;
+    pluginId: string;
+  }[];
+  getInspectorInfo(id: string): {
+    id: string;
+    label: string;
+    logo: string | undefined;
+    packageName: string | undefined;
+    homepage: string | undefined;
+    timelineLayers: {
+      id: string;
+      label: string;
+      color: number;
+    }[];
+    treeFilterPlaceholder: string;
+    stateFilterPlaceholder: string;
+  } | undefined;
+  highlighComponent(uid: string): Promise<any>;
+  unhighlight(): Promise<any>;
+  updateDevToolsClientDetected(params: Record<string, boolean>): void;
+  initDevToolsServerListener(): void;
+};
+type RPCFunctions = typeof functions;
+declare const rpc: {
+  value: ReturnType<typeof getRpcClient<RPCFunctions>>;
+  functions: ReturnType<typeof getRpcClient<RPCFunctions>>;
+};
+declare const rpcServer: {
+  value: ReturnType<typeof getRpcServer<RPCFunctions>>;
+  functions: ReturnType<typeof getRpcServer<RPCFunctions>>;
+};
+declare function onRpcConnected(callback: () => void): void;
+declare function onRpcSeverReady(callback: () => void): void;
+//#endregion
+//#region src/rpc/types.d.ts
+type AssetType = 'image' | 'font' | 'video' | 'audio' | 'text' | 'json' | 'wasm' | 'other';
+interface AssetInfo {
+  path: string;
+  type: AssetType;
+  publicPath: string;
+  relativePath: string;
+  filePath: string;
+  size: number;
+  mtime: number;
+}
+interface ImageMeta {
+  width: number;
+  height: number;
+  orientation?: number;
+  type?: string;
+  mimeType?: string;
+}
+type AssetImporter = Pick<ModuleNode, 'url' | 'id'>;
+interface AssetEntry {
+  path: string;
+  content: string;
+  encoding?: BufferEncoding;
+  override?: boolean;
+}
+interface CodeSnippet {
+  code: string;
+  lang: string;
+  name: string;
+  docs?: string;
+}
+interface ModuleInfo {
+  id: string;
+  plugins: {
+    name: string;
+    transform?: number;
+    resolveId?: number;
+  }[];
+  deps: string[];
+  virtual: boolean;
+}
+//#endregion
+//#region src/rpc/vite.d.ts
+declare const viteRpcFunctions: {
+  on: (event: string, handler: Function) => void;
+  off: (event: string, handler: Function) => void;
+  once: (event: string, handler: Function) => void;
+  emit: (event: string, ...args: any[]) => void;
+  heartbeat: () => boolean;
+};
+type ViteRPCFunctions = typeof viteRpcFunctions & {
+  getStaticAssets: () => Promise<AssetInfo[]>;
+  getAssetImporters: (url: string) => Promise<AssetImporter[]>;
+  getImageMeta: (filepath: string) => Promise<ImageMeta>;
+  getTextAssetContent: (filepath: string, limit?: number) => Promise<string>;
+  getRoot: () => Promise<string>;
+  getGraphModules: () => Promise<ModuleInfo[]>;
+};
+declare const viteRpc: {
+  value: ReturnType<typeof getViteRpcClient<ViteRPCFunctions>>;
+  functions: ReturnType<typeof getViteRpcClient<ViteRPCFunctions>>;
+};
+declare function onViteRpcConnected(callback: () => void): void;
+declare function createViteClientRpc(): void;
+declare function createViteServerRpc(functions: Record<string, any>): void;
+//#endregion
+//#region src/vue-plugin/devtools-state.d.ts
+interface DevToolsState {
+  connected: boolean;
+  clientConnected: boolean;
+  vueVersion: string;
+  tabs: CustomTab[];
+  commands: CustomCommand[];
+  vitePluginDetected: boolean;
+  appRecords: AppRecord[];
+  activeAppRecordId: string;
+  timelineLayersState: Record<string, boolean>;
+}
+type DevToolsRefState = { [P in keyof DevToolsState]: Ref<DevToolsState[P]> };
+declare function VueDevToolsVuePlugin(): {
+  install(app: App): void;
+};
+declare function createDevToolsStateContext(): {
+  getDevToolsState: () => void;
+  connected: Ref<boolean, boolean>;
+  clientConnected: Ref<boolean, boolean>;
+  vueVersion: Ref<string, string>;
+  tabs: Ref<{
+    name: string;
+    icon?: string | undefined;
+    title: string;
+    view: {
+      type: "iframe";
+      src: string;
+      persistent?: boolean | undefined;
+    } | {
+      type: "vnode";
+      vnode: vue0.VNode;
+    } | {
+      type: "sfc";
+      sfc: string;
+    };
+    category?: ("app" | "pinned" | "modules" | "advanced") | undefined;
+  }[], CustomTab[] | {
+    name: string;
+    icon?: string | undefined;
+    title: string;
+    view: {
+      type: "iframe";
+      src: string;
+      persistent?: boolean | undefined;
+    } | {
+      type: "vnode";
+      vnode: vue0.VNode;
+    } | {
+      type: "sfc";
+      sfc: string;
+    };
+    category?: ("app" | "pinned" | "modules" | "advanced") | undefined;
+  }[]>;
+  commands: Ref<{
+    id: string;
+    title: string;
+    description?: string | undefined;
+    order?: number | undefined;
+    icon?: string | undefined;
+    action?: {
+      type: "url";
+      src: string;
+    } | undefined;
+    children?: {
+      title: string;
+      icon?: string | undefined;
+      id: string;
+      description?: string | undefined;
+      order?: number | undefined;
+      action?: {
+        type: "url";
+        src: string;
+      } | undefined;
+    }[] | undefined;
+  }[], CustomCommand[] | {
+    id: string;
+    title: string;
+    description?: string | undefined;
+    order?: number | undefined;
+    icon?: string | undefined;
+    action?: {
+      type: "url";
+      src: string;
+    } | undefined;
+    children?: {
+      title: string;
+      icon?: string | undefined;
+      id: string;
+      description?: string | undefined;
+      order?: number | undefined;
+      action?: {
+        type: "url";
+        src: string;
+      } | undefined;
+    }[] | undefined;
+  }[]>;
+  vitePluginDetected: Ref<boolean, boolean>;
+  appRecords: Ref<{
+    id: string;
+    name: string;
+    app?: App$1;
+    version?: string | undefined;
+    types?: Record<string, string | symbol> | undefined;
+    instanceMap: Map<string, any> & Omit<Map<string, any>, keyof Map<any, any>>;
+    perfGroupIds: Map<string, {
+      groupId: number;
+      time: number;
+    }> & Omit<Map<string, {
+      groupId: number;
+      time: number;
+    }>, keyof Map<any, any>>;
+    rootInstance: VueAppInstance;
+    routerId?: string | undefined;
+    iframe?: string | undefined;
+  }[], AppRecord[] | {
+    id: string;
+    name: string;
+    app?: App$1;
+    version?: string | undefined;
+    types?: Record<string, string | symbol> | undefined;
+    instanceMap: Map<string, any> & Omit<Map<string, any>, keyof Map<any, any>>;
+    perfGroupIds: Map<string, {
+      groupId: number;
+      time: number;
+    }> & Omit<Map<string, {
+      groupId: number;
+      time: number;
+    }>, keyof Map<any, any>>;
+    rootInstance: VueAppInstance;
+    routerId?: string | undefined;
+    iframe?: string | undefined;
+  }[]>;
+  activeAppRecordId: Ref<string, string>;
+  timelineLayersState: Ref<Record<string, boolean>, Record<string, boolean>>;
+};
+declare function useDevToolsState(): DevToolsRefState;
+declare function onDevToolsConnected(fn: () => void): () => void;
+declare function refreshCurrentPageData(): void;
+//#endregion
+export { AssetEntry, AssetImporter, AssetInfo, AssetType, CodeSnippet, DevToolsMessagingEvents, ImageMeta, ModuleInfo, RPCFunctions, ViteRPCFunctions, VueDevToolsVuePlugin, createDevToolsStateContext, createViteClientRpc, createViteServerRpc, functions, getDevToolsClientUrl, onDevToolsConnected, onRpcConnected, onRpcSeverReady, onViteRpcConnected, refreshCurrentPageData, rpc, rpcServer, setDevToolsClientUrl, useDevToolsState, viteRpc, viteRpcFunctions };

web/node_modules/@vue/devtools-core/dist/index.d.ts

@@ -0,0 +1,712 @@
+import * as vue0 from "vue";
+import { App, ComponentInternalInstance, ComponentOptions, Ref, SuspenseBoundary, VNode } from "vue";
+import * as vue_router0 from "vue-router";
+import { RouteLocationNormalizedLoaded, RouteRecordNormalized } from "vue-router";
+import { BirpcGroup, BirpcReturn } from "birpc";
+import { ModuleNode } from "vite";
+
+//#region src/client.d.ts
+declare function setDevToolsClientUrl(url: string): void;
+declare function getDevToolsClientUrl(): any;
+//#endregion
+//#region ../devtools-kit/src/types/app.d.ts
+type App$1 = any;
+type VueAppInstance = ComponentInternalInstance & {
+  type: {
+    _componentTag: string | undefined;
+    components: Record<string, ComponentInternalInstance['type']>;
+    __VUE_DEVTOOLS_COMPONENT_GUSSED_NAME__: string;
+    __isKeepAlive: boolean;
+    devtools: {
+      hide: boolean;
+    };
+    mixins: ComponentOptions[];
+    extends: ComponentOptions;
+    vuex: {
+      getters: Record<string, unknown>;
+    };
+    computed: Record<string, unknown>;
+  };
+  __v_cache: Cache;
+  __VUE_DEVTOOLS_NEXT_UID__: string;
+  _isBeingDestroyed: boolean;
+  _instance: VueAppInstance;
+  _container: {
+    _vnode: {
+      component: VueAppInstance;
+    };
+  };
+  isUnmounted: boolean;
+  parent: VueAppInstance;
+  appContext: {
+    app: VueAppInstance & App$1 & {
+      __VUE_DEVTOOLS_NEXT_APP_RECORD_ID__: string;
+      __VUE_DEVTOOLS_NEXT_APP_RECORD__: AppRecord;
+    };
+  };
+  __VUE_DEVTOOLS_NEXT_APP_RECORD__: AppRecord;
+  suspense: SuspenseBoundary & {
+    suspenseKey: string;
+  };
+  renderContext: Record<string, unknown>;
+  devtoolsRawSetupState: Record<string, unknown>;
+  setupState: Record<string, unknown>;
+  provides: Record<string | symbol, unknown>;
+  ctx: Record<string, unknown>;
+} & App$1;
+interface AppRecord {
+  id: string;
+  name: string;
+  app?: App$1;
+  version?: string;
+  types?: Record<string, string | symbol>;
+  instanceMap: Map<string, VueAppInstance>;
+  perfGroupIds: Map<string, {
+    groupId: number;
+    time: number;
+  }>;
+  rootInstance: VueAppInstance;
+  routerId?: string;
+  iframe?: string;
+}
+//#endregion
+//#region ../devtools-kit/src/types/command.d.ts
+interface CustomCommandAction {
+  type: 'url';
+  /**
+   * Url of the action, if set, execute the action will open the url
+   */
+  src: string;
+}
+interface CustomCommand {
+  /**
+   * The id of the command, should be unique
+   */
+  id: string;
+  title: string;
+  description?: string;
+  /**
+   * Order of the command, bigger number will be shown first
+   * @default 0
+   */
+  order?: number;
+  /**
+   * Icon of the tab, support any Iconify icons, or a url to an image
+   */
+  icon?: string;
+  /**
+   * - action of the command
+   * - __NOTE__: This will be ignored if `children` is set
+   */
+  action?: CustomCommandAction;
+  /**
+   * - children of action, if set, execute the action will show the children
+   */
+  children?: Omit<CustomCommand, 'children'>[];
+}
+//#endregion
+//#region ../devtools-kit/src/types/inspector.d.ts
+interface InspectorNodeTag {
+  label: string;
+  textColor: number;
+  backgroundColor: number;
+  tooltip?: string;
+}
+type EditStatePayload = {
+  value: any;
+  newKey?: string | null;
+  remove?: undefined | false;
+} | {
+  value?: undefined;
+  newKey?: undefined;
+  remove: true;
+};
+interface CustomInspectorNode {
+  id: string;
+  label: string;
+  children?: CustomInspectorNode[];
+  tags?: InspectorNodeTag[];
+  name?: string;
+  file?: string;
+}
+interface CustomInspectorState {
+  [key: string]: (StateBase | Omit<ComponentState, 'type'>)[];
+}
+//#endregion
+//#region ../devtools-kit/src/types/component.d.ts
+type ComponentInstance = any;
+interface ComponentTreeNode {
+  uid: string | number;
+  id: string;
+  name: string;
+  renderKey: string | number;
+  inactive: boolean;
+  isFragment: boolean;
+  hasChildren: boolean;
+  children: ComponentTreeNode[];
+  domOrder?: number[];
+  consoleId?: string;
+  isRouterView?: boolean;
+  macthedRouteSegment?: string;
+  tags: InspectorNodeTag[];
+  autoOpen: boolean;
+  meta?: any;
+}
+type ComponentBuiltinCustomStateTypes = 'function' | 'map' | 'set' | 'reference' | 'component' | 'component-definition' | 'router' | 'store';
+interface ComponentCustomState extends ComponentStateBase {
+  value: CustomState;
+}
+interface StateBase {
+  key: string;
+  value: any;
+  editable?: boolean;
+  objectType?: 'ref' | 'reactive' | 'computed' | 'other';
+  raw?: string;
+}
+interface ComponentStateBase extends StateBase {
+  type: string;
+}
+interface ComponentPropState extends ComponentStateBase {
+  meta?: {
+    type: string;
+    required: boolean;
+    /** Vue 1 only */
+    mode?: 'default' | 'sync' | 'once';
+  };
+}
+interface CustomState {
+  _custom: {
+    type: ComponentBuiltinCustomStateTypes | string;
+    objectType?: string;
+    display?: string;
+    tooltip?: string;
+    value?: any;
+    abstract?: boolean;
+    file?: string;
+    uid?: number;
+    readOnly?: boolean;
+    /** Configure immediate child fields */
+    fields?: {
+      abstract?: boolean;
+    };
+    id?: any;
+    actions?: {
+      icon: string;
+      tooltip?: string;
+      action: () => void | Promise<void>;
+    }[];
+    /** internal */
+    _reviveId?: number;
+  };
+}
+type ComponentState = ComponentStateBase | ComponentPropState | ComponentCustomState;
+interface InspectedComponentData {
+  id: string;
+  name: string;
+  file: string;
+  state: ComponentState[];
+  functional?: boolean;
+}
+//#endregion
+//#region ../devtools-kit/src/ctx/hook.d.ts
+declare enum DevToolsV6PluginAPIHookKeys {
+  VISIT_COMPONENT_TREE = "visitComponentTree",
+  INSPECT_COMPONENT = "inspectComponent",
+  EDIT_COMPONENT_STATE = "editComponentState",
+  GET_INSPECTOR_TREE = "getInspectorTree",
+  GET_INSPECTOR_STATE = "getInspectorState",
+  EDIT_INSPECTOR_STATE = "editInspectorState",
+  INSPECT_TIMELINE_EVENT = "inspectTimelineEvent",
+  TIMELINE_CLEARED = "timelineCleared",
+  SET_PLUGIN_SETTINGS = "setPluginSettings",
+}
+interface DevToolsV6PluginAPIHookPayloads {
+  [DevToolsV6PluginAPIHookKeys.VISIT_COMPONENT_TREE]: {
+    app: App$1;
+    componentInstance: ComponentInstance;
+    treeNode: ComponentTreeNode;
+    filter: string;
+  };
+  [DevToolsV6PluginAPIHookKeys.INSPECT_COMPONENT]: {
+    app: App$1;
+    componentInstance: ComponentInstance;
+    instanceData: InspectedComponentData;
+  };
+  [DevToolsV6PluginAPIHookKeys.EDIT_COMPONENT_STATE]: {
+    app: App$1;
+    inspectorId: string;
+    nodeId: string;
+    path: string[];
+    type: string;
+    state: EditStatePayload;
+    set: (object: any, path?: string | (string[]), value?: any, cb?: (object: any, field: string, value: any) => void) => void;
+  };
+  [DevToolsV6PluginAPIHookKeys.GET_INSPECTOR_TREE]: {
+    app: App$1;
+    inspectorId: string;
+    filter: string;
+    rootNodes: CustomInspectorNode[];
+  };
+  [DevToolsV6PluginAPIHookKeys.GET_INSPECTOR_STATE]: {
+    app: App$1;
+    inspectorId: string;
+    nodeId: string;
+    state: CustomInspectorState;
+  };
+  [DevToolsV6PluginAPIHookKeys.EDIT_INSPECTOR_STATE]: {
+    app: App$1;
+    inspectorId: string;
+    nodeId: string;
+    path: string[];
+    type: string;
+    state: EditStatePayload;
+    set: (object: any, path?: string | (string[]), value?: any, cb?: (object: any, field: string, value: any) => void) => void;
+  };
+  [DevToolsV6PluginAPIHookKeys.INSPECT_TIMELINE_EVENT]: {
+    app: App$1;
+    layerId: string;
+    event: TimelineEvent;
+    all?: boolean;
+    data: any;
+  };
+  [DevToolsV6PluginAPIHookKeys.TIMELINE_CLEARED]: Record<string, never>;
+  [DevToolsV6PluginAPIHookKeys.SET_PLUGIN_SETTINGS]: {
+    app: App$1;
+    pluginId: string;
+    key: string;
+    newValue: any;
+    oldValue: any;
+    settings: any;
+  };
+}
+//#endregion
+//#region ../devtools-kit/src/core/open-in-editor/index.d.ts
+interface OpenInEditorOptions {
+  baseUrl?: string;
+  file?: string;
+  line?: number;
+  column?: number;
+  host?: string;
+}
+//#endregion
+//#region ../devtools-kit/src/types/router.d.ts
+interface RouterInfo {
+  currentRoute: RouteLocationNormalizedLoaded | null | Record<string, any>;
+  routes: RouteRecordNormalized[];
+}
+//#endregion
+//#region ../devtools-kit/src/types/tab.d.ts
+type TabCategory = 'pinned' | 'app' | 'modules' | 'advanced';
+type ModuleView = ModuleIframeView | ModuleVNodeView | ModuleSFCView;
+interface ModuleIframeView {
+  /**
+   * Iframe view
+   */
+  type: 'iframe';
+  /**
+   * Url of the iframe
+   */
+  src: string;
+  /**
+   * Persist the iframe instance even if the tab is not active
+   *
+   * @default true
+   */
+  persistent?: boolean;
+}
+interface ModuleVNodeView {
+  /**
+   * Vue's VNode view
+   */
+  type: 'vnode';
+  /**
+   * Send vnode to the client, they must be static and serializable
+   */
+  vnode: VNode;
+}
+interface ModuleSFCView {
+  /**
+   * SFC view
+   */
+  type: 'sfc';
+  /**
+   * SFC component
+   */
+  sfc: string;
+}
+interface CustomTab {
+  /**
+   * The name of the tab, must be unique
+   */
+  name: string;
+  /**
+   * Icon of the tab, support any Iconify icons, or a url to an image
+   */
+  icon?: string;
+  /**
+   * Title of the tab
+   */
+  title: string;
+  /**
+   * Main view of the tab
+   */
+  view: ModuleView;
+  /**
+   * Category of the tab
+   * @default 'app'
+   */
+  category?: TabCategory;
+}
+//#endregion
+//#region ../devtools-kit/src/types/timeline.d.ts
+interface TimelineEvent<TData = any, TMeta = any> {
+  time: number;
+  data: TData;
+  logType?: 'default' | 'warning' | 'error';
+  meta?: TMeta;
+  groupId?: number | string;
+  title?: string;
+  subtitle?: string;
+}
+//#endregion
+//#region ../devtools-kit/src/messaging/index.d.ts
+declare function getRpcClient<R, L extends object = Record<string, never>>(): BirpcReturn<R, L>;
+declare function getRpcServer<R, L extends object = Record<string, never>>(): BirpcGroup<R, L>;
+declare function getViteRpcClient<R, L extends object = Record<string, never>>(): BirpcReturn<R, L>;
+//#endregion
+//#region src/rpc/global.d.ts
+declare enum DevToolsMessagingEvents {
+  INSPECTOR_TREE_UPDATED = "inspector-tree-updated",
+  INSPECTOR_STATE_UPDATED = "inspector-state-updated",
+  DEVTOOLS_STATE_UPDATED = "devtools-state-updated",
+  ROUTER_INFO_UPDATED = "router-info-updated",
+  TIMELINE_EVENT_UPDATED = "timeline-event-updated",
+  INSPECTOR_UPDATED = "inspector-updated",
+  ACTIVE_APP_UNMOUNTED = "active-app-updated",
+  DESTROY_DEVTOOLS_CLIENT = "destroy-devtools-client",
+  RELOAD_DEVTOOLS_CLIENT = "reload-devtools-client",
+}
+declare const functions: {
+  on: (event: string, handler: Function) => void;
+  off: (event: string, handler: Function) => void;
+  once: (event: string, handler: Function) => void;
+  emit: (event: string, ...args: any[]) => void;
+  heartbeat: () => boolean;
+  devtoolsState: () => {
+    connected: boolean;
+    clientConnected: boolean;
+    vueVersion: string;
+    tabs: CustomTab[];
+    commands: CustomCommand[];
+    vitePluginDetected: boolean;
+    appRecords: {
+      id: string;
+      name: string;
+      version: string | undefined;
+      routerId: string | undefined;
+      iframe: string | undefined;
+    }[];
+    activeAppRecordId: string;
+    timelineLayersState: Record<string, boolean>;
+  };
+  getInspectorTree(payload: Pick<DevToolsV6PluginAPIHookPayloads[DevToolsV6PluginAPIHookKeys.GET_INSPECTOR_TREE], "inspectorId" | "filter">): Promise<string>;
+  getInspectorState(payload: Pick<DevToolsV6PluginAPIHookPayloads[DevToolsV6PluginAPIHookKeys.GET_INSPECTOR_STATE], "inspectorId" | "nodeId">): Promise<string>;
+  editInspectorState(payload: DevToolsV6PluginAPIHookPayloads[DevToolsV6PluginAPIHookKeys.EDIT_INSPECTOR_STATE]): Promise<void>;
+  sendInspectorState(id: string): void;
+  inspectComponentInspector(): Promise<string>;
+  cancelInspectComponentInspector(): void;
+  getComponentRenderCode(id: string): any;
+  scrollToComponent(id: string): void;
+  inspectDOM(id: string): void;
+  getInspectorNodeActions(id: string): {
+    icon: string;
+    tooltip?: string;
+    action: (nodeId: string) => void | Promise<void>;
+  }[] | undefined;
+  getInspectorActions(id: string): {
+    icon: string;
+    tooltip?: string;
+    action: () => void | Promise<void>;
+  }[] | undefined;
+  updateTimelineLayersState(state: Record<string, boolean>): void;
+  callInspectorNodeAction(inspectorId: string, actionIndex: number, nodeId: string): void;
+  callInspectorAction(inspectorId: string, actionIndex: number): void;
+  openInEditor(options: OpenInEditorOptions): void;
+  checkVueInspectorDetected(): Promise<boolean>;
+  enableVueInspector(): Promise<void>;
+  toggleApp(id: string, options?: {
+    inspectingComponent?: boolean;
+  }): Promise<void>;
+  updatePluginSettings(pluginId: string, key: string, value: string): void;
+  getPluginSettings(pluginId: string): {
+    options: Record<string, {
+      label: string;
+      description?: string;
+    } & ({
+      type: "boolean";
+      defaultValue: boolean;
+    } | {
+      type: "choice";
+      defaultValue: string | number;
+      options: {
+        value: string | number;
+        label: string;
+      }[];
+      component?: "select" | "button-group";
+    } | {
+      type: "text";
+      defaultValue: string;
+    })> | null;
+    values: any;
+  };
+  getRouterInfo(): RouterInfo;
+  navigate(path: string): Promise<void | vue_router0.NavigationFailure | {} | undefined>;
+  getMatchedRoutes(path: string): vue_router0.RouteRecordNormalized[];
+  toggleClientConnected(state: boolean): void;
+  getCustomInspector(): {
+    id: string;
+    label: string;
+    logo: string;
+    icon: string;
+    packageName: string | undefined;
+    homepage: string | undefined;
+    pluginId: string;
+  }[];
+  getInspectorInfo(id: string): {
+    id: string;
+    label: string;
+    logo: string | undefined;
+    packageName: string | undefined;
+    homepage: string | undefined;
+    timelineLayers: {
+      id: string;
+      label: string;
+      color: number;
+    }[];
+    treeFilterPlaceholder: string;
+    stateFilterPlaceholder: string;
+  } | undefined;
+  highlighComponent(uid: string): Promise<any>;
+  unhighlight(): Promise<any>;
+  updateDevToolsClientDetected(params: Record<string, boolean>): void;
+  initDevToolsServerListener(): void;
+};
+type RPCFunctions = typeof functions;
+declare const rpc: {
+  value: ReturnType<typeof getRpcClient<RPCFunctions>>;
+  functions: ReturnType<typeof getRpcClient<RPCFunctions>>;
+};
+declare const rpcServer: {
+  value: ReturnType<typeof getRpcServer<RPCFunctions>>;
+  functions: ReturnType<typeof getRpcServer<RPCFunctions>>;
+};
+declare function onRpcConnected(callback: () => void): void;
+declare function onRpcSeverReady(callback: () => void): void;
+//#endregion
+//#region src/rpc/types.d.ts
+type AssetType = 'image' | 'font' | 'video' | 'audio' | 'text' | 'json' | 'wasm' | 'other';
+interface AssetInfo {
+  path: string;
+  type: AssetType;
+  publicPath: string;
+  relativePath: string;
+  filePath: string;
+  size: number;
+  mtime: number;
+}
+interface ImageMeta {
+  width: number;
+  height: number;
+  orientation?: number;
+  type?: string;
+  mimeType?: string;
+}
+type AssetImporter = Pick<ModuleNode, 'url' | 'id'>;
+interface AssetEntry {
+  path: string;
+  content: string;
+  encoding?: BufferEncoding;
+  override?: boolean;
+}
+interface CodeSnippet {
+  code: string;
+  lang: string;
+  name: string;
+  docs?: string;
+}
+interface ModuleInfo {
+  id: string;
+  plugins: {
+    name: string;
+    transform?: number;
+    resolveId?: number;
+  }[];
+  deps: string[];
+  virtual: boolean;
+}
+//#endregion
+//#region src/rpc/vite.d.ts
+declare const viteRpcFunctions: {
+  on: (event: string, handler: Function) => void;
+  off: (event: string, handler: Function) => void;
+  once: (event: string, handler: Function) => void;
+  emit: (event: string, ...args: any[]) => void;
+  heartbeat: () => boolean;
+};
+type ViteRPCFunctions = typeof viteRpcFunctions & {
+  getStaticAssets: () => Promise<AssetInfo[]>;
+  getAssetImporters: (url: string) => Promise<AssetImporter[]>;
+  getImageMeta: (filepath: string) => Promise<ImageMeta>;
+  getTextAssetContent: (filepath: string, limit?: number) => Promise<string>;
+  getRoot: () => Promise<string>;
+  getGraphModules: () => Promise<ModuleInfo[]>;
+};
+declare const viteRpc: {
+  value: ReturnType<typeof getViteRpcClient<ViteRPCFunctions>>;
+  functions: ReturnType<typeof getViteRpcClient<ViteRPCFunctions>>;
+};
+declare function onViteRpcConnected(callback: () => void): void;
+declare function createViteClientRpc(): void;
+declare function createViteServerRpc(functions: Record<string, any>): void;
+//#endregion
+//#region src/vue-plugin/devtools-state.d.ts
+interface DevToolsState {
+  connected: boolean;
+  clientConnected: boolean;
+  vueVersion: string;
+  tabs: CustomTab[];
+  commands: CustomCommand[];
+  vitePluginDetected: boolean;
+  appRecords: AppRecord[];
+  activeAppRecordId: string;
+  timelineLayersState: Record<string, boolean>;
+}
+type DevToolsRefState = { [P in keyof DevToolsState]: Ref<DevToolsState[P]> };
+declare function VueDevToolsVuePlugin(): {
+  install(app: App): void;
+};
+declare function createDevToolsStateContext(): {
+  getDevToolsState: () => void;
+  connected: Ref<boolean, boolean>;
+  clientConnected: Ref<boolean, boolean>;
+  vueVersion: Ref<string, string>;
+  tabs: Ref<{
+    name: string;
+    icon?: string | undefined;
+    title: string;
+    view: {
+      type: "iframe";
+      src: string;
+      persistent?: boolean | undefined;
+    } | {
+      type: "vnode";
+      vnode: vue0.VNode;
+    } | {
+      type: "sfc";
+      sfc: string;
+    };
+    category?: ("app" | "pinned" | "modules" | "advanced") | undefined;
+  }[], CustomTab[] | {
+    name: string;
+    icon?: string | undefined;
+    title: string;
+    view: {
+      type: "iframe";
+      src: string;
+      persistent?: boolean | undefined;
+    } | {
+      type: "vnode";
+      vnode: vue0.VNode;
+    } | {
+      type: "sfc";
+      sfc: string;
+    };
+    category?: ("app" | "pinned" | "modules" | "advanced") | undefined;
+  }[]>;
+  commands: Ref<{
+    id: string;
+    title: string;
+    description?: string | undefined;
+    order?: number | undefined;
+    icon?: string | undefined;
+    action?: {
+      type: "url";
+      src: string;
+    } | undefined;
+    children?: {
+      title: string;
+      icon?: string | undefined;
+      id: string;
+      description?: string | undefined;
+      order?: number | undefined;
+      action?: {
+        type: "url";
+        src: string;
+      } | undefined;
+    }[] | undefined;
+  }[], CustomCommand[] | {
+    id: string;
+    title: string;
+    description?: string | undefined;
+    order?: number | undefined;
+    icon?: string | undefined;
+    action?: {
+      type: "url";
+      src: string;
+    } | undefined;
+    children?: {
+      title: string;
+      icon?: string | undefined;
+      id: string;
+      description?: string | undefined;
+      order?: number | undefined;
+      action?: {
+        type: "url";
+        src: string;
+      } | undefined;
+    }[] | undefined;
+  }[]>;
+  vitePluginDetected: Ref<boolean, boolean>;
+  appRecords: Ref<{
+    id: string;
+    name: string;
+    app?: App$1;
+    version?: string | undefined;
+    types?: Record<string, string | symbol> | undefined;
+    instanceMap: Map<string, any> & Omit<Map<string, any>, keyof Map<any, any>>;
+    perfGroupIds: Map<string, {
+      groupId: number;
+      time: number;
+    }> & Omit<Map<string, {
+      groupId: number;
+      time: number;
+    }>, keyof Map<any, any>>;
+    rootInstance: VueAppInstance;
+    routerId?: string | undefined;
+    iframe?: string | undefined;
+  }[], AppRecord[] | {
+    id: string;
+    name: string;
+    app?: App$1;
+    version?: string | undefined;
+    types?: Record<string, string | symbol> | undefined;
+    instanceMap: Map<string, any> & Omit<Map<string, any>, keyof Map<any, any>>;
+    perfGroupIds: Map<string, {
+      groupId: number;
+      time: number;
+    }> & Omit<Map<string, {
+      groupId: number;
+      time: number;
+    }>, keyof Map<any, any>>;
+    rootInstance: VueAppInstance;
+    routerId?: string | undefined;
+    iframe?: string | undefined;
+  }[]>;
+  activeAppRecordId: Ref<string, string>;
+  timelineLayersState: Ref<Record<string, boolean>, Record<string, boolean>>;
+};
+declare function useDevToolsState(): DevToolsRefState;
+declare function onDevToolsConnected(fn: () => void): () => void;
+declare function refreshCurrentPageData(): void;
+//#endregion
+export { AssetEntry, AssetImporter, AssetInfo, AssetType, CodeSnippet, DevToolsMessagingEvents, ImageMeta, ModuleInfo, RPCFunctions, ViteRPCFunctions, VueDevToolsVuePlugin, createDevToolsStateContext, createViteClientRpc, createViteServerRpc, functions, getDevToolsClientUrl, onDevToolsConnected, onRpcConnected, onRpcSeverReady, onViteRpcConnected, refreshCurrentPageData, rpc, rpcServer, setDevToolsClientUrl, useDevToolsState, viteRpc, viteRpcFunctions };

web/node_modules/@vue/devtools-core/dist/index.js

@@ -0,0 +1,532 @@
+import { isBrowser, target } from "@vue/devtools-shared";
+import { DevToolsContextHookKeys, DevToolsMessagingHookKeys, createRpcClient, createRpcServer, devtools, devtoolsRouter, devtoolsRouterInfo, getActiveInspectors, getInspector, getInspectorActions, getInspectorInfo, getInspectorNodeActions, getRpcClient, getRpcServer, getViteRpcClient, stringify, toggleClientConnected, updateDevToolsClientDetected, updateTimelineLayersState } from "@vue/devtools-kit";
+import { computed, inject, onUnmounted, ref, watch } from "vue";
+
+//#region src/client.ts
+function setDevToolsClientUrl(url) {
+	target.__VUE_DEVTOOLS_CLIENT_URL__ = url;
+}
+function getDevToolsClientUrl() {
+	return target.__VUE_DEVTOOLS_CLIENT_URL__ ?? (() => {
+		if (isBrowser) {
+			const devtoolsMeta = document.querySelector("meta[name=__VUE_DEVTOOLS_CLIENT_URL__]");
+			if (devtoolsMeta) return devtoolsMeta.getAttribute("content");
+		}
+		return "";
+	})();
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/hookable@5.5.3/node_modules/hookable/dist/index.mjs
+function flatHooks(configHooks, hooks$2 = {}, parentName) {
+	for (const key in configHooks) {
+		const subHook = configHooks[key];
+		const name = parentName ? `${parentName}:${key}` : key;
+		if (typeof subHook === "object" && subHook !== null) flatHooks(subHook, hooks$2, name);
+		else if (typeof subHook === "function") hooks$2[name] = subHook;
+	}
+	return hooks$2;
+}
+const defaultTask = { run: (function_) => function_() };
+const _createTask = () => defaultTask;
+const createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
+function serialTaskCaller(hooks$2, args) {
+	const task = createTask(args.shift());
+	return hooks$2.reduce((promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))), Promise.resolve());
+}
+function parallelTaskCaller(hooks$2, args) {
+	const task = createTask(args.shift());
+	return Promise.all(hooks$2.map((hook) => task.run(() => hook(...args))));
+}
+function callEachWith(callbacks, arg0) {
+	for (const callback of [...callbacks]) callback(arg0);
+}
+var Hookable = class {
+	constructor() {
+		this._hooks = {};
+		this._before = void 0;
+		this._after = void 0;
+		this._deprecatedMessages = void 0;
+		this._deprecatedHooks = {};
+		this.hook = this.hook.bind(this);
+		this.callHook = this.callHook.bind(this);
+		this.callHookWith = this.callHookWith.bind(this);
+	}
+	hook(name, function_, options = {}) {
+		if (!name || typeof function_ !== "function") return () => {};
+		const originalName = name;
+		let dep;
+		while (this._deprecatedHooks[name]) {
+			dep = this._deprecatedHooks[name];
+			name = dep.to;
+		}
+		if (dep && !options.allowDeprecated) {
+			let message = dep.message;
+			if (!message) message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
+			if (!this._deprecatedMessages) this._deprecatedMessages = /* @__PURE__ */ new Set();
+			if (!this._deprecatedMessages.has(message)) {
+				console.warn(message);
+				this._deprecatedMessages.add(message);
+			}
+		}
+		if (!function_.name) try {
+			Object.defineProperty(function_, "name", {
+				get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
+				configurable: true
+			});
+		} catch {}
+		this._hooks[name] = this._hooks[name] || [];
+		this._hooks[name].push(function_);
+		return () => {
+			if (function_) {
+				this.removeHook(name, function_);
+				function_ = void 0;
+			}
+		};
+	}
+	hookOnce(name, function_) {
+		let _unreg;
+		let _function = (...arguments_) => {
+			if (typeof _unreg === "function") _unreg();
+			_unreg = void 0;
+			_function = void 0;
+			return function_(...arguments_);
+		};
+		_unreg = this.hook(name, _function);
+		return _unreg;
+	}
+	removeHook(name, function_) {
+		if (this._hooks[name]) {
+			const index = this._hooks[name].indexOf(function_);
+			if (index !== -1) this._hooks[name].splice(index, 1);
+			if (this._hooks[name].length === 0) delete this._hooks[name];
+		}
+	}
+	deprecateHook(name, deprecated) {
+		this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
+		const _hooks = this._hooks[name] || [];
+		delete this._hooks[name];
+		for (const hook of _hooks) this.hook(name, hook);
+	}
+	deprecateHooks(deprecatedHooks) {
+		Object.assign(this._deprecatedHooks, deprecatedHooks);
+		for (const name in deprecatedHooks) this.deprecateHook(name, deprecatedHooks[name]);
+	}
+	addHooks(configHooks) {
+		const hooks$2 = flatHooks(configHooks);
+		const removeFns = Object.keys(hooks$2).map((key) => this.hook(key, hooks$2[key]));
+		return () => {
+			for (const unreg of removeFns.splice(0, removeFns.length)) unreg();
+		};
+	}
+	removeHooks(configHooks) {
+		const hooks$2 = flatHooks(configHooks);
+		for (const key in hooks$2) this.removeHook(key, hooks$2[key]);
+	}
+	removeAllHooks() {
+		for (const key in this._hooks) delete this._hooks[key];
+	}
+	callHook(name, ...arguments_) {
+		arguments_.unshift(name);
+		return this.callHookWith(serialTaskCaller, name, ...arguments_);
+	}
+	callHookParallel(name, ...arguments_) {
+		arguments_.unshift(name);
+		return this.callHookWith(parallelTaskCaller, name, ...arguments_);
+	}
+	callHookWith(caller, name, ...arguments_) {
+		const event = this._before || this._after ? {
+			name,
+			args: arguments_,
+			context: {}
+		} : void 0;
+		if (this._before) callEachWith(this._before, event);
+		const result = caller(name in this._hooks ? [...this._hooks[name]] : [], arguments_);
+		if (result instanceof Promise) return result.finally(() => {
+			if (this._after && event) callEachWith(this._after, event);
+		});
+		if (this._after && event) callEachWith(this._after, event);
+		return result;
+	}
+	beforeEach(function_) {
+		this._before = this._before || [];
+		this._before.push(function_);
+		return () => {
+			if (this._before !== void 0) {
+				const index = this._before.indexOf(function_);
+				if (index !== -1) this._before.splice(index, 1);
+			}
+		};
+	}
+	afterEach(function_) {
+		this._after = this._after || [];
+		this._after.push(function_);
+		return () => {
+			if (this._after !== void 0) {
+				const index = this._after.indexOf(function_);
+				if (index !== -1) this._after.splice(index, 1);
+			}
+		};
+	}
+};
+function createHooks() {
+	return new Hookable();
+}
+
+//#endregion
+//#region src/rpc/global.ts
+const hooks$1 = createHooks();
+let DevToolsMessagingEvents = /* @__PURE__ */ function(DevToolsMessagingEvents$1) {
+	DevToolsMessagingEvents$1["INSPECTOR_TREE_UPDATED"] = "inspector-tree-updated";
+	DevToolsMessagingEvents$1["INSPECTOR_STATE_UPDATED"] = "inspector-state-updated";
+	DevToolsMessagingEvents$1["DEVTOOLS_STATE_UPDATED"] = "devtools-state-updated";
+	DevToolsMessagingEvents$1["ROUTER_INFO_UPDATED"] = "router-info-updated";
+	DevToolsMessagingEvents$1["TIMELINE_EVENT_UPDATED"] = "timeline-event-updated";
+	DevToolsMessagingEvents$1["INSPECTOR_UPDATED"] = "inspector-updated";
+	DevToolsMessagingEvents$1["ACTIVE_APP_UNMOUNTED"] = "active-app-updated";
+	DevToolsMessagingEvents$1["DESTROY_DEVTOOLS_CLIENT"] = "destroy-devtools-client";
+	DevToolsMessagingEvents$1["RELOAD_DEVTOOLS_CLIENT"] = "reload-devtools-client";
+	return DevToolsMessagingEvents$1;
+}({});
+function getDevToolsState() {
+	const state = devtools.ctx.state;
+	return {
+		connected: state.connected,
+		clientConnected: true,
+		vueVersion: state?.activeAppRecord?.version || "",
+		tabs: state.tabs,
+		commands: state.commands,
+		vitePluginDetected: state.vitePluginDetected,
+		appRecords: state.appRecords.map((item) => ({
+			id: item.id,
+			name: item.name,
+			version: item.version,
+			routerId: item.routerId,
+			iframe: item.iframe
+		})),
+		activeAppRecordId: state.activeAppRecordId,
+		timelineLayersState: state.timelineLayersState
+	};
+}
+const functions = {
+	on: (event, handler) => {
+		hooks$1.hook(event, handler);
+	},
+	off: (event, handler) => {
+		hooks$1.removeHook(event, handler);
+	},
+	once: (event, handler) => {
+		hooks$1.hookOnce(event, handler);
+	},
+	emit: (event, ...args) => {
+		hooks$1.callHook(event, ...args);
+	},
+	heartbeat: () => {
+		return true;
+	},
+	devtoolsState: () => {
+		return getDevToolsState();
+	},
+	async getInspectorTree(payload) {
+		return stringify(await devtools.ctx.api.getInspectorTree(payload));
+	},
+	async getInspectorState(payload) {
+		const inspector = getInspector(payload.inspectorId);
+		if (inspector) inspector.selectedNodeId = payload.nodeId;
+		return stringify(await devtools.ctx.api.getInspectorState(payload));
+	},
+	async editInspectorState(payload) {
+		return await devtools.ctx.api.editInspectorState(payload);
+	},
+	sendInspectorState(id) {
+		return devtools.ctx.api.sendInspectorState(id);
+	},
+	inspectComponentInspector() {
+		return devtools.ctx.api.inspectComponentInspector();
+	},
+	cancelInspectComponentInspector() {
+		return devtools.ctx.api.cancelInspectComponentInspector();
+	},
+	getComponentRenderCode(id) {
+		return devtools.ctx.api.getComponentRenderCode(id);
+	},
+	scrollToComponent(id) {
+		return devtools.ctx.api.scrollToComponent(id);
+	},
+	inspectDOM(id) {
+		return devtools.ctx.api.inspectDOM(id);
+	},
+	getInspectorNodeActions(id) {
+		return getInspectorNodeActions(id);
+	},
+	getInspectorActions(id) {
+		return getInspectorActions(id);
+	},
+	updateTimelineLayersState(state) {
+		return updateTimelineLayersState(state);
+	},
+	callInspectorNodeAction(inspectorId, actionIndex, nodeId) {
+		const nodeActions = getInspectorNodeActions(inspectorId);
+		if (nodeActions?.length) nodeActions[actionIndex].action?.(nodeId);
+	},
+	callInspectorAction(inspectorId, actionIndex) {
+		const actions = getInspectorActions(inspectorId);
+		if (actions?.length) actions[actionIndex].action?.();
+	},
+	openInEditor(options) {
+		return devtools.ctx.api.openInEditor(options);
+	},
+	async checkVueInspectorDetected() {
+		return !!await devtools.ctx.api.getVueInspector();
+	},
+	async enableVueInspector() {
+		const inspector = await devtools?.api?.getVueInspector?.();
+		if (inspector) await inspector.enable();
+	},
+	async toggleApp(id, options) {
+		return devtools.ctx.api.toggleApp(id, options);
+	},
+	updatePluginSettings(pluginId, key, value) {
+		return devtools.ctx.api.updatePluginSettings(pluginId, key, value);
+	},
+	getPluginSettings(pluginId) {
+		return devtools.ctx.api.getPluginSettings(pluginId);
+	},
+	getRouterInfo() {
+		return devtoolsRouterInfo;
+	},
+	navigate(path) {
+		return devtoolsRouter.value?.push(path).catch(() => ({}));
+	},
+	getMatchedRoutes(path) {
+		const c = console.warn;
+		console.warn = () => {};
+		const matched = devtoolsRouter.value?.resolve?.({ path: path || "/" }).matched ?? [];
+		console.warn = c;
+		return matched;
+	},
+	toggleClientConnected(state) {
+		toggleClientConnected(state);
+	},
+	getCustomInspector() {
+		return getActiveInspectors();
+	},
+	getInspectorInfo(id) {
+		return getInspectorInfo(id);
+	},
+	highlighComponent(uid) {
+		return devtools.ctx.hooks.callHook(DevToolsContextHookKeys.COMPONENT_HIGHLIGHT, { uid });
+	},
+	unhighlight() {
+		return devtools.ctx.hooks.callHook(DevToolsContextHookKeys.COMPONENT_UNHIGHLIGHT);
+	},
+	updateDevToolsClientDetected(params) {
+		updateDevToolsClientDetected(params);
+	},
+	initDevToolsServerListener() {
+		const broadcast = getRpcServer().broadcast;
+		devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_INSPECTOR_TREE_TO_CLIENT, (payload) => {
+			broadcast.emit(DevToolsMessagingEvents.INSPECTOR_TREE_UPDATED, stringify(payload));
+		});
+		devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_INSPECTOR_STATE_TO_CLIENT, (payload) => {
+			broadcast.emit(DevToolsMessagingEvents.INSPECTOR_STATE_UPDATED, stringify(payload));
+		});
+		devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.DEVTOOLS_STATE_UPDATED, () => {
+			broadcast.emit(DevToolsMessagingEvents.DEVTOOLS_STATE_UPDATED, getDevToolsState());
+		});
+		devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.ROUTER_INFO_UPDATED, ({ state }) => {
+			broadcast.emit(DevToolsMessagingEvents.ROUTER_INFO_UPDATED, state);
+		});
+		devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_TIMELINE_EVENT_TO_CLIENT, (payload) => {
+			broadcast.emit(DevToolsMessagingEvents.TIMELINE_EVENT_UPDATED, stringify(payload));
+		});
+		devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_INSPECTOR_TO_CLIENT, (payload) => {
+			broadcast.emit(DevToolsMessagingEvents.INSPECTOR_UPDATED, payload);
+		});
+		devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_ACTIVE_APP_UNMOUNTED_TO_CLIENT, () => {
+			broadcast.emit(DevToolsMessagingEvents.ACTIVE_APP_UNMOUNTED);
+		});
+	}
+};
+const rpc = new Proxy({
+	value: {},
+	functions: {}
+}, { get(target$1, property) {
+	const _rpc = getRpcClient();
+	if (property === "value") return _rpc;
+	else if (property === "functions") return _rpc.$functions;
+} });
+const rpcServer = new Proxy({
+	value: {},
+	functions: {}
+}, { get(target$1, property) {
+	const _rpc = getRpcServer();
+	if (property === "value") return _rpc;
+	else if (property === "functions") return _rpc.functions;
+} });
+function onRpcConnected(callback) {
+	let timer = null;
+	let retryCount = 0;
+	function heartbeat() {
+		rpc.value?.heartbeat?.().then(() => {
+			callback();
+			clearTimeout(timer);
+		}).catch(() => {});
+	}
+	timer = setInterval(() => {
+		if (retryCount >= 30) clearTimeout(timer);
+		retryCount++;
+		heartbeat();
+	}, retryCount * 200 + 200);
+	heartbeat();
+}
+function onRpcSeverReady(callback) {
+	let timer = null;
+	const timeout = 120;
+	function heartbeat() {
+		if (rpcServer.value.clients.length > 0) {
+			callback();
+			clearTimeout(timer);
+		}
+	}
+	timer = setInterval(() => {
+		heartbeat();
+	}, timeout);
+}
+
+//#endregion
+//#region src/rpc/vite.ts
+const hooks = createHooks();
+const viteRpcFunctions = {
+	on: (event, handler) => {
+		hooks.hook(event, handler);
+	},
+	off: (event, handler) => {
+		hooks.removeHook(event, handler);
+	},
+	once: (event, handler) => {
+		hooks.hookOnce(event, handler);
+	},
+	emit: (event, ...args) => {
+		hooks.callHook(event, ...args);
+	},
+	heartbeat: () => {
+		return true;
+	}
+};
+const viteRpc = new Proxy({
+	value: {},
+	functions: {}
+}, { get(target$1, property) {
+	const _rpc = getViteRpcClient();
+	if (property === "value") return _rpc;
+	else if (property === "functions") return _rpc?.$functions;
+} });
+function onViteRpcConnected(callback) {
+	let timer = null;
+	function heartbeat() {
+		viteRpc.value?.heartbeat?.().then(() => {
+			clearTimeout(timer);
+			callback();
+		}).catch(() => ({}));
+		timer = setTimeout(() => {
+			heartbeat();
+		}, 80);
+	}
+	heartbeat();
+}
+function createViteClientRpc() {
+	createRpcClient(viteRpcFunctions, { preset: "vite" });
+}
+function createViteServerRpc(functions$1) {
+	createRpcServer(functions$1, { preset: "vite" });
+}
+
+//#endregion
+//#region src/vue-plugin/devtools-state.ts
+const VueDevToolsStateSymbol = Symbol.for("__VueDevToolsStateSymbol__");
+function VueDevToolsVuePlugin() {
+	return { install(app) {
+		const state = createDevToolsStateContext();
+		state.getDevToolsState();
+		app.provide(VueDevToolsStateSymbol, state);
+		app.config.globalProperties.$getDevToolsState = state.getDevToolsState;
+		app.config.globalProperties.$disconnectDevToolsClient = () => {
+			state.clientConnected.value = false;
+			state.connected.value = false;
+		};
+	} };
+}
+function createDevToolsStateContext() {
+	const connected = ref(false);
+	const clientConnected = ref(false);
+	const vueVersion = ref("");
+	const tabs = ref([]);
+	const commands = ref([]);
+	const vitePluginDetected = ref(false);
+	const appRecords = ref([]);
+	const activeAppRecordId = ref("");
+	const timelineLayersState = ref({});
+	function updateState(data) {
+		connected.value = data.connected;
+		clientConnected.value = data.clientConnected;
+		vueVersion.value = data.vueVersion || "";
+		tabs.value = data.tabs;
+		commands.value = data.commands;
+		vitePluginDetected.value = data.vitePluginDetected;
+		appRecords.value = data.appRecords;
+		activeAppRecordId.value = data.activeAppRecordId;
+		timelineLayersState.value = data.timelineLayersState;
+	}
+	function getDevToolsState$1() {
+		onRpcConnected(() => {
+			rpc.value.devtoolsState().then((data) => {
+				updateState(data);
+			});
+			rpc.functions.off(DevToolsMessagingEvents.DEVTOOLS_STATE_UPDATED, updateState);
+			rpc.functions.on(DevToolsMessagingEvents.DEVTOOLS_STATE_UPDATED, updateState);
+		});
+	}
+	return {
+		getDevToolsState: getDevToolsState$1,
+		connected,
+		clientConnected,
+		vueVersion,
+		tabs,
+		commands,
+		vitePluginDetected,
+		appRecords,
+		activeAppRecordId,
+		timelineLayersState
+	};
+}
+function useDevToolsState() {
+	return inject(VueDevToolsStateSymbol);
+}
+const fns = [];
+function onDevToolsConnected(fn) {
+	const { connected, clientConnected } = useDevToolsState();
+	fns.push(fn);
+	onUnmounted(() => {
+		fns.splice(fns.indexOf(fn), 1);
+	});
+	const devtoolsReady = computed(() => clientConnected.value && connected.value);
+	if (devtoolsReady.value) fn();
+	else {
+		const stop = watch(devtoolsReady, (v) => {
+			if (v) {
+				fn();
+				stop();
+			}
+		});
+	}
+	return () => {
+		fns.splice(fns.indexOf(fn), 1);
+	};
+}
+function refreshCurrentPageData() {
+	fns.forEach((fn) => fn());
+}
+
+//#endregion
+export { DevToolsMessagingEvents, VueDevToolsVuePlugin, createDevToolsStateContext, createViteClientRpc, createViteServerRpc, functions, getDevToolsClientUrl, onDevToolsConnected, onRpcConnected, onRpcSeverReady, onViteRpcConnected, refreshCurrentPageData, rpc, rpcServer, setDevToolsClientUrl, useDevToolsState, viteRpc, viteRpcFunctions };

web/node_modules/@vue/devtools-core/node_modules/.bin/nanoid

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../nanoid/bin/nanoid.js" "$@"
+else 
+  exec node  "$basedir/../nanoid/bin/nanoid.js" "$@"
+fi

web/node_modules/@vue/devtools-core/node_modules/.bin/nanoid.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\nanoid\bin\nanoid.js" %*

web/node_modules/@vue/devtools-core/node_modules/.bin/nanoid.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../nanoid/bin/nanoid.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../nanoid/bin/nanoid.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../nanoid/bin/nanoid.js" $args
+  } else {
+    & "node$exe"  "$basedir/../nanoid/bin/nanoid.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

web/node_modules/@vue/devtools-core/node_modules/@vue/devtools-kit/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 webfansplz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

web/node_modules/@vue/devtools-core/node_modules/@vue/devtools-kit/README.md

@@ -0,0 +1,3 @@
+# @vue/devtools-kit
+
+> Utility kit for DevTools.

web/node_modules/@vue/devtools-core/node_modules/@vue/devtools-kit/global.d.ts

@@ -0,0 +1,20 @@
+import type { DevToolsHook, RouterInfo } from './src/types'
+
+/* eslint-disable vars-on-top */
+declare global {
+  var __VUE_DEVTOOLS_GLOBAL_HOOK__: DevToolsHook
+  var __VUE_DEVTOOLS_NEXT_APP_RECORD_INFO__: {
+    id: number
+    appIds: Set<string>
+  }
+  var __VUE_DEVTOOLS_ROUTER_INFO__: RouterInfo
+  var __VUE_DEVTOOLS_ENV__: {
+    vitePluginDetected: boolean
+  }
+  var __VUE_DEVTOOLS_COMPONENT_INSPECTOR_ENABLED__: boolean
+  var __VUE_DEVTOOLS_VITE_PLUGIN_DETECTED__: boolean
+  var __VUE_DEVTOOLS_VITE_PLUGIN_CLIENT_URL__: string
+  var __VUE_DEVTOOLS_BROWSER_EXTENSION_DETECTED__: boolean
+}
+
+export { }

web/node_modules/@vue/devtools-core/node_modules/@vue/devtools-kit/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@vue/devtools-kit",
+  "type": "module",
+  "version": "8.0.5",
+  "author": "webfansplz",
+  "license": "MIT",
+  "repository": {
+    "directory": "packages/devtools-kit",
+    "type": "git",
+    "url": "git+https://github.com/vuejs/devtools.git"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./types.d.ts",
+  "files": [
+    "**.d.ts",
+    "dist"
+  ],
+  "dependencies": {
+    "birpc": "^2.6.1",
+    "hookable": "^5.5.3",
+    "mitt": "^3.0.1",
+    "perfect-debounce": "^2.0.0",
+    "speakingurl": "^14.0.1",
+    "superjson": "^2.2.2",
+    "@vue/devtools-shared": "^8.0.5"
+  },
+  "devDependencies": {
+    "@types/speakingurl": "^13.0.6",
+    "vue": "^3.5.22",
+    "vue-router": "^4.6.0"
+  },
+  "scripts": {
+    "build": "tsdown --clean",
+    "prepare:type": "tsdown --dts-only",
+    "stub": "tsdown --watch --onSuccess 'tsdown --dts-only'"
+  }
+}

web/node_modules/@vue/devtools-core/node_modules/@vue/devtools-kit/types.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="./global.d.ts" />
+export * from './dist/index'

web/node_modules/@vue/devtools-core/node_modules/@vue/devtools-shared/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 webfansplz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

web/node_modules/@vue/devtools-core/node_modules/@vue/devtools-shared/README.md

@@ -0,0 +1,3 @@
+# @vue/devtools-shared
+
+> Internal utility types shared across @vue/devtools packages.

web/node_modules/@vue/devtools-core/node_modules/@vue/devtools-shared/dist/index.cjs

@@ -0,0 +1,275 @@
+//#region rolldown:runtime
+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 __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target$1) => (target$1 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target$1, "default", {
+	value: mod,
+	enumerable: true
+}) : target$1, mod));
+
+//#endregion
+
+//#region src/constants.ts
+const VIEW_MODE_STORAGE_KEY = "__vue-devtools-view-mode__";
+const VITE_PLUGIN_DETECTED_STORAGE_KEY = "__vue-devtools-vite-plugin-detected__";
+const VITE_PLUGIN_CLIENT_URL_STORAGE_KEY = "__vue-devtools-vite-plugin-client-url__";
+const BROADCAST_CHANNEL_NAME = "__vue-devtools-broadcast-channel__";
+
+//#endregion
+//#region src/env.ts
+const isBrowser = typeof navigator !== "undefined";
+const target = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : {};
+const isInChromePanel = typeof target.chrome !== "undefined" && !!target.chrome.devtools;
+const isInIframe = isBrowser && target.self !== target.top;
+const isInElectron = typeof navigator !== "undefined" && navigator.userAgent?.toLowerCase().includes("electron");
+const isNuxtApp = typeof window !== "undefined" && !!window.__NUXT__;
+const isInSeparateWindow = !isInIframe && !isInChromePanel && !isInElectron;
+
+//#endregion
+//#region ../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js
+var require_rfdc = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js": ((exports, module) => {
+	module.exports = rfdc$1;
+	function copyBuffer(cur) {
+		if (cur instanceof Buffer) return Buffer.from(cur);
+		return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
+	}
+	function rfdc$1(opts) {
+		opts = opts || {};
+		if (opts.circles) return rfdcCircles(opts);
+		const constructorHandlers = /* @__PURE__ */ new Map();
+		constructorHandlers.set(Date, (o) => new Date(o));
+		constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+		constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+		if (opts.constructorHandlers) for (const handler$1 of opts.constructorHandlers) constructorHandlers.set(handler$1[0], handler$1[1]);
+		let handler = null;
+		return opts.proto ? cloneProto : clone;
+		function cloneArray(a, fn) {
+			const keys = Object.keys(a);
+			const a2 = new Array(keys.length);
+			for (let i = 0; i < keys.length; i++) {
+				const k = keys[i];
+				const cur = a[k];
+				if (typeof cur !== "object" || cur === null) a2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) a2[k] = handler(cur, fn);
+				else if (ArrayBuffer.isView(cur)) a2[k] = copyBuffer(cur);
+				else a2[k] = fn(cur);
+			}
+			return a2;
+		}
+		function clone(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, clone);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, clone);
+			const o2 = {};
+			for (const k in o) {
+				if (Object.hasOwnProperty.call(o, k) === false) continue;
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, clone);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else o2[k] = clone(cur);
+			}
+			return o2;
+		}
+		function cloneProto(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, cloneProto);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, cloneProto);
+			const o2 = {};
+			for (const k in o) {
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, cloneProto);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else o2[k] = cloneProto(cur);
+			}
+			return o2;
+		}
+	}
+	function rfdcCircles(opts) {
+		const refs = [];
+		const refsNew = [];
+		const constructorHandlers = /* @__PURE__ */ new Map();
+		constructorHandlers.set(Date, (o) => new Date(o));
+		constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+		constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+		if (opts.constructorHandlers) for (const handler$1 of opts.constructorHandlers) constructorHandlers.set(handler$1[0], handler$1[1]);
+		let handler = null;
+		return opts.proto ? cloneProto : clone;
+		function cloneArray(a, fn) {
+			const keys = Object.keys(a);
+			const a2 = new Array(keys.length);
+			for (let i = 0; i < keys.length; i++) {
+				const k = keys[i];
+				const cur = a[k];
+				if (typeof cur !== "object" || cur === null) a2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) a2[k] = handler(cur, fn);
+				else if (ArrayBuffer.isView(cur)) a2[k] = copyBuffer(cur);
+				else {
+					const index = refs.indexOf(cur);
+					if (index !== -1) a2[k] = refsNew[index];
+					else a2[k] = fn(cur);
+				}
+			}
+			return a2;
+		}
+		function clone(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, clone);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, clone);
+			const o2 = {};
+			refs.push(o);
+			refsNew.push(o2);
+			for (const k in o) {
+				if (Object.hasOwnProperty.call(o, k) === false) continue;
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, clone);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else {
+					const i = refs.indexOf(cur);
+					if (i !== -1) o2[k] = refsNew[i];
+					else o2[k] = clone(cur);
+				}
+			}
+			refs.pop();
+			refsNew.pop();
+			return o2;
+		}
+		function cloneProto(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, cloneProto);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, cloneProto);
+			const o2 = {};
+			refs.push(o);
+			refsNew.push(o2);
+			for (const k in o) {
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, cloneProto);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else {
+					const i = refs.indexOf(cur);
+					if (i !== -1) o2[k] = refsNew[i];
+					else o2[k] = cloneProto(cur);
+				}
+			}
+			refs.pop();
+			refsNew.pop();
+			return o2;
+		}
+	}
+}) });
+
+//#endregion
+//#region src/general.ts
+var import_rfdc = /* @__PURE__ */ __toESM(require_rfdc(), 1);
+function NOOP() {}
+const isNumeric = (str) => `${+str}` === str;
+const isMacOS = () => navigator?.platform ? navigator?.platform.toLowerCase().includes("mac") : /Macintosh/.test(navigator.userAgent);
+const classifyRE = /(?:^|[-_/])(\w)/g;
+const camelizeRE = /-(\w)/g;
+const kebabizeRE = /([a-z0-9])([A-Z])/g;
+function toUpper(_, c) {
+	return c ? c.toUpperCase() : "";
+}
+function classify(str) {
+	return str && `${str}`.replace(classifyRE, toUpper);
+}
+function camelize(str) {
+	return str && str.replace(camelizeRE, toUpper);
+}
+function kebabize(str) {
+	return str && str.replace(kebabizeRE, (_, lowerCaseCharacter, upperCaseLetter) => {
+		return `${lowerCaseCharacter}-${upperCaseLetter}`;
+	}).toLowerCase();
+}
+function basename(filename, ext) {
+	let normalizedFilename = filename.replace(/^[a-z]:/i, "").replace(/\\/g, "/");
+	if (normalizedFilename.endsWith(`index${ext}`)) normalizedFilename = normalizedFilename.replace(`/index${ext}`, ext);
+	const lastSlashIndex = normalizedFilename.lastIndexOf("/");
+	const baseNameWithExt = normalizedFilename.substring(lastSlashIndex + 1);
+	if (ext) {
+		const extIndex = baseNameWithExt.lastIndexOf(ext);
+		return baseNameWithExt.substring(0, extIndex);
+	}
+	return "";
+}
+function sortByKey(state) {
+	return state && state.slice().sort((a, b) => {
+		if (a.key < b.key) return -1;
+		if (a.key > b.key) return 1;
+		return 0;
+	});
+}
+const HTTP_URL_RE = /^https?:\/\//;
+/**
+* Check a string is start with `/` or a valid http url
+*/
+function isUrlString(str) {
+	return str.startsWith("/") || HTTP_URL_RE.test(str);
+}
+/**
+* @copyright [rfdc](https://github.com/davidmarkclements/rfdc)
+* @description A really fast deep clone alternative
+*/
+const deepClone = (0, import_rfdc.default)({ circles: true });
+function randomStr() {
+	return Math.random().toString(36).slice(2);
+}
+function isObject(value) {
+	return typeof value === "object" && !Array.isArray(value) && value !== null;
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isSet(value) {
+	return value instanceof Set;
+}
+function isMap(value) {
+	return value instanceof Map;
+}
+
+//#endregion
+exports.BROADCAST_CHANNEL_NAME = BROADCAST_CHANNEL_NAME;
+exports.NOOP = NOOP;
+exports.VIEW_MODE_STORAGE_KEY = VIEW_MODE_STORAGE_KEY;
+exports.VITE_PLUGIN_CLIENT_URL_STORAGE_KEY = VITE_PLUGIN_CLIENT_URL_STORAGE_KEY;
+exports.VITE_PLUGIN_DETECTED_STORAGE_KEY = VITE_PLUGIN_DETECTED_STORAGE_KEY;
+exports.basename = basename;
+exports.camelize = camelize;
+exports.classify = classify;
+exports.deepClone = deepClone;
+exports.isArray = isArray;
+exports.isBrowser = isBrowser;
+exports.isInChromePanel = isInChromePanel;
+exports.isInElectron = isInElectron;
+exports.isInIframe = isInIframe;
+exports.isInSeparateWindow = isInSeparateWindow;
+exports.isMacOS = isMacOS;
+exports.isMap = isMap;
+exports.isNumeric = isNumeric;
+exports.isNuxtApp = isNuxtApp;
+exports.isObject = isObject;
+exports.isSet = isSet;
+exports.isUrlString = isUrlString;
+exports.kebabize = kebabize;
+exports.randomStr = randomStr;
+exports.sortByKey = sortByKey;
+exports.target = target;

web/node_modules/@vue/devtools-core/node_modules/@vue/devtools-shared/dist/index.d.cts

@@ -0,0 +1,40 @@
+//#region src/constants.d.ts
+declare const VIEW_MODE_STORAGE_KEY = "__vue-devtools-view-mode__";
+declare const VITE_PLUGIN_DETECTED_STORAGE_KEY = "__vue-devtools-vite-plugin-detected__";
+declare const VITE_PLUGIN_CLIENT_URL_STORAGE_KEY = "__vue-devtools-vite-plugin-client-url__";
+declare const BROADCAST_CHANNEL_NAME = "__vue-devtools-broadcast-channel__";
+//#endregion
+//#region src/env.d.ts
+declare const isBrowser: boolean;
+declare const target: typeof globalThis;
+declare const isInChromePanel: boolean;
+declare const isInIframe: boolean;
+declare const isInElectron: boolean;
+declare const isNuxtApp: boolean;
+declare const isInSeparateWindow: boolean;
+//#endregion
+//#region src/general.d.ts
+declare function NOOP(): void;
+declare const isNumeric: (str: string | number) => boolean;
+declare const isMacOS: () => boolean;
+declare function classify(str: string): string;
+declare function camelize(str: string): string;
+declare function kebabize(str: string): string;
+declare function basename(filename: string, ext: string): string;
+declare function sortByKey(state: unknown[]): Record<"key", number>[];
+/**
+ * Check a string is start with `/` or a valid http url
+ */
+declare function isUrlString(str: string): boolean;
+/**
+ * @copyright [rfdc](https://github.com/davidmarkclements/rfdc)
+ * @description A really fast deep clone alternative
+ */
+declare const deepClone: <T>(input: T) => T;
+declare function randomStr(): string;
+declare function isObject<T extends object>(value: any): value is T;
+declare function isArray<T>(value: any): value is T[];
+declare function isSet<T>(value: any): value is Set<T>;
+declare function isMap<K, V>(value: any): value is Map<K, V>;
+//#endregion
+export { BROADCAST_CHANNEL_NAME, NOOP, VIEW_MODE_STORAGE_KEY, VITE_PLUGIN_CLIENT_URL_STORAGE_KEY, VITE_PLUGIN_DETECTED_STORAGE_KEY, basename, camelize, classify, deepClone, isArray, isBrowser, isInChromePanel, isInElectron, isInIframe, isInSeparateWindow, isMacOS, isMap, isNumeric, isNuxtApp, isObject, isSet, isUrlString, kebabize, randomStr, sortByKey, target };

web/node_modules/@vue/devtools-core/node_modules/@vue/devtools-shared/dist/index.d.ts

@@ -0,0 +1,40 @@
+//#region src/constants.d.ts
+declare const VIEW_MODE_STORAGE_KEY = "__vue-devtools-view-mode__";
+declare const VITE_PLUGIN_DETECTED_STORAGE_KEY = "__vue-devtools-vite-plugin-detected__";
+declare const VITE_PLUGIN_CLIENT_URL_STORAGE_KEY = "__vue-devtools-vite-plugin-client-url__";
+declare const BROADCAST_CHANNEL_NAME = "__vue-devtools-broadcast-channel__";
+//#endregion
+//#region src/env.d.ts
+declare const isBrowser: boolean;
+declare const target: typeof globalThis;
+declare const isInChromePanel: boolean;
+declare const isInIframe: boolean;
+declare const isInElectron: boolean;
+declare const isNuxtApp: boolean;
+declare const isInSeparateWindow: boolean;
+//#endregion
+//#region src/general.d.ts
+declare function NOOP(): void;
+declare const isNumeric: (str: string | number) => boolean;
+declare const isMacOS: () => boolean;
+declare function classify(str: string): string;
+declare function camelize(str: string): string;
+declare function kebabize(str: string): string;
+declare function basename(filename: string, ext: string): string;
+declare function sortByKey(state: unknown[]): Record<"key", number>[];
+/**
+ * Check a string is start with `/` or a valid http url
+ */
+declare function isUrlString(str: string): boolean;
+/**
+ * @copyright [rfdc](https://github.com/davidmarkclements/rfdc)
+ * @description A really fast deep clone alternative
+ */
+declare const deepClone: <T>(input: T) => T;
+declare function randomStr(): string;
+declare function isObject<T extends object>(value: any): value is T;
+declare function isArray<T>(value: any): value is T[];
+declare function isSet<T>(value: any): value is Set<T>;
+declare function isMap<K, V>(value: any): value is Map<K, V>;
+//#endregion
+export { BROADCAST_CHANNEL_NAME, NOOP, VIEW_MODE_STORAGE_KEY, VITE_PLUGIN_CLIENT_URL_STORAGE_KEY, VITE_PLUGIN_DETECTED_STORAGE_KEY, basename, camelize, classify, deepClone, isArray, isBrowser, isInChromePanel, isInElectron, isInIframe, isInSeparateWindow, isMacOS, isMap, isNumeric, isNuxtApp, isObject, isSet, isUrlString, kebabize, randomStr, sortByKey, target };

web/node_modules/@vue/devtools-core/node_modules/@vue/devtools-shared/dist/index.js

@@ -0,0 +1,249 @@
+//#region rolldown:runtime
+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 __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target$1) => (target$1 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target$1, "default", {
+	value: mod,
+	enumerable: true
+}) : target$1, mod));
+
+//#endregion
+//#region src/constants.ts
+const VIEW_MODE_STORAGE_KEY = "__vue-devtools-view-mode__";
+const VITE_PLUGIN_DETECTED_STORAGE_KEY = "__vue-devtools-vite-plugin-detected__";
+const VITE_PLUGIN_CLIENT_URL_STORAGE_KEY = "__vue-devtools-vite-plugin-client-url__";
+const BROADCAST_CHANNEL_NAME = "__vue-devtools-broadcast-channel__";
+
+//#endregion
+//#region src/env.ts
+const isBrowser = typeof navigator !== "undefined";
+const target = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : {};
+const isInChromePanel = typeof target.chrome !== "undefined" && !!target.chrome.devtools;
+const isInIframe = isBrowser && target.self !== target.top;
+const isInElectron = typeof navigator !== "undefined" && navigator.userAgent?.toLowerCase().includes("electron");
+const isNuxtApp = typeof window !== "undefined" && !!window.__NUXT__;
+const isInSeparateWindow = !isInIframe && !isInChromePanel && !isInElectron;
+
+//#endregion
+//#region ../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js
+var require_rfdc = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js": ((exports, module) => {
+	module.exports = rfdc$1;
+	function copyBuffer(cur) {
+		if (cur instanceof Buffer) return Buffer.from(cur);
+		return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
+	}
+	function rfdc$1(opts) {
+		opts = opts || {};
+		if (opts.circles) return rfdcCircles(opts);
+		const constructorHandlers = /* @__PURE__ */ new Map();
+		constructorHandlers.set(Date, (o) => new Date(o));
+		constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+		constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+		if (opts.constructorHandlers) for (const handler$1 of opts.constructorHandlers) constructorHandlers.set(handler$1[0], handler$1[1]);
+		let handler = null;
+		return opts.proto ? cloneProto : clone;
+		function cloneArray(a, fn) {
+			const keys = Object.keys(a);
+			const a2 = new Array(keys.length);
+			for (let i = 0; i < keys.length; i++) {
+				const k = keys[i];
+				const cur = a[k];
+				if (typeof cur !== "object" || cur === null) a2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) a2[k] = handler(cur, fn);
+				else if (ArrayBuffer.isView(cur)) a2[k] = copyBuffer(cur);
+				else a2[k] = fn(cur);
+			}
+			return a2;
+		}
+		function clone(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, clone);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, clone);
+			const o2 = {};
+			for (const k in o) {
+				if (Object.hasOwnProperty.call(o, k) === false) continue;
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, clone);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else o2[k] = clone(cur);
+			}
+			return o2;
+		}
+		function cloneProto(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, cloneProto);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, cloneProto);
+			const o2 = {};
+			for (const k in o) {
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, cloneProto);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else o2[k] = cloneProto(cur);
+			}
+			return o2;
+		}
+	}
+	function rfdcCircles(opts) {
+		const refs = [];
+		const refsNew = [];
+		const constructorHandlers = /* @__PURE__ */ new Map();
+		constructorHandlers.set(Date, (o) => new Date(o));
+		constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+		constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+		if (opts.constructorHandlers) for (const handler$1 of opts.constructorHandlers) constructorHandlers.set(handler$1[0], handler$1[1]);
+		let handler = null;
+		return opts.proto ? cloneProto : clone;
+		function cloneArray(a, fn) {
+			const keys = Object.keys(a);
+			const a2 = new Array(keys.length);
+			for (let i = 0; i < keys.length; i++) {
+				const k = keys[i];
+				const cur = a[k];
+				if (typeof cur !== "object" || cur === null) a2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) a2[k] = handler(cur, fn);
+				else if (ArrayBuffer.isView(cur)) a2[k] = copyBuffer(cur);
+				else {
+					const index = refs.indexOf(cur);
+					if (index !== -1) a2[k] = refsNew[index];
+					else a2[k] = fn(cur);
+				}
+			}
+			return a2;
+		}
+		function clone(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, clone);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, clone);
+			const o2 = {};
+			refs.push(o);
+			refsNew.push(o2);
+			for (const k in o) {
+				if (Object.hasOwnProperty.call(o, k) === false) continue;
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, clone);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else {
+					const i = refs.indexOf(cur);
+					if (i !== -1) o2[k] = refsNew[i];
+					else o2[k] = clone(cur);
+				}
+			}
+			refs.pop();
+			refsNew.pop();
+			return o2;
+		}
+		function cloneProto(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, cloneProto);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, cloneProto);
+			const o2 = {};
+			refs.push(o);
+			refsNew.push(o2);
+			for (const k in o) {
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, cloneProto);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else {
+					const i = refs.indexOf(cur);
+					if (i !== -1) o2[k] = refsNew[i];
+					else o2[k] = cloneProto(cur);
+				}
+			}
+			refs.pop();
+			refsNew.pop();
+			return o2;
+		}
+	}
+}) });
+
+//#endregion
+//#region src/general.ts
+var import_rfdc = /* @__PURE__ */ __toESM(require_rfdc(), 1);
+function NOOP() {}
+const isNumeric = (str) => `${+str}` === str;
+const isMacOS = () => navigator?.platform ? navigator?.platform.toLowerCase().includes("mac") : /Macintosh/.test(navigator.userAgent);
+const classifyRE = /(?:^|[-_/])(\w)/g;
+const camelizeRE = /-(\w)/g;
+const kebabizeRE = /([a-z0-9])([A-Z])/g;
+function toUpper(_, c) {
+	return c ? c.toUpperCase() : "";
+}
+function classify(str) {
+	return str && `${str}`.replace(classifyRE, toUpper);
+}
+function camelize(str) {
+	return str && str.replace(camelizeRE, toUpper);
+}
+function kebabize(str) {
+	return str && str.replace(kebabizeRE, (_, lowerCaseCharacter, upperCaseLetter) => {
+		return `${lowerCaseCharacter}-${upperCaseLetter}`;
+	}).toLowerCase();
+}
+function basename(filename, ext) {
+	let normalizedFilename = filename.replace(/^[a-z]:/i, "").replace(/\\/g, "/");
+	if (normalizedFilename.endsWith(`index${ext}`)) normalizedFilename = normalizedFilename.replace(`/index${ext}`, ext);
+	const lastSlashIndex = normalizedFilename.lastIndexOf("/");
+	const baseNameWithExt = normalizedFilename.substring(lastSlashIndex + 1);
+	if (ext) {
+		const extIndex = baseNameWithExt.lastIndexOf(ext);
+		return baseNameWithExt.substring(0, extIndex);
+	}
+	return "";
+}
+function sortByKey(state) {
+	return state && state.slice().sort((a, b) => {
+		if (a.key < b.key) return -1;
+		if (a.key > b.key) return 1;
+		return 0;
+	});
+}
+const HTTP_URL_RE = /^https?:\/\//;
+/**
+* Check a string is start with `/` or a valid http url
+*/
+function isUrlString(str) {
+	return str.startsWith("/") || HTTP_URL_RE.test(str);
+}
+/**
+* @copyright [rfdc](https://github.com/davidmarkclements/rfdc)
+* @description A really fast deep clone alternative
+*/
+const deepClone = (0, import_rfdc.default)({ circles: true });
+function randomStr() {
+	return Math.random().toString(36).slice(2);
+}
+function isObject(value) {
+	return typeof value === "object" && !Array.isArray(value) && value !== null;
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isSet(value) {
+	return value instanceof Set;
+}
+function isMap(value) {
+	return value instanceof Map;
+}
+
+//#endregion
+export { BROADCAST_CHANNEL_NAME, NOOP, VIEW_MODE_STORAGE_KEY, VITE_PLUGIN_CLIENT_URL_STORAGE_KEY, VITE_PLUGIN_DETECTED_STORAGE_KEY, basename, camelize, classify, deepClone, isArray, isBrowser, isInChromePanel, isInElectron, isInIframe, isInSeparateWindow, isMacOS, isMap, isNumeric, isNuxtApp, isObject, isSet, isUrlString, kebabize, randomStr, sortByKey, target };

web/node_modules/@vue/devtools-core/node_modules/@vue/devtools-shared/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@vue/devtools-shared",
+  "type": "module",
+  "version": "8.0.5",
+  "author": "webfansplz",
+  "license": "MIT",
+  "repository": {
+    "directory": "packages/shared",
+    "type": "git",
+    "url": "git+https://github.com/vuejs/devtools.git"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "rfdc": "^1.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.7.2"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepare:type": "tsdown --dts-only",
+    "stub": "tsdown --watch --onSuccess 'tsdown --dts-only'"
+  }
+}

web/node_modules/@vue/devtools-core/node_modules/nanoid/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2017 Andrey Sitnik <andrey@sitnik.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

web/node_modules/@vue/devtools-core/node_modules/nanoid/README.md

@@ -0,0 +1,38 @@
+# Nano ID
+
+<img src="https://ai.github.io/nanoid/logo.svg" align="right"
+     alt="Nano ID logo by Anton Lovchikov" width="180" height="94">
+
+**English** | [日本語](./README.ja.md) | [Русский](./README.ru.md) | [简体中文](./README.zh-CN.md) | [Bahasa Indonesia](./README.id-ID.md) | [한국어](./README.ko.md)
+
+A tiny, secure, URL-friendly, unique string ID generator for JavaScript.
+
+> “An amazing level of senseless perfectionism,
+> which is simply impossible not to respect.”
+
+* **Small.** 118 bytes (minified and brotlied). No dependencies.
+  [Size Limit] controls the size.
+* **Safe.** It uses hardware random generator. Can be used in clusters.
+* **Short IDs.** It uses a larger alphabet than UUID (`A-Za-z0-9_-`).
+  So ID size was reduced from 36 to 21 symbols.
+* **Portable.** Nano ID was ported
+  to over [20 programming languages](./README.md#other-programming-languages).
+
+```js
+import { nanoid } from 'nanoid'
+model.id = nanoid() //=> "V1StGXR8_Z5jdHi6B-myT"
+```
+
+---
+
+<img src="https://cdn.evilmartians.com/badges/logo-no-label.svg" alt="" width="22" height="16" />  Made at <b><a href="https://evilmartians.com/devtools?utm_source=nanoid&utm_campaign=devtools-button&utm_medium=github">Evil Martians</a></b>, product consulting for <b>developer tools</b>.
+
+---
+
+[online tool]: https://gitpod.io/#https://github.com/ai/nanoid/
+[with Babel]:  https://developer.epages.com/blog/coding/how-to-transpile-node-modules-with-babel-and-webpack-in-a-monorepo/
+[Size Limit]:  https://github.com/ai/size-limit
+
+
+## Docs
+Read full docs **[here](https://github.com/ai/nanoid#readme)**.

web/node_modules/@vue/devtools-core/node_modules/nanoid/bin/nanoid.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { customAlphabet, nanoid } from '../index.js'
+function print(msg) {
+  process.stdout.write(msg + '\n')
+}
+function error(msg) {
+  process.stderr.write(msg + '\n')
+  process.exit(1)
+}
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  print(`Usage
+  $ nanoid [options]
+Options
+  -s, --size       Generated ID size
+  -a, --alphabet   Alphabet to use
+  -h, --help       Show this help
+Examples
+  $ nanoid -s 15
+  S9sBF77U6sDB8Yg
+  $ nanoid --size 10 --alphabet abc
+  bcabababca`)
+  process.exit()
+}
+let alphabet, size
+for (let i = 2; i < process.argv.length; i++) {
+  let arg = process.argv[i]
+  if (arg === '--size' || arg === '-s') {
+    size = Number(process.argv[i + 1])
+    i += 1
+    if (Number.isNaN(size) || size <= 0) {
+      error('Size must be positive integer')
+    }
+  } else if (arg === '--alphabet' || arg === '-a') {
+    alphabet = process.argv[i + 1]
+    i += 1
+  } else {
+    error('Unknown argument ' + arg)
+  }
+}
+if (alphabet) {
+  let customNanoid = customAlphabet(alphabet, size)
+  print(customNanoid())
+} else {
+  print(nanoid(size))
+}

web/node_modules/@vue/devtools-core/node_modules/nanoid/index.browser.js

@@ -0,0 +1,29 @@
+/* @ts-self-types="./index.d.ts" */
+import { urlAlphabet as scopedUrlAlphabet } from './url-alphabet/index.js'
+export { urlAlphabet } from './url-alphabet/index.js'
+export let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))
+export let customRandom = (alphabet, defaultSize, getRandom) => {
+  let mask = (2 << Math.log2(alphabet.length - 1)) - 1
+  let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+  return (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = getRandom(step)
+      let j = step | 0
+      while (j--) {
+        id += alphabet[bytes[j] & mask] || ''
+        if (id.length >= size) return id
+      }
+    }
+  }
+}
+export let customAlphabet = (alphabet, size = 21) =>
+  customRandom(alphabet, size | 0, random)
+export let nanoid = (size = 21) => {
+  let id = ''
+  let bytes = crypto.getRandomValues(new Uint8Array((size |= 0)))
+  while (size--) {
+    id += scopedUrlAlphabet[bytes[size] & 63]
+  }
+  return id
+}

web/node_modules/@vue/devtools-core/node_modules/nanoid/index.d.ts

@@ -0,0 +1,106 @@
+/**
+ * A tiny, secure, URL-friendly, unique string ID generator for JavaScript
+ * with hardware random generator.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid'
+ * model.id = nanoid() //=> "V1StGXR8_Z5jdHi6B-myT"
+ * ```
+ *
+ * @module
+ */
+
+/**
+ * Generate secure URL-friendly unique ID.
+ *
+ * By default, the ID will have 21 symbols to have a collision probability
+ * similar to UUID v4.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid'
+ * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL"
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @typeparam Type The ID type to replace `string` with some opaque type.
+ * @returns A random string.
+ */
+export function nanoid<Type extends string>(size?: number): Type
+
+/**
+ * Generate secure unique ID with custom alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @typeparam Type The ID type to replace `string` with some opaque type.
+ * @returns A random string generator.
+ *
+ * ```js
+ * const { customAlphabet } = require('nanoid')
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * nanoid() //=> "8ё56а"
+ * ```
+ */
+export function customAlphabet<Type extends string>(
+  alphabet: string,
+  defaultSize?: number
+): (size?: number) => Type
+
+/**
+ * Generate unique ID with custom random generator and alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * ```js
+ * import { customRandom } from 'nanoid/format'
+ *
+ * const nanoid = customRandom('abcdef', 5, size => {
+ *   const random = []
+ *   for (let i = 0; i < size; i++) {
+ *     random.push(randomByte())
+ *   }
+ *   return random
+ * })
+ *
+ * nanoid() //=> "fbaef"
+ * ```
+ *
+ * @param alphabet Alphabet used to generate a random string.
+ * @param size Size of the random string.
+ * @param random A random bytes generator.
+ * @typeparam Type The ID type to replace `string` with some opaque type.
+ * @returns A random string generator.
+ */
+export function customRandom<Type extends string>(
+  alphabet: string,
+  size: number,
+  random: (bytes: number) => Uint8Array
+): () => Type
+
+/**
+ * URL safe symbols.
+ *
+ * ```js
+ * import { urlAlphabet } from 'nanoid'
+ * const nanoid = customAlphabet(urlAlphabet, 10)
+ * nanoid() //=> "Uakgb_J5m9"
+ * ```
+ */
+export const urlAlphabet: string
+
+/**
+ * Generate an array of random bytes collected from hardware noise.
+ *
+ * ```js
+ * import { customRandom, random } from 'nanoid'
+ * const nanoid = customRandom("abcdef", 5, random)
+ * ```
+ *
+ * @param bytes Size of the array.
+ * @returns An array of random bytes.
+ */
+export function random(bytes: number): Uint8Array

web/node_modules/@vue/devtools-core/node_modules/nanoid/index.js

@@ -0,0 +1,47 @@
+import { webcrypto as crypto } from 'node:crypto'
+import { urlAlphabet as scopedUrlAlphabet } from './url-alphabet/index.js'
+export { urlAlphabet } from './url-alphabet/index.js'
+const POOL_SIZE_MULTIPLIER = 128
+let pool, poolOffset
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER)
+    crypto.getRandomValues(pool)
+    poolOffset = 0
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.getRandomValues(pool)
+    poolOffset = 0
+  }
+  poolOffset += bytes
+}
+export function random(bytes) {
+  fillPool((bytes |= 0))
+  return pool.subarray(poolOffset - bytes, poolOffset)
+}
+export function customRandom(alphabet, defaultSize, getRandom) {
+  let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+  let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+  return (size = defaultSize) => {
+    if (!size) return ''
+    let id = ''
+    while (true) {
+      let bytes = getRandom(step)
+      let i = step
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length >= size) return id
+      }
+    }
+  }
+}
+export function customAlphabet(alphabet, size = 21) {
+  return customRandom(alphabet, size, random)
+}
+export function nanoid(size = 21) {
+  fillPool((size |= 0))
+  let id = ''
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += scopedUrlAlphabet[pool[i] & 63]
+  }
+  return id
+}

web/node_modules/@vue/devtools-core/node_modules/nanoid/nanoid.js

@@ -0,0 +1 @@
+let a="useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";export let nanoid=(e=21)=>{let t="",r=crypto.getRandomValues(new Uint8Array(e));for(let n=0;n<e;n++)t+=a[63&r[n]];return t};

web/node_modules/@vue/devtools-core/node_modules/nanoid/non-secure/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * By default, Nano ID uses hardware random bytes generation for security
+ * and low collision probability. If you are not so concerned with security,
+ * you can use it for environments without hardware random generators.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid/non-secure'
+ * const id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqLJ"
+ * ```
+ *
+ * @module
+ */
+
+/**
+ * Generate URL-friendly unique ID. This method uses the non-secure
+ * predictable random generator with bigger collision probability.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid/non-secure'
+ * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL"
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @typeparam Type The ID type to replace `string` with some opaque type.
+ * @returns A random string.
+ */
+export function nanoid<Type extends string>(size?: number): Type
+
+/**
+ * Generate a unique ID based on a custom alphabet.
+ * This method uses the non-secure predictable random generator
+ * with bigger collision probability.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @typeparam Type The ID type to replace `string` with some opaque type.
+ * @returns A random string generator.
+ *
+ * ```js
+ * import { customAlphabet } from 'nanoid/non-secure'
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * model.id = nanoid() //=> "8ё56а"
+ * ```
+ */
+export function customAlphabet<Type extends string>(
+  alphabet: string,
+  defaultSize?: number
+): (size?: number) => Type

web/node_modules/@vue/devtools-core/node_modules/nanoid/non-secure/index.js

@@ -0,0 +1,21 @@
+/* @ts-self-types="./index.d.ts" */
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
+export let customAlphabet = (alphabet, defaultSize = 21) => {
+  return (size = defaultSize) => {
+    let id = ''
+    let i = size | 0
+    while (i--) {
+      id += alphabet[(Math.random() * alphabet.length) | 0]
+    }
+    return id
+  }
+}
+export let nanoid = (size = 21) => {
+  let id = ''
+  let i = size | 0
+  while (i--) {
+    id += urlAlphabet[(Math.random() * 64) | 0]
+  }
+  return id
+}

web/node_modules/@vue/devtools-core/node_modules/nanoid/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "nanoid",
+  "version": "5.1.6",
+  "description": "A tiny (118 bytes), secure URL-friendly unique string ID generator",
+  "keywords": [
+    "uuid",
+    "random",
+    "id",
+    "url"
+  ],
+  "type": "module",
+  "engines": {
+    "node": "^18 || >=20"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/ai"
+    }
+  ],
+  "author": "Andrey Sitnik <andrey@sitnik.ru>",
+  "license": "MIT",
+  "repository": "ai/nanoid",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "browser": "./index.browser.js",
+      "react-native": "./index.browser.js",
+      "default": "./index.js"
+    },
+    "./non-secure": "./non-secure/index.js",
+    "./package.json": "./package.json"
+  },
+  "browser": {
+    "./index.js": "./index.browser.js"
+  },
+  "react-native": {
+    "./index.js": "./index.browser.js"
+  },
+  "bin": "./bin/nanoid.js",
+  "sideEffects": false,
+  "types": "./index.d.ts"
+}

web/node_modules/@vue/devtools-core/node_modules/nanoid/url-alphabet/index.js

@@ -0,0 +1,2 @@
+export const urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'

web/node_modules/@vue/devtools-core/node_modules/perfect-debounce/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Pooya Parsa <pooya@pi0.io>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

web/node_modules/@vue/devtools-core/node_modules/perfect-debounce/README.md

@@ -0,0 +1,119 @@
+# perfect-debounce
+
+<!-- automd:badges color=yellow codecov bundlephobia packagephobia  -->
+
+[![npm version](https://img.shields.io/npm/v/perfect-debounce?color=yellow)](https://npmjs.com/package/perfect-debounce)
+[![npm downloads](https://img.shields.io/npm/dm/perfect-debounce?color=yellow)](https://npm.chart.dev/perfect-debounce)
+[![bundle size](https://img.shields.io/bundlephobia/minzip/perfect-debounce?color=yellow)](https://bundlephobia.com/package/perfect-debounce)
+[![install size](https://badgen.net/packagephobia/install/perfect-debounce?color=yellow)](https://packagephobia.com/result?p=perfect-debounce)
+[![codecov](https://img.shields.io/codecov/c/gh/unjs/perfect-debounce?color=yellow)](https://codecov.io/gh/unjs/perfect-debounce)
+
+<!-- /automd -->
+
+Improved debounce function with Promise support.
+
+## Features
+
+- Well tested debounce implementation
+- Native Promise support
+- Avoid duplicate calls while promise is being resolved
+- Configurable `trailing` and `leading` behavior
+- Control methods
+
+## Usage
+
+Install package:
+
+```sh
+npx nypm i perfect-debounce
+```
+
+Import:
+
+```js
+import { debounce } from "perfect-debounce";
+```
+
+Debounce function:
+
+```js
+const debounced = debounce(async () => {
+  // Some heavy stuff
+}, 25);
+```
+
+When calling `debounced`, it will wait at least for `25ms` as configured before actually calling your function. This helps to avoid multiple calls.
+
+### Control Methods
+
+The returned debounced function provides additional control methods:
+
+- `debounced.cancel()`: Cancel any pending invocation that has not yet occurred.
+- `await debounced.flush()`: Immediately invoke the pending function call (if any) and return its result.
+- `debounced.isPending()`: Returns `true` if there is a pending invocation waiting to be called, otherwise `false`.
+
+```js
+debounced.cancel(); // Cancel any pending call
+await debounced.flush(); // Immediately invoke pending call (if any)
+debounced.isPending(); // Returns true if a call is pending
+```
+
+### Example
+
+```js
+const debounced = debounce(async (value) => {
+  // Some async work
+  return value * 2;
+}, 100);
+
+debounced(1);
+debounced(2);
+debounced(3);
+
+// Check if a call is pending
+console.log(debounced.isPending()); // true
+
+// Immediately invoke the pending call
+const result = await debounced.flush();
+console.log(result); // 6
+
+// Cancel any further pending calls
+debounced.cancel();
+```
+
+To avoid initial wait, we can set `leading: true` option. It will cause function to be immediately called if there is no other call:
+
+```js
+const debounced = debounce(
+  async () => {
+    // Some heavy stuff
+  },
+  25,
+  { leading: true },
+);
+```
+
+If executing async function takes longer than debounce value, duplicate calls will be still prevented a last call will happen. To disable this behavior, we can set `trailing: false` option:
+
+```js
+const debounced = debounce(
+  async () => {
+    // Some heavy stuff
+  },
+  25,
+  { trailing: false },
+);
+```
+
+## 💻 Development
+
+- Clone this repository
+- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable` (use `npm i -g corepack` for Node.js < 16.10)
+- Install dependencies using `pnpm install`
+- Run interactive tests using `pnpm dev`
+
+## License
+
+Based on [sindresorhus/p-debounce](https://github.com/sindresorhus/p-debounce).
+
+Made with 💛 Published under [MIT License](./LICENSE).

web/node_modules/@vue/devtools-core/node_modules/perfect-debounce/dist/index.d.mts

@@ -0,0 +1,49 @@
+//#region src/index.d.ts
+interface DebounceOptions {
+  /**
+  Call the `fn` on the [leading edge of the timeout](https://css-tricks.com/debouncing-throttling-explained-examples/#article-header-id-1).
+  Meaning immediately, instead of waiting for `wait` milliseconds.
+  @default false
+  */
+  readonly leading?: boolean;
+  /**
+  Call the `fn` on trailing edge with last used arguments. Result of call is from previous call.
+  @default true
+  */
+  readonly trailing?: boolean;
+}
+type DebouncedReturn<ArgumentsT extends unknown[], ReturnT> = ((...args: ArgumentsT) => Promise<ReturnT>) & {
+  /**
+   * Cancel pending function call
+   */
+  cancel: () => void;
+  /**
+   * Immediately invoke pending function call
+   */
+  flush: () => Promise<ReturnT> | undefined;
+  /**
+   * Get pending function call
+   */
+  isPending: () => boolean;
+};
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+  console.log(await debouncedFn(number));
+}
+//=> 1
+//=> 2
+//=> 3
+```
+*/
+declare function debounce<ArgumentsT extends unknown[], ReturnT>(fn: (...args: ArgumentsT) => PromiseLike<ReturnT> | ReturnT, wait?: number, options?: DebounceOptions): DebouncedReturn<ArgumentsT, ReturnT>;
+//#endregion
+export { DebounceOptions, debounce };

web/node_modules/@vue/devtools-core/node_modules/perfect-debounce/dist/index.mjs

@@ -0,0 +1,89 @@
+//#region src/index.ts
+const DEBOUNCE_DEFAULTS = { trailing: true };
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+console.log(await debouncedFn(number));
+}
+//=> 1
+//=> 2
+//=> 3
+```
+*/
+function debounce(fn, wait = 25, options = {}) {
+	options = {
+		...DEBOUNCE_DEFAULTS,
+		...options
+	};
+	if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
+	let leadingValue;
+	let timeout;
+	let resolveList = [];
+	let currentPromise;
+	let trailingArgs;
+	const applyFn = (_this, args) => {
+		currentPromise = _applyPromised(fn, _this, args);
+		currentPromise.finally(() => {
+			currentPromise = null;
+			if (options.trailing && trailingArgs && !timeout) {
+				const promise = applyFn(_this, trailingArgs);
+				trailingArgs = null;
+				return promise;
+			}
+		});
+		return currentPromise;
+	};
+	const debounced = function(...args) {
+		if (options.trailing) trailingArgs = args;
+		if (currentPromise) return currentPromise;
+		return new Promise((resolve) => {
+			const shouldCallNow = !timeout && options.leading;
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				timeout = null;
+				const promise = options.leading ? leadingValue : applyFn(this, args);
+				trailingArgs = null;
+				for (const _resolve of resolveList) _resolve(promise);
+				resolveList = [];
+			}, wait);
+			if (shouldCallNow) {
+				leadingValue = applyFn(this, args);
+				resolve(leadingValue);
+			} else resolveList.push(resolve);
+		});
+	};
+	const _clearTimeout = (timer) => {
+		if (timer) {
+			clearTimeout(timer);
+			timeout = null;
+		}
+	};
+	debounced.isPending = () => !!timeout;
+	debounced.cancel = () => {
+		_clearTimeout(timeout);
+		resolveList = [];
+		trailingArgs = null;
+	};
+	debounced.flush = () => {
+		_clearTimeout(timeout);
+		if (!trailingArgs || currentPromise) return;
+		const args = trailingArgs;
+		trailingArgs = null;
+		return applyFn(this, args);
+	};
+	return debounced;
+}
+async function _applyPromised(fn, _this, args) {
+	return await fn.apply(_this, args);
+}
+
+//#endregion
+export { debounce };

web/node_modules/@vue/devtools-core/node_modules/perfect-debounce/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "perfect-debounce",
+  "version": "2.0.0",
+  "description": "",
+  "repository": "unjs/perfect-debounce",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "obuild",
+    "dev": "vitest dev",
+    "lint": "eslint . && prettier --check src test",
+    "lint:fix": "eslint . --fix && prettier -w src test",
+    "release": "pnpm test && pnpm build && changelogen --release --push && npm publish",
+    "test": "vitest run --coverage"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "automd": "^0.4.0",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.34.0",
+    "eslint-config-unjs": "^0.5.0",
+    "in-range": "^3.0.0",
+    "obuild": "^0.2.1",
+    "prettier": "^3.6.2",
+    "time-span": "^5.1.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "packageManager": "pnpm@10.15.0"
+}

web/node_modules/@vue/devtools-core/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@vue/devtools-core",
+  "type": "module",
+  "version": "8.0.5",
+  "author": "webfansplz",
+  "license": "MIT",
+  "repository": {
+    "directory": "packages/core",
+    "type": "git",
+    "url": "git+https://github.com/vuejs/devtools.git"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "files": [
+    "dist",
+    "server.d.ts"
+  ],
+  "peerDependencies": {
+    "vue": "^3.0.0"
+  },
+  "dependencies": {
+    "mitt": "^3.0.1",
+    "nanoid": "^5.1.5",
+    "pathe": "^2.0.3",
+    "vite-hot-client": "^2.1.0",
+    "@vue/devtools-kit": "^8.0.5",
+    "@vue/devtools-shared": "^8.0.5"
+  },
+  "devDependencies": {
+    "vue": "^3.5.22"
+  },
+  "scripts": {
+    "build": "tsdown --clean",
+    "prepare:type": "tsdown --dts-only",
+    "stub": "tsdown --watch --onSuccess 'tsdown --dts-only'"
+  }
+}