Criada a API do site

node_modules/@vue/babel-helper-vue-transform-on/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-present vuejs
+
+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.

node_modules/@vue/babel-helper-vue-transform-on/README.md

@@ -0,0 +1,5 @@
+# @vue/babel-helper-vue-transform-on
+
+A package used internally by vue jsx transformer to transform events.
+
+on: { click: xx } --> onClick: xx

node_modules/@vue/babel-helper-vue-transform-on/index.d.ts

@@ -0,0 +1,4 @@
+declare function transformOn(
+  obj: Record<string, any>
+): Record<`on${string}`, any>;
+export = transformOn;

node_modules/@vue/babel-helper-vue-transform-on/index.js

@@ -0,0 +1,9 @@
+const transformOn = (obj) => {
+  const result = {};
+  Object.keys(obj).forEach((evt) => {
+    result[`on${evt[0].toUpperCase()}${evt.slice(1)}`] = obj[evt];
+  });
+  return result;
+};
+
+module.exports = transformOn;

node_modules/@vue/babel-helper-vue-transform-on/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@vue/babel-helper-vue-transform-on",
+  "version": "1.5.0",
+  "type": "commonjs",
+  "description": "to help transform on",
+  "author": "Amour1688 <lcz_1996@foxmail.com>",
+  "license": "MIT",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/babel-plugin-jsx.git"
+  }
+}

node_modules/@vue/babel-plugin-jsx/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-present vuejs
+
+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.

node_modules/@vue/babel-plugin-jsx/README.md

@@ -0,0 +1,390 @@
+# Babel Plugin JSX for Vue 3
+
+[![npm package](https://img.shields.io/npm/v/@vue/babel-plugin-jsx.svg?style=flat-square)](https://www.npmjs.com/package/@vue/babel-plugin-jsx)
+[![issues-helper](https://img.shields.io/badge/Issues%20Manage%20By-issues--helper-blueviolet?style=flat-square)](https://github.com/actions-cool/issues-helper)
+
+To add Vue JSX support.
+
+English | [简体中文](/packages/babel-plugin-jsx/README-zh_CN.md)
+
+## Installation
+
+Install the plugin with:
+
+```bash
+npm install @vue/babel-plugin-jsx -D
+```
+
+Then add the plugin to your babel config:
+
+```json
+{
+  "plugins": ["@vue/babel-plugin-jsx"]
+}
+```
+
+## Usage
+
+### options
+
+#### transformOn
+
+Type: `boolean`
+
+Default: `false`
+
+transform `on: { click: xx }` to `onClick: xxx`
+
+#### optimize
+
+Type: `boolean`
+
+Default: `false`
+
+When enabled, this plugin generates optimized runtime code using [`PatchFlags`](https://vuejs.org/guide/extras/rendering-mechanism#patch-flags) and [`SlotFlags`](https://github.com/vuejs/core/blob/v3.5.13/packages/runtime-core/src/componentSlots.ts#L69-L77) to improve rendering performance. However, due to JSX's dynamic nature, the optimizations are not as comprehensive as those in Vue's official template compiler.
+
+Since the optimized code may skip certain re-renders to improve performance, we strongly recommend thorough testing of your application after enabling this option to ensure everything works as expected.
+
+#### isCustomElement
+
+Type: `(tag: string) => boolean`
+
+Default: `undefined`
+
+configuring custom elements
+
+#### mergeProps
+
+Type: `boolean`
+
+Default: `true`
+
+merge static and dynamic class / style attributes / onXXX handlers
+
+#### enableObjectSlots
+
+Type: `boolean`
+
+Default: `true`
+
+Whether to enable `object slots` (mentioned below the document) syntax". It might be useful in JSX, but it will add a lot of `_isSlot` condition expressions which increase your bundle size. And `v-slots` is still available even if `enableObjectSlots` is turned off.
+
+#### pragma
+
+Type: `string`
+
+Default: `createVNode`
+
+Replace the function used when compiling JSX expressions.
+
+#### resolveType
+
+Type: `boolean`
+
+Default: `false`
+
+(**Experimental**) Infer component metadata from types (e.g. `props`, `emits`, `name`). This is an experimental feature and may not work in all cases.
+
+## Syntax
+
+### Content
+
+functional component
+
+```jsx
+const App = () => <div>Vue 3.0</div>;
+```
+
+with render
+
+```jsx
+const App = {
+  render() {
+    return <div>Vue 3.0</div>;
+  },
+};
+```
+
+```jsx
+import { withModifiers, defineComponent } from 'vue';
+
+const App = defineComponent({
+  setup() {
+    const count = ref(0);
+
+    const inc = () => {
+      count.value++;
+    };
+
+    return () => (
+      <div onClick={withModifiers(inc, ['self'])}>{count.value}</div>
+    );
+  },
+});
+```
+
+Fragment
+
+```jsx
+const App = () => (
+  <>
+    <span>I'm</span>
+    <span>Fragment</span>
+  </>
+);
+```
+
+### Attributes / Props
+
+```jsx
+const App = () => <input type="email" />;
+```
+
+with a dynamic binding:
+
+```jsx
+const placeholderText = 'email';
+const App = () => <input type="email" placeholder={placeholderText} />;
+```
+
+### Directives
+
+#### v-show
+
+```jsx
+const App = {
+  data() {
+    return { visible: true };
+  },
+  render() {
+    return <input v-show={this.visible} />;
+  },
+};
+```
+
+#### v-model
+
+> Note: You should pass the second param as string for using `arg`.
+
+```jsx
+<input v-model={val} />
+```
+
+```jsx
+<input v-model:argument={val} />
+```
+
+```jsx
+<input v-model={[val, ['modifier']]} />
+// Or
+<input v-model_modifier={val} />
+```
+
+```jsx
+<A v-model={[val, 'argument', ['modifier']]} />
+// Or
+<input v-model:argument_modifier={val} />
+```
+
+Will compile to:
+
+```js
+h(A, {
+  argument: val,
+  argumentModifiers: {
+    modifier: true,
+  },
+  'onUpdate:argument': ($event) => (val = $event),
+});
+```
+
+#### v-models (Not recommended since v1.1.0)
+
+> Note: You should pass a Two-dimensional Arrays to v-models.
+
+```jsx
+<A v-models={[[foo], [bar, 'bar']]} />
+```
+
+```jsx
+<A
+  v-models={[
+    [foo, 'foo'],
+    [bar, 'bar'],
+  ]}
+/>
+```
+
+```jsx
+<A
+  v-models={[
+    [foo, ['modifier']],
+    [bar, 'bar', ['modifier']],
+  ]}
+/>
+```
+
+Will compile to:
+
+```js
+h(A, {
+  modelValue: foo,
+  modelModifiers: {
+    modifier: true,
+  },
+  'onUpdate:modelValue': ($event) => (foo = $event),
+  bar: bar,
+  barModifiers: {
+    modifier: true,
+  },
+  'onUpdate:bar': ($event) => (bar = $event),
+});
+```
+
+#### custom directive
+
+Recommended when using string arguments
+
+```jsx
+const App = {
+  directives: { custom: customDirective },
+  setup() {
+    return () => <a v-custom:arg={val} />;
+  },
+};
+```
+
+```jsx
+const App = {
+  directives: { custom: customDirective },
+  setup() {
+    return () => <a v-custom={[val, 'arg', ['a', 'b']]} />;
+  },
+};
+```
+
+### Slot
+
+> Note: In `jsx`, _`v-slot`_ should be replaced with **`v-slots`**
+
+```jsx
+const A = (props, { slots }) => (
+  <>
+    <h1>{slots.default ? slots.default() : 'foo'}</h1>
+    <h2>{slots.bar?.()}</h2>
+  </>
+);
+
+const App = {
+  setup() {
+    const slots = {
+      bar: () => <span>B</span>,
+    };
+    return () => (
+      <A v-slots={slots}>
+        <div>A</div>
+      </A>
+    );
+  },
+};
+
+// or
+
+const App = {
+  setup() {
+    const slots = {
+      default: () => <div>A</div>,
+      bar: () => <span>B</span>,
+    };
+    return () => <A v-slots={slots} />;
+  },
+};
+
+// or you can use object slots when `enableObjectSlots` is not false.
+const App = {
+  setup() {
+    return () => (
+      <>
+        <A>
+          {{
+            default: () => <div>A</div>,
+            bar: () => <span>B</span>,
+          }}
+        </A>
+        <B>{() => 'foo'}</B>
+      </>
+    );
+  },
+};
+```
+
+### In TypeScript
+
+`tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "jsx": "preserve"
+  }
+}
+```
+
+## Who is using
+
+<table>
+  <tbody>
+    <tr>
+      <td align="center">
+        <a target="_blank" href="https://www.antdv.com/">
+          <img
+            width="32"
+            src="https://github.com/vuejs/babel-plugin-jsx/assets/6481596/8d604d42-fe5f-4450-af87-97999537cd21"
+          />
+          <br>
+          <strong>Ant Design Vue</strong>
+        </a>
+      </td>
+      <td align="center">
+        <a target="_blank" href="https://youzan.github.io/vant/#/zh-CN/">
+          <img
+            width="32"
+            style="vertical-align: -0.32em; margin-right: 8px;"
+            src="https://img.yzcdn.cn/vant/logo.png"
+          />
+          <br>
+          <strong>Vant</strong>
+        </a>
+      </td>
+      <td align="center">
+        <a target="_blank" href="https://github.com/element-plus/element-plus">
+          <img
+            height="32"
+            style="vertical-align: -0.32em; margin-right: 8px;"
+            src="https://user-images.githubusercontent.com/10731096/91267529-259f3680-e7a6-11ea-9a60-3286f750de01.png"
+          />
+          <br>
+          <strong>Element Plus</strong>
+        </a>
+      </td>
+      <td align="center">
+        <a target="_blank" href="https://github.com/leezng/vue-json-pretty">
+          <img
+            height="32"
+            style="vertical-align: -0.32em; margin-right: 8px;"
+            src="https://raw.githubusercontent.com/leezng/vue-json-pretty/master/static/logo.svg"
+          />
+          <br>
+          <strong>Vue Json Pretty</strong>
+        </a>
+      </td>
+    </tr>
+  </tbody>
+</table>
+
+## Compatibility
+
+This repo is only compatible with:
+
+- **Babel 7+**
+- **Vue 3+**

node_modules/@vue/babel-plugin-jsx/dist/index.d.mts

@@ -0,0 +1,35 @@
+import "@babel/types";
+import { Options } from "@vue/babel-plugin-resolve-type";
+import * as BabelCore from "@babel/core";
+
+//#region src/interface.d.ts
+type State = {
+  get: (name: string) => any;
+  set: (name: string, value: any) => any;
+  opts: VueJSXPluginOptions;
+  file: BabelCore.BabelFile;
+};
+interface VueJSXPluginOptions {
+  /** transform `on: { click: xx }` to `onClick: xxx` */
+  transformOn?: boolean;
+  /** enable optimization or not. */
+  optimize?: boolean;
+  /** merge static and dynamic class / style attributes / onXXX handlers */
+  mergeProps?: boolean;
+  /** configuring custom elements */
+  isCustomElement?: (tag: string) => boolean;
+  /** enable object slots syntax */
+  enableObjectSlots?: boolean;
+  /** Replace the function used when compiling JSX expressions */
+  pragma?: string;
+  /**
+  * (**Experimental**) Infer component metadata from types (e.g. `props`, `emits`, `name`)
+  * @default false
+  */
+  resolveType?: Options | boolean;
+}
+//#endregion
+//#region src/index.d.ts
+declare const plugin: (api: object, options: VueJSXPluginOptions | null | undefined, dirname: string) => BabelCore.PluginObj<State>;
+//#endregion
+export { VueJSXPluginOptions, plugin as default };

node_modules/@vue/babel-plugin-jsx/dist/index.d.ts

@@ -0,0 +1,34 @@
+import * as BabelCore from "@babel/core";
+import { Options } from "@vue/babel-plugin-resolve-type";
+
+//#region src/interface.d.ts
+type State = {
+  get: (name: string) => any;
+  set: (name: string, value: any) => any;
+  opts: VueJSXPluginOptions;
+  file: BabelCore.BabelFile;
+};
+interface VueJSXPluginOptions {
+  /** transform `on: { click: xx }` to `onClick: xxx` */
+  transformOn?: boolean;
+  /** enable optimization or not. */
+  optimize?: boolean;
+  /** merge static and dynamic class / style attributes / onXXX handlers */
+  mergeProps?: boolean;
+  /** configuring custom elements */
+  isCustomElement?: (tag: string) => boolean;
+  /** enable object slots syntax */
+  enableObjectSlots?: boolean;
+  /** Replace the function used when compiling JSX expressions */
+  pragma?: string;
+  /**
+  * (**Experimental**) Infer component metadata from types (e.g. `props`, `emits`, `name`)
+  * @default false
+  */
+  resolveType?: Options | boolean;
+}
+//#endregion
+//#region src/index.d.ts
+declare const plugin: (api: object, options: VueJSXPluginOptions | null | undefined, dirname: string) => BabelCore.PluginObj<State>;
+//#endregion
+export { VueJSXPluginOptions, plugin as default };

node_modules/@vue/babel-plugin-jsx/dist/index.js

@@ -0,0 +1,818 @@
+//#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) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __babel_types = __toESM(require("@babel/types"));
+const __babel_template = __toESM(require("@babel/template"));
+const __babel_plugin_syntax_jsx = __toESM(require("@babel/plugin-syntax-jsx"));
+const __babel_helper_module_imports = __toESM(require("@babel/helper-module-imports"));
+const __vue_babel_plugin_resolve_type = __toESM(require("@vue/babel-plugin-resolve-type"));
+const __babel_helper_plugin_utils = __toESM(require("@babel/helper-plugin-utils"));
+const __vue_shared = __toESM(require("@vue/shared"));
+
+//#region src/slotFlags.ts
+var SlotFlags = /* @__PURE__ */ function(SlotFlags$1) {
+	/**
+	* Stable slots that only reference slot props or context state. The slot
+	* can fully capture its own dependencies so when passed down the parent won't
+	* need to force the child to update.
+	*/
+	SlotFlags$1[SlotFlags$1["STABLE"] = 1] = "STABLE";
+	/**
+	* Slots that reference scope variables (v-for or an outer slot prop), or
+	* has conditional structure (v-if, v-for). The parent will need to force
+	* the child to update because the slot does not fully capture its dependencies.
+	*/
+	SlotFlags$1[SlotFlags$1["DYNAMIC"] = 2] = "DYNAMIC";
+	/**
+	* `<slot/>` being forwarded into a child component. Whether the parent needs
+	* to update the child is dependent on what kind of slots the parent itself
+	* received. This has to be refined at runtime, when the child's vnode
+	* is being created (in `normalizeChildren`)
+	*/
+	SlotFlags$1[SlotFlags$1["FORWARDED"] = 3] = "FORWARDED";
+	return SlotFlags$1;
+}(SlotFlags || {});
+var slotFlags_default = SlotFlags;
+
+//#endregion
+//#region src/utils.ts
+const FRAGMENT = "Fragment";
+const KEEP_ALIVE = "KeepAlive";
+/**
+* create Identifier
+* @param path NodePath
+* @param state
+* @param name string
+* @returns MemberExpression
+*/
+const createIdentifier = (state, name) => state.get(name)();
+/**
+* Checks if string is describing a directive
+* @param src string
+*/
+const isDirective = (src) => src.startsWith("v-") || src.startsWith("v") && src.length >= 2 && src[1] >= "A" && src[1] <= "Z";
+/**
+* Should transformed to slots
+* @param tag string
+* @returns boolean
+*/
+const shouldTransformedToSlots = (tag) => !(tag.match(RegExp(`^_?${FRAGMENT}\\d*$`)) || tag === KEEP_ALIVE);
+/**
+* Check if a Node is a component
+*
+* @param t
+* @param path JSXOpeningElement
+* @returns boolean
+*/
+const checkIsComponent = (path, state) => {
+	var _state$opts$isCustomE, _state$opts;
+	const namePath = path.get("name");
+	if (namePath.isJSXMemberExpression()) return shouldTransformedToSlots(namePath.node.property.name);
+	const tag = namePath.node.name;
+	return !((_state$opts$isCustomE = (_state$opts = state.opts).isCustomElement) === null || _state$opts$isCustomE === void 0 ? void 0 : _state$opts$isCustomE.call(_state$opts, tag)) && shouldTransformedToSlots(tag) && !(0, __vue_shared.isHTMLTag)(tag) && !(0, __vue_shared.isSVGTag)(tag);
+};
+/**
+* Transform JSXMemberExpression to MemberExpression
+* @param path JSXMemberExpression
+* @returns MemberExpression
+*/
+const transformJSXMemberExpression = (path) => {
+	const objectPath = path.node.object;
+	const propertyPath = path.node.property;
+	const transformedObject = __babel_types.isJSXMemberExpression(objectPath) ? transformJSXMemberExpression(path.get("object")) : __babel_types.isJSXIdentifier(objectPath) ? __babel_types.identifier(objectPath.name) : __babel_types.nullLiteral();
+	const transformedProperty = __babel_types.identifier(propertyPath.name);
+	return __babel_types.memberExpression(transformedObject, transformedProperty);
+};
+/**
+* Get tag (first attribute for h) from JSXOpeningElement
+* @param path JSXElement
+* @param state State
+* @returns Identifier | StringLiteral | MemberExpression | CallExpression
+*/
+const getTag = (path, state) => {
+	const namePath = path.get("openingElement").get("name");
+	if (namePath.isJSXIdentifier()) {
+		const { name } = namePath.node;
+		if (!(0, __vue_shared.isHTMLTag)(name) && !(0, __vue_shared.isSVGTag)(name)) {
+			var _state$opts$isCustomE2, _state$opts2;
+			return name === FRAGMENT ? createIdentifier(state, FRAGMENT) : path.scope.hasBinding(name) ? __babel_types.identifier(name) : ((_state$opts$isCustomE2 = (_state$opts2 = state.opts).isCustomElement) === null || _state$opts$isCustomE2 === void 0 ? void 0 : _state$opts$isCustomE2.call(_state$opts2, name)) ? __babel_types.stringLiteral(name) : __babel_types.callExpression(createIdentifier(state, "resolveComponent"), [__babel_types.stringLiteral(name)]);
+		}
+		return __babel_types.stringLiteral(name);
+	}
+	if (namePath.isJSXMemberExpression()) return transformJSXMemberExpression(namePath);
+	throw new Error(`getTag: ${namePath.type} is not supported`);
+};
+const getJSXAttributeName = (path) => {
+	const nameNode = path.node.name;
+	if (__babel_types.isJSXIdentifier(nameNode)) return nameNode.name;
+	return `${nameNode.namespace.name}:${nameNode.name.name}`;
+};
+/**
+* Transform JSXText to StringLiteral
+* @param path JSXText
+* @returns StringLiteral | null
+*/
+const transformJSXText = (path) => {
+	const str = transformText(path.node.value);
+	return str !== "" ? __babel_types.stringLiteral(str) : null;
+};
+const transformText = (text) => {
+	const lines = text.split(/\r\n|\n|\r/);
+	let lastNonEmptyLine = 0;
+	for (let i = 0; i < lines.length; i++) if (lines[i].match(/[^ \t]/)) lastNonEmptyLine = i;
+	let str = "";
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const isFirstLine = i === 0;
+		const isLastLine = i === lines.length - 1;
+		const isLastNonEmptyLine = i === lastNonEmptyLine;
+		let trimmedLine = line.replace(/\t/g, " ");
+		if (!isFirstLine) trimmedLine = trimmedLine.replace(/^[ ]+/, "");
+		if (!isLastLine) trimmedLine = trimmedLine.replace(/[ ]+$/, "");
+		if (trimmedLine) {
+			if (!isLastNonEmptyLine) trimmedLine += " ";
+			str += trimmedLine;
+		}
+	}
+	return str;
+};
+/**
+* Transform JSXExpressionContainer to Expression
+* @param path JSXExpressionContainer
+* @returns Expression
+*/
+const transformJSXExpressionContainer = (path) => path.get("expression").node;
+/**
+* Transform JSXSpreadChild
+* @param path JSXSpreadChild
+* @returns SpreadElement
+*/
+const transformJSXSpreadChild = (path) => __babel_types.spreadElement(path.get("expression").node);
+const walksScope = (path, name, slotFlag) => {
+	if (path.scope.hasBinding(name) && path.parentPath) {
+		if (__babel_types.isJSXElement(path.parentPath.node)) path.parentPath.setData("slotFlag", slotFlag);
+		walksScope(path.parentPath, name, slotFlag);
+	}
+};
+const buildIIFE = (path, children) => {
+	const { parentPath } = path;
+	if (parentPath.isAssignmentExpression()) {
+		const { left } = parentPath.node;
+		if (__babel_types.isIdentifier(left)) return children.map((child) => {
+			if (__babel_types.isIdentifier(child) && child.name === left.name) {
+				const insertName = path.scope.generateUidIdentifier(child.name);
+				parentPath.insertBefore(__babel_types.variableDeclaration("const", [__babel_types.variableDeclarator(insertName, __babel_types.callExpression(__babel_types.functionExpression(null, [], __babel_types.blockStatement([__babel_types.returnStatement(child)])), []))]));
+				return insertName;
+			}
+			return child;
+		});
+	}
+	return children;
+};
+const onRE = /^on[^a-z]/;
+const isOn = (key) => onRE.test(key);
+const mergeAsArray = (existing, incoming) => {
+	if (__babel_types.isArrayExpression(existing.value)) existing.value.elements.push(incoming.value);
+	else existing.value = __babel_types.arrayExpression([existing.value, incoming.value]);
+};
+const dedupeProperties = (properties = [], mergeProps) => {
+	if (!mergeProps) return properties;
+	const knownProps = /* @__PURE__ */ new Map();
+	const deduped = [];
+	properties.forEach((prop) => {
+		if (__babel_types.isStringLiteral(prop.key)) {
+			const { value: name } = prop.key;
+			const existing = knownProps.get(name);
+			if (existing) {
+				if (name === "style" || name === "class" || name.startsWith("on")) mergeAsArray(existing, prop);
+			} else {
+				knownProps.set(name, prop);
+				deduped.push(prop);
+			}
+		} else deduped.push(prop);
+	});
+	return deduped;
+};
+/**
+*  Check if an attribute value is constant
+* @param node
+* @returns boolean
+*/
+const isConstant = (node) => {
+	if (__babel_types.isIdentifier(node)) return node.name === "undefined";
+	if (__babel_types.isArrayExpression(node)) {
+		const { elements } = node;
+		return elements.every((element) => element && isConstant(element));
+	}
+	if (__babel_types.isObjectExpression(node)) return node.properties.every((property) => isConstant(property.value));
+	if (__babel_types.isTemplateLiteral(node) ? !node.expressions.length : __babel_types.isLiteral(node)) return true;
+	return false;
+};
+const transformJSXSpreadAttribute = (nodePath, path, mergeProps, args) => {
+	const argument = path.get("argument");
+	const properties = __babel_types.isObjectExpression(argument.node) ? argument.node.properties : void 0;
+	if (!properties) {
+		if (argument.isIdentifier()) walksScope(nodePath, argument.node.name, slotFlags_default.DYNAMIC);
+		args.push(mergeProps ? argument.node : __babel_types.spreadElement(argument.node));
+	} else if (mergeProps) args.push(__babel_types.objectExpression(properties));
+	else args.push(...properties);
+};
+
+//#endregion
+//#region src/patchFlags.ts
+let PatchFlags = /* @__PURE__ */ function(PatchFlags$1) {
+	PatchFlags$1[PatchFlags$1["TEXT"] = 1] = "TEXT";
+	PatchFlags$1[PatchFlags$1["CLASS"] = 2] = "CLASS";
+	PatchFlags$1[PatchFlags$1["STYLE"] = 4] = "STYLE";
+	PatchFlags$1[PatchFlags$1["PROPS"] = 8] = "PROPS";
+	PatchFlags$1[PatchFlags$1["FULL_PROPS"] = 16] = "FULL_PROPS";
+	PatchFlags$1[PatchFlags$1["HYDRATE_EVENTS"] = 32] = "HYDRATE_EVENTS";
+	PatchFlags$1[PatchFlags$1["STABLE_FRAGMENT"] = 64] = "STABLE_FRAGMENT";
+	PatchFlags$1[PatchFlags$1["KEYED_FRAGMENT"] = 128] = "KEYED_FRAGMENT";
+	PatchFlags$1[PatchFlags$1["UNKEYED_FRAGMENT"] = 256] = "UNKEYED_FRAGMENT";
+	PatchFlags$1[PatchFlags$1["NEED_PATCH"] = 512] = "NEED_PATCH";
+	PatchFlags$1[PatchFlags$1["DYNAMIC_SLOTS"] = 1024] = "DYNAMIC_SLOTS";
+	PatchFlags$1[PatchFlags$1["HOISTED"] = -1] = "HOISTED";
+	PatchFlags$1[PatchFlags$1["BAIL"] = -2] = "BAIL";
+	return PatchFlags$1;
+}({});
+const PatchFlagNames = {
+	[PatchFlags.TEXT]: "TEXT",
+	[PatchFlags.CLASS]: "CLASS",
+	[PatchFlags.STYLE]: "STYLE",
+	[PatchFlags.PROPS]: "PROPS",
+	[PatchFlags.FULL_PROPS]: "FULL_PROPS",
+	[PatchFlags.HYDRATE_EVENTS]: "HYDRATE_EVENTS",
+	[PatchFlags.STABLE_FRAGMENT]: "STABLE_FRAGMENT",
+	[PatchFlags.KEYED_FRAGMENT]: "KEYED_FRAGMENT",
+	[PatchFlags.UNKEYED_FRAGMENT]: "UNKEYED_FRAGMENT",
+	[PatchFlags.DYNAMIC_SLOTS]: "DYNAMIC_SLOTS",
+	[PatchFlags.NEED_PATCH]: "NEED_PATCH",
+	[PatchFlags.HOISTED]: "HOISTED",
+	[PatchFlags.BAIL]: "BAIL"
+};
+
+//#endregion
+//#region src/parseDirectives.ts
+/**
+* Get JSX element type
+*
+* @param path Path<JSXOpeningElement>
+*/
+const getType = (path) => {
+	const typePath = path.get("attributes").find((attribute) => {
+		if (!attribute.isJSXAttribute()) return false;
+		return attribute.get("name").isJSXIdentifier() && attribute.get("name").node.name === "type";
+	});
+	return typePath ? typePath.get("value").node : null;
+};
+const parseModifiers = (value) => __babel_types.isArrayExpression(value) ? value.elements.map((el) => __babel_types.isStringLiteral(el) ? el.value : "").filter(Boolean) : [];
+const parseDirectives = (params) => {
+	var _modifiersSet$, _modifiersSet$2;
+	const { path, value, state, tag, isComponent } = params;
+	const args = [];
+	const vals = [];
+	const modifiersSet = [];
+	let directiveName;
+	let directiveArgument;
+	let directiveModifiers;
+	if ("namespace" in path.node.name) {
+		[directiveName, directiveArgument] = params.name.split(":");
+		directiveName = path.node.name.namespace.name;
+		directiveArgument = path.node.name.name.name;
+		directiveModifiers = directiveArgument.split("_").slice(1);
+	} else {
+		const underscoreModifiers = params.name.split("_");
+		directiveName = underscoreModifiers.shift() || "";
+		directiveModifiers = underscoreModifiers;
+	}
+	directiveName = directiveName.replace(/^v/, "").replace(/^-/, "").replace(/^\S/, (s) => s.toLowerCase());
+	if (directiveArgument) args.push(__babel_types.stringLiteral(directiveArgument.split("_")[0]));
+	const isVModels = directiveName === "models";
+	const isVModel = directiveName === "model";
+	if (isVModel && !path.get("value").isJSXExpressionContainer()) throw new Error("You have to use JSX Expression inside your v-model");
+	if (isVModels && !isComponent) throw new Error("v-models can only use in custom components");
+	const shouldResolve = ![
+		"html",
+		"text",
+		"model",
+		"slots",
+		"models"
+	].includes(directiveName) || isVModel && !isComponent;
+	let modifiers = directiveModifiers;
+	if (__babel_types.isArrayExpression(value)) {
+		const elementsList = isVModels ? value.elements : [value];
+		elementsList.forEach((element) => {
+			if (isVModels && !__babel_types.isArrayExpression(element)) throw new Error("You should pass a Two-dimensional Arrays to v-models");
+			const { elements } = element;
+			const [first, second, third] = elements;
+			if (second && !__babel_types.isArrayExpression(second) && !__babel_types.isSpreadElement(second)) {
+				args.push(second);
+				modifiers = parseModifiers(third);
+			} else if (__babel_types.isArrayExpression(second)) {
+				if (!shouldResolve) args.push(__babel_types.nullLiteral());
+				modifiers = parseModifiers(second);
+			} else if (!shouldResolve) args.push(__babel_types.nullLiteral());
+			modifiersSet.push(new Set(modifiers));
+			vals.push(first);
+		});
+	} else if (isVModel && !shouldResolve) {
+		args.push(__babel_types.nullLiteral());
+		modifiersSet.push(new Set(directiveModifiers));
+	} else modifiersSet.push(new Set(directiveModifiers));
+	return {
+		directiveName,
+		modifiers: modifiersSet,
+		values: vals.length ? vals : [value],
+		args,
+		directive: shouldResolve ? [
+			resolveDirective(path, state, tag, directiveName),
+			vals[0] || value,
+			((_modifiersSet$ = modifiersSet[0]) === null || _modifiersSet$ === void 0 ? void 0 : _modifiersSet$.size) ? args[0] || __babel_types.unaryExpression("void", __babel_types.numericLiteral(0), true) : args[0],
+			!!((_modifiersSet$2 = modifiersSet[0]) === null || _modifiersSet$2 === void 0 ? void 0 : _modifiersSet$2.size) && __babel_types.objectExpression([...modifiersSet[0]].map((modifier) => __babel_types.objectProperty(__babel_types.identifier(modifier), __babel_types.booleanLiteral(true))))
+		].filter(Boolean) : void 0
+	};
+};
+const resolveDirective = (path, state, tag, directiveName) => {
+	if (directiveName === "show") return createIdentifier(state, "vShow");
+	if (directiveName === "model") {
+		let modelToUse;
+		const type = getType(path.parentPath);
+		switch (tag.value) {
+			case "select":
+				modelToUse = createIdentifier(state, "vModelSelect");
+				break;
+			case "textarea":
+				modelToUse = createIdentifier(state, "vModelText");
+				break;
+			default: if (__babel_types.isStringLiteral(type) || !type) switch (type === null || type === void 0 ? void 0 : type.value) {
+				case "checkbox":
+					modelToUse = createIdentifier(state, "vModelCheckbox");
+					break;
+				case "radio":
+					modelToUse = createIdentifier(state, "vModelRadio");
+					break;
+				default: modelToUse = createIdentifier(state, "vModelText");
+			}
+			else modelToUse = createIdentifier(state, "vModelDynamic");
+		}
+		return modelToUse;
+	}
+	const referenceName = "v" + directiveName[0].toUpperCase() + directiveName.slice(1);
+	if (path.scope.references[referenceName]) return __babel_types.identifier(referenceName);
+	return __babel_types.callExpression(createIdentifier(state, "resolveDirective"), [__babel_types.stringLiteral(directiveName)]);
+};
+var parseDirectives_default = parseDirectives;
+
+//#endregion
+//#region src/transform-vue-jsx.ts
+const xlinkRE = new RegExp("^xlink([A-Z])", "");
+const getJSXAttributeValue = (path, state) => {
+	const valuePath = path.get("value");
+	if (valuePath.isJSXElement()) return transformJSXElement(valuePath, state);
+	if (valuePath.isStringLiteral()) return __babel_types.stringLiteral(transformText(valuePath.node.value));
+	if (valuePath.isJSXExpressionContainer()) return transformJSXExpressionContainer(valuePath);
+	return null;
+};
+const buildProps = (path, state) => {
+	const tag = getTag(path, state);
+	const isComponent = checkIsComponent(path.get("openingElement"), state);
+	const props = path.get("openingElement").get("attributes");
+	const directives = [];
+	const dynamicPropNames = /* @__PURE__ */ new Set();
+	let slots = null;
+	let patchFlag = 0;
+	if (props.length === 0) return {
+		tag,
+		isComponent,
+		slots,
+		props: __babel_types.nullLiteral(),
+		directives,
+		patchFlag,
+		dynamicPropNames
+	};
+	let properties = [];
+	let hasRef = false;
+	let hasClassBinding = false;
+	let hasStyleBinding = false;
+	let hasHydrationEventBinding = false;
+	let hasDynamicKeys = false;
+	const mergeArgs = [];
+	const { mergeProps = true } = state.opts;
+	props.forEach((prop) => {
+		if (prop.isJSXAttribute()) {
+			let name = getJSXAttributeName(prop);
+			const attributeValue = getJSXAttributeValue(prop, state);
+			if (!isConstant(attributeValue) || name === "ref") {
+				if (!isComponent && isOn(name) && name.toLowerCase() !== "onclick" && name !== "onUpdate:modelValue") hasHydrationEventBinding = true;
+				if (name === "ref") hasRef = true;
+				else if (name === "class" && !isComponent) hasClassBinding = true;
+				else if (name === "style" && !isComponent) hasStyleBinding = true;
+				else if (name !== "key" && !isDirective(name) && name !== "on") dynamicPropNames.add(name);
+			}
+			if (state.opts.transformOn && (name === "on" || name === "nativeOn")) {
+				if (!state.get("transformOn")) state.set("transformOn", (0, __babel_helper_module_imports.addDefault)(path, "@vue/babel-helper-vue-transform-on", { nameHint: "_transformOn" }));
+				mergeArgs.push(__babel_types.callExpression(state.get("transformOn"), [attributeValue || __babel_types.booleanLiteral(true)]));
+				return;
+			}
+			if (isDirective(name)) {
+				const { directive, modifiers, values, args, directiveName } = parseDirectives_default({
+					tag,
+					isComponent,
+					name,
+					path: prop,
+					state,
+					value: attributeValue
+				});
+				if (directiveName === "slots") {
+					slots = attributeValue;
+					return;
+				}
+				if (directive) directives.push(__babel_types.arrayExpression(directive));
+				else if (directiveName === "html") {
+					properties.push(__babel_types.objectProperty(__babel_types.stringLiteral("innerHTML"), values[0]));
+					dynamicPropNames.add("innerHTML");
+				} else if (directiveName === "text") {
+					properties.push(__babel_types.objectProperty(__babel_types.stringLiteral("textContent"), values[0]));
+					dynamicPropNames.add("textContent");
+				}
+				if (["models", "model"].includes(directiveName)) values.forEach((value, index) => {
+					const propName = args[index];
+					const isDynamic = propName && !__babel_types.isStringLiteral(propName) && !__babel_types.isNullLiteral(propName);
+					if (!directive) {
+						var _modifiers$index;
+						properties.push(__babel_types.objectProperty(__babel_types.isNullLiteral(propName) ? __babel_types.stringLiteral("modelValue") : propName, value, isDynamic));
+						if (!isDynamic) dynamicPropNames.add((propName === null || propName === void 0 ? void 0 : propName.value) || "modelValue");
+						if ((_modifiers$index = modifiers[index]) === null || _modifiers$index === void 0 ? void 0 : _modifiers$index.size) properties.push(__babel_types.objectProperty(isDynamic ? __babel_types.binaryExpression("+", propName, __babel_types.stringLiteral("Modifiers")) : __babel_types.stringLiteral(`${(propName === null || propName === void 0 ? void 0 : propName.value) || "model"}Modifiers`), __babel_types.objectExpression([...modifiers[index]].map((modifier) => __babel_types.objectProperty(__babel_types.stringLiteral(modifier), __babel_types.booleanLiteral(true)))), isDynamic));
+					}
+					const updateName = isDynamic ? __babel_types.binaryExpression("+", __babel_types.stringLiteral("onUpdate:"), propName) : __babel_types.stringLiteral(`onUpdate:${(propName === null || propName === void 0 ? void 0 : propName.value) || "modelValue"}`);
+					properties.push(__babel_types.objectProperty(updateName, __babel_types.arrowFunctionExpression([__babel_types.identifier("$event")], __babel_types.assignmentExpression("=", value, __babel_types.identifier("$event"))), isDynamic));
+					if (!isDynamic) dynamicPropNames.add(updateName.value);
+					else hasDynamicKeys = true;
+				});
+			} else {
+				if (name.match(xlinkRE)) name = name.replace(xlinkRE, (_, firstCharacter) => `xlink:${firstCharacter.toLowerCase()}`);
+				properties.push(__babel_types.objectProperty(__babel_types.stringLiteral(name), attributeValue || __babel_types.booleanLiteral(true)));
+			}
+		} else {
+			if (properties.length && mergeProps) {
+				mergeArgs.push(__babel_types.objectExpression(dedupeProperties(properties, mergeProps)));
+				properties = [];
+			}
+			hasDynamicKeys = true;
+			transformJSXSpreadAttribute(path, prop, mergeProps, mergeProps ? mergeArgs : properties);
+		}
+	});
+	if (hasDynamicKeys) patchFlag |= PatchFlags.FULL_PROPS;
+	else {
+		if (hasClassBinding) patchFlag |= PatchFlags.CLASS;
+		if (hasStyleBinding) patchFlag |= PatchFlags.STYLE;
+		if (dynamicPropNames.size) patchFlag |= PatchFlags.PROPS;
+		if (hasHydrationEventBinding) patchFlag |= PatchFlags.HYDRATE_EVENTS;
+	}
+	if ((patchFlag === 0 || patchFlag === PatchFlags.HYDRATE_EVENTS) && (hasRef || directives.length > 0)) patchFlag |= PatchFlags.NEED_PATCH;
+	let propsExpression = __babel_types.nullLiteral();
+	if (mergeArgs.length) {
+		if (properties.length) mergeArgs.push(__babel_types.objectExpression(dedupeProperties(properties, mergeProps)));
+		if (mergeArgs.length > 1) propsExpression = __babel_types.callExpression(createIdentifier(state, "mergeProps"), mergeArgs);
+		else propsExpression = mergeArgs[0];
+	} else if (properties.length) if (properties.length === 1 && __babel_types.isSpreadElement(properties[0])) propsExpression = properties[0].argument;
+	else propsExpression = __babel_types.objectExpression(dedupeProperties(properties, mergeProps));
+	return {
+		tag,
+		props: propsExpression,
+		isComponent,
+		slots,
+		directives,
+		patchFlag,
+		dynamicPropNames
+	};
+};
+/**
+* Get children from Array of JSX children
+* @param paths Array<JSXText | JSXExpressionContainer  | JSXElement | JSXFragment>
+* @returns Array<Expression | SpreadElement>
+*/
+const getChildren = (paths, state) => paths.map((path) => {
+	if (path.isJSXText()) {
+		const transformedText = transformJSXText(path);
+		if (transformedText) return __babel_types.callExpression(createIdentifier(state, "createTextVNode"), [transformedText]);
+		return transformedText;
+	}
+	if (path.isJSXExpressionContainer()) {
+		const expression = transformJSXExpressionContainer(path);
+		if (__babel_types.isIdentifier(expression)) {
+			const { name } = expression;
+			const { referencePaths = [] } = path.scope.getBinding(name) || {};
+			referencePaths.forEach((referencePath) => {
+				walksScope(referencePath, name, slotFlags_default.DYNAMIC);
+			});
+		}
+		return expression;
+	}
+	if (path.isJSXSpreadChild()) return transformJSXSpreadChild(path);
+	if (path.isCallExpression()) return path.node;
+	if (path.isJSXElement()) return transformJSXElement(path, state);
+	throw new Error(`getChildren: ${path.type} is not supported`);
+}).filter(((value) => value != null && !__babel_types.isJSXEmptyExpression(value)));
+const transformJSXElement = (path, state) => {
+	var _path$getData;
+	const children = getChildren(path.get("children"), state);
+	const { tag, props, isComponent, directives, patchFlag, dynamicPropNames, slots } = buildProps(path, state);
+	const { optimize = false } = state.opts;
+	if (directives.length && directives.some((d) => {
+		var _d$elements;
+		return ((_d$elements = d.elements) === null || _d$elements === void 0 || (_d$elements = _d$elements[0]) === null || _d$elements === void 0 ? void 0 : _d$elements.type) === "CallExpression" && d.elements[0].callee.type === "Identifier" && d.elements[0].callee.name === "_resolveDirective";
+	})) {
+		var _currentPath$parentPa;
+		let currentPath = path;
+		while ((_currentPath$parentPa = currentPath.parentPath) === null || _currentPath$parentPa === void 0 ? void 0 : _currentPath$parentPa.isJSXElement()) {
+			currentPath = currentPath.parentPath;
+			currentPath.setData("slotFlag", 0);
+		}
+	}
+	const slotFlag = (_path$getData = path.getData("slotFlag")) !== null && _path$getData !== void 0 ? _path$getData : slotFlags_default.STABLE;
+	const optimizeSlots = optimize && slotFlag !== 0;
+	let VNodeChild;
+	if (children.length > 1 || slots) VNodeChild = isComponent ? children.length ? __babel_types.objectExpression([
+		!!children.length && __babel_types.objectProperty(__babel_types.identifier("default"), __babel_types.arrowFunctionExpression([], __babel_types.arrayExpression(buildIIFE(path, children)))),
+		...slots ? __babel_types.isObjectExpression(slots) ? slots.properties : [__babel_types.spreadElement(slots)] : [],
+		optimizeSlots && __babel_types.objectProperty(__babel_types.identifier("_"), __babel_types.numericLiteral(slotFlag))
+	].filter(Boolean)) : slots : __babel_types.arrayExpression(children);
+	else if (children.length === 1) {
+		const { enableObjectSlots = true } = state.opts;
+		const child = children[0];
+		const objectExpression = __babel_types.objectExpression([__babel_types.objectProperty(__babel_types.identifier("default"), __babel_types.arrowFunctionExpression([], __babel_types.arrayExpression(buildIIFE(path, [child])))), optimizeSlots && __babel_types.objectProperty(__babel_types.identifier("_"), __babel_types.numericLiteral(slotFlag))].filter(Boolean));
+		if (__babel_types.isIdentifier(child) && isComponent) VNodeChild = enableObjectSlots ? __babel_types.conditionalExpression(__babel_types.callExpression(state.get("@vue/babel-plugin-jsx/runtimeIsSlot")(), [child]), child, objectExpression) : objectExpression;
+		else if (__babel_types.isCallExpression(child) && child.loc && isComponent) if (enableObjectSlots) {
+			const { scope } = path;
+			const slotId = scope.generateUidIdentifier("slot");
+			if (scope) scope.push({
+				id: slotId,
+				kind: "let"
+			});
+			const alternate = __babel_types.objectExpression([__babel_types.objectProperty(__babel_types.identifier("default"), __babel_types.arrowFunctionExpression([], __babel_types.arrayExpression(buildIIFE(path, [slotId])))), optimizeSlots && __babel_types.objectProperty(__babel_types.identifier("_"), __babel_types.numericLiteral(slotFlag))].filter(Boolean));
+			const assignment = __babel_types.assignmentExpression("=", slotId, child);
+			const condition = __babel_types.callExpression(state.get("@vue/babel-plugin-jsx/runtimeIsSlot")(), [assignment]);
+			VNodeChild = __babel_types.conditionalExpression(condition, slotId, alternate);
+		} else VNodeChild = objectExpression;
+		else if (__babel_types.isFunctionExpression(child) || __babel_types.isArrowFunctionExpression(child)) VNodeChild = __babel_types.objectExpression([__babel_types.objectProperty(__babel_types.identifier("default"), child)]);
+		else if (__babel_types.isObjectExpression(child)) VNodeChild = __babel_types.objectExpression([...child.properties, optimizeSlots && __babel_types.objectProperty(__babel_types.identifier("_"), __babel_types.numericLiteral(slotFlag))].filter(Boolean));
+		else VNodeChild = isComponent ? __babel_types.objectExpression([__babel_types.objectProperty(__babel_types.identifier("default"), __babel_types.arrowFunctionExpression([], __babel_types.arrayExpression([child])))]) : __babel_types.arrayExpression([child]);
+	}
+	const createVNode = __babel_types.callExpression(createIdentifier(state, "createVNode"), [
+		tag,
+		props,
+		VNodeChild || __babel_types.nullLiteral(),
+		!!patchFlag && optimize && __babel_types.numericLiteral(patchFlag),
+		!!dynamicPropNames.size && optimize && __babel_types.arrayExpression([...dynamicPropNames.keys()].map((name) => __babel_types.stringLiteral(name)))
+	].filter(Boolean));
+	if (!directives.length) return createVNode;
+	return __babel_types.callExpression(createIdentifier(state, "withDirectives"), [createVNode, __babel_types.arrayExpression(directives)]);
+};
+const visitor$1 = { JSXElement: { exit(path, state) {
+	path.replaceWith(transformJSXElement(path, state));
+} } };
+var transform_vue_jsx_default = visitor$1;
+
+//#endregion
+//#region src/sugar-fragment.ts
+const transformFragment = (path, Fragment) => {
+	const children = path.get("children") || [];
+	return __babel_types.jsxElement(__babel_types.jsxOpeningElement(Fragment, []), __babel_types.jsxClosingElement(Fragment), children.map(({ node }) => node), false);
+};
+const visitor = { JSXFragment: { enter(path, state) {
+	const fragmentCallee = createIdentifier(state, FRAGMENT);
+	path.replaceWith(transformFragment(path, __babel_types.isIdentifier(fragmentCallee) ? __babel_types.jsxIdentifier(fragmentCallee.name) : __babel_types.jsxMemberExpression(__babel_types.jsxIdentifier(fragmentCallee.object.name), __babel_types.jsxIdentifier(fragmentCallee.property.name))));
+} } };
+var sugar_fragment_default = visitor;
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/typeof.js
+var require_typeof = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/typeof.js": ((exports, module) => {
+	function _typeof$2(o) {
+		"@babel/helpers - typeof";
+		return module.exports = _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+			return typeof o$1;
+		} : function(o$1) {
+			return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+		}, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof$2(o);
+	}
+	module.exports = _typeof$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js
+var require_toPrimitive = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js": ((exports, module) => {
+	var _typeof$1 = require_typeof()["default"];
+	function toPrimitive$1(t, r) {
+		if ("object" != _typeof$1(t) || !t) return t;
+		var e = t[Symbol.toPrimitive];
+		if (void 0 !== e) {
+			var i = e.call(t, r || "default");
+			if ("object" != _typeof$1(i)) return i;
+			throw new TypeError("@@toPrimitive must return a primitive value.");
+		}
+		return ("string" === r ? String : Number)(t);
+	}
+	module.exports = toPrimitive$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js
+var require_toPropertyKey = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js": ((exports, module) => {
+	var _typeof = require_typeof()["default"];
+	var toPrimitive = require_toPrimitive();
+	function toPropertyKey$1(t) {
+		var i = toPrimitive(t, "string");
+		return "symbol" == _typeof(i) ? i : i + "";
+	}
+	module.exports = toPropertyKey$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js
+var require_defineProperty = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js": ((exports, module) => {
+	var toPropertyKey = require_toPropertyKey();
+	function _defineProperty(e, r, t) {
+		return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+			value: t,
+			enumerable: !0,
+			configurable: !0,
+			writable: !0
+		}) : e[r] = t, e;
+	}
+	module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js
+var require_objectSpread2 = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js": ((exports, module) => {
+	var defineProperty = require_defineProperty();
+	function ownKeys(e, r) {
+		var t = Object.keys(e);
+		if (Object.getOwnPropertySymbols) {
+			var o = Object.getOwnPropertySymbols(e);
+			r && (o = o.filter(function(r$1) {
+				return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+			})), t.push.apply(t, o);
+		}
+		return t;
+	}
+	function _objectSpread2(e) {
+		for (var r = 1; r < arguments.length; r++) {
+			var t = null != arguments[r] ? arguments[r] : {};
+			r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
+				defineProperty(e, r$1, t[r$1]);
+			}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+				Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+			});
+		}
+		return e;
+	}
+	module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}) });
+
+//#endregion
+//#region src/index.ts
+var import_objectSpread2 = /* @__PURE__ */ __toESM(require_objectSpread2());
+const hasJSX = (parentPath) => {
+	let fileHasJSX = false;
+	parentPath.traverse({
+		JSXElement(path) {
+			fileHasJSX = true;
+			path.stop();
+		},
+		JSXFragment(path) {
+			fileHasJSX = true;
+			path.stop();
+		}
+	});
+	return fileHasJSX;
+};
+const JSX_ANNOTATION_REGEX = new RegExp("\\*?\\s*@jsx\\s+([^\\s]+)", "");
+/* @__NO_SIDE_EFFECTS__ */
+function interopDefault(m) {
+	return m.default || m;
+}
+const syntaxJsx = /* @__PURE__ */ interopDefault(__babel_plugin_syntax_jsx.default);
+const template = /* @__PURE__ */ interopDefault(__babel_template.default);
+const plugin = (0, __babel_helper_plugin_utils.declare)((api, opt, dirname) => {
+	const { types } = api;
+	let resolveType;
+	if (opt.resolveType) {
+		if (typeof opt.resolveType === "boolean") opt.resolveType = {};
+		resolveType = (0, __vue_babel_plugin_resolve_type.default)(api, opt.resolveType, dirname);
+	}
+	return (0, import_objectSpread2.default)((0, import_objectSpread2.default)({}, resolveType || {}), {}, {
+		name: "babel-plugin-jsx",
+		inherits: /* @__PURE__ */ interopDefault(syntaxJsx),
+		visitor: (0, import_objectSpread2.default)((0, import_objectSpread2.default)((0, import_objectSpread2.default)((0, import_objectSpread2.default)({}, resolveType === null || resolveType === void 0 ? void 0 : resolveType.visitor), transform_vue_jsx_default), sugar_fragment_default), {}, { Program: { enter(path, state) {
+			if (hasJSX(path)) {
+				const importNames = [
+					"createVNode",
+					"Fragment",
+					"resolveComponent",
+					"withDirectives",
+					"vShow",
+					"vModelSelect",
+					"vModelText",
+					"vModelCheckbox",
+					"vModelRadio",
+					"vModelText",
+					"vModelDynamic",
+					"resolveDirective",
+					"mergeProps",
+					"createTextVNode",
+					"isVNode"
+				];
+				if ((0, __babel_helper_module_imports.isModule)(path)) {
+					const importMap = {};
+					importNames.forEach((name) => {
+						state.set(name, () => {
+							if (importMap[name]) return types.cloneNode(importMap[name]);
+							const identifier = (0, __babel_helper_module_imports.addNamed)(path, name, "vue", { ensureLiveReference: true });
+							importMap[name] = identifier;
+							return identifier;
+						});
+					});
+					const { enableObjectSlots = true } = state.opts;
+					if (enableObjectSlots) state.set("@vue/babel-plugin-jsx/runtimeIsSlot", () => {
+						if (importMap.runtimeIsSlot) return importMap.runtimeIsSlot;
+						const { name: isVNodeName } = state.get("isVNode")();
+						const isSlot = path.scope.generateUidIdentifier("isSlot");
+						const ast = template.ast`
+                    function ${isSlot.name}(s) {
+                      return typeof s === 'function' || (Object.prototype.toString.call(s) === '[object Object]' && !${isVNodeName}(s));
+                    }
+                  `;
+						const lastImport = path.get("body").filter((p) => p.isImportDeclaration()).pop();
+						if (lastImport) lastImport.insertAfter(ast);
+						importMap.runtimeIsSlot = isSlot;
+						return isSlot;
+					});
+				} else {
+					let sourceName;
+					importNames.forEach((name) => {
+						state.set(name, () => {
+							if (!sourceName) sourceName = (0, __babel_helper_module_imports.addNamespace)(path, "vue", { ensureLiveReference: true });
+							return __babel_types.memberExpression(sourceName, __babel_types.identifier(name));
+						});
+					});
+					const helpers = {};
+					const { enableObjectSlots = true } = state.opts;
+					if (enableObjectSlots) state.set("@vue/babel-plugin-jsx/runtimeIsSlot", () => {
+						if (helpers.runtimeIsSlot) return helpers.runtimeIsSlot;
+						const isSlot = path.scope.generateUidIdentifier("isSlot");
+						const { object: objectName } = state.get("isVNode")();
+						const ast = template.ast`
+                    function ${isSlot.name}(s) {
+                      return typeof s === 'function' || (Object.prototype.toString.call(s) === '[object Object]' && !${objectName.name}.isVNode(s));
+                    }
+                  `;
+						const nodePaths = path.get("body");
+						const lastImport = nodePaths.filter((p) => p.isVariableDeclaration() && p.node.declarations.some((d) => {
+							var _d$id;
+							return ((_d$id = d.id) === null || _d$id === void 0 ? void 0 : _d$id.name) === sourceName.name;
+						})).pop();
+						if (lastImport) lastImport.insertAfter(ast);
+						return isSlot;
+					});
+				}
+				const { opts: { pragma = "" }, file } = state;
+				if (pragma) state.set("createVNode", () => __babel_types.identifier(pragma));
+				if (file.ast.comments) for (const comment of file.ast.comments) {
+					const jsxMatches = JSX_ANNOTATION_REGEX.exec(comment.value);
+					if (jsxMatches) state.set("createVNode", () => __babel_types.identifier(jsxMatches[1]));
+				}
+			}
+		} } })
+	});
+});
+var src_default = plugin;
+
+//#endregion
+module.exports = src_default;

node_modules/@vue/babel-plugin-jsx/dist/index.mjs

@@ -0,0 +1,771 @@
+import * as t from "@babel/types";
+import _template from "@babel/template";
+import _syntaxJsx from "@babel/plugin-syntax-jsx";
+import { addDefault, addNamed, addNamespace, isModule } from "@babel/helper-module-imports";
+import ResolveType from "@vue/babel-plugin-resolve-type";
+import { declare } from "@babel/helper-plugin-utils";
+import { isHTMLTag, isSVGTag } from "@vue/shared";
+
+//#region src/slotFlags.ts
+var SlotFlags = /* @__PURE__ */ function(SlotFlags$1) {
+	/**
+	* Stable slots that only reference slot props or context state. The slot
+	* can fully capture its own dependencies so when passed down the parent won't
+	* need to force the child to update.
+	*/
+	SlotFlags$1[SlotFlags$1["STABLE"] = 1] = "STABLE";
+	/**
+	* Slots that reference scope variables (v-for or an outer slot prop), or
+	* has conditional structure (v-if, v-for). The parent will need to force
+	* the child to update because the slot does not fully capture its dependencies.
+	*/
+	SlotFlags$1[SlotFlags$1["DYNAMIC"] = 2] = "DYNAMIC";
+	/**
+	* `<slot/>` being forwarded into a child component. Whether the parent needs
+	* to update the child is dependent on what kind of slots the parent itself
+	* received. This has to be refined at runtime, when the child's vnode
+	* is being created (in `normalizeChildren`)
+	*/
+	SlotFlags$1[SlotFlags$1["FORWARDED"] = 3] = "FORWARDED";
+	return SlotFlags$1;
+}(SlotFlags || {});
+var slotFlags_default = SlotFlags;
+
+//#endregion
+//#region src/utils.ts
+const FRAGMENT = "Fragment";
+const KEEP_ALIVE = "KeepAlive";
+/**
+* create Identifier
+* @param path NodePath
+* @param state
+* @param name string
+* @returns MemberExpression
+*/
+const createIdentifier = (state, name) => state.get(name)();
+/**
+* Checks if string is describing a directive
+* @param src string
+*/
+const isDirective = (src) => src.startsWith("v-") || src.startsWith("v") && src.length >= 2 && src[1] >= "A" && src[1] <= "Z";
+/**
+* Should transformed to slots
+* @param tag string
+* @returns boolean
+*/
+const shouldTransformedToSlots = (tag) => !(tag.match(RegExp(`^_?${FRAGMENT}\\d*$`)) || tag === KEEP_ALIVE);
+/**
+* Check if a Node is a component
+*
+* @param t
+* @param path JSXOpeningElement
+* @returns boolean
+*/
+const checkIsComponent = (path, state) => {
+	var _state$opts$isCustomE, _state$opts;
+	const namePath = path.get("name");
+	if (namePath.isJSXMemberExpression()) return shouldTransformedToSlots(namePath.node.property.name);
+	const tag = namePath.node.name;
+	return !((_state$opts$isCustomE = (_state$opts = state.opts).isCustomElement) === null || _state$opts$isCustomE === void 0 ? void 0 : _state$opts$isCustomE.call(_state$opts, tag)) && shouldTransformedToSlots(tag) && !isHTMLTag(tag) && !isSVGTag(tag);
+};
+/**
+* Transform JSXMemberExpression to MemberExpression
+* @param path JSXMemberExpression
+* @returns MemberExpression
+*/
+const transformJSXMemberExpression = (path) => {
+	const objectPath = path.node.object;
+	const propertyPath = path.node.property;
+	const transformedObject = t.isJSXMemberExpression(objectPath) ? transformJSXMemberExpression(path.get("object")) : t.isJSXIdentifier(objectPath) ? t.identifier(objectPath.name) : t.nullLiteral();
+	const transformedProperty = t.identifier(propertyPath.name);
+	return t.memberExpression(transformedObject, transformedProperty);
+};
+/**
+* Get tag (first attribute for h) from JSXOpeningElement
+* @param path JSXElement
+* @param state State
+* @returns Identifier | StringLiteral | MemberExpression | CallExpression
+*/
+const getTag = (path, state) => {
+	const namePath = path.get("openingElement").get("name");
+	if (namePath.isJSXIdentifier()) {
+		const { name } = namePath.node;
+		if (!isHTMLTag(name) && !isSVGTag(name)) {
+			var _state$opts$isCustomE2, _state$opts2;
+			return name === FRAGMENT ? createIdentifier(state, FRAGMENT) : path.scope.hasBinding(name) ? t.identifier(name) : ((_state$opts$isCustomE2 = (_state$opts2 = state.opts).isCustomElement) === null || _state$opts$isCustomE2 === void 0 ? void 0 : _state$opts$isCustomE2.call(_state$opts2, name)) ? t.stringLiteral(name) : t.callExpression(createIdentifier(state, "resolveComponent"), [t.stringLiteral(name)]);
+		}
+		return t.stringLiteral(name);
+	}
+	if (namePath.isJSXMemberExpression()) return transformJSXMemberExpression(namePath);
+	throw new Error(`getTag: ${namePath.type} is not supported`);
+};
+const getJSXAttributeName = (path) => {
+	const nameNode = path.node.name;
+	if (t.isJSXIdentifier(nameNode)) return nameNode.name;
+	return `${nameNode.namespace.name}:${nameNode.name.name}`;
+};
+/**
+* Transform JSXText to StringLiteral
+* @param path JSXText
+* @returns StringLiteral | null
+*/
+const transformJSXText = (path) => {
+	const str = transformText(path.node.value);
+	return str !== "" ? t.stringLiteral(str) : null;
+};
+const transformText = (text) => {
+	const lines = text.split(/\r\n|\n|\r/);
+	let lastNonEmptyLine = 0;
+	for (let i = 0; i < lines.length; i++) if (lines[i].match(/[^ \t]/)) lastNonEmptyLine = i;
+	let str = "";
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const isFirstLine = i === 0;
+		const isLastLine = i === lines.length - 1;
+		const isLastNonEmptyLine = i === lastNonEmptyLine;
+		let trimmedLine = line.replace(/\t/g, " ");
+		if (!isFirstLine) trimmedLine = trimmedLine.replace(/^[ ]+/, "");
+		if (!isLastLine) trimmedLine = trimmedLine.replace(/[ ]+$/, "");
+		if (trimmedLine) {
+			if (!isLastNonEmptyLine) trimmedLine += " ";
+			str += trimmedLine;
+		}
+	}
+	return str;
+};
+/**
+* Transform JSXExpressionContainer to Expression
+* @param path JSXExpressionContainer
+* @returns Expression
+*/
+const transformJSXExpressionContainer = (path) => path.get("expression").node;
+/**
+* Transform JSXSpreadChild
+* @param path JSXSpreadChild
+* @returns SpreadElement
+*/
+const transformJSXSpreadChild = (path) => t.spreadElement(path.get("expression").node);
+const walksScope = (path, name, slotFlag) => {
+	if (path.scope.hasBinding(name) && path.parentPath) {
+		if (t.isJSXElement(path.parentPath.node)) path.parentPath.setData("slotFlag", slotFlag);
+		walksScope(path.parentPath, name, slotFlag);
+	}
+};
+const buildIIFE = (path, children) => {
+	const { parentPath } = path;
+	if (parentPath.isAssignmentExpression()) {
+		const { left } = parentPath.node;
+		if (t.isIdentifier(left)) return children.map((child) => {
+			if (t.isIdentifier(child) && child.name === left.name) {
+				const insertName = path.scope.generateUidIdentifier(child.name);
+				parentPath.insertBefore(t.variableDeclaration("const", [t.variableDeclarator(insertName, t.callExpression(t.functionExpression(null, [], t.blockStatement([t.returnStatement(child)])), []))]));
+				return insertName;
+			}
+			return child;
+		});
+	}
+	return children;
+};
+const onRE = /^on[^a-z]/;
+const isOn = (key) => onRE.test(key);
+const mergeAsArray = (existing, incoming) => {
+	if (t.isArrayExpression(existing.value)) existing.value.elements.push(incoming.value);
+	else existing.value = t.arrayExpression([existing.value, incoming.value]);
+};
+const dedupeProperties = (properties = [], mergeProps) => {
+	if (!mergeProps) return properties;
+	const knownProps = /* @__PURE__ */ new Map();
+	const deduped = [];
+	properties.forEach((prop) => {
+		if (t.isStringLiteral(prop.key)) {
+			const { value: name } = prop.key;
+			const existing = knownProps.get(name);
+			if (existing) {
+				if (name === "style" || name === "class" || name.startsWith("on")) mergeAsArray(existing, prop);
+			} else {
+				knownProps.set(name, prop);
+				deduped.push(prop);
+			}
+		} else deduped.push(prop);
+	});
+	return deduped;
+};
+/**
+*  Check if an attribute value is constant
+* @param node
+* @returns boolean
+*/
+const isConstant = (node) => {
+	if (t.isIdentifier(node)) return node.name === "undefined";
+	if (t.isArrayExpression(node)) {
+		const { elements } = node;
+		return elements.every((element) => element && isConstant(element));
+	}
+	if (t.isObjectExpression(node)) return node.properties.every((property) => isConstant(property.value));
+	if (t.isTemplateLiteral(node) ? !node.expressions.length : t.isLiteral(node)) return true;
+	return false;
+};
+const transformJSXSpreadAttribute = (nodePath, path, mergeProps, args) => {
+	const argument = path.get("argument");
+	const properties = t.isObjectExpression(argument.node) ? argument.node.properties : void 0;
+	if (!properties) {
+		if (argument.isIdentifier()) walksScope(nodePath, argument.node.name, slotFlags_default.DYNAMIC);
+		args.push(mergeProps ? argument.node : t.spreadElement(argument.node));
+	} else if (mergeProps) args.push(t.objectExpression(properties));
+	else args.push(...properties);
+};
+
+//#endregion
+//#region src/patchFlags.ts
+let PatchFlags = /* @__PURE__ */ function(PatchFlags$1) {
+	PatchFlags$1[PatchFlags$1["TEXT"] = 1] = "TEXT";
+	PatchFlags$1[PatchFlags$1["CLASS"] = 2] = "CLASS";
+	PatchFlags$1[PatchFlags$1["STYLE"] = 4] = "STYLE";
+	PatchFlags$1[PatchFlags$1["PROPS"] = 8] = "PROPS";
+	PatchFlags$1[PatchFlags$1["FULL_PROPS"] = 16] = "FULL_PROPS";
+	PatchFlags$1[PatchFlags$1["HYDRATE_EVENTS"] = 32] = "HYDRATE_EVENTS";
+	PatchFlags$1[PatchFlags$1["STABLE_FRAGMENT"] = 64] = "STABLE_FRAGMENT";
+	PatchFlags$1[PatchFlags$1["KEYED_FRAGMENT"] = 128] = "KEYED_FRAGMENT";
+	PatchFlags$1[PatchFlags$1["UNKEYED_FRAGMENT"] = 256] = "UNKEYED_FRAGMENT";
+	PatchFlags$1[PatchFlags$1["NEED_PATCH"] = 512] = "NEED_PATCH";
+	PatchFlags$1[PatchFlags$1["DYNAMIC_SLOTS"] = 1024] = "DYNAMIC_SLOTS";
+	PatchFlags$1[PatchFlags$1["HOISTED"] = -1] = "HOISTED";
+	PatchFlags$1[PatchFlags$1["BAIL"] = -2] = "BAIL";
+	return PatchFlags$1;
+}({});
+const PatchFlagNames = {
+	[PatchFlags.TEXT]: "TEXT",
+	[PatchFlags.CLASS]: "CLASS",
+	[PatchFlags.STYLE]: "STYLE",
+	[PatchFlags.PROPS]: "PROPS",
+	[PatchFlags.FULL_PROPS]: "FULL_PROPS",
+	[PatchFlags.HYDRATE_EVENTS]: "HYDRATE_EVENTS",
+	[PatchFlags.STABLE_FRAGMENT]: "STABLE_FRAGMENT",
+	[PatchFlags.KEYED_FRAGMENT]: "KEYED_FRAGMENT",
+	[PatchFlags.UNKEYED_FRAGMENT]: "UNKEYED_FRAGMENT",
+	[PatchFlags.DYNAMIC_SLOTS]: "DYNAMIC_SLOTS",
+	[PatchFlags.NEED_PATCH]: "NEED_PATCH",
+	[PatchFlags.HOISTED]: "HOISTED",
+	[PatchFlags.BAIL]: "BAIL"
+};
+
+//#endregion
+//#region src/parseDirectives.ts
+/**
+* Get JSX element type
+*
+* @param path Path<JSXOpeningElement>
+*/
+const getType = (path) => {
+	const typePath = path.get("attributes").find((attribute) => {
+		if (!attribute.isJSXAttribute()) return false;
+		return attribute.get("name").isJSXIdentifier() && attribute.get("name").node.name === "type";
+	});
+	return typePath ? typePath.get("value").node : null;
+};
+const parseModifiers = (value) => t.isArrayExpression(value) ? value.elements.map((el) => t.isStringLiteral(el) ? el.value : "").filter(Boolean) : [];
+const parseDirectives = (params) => {
+	var _modifiersSet$, _modifiersSet$2;
+	const { path, value, state, tag, isComponent } = params;
+	const args = [];
+	const vals = [];
+	const modifiersSet = [];
+	let directiveName;
+	let directiveArgument;
+	let directiveModifiers;
+	if ("namespace" in path.node.name) {
+		[directiveName, directiveArgument] = params.name.split(":");
+		directiveName = path.node.name.namespace.name;
+		directiveArgument = path.node.name.name.name;
+		directiveModifiers = directiveArgument.split("_").slice(1);
+	} else {
+		const underscoreModifiers = params.name.split("_");
+		directiveName = underscoreModifiers.shift() || "";
+		directiveModifiers = underscoreModifiers;
+	}
+	directiveName = directiveName.replace(/^v/, "").replace(/^-/, "").replace(/^\S/, (s) => s.toLowerCase());
+	if (directiveArgument) args.push(t.stringLiteral(directiveArgument.split("_")[0]));
+	const isVModels = directiveName === "models";
+	const isVModel = directiveName === "model";
+	if (isVModel && !path.get("value").isJSXExpressionContainer()) throw new Error("You have to use JSX Expression inside your v-model");
+	if (isVModels && !isComponent) throw new Error("v-models can only use in custom components");
+	const shouldResolve = ![
+		"html",
+		"text",
+		"model",
+		"slots",
+		"models"
+	].includes(directiveName) || isVModel && !isComponent;
+	let modifiers = directiveModifiers;
+	if (t.isArrayExpression(value)) {
+		const elementsList = isVModels ? value.elements : [value];
+		elementsList.forEach((element) => {
+			if (isVModels && !t.isArrayExpression(element)) throw new Error("You should pass a Two-dimensional Arrays to v-models");
+			const { elements } = element;
+			const [first, second, third] = elements;
+			if (second && !t.isArrayExpression(second) && !t.isSpreadElement(second)) {
+				args.push(second);
+				modifiers = parseModifiers(third);
+			} else if (t.isArrayExpression(second)) {
+				if (!shouldResolve) args.push(t.nullLiteral());
+				modifiers = parseModifiers(second);
+			} else if (!shouldResolve) args.push(t.nullLiteral());
+			modifiersSet.push(new Set(modifiers));
+			vals.push(first);
+		});
+	} else if (isVModel && !shouldResolve) {
+		args.push(t.nullLiteral());
+		modifiersSet.push(new Set(directiveModifiers));
+	} else modifiersSet.push(new Set(directiveModifiers));
+	return {
+		directiveName,
+		modifiers: modifiersSet,
+		values: vals.length ? vals : [value],
+		args,
+		directive: shouldResolve ? [
+			resolveDirective(path, state, tag, directiveName),
+			vals[0] || value,
+			((_modifiersSet$ = modifiersSet[0]) === null || _modifiersSet$ === void 0 ? void 0 : _modifiersSet$.size) ? args[0] || t.unaryExpression("void", t.numericLiteral(0), true) : args[0],
+			!!((_modifiersSet$2 = modifiersSet[0]) === null || _modifiersSet$2 === void 0 ? void 0 : _modifiersSet$2.size) && t.objectExpression([...modifiersSet[0]].map((modifier) => t.objectProperty(t.identifier(modifier), t.booleanLiteral(true))))
+		].filter(Boolean) : void 0
+	};
+};
+const resolveDirective = (path, state, tag, directiveName) => {
+	if (directiveName === "show") return createIdentifier(state, "vShow");
+	if (directiveName === "model") {
+		let modelToUse;
+		const type = getType(path.parentPath);
+		switch (tag.value) {
+			case "select":
+				modelToUse = createIdentifier(state, "vModelSelect");
+				break;
+			case "textarea":
+				modelToUse = createIdentifier(state, "vModelText");
+				break;
+			default: if (t.isStringLiteral(type) || !type) switch (type === null || type === void 0 ? void 0 : type.value) {
+				case "checkbox":
+					modelToUse = createIdentifier(state, "vModelCheckbox");
+					break;
+				case "radio":
+					modelToUse = createIdentifier(state, "vModelRadio");
+					break;
+				default: modelToUse = createIdentifier(state, "vModelText");
+			}
+			else modelToUse = createIdentifier(state, "vModelDynamic");
+		}
+		return modelToUse;
+	}
+	const referenceName = "v" + directiveName[0].toUpperCase() + directiveName.slice(1);
+	if (path.scope.references[referenceName]) return t.identifier(referenceName);
+	return t.callExpression(createIdentifier(state, "resolveDirective"), [t.stringLiteral(directiveName)]);
+};
+var parseDirectives_default = parseDirectives;
+
+//#endregion
+//#region src/transform-vue-jsx.ts
+const xlinkRE = new RegExp("^xlink([A-Z])", "");
+const getJSXAttributeValue = (path, state) => {
+	const valuePath = path.get("value");
+	if (valuePath.isJSXElement()) return transformJSXElement(valuePath, state);
+	if (valuePath.isStringLiteral()) return t.stringLiteral(transformText(valuePath.node.value));
+	if (valuePath.isJSXExpressionContainer()) return transformJSXExpressionContainer(valuePath);
+	return null;
+};
+const buildProps = (path, state) => {
+	const tag = getTag(path, state);
+	const isComponent = checkIsComponent(path.get("openingElement"), state);
+	const props = path.get("openingElement").get("attributes");
+	const directives = [];
+	const dynamicPropNames = /* @__PURE__ */ new Set();
+	let slots = null;
+	let patchFlag = 0;
+	if (props.length === 0) return {
+		tag,
+		isComponent,
+		slots,
+		props: t.nullLiteral(),
+		directives,
+		patchFlag,
+		dynamicPropNames
+	};
+	let properties = [];
+	let hasRef = false;
+	let hasClassBinding = false;
+	let hasStyleBinding = false;
+	let hasHydrationEventBinding = false;
+	let hasDynamicKeys = false;
+	const mergeArgs = [];
+	const { mergeProps = true } = state.opts;
+	props.forEach((prop) => {
+		if (prop.isJSXAttribute()) {
+			let name = getJSXAttributeName(prop);
+			const attributeValue = getJSXAttributeValue(prop, state);
+			if (!isConstant(attributeValue) || name === "ref") {
+				if (!isComponent && isOn(name) && name.toLowerCase() !== "onclick" && name !== "onUpdate:modelValue") hasHydrationEventBinding = true;
+				if (name === "ref") hasRef = true;
+				else if (name === "class" && !isComponent) hasClassBinding = true;
+				else if (name === "style" && !isComponent) hasStyleBinding = true;
+				else if (name !== "key" && !isDirective(name) && name !== "on") dynamicPropNames.add(name);
+			}
+			if (state.opts.transformOn && (name === "on" || name === "nativeOn")) {
+				if (!state.get("transformOn")) state.set("transformOn", addDefault(path, "@vue/babel-helper-vue-transform-on", { nameHint: "_transformOn" }));
+				mergeArgs.push(t.callExpression(state.get("transformOn"), [attributeValue || t.booleanLiteral(true)]));
+				return;
+			}
+			if (isDirective(name)) {
+				const { directive, modifiers, values, args, directiveName } = parseDirectives_default({
+					tag,
+					isComponent,
+					name,
+					path: prop,
+					state,
+					value: attributeValue
+				});
+				if (directiveName === "slots") {
+					slots = attributeValue;
+					return;
+				}
+				if (directive) directives.push(t.arrayExpression(directive));
+				else if (directiveName === "html") {
+					properties.push(t.objectProperty(t.stringLiteral("innerHTML"), values[0]));
+					dynamicPropNames.add("innerHTML");
+				} else if (directiveName === "text") {
+					properties.push(t.objectProperty(t.stringLiteral("textContent"), values[0]));
+					dynamicPropNames.add("textContent");
+				}
+				if (["models", "model"].includes(directiveName)) values.forEach((value, index) => {
+					const propName = args[index];
+					const isDynamic = propName && !t.isStringLiteral(propName) && !t.isNullLiteral(propName);
+					if (!directive) {
+						var _modifiers$index;
+						properties.push(t.objectProperty(t.isNullLiteral(propName) ? t.stringLiteral("modelValue") : propName, value, isDynamic));
+						if (!isDynamic) dynamicPropNames.add((propName === null || propName === void 0 ? void 0 : propName.value) || "modelValue");
+						if ((_modifiers$index = modifiers[index]) === null || _modifiers$index === void 0 ? void 0 : _modifiers$index.size) properties.push(t.objectProperty(isDynamic ? t.binaryExpression("+", propName, t.stringLiteral("Modifiers")) : t.stringLiteral(`${(propName === null || propName === void 0 ? void 0 : propName.value) || "model"}Modifiers`), t.objectExpression([...modifiers[index]].map((modifier) => t.objectProperty(t.stringLiteral(modifier), t.booleanLiteral(true)))), isDynamic));
+					}
+					const updateName = isDynamic ? t.binaryExpression("+", t.stringLiteral("onUpdate:"), propName) : t.stringLiteral(`onUpdate:${(propName === null || propName === void 0 ? void 0 : propName.value) || "modelValue"}`);
+					properties.push(t.objectProperty(updateName, t.arrowFunctionExpression([t.identifier("$event")], t.assignmentExpression("=", value, t.identifier("$event"))), isDynamic));
+					if (!isDynamic) dynamicPropNames.add(updateName.value);
+					else hasDynamicKeys = true;
+				});
+			} else {
+				if (name.match(xlinkRE)) name = name.replace(xlinkRE, (_, firstCharacter) => `xlink:${firstCharacter.toLowerCase()}`);
+				properties.push(t.objectProperty(t.stringLiteral(name), attributeValue || t.booleanLiteral(true)));
+			}
+		} else {
+			if (properties.length && mergeProps) {
+				mergeArgs.push(t.objectExpression(dedupeProperties(properties, mergeProps)));
+				properties = [];
+			}
+			hasDynamicKeys = true;
+			transformJSXSpreadAttribute(path, prop, mergeProps, mergeProps ? mergeArgs : properties);
+		}
+	});
+	if (hasDynamicKeys) patchFlag |= PatchFlags.FULL_PROPS;
+	else {
+		if (hasClassBinding) patchFlag |= PatchFlags.CLASS;
+		if (hasStyleBinding) patchFlag |= PatchFlags.STYLE;
+		if (dynamicPropNames.size) patchFlag |= PatchFlags.PROPS;
+		if (hasHydrationEventBinding) patchFlag |= PatchFlags.HYDRATE_EVENTS;
+	}
+	if ((patchFlag === 0 || patchFlag === PatchFlags.HYDRATE_EVENTS) && (hasRef || directives.length > 0)) patchFlag |= PatchFlags.NEED_PATCH;
+	let propsExpression = t.nullLiteral();
+	if (mergeArgs.length) {
+		if (properties.length) mergeArgs.push(t.objectExpression(dedupeProperties(properties, mergeProps)));
+		if (mergeArgs.length > 1) propsExpression = t.callExpression(createIdentifier(state, "mergeProps"), mergeArgs);
+		else propsExpression = mergeArgs[0];
+	} else if (properties.length) if (properties.length === 1 && t.isSpreadElement(properties[0])) propsExpression = properties[0].argument;
+	else propsExpression = t.objectExpression(dedupeProperties(properties, mergeProps));
+	return {
+		tag,
+		props: propsExpression,
+		isComponent,
+		slots,
+		directives,
+		patchFlag,
+		dynamicPropNames
+	};
+};
+/**
+* Get children from Array of JSX children
+* @param paths Array<JSXText | JSXExpressionContainer  | JSXElement | JSXFragment>
+* @returns Array<Expression | SpreadElement>
+*/
+const getChildren = (paths, state) => paths.map((path) => {
+	if (path.isJSXText()) {
+		const transformedText = transformJSXText(path);
+		if (transformedText) return t.callExpression(createIdentifier(state, "createTextVNode"), [transformedText]);
+		return transformedText;
+	}
+	if (path.isJSXExpressionContainer()) {
+		const expression = transformJSXExpressionContainer(path);
+		if (t.isIdentifier(expression)) {
+			const { name } = expression;
+			const { referencePaths = [] } = path.scope.getBinding(name) || {};
+			referencePaths.forEach((referencePath) => {
+				walksScope(referencePath, name, slotFlags_default.DYNAMIC);
+			});
+		}
+		return expression;
+	}
+	if (path.isJSXSpreadChild()) return transformJSXSpreadChild(path);
+	if (path.isCallExpression()) return path.node;
+	if (path.isJSXElement()) return transformJSXElement(path, state);
+	throw new Error(`getChildren: ${path.type} is not supported`);
+}).filter(((value) => value != null && !t.isJSXEmptyExpression(value)));
+const transformJSXElement = (path, state) => {
+	var _path$getData;
+	const children = getChildren(path.get("children"), state);
+	const { tag, props, isComponent, directives, patchFlag, dynamicPropNames, slots } = buildProps(path, state);
+	const { optimize = false } = state.opts;
+	if (directives.length && directives.some((d) => {
+		var _d$elements;
+		return ((_d$elements = d.elements) === null || _d$elements === void 0 || (_d$elements = _d$elements[0]) === null || _d$elements === void 0 ? void 0 : _d$elements.type) === "CallExpression" && d.elements[0].callee.type === "Identifier" && d.elements[0].callee.name === "_resolveDirective";
+	})) {
+		var _currentPath$parentPa;
+		let currentPath = path;
+		while ((_currentPath$parentPa = currentPath.parentPath) === null || _currentPath$parentPa === void 0 ? void 0 : _currentPath$parentPa.isJSXElement()) {
+			currentPath = currentPath.parentPath;
+			currentPath.setData("slotFlag", 0);
+		}
+	}
+	const slotFlag = (_path$getData = path.getData("slotFlag")) !== null && _path$getData !== void 0 ? _path$getData : slotFlags_default.STABLE;
+	const optimizeSlots = optimize && slotFlag !== 0;
+	let VNodeChild;
+	if (children.length > 1 || slots) VNodeChild = isComponent ? children.length ? t.objectExpression([
+		!!children.length && t.objectProperty(t.identifier("default"), t.arrowFunctionExpression([], t.arrayExpression(buildIIFE(path, children)))),
+		...slots ? t.isObjectExpression(slots) ? slots.properties : [t.spreadElement(slots)] : [],
+		optimizeSlots && t.objectProperty(t.identifier("_"), t.numericLiteral(slotFlag))
+	].filter(Boolean)) : slots : t.arrayExpression(children);
+	else if (children.length === 1) {
+		const { enableObjectSlots = true } = state.opts;
+		const child = children[0];
+		const objectExpression = t.objectExpression([t.objectProperty(t.identifier("default"), t.arrowFunctionExpression([], t.arrayExpression(buildIIFE(path, [child])))), optimizeSlots && t.objectProperty(t.identifier("_"), t.numericLiteral(slotFlag))].filter(Boolean));
+		if (t.isIdentifier(child) && isComponent) VNodeChild = enableObjectSlots ? t.conditionalExpression(t.callExpression(state.get("@vue/babel-plugin-jsx/runtimeIsSlot")(), [child]), child, objectExpression) : objectExpression;
+		else if (t.isCallExpression(child) && child.loc && isComponent) if (enableObjectSlots) {
+			const { scope } = path;
+			const slotId = scope.generateUidIdentifier("slot");
+			if (scope) scope.push({
+				id: slotId,
+				kind: "let"
+			});
+			const alternate = t.objectExpression([t.objectProperty(t.identifier("default"), t.arrowFunctionExpression([], t.arrayExpression(buildIIFE(path, [slotId])))), optimizeSlots && t.objectProperty(t.identifier("_"), t.numericLiteral(slotFlag))].filter(Boolean));
+			const assignment = t.assignmentExpression("=", slotId, child);
+			const condition = t.callExpression(state.get("@vue/babel-plugin-jsx/runtimeIsSlot")(), [assignment]);
+			VNodeChild = t.conditionalExpression(condition, slotId, alternate);
+		} else VNodeChild = objectExpression;
+		else if (t.isFunctionExpression(child) || t.isArrowFunctionExpression(child)) VNodeChild = t.objectExpression([t.objectProperty(t.identifier("default"), child)]);
+		else if (t.isObjectExpression(child)) VNodeChild = t.objectExpression([...child.properties, optimizeSlots && t.objectProperty(t.identifier("_"), t.numericLiteral(slotFlag))].filter(Boolean));
+		else VNodeChild = isComponent ? t.objectExpression([t.objectProperty(t.identifier("default"), t.arrowFunctionExpression([], t.arrayExpression([child])))]) : t.arrayExpression([child]);
+	}
+	const createVNode = t.callExpression(createIdentifier(state, "createVNode"), [
+		tag,
+		props,
+		VNodeChild || t.nullLiteral(),
+		!!patchFlag && optimize && t.numericLiteral(patchFlag),
+		!!dynamicPropNames.size && optimize && t.arrayExpression([...dynamicPropNames.keys()].map((name) => t.stringLiteral(name)))
+	].filter(Boolean));
+	if (!directives.length) return createVNode;
+	return t.callExpression(createIdentifier(state, "withDirectives"), [createVNode, t.arrayExpression(directives)]);
+};
+const visitor$1 = { JSXElement: { exit(path, state) {
+	path.replaceWith(transformJSXElement(path, state));
+} } };
+var transform_vue_jsx_default = visitor$1;
+
+//#endregion
+//#region src/sugar-fragment.ts
+const transformFragment = (path, Fragment) => {
+	const children = path.get("children") || [];
+	return t.jsxElement(t.jsxOpeningElement(Fragment, []), t.jsxClosingElement(Fragment), children.map(({ node }) => node), false);
+};
+const visitor = { JSXFragment: { enter(path, state) {
+	const fragmentCallee = createIdentifier(state, FRAGMENT);
+	path.replaceWith(transformFragment(path, t.isIdentifier(fragmentCallee) ? t.jsxIdentifier(fragmentCallee.name) : t.jsxMemberExpression(t.jsxIdentifier(fragmentCallee.object.name), t.jsxIdentifier(fragmentCallee.property.name))));
+} } };
+var sugar_fragment_default = visitor;
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/esm/toPrimitive.js
+function toPrimitive(t$1, r) {
+	if ("object" != _typeof(t$1) || !t$1) return t$1;
+	var e = t$1[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t$1, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t$1);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/esm/toPropertyKey.js
+function toPropertyKey(t$1) {
+	var i = toPrimitive(t$1, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t$1) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t$1,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t$1, e;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.80.0/node_modules/@oxc-project/runtime/src/helpers/esm/objectSpread2.js
+function ownKeys(e, r) {
+	var t$1 = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r$1) {
+			return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+		})), t$1.push.apply(t$1, o);
+	}
+	return t$1;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t$1 = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t$1), !0).forEach(function(r$1) {
+			_defineProperty(e, r$1, t$1[r$1]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t$1)) : ownKeys(Object(t$1)).forEach(function(r$1) {
+			Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t$1, r$1));
+		});
+	}
+	return e;
+}
+
+//#endregion
+//#region src/index.ts
+const hasJSX = (parentPath) => {
+	let fileHasJSX = false;
+	parentPath.traverse({
+		JSXElement(path) {
+			fileHasJSX = true;
+			path.stop();
+		},
+		JSXFragment(path) {
+			fileHasJSX = true;
+			path.stop();
+		}
+	});
+	return fileHasJSX;
+};
+const JSX_ANNOTATION_REGEX = new RegExp("\\*?\\s*@jsx\\s+([^\\s]+)", "");
+/* @__NO_SIDE_EFFECTS__ */
+function interopDefault(m) {
+	return m.default || m;
+}
+const syntaxJsx = /* @__PURE__ */ interopDefault(_syntaxJsx);
+const template = /* @__PURE__ */ interopDefault(_template);
+const plugin = declare((api, opt, dirname) => {
+	const { types } = api;
+	let resolveType;
+	if (opt.resolveType) {
+		if (typeof opt.resolveType === "boolean") opt.resolveType = {};
+		resolveType = ResolveType(api, opt.resolveType, dirname);
+	}
+	return _objectSpread2(_objectSpread2({}, resolveType || {}), {}, {
+		name: "babel-plugin-jsx",
+		inherits: /* @__PURE__ */ interopDefault(syntaxJsx),
+		visitor: _objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({}, resolveType === null || resolveType === void 0 ? void 0 : resolveType.visitor), transform_vue_jsx_default), sugar_fragment_default), {}, { Program: { enter(path, state) {
+			if (hasJSX(path)) {
+				const importNames = [
+					"createVNode",
+					"Fragment",
+					"resolveComponent",
+					"withDirectives",
+					"vShow",
+					"vModelSelect",
+					"vModelText",
+					"vModelCheckbox",
+					"vModelRadio",
+					"vModelText",
+					"vModelDynamic",
+					"resolveDirective",
+					"mergeProps",
+					"createTextVNode",
+					"isVNode"
+				];
+				if (isModule(path)) {
+					const importMap = {};
+					importNames.forEach((name) => {
+						state.set(name, () => {
+							if (importMap[name]) return types.cloneNode(importMap[name]);
+							const identifier = addNamed(path, name, "vue", { ensureLiveReference: true });
+							importMap[name] = identifier;
+							return identifier;
+						});
+					});
+					const { enableObjectSlots = true } = state.opts;
+					if (enableObjectSlots) state.set("@vue/babel-plugin-jsx/runtimeIsSlot", () => {
+						if (importMap.runtimeIsSlot) return importMap.runtimeIsSlot;
+						const { name: isVNodeName } = state.get("isVNode")();
+						const isSlot = path.scope.generateUidIdentifier("isSlot");
+						const ast = template.ast`
+                    function ${isSlot.name}(s) {
+                      return typeof s === 'function' || (Object.prototype.toString.call(s) === '[object Object]' && !${isVNodeName}(s));
+                    }
+                  `;
+						const lastImport = path.get("body").filter((p) => p.isImportDeclaration()).pop();
+						if (lastImport) lastImport.insertAfter(ast);
+						importMap.runtimeIsSlot = isSlot;
+						return isSlot;
+					});
+				} else {
+					let sourceName;
+					importNames.forEach((name) => {
+						state.set(name, () => {
+							if (!sourceName) sourceName = addNamespace(path, "vue", { ensureLiveReference: true });
+							return t.memberExpression(sourceName, t.identifier(name));
+						});
+					});
+					const helpers = {};
+					const { enableObjectSlots = true } = state.opts;
+					if (enableObjectSlots) state.set("@vue/babel-plugin-jsx/runtimeIsSlot", () => {
+						if (helpers.runtimeIsSlot) return helpers.runtimeIsSlot;
+						const isSlot = path.scope.generateUidIdentifier("isSlot");
+						const { object: objectName } = state.get("isVNode")();
+						const ast = template.ast`
+                    function ${isSlot.name}(s) {
+                      return typeof s === 'function' || (Object.prototype.toString.call(s) === '[object Object]' && !${objectName.name}.isVNode(s));
+                    }
+                  `;
+						const nodePaths = path.get("body");
+						const lastImport = nodePaths.filter((p) => p.isVariableDeclaration() && p.node.declarations.some((d) => {
+							var _d$id;
+							return ((_d$id = d.id) === null || _d$id === void 0 ? void 0 : _d$id.name) === sourceName.name;
+						})).pop();
+						if (lastImport) lastImport.insertAfter(ast);
+						return isSlot;
+					});
+				}
+				const { opts: { pragma = "" }, file } = state;
+				if (pragma) state.set("createVNode", () => t.identifier(pragma));
+				if (file.ast.comments) for (const comment of file.ast.comments) {
+					const jsxMatches = JSX_ANNOTATION_REGEX.exec(comment.value);
+					if (jsxMatches) state.set("createVNode", () => t.identifier(jsxMatches[1]));
+				}
+			}
+		} } })
+	});
+});
+var src_default = plugin;
+
+//#endregion
+export { src_default as default };

node_modules/@vue/babel-plugin-jsx/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@vue/babel-plugin-jsx",
+  "version": "1.5.0",
+  "description": "Babel plugin for Vue 3 JSX",
+  "author": "Amour1688 <lcz_1996@foxmail.com>",
+  "homepage": "https://github.com/vuejs/babel-plugin-jsx/tree/dev/packages/babel-plugin-jsx#readme",
+  "license": "MIT",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./*": "./*"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/babel-plugin-jsx.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vuejs/babel-plugin-jsx/issues"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@babel/helper-module-imports": "^7.27.1",
+    "@babel/helper-plugin-utils": "^7.27.1",
+    "@babel/plugin-syntax-jsx": "^7.27.1",
+    "@babel/template": "^7.27.2",
+    "@babel/traverse": "^7.28.0",
+    "@babel/types": "^7.28.2",
+    "@vue/shared": "^3.5.18",
+    "@vue/babel-helper-vue-transform-on": "1.5.0",
+    "@vue/babel-plugin-resolve-type": "1.5.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.0",
+    "@babel/preset-env": "^7.28.0",
+    "@types/babel__template": "^7.4.4",
+    "@types/babel__traverse": "^7.28.0",
+    "@vue/test-utils": "^2.4.6",
+    "regenerator-runtime": "^0.14.1",
+    "vue": "^3.5.18"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "peerDependenciesMeta": {
+    "@babel/core": {
+      "optional": true
+    }
+  }
+}

node_modules/@vue/babel-plugin-resolve-type/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-present vuejs
+
+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.

node_modules/@vue/babel-plugin-resolve-type/README.md

@@ -0,0 +1 @@
+# babel-plugin-resolve-type

node_modules/@vue/babel-plugin-resolve-type/dist/index.d.mts

@@ -0,0 +1,7 @@
+import { SimpleTypeResolveOptions } from "@vue/compiler-sfc";
+import * as BabelCore from "@babel/core";
+
+//#region src/index.d.ts
+declare const plugin: (api: object, options: SimpleTypeResolveOptions | null | undefined, dirname: string) => BabelCore.PluginObj<BabelCore.PluginPass>;
+//#endregion
+export { SimpleTypeResolveOptions as Options, plugin as default };

node_modules/@vue/babel-plugin-resolve-type/dist/index.d.ts

@@ -0,0 +1,7 @@
+import * as BabelCore from "@babel/core";
+import { SimpleTypeResolveOptions } from "@vue/compiler-sfc";
+
+//#region src/index.d.ts
+declare const plugin: (api: object, options: SimpleTypeResolveOptions | null | undefined, dirname: string) => BabelCore.PluginObj<BabelCore.PluginPass>;
+//#endregion
+export { SimpleTypeResolveOptions as Options, plugin as default };

node_modules/@vue/babel-plugin-resolve-type/dist/index.js

@@ -0,0 +1,196 @@
+//#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
+const __babel_parser = __toESM(require("@babel/parser"));
+const __vue_compiler_sfc = __toESM(require("@vue/compiler-sfc"));
+const __babel_code_frame = __toESM(require("@babel/code-frame"));
+const __babel_helper_module_imports = __toESM(require("@babel/helper-module-imports"));
+const __babel_helper_plugin_utils = __toESM(require("@babel/helper-plugin-utils"));
+
+//#region src/index.ts
+const plugin = (0, __babel_helper_plugin_utils.declare)(({ types: t }, options) => {
+	let ctx;
+	let helpers;
+	return {
+		name: "babel-plugin-resolve-type",
+		pre(file) {
+			const filename = file.opts.filename || "unknown.js";
+			helpers = /* @__PURE__ */ new Set();
+			ctx = {
+				filename,
+				source: file.code,
+				options,
+				ast: file.ast.program.body,
+				isCE: false,
+				error(msg, node) {
+					throw new Error(`[@vue/babel-plugin-resolve-type] ${msg}\n\n${filename}\n${(0, __babel_code_frame.codeFrameColumns)(file.code, {
+						start: {
+							line: node.loc.start.line,
+							column: node.loc.start.column + 1
+						},
+						end: {
+							line: node.loc.end.line,
+							column: node.loc.end.column + 1
+						}
+					})}`);
+				},
+				helper(key) {
+					helpers.add(key);
+					return `_${key}`;
+				},
+				getString(node) {
+					return file.code.slice(node.start, node.end);
+				},
+				propsTypeDecl: void 0,
+				propsRuntimeDefaults: void 0,
+				propsDestructuredBindings: {},
+				emitsTypeDecl: void 0
+			};
+		},
+		visitor: {
+			CallExpression(path) {
+				if (!ctx) throw new Error("[@vue/babel-plugin-resolve-type] context is not loaded.");
+				const { node } = path;
+				if (!t.isIdentifier(node.callee, { name: "defineComponent" })) return;
+				if (!checkDefineComponent(path)) return;
+				const comp = node.arguments[0];
+				if (!comp || !t.isFunction(comp)) return;
+				let options$1 = node.arguments[1];
+				if (!options$1) {
+					options$1 = t.objectExpression([]);
+					node.arguments.push(options$1);
+				}
+				let propsGenerics;
+				let emitsGenerics;
+				if (node.typeParameters && node.typeParameters.params.length > 0) {
+					propsGenerics = node.typeParameters.params[0];
+					emitsGenerics = node.typeParameters.params[1];
+				}
+				node.arguments[1] = processProps(comp, propsGenerics, options$1) || options$1;
+				node.arguments[1] = processEmits(comp, emitsGenerics, node.arguments[1]) || options$1;
+			},
+			VariableDeclarator(path) {
+				inferComponentName(path);
+			}
+		},
+		post(file) {
+			for (const helper of helpers) (0, __babel_helper_module_imports.addNamed)(file.path, `_${helper}`, "vue");
+		}
+	};
+	function inferComponentName(path) {
+		var _init$get;
+		const id = path.get("id");
+		const init = path.get("init");
+		if (!id || !id.isIdentifier() || !init || !init.isCallExpression()) return;
+		if (!((_init$get = init.get("callee")) === null || _init$get === void 0 ? void 0 : _init$get.isIdentifier({ name: "defineComponent" }))) return;
+		if (!checkDefineComponent(init)) return;
+		const nameProperty = t.objectProperty(t.identifier("name"), t.stringLiteral(id.node.name));
+		const { arguments: args } = init.node;
+		if (args.length === 0) return;
+		if (args.length === 1) init.node.arguments.push(t.objectExpression([]));
+		args[1] = addProperty(t, args[1], nameProperty);
+	}
+	function processProps(comp, generics, options$1) {
+		const props = comp.params[0];
+		if (!props) return;
+		if (props.type === "AssignmentPattern") {
+			if (generics) ctx.propsTypeDecl = resolveTypeReference(generics);
+			else ctx.propsTypeDecl = getTypeAnnotation(props.left);
+			ctx.propsRuntimeDefaults = props.right;
+		} else if (generics) ctx.propsTypeDecl = resolveTypeReference(generics);
+		else ctx.propsTypeDecl = getTypeAnnotation(props);
+		if (!ctx.propsTypeDecl) return;
+		const runtimeProps = (0, __vue_compiler_sfc.extractRuntimeProps)(ctx);
+		if (!runtimeProps) return;
+		const ast = (0, __babel_parser.parseExpression)(runtimeProps);
+		return addProperty(t, options$1, t.objectProperty(t.identifier("props"), ast));
+	}
+	function processEmits(comp, generics, options$1) {
+		let emitType;
+		if (generics) emitType = resolveTypeReference(generics);
+		const setupCtx = comp.params[1] && getTypeAnnotation(comp.params[1]);
+		if (!emitType && setupCtx && t.isTSTypeReference(setupCtx) && t.isIdentifier(setupCtx.typeName, { name: "SetupContext" })) {
+			var _setupCtx$typeParamet;
+			emitType = (_setupCtx$typeParamet = setupCtx.typeParameters) === null || _setupCtx$typeParamet === void 0 ? void 0 : _setupCtx$typeParamet.params[0];
+		}
+		if (!emitType) return;
+		ctx.emitsTypeDecl = emitType;
+		const runtimeEmits = (0, __vue_compiler_sfc.extractRuntimeEmits)(ctx);
+		const ast = t.arrayExpression(Array.from(runtimeEmits).map((e) => t.stringLiteral(e)));
+		return addProperty(t, options$1, t.objectProperty(t.identifier("emits"), ast));
+	}
+	function resolveTypeReference(typeNode) {
+		if (!ctx) return;
+		if (t.isTSTypeReference(typeNode)) {
+			const typeName = getTypeReferenceName(typeNode);
+			if (typeName) {
+				const typeDeclaration = findTypeDeclaration(typeName);
+				if (typeDeclaration) return typeDeclaration;
+			}
+		}
+	}
+	function getTypeReferenceName(typeRef) {
+		if (t.isIdentifier(typeRef.typeName)) return typeRef.typeName.name;
+		else if (t.isTSQualifiedName(typeRef.typeName)) {
+			const parts = [];
+			let current = typeRef.typeName;
+			while (t.isTSQualifiedName(current)) {
+				if (t.isIdentifier(current.right)) parts.unshift(current.right.name);
+				current = current.left;
+			}
+			if (t.isIdentifier(current)) parts.unshift(current.name);
+			return parts.join(".");
+		}
+		return null;
+	}
+	function findTypeDeclaration(typeName) {
+		if (!ctx) return null;
+		for (const statement of ctx.ast) {
+			if (t.isTSInterfaceDeclaration(statement) && statement.id.name === typeName) return t.tsTypeLiteral(statement.body.body);
+			if (t.isTSTypeAliasDeclaration(statement) && statement.id.name === typeName) return statement.typeAnnotation;
+			if (t.isExportNamedDeclaration(statement) && statement.declaration) {
+				if (t.isTSInterfaceDeclaration(statement.declaration) && statement.declaration.id.name === typeName) return t.tsTypeLiteral(statement.declaration.body.body);
+				if (t.isTSTypeAliasDeclaration(statement.declaration) && statement.declaration.id.name === typeName) return statement.declaration.typeAnnotation;
+			}
+		}
+		return null;
+	}
+});
+var src_default = plugin;
+function getTypeAnnotation(node) {
+	if ("typeAnnotation" in node && node.typeAnnotation && node.typeAnnotation.type === "TSTypeAnnotation") return node.typeAnnotation.typeAnnotation;
+}
+function checkDefineComponent(path) {
+	var _path$scope$getBindin;
+	const defineCompImport = (_path$scope$getBindin = path.scope.getBinding("defineComponent")) === null || _path$scope$getBindin === void 0 ? void 0 : _path$scope$getBindin.path.parent;
+	if (!defineCompImport) return true;
+	return defineCompImport.type === "ImportDeclaration" && new RegExp("^@?vue(\\/|$)", "").test(defineCompImport.source.value);
+}
+function addProperty(t, object, property) {
+	if (t.isObjectExpression(object)) object.properties.unshift(property);
+	else if (t.isExpression(object)) return t.objectExpression([property, t.spreadElement(object)]);
+	return object;
+}
+
+//#endregion
+module.exports = src_default;

node_modules/@vue/babel-plugin-resolve-type/dist/index.mjs

@@ -0,0 +1,173 @@
+import { parseExpression } from "@babel/parser";
+import { extractRuntimeEmits, extractRuntimeProps } from "@vue/compiler-sfc";
+import { codeFrameColumns } from "@babel/code-frame";
+import { addNamed } from "@babel/helper-module-imports";
+import { declare } from "@babel/helper-plugin-utils";
+
+//#region src/index.ts
+const plugin = declare(({ types: t }, options) => {
+	let ctx;
+	let helpers;
+	return {
+		name: "babel-plugin-resolve-type",
+		pre(file) {
+			const filename = file.opts.filename || "unknown.js";
+			helpers = /* @__PURE__ */ new Set();
+			ctx = {
+				filename,
+				source: file.code,
+				options,
+				ast: file.ast.program.body,
+				isCE: false,
+				error(msg, node) {
+					throw new Error(`[@vue/babel-plugin-resolve-type] ${msg}\n\n${filename}\n${codeFrameColumns(file.code, {
+						start: {
+							line: node.loc.start.line,
+							column: node.loc.start.column + 1
+						},
+						end: {
+							line: node.loc.end.line,
+							column: node.loc.end.column + 1
+						}
+					})}`);
+				},
+				helper(key) {
+					helpers.add(key);
+					return `_${key}`;
+				},
+				getString(node) {
+					return file.code.slice(node.start, node.end);
+				},
+				propsTypeDecl: void 0,
+				propsRuntimeDefaults: void 0,
+				propsDestructuredBindings: {},
+				emitsTypeDecl: void 0
+			};
+		},
+		visitor: {
+			CallExpression(path) {
+				if (!ctx) throw new Error("[@vue/babel-plugin-resolve-type] context is not loaded.");
+				const { node } = path;
+				if (!t.isIdentifier(node.callee, { name: "defineComponent" })) return;
+				if (!checkDefineComponent(path)) return;
+				const comp = node.arguments[0];
+				if (!comp || !t.isFunction(comp)) return;
+				let options$1 = node.arguments[1];
+				if (!options$1) {
+					options$1 = t.objectExpression([]);
+					node.arguments.push(options$1);
+				}
+				let propsGenerics;
+				let emitsGenerics;
+				if (node.typeParameters && node.typeParameters.params.length > 0) {
+					propsGenerics = node.typeParameters.params[0];
+					emitsGenerics = node.typeParameters.params[1];
+				}
+				node.arguments[1] = processProps(comp, propsGenerics, options$1) || options$1;
+				node.arguments[1] = processEmits(comp, emitsGenerics, node.arguments[1]) || options$1;
+			},
+			VariableDeclarator(path) {
+				inferComponentName(path);
+			}
+		},
+		post(file) {
+			for (const helper of helpers) addNamed(file.path, `_${helper}`, "vue");
+		}
+	};
+	function inferComponentName(path) {
+		var _init$get;
+		const id = path.get("id");
+		const init = path.get("init");
+		if (!id || !id.isIdentifier() || !init || !init.isCallExpression()) return;
+		if (!((_init$get = init.get("callee")) === null || _init$get === void 0 ? void 0 : _init$get.isIdentifier({ name: "defineComponent" }))) return;
+		if (!checkDefineComponent(init)) return;
+		const nameProperty = t.objectProperty(t.identifier("name"), t.stringLiteral(id.node.name));
+		const { arguments: args } = init.node;
+		if (args.length === 0) return;
+		if (args.length === 1) init.node.arguments.push(t.objectExpression([]));
+		args[1] = addProperty(t, args[1], nameProperty);
+	}
+	function processProps(comp, generics, options$1) {
+		const props = comp.params[0];
+		if (!props) return;
+		if (props.type === "AssignmentPattern") {
+			if (generics) ctx.propsTypeDecl = resolveTypeReference(generics);
+			else ctx.propsTypeDecl = getTypeAnnotation(props.left);
+			ctx.propsRuntimeDefaults = props.right;
+		} else if (generics) ctx.propsTypeDecl = resolveTypeReference(generics);
+		else ctx.propsTypeDecl = getTypeAnnotation(props);
+		if (!ctx.propsTypeDecl) return;
+		const runtimeProps = extractRuntimeProps(ctx);
+		if (!runtimeProps) return;
+		const ast = parseExpression(runtimeProps);
+		return addProperty(t, options$1, t.objectProperty(t.identifier("props"), ast));
+	}
+	function processEmits(comp, generics, options$1) {
+		let emitType;
+		if (generics) emitType = resolveTypeReference(generics);
+		const setupCtx = comp.params[1] && getTypeAnnotation(comp.params[1]);
+		if (!emitType && setupCtx && t.isTSTypeReference(setupCtx) && t.isIdentifier(setupCtx.typeName, { name: "SetupContext" })) {
+			var _setupCtx$typeParamet;
+			emitType = (_setupCtx$typeParamet = setupCtx.typeParameters) === null || _setupCtx$typeParamet === void 0 ? void 0 : _setupCtx$typeParamet.params[0];
+		}
+		if (!emitType) return;
+		ctx.emitsTypeDecl = emitType;
+		const runtimeEmits = extractRuntimeEmits(ctx);
+		const ast = t.arrayExpression(Array.from(runtimeEmits).map((e) => t.stringLiteral(e)));
+		return addProperty(t, options$1, t.objectProperty(t.identifier("emits"), ast));
+	}
+	function resolveTypeReference(typeNode) {
+		if (!ctx) return;
+		if (t.isTSTypeReference(typeNode)) {
+			const typeName = getTypeReferenceName(typeNode);
+			if (typeName) {
+				const typeDeclaration = findTypeDeclaration(typeName);
+				if (typeDeclaration) return typeDeclaration;
+			}
+		}
+	}
+	function getTypeReferenceName(typeRef) {
+		if (t.isIdentifier(typeRef.typeName)) return typeRef.typeName.name;
+		else if (t.isTSQualifiedName(typeRef.typeName)) {
+			const parts = [];
+			let current = typeRef.typeName;
+			while (t.isTSQualifiedName(current)) {
+				if (t.isIdentifier(current.right)) parts.unshift(current.right.name);
+				current = current.left;
+			}
+			if (t.isIdentifier(current)) parts.unshift(current.name);
+			return parts.join(".");
+		}
+		return null;
+	}
+	function findTypeDeclaration(typeName) {
+		if (!ctx) return null;
+		for (const statement of ctx.ast) {
+			if (t.isTSInterfaceDeclaration(statement) && statement.id.name === typeName) return t.tsTypeLiteral(statement.body.body);
+			if (t.isTSTypeAliasDeclaration(statement) && statement.id.name === typeName) return statement.typeAnnotation;
+			if (t.isExportNamedDeclaration(statement) && statement.declaration) {
+				if (t.isTSInterfaceDeclaration(statement.declaration) && statement.declaration.id.name === typeName) return t.tsTypeLiteral(statement.declaration.body.body);
+				if (t.isTSTypeAliasDeclaration(statement.declaration) && statement.declaration.id.name === typeName) return statement.declaration.typeAnnotation;
+			}
+		}
+		return null;
+	}
+});
+var src_default = plugin;
+function getTypeAnnotation(node) {
+	if ("typeAnnotation" in node && node.typeAnnotation && node.typeAnnotation.type === "TSTypeAnnotation") return node.typeAnnotation.typeAnnotation;
+}
+function checkDefineComponent(path) {
+	var _path$scope$getBindin;
+	const defineCompImport = (_path$scope$getBindin = path.scope.getBinding("defineComponent")) === null || _path$scope$getBindin === void 0 ? void 0 : _path$scope$getBindin.path.parent;
+	if (!defineCompImport) return true;
+	return defineCompImport.type === "ImportDeclaration" && new RegExp("^@?vue(\\/|$)", "").test(defineCompImport.source.value);
+}
+function addProperty(t, object, property) {
+	if (t.isObjectExpression(object)) object.properties.unshift(property);
+	else if (t.isExpression(object)) return t.objectExpression([property, t.spreadElement(object)]);
+	return object;
+}
+
+//#endregion
+export { src_default as default };

node_modules/@vue/babel-plugin-resolve-type/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@vue/babel-plugin-resolve-type",
+  "version": "1.5.0",
+  "description": "Babel plugin for resolving Vue types.",
+  "author": "三咲智子 Kevin Deng <sxzz@sxzz.moe>",
+  "funding": "https://github.com/sponsors/sxzz",
+  "homepage": "https://github.com/vuejs/babel-plugin-jsx/tree/dev/packages/babel-plugin-resolve-type#readme",
+  "license": "MIT",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/babel-plugin-jsx.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vuejs/babel-plugin-jsx/issues"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "dependencies": {
+    "@babel/code-frame": "^7.27.1",
+    "@babel/helper-module-imports": "^7.27.1",
+    "@babel/helper-plugin-utils": "^7.27.1",
+    "@babel/parser": "^7.28.0",
+    "@vue/compiler-sfc": "^3.5.18"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.0",
+    "@types/babel__code-frame": "^7.0.6",
+    "vue": "^3.5.18"
+  }
+}

node_modules/@vue/compiler-core/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present, Yuxi (Evan) You
+
+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.

node_modules/@vue/compiler-core/README.md

@@ -0,0 +1 @@
+# @vue/compiler-core

node_modules/@vue/compiler-core/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/compiler-core.cjs.prod.js')
+} else {
+  module.exports = require('./dist/compiler-core.cjs.js')
+}

node_modules/@vue/compiler-core/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@vue/compiler-core",
+  "version": "3.5.22",
+  "description": "@vue/compiler-core",
+  "main": "index.js",
+  "module": "dist/compiler-core.esm-bundler.js",
+  "types": "dist/compiler-core.d.ts",
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/compiler-core.d.ts",
+      "node": {
+        "production": "./dist/compiler-core.cjs.prod.js",
+        "development": "./dist/compiler-core.cjs.js",
+        "default": "./index.js"
+      },
+      "module": "./dist/compiler-core.esm-bundler.js",
+      "import": "./dist/compiler-core.esm-bundler.js",
+      "require": "./index.js"
+    },
+    "./*": "./*"
+  },
+  "buildOptions": {
+    "name": "VueCompilerCore",
+    "compat": true,
+    "formats": [
+      "esm-bundler",
+      "cjs"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/compiler-core"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-core#readme",
+  "dependencies": {
+    "@babel/parser": "^7.28.4",
+    "entities": "^4.5.0",
+    "estree-walker": "^2.0.2",
+    "source-map-js": "^1.2.1",
+    "@vue/shared": "3.5.22"
+  },
+  "devDependencies": {
+    "@babel/types": "^7.28.4"
+  }
+}

node_modules/@vue/compiler-dom/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present, Yuxi (Evan) You
+
+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.

node_modules/@vue/compiler-dom/README.md

@@ -0,0 +1 @@
+# @vue/compiler-dom

node_modules/@vue/compiler-dom/dist/compiler-dom.cjs.js

@@ -0,0 +1,934 @@
+/**
+* @vue/compiler-dom v3.5.22
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compilerCore = require('@vue/compiler-core');
+var shared = require('@vue/shared');
+
+const V_MODEL_RADIO = Symbol(`vModelRadio` );
+const V_MODEL_CHECKBOX = Symbol(
+  `vModelCheckbox` 
+);
+const V_MODEL_TEXT = Symbol(`vModelText` );
+const V_MODEL_SELECT = Symbol(
+  `vModelSelect` 
+);
+const V_MODEL_DYNAMIC = Symbol(
+  `vModelDynamic` 
+);
+const V_ON_WITH_MODIFIERS = Symbol(
+  `vOnModifiersGuard` 
+);
+const V_ON_WITH_KEYS = Symbol(
+  `vOnKeysGuard` 
+);
+const V_SHOW = Symbol(`vShow` );
+const TRANSITION = Symbol(`Transition` );
+const TRANSITION_GROUP = Symbol(
+  `TransitionGroup` 
+);
+compilerCore.registerRuntimeHelpers({
+  [V_MODEL_RADIO]: `vModelRadio`,
+  [V_MODEL_CHECKBOX]: `vModelCheckbox`,
+  [V_MODEL_TEXT]: `vModelText`,
+  [V_MODEL_SELECT]: `vModelSelect`,
+  [V_MODEL_DYNAMIC]: `vModelDynamic`,
+  [V_ON_WITH_MODIFIERS]: `withModifiers`,
+  [V_ON_WITH_KEYS]: `withKeys`,
+  [V_SHOW]: `vShow`,
+  [TRANSITION]: `Transition`,
+  [TRANSITION_GROUP]: `TransitionGroup`
+});
+
+const parserOptions = {
+  parseMode: "html",
+  isVoidTag: shared.isVoidTag,
+  isNativeTag: (tag) => shared.isHTMLTag(tag) || shared.isSVGTag(tag) || shared.isMathMLTag(tag),
+  isPreTag: (tag) => tag === "pre",
+  isIgnoreNewlineTag: (tag) => tag === "pre" || tag === "textarea",
+  decodeEntities: void 0,
+  isBuiltInComponent: (tag) => {
+    if (tag === "Transition" || tag === "transition") {
+      return TRANSITION;
+    } else if (tag === "TransitionGroup" || tag === "transition-group") {
+      return TRANSITION_GROUP;
+    }
+  },
+  // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
+  getNamespace(tag, parent, rootNamespace) {
+    let ns = parent ? parent.ns : rootNamespace;
+    if (parent && ns === 2) {
+      if (parent.tag === "annotation-xml") {
+        if (tag === "svg") {
+          return 1;
+        }
+        if (parent.props.some(
+          (a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml")
+        )) {
+          ns = 0;
+        }
+      } else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") {
+        ns = 0;
+      }
+    } else if (parent && ns === 1) {
+      if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") {
+        ns = 0;
+      }
+    }
+    if (ns === 0) {
+      if (tag === "svg") {
+        return 1;
+      }
+      if (tag === "math") {
+        return 2;
+      }
+    }
+    return ns;
+  }
+};
+
+const transformStyle = (node) => {
+  if (node.type === 1) {
+    node.props.forEach((p, i) => {
+      if (p.type === 6 && p.name === "style" && p.value) {
+        node.props[i] = {
+          type: 7,
+          name: `bind`,
+          arg: compilerCore.createSimpleExpression(`style`, true, p.loc),
+          exp: parseInlineCSS(p.value.content, p.loc),
+          modifiers: [],
+          loc: p.loc
+        };
+      }
+    });
+  }
+};
+const parseInlineCSS = (cssText, loc) => {
+  const normalized = shared.parseStringStyle(cssText);
+  return compilerCore.createSimpleExpression(
+    JSON.stringify(normalized),
+    false,
+    loc,
+    3
+  );
+};
+
+function createDOMCompilerError(code, loc) {
+  return compilerCore.createCompilerError(
+    code,
+    loc,
+    DOMErrorMessages 
+  );
+}
+const DOMErrorCodes = {
+  "X_V_HTML_NO_EXPRESSION": 53,
+  "53": "X_V_HTML_NO_EXPRESSION",
+  "X_V_HTML_WITH_CHILDREN": 54,
+  "54": "X_V_HTML_WITH_CHILDREN",
+  "X_V_TEXT_NO_EXPRESSION": 55,
+  "55": "X_V_TEXT_NO_EXPRESSION",
+  "X_V_TEXT_WITH_CHILDREN": 56,
+  "56": "X_V_TEXT_WITH_CHILDREN",
+  "X_V_MODEL_ON_INVALID_ELEMENT": 57,
+  "57": "X_V_MODEL_ON_INVALID_ELEMENT",
+  "X_V_MODEL_ARG_ON_ELEMENT": 58,
+  "58": "X_V_MODEL_ARG_ON_ELEMENT",
+  "X_V_MODEL_ON_FILE_INPUT_ELEMENT": 59,
+  "59": "X_V_MODEL_ON_FILE_INPUT_ELEMENT",
+  "X_V_MODEL_UNNECESSARY_VALUE": 60,
+  "60": "X_V_MODEL_UNNECESSARY_VALUE",
+  "X_V_SHOW_NO_EXPRESSION": 61,
+  "61": "X_V_SHOW_NO_EXPRESSION",
+  "X_TRANSITION_INVALID_CHILDREN": 62,
+  "62": "X_TRANSITION_INVALID_CHILDREN",
+  "X_IGNORED_SIDE_EFFECT_TAG": 63,
+  "63": "X_IGNORED_SIDE_EFFECT_TAG",
+  "__EXTEND_POINT__": 64,
+  "64": "__EXTEND_POINT__"
+};
+const DOMErrorMessages = {
+  [53]: `v-html is missing expression.`,
+  [54]: `v-html will override element children.`,
+  [55]: `v-text is missing expression.`,
+  [56]: `v-text will override element children.`,
+  [57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
+  [58]: `v-model argument is not supported on plain elements.`,
+  [59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+  [60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
+  [61]: `v-show is missing expression.`,
+  [62]: `<Transition> expects exactly one child element or component.`,
+  [63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
+};
+
+const transformVHtml = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(53, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(54, loc)
+    );
+    node.children.length = 0;
+  }
+  return {
+    props: [
+      compilerCore.createObjectProperty(
+        compilerCore.createSimpleExpression(`innerHTML`, true, loc),
+        exp || compilerCore.createSimpleExpression("", true)
+      )
+    ]
+  };
+};
+
+const transformVText = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(55, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(56, loc)
+    );
+    node.children.length = 0;
+  }
+  return {
+    props: [
+      compilerCore.createObjectProperty(
+        compilerCore.createSimpleExpression(`textContent`, true),
+        exp ? compilerCore.getConstantType(exp, context) > 0 ? exp : compilerCore.createCallExpression(
+          context.helperString(compilerCore.TO_DISPLAY_STRING),
+          [exp],
+          loc
+        ) : compilerCore.createSimpleExpression("", true)
+      )
+    ]
+  };
+};
+
+const transformModel = (dir, node, context) => {
+  const baseResult = compilerCore.transformModel(dir, node, context);
+  if (!baseResult.props.length || node.tagType === 1) {
+    return baseResult;
+  }
+  if (dir.arg) {
+    context.onError(
+      createDOMCompilerError(
+        58,
+        dir.arg.loc
+      )
+    );
+  }
+  function checkDuplicatedValue() {
+    const value = compilerCore.findDir(node, "bind");
+    if (value && compilerCore.isStaticArgOf(value.arg, "value")) {
+      context.onError(
+        createDOMCompilerError(
+          60,
+          value.loc
+        )
+      );
+    }
+  }
+  const { tag } = node;
+  const isCustomElement = context.isCustomElement(tag);
+  if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
+    let directiveToUse = V_MODEL_TEXT;
+    let isInvalidType = false;
+    if (tag === "input" || isCustomElement) {
+      const type = compilerCore.findProp(node, `type`);
+      if (type) {
+        if (type.type === 7) {
+          directiveToUse = V_MODEL_DYNAMIC;
+        } else if (type.value) {
+          switch (type.value.content) {
+            case "radio":
+              directiveToUse = V_MODEL_RADIO;
+              break;
+            case "checkbox":
+              directiveToUse = V_MODEL_CHECKBOX;
+              break;
+            case "file":
+              isInvalidType = true;
+              context.onError(
+                createDOMCompilerError(
+                  59,
+                  dir.loc
+                )
+              );
+              break;
+            default:
+              checkDuplicatedValue();
+              break;
+          }
+        }
+      } else if (compilerCore.hasDynamicKeyVBind(node)) {
+        directiveToUse = V_MODEL_DYNAMIC;
+      } else {
+        checkDuplicatedValue();
+      }
+    } else if (tag === "select") {
+      directiveToUse = V_MODEL_SELECT;
+    } else {
+      checkDuplicatedValue();
+    }
+    if (!isInvalidType) {
+      baseResult.needRuntime = context.helper(directiveToUse);
+    }
+  } else {
+    context.onError(
+      createDOMCompilerError(
+        57,
+        dir.loc
+      )
+    );
+  }
+  baseResult.props = baseResult.props.filter(
+    (p) => !(p.key.type === 4 && p.key.content === "modelValue")
+  );
+  return baseResult;
+};
+
+const isEventOptionModifier = /* @__PURE__ */ shared.makeMap(`passive,once,capture`);
+const isNonKeyModifier = /* @__PURE__ */ shared.makeMap(
+  // event propagation management
+  `stop,prevent,self,ctrl,shift,alt,meta,exact,middle`
+);
+const maybeKeyModifier = /* @__PURE__ */ shared.makeMap("left,right");
+const isKeyboardEvent = /* @__PURE__ */ shared.makeMap(`onkeyup,onkeydown,onkeypress`);
+const resolveModifiers = (key, modifiers, context, loc) => {
+  const keyModifiers = [];
+  const nonKeyModifiers = [];
+  const eventOptionModifiers = [];
+  for (let i = 0; i < modifiers.length; i++) {
+    const modifier = modifiers[i].content;
+    if (modifier === "native" && compilerCore.checkCompatEnabled(
+      "COMPILER_V_ON_NATIVE",
+      context,
+      loc
+    )) {
+      eventOptionModifiers.push(modifier);
+    } else if (isEventOptionModifier(modifier)) {
+      eventOptionModifiers.push(modifier);
+    } else {
+      if (maybeKeyModifier(modifier)) {
+        if (compilerCore.isStaticExp(key)) {
+          if (isKeyboardEvent(key.content.toLowerCase())) {
+            keyModifiers.push(modifier);
+          } else {
+            nonKeyModifiers.push(modifier);
+          }
+        } else {
+          keyModifiers.push(modifier);
+          nonKeyModifiers.push(modifier);
+        }
+      } else {
+        if (isNonKeyModifier(modifier)) {
+          nonKeyModifiers.push(modifier);
+        } else {
+          keyModifiers.push(modifier);
+        }
+      }
+    }
+  }
+  return {
+    keyModifiers,
+    nonKeyModifiers,
+    eventOptionModifiers
+  };
+};
+const transformClick = (key, event) => {
+  const isStaticClick = compilerCore.isStaticExp(key) && key.content.toLowerCase() === "onclick";
+  return isStaticClick ? compilerCore.createSimpleExpression(event, true) : key.type !== 4 ? compilerCore.createCompoundExpression([
+    `(`,
+    key,
+    `) === "onClick" ? "${event}" : (`,
+    key,
+    `)`
+  ]) : key;
+};
+const transformOn = (dir, node, context) => {
+  return compilerCore.transformOn(dir, node, context, (baseResult) => {
+    const { modifiers } = dir;
+    if (!modifiers.length) return baseResult;
+    let { key, value: handlerExp } = baseResult.props[0];
+    const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
+    if (nonKeyModifiers.includes("right")) {
+      key = transformClick(key, `onContextmenu`);
+    }
+    if (nonKeyModifiers.includes("middle")) {
+      key = transformClick(key, `onMouseup`);
+    }
+    if (nonKeyModifiers.length) {
+      handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [
+        handlerExp,
+        JSON.stringify(nonKeyModifiers)
+      ]);
+    }
+    if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard
+    (!compilerCore.isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) {
+      handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_KEYS), [
+        handlerExp,
+        JSON.stringify(keyModifiers)
+      ]);
+    }
+    if (eventOptionModifiers.length) {
+      const modifierPostfix = eventOptionModifiers.map(shared.capitalize).join("");
+      key = compilerCore.isStaticExp(key) ? compilerCore.createSimpleExpression(`${key.content}${modifierPostfix}`, true) : compilerCore.createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
+    }
+    return {
+      props: [compilerCore.createObjectProperty(key, handlerExp)]
+    };
+  });
+};
+
+const transformShow = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(61, loc)
+    );
+  }
+  return {
+    props: [],
+    needRuntime: context.helper(V_SHOW)
+  };
+};
+
+const transformTransition = (node, context) => {
+  if (node.type === 1 && node.tagType === 1) {
+    const component = context.isBuiltInComponent(node.tag);
+    if (component === TRANSITION) {
+      return () => {
+        if (!node.children.length) {
+          return;
+        }
+        if (hasMultipleChildren(node)) {
+          context.onError(
+            createDOMCompilerError(
+              62,
+              {
+                start: node.children[0].loc.start,
+                end: node.children[node.children.length - 1].loc.end,
+                source: ""
+              }
+            )
+          );
+        }
+        const child = node.children[0];
+        if (child.type === 1) {
+          for (const p of child.props) {
+            if (p.type === 7 && p.name === "show") {
+              node.props.push({
+                type: 6,
+                name: "persisted",
+                nameLoc: node.loc,
+                value: void 0,
+                loc: node.loc
+              });
+            }
+          }
+        }
+      };
+    }
+  }
+};
+function hasMultipleChildren(node) {
+  const children = node.children = node.children.filter(
+    (c) => c.type !== 3 && !(c.type === 2 && !c.content.trim())
+  );
+  const child = children[0];
+  return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(hasMultipleChildren);
+}
+
+const expReplaceRE = /__VUE_EXP_START__(.*?)__VUE_EXP_END__/g;
+const stringifyStatic = (children, context, parent) => {
+  if (context.scopes.vSlot > 0) {
+    return;
+  }
+  const isParentCached = parent.type === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared.isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 20;
+  let nc = 0;
+  let ec = 0;
+  const currentChunk = [];
+  const stringifyCurrentChunk = (currentIndex) => {
+    if (nc >= 20 || ec >= 5) {
+      const staticCall = compilerCore.createCallExpression(context.helper(compilerCore.CREATE_STATIC), [
+        JSON.stringify(
+          currentChunk.map((node) => stringifyNode(node, context)).join("")
+        ).replace(expReplaceRE, `" + $1 + "`),
+        // the 2nd argument indicates the number of DOM nodes this static vnode
+        // will insert / hydrate
+        String(currentChunk.length)
+      ]);
+      const deleteCount = currentChunk.length - 1;
+      if (isParentCached) {
+        children.splice(
+          currentIndex - currentChunk.length,
+          currentChunk.length,
+          // @ts-expect-error
+          staticCall
+        );
+      } else {
+        currentChunk[0].codegenNode.value = staticCall;
+        if (currentChunk.length > 1) {
+          children.splice(currentIndex - currentChunk.length + 1, deleteCount);
+          const cacheIndex = context.cached.indexOf(
+            currentChunk[currentChunk.length - 1].codegenNode
+          );
+          if (cacheIndex > -1) {
+            for (let i2 = cacheIndex; i2 < context.cached.length; i2++) {
+              const c = context.cached[i2];
+              if (c) c.index -= deleteCount;
+            }
+            context.cached.splice(cacheIndex - deleteCount + 1, deleteCount);
+          }
+        }
+      }
+      return deleteCount;
+    }
+    return 0;
+  };
+  let i = 0;
+  for (; i < children.length; i++) {
+    const child = children[i];
+    const isCached = isParentCached || getCachedNode(child);
+    if (isCached) {
+      const result = analyzeNode(child);
+      if (result) {
+        nc += result[0];
+        ec += result[1];
+        currentChunk.push(child);
+        continue;
+      }
+    }
+    i -= stringifyCurrentChunk(i);
+    nc = 0;
+    ec = 0;
+    currentChunk.length = 0;
+  }
+  stringifyCurrentChunk(i);
+};
+const getCachedNode = (node) => {
+  if ((node.type === 1 && node.tagType === 0 || node.type === 12) && node.codegenNode && node.codegenNode.type === 20) {
+    return node.codegenNode;
+  }
+};
+const dataAriaRE = /^(?:data|aria)-/;
+const isStringifiableAttr = (name, ns) => {
+  return (ns === 0 ? shared.isKnownHtmlAttr(name) : ns === 1 ? shared.isKnownSvgAttr(name) : ns === 2 ? shared.isKnownMathMLAttr(name) : false) || dataAriaRE.test(name);
+};
+const isNonStringifiable = /* @__PURE__ */ shared.makeMap(
+  `caption,thead,tr,th,tbody,td,tfoot,colgroup,col`
+);
+function analyzeNode(node) {
+  if (node.type === 1 && isNonStringifiable(node.tag)) {
+    return false;
+  }
+  if (node.type === 1 && compilerCore.findDir(node, "once", true)) {
+    return false;
+  }
+  if (node.type === 12) {
+    return [1, 0];
+  }
+  let nc = 1;
+  let ec = node.props.length > 0 ? 1 : 0;
+  let bailed = false;
+  const bail = () => {
+    bailed = true;
+    return false;
+  };
+  function walk(node2) {
+    const isOptionTag = node2.tag === "option" && node2.ns === 0;
+    for (let i = 0; i < node2.props.length; i++) {
+      const p = node2.props[i];
+      if (p.type === 6 && !isStringifiableAttr(p.name, node2.ns)) {
+        return bail();
+      }
+      if (p.type === 7 && p.name === "bind") {
+        if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node2.ns))) {
+          return bail();
+        }
+        if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) {
+          return bail();
+        }
+        if (isOptionTag && compilerCore.isStaticArgOf(p.arg, "value") && p.exp && !p.exp.isStatic) {
+          return bail();
+        }
+      }
+    }
+    for (let i = 0; i < node2.children.length; i++) {
+      nc++;
+      const child = node2.children[i];
+      if (child.type === 1) {
+        if (child.props.length > 0) {
+          ec++;
+        }
+        walk(child);
+        if (bailed) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  return walk(node) ? [nc, ec] : false;
+}
+function stringifyNode(node, context) {
+  if (shared.isString(node)) {
+    return node;
+  }
+  if (shared.isSymbol(node)) {
+    return ``;
+  }
+  switch (node.type) {
+    case 1:
+      return stringifyElement(node, context);
+    case 2:
+      return shared.escapeHtml(node.content);
+    case 3:
+      return `<!--${shared.escapeHtml(node.content)}-->`;
+    case 5:
+      return shared.escapeHtml(shared.toDisplayString(evaluateConstant(node.content)));
+    case 8:
+      return shared.escapeHtml(evaluateConstant(node));
+    case 12:
+      return stringifyNode(node.content, context);
+    default:
+      return "";
+  }
+}
+function stringifyElement(node, context) {
+  let res = `<${node.tag}`;
+  let innerHTML = "";
+  for (let i = 0; i < node.props.length; i++) {
+    const p = node.props[i];
+    if (p.type === 6) {
+      res += ` ${p.name}`;
+      if (p.value) {
+        res += `="${shared.escapeHtml(p.value.content)}"`;
+      }
+    } else if (p.type === 7) {
+      if (p.name === "bind") {
+        const exp = p.exp;
+        if (exp.content[0] === "_") {
+          res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`;
+          continue;
+        }
+        if (shared.isBooleanAttr(p.arg.content) && exp.content === "false") {
+          continue;
+        }
+        let evaluated = evaluateConstant(exp);
+        if (evaluated != null) {
+          const arg = p.arg && p.arg.content;
+          if (arg === "class") {
+            evaluated = shared.normalizeClass(evaluated);
+          } else if (arg === "style") {
+            evaluated = shared.stringifyStyle(shared.normalizeStyle(evaluated));
+          }
+          res += ` ${p.arg.content}="${shared.escapeHtml(
+            evaluated
+          )}"`;
+        }
+      } else if (p.name === "html") {
+        innerHTML = evaluateConstant(p.exp);
+      } else if (p.name === "text") {
+        innerHTML = shared.escapeHtml(
+          shared.toDisplayString(evaluateConstant(p.exp))
+        );
+      }
+    }
+  }
+  if (context.scopeId) {
+    res += ` ${context.scopeId}`;
+  }
+  res += `>`;
+  if (innerHTML) {
+    res += innerHTML;
+  } else {
+    for (let i = 0; i < node.children.length; i++) {
+      res += stringifyNode(node.children[i], context);
+    }
+  }
+  if (!shared.isVoidTag(node.tag)) {
+    res += `</${node.tag}>`;
+  }
+  return res;
+}
+function evaluateConstant(exp) {
+  if (exp.type === 4) {
+    return new Function(`return (${exp.content})`)();
+  } else {
+    let res = ``;
+    exp.children.forEach((c) => {
+      if (shared.isString(c) || shared.isSymbol(c)) {
+        return;
+      }
+      if (c.type === 2) {
+        res += c.content;
+      } else if (c.type === 5) {
+        res += shared.toDisplayString(evaluateConstant(c.content));
+      } else {
+        res += evaluateConstant(c);
+      }
+    });
+    return res;
+  }
+}
+
+const ignoreSideEffectTags = (node, context) => {
+  if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
+    context.onError(
+      createDOMCompilerError(
+        63,
+        node.loc
+      )
+    );
+    context.removeNode();
+  }
+};
+
+function isValidHTMLNesting(parent, child) {
+  if (parent === "template") {
+    return true;
+  }
+  if (parent in onlyValidChildren) {
+    return onlyValidChildren[parent].has(child);
+  }
+  if (child in onlyValidParents) {
+    return onlyValidParents[child].has(parent);
+  }
+  if (parent in knownInvalidChildren) {
+    if (knownInvalidChildren[parent].has(child)) return false;
+  }
+  if (child in knownInvalidParents) {
+    if (knownInvalidParents[child].has(parent)) return false;
+  }
+  return true;
+}
+const headings = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+const emptySet = /* @__PURE__ */ new Set([]);
+const onlyValidChildren = {
+  head: /* @__PURE__ */ new Set([
+    "base",
+    "basefront",
+    "bgsound",
+    "link",
+    "meta",
+    "title",
+    "noscript",
+    "noframes",
+    "style",
+    "script",
+    "template"
+  ]),
+  optgroup: /* @__PURE__ */ new Set(["option"]),
+  select: /* @__PURE__ */ new Set(["optgroup", "option", "hr"]),
+  // table
+  table: /* @__PURE__ */ new Set(["caption", "colgroup", "tbody", "tfoot", "thead"]),
+  tr: /* @__PURE__ */ new Set(["td", "th"]),
+  colgroup: /* @__PURE__ */ new Set(["col"]),
+  tbody: /* @__PURE__ */ new Set(["tr"]),
+  thead: /* @__PURE__ */ new Set(["tr"]),
+  tfoot: /* @__PURE__ */ new Set(["tr"]),
+  // these elements can not have any children elements
+  script: emptySet,
+  iframe: emptySet,
+  option: emptySet,
+  textarea: emptySet,
+  style: emptySet,
+  title: emptySet
+};
+const onlyValidParents = {
+  // sections
+  html: emptySet,
+  body: /* @__PURE__ */ new Set(["html"]),
+  head: /* @__PURE__ */ new Set(["html"]),
+  // table
+  td: /* @__PURE__ */ new Set(["tr"]),
+  colgroup: /* @__PURE__ */ new Set(["table"]),
+  caption: /* @__PURE__ */ new Set(["table"]),
+  tbody: /* @__PURE__ */ new Set(["table"]),
+  tfoot: /* @__PURE__ */ new Set(["table"]),
+  col: /* @__PURE__ */ new Set(["colgroup"]),
+  th: /* @__PURE__ */ new Set(["tr"]),
+  thead: /* @__PURE__ */ new Set(["table"]),
+  tr: /* @__PURE__ */ new Set(["tbody", "thead", "tfoot"]),
+  // data list
+  dd: /* @__PURE__ */ new Set(["dl", "div"]),
+  dt: /* @__PURE__ */ new Set(["dl", "div"]),
+  // other
+  figcaption: /* @__PURE__ */ new Set(["figure"]),
+  // li: new Set(["ul", "ol"]),
+  summary: /* @__PURE__ */ new Set(["details"]),
+  area: /* @__PURE__ */ new Set(["map"])
+};
+const knownInvalidChildren = {
+  p: /* @__PURE__ */ new Set([
+    "address",
+    "article",
+    "aside",
+    "blockquote",
+    "center",
+    "details",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "fieldset",
+    "figure",
+    "footer",
+    "form",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "header",
+    "hgroup",
+    "hr",
+    "li",
+    "main",
+    "nav",
+    "menu",
+    "ol",
+    "p",
+    "pre",
+    "section",
+    "table",
+    "ul"
+  ]),
+  svg: /* @__PURE__ */ new Set([
+    "b",
+    "blockquote",
+    "br",
+    "code",
+    "dd",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "embed",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "hr",
+    "i",
+    "img",
+    "li",
+    "menu",
+    "meta",
+    "ol",
+    "p",
+    "pre",
+    "ruby",
+    "s",
+    "small",
+    "span",
+    "strong",
+    "sub",
+    "sup",
+    "table",
+    "u",
+    "ul",
+    "var"
+  ])
+};
+const knownInvalidParents = {
+  a: /* @__PURE__ */ new Set(["a"]),
+  button: /* @__PURE__ */ new Set(["button"]),
+  dd: /* @__PURE__ */ new Set(["dd", "dt"]),
+  dt: /* @__PURE__ */ new Set(["dd", "dt"]),
+  form: /* @__PURE__ */ new Set(["form"]),
+  li: /* @__PURE__ */ new Set(["li"]),
+  h1: headings,
+  h2: headings,
+  h3: headings,
+  h4: headings,
+  h5: headings,
+  h6: headings
+};
+
+const validateHtmlNesting = (node, context) => {
+  if (node.type === 1 && node.tagType === 0 && context.parent && context.parent.type === 1 && context.parent.tagType === 0 && !isValidHTMLNesting(context.parent.tag, node.tag)) {
+    const error = new SyntaxError(
+      `<${node.tag}> cannot be child of <${context.parent.tag}>, according to HTML specifications. This can cause hydration errors or potentially disrupt future functionality.`
+    );
+    error.loc = node.loc;
+    context.onWarn(error);
+  }
+};
+
+const DOMNodeTransforms = [
+  transformStyle,
+  ...[transformTransition, validateHtmlNesting] 
+];
+const DOMDirectiveTransforms = {
+  cloak: compilerCore.noopDirectiveTransform,
+  html: transformVHtml,
+  text: transformVText,
+  model: transformModel,
+  // override compiler-core
+  on: transformOn,
+  // override compiler-core
+  show: transformShow
+};
+function compile(src, options = {}) {
+  return compilerCore.baseCompile(
+    src,
+    shared.extend({}, parserOptions, options, {
+      nodeTransforms: [
+        // ignore <script> and <tag>
+        // this is not put inside DOMNodeTransforms because that list is used
+        // by compiler-ssr to generate vnode fallback branches
+        ignoreSideEffectTags,
+        ...DOMNodeTransforms,
+        ...options.nodeTransforms || []
+      ],
+      directiveTransforms: shared.extend(
+        {},
+        DOMDirectiveTransforms,
+        options.directiveTransforms || {}
+      ),
+      transformHoist: stringifyStatic
+    })
+  );
+}
+function parse(template, options = {}) {
+  return compilerCore.baseParse(template, shared.extend({}, parserOptions, options));
+}
+
+exports.DOMDirectiveTransforms = DOMDirectiveTransforms;
+exports.DOMErrorCodes = DOMErrorCodes;
+exports.DOMErrorMessages = DOMErrorMessages;
+exports.DOMNodeTransforms = DOMNodeTransforms;
+exports.TRANSITION = TRANSITION;
+exports.TRANSITION_GROUP = TRANSITION_GROUP;
+exports.V_MODEL_CHECKBOX = V_MODEL_CHECKBOX;
+exports.V_MODEL_DYNAMIC = V_MODEL_DYNAMIC;
+exports.V_MODEL_RADIO = V_MODEL_RADIO;
+exports.V_MODEL_SELECT = V_MODEL_SELECT;
+exports.V_MODEL_TEXT = V_MODEL_TEXT;
+exports.V_ON_WITH_KEYS = V_ON_WITH_KEYS;
+exports.V_ON_WITH_MODIFIERS = V_ON_WITH_MODIFIERS;
+exports.V_SHOW = V_SHOW;
+exports.compile = compile;
+exports.createDOMCompilerError = createDOMCompilerError;
+exports.parse = parse;
+exports.parserOptions = parserOptions;
+exports.transformStyle = transformStyle;
+Object.keys(compilerCore).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = compilerCore[k];
+});

node_modules/@vue/compiler-dom/dist/compiler-dom.cjs.prod.js

@@ -0,0 +1,689 @@
+/**
+* @vue/compiler-dom v3.5.22
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compilerCore = require('@vue/compiler-core');
+var shared = require('@vue/shared');
+
+const V_MODEL_RADIO = Symbol(``);
+const V_MODEL_CHECKBOX = Symbol(
+  ``
+);
+const V_MODEL_TEXT = Symbol(``);
+const V_MODEL_SELECT = Symbol(
+  ``
+);
+const V_MODEL_DYNAMIC = Symbol(
+  ``
+);
+const V_ON_WITH_MODIFIERS = Symbol(
+  ``
+);
+const V_ON_WITH_KEYS = Symbol(
+  ``
+);
+const V_SHOW = Symbol(``);
+const TRANSITION = Symbol(``);
+const TRANSITION_GROUP = Symbol(
+  ``
+);
+compilerCore.registerRuntimeHelpers({
+  [V_MODEL_RADIO]: `vModelRadio`,
+  [V_MODEL_CHECKBOX]: `vModelCheckbox`,
+  [V_MODEL_TEXT]: `vModelText`,
+  [V_MODEL_SELECT]: `vModelSelect`,
+  [V_MODEL_DYNAMIC]: `vModelDynamic`,
+  [V_ON_WITH_MODIFIERS]: `withModifiers`,
+  [V_ON_WITH_KEYS]: `withKeys`,
+  [V_SHOW]: `vShow`,
+  [TRANSITION]: `Transition`,
+  [TRANSITION_GROUP]: `TransitionGroup`
+});
+
+const parserOptions = {
+  parseMode: "html",
+  isVoidTag: shared.isVoidTag,
+  isNativeTag: (tag) => shared.isHTMLTag(tag) || shared.isSVGTag(tag) || shared.isMathMLTag(tag),
+  isPreTag: (tag) => tag === "pre",
+  isIgnoreNewlineTag: (tag) => tag === "pre" || tag === "textarea",
+  decodeEntities: void 0,
+  isBuiltInComponent: (tag) => {
+    if (tag === "Transition" || tag === "transition") {
+      return TRANSITION;
+    } else if (tag === "TransitionGroup" || tag === "transition-group") {
+      return TRANSITION_GROUP;
+    }
+  },
+  // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
+  getNamespace(tag, parent, rootNamespace) {
+    let ns = parent ? parent.ns : rootNamespace;
+    if (parent && ns === 2) {
+      if (parent.tag === "annotation-xml") {
+        if (tag === "svg") {
+          return 1;
+        }
+        if (parent.props.some(
+          (a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml")
+        )) {
+          ns = 0;
+        }
+      } else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") {
+        ns = 0;
+      }
+    } else if (parent && ns === 1) {
+      if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") {
+        ns = 0;
+      }
+    }
+    if (ns === 0) {
+      if (tag === "svg") {
+        return 1;
+      }
+      if (tag === "math") {
+        return 2;
+      }
+    }
+    return ns;
+  }
+};
+
+const transformStyle = (node) => {
+  if (node.type === 1) {
+    node.props.forEach((p, i) => {
+      if (p.type === 6 && p.name === "style" && p.value) {
+        node.props[i] = {
+          type: 7,
+          name: `bind`,
+          arg: compilerCore.createSimpleExpression(`style`, true, p.loc),
+          exp: parseInlineCSS(p.value.content, p.loc),
+          modifiers: [],
+          loc: p.loc
+        };
+      }
+    });
+  }
+};
+const parseInlineCSS = (cssText, loc) => {
+  const normalized = shared.parseStringStyle(cssText);
+  return compilerCore.createSimpleExpression(
+    JSON.stringify(normalized),
+    false,
+    loc,
+    3
+  );
+};
+
+function createDOMCompilerError(code, loc) {
+  return compilerCore.createCompilerError(
+    code,
+    loc,
+    DOMErrorMessages 
+  );
+}
+const DOMErrorCodes = {
+  "X_V_HTML_NO_EXPRESSION": 53,
+  "53": "X_V_HTML_NO_EXPRESSION",
+  "X_V_HTML_WITH_CHILDREN": 54,
+  "54": "X_V_HTML_WITH_CHILDREN",
+  "X_V_TEXT_NO_EXPRESSION": 55,
+  "55": "X_V_TEXT_NO_EXPRESSION",
+  "X_V_TEXT_WITH_CHILDREN": 56,
+  "56": "X_V_TEXT_WITH_CHILDREN",
+  "X_V_MODEL_ON_INVALID_ELEMENT": 57,
+  "57": "X_V_MODEL_ON_INVALID_ELEMENT",
+  "X_V_MODEL_ARG_ON_ELEMENT": 58,
+  "58": "X_V_MODEL_ARG_ON_ELEMENT",
+  "X_V_MODEL_ON_FILE_INPUT_ELEMENT": 59,
+  "59": "X_V_MODEL_ON_FILE_INPUT_ELEMENT",
+  "X_V_MODEL_UNNECESSARY_VALUE": 60,
+  "60": "X_V_MODEL_UNNECESSARY_VALUE",
+  "X_V_SHOW_NO_EXPRESSION": 61,
+  "61": "X_V_SHOW_NO_EXPRESSION",
+  "X_TRANSITION_INVALID_CHILDREN": 62,
+  "62": "X_TRANSITION_INVALID_CHILDREN",
+  "X_IGNORED_SIDE_EFFECT_TAG": 63,
+  "63": "X_IGNORED_SIDE_EFFECT_TAG",
+  "__EXTEND_POINT__": 64,
+  "64": "__EXTEND_POINT__"
+};
+const DOMErrorMessages = {
+  [53]: `v-html is missing expression.`,
+  [54]: `v-html will override element children.`,
+  [55]: `v-text is missing expression.`,
+  [56]: `v-text will override element children.`,
+  [57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
+  [58]: `v-model argument is not supported on plain elements.`,
+  [59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+  [60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
+  [61]: `v-show is missing expression.`,
+  [62]: `<Transition> expects exactly one child element or component.`,
+  [63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
+};
+
+const transformVHtml = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(53, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(54, loc)
+    );
+    node.children.length = 0;
+  }
+  return {
+    props: [
+      compilerCore.createObjectProperty(
+        compilerCore.createSimpleExpression(`innerHTML`, true, loc),
+        exp || compilerCore.createSimpleExpression("", true)
+      )
+    ]
+  };
+};
+
+const transformVText = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(55, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(56, loc)
+    );
+    node.children.length = 0;
+  }
+  return {
+    props: [
+      compilerCore.createObjectProperty(
+        compilerCore.createSimpleExpression(`textContent`, true),
+        exp ? compilerCore.getConstantType(exp, context) > 0 ? exp : compilerCore.createCallExpression(
+          context.helperString(compilerCore.TO_DISPLAY_STRING),
+          [exp],
+          loc
+        ) : compilerCore.createSimpleExpression("", true)
+      )
+    ]
+  };
+};
+
+const transformModel = (dir, node, context) => {
+  const baseResult = compilerCore.transformModel(dir, node, context);
+  if (!baseResult.props.length || node.tagType === 1) {
+    return baseResult;
+  }
+  if (dir.arg) {
+    context.onError(
+      createDOMCompilerError(
+        58,
+        dir.arg.loc
+      )
+    );
+  }
+  const { tag } = node;
+  const isCustomElement = context.isCustomElement(tag);
+  if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
+    let directiveToUse = V_MODEL_TEXT;
+    let isInvalidType = false;
+    if (tag === "input" || isCustomElement) {
+      const type = compilerCore.findProp(node, `type`);
+      if (type) {
+        if (type.type === 7) {
+          directiveToUse = V_MODEL_DYNAMIC;
+        } else if (type.value) {
+          switch (type.value.content) {
+            case "radio":
+              directiveToUse = V_MODEL_RADIO;
+              break;
+            case "checkbox":
+              directiveToUse = V_MODEL_CHECKBOX;
+              break;
+            case "file":
+              isInvalidType = true;
+              context.onError(
+                createDOMCompilerError(
+                  59,
+                  dir.loc
+                )
+              );
+              break;
+          }
+        }
+      } else if (compilerCore.hasDynamicKeyVBind(node)) {
+        directiveToUse = V_MODEL_DYNAMIC;
+      } else ;
+    } else if (tag === "select") {
+      directiveToUse = V_MODEL_SELECT;
+    } else ;
+    if (!isInvalidType) {
+      baseResult.needRuntime = context.helper(directiveToUse);
+    }
+  } else {
+    context.onError(
+      createDOMCompilerError(
+        57,
+        dir.loc
+      )
+    );
+  }
+  baseResult.props = baseResult.props.filter(
+    (p) => !(p.key.type === 4 && p.key.content === "modelValue")
+  );
+  return baseResult;
+};
+
+const isEventOptionModifier = /* @__PURE__ */ shared.makeMap(`passive,once,capture`);
+const isNonKeyModifier = /* @__PURE__ */ shared.makeMap(
+  // event propagation management
+  `stop,prevent,self,ctrl,shift,alt,meta,exact,middle`
+);
+const maybeKeyModifier = /* @__PURE__ */ shared.makeMap("left,right");
+const isKeyboardEvent = /* @__PURE__ */ shared.makeMap(`onkeyup,onkeydown,onkeypress`);
+const resolveModifiers = (key, modifiers, context, loc) => {
+  const keyModifiers = [];
+  const nonKeyModifiers = [];
+  const eventOptionModifiers = [];
+  for (let i = 0; i < modifiers.length; i++) {
+    const modifier = modifiers[i].content;
+    if (modifier === "native" && compilerCore.checkCompatEnabled(
+      "COMPILER_V_ON_NATIVE",
+      context,
+      loc
+    )) {
+      eventOptionModifiers.push(modifier);
+    } else if (isEventOptionModifier(modifier)) {
+      eventOptionModifiers.push(modifier);
+    } else {
+      if (maybeKeyModifier(modifier)) {
+        if (compilerCore.isStaticExp(key)) {
+          if (isKeyboardEvent(key.content.toLowerCase())) {
+            keyModifiers.push(modifier);
+          } else {
+            nonKeyModifiers.push(modifier);
+          }
+        } else {
+          keyModifiers.push(modifier);
+          nonKeyModifiers.push(modifier);
+        }
+      } else {
+        if (isNonKeyModifier(modifier)) {
+          nonKeyModifiers.push(modifier);
+        } else {
+          keyModifiers.push(modifier);
+        }
+      }
+    }
+  }
+  return {
+    keyModifiers,
+    nonKeyModifiers,
+    eventOptionModifiers
+  };
+};
+const transformClick = (key, event) => {
+  const isStaticClick = compilerCore.isStaticExp(key) && key.content.toLowerCase() === "onclick";
+  return isStaticClick ? compilerCore.createSimpleExpression(event, true) : key.type !== 4 ? compilerCore.createCompoundExpression([
+    `(`,
+    key,
+    `) === "onClick" ? "${event}" : (`,
+    key,
+    `)`
+  ]) : key;
+};
+const transformOn = (dir, node, context) => {
+  return compilerCore.transformOn(dir, node, context, (baseResult) => {
+    const { modifiers } = dir;
+    if (!modifiers.length) return baseResult;
+    let { key, value: handlerExp } = baseResult.props[0];
+    const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
+    if (nonKeyModifiers.includes("right")) {
+      key = transformClick(key, `onContextmenu`);
+    }
+    if (nonKeyModifiers.includes("middle")) {
+      key = transformClick(key, `onMouseup`);
+    }
+    if (nonKeyModifiers.length) {
+      handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [
+        handlerExp,
+        JSON.stringify(nonKeyModifiers)
+      ]);
+    }
+    if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard
+    (!compilerCore.isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) {
+      handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_KEYS), [
+        handlerExp,
+        JSON.stringify(keyModifiers)
+      ]);
+    }
+    if (eventOptionModifiers.length) {
+      const modifierPostfix = eventOptionModifiers.map(shared.capitalize).join("");
+      key = compilerCore.isStaticExp(key) ? compilerCore.createSimpleExpression(`${key.content}${modifierPostfix}`, true) : compilerCore.createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
+    }
+    return {
+      props: [compilerCore.createObjectProperty(key, handlerExp)]
+    };
+  });
+};
+
+const transformShow = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(61, loc)
+    );
+  }
+  return {
+    props: [],
+    needRuntime: context.helper(V_SHOW)
+  };
+};
+
+const expReplaceRE = /__VUE_EXP_START__(.*?)__VUE_EXP_END__/g;
+const stringifyStatic = (children, context, parent) => {
+  if (context.scopes.vSlot > 0) {
+    return;
+  }
+  const isParentCached = parent.type === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared.isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 20;
+  let nc = 0;
+  let ec = 0;
+  const currentChunk = [];
+  const stringifyCurrentChunk = (currentIndex) => {
+    if (nc >= 20 || ec >= 5) {
+      const staticCall = compilerCore.createCallExpression(context.helper(compilerCore.CREATE_STATIC), [
+        JSON.stringify(
+          currentChunk.map((node) => stringifyNode(node, context)).join("")
+        ).replace(expReplaceRE, `" + $1 + "`),
+        // the 2nd argument indicates the number of DOM nodes this static vnode
+        // will insert / hydrate
+        String(currentChunk.length)
+      ]);
+      const deleteCount = currentChunk.length - 1;
+      if (isParentCached) {
+        children.splice(
+          currentIndex - currentChunk.length,
+          currentChunk.length,
+          // @ts-expect-error
+          staticCall
+        );
+      } else {
+        currentChunk[0].codegenNode.value = staticCall;
+        if (currentChunk.length > 1) {
+          children.splice(currentIndex - currentChunk.length + 1, deleteCount);
+          const cacheIndex = context.cached.indexOf(
+            currentChunk[currentChunk.length - 1].codegenNode
+          );
+          if (cacheIndex > -1) {
+            for (let i2 = cacheIndex; i2 < context.cached.length; i2++) {
+              const c = context.cached[i2];
+              if (c) c.index -= deleteCount;
+            }
+            context.cached.splice(cacheIndex - deleteCount + 1, deleteCount);
+          }
+        }
+      }
+      return deleteCount;
+    }
+    return 0;
+  };
+  let i = 0;
+  for (; i < children.length; i++) {
+    const child = children[i];
+    const isCached = isParentCached || getCachedNode(child);
+    if (isCached) {
+      const result = analyzeNode(child);
+      if (result) {
+        nc += result[0];
+        ec += result[1];
+        currentChunk.push(child);
+        continue;
+      }
+    }
+    i -= stringifyCurrentChunk(i);
+    nc = 0;
+    ec = 0;
+    currentChunk.length = 0;
+  }
+  stringifyCurrentChunk(i);
+};
+const getCachedNode = (node) => {
+  if ((node.type === 1 && node.tagType === 0 || node.type === 12) && node.codegenNode && node.codegenNode.type === 20) {
+    return node.codegenNode;
+  }
+};
+const dataAriaRE = /^(?:data|aria)-/;
+const isStringifiableAttr = (name, ns) => {
+  return (ns === 0 ? shared.isKnownHtmlAttr(name) : ns === 1 ? shared.isKnownSvgAttr(name) : ns === 2 ? shared.isKnownMathMLAttr(name) : false) || dataAriaRE.test(name);
+};
+const isNonStringifiable = /* @__PURE__ */ shared.makeMap(
+  `caption,thead,tr,th,tbody,td,tfoot,colgroup,col`
+);
+function analyzeNode(node) {
+  if (node.type === 1 && isNonStringifiable(node.tag)) {
+    return false;
+  }
+  if (node.type === 1 && compilerCore.findDir(node, "once", true)) {
+    return false;
+  }
+  if (node.type === 12) {
+    return [1, 0];
+  }
+  let nc = 1;
+  let ec = node.props.length > 0 ? 1 : 0;
+  let bailed = false;
+  const bail = () => {
+    bailed = true;
+    return false;
+  };
+  function walk(node2) {
+    const isOptionTag = node2.tag === "option" && node2.ns === 0;
+    for (let i = 0; i < node2.props.length; i++) {
+      const p = node2.props[i];
+      if (p.type === 6 && !isStringifiableAttr(p.name, node2.ns)) {
+        return bail();
+      }
+      if (p.type === 7 && p.name === "bind") {
+        if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node2.ns))) {
+          return bail();
+        }
+        if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) {
+          return bail();
+        }
+        if (isOptionTag && compilerCore.isStaticArgOf(p.arg, "value") && p.exp && !p.exp.isStatic) {
+          return bail();
+        }
+      }
+    }
+    for (let i = 0; i < node2.children.length; i++) {
+      nc++;
+      const child = node2.children[i];
+      if (child.type === 1) {
+        if (child.props.length > 0) {
+          ec++;
+        }
+        walk(child);
+        if (bailed) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  return walk(node) ? [nc, ec] : false;
+}
+function stringifyNode(node, context) {
+  if (shared.isString(node)) {
+    return node;
+  }
+  if (shared.isSymbol(node)) {
+    return ``;
+  }
+  switch (node.type) {
+    case 1:
+      return stringifyElement(node, context);
+    case 2:
+      return shared.escapeHtml(node.content);
+    case 3:
+      return `<!--${shared.escapeHtml(node.content)}-->`;
+    case 5:
+      return shared.escapeHtml(shared.toDisplayString(evaluateConstant(node.content)));
+    case 8:
+      return shared.escapeHtml(evaluateConstant(node));
+    case 12:
+      return stringifyNode(node.content, context);
+    default:
+      return "";
+  }
+}
+function stringifyElement(node, context) {
+  let res = `<${node.tag}`;
+  let innerHTML = "";
+  for (let i = 0; i < node.props.length; i++) {
+    const p = node.props[i];
+    if (p.type === 6) {
+      res += ` ${p.name}`;
+      if (p.value) {
+        res += `="${shared.escapeHtml(p.value.content)}"`;
+      }
+    } else if (p.type === 7) {
+      if (p.name === "bind") {
+        const exp = p.exp;
+        if (exp.content[0] === "_") {
+          res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`;
+          continue;
+        }
+        if (shared.isBooleanAttr(p.arg.content) && exp.content === "false") {
+          continue;
+        }
+        let evaluated = evaluateConstant(exp);
+        if (evaluated != null) {
+          const arg = p.arg && p.arg.content;
+          if (arg === "class") {
+            evaluated = shared.normalizeClass(evaluated);
+          } else if (arg === "style") {
+            evaluated = shared.stringifyStyle(shared.normalizeStyle(evaluated));
+          }
+          res += ` ${p.arg.content}="${shared.escapeHtml(
+            evaluated
+          )}"`;
+        }
+      } else if (p.name === "html") {
+        innerHTML = evaluateConstant(p.exp);
+      } else if (p.name === "text") {
+        innerHTML = shared.escapeHtml(
+          shared.toDisplayString(evaluateConstant(p.exp))
+        );
+      }
+    }
+  }
+  if (context.scopeId) {
+    res += ` ${context.scopeId}`;
+  }
+  res += `>`;
+  if (innerHTML) {
+    res += innerHTML;
+  } else {
+    for (let i = 0; i < node.children.length; i++) {
+      res += stringifyNode(node.children[i], context);
+    }
+  }
+  if (!shared.isVoidTag(node.tag)) {
+    res += `</${node.tag}>`;
+  }
+  return res;
+}
+function evaluateConstant(exp) {
+  if (exp.type === 4) {
+    return new Function(`return (${exp.content})`)();
+  } else {
+    let res = ``;
+    exp.children.forEach((c) => {
+      if (shared.isString(c) || shared.isSymbol(c)) {
+        return;
+      }
+      if (c.type === 2) {
+        res += c.content;
+      } else if (c.type === 5) {
+        res += shared.toDisplayString(evaluateConstant(c.content));
+      } else {
+        res += evaluateConstant(c);
+      }
+    });
+    return res;
+  }
+}
+
+const ignoreSideEffectTags = (node, context) => {
+  if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
+    context.removeNode();
+  }
+};
+
+const DOMNodeTransforms = [
+  transformStyle,
+  ...[]
+];
+const DOMDirectiveTransforms = {
+  cloak: compilerCore.noopDirectiveTransform,
+  html: transformVHtml,
+  text: transformVText,
+  model: transformModel,
+  // override compiler-core
+  on: transformOn,
+  // override compiler-core
+  show: transformShow
+};
+function compile(src, options = {}) {
+  return compilerCore.baseCompile(
+    src,
+    shared.extend({}, parserOptions, options, {
+      nodeTransforms: [
+        // ignore <script> and <tag>
+        // this is not put inside DOMNodeTransforms because that list is used
+        // by compiler-ssr to generate vnode fallback branches
+        ignoreSideEffectTags,
+        ...DOMNodeTransforms,
+        ...options.nodeTransforms || []
+      ],
+      directiveTransforms: shared.extend(
+        {},
+        DOMDirectiveTransforms,
+        options.directiveTransforms || {}
+      ),
+      transformHoist: stringifyStatic
+    })
+  );
+}
+function parse(template, options = {}) {
+  return compilerCore.baseParse(template, shared.extend({}, parserOptions, options));
+}
+
+exports.DOMDirectiveTransforms = DOMDirectiveTransforms;
+exports.DOMErrorCodes = DOMErrorCodes;
+exports.DOMErrorMessages = DOMErrorMessages;
+exports.DOMNodeTransforms = DOMNodeTransforms;
+exports.TRANSITION = TRANSITION;
+exports.TRANSITION_GROUP = TRANSITION_GROUP;
+exports.V_MODEL_CHECKBOX = V_MODEL_CHECKBOX;
+exports.V_MODEL_DYNAMIC = V_MODEL_DYNAMIC;
+exports.V_MODEL_RADIO = V_MODEL_RADIO;
+exports.V_MODEL_SELECT = V_MODEL_SELECT;
+exports.V_MODEL_TEXT = V_MODEL_TEXT;
+exports.V_ON_WITH_KEYS = V_ON_WITH_KEYS;
+exports.V_ON_WITH_MODIFIERS = V_ON_WITH_MODIFIERS;
+exports.V_SHOW = V_SHOW;
+exports.compile = compile;
+exports.createDOMCompilerError = createDOMCompilerError;
+exports.parse = parse;
+exports.parserOptions = parserOptions;
+exports.transformStyle = transformStyle;
+Object.keys(compilerCore).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = compilerCore[k];
+});

node_modules/@vue/compiler-dom/dist/compiler-dom.d.ts

@@ -0,0 +1,45 @@
+import { ParserOptions, NodeTransform, SourceLocation, CompilerError, DirectiveTransform, RootNode, CompilerOptions, CodegenResult } from '@vue/compiler-core';
+export * from '@vue/compiler-core';
+
+export declare const parserOptions: ParserOptions;
+
+export declare const V_MODEL_RADIO: unique symbol;
+export declare const V_MODEL_CHECKBOX: unique symbol;
+export declare const V_MODEL_TEXT: unique symbol;
+export declare const V_MODEL_SELECT: unique symbol;
+export declare const V_MODEL_DYNAMIC: unique symbol;
+export declare const V_ON_WITH_MODIFIERS: unique symbol;
+export declare const V_ON_WITH_KEYS: unique symbol;
+export declare const V_SHOW: unique symbol;
+export declare const TRANSITION: unique symbol;
+export declare const TRANSITION_GROUP: unique symbol;
+
+export declare const transformStyle: NodeTransform;
+
+interface DOMCompilerError extends CompilerError {
+    code: DOMErrorCodes;
+}
+export declare function createDOMCompilerError(code: DOMErrorCodes, loc?: SourceLocation): DOMCompilerError;
+export declare enum DOMErrorCodes {
+    X_V_HTML_NO_EXPRESSION = 53,
+    X_V_HTML_WITH_CHILDREN = 54,
+    X_V_TEXT_NO_EXPRESSION = 55,
+    X_V_TEXT_WITH_CHILDREN = 56,
+    X_V_MODEL_ON_INVALID_ELEMENT = 57,
+    X_V_MODEL_ARG_ON_ELEMENT = 58,
+    X_V_MODEL_ON_FILE_INPUT_ELEMENT = 59,
+    X_V_MODEL_UNNECESSARY_VALUE = 60,
+    X_V_SHOW_NO_EXPRESSION = 61,
+    X_TRANSITION_INVALID_CHILDREN = 62,
+    X_IGNORED_SIDE_EFFECT_TAG = 63,
+    __EXTEND_POINT__ = 64
+}
+export declare const DOMErrorMessages: {
+    [code: number]: string;
+};
+
+export declare const DOMNodeTransforms: NodeTransform[];
+export declare const DOMDirectiveTransforms: Record<string, DirectiveTransform>;
+export declare function compile(src: string | RootNode, options?: CompilerOptions): CodegenResult;
+export declare function parse(template: string, options?: ParserOptions): RootNode;
+

node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js

@@ -0,0 +1,690 @@
+/**
+* @vue/compiler-dom v3.5.22
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+import { registerRuntimeHelpers, createSimpleExpression, createCompilerError, createObjectProperty, createCallExpression, getConstantType, TO_DISPLAY_STRING, transformModel as transformModel$1, findProp, hasDynamicKeyVBind, findDir, isStaticArgOf, transformOn as transformOn$1, isStaticExp, createCompoundExpression, checkCompatEnabled, noopDirectiveTransform, baseCompile, baseParse } from '@vue/compiler-core';
+export * from '@vue/compiler-core';
+import { isHTMLTag, isSVGTag, isMathMLTag, isVoidTag, parseStringStyle, makeMap, capitalize, extend } from '@vue/shared';
+
+const V_MODEL_RADIO = Symbol(!!(process.env.NODE_ENV !== "production") ? `vModelRadio` : ``);
+const V_MODEL_CHECKBOX = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vModelCheckbox` : ``
+);
+const V_MODEL_TEXT = Symbol(!!(process.env.NODE_ENV !== "production") ? `vModelText` : ``);
+const V_MODEL_SELECT = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vModelSelect` : ``
+);
+const V_MODEL_DYNAMIC = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vModelDynamic` : ``
+);
+const V_ON_WITH_MODIFIERS = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vOnModifiersGuard` : ``
+);
+const V_ON_WITH_KEYS = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vOnKeysGuard` : ``
+);
+const V_SHOW = Symbol(!!(process.env.NODE_ENV !== "production") ? `vShow` : ``);
+const TRANSITION = Symbol(!!(process.env.NODE_ENV !== "production") ? `Transition` : ``);
+const TRANSITION_GROUP = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `TransitionGroup` : ``
+);
+registerRuntimeHelpers({
+  [V_MODEL_RADIO]: `vModelRadio`,
+  [V_MODEL_CHECKBOX]: `vModelCheckbox`,
+  [V_MODEL_TEXT]: `vModelText`,
+  [V_MODEL_SELECT]: `vModelSelect`,
+  [V_MODEL_DYNAMIC]: `vModelDynamic`,
+  [V_ON_WITH_MODIFIERS]: `withModifiers`,
+  [V_ON_WITH_KEYS]: `withKeys`,
+  [V_SHOW]: `vShow`,
+  [TRANSITION]: `Transition`,
+  [TRANSITION_GROUP]: `TransitionGroup`
+});
+
+let decoder;
+function decodeHtmlBrowser(raw, asAttr = false) {
+  if (!decoder) {
+    decoder = document.createElement("div");
+  }
+  if (asAttr) {
+    decoder.innerHTML = `<div foo="${raw.replace(/"/g, "&quot;")}">`;
+    return decoder.children[0].getAttribute("foo");
+  } else {
+    decoder.innerHTML = raw;
+    return decoder.textContent;
+  }
+}
+
+const parserOptions = {
+  parseMode: "html",
+  isVoidTag,
+  isNativeTag: (tag) => isHTMLTag(tag) || isSVGTag(tag) || isMathMLTag(tag),
+  isPreTag: (tag) => tag === "pre",
+  isIgnoreNewlineTag: (tag) => tag === "pre" || tag === "textarea",
+  decodeEntities: decodeHtmlBrowser ,
+  isBuiltInComponent: (tag) => {
+    if (tag === "Transition" || tag === "transition") {
+      return TRANSITION;
+    } else if (tag === "TransitionGroup" || tag === "transition-group") {
+      return TRANSITION_GROUP;
+    }
+  },
+  // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
+  getNamespace(tag, parent, rootNamespace) {
+    let ns = parent ? parent.ns : rootNamespace;
+    if (parent && ns === 2) {
+      if (parent.tag === "annotation-xml") {
+        if (tag === "svg") {
+          return 1;
+        }
+        if (parent.props.some(
+          (a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml")
+        )) {
+          ns = 0;
+        }
+      } else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") {
+        ns = 0;
+      }
+    } else if (parent && ns === 1) {
+      if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") {
+        ns = 0;
+      }
+    }
+    if (ns === 0) {
+      if (tag === "svg") {
+        return 1;
+      }
+      if (tag === "math") {
+        return 2;
+      }
+    }
+    return ns;
+  }
+};
+
+const transformStyle = (node) => {
+  if (node.type === 1) {
+    node.props.forEach((p, i) => {
+      if (p.type === 6 && p.name === "style" && p.value) {
+        node.props[i] = {
+          type: 7,
+          name: `bind`,
+          arg: createSimpleExpression(`style`, true, p.loc),
+          exp: parseInlineCSS(p.value.content, p.loc),
+          modifiers: [],
+          loc: p.loc
+        };
+      }
+    });
+  }
+};
+const parseInlineCSS = (cssText, loc) => {
+  const normalized = parseStringStyle(cssText);
+  return createSimpleExpression(
+    JSON.stringify(normalized),
+    false,
+    loc,
+    3
+  );
+};
+
+function createDOMCompilerError(code, loc) {
+  return createCompilerError(
+    code,
+    loc,
+    !!(process.env.NODE_ENV !== "production") || false ? DOMErrorMessages : void 0
+  );
+}
+const DOMErrorCodes = {
+  "X_V_HTML_NO_EXPRESSION": 53,
+  "53": "X_V_HTML_NO_EXPRESSION",
+  "X_V_HTML_WITH_CHILDREN": 54,
+  "54": "X_V_HTML_WITH_CHILDREN",
+  "X_V_TEXT_NO_EXPRESSION": 55,
+  "55": "X_V_TEXT_NO_EXPRESSION",
+  "X_V_TEXT_WITH_CHILDREN": 56,
+  "56": "X_V_TEXT_WITH_CHILDREN",
+  "X_V_MODEL_ON_INVALID_ELEMENT": 57,
+  "57": "X_V_MODEL_ON_INVALID_ELEMENT",
+  "X_V_MODEL_ARG_ON_ELEMENT": 58,
+  "58": "X_V_MODEL_ARG_ON_ELEMENT",
+  "X_V_MODEL_ON_FILE_INPUT_ELEMENT": 59,
+  "59": "X_V_MODEL_ON_FILE_INPUT_ELEMENT",
+  "X_V_MODEL_UNNECESSARY_VALUE": 60,
+  "60": "X_V_MODEL_UNNECESSARY_VALUE",
+  "X_V_SHOW_NO_EXPRESSION": 61,
+  "61": "X_V_SHOW_NO_EXPRESSION",
+  "X_TRANSITION_INVALID_CHILDREN": 62,
+  "62": "X_TRANSITION_INVALID_CHILDREN",
+  "X_IGNORED_SIDE_EFFECT_TAG": 63,
+  "63": "X_IGNORED_SIDE_EFFECT_TAG",
+  "__EXTEND_POINT__": 64,
+  "64": "__EXTEND_POINT__"
+};
+const DOMErrorMessages = {
+  [53]: `v-html is missing expression.`,
+  [54]: `v-html will override element children.`,
+  [55]: `v-text is missing expression.`,
+  [56]: `v-text will override element children.`,
+  [57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
+  [58]: `v-model argument is not supported on plain elements.`,
+  [59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+  [60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
+  [61]: `v-show is missing expression.`,
+  [62]: `<Transition> expects exactly one child element or component.`,
+  [63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
+};
+
+const transformVHtml = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(53, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(54, loc)
+    );
+    node.children.length = 0;
+  }
+  return {
+    props: [
+      createObjectProperty(
+        createSimpleExpression(`innerHTML`, true, loc),
+        exp || createSimpleExpression("", true)
+      )
+    ]
+  };
+};
+
+const transformVText = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(55, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(56, loc)
+    );
+    node.children.length = 0;
+  }
+  return {
+    props: [
+      createObjectProperty(
+        createSimpleExpression(`textContent`, true),
+        exp ? getConstantType(exp, context) > 0 ? exp : createCallExpression(
+          context.helperString(TO_DISPLAY_STRING),
+          [exp],
+          loc
+        ) : createSimpleExpression("", true)
+      )
+    ]
+  };
+};
+
+const transformModel = (dir, node, context) => {
+  const baseResult = transformModel$1(dir, node, context);
+  if (!baseResult.props.length || node.tagType === 1) {
+    return baseResult;
+  }
+  if (dir.arg) {
+    context.onError(
+      createDOMCompilerError(
+        58,
+        dir.arg.loc
+      )
+    );
+  }
+  function checkDuplicatedValue() {
+    const value = findDir(node, "bind");
+    if (value && isStaticArgOf(value.arg, "value")) {
+      context.onError(
+        createDOMCompilerError(
+          60,
+          value.loc
+        )
+      );
+    }
+  }
+  const { tag } = node;
+  const isCustomElement = context.isCustomElement(tag);
+  if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
+    let directiveToUse = V_MODEL_TEXT;
+    let isInvalidType = false;
+    if (tag === "input" || isCustomElement) {
+      const type = findProp(node, `type`);
+      if (type) {
+        if (type.type === 7) {
+          directiveToUse = V_MODEL_DYNAMIC;
+        } else if (type.value) {
+          switch (type.value.content) {
+            case "radio":
+              directiveToUse = V_MODEL_RADIO;
+              break;
+            case "checkbox":
+              directiveToUse = V_MODEL_CHECKBOX;
+              break;
+            case "file":
+              isInvalidType = true;
+              context.onError(
+                createDOMCompilerError(
+                  59,
+                  dir.loc
+                )
+              );
+              break;
+            default:
+              !!(process.env.NODE_ENV !== "production") && checkDuplicatedValue();
+              break;
+          }
+        }
+      } else if (hasDynamicKeyVBind(node)) {
+        directiveToUse = V_MODEL_DYNAMIC;
+      } else {
+        !!(process.env.NODE_ENV !== "production") && checkDuplicatedValue();
+      }
+    } else if (tag === "select") {
+      directiveToUse = V_MODEL_SELECT;
+    } else {
+      !!(process.env.NODE_ENV !== "production") && checkDuplicatedValue();
+    }
+    if (!isInvalidType) {
+      baseResult.needRuntime = context.helper(directiveToUse);
+    }
+  } else {
+    context.onError(
+      createDOMCompilerError(
+        57,
+        dir.loc
+      )
+    );
+  }
+  baseResult.props = baseResult.props.filter(
+    (p) => !(p.key.type === 4 && p.key.content === "modelValue")
+  );
+  return baseResult;
+};
+
+const isEventOptionModifier = /* @__PURE__ */ makeMap(`passive,once,capture`);
+const isNonKeyModifier = /* @__PURE__ */ makeMap(
+  // event propagation management
+  `stop,prevent,self,ctrl,shift,alt,meta,exact,middle`
+);
+const maybeKeyModifier = /* @__PURE__ */ makeMap("left,right");
+const isKeyboardEvent = /* @__PURE__ */ makeMap(`onkeyup,onkeydown,onkeypress`);
+const resolveModifiers = (key, modifiers, context, loc) => {
+  const keyModifiers = [];
+  const nonKeyModifiers = [];
+  const eventOptionModifiers = [];
+  for (let i = 0; i < modifiers.length; i++) {
+    const modifier = modifiers[i].content;
+    if (modifier === "native" && checkCompatEnabled(
+      "COMPILER_V_ON_NATIVE",
+      context,
+      loc
+    )) {
+      eventOptionModifiers.push(modifier);
+    } else if (isEventOptionModifier(modifier)) {
+      eventOptionModifiers.push(modifier);
+    } else {
+      if (maybeKeyModifier(modifier)) {
+        if (isStaticExp(key)) {
+          if (isKeyboardEvent(key.content.toLowerCase())) {
+            keyModifiers.push(modifier);
+          } else {
+            nonKeyModifiers.push(modifier);
+          }
+        } else {
+          keyModifiers.push(modifier);
+          nonKeyModifiers.push(modifier);
+        }
+      } else {
+        if (isNonKeyModifier(modifier)) {
+          nonKeyModifiers.push(modifier);
+        } else {
+          keyModifiers.push(modifier);
+        }
+      }
+    }
+  }
+  return {
+    keyModifiers,
+    nonKeyModifiers,
+    eventOptionModifiers
+  };
+};
+const transformClick = (key, event) => {
+  const isStaticClick = isStaticExp(key) && key.content.toLowerCase() === "onclick";
+  return isStaticClick ? createSimpleExpression(event, true) : key.type !== 4 ? createCompoundExpression([
+    `(`,
+    key,
+    `) === "onClick" ? "${event}" : (`,
+    key,
+    `)`
+  ]) : key;
+};
+const transformOn = (dir, node, context) => {
+  return transformOn$1(dir, node, context, (baseResult) => {
+    const { modifiers } = dir;
+    if (!modifiers.length) return baseResult;
+    let { key, value: handlerExp } = baseResult.props[0];
+    const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
+    if (nonKeyModifiers.includes("right")) {
+      key = transformClick(key, `onContextmenu`);
+    }
+    if (nonKeyModifiers.includes("middle")) {
+      key = transformClick(key, `onMouseup`);
+    }
+    if (nonKeyModifiers.length) {
+      handlerExp = createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [
+        handlerExp,
+        JSON.stringify(nonKeyModifiers)
+      ]);
+    }
+    if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard
+    (!isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) {
+      handlerExp = createCallExpression(context.helper(V_ON_WITH_KEYS), [
+        handlerExp,
+        JSON.stringify(keyModifiers)
+      ]);
+    }
+    if (eventOptionModifiers.length) {
+      const modifierPostfix = eventOptionModifiers.map(capitalize).join("");
+      key = isStaticExp(key) ? createSimpleExpression(`${key.content}${modifierPostfix}`, true) : createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
+    }
+    return {
+      props: [createObjectProperty(key, handlerExp)]
+    };
+  });
+};
+
+const transformShow = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(61, loc)
+    );
+  }
+  return {
+    props: [],
+    needRuntime: context.helper(V_SHOW)
+  };
+};
+
+const transformTransition = (node, context) => {
+  if (node.type === 1 && node.tagType === 1) {
+    const component = context.isBuiltInComponent(node.tag);
+    if (component === TRANSITION) {
+      return () => {
+        if (!node.children.length) {
+          return;
+        }
+        if (hasMultipleChildren(node)) {
+          context.onError(
+            createDOMCompilerError(
+              62,
+              {
+                start: node.children[0].loc.start,
+                end: node.children[node.children.length - 1].loc.end,
+                source: ""
+              }
+            )
+          );
+        }
+        const child = node.children[0];
+        if (child.type === 1) {
+          for (const p of child.props) {
+            if (p.type === 7 && p.name === "show") {
+              node.props.push({
+                type: 6,
+                name: "persisted",
+                nameLoc: node.loc,
+                value: void 0,
+                loc: node.loc
+              });
+            }
+          }
+        }
+      };
+    }
+  }
+};
+function hasMultipleChildren(node) {
+  const children = node.children = node.children.filter(
+    (c) => c.type !== 3 && !(c.type === 2 && !c.content.trim())
+  );
+  const child = children[0];
+  return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(hasMultipleChildren);
+}
+
+const ignoreSideEffectTags = (node, context) => {
+  if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
+    !!(process.env.NODE_ENV !== "production") && context.onError(
+      createDOMCompilerError(
+        63,
+        node.loc
+      )
+    );
+    context.removeNode();
+  }
+};
+
+function isValidHTMLNesting(parent, child) {
+  if (parent === "template") {
+    return true;
+  }
+  if (parent in onlyValidChildren) {
+    return onlyValidChildren[parent].has(child);
+  }
+  if (child in onlyValidParents) {
+    return onlyValidParents[child].has(parent);
+  }
+  if (parent in knownInvalidChildren) {
+    if (knownInvalidChildren[parent].has(child)) return false;
+  }
+  if (child in knownInvalidParents) {
+    if (knownInvalidParents[child].has(parent)) return false;
+  }
+  return true;
+}
+const headings = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+const emptySet = /* @__PURE__ */ new Set([]);
+const onlyValidChildren = {
+  head: /* @__PURE__ */ new Set([
+    "base",
+    "basefront",
+    "bgsound",
+    "link",
+    "meta",
+    "title",
+    "noscript",
+    "noframes",
+    "style",
+    "script",
+    "template"
+  ]),
+  optgroup: /* @__PURE__ */ new Set(["option"]),
+  select: /* @__PURE__ */ new Set(["optgroup", "option", "hr"]),
+  // table
+  table: /* @__PURE__ */ new Set(["caption", "colgroup", "tbody", "tfoot", "thead"]),
+  tr: /* @__PURE__ */ new Set(["td", "th"]),
+  colgroup: /* @__PURE__ */ new Set(["col"]),
+  tbody: /* @__PURE__ */ new Set(["tr"]),
+  thead: /* @__PURE__ */ new Set(["tr"]),
+  tfoot: /* @__PURE__ */ new Set(["tr"]),
+  // these elements can not have any children elements
+  script: emptySet,
+  iframe: emptySet,
+  option: emptySet,
+  textarea: emptySet,
+  style: emptySet,
+  title: emptySet
+};
+const onlyValidParents = {
+  // sections
+  html: emptySet,
+  body: /* @__PURE__ */ new Set(["html"]),
+  head: /* @__PURE__ */ new Set(["html"]),
+  // table
+  td: /* @__PURE__ */ new Set(["tr"]),
+  colgroup: /* @__PURE__ */ new Set(["table"]),
+  caption: /* @__PURE__ */ new Set(["table"]),
+  tbody: /* @__PURE__ */ new Set(["table"]),
+  tfoot: /* @__PURE__ */ new Set(["table"]),
+  col: /* @__PURE__ */ new Set(["colgroup"]),
+  th: /* @__PURE__ */ new Set(["tr"]),
+  thead: /* @__PURE__ */ new Set(["table"]),
+  tr: /* @__PURE__ */ new Set(["tbody", "thead", "tfoot"]),
+  // data list
+  dd: /* @__PURE__ */ new Set(["dl", "div"]),
+  dt: /* @__PURE__ */ new Set(["dl", "div"]),
+  // other
+  figcaption: /* @__PURE__ */ new Set(["figure"]),
+  // li: new Set(["ul", "ol"]),
+  summary: /* @__PURE__ */ new Set(["details"]),
+  area: /* @__PURE__ */ new Set(["map"])
+};
+const knownInvalidChildren = {
+  p: /* @__PURE__ */ new Set([
+    "address",
+    "article",
+    "aside",
+    "blockquote",
+    "center",
+    "details",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "fieldset",
+    "figure",
+    "footer",
+    "form",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "header",
+    "hgroup",
+    "hr",
+    "li",
+    "main",
+    "nav",
+    "menu",
+    "ol",
+    "p",
+    "pre",
+    "section",
+    "table",
+    "ul"
+  ]),
+  svg: /* @__PURE__ */ new Set([
+    "b",
+    "blockquote",
+    "br",
+    "code",
+    "dd",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "embed",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "hr",
+    "i",
+    "img",
+    "li",
+    "menu",
+    "meta",
+    "ol",
+    "p",
+    "pre",
+    "ruby",
+    "s",
+    "small",
+    "span",
+    "strong",
+    "sub",
+    "sup",
+    "table",
+    "u",
+    "ul",
+    "var"
+  ])
+};
+const knownInvalidParents = {
+  a: /* @__PURE__ */ new Set(["a"]),
+  button: /* @__PURE__ */ new Set(["button"]),
+  dd: /* @__PURE__ */ new Set(["dd", "dt"]),
+  dt: /* @__PURE__ */ new Set(["dd", "dt"]),
+  form: /* @__PURE__ */ new Set(["form"]),
+  li: /* @__PURE__ */ new Set(["li"]),
+  h1: headings,
+  h2: headings,
+  h3: headings,
+  h4: headings,
+  h5: headings,
+  h6: headings
+};
+
+const validateHtmlNesting = (node, context) => {
+  if (node.type === 1 && node.tagType === 0 && context.parent && context.parent.type === 1 && context.parent.tagType === 0 && !isValidHTMLNesting(context.parent.tag, node.tag)) {
+    const error = new SyntaxError(
+      `<${node.tag}> cannot be child of <${context.parent.tag}>, according to HTML specifications. This can cause hydration errors or potentially disrupt future functionality.`
+    );
+    error.loc = node.loc;
+    context.onWarn(error);
+  }
+};
+
+const DOMNodeTransforms = [
+  transformStyle,
+  ...!!(process.env.NODE_ENV !== "production") ? [transformTransition, validateHtmlNesting] : []
+];
+const DOMDirectiveTransforms = {
+  cloak: noopDirectiveTransform,
+  html: transformVHtml,
+  text: transformVText,
+  model: transformModel,
+  // override compiler-core
+  on: transformOn,
+  // override compiler-core
+  show: transformShow
+};
+function compile(src, options = {}) {
+  return baseCompile(
+    src,
+    extend({}, parserOptions, options, {
+      nodeTransforms: [
+        // ignore <script> and <tag>
+        // this is not put inside DOMNodeTransforms because that list is used
+        // by compiler-ssr to generate vnode fallback branches
+        ignoreSideEffectTags,
+        ...DOMNodeTransforms,
+        ...options.nodeTransforms || []
+      ],
+      directiveTransforms: extend(
+        {},
+        DOMDirectiveTransforms,
+        options.directiveTransforms || {}
+      ),
+      transformHoist: null 
+    })
+  );
+}
+function parse(template, options = {}) {
+  return baseParse(template, extend({}, parserOptions, options));
+}
+
+export { DOMDirectiveTransforms, DOMErrorCodes, DOMErrorMessages, DOMNodeTransforms, TRANSITION, TRANSITION_GROUP, V_MODEL_CHECKBOX, V_MODEL_DYNAMIC, V_MODEL_RADIO, V_MODEL_SELECT, V_MODEL_TEXT, V_ON_WITH_KEYS, V_ON_WITH_MODIFIERS, V_SHOW, compile, createDOMCompilerError, parse, parserOptions, transformStyle };

node_modules/@vue/compiler-dom/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/compiler-dom.cjs.prod.js')
+} else {
+  module.exports = require('./dist/compiler-dom.cjs.js')
+}

node_modules/@vue/compiler-dom/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@vue/compiler-dom",
+  "version": "3.5.22",
+  "description": "@vue/compiler-dom",
+  "main": "index.js",
+  "module": "dist/compiler-dom.esm-bundler.js",
+  "types": "dist/compiler-dom.d.ts",
+  "unpkg": "dist/compiler-dom.global.js",
+  "jsdelivr": "dist/compiler-dom.global.js",
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/compiler-dom.d.ts",
+      "node": {
+        "production": "./dist/compiler-dom.cjs.prod.js",
+        "development": "./dist/compiler-dom.cjs.js",
+        "default": "./index.js"
+      },
+      "module": "./dist/compiler-dom.esm-bundler.js",
+      "import": "./dist/compiler-dom.esm-bundler.js",
+      "require": "./index.js"
+    },
+    "./*": "./*"
+  },
+  "sideEffects": false,
+  "buildOptions": {
+    "name": "VueCompilerDOM",
+    "compat": true,
+    "formats": [
+      "esm-bundler",
+      "esm-browser",
+      "cjs",
+      "global"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/compiler-dom"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-dom#readme",
+  "dependencies": {
+    "@vue/shared": "3.5.22",
+    "@vue/compiler-core": "3.5.22"
+  }
+}

node_modules/@vue/compiler-sfc/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present, Yuxi (Evan) You
+
+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.

node_modules/@vue/compiler-sfc/README.md

@@ -0,0 +1,80 @@
+# @vue/compiler-sfc
+
+> Lower level utilities for compiling Vue Single File Components
+
+**Note: as of 3.2.13+, this package is included as a dependency of the main `vue` package and can be accessed as `vue/compiler-sfc`. This means you no longer need to explicitly install this package and ensure its version match that of `vue`'s. Just use the main `vue/compiler-sfc` deep import instead.**
+
+This package contains lower level utilities that you can use if you are writing a plugin / transform for a bundler or module system that compiles Vue Single File Components (SFCs) into JavaScript. It is used in [vue-loader](https://github.com/vuejs/vue-loader) and [@vitejs/plugin-vue](https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue).
+
+## API
+
+The API is intentionally low-level due to the various considerations when integrating Vue SFCs in a build system:
+
+- Separate hot-module replacement (HMR) for script, template and styles
+
+  - template updates should not reset component state
+  - style updates should be performed without component re-render
+
+- Leveraging the tool's plugin system for pre-processor handling. e.g. `<style lang="scss">` should be processed by the corresponding webpack loader.
+
+- In some cases, transformers of each block in an SFC do not share the same execution context. For example, when used with `thread-loader` or other parallelized configurations, the template sub-loader in `vue-loader` may not have access to the full SFC and its descriptor.
+
+The general idea is to generate a facade module that imports the individual blocks of the component. The trick is the module imports itself with different query strings so that the build system can handle each request as "virtual" modules:
+
+```
+                                  +--------------------+
+                                  |                    |
+                                  |  script transform  |
+                           +----->+                    |
+                           |      +--------------------+
+                           |
++--------------------+     |      +--------------------+
+|                    |     |      |                    |
+|  facade transform  +----------->+ template transform |
+|                    |     |      |                    |
++--------------------+     |      +--------------------+
+                           |
+                           |      +--------------------+
+                           +----->+                    |
+                                  |  style transform   |
+                                  |                    |
+                                  +--------------------+
+```
+
+Where the facade module looks like this:
+
+```js
+// main script
+import script from '/project/foo.vue?vue&type=script'
+// template compiled to render function
+import { render } from '/project/foo.vue?vue&type=template&id=xxxxxx'
+// css
+import '/project/foo.vue?vue&type=style&index=0&id=xxxxxx'
+
+// attach render function to script
+script.render = render
+
+// attach additional metadata
+// some of these should be dev only
+script.__file = 'example.vue'
+script.__scopeId = 'xxxxxx'
+
+// additional tooling-specific HMR handling code
+// using __VUE_HMR_API__ global
+
+export default script
+```
+
+### High Level Workflow
+
+1. In facade transform, parse the source into descriptor with the `parse` API and generate the above facade module code based on the descriptor;
+
+2. In script transform, use `compileScript` to process the script. This handles features like `<script setup>` and CSS variable injection. Alternatively, this can be done directly in the facade module (with the code inlined instead of imported), but it will require rewriting `export default` to a temp variable (a `rewriteDefault` convenience API is provided for this purpose) so additional options can be attached to the exported object.
+
+3. In template transform, use `compileTemplate` to compile the raw template into render function code.
+
+4. In style transform, use `compileStyle` to compile raw CSS to handle `<style scoped>`, `<style module>` and CSS variable injection.
+
+Options needed for these APIs can be passed via the query string.
+
+For detailed API references and options, check out the source type definitions. For actual usage of these APIs, check out [@vitejs/plugin-vue](https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue) or [vue-loader](https://github.com/vuejs/vue-loader/tree/next).

node_modules/@vue/compiler-sfc/dist/compiler-sfc.d.ts

@@ -0,0 +1,485 @@
+import * as _babel_types from '@babel/types';
+import { Statement, Expression, TSType, Node, Program, CallExpression, ObjectPattern, TSModuleDeclaration, TSPropertySignature, TSMethodSignature, TSCallSignatureDeclaration, TSFunctionType } from '@babel/types';
+import { RootNode, CompilerOptions, CodegenResult, ParserOptions, RawSourceMap, CompilerError, SourceLocation, BindingMetadata as BindingMetadata$1 } from '@vue/compiler-core';
+export { BindingMetadata, CompilerError, CompilerOptions, extractIdentifiers, generateCodeFrame, isInDestructureAssignment, isStaticProperty, walkIdentifiers } from '@vue/compiler-core';
+import { ParserPlugin } from '@babel/parser';
+export { parse as babelParse } from '@babel/parser';
+import { Result, LazyResult } from 'postcss';
+import MagicString from 'magic-string';
+export { default as MagicString } from 'magic-string';
+import TS from 'typescript';
+
+export interface AssetURLTagConfig {
+    [name: string]: string[];
+}
+export interface AssetURLOptions {
+    /**
+     * If base is provided, instead of transforming relative asset urls into
+     * imports, they will be directly rewritten to absolute urls.
+     */
+    base?: string | null;
+    /**
+     * If true, also processes absolute urls.
+     */
+    includeAbsolute?: boolean;
+    tags?: AssetURLTagConfig;
+}
+
+export interface TemplateCompiler {
+    compile(source: string | RootNode, options: CompilerOptions): CodegenResult;
+    parse(template: string, options: ParserOptions): RootNode;
+}
+export interface SFCTemplateCompileResults {
+    code: string;
+    ast?: RootNode;
+    preamble?: string;
+    source: string;
+    tips: string[];
+    errors: (string | CompilerError)[];
+    map?: RawSourceMap;
+}
+export interface SFCTemplateCompileOptions {
+    source: string;
+    ast?: RootNode;
+    filename: string;
+    id: string;
+    scoped?: boolean;
+    slotted?: boolean;
+    isProd?: boolean;
+    ssr?: boolean;
+    ssrCssVars?: string[];
+    inMap?: RawSourceMap;
+    compiler?: TemplateCompiler;
+    compilerOptions?: CompilerOptions;
+    preprocessLang?: string;
+    preprocessOptions?: any;
+    /**
+     * In some cases, compiler-sfc may not be inside the project root (e.g. when
+     * linked or globally installed). In such cases a custom `require` can be
+     * passed to correctly resolve the preprocessors.
+     */
+    preprocessCustomRequire?: (id: string) => any;
+    /**
+     * Configure what tags/attributes to transform into asset url imports,
+     * or disable the transform altogether with `false`.
+     */
+    transformAssetUrls?: AssetURLOptions | AssetURLTagConfig | boolean;
+}
+export declare function compileTemplate(options: SFCTemplateCompileOptions): SFCTemplateCompileResults;
+
+export interface SFCScriptCompileOptions {
+    /**
+     * Scope ID for prefixing injected CSS variables.
+     * This must be consistent with the `id` passed to `compileStyle`.
+     */
+    id: string;
+    /**
+     * Production mode. Used to determine whether to generate hashed CSS variables
+     */
+    isProd?: boolean;
+    /**
+     * Enable/disable source map. Defaults to true.
+     */
+    sourceMap?: boolean;
+    /**
+     * https://babeljs.io/docs/en/babel-parser#plugins
+     */
+    babelParserPlugins?: ParserPlugin[];
+    /**
+     * A list of files to parse for global types to be made available for type
+     * resolving in SFC macros. The list must be fully resolved file system paths.
+     */
+    globalTypeFiles?: string[];
+    /**
+     * Compile the template and inline the resulting render function
+     * directly inside setup().
+     * - Only affects `<script setup>`
+     * - This should only be used in production because it prevents the template
+     * from being hot-reloaded separately from component state.
+     */
+    inlineTemplate?: boolean;
+    /**
+     * Generate the final component as a variable instead of default export.
+     * This is useful in e.g. @vitejs/plugin-vue where the script needs to be
+     * placed inside the main module.
+     */
+    genDefaultAs?: string;
+    /**
+     * Options for template compilation when inlining. Note these are options that
+     * would normally be passed to `compiler-sfc`'s own `compileTemplate()`, not
+     * options passed to `compiler-dom`.
+     */
+    templateOptions?: Partial<SFCTemplateCompileOptions>;
+    /**
+     * Hoist <script setup> static constants.
+     * - Only enables when one `<script setup>` exists.
+     * @default true
+     */
+    hoistStatic?: boolean;
+    /**
+     * Set to `false` to disable reactive destructure for `defineProps` (pre-3.5
+     * behavior), or set to `'error'` to throw hard error on props destructures.
+     * @default true
+     */
+    propsDestructure?: boolean | 'error';
+    /**
+     * File system access methods to be used when resolving types
+     * imported in SFC macros. Defaults to ts.sys in Node.js, can be overwritten
+     * to use a virtual file system for use in browsers (e.g. in REPLs)
+     */
+    fs?: {
+        fileExists(file: string): boolean;
+        readFile(file: string): string | undefined;
+        realpath?(file: string): string;
+    };
+    /**
+     * Transform Vue SFCs into custom elements.
+     */
+    customElement?: boolean | ((filename: string) => boolean);
+}
+interface ImportBinding {
+    isType: boolean;
+    imported: string;
+    local: string;
+    source: string;
+    isFromSetup: boolean;
+    isUsedInTemplate: boolean;
+}
+/**
+ * Compile `<script setup>`
+ * It requires the whole SFC descriptor because we need to handle and merge
+ * normal `<script>` + `<script setup>` if both are present.
+ */
+export declare function compileScript(sfc: SFCDescriptor, options: SFCScriptCompileOptions): SFCScriptBlock;
+
+export interface SFCParseOptions {
+    filename?: string;
+    sourceMap?: boolean;
+    sourceRoot?: string;
+    pad?: boolean | 'line' | 'space';
+    ignoreEmpty?: boolean;
+    compiler?: TemplateCompiler;
+    templateParseOptions?: ParserOptions;
+}
+export interface SFCBlock {
+    type: string;
+    content: string;
+    attrs: Record<string, string | true>;
+    loc: SourceLocation;
+    map?: RawSourceMap;
+    lang?: string;
+    src?: string;
+}
+export interface SFCTemplateBlock extends SFCBlock {
+    type: 'template';
+    ast?: RootNode;
+}
+export interface SFCScriptBlock extends SFCBlock {
+    type: 'script';
+    setup?: string | boolean;
+    bindings?: BindingMetadata$1;
+    imports?: Record<string, ImportBinding>;
+    scriptAst?: _babel_types.Statement[];
+    scriptSetupAst?: _babel_types.Statement[];
+    warnings?: string[];
+    /**
+     * Fully resolved dependency file paths (unix slashes) with imported types
+     * used in macros, used for HMR cache busting in @vitejs/plugin-vue and
+     * vue-loader.
+     */
+    deps?: string[];
+}
+export interface SFCStyleBlock extends SFCBlock {
+    type: 'style';
+    scoped?: boolean;
+    module?: string | boolean;
+}
+export interface SFCDescriptor {
+    filename: string;
+    source: string;
+    template: SFCTemplateBlock | null;
+    script: SFCScriptBlock | null;
+    scriptSetup: SFCScriptBlock | null;
+    styles: SFCStyleBlock[];
+    customBlocks: SFCBlock[];
+    cssVars: string[];
+    /**
+     * whether the SFC uses :slotted() modifier.
+     * this is used as a compiler optimization hint.
+     */
+    slotted: boolean;
+    /**
+     * compare with an existing descriptor to determine whether HMR should perform
+     * a reload vs. re-render.
+     *
+     * Note: this comparison assumes the prev/next script are already identical,
+     * and only checks the special case where <script setup lang="ts"> unused import
+     * pruning result changes due to template changes.
+     */
+    shouldForceReload: (prevImports: Record<string, ImportBinding>) => boolean;
+}
+export interface SFCParseResult {
+    descriptor: SFCDescriptor;
+    errors: (CompilerError | SyntaxError)[];
+}
+export declare function parse(source: string, options?: SFCParseOptions): SFCParseResult;
+
+type PreprocessLang = 'less' | 'sass' | 'scss' | 'styl' | 'stylus';
+
+export interface SFCStyleCompileOptions {
+    source: string;
+    filename: string;
+    id: string;
+    scoped?: boolean;
+    trim?: boolean;
+    isProd?: boolean;
+    inMap?: RawSourceMap;
+    preprocessLang?: PreprocessLang;
+    preprocessOptions?: any;
+    preprocessCustomRequire?: (id: string) => any;
+    postcssOptions?: any;
+    postcssPlugins?: any[];
+    /**
+     * @deprecated use `inMap` instead.
+     */
+    map?: RawSourceMap;
+}
+/**
+ * Aligns with postcss-modules
+ * https://github.com/css-modules/postcss-modules
+ */
+interface CSSModulesOptions {
+    scopeBehaviour?: 'global' | 'local';
+    generateScopedName?: string | ((name: string, filename: string, css: string) => string);
+    hashPrefix?: string;
+    localsConvention?: 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashesOnly';
+    exportGlobals?: boolean;
+    globalModulePaths?: RegExp[];
+}
+export interface SFCAsyncStyleCompileOptions extends SFCStyleCompileOptions {
+    isAsync?: boolean;
+    modules?: boolean;
+    modulesOptions?: CSSModulesOptions;
+}
+export interface SFCStyleCompileResults {
+    code: string;
+    map: RawSourceMap | undefined;
+    rawResult: Result | LazyResult | undefined;
+    errors: Error[];
+    modules?: Record<string, string>;
+    dependencies: Set<string>;
+}
+export declare function compileStyle(options: SFCStyleCompileOptions): SFCStyleCompileResults;
+export declare function compileStyleAsync(options: SFCAsyncStyleCompileOptions): Promise<SFCStyleCompileResults>;
+
+export declare function rewriteDefault(input: string, as: string, parserPlugins?: ParserPlugin[]): string;
+/**
+ * Utility for rewriting `export default` in a script block into a variable
+ * declaration so that we can inject things into it
+ */
+export declare function rewriteDefaultAST(ast: Statement[], s: MagicString, as: string): void;
+
+type PropsDestructureBindings = Record<string, // public prop key
+{
+    local: string;
+    default?: Expression;
+}>;
+export declare function extractRuntimeProps(ctx: TypeResolveContext): string | undefined;
+
+interface ModelDecl {
+    type: TSType | undefined;
+    options: string | undefined;
+    identifier: string | undefined;
+    runtimeOptionNodes: Node[];
+}
+
+declare enum BindingTypes {
+    /**
+     * returned from data()
+     */
+    DATA = "data",
+    /**
+     * declared as a prop
+     */
+    PROPS = "props",
+    /**
+     * a local alias of a `<script setup>` destructured prop.
+     * the original is stored in __propsAliases of the bindingMetadata object.
+     */
+    PROPS_ALIASED = "props-aliased",
+    /**
+     * a let binding (may or may not be a ref)
+     */
+    SETUP_LET = "setup-let",
+    /**
+     * a const binding that can never be a ref.
+     * these bindings don't need `unref()` calls when processed in inlined
+     * template expressions.
+     */
+    SETUP_CONST = "setup-const",
+    /**
+     * a const binding that does not need `unref()`, but may be mutated.
+     */
+    SETUP_REACTIVE_CONST = "setup-reactive-const",
+    /**
+     * a const binding that may be a ref.
+     */
+    SETUP_MAYBE_REF = "setup-maybe-ref",
+    /**
+     * bindings that are guaranteed to be refs
+     */
+    SETUP_REF = "setup-ref",
+    /**
+     * declared by other options, e.g. computed, inject
+     */
+    OPTIONS = "options",
+    /**
+     * a literal constant, e.g. 'foo', 1, true
+     */
+    LITERAL_CONST = "literal-const"
+}
+type BindingMetadata = {
+    [key: string]: BindingTypes | undefined;
+} & {
+    __isScriptSetup?: boolean;
+    __propsAliases?: Record<string, string>;
+};
+
+export declare class ScriptCompileContext {
+    descriptor: SFCDescriptor;
+    options: Partial<SFCScriptCompileOptions>;
+    isJS: boolean;
+    isTS: boolean;
+    isCE: boolean;
+    scriptAst: Program | null;
+    scriptSetupAst: Program | null;
+    source: string;
+    filename: string;
+    s: MagicString;
+    startOffset: number | undefined;
+    endOffset: number | undefined;
+    scope?: TypeScope;
+    globalScopes?: TypeScope[];
+    userImports: Record<string, ImportBinding>;
+    hasDefinePropsCall: boolean;
+    hasDefineEmitCall: boolean;
+    hasDefineExposeCall: boolean;
+    hasDefaultExportName: boolean;
+    hasDefaultExportRender: boolean;
+    hasDefineOptionsCall: boolean;
+    hasDefineSlotsCall: boolean;
+    hasDefineModelCall: boolean;
+    propsCall: CallExpression | undefined;
+    propsDecl: Node | undefined;
+    propsRuntimeDecl: Node | undefined;
+    propsTypeDecl: Node | undefined;
+    propsDestructureDecl: ObjectPattern | undefined;
+    propsDestructuredBindings: PropsDestructureBindings;
+    propsDestructureRestId: string | undefined;
+    propsRuntimeDefaults: Node | undefined;
+    emitsRuntimeDecl: Node | undefined;
+    emitsTypeDecl: Node | undefined;
+    emitDecl: Node | undefined;
+    modelDecls: Record<string, ModelDecl>;
+    optionsRuntimeDecl: Node | undefined;
+    bindingMetadata: BindingMetadata;
+    helperImports: Set<string>;
+    helper(key: string): string;
+    /**
+     * to be exposed on compiled script block for HMR cache busting
+     */
+    deps?: Set<string>;
+    /**
+     * cache for resolved fs
+     */
+    fs?: NonNullable<SFCScriptCompileOptions['fs']>;
+    constructor(descriptor: SFCDescriptor, options: Partial<SFCScriptCompileOptions>);
+    getString(node: Node, scriptSetup?: boolean): string;
+    warn(msg: string, node: Node, scope?: TypeScope): void;
+    error(msg: string, node: Node, scope?: TypeScope): never;
+}
+
+export type SimpleTypeResolveOptions = Partial<Pick<SFCScriptCompileOptions, 'globalTypeFiles' | 'fs' | 'babelParserPlugins' | 'isProd'>>;
+/**
+ * TypeResolveContext is compatible with ScriptCompileContext
+ * but also allows a simpler version of it with minimal required properties
+ * when resolveType needs to be used in a non-SFC context, e.g. in a babel
+ * plugin. The simplest context can be just:
+ * ```ts
+ * const ctx: SimpleTypeResolveContext = {
+ *   filename: '...',
+ *   source: '...',
+ *   options: {},
+ *   error() {},
+ *   ast: []
+ * }
+ * ```
+ */
+export type SimpleTypeResolveContext = Pick<ScriptCompileContext, 'source' | 'filename' | 'error' | 'helper' | 'getString' | 'propsTypeDecl' | 'propsRuntimeDefaults' | 'propsDestructuredBindings' | 'emitsTypeDecl' | 'isCE'> & Partial<Pick<ScriptCompileContext, 'scope' | 'globalScopes' | 'deps' | 'fs'>> & {
+    ast: Statement[];
+    options: SimpleTypeResolveOptions;
+};
+export type TypeResolveContext = ScriptCompileContext | SimpleTypeResolveContext;
+type Import = Pick<ImportBinding, 'source' | 'imported'>;
+interface WithScope {
+    _ownerScope: TypeScope;
+}
+type ScopeTypeNode = Node & WithScope & {
+    _ns?: TSModuleDeclaration & WithScope;
+};
+declare class TypeScope {
+    filename: string;
+    source: string;
+    offset: number;
+    imports: Record<string, Import>;
+    types: Record<string, ScopeTypeNode>;
+    declares: Record<string, ScopeTypeNode>;
+    constructor(filename: string, source: string, offset?: number, imports?: Record<string, Import>, types?: Record<string, ScopeTypeNode>, declares?: Record<string, ScopeTypeNode>);
+    isGenericScope: boolean;
+    resolvedImportSources: Record<string, string>;
+    exportedTypes: Record<string, ScopeTypeNode>;
+    exportedDeclares: Record<string, ScopeTypeNode>;
+}
+interface MaybeWithScope {
+    _ownerScope?: TypeScope;
+}
+interface ResolvedElements {
+    props: Record<string, (TSPropertySignature | TSMethodSignature) & {
+        _ownerScope: TypeScope;
+    }>;
+    calls?: (TSCallSignatureDeclaration | TSFunctionType)[];
+}
+/**
+ * Resolve arbitrary type node to a list of type elements that can be then
+ * mapped to runtime props or emits.
+ */
+export declare function resolveTypeElements(ctx: TypeResolveContext, node: Node & MaybeWithScope & {
+    _resolvedElements?: ResolvedElements;
+}, scope?: TypeScope, typeParameters?: Record<string, Node>): ResolvedElements;
+/**
+ * @private
+ */
+export declare function registerTS(_loadTS: () => typeof TS): void;
+/**
+ * @private
+ */
+export declare function invalidateTypeCache(filename: string): void;
+export declare function inferRuntimeType(ctx: TypeResolveContext, node: Node & MaybeWithScope, scope?: TypeScope, isKeyOf?: boolean, typeParameters?: Record<string, Node>): string[];
+
+export declare function extractRuntimeEmits(ctx: TypeResolveContext): Set<string>;
+
+export declare const version: string;
+
+export declare const parseCache: Map<string, SFCParseResult>;
+export declare const errorMessages: Record<number, string>;
+
+export declare const walk: any;
+
+/**
+ * @deprecated this is preserved to avoid breaking vite-plugin-vue < 5.0
+ * with reactivityTransform: true. The desired behavior should be silently
+ * ignoring the option instead of breaking.
+ */
+export declare const shouldTransformRef: () => boolean;
+
+

node_modules/@vue/compiler-sfc/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@vue/compiler-sfc",
+  "version": "3.5.22",
+  "description": "@vue/compiler-sfc",
+  "main": "dist/compiler-sfc.cjs.js",
+  "module": "dist/compiler-sfc.esm-browser.js",
+  "types": "dist/compiler-sfc.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/compiler-sfc.d.ts",
+      "node": "./dist/compiler-sfc.cjs.js",
+      "module": "./dist/compiler-sfc.esm-browser.js",
+      "import": "./dist/compiler-sfc.esm-browser.js",
+      "require": "./dist/compiler-sfc.cjs.js"
+    },
+    "./*": "./*"
+  },
+  "buildOptions": {
+    "name": "VueCompilerSFC",
+    "formats": [
+      "cjs",
+      "esm-browser"
+    ],
+    "prod": false,
+    "enableNonBrowserBranches": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/compiler-sfc"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-sfc#readme",
+  "dependencies": {
+    "@babel/parser": "^7.28.4",
+    "estree-walker": "^2.0.2",
+    "magic-string": "^0.30.19",
+    "postcss": "^8.5.6",
+    "source-map-js": "^1.2.1",
+    "@vue/compiler-core": "3.5.22",
+    "@vue/compiler-ssr": "3.5.22",
+    "@vue/shared": "3.5.22",
+    "@vue/compiler-dom": "3.5.22"
+  },
+  "devDependencies": {
+    "@babel/types": "^7.28.4",
+    "@vue/consolidate": "^1.0.0",
+    "hash-sum": "^2.0.0",
+    "lru-cache": "10.1.0",
+    "merge-source-map": "^1.1.0",
+    "minimatch": "~10.0.3",
+    "postcss-modules": "^6.0.1",
+    "postcss-selector-parser": "^7.1.0",
+    "pug": "^3.0.3",
+    "sass": "^1.93.2"
+  }
+}

node_modules/@vue/compiler-ssr/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present, Yuxi (Evan) You
+
+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.

node_modules/@vue/compiler-ssr/README.md

@@ -0,0 +1 @@
+# @vue/compiler-ssr

node_modules/@vue/compiler-ssr/dist/compiler-ssr.d.ts

@@ -0,0 +1,4 @@
+import { RootNode, CompilerOptions, CodegenResult } from '@vue/compiler-dom';
+
+export declare function compile(source: string | RootNode, options?: CompilerOptions): CodegenResult;
+

node_modules/@vue/compiler-ssr/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@vue/compiler-ssr",
+  "version": "3.5.22",
+  "description": "@vue/compiler-ssr",
+  "main": "dist/compiler-ssr.cjs.js",
+  "types": "dist/compiler-ssr.d.ts",
+  "files": [
+    "dist"
+  ],
+  "buildOptions": {
+    "prod": false,
+    "formats": [
+      "cjs"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/compiler-ssr"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-ssr#readme",
+  "dependencies": {
+    "@vue/shared": "3.5.22",
+    "@vue/compiler-dom": "3.5.22"
+  }
+}

node_modules/@vue/devtools-api/lib/cjs/api/api.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@vue/devtools-api/lib/cjs/api/app.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@vue/devtools-api/lib/cjs/api/component.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@vue/devtools-api/lib/cjs/api/context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@vue/devtools-api/lib/cjs/api/hooks.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@vue/devtools-api/lib/cjs/api/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api.js"), exports);
+__exportStar(require("./app.js"), exports);
+__exportStar(require("./component.js"), exports);
+__exportStar(require("./context.js"), exports);
+__exportStar(require("./hooks.js"), exports);
+__exportStar(require("./util.js"), exports);

node_modules/@vue/devtools-api/lib/cjs/api/util.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@vue/devtools-api/lib/cjs/const.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOOK_PLUGIN_SETTINGS_SET = exports.HOOK_SETUP = void 0;
+exports.HOOK_SETUP = 'devtools-plugin:setup';
+exports.HOOK_PLUGIN_SETTINGS_SET = 'plugin:settings:set';

node_modules/@vue/devtools-api/lib/cjs/env.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProxyAvailable = exports.getTarget = exports.getDevtoolsGlobalHook = void 0;
+function getDevtoolsGlobalHook() {
+    return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;
+}
+exports.getDevtoolsGlobalHook = getDevtoolsGlobalHook;
+function getTarget() {
+    // @ts-expect-error navigator and windows are not available in all environments
+    return (typeof navigator !== 'undefined' && typeof window !== 'undefined')
+        ? window
+        : typeof globalThis !== 'undefined'
+            ? globalThis
+            : {};
+}
+exports.getTarget = getTarget;
+exports.isProxyAvailable = typeof Proxy === 'function';

node_modules/@vue/devtools-api/lib/cjs/index.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupDevtoolsPlugin = void 0;
+const env_js_1 = require("./env.js");
+const const_js_1 = require("./const.js");
+const proxy_js_1 = require("./proxy.js");
+__exportStar(require("./api/index.js"), exports);
+__exportStar(require("./plugin.js"), exports);
+__exportStar(require("./time.js"), exports);
+function setupDevtoolsPlugin(pluginDescriptor, setupFn) {
+    const descriptor = pluginDescriptor;
+    const target = (0, env_js_1.getTarget)();
+    const hook = (0, env_js_1.getDevtoolsGlobalHook)();
+    const enableProxy = env_js_1.isProxyAvailable && descriptor.enableEarlyProxy;
+    if (hook && (target.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !enableProxy)) {
+        hook.emit(const_js_1.HOOK_SETUP, pluginDescriptor, setupFn);
+    }
+    else {
+        const proxy = enableProxy ? new proxy_js_1.ApiProxy(descriptor, hook) : null;
+        const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || [];
+        list.push({
+            pluginDescriptor: descriptor,
+            setupFn,
+            proxy,
+        });
+        if (proxy) {
+            setupFn(proxy.proxiedTarget);
+        }
+    }
+}
+exports.setupDevtoolsPlugin = setupDevtoolsPlugin;

node_modules/@vue/devtools-api/lib/cjs/plugin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@vue/devtools-api/lib/cjs/proxy.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiProxy = void 0;
+const const_js_1 = require("./const.js");
+const time_js_1 = require("./time.js");
+class ApiProxy {
+    constructor(plugin, hook) {
+        this.target = null;
+        this.targetQueue = [];
+        this.onQueue = [];
+        this.plugin = plugin;
+        this.hook = hook;
+        const defaultSettings = {};
+        if (plugin.settings) {
+            for (const id in plugin.settings) {
+                const item = plugin.settings[id];
+                defaultSettings[id] = item.defaultValue;
+            }
+        }
+        const localSettingsSaveId = `__vue-devtools-plugin-settings__${plugin.id}`;
+        let currentSettings = Object.assign({}, defaultSettings);
+        try {
+            const raw = localStorage.getItem(localSettingsSaveId);
+            const data = JSON.parse(raw);
+            Object.assign(currentSettings, data);
+        }
+        catch (e) {
+            // noop
+        }
+        this.fallbacks = {
+            getSettings() {
+                return currentSettings;
+            },
+            setSettings(value) {
+                try {
+                    localStorage.setItem(localSettingsSaveId, JSON.stringify(value));
+                }
+                catch (e) {
+                    // noop
+                }
+                currentSettings = value;
+            },
+            now() {
+                return (0, time_js_1.now)();
+            },
+        };
+        if (hook) {
+            hook.on(const_js_1.HOOK_PLUGIN_SETTINGS_SET, (pluginId, value) => {
+                if (pluginId === this.plugin.id) {
+                    this.fallbacks.setSettings(value);
+                }
+            });
+        }
+        this.proxiedOn = new Proxy({}, {
+            get: (_target, prop) => {
+                if (this.target) {
+                    return this.target.on[prop];
+                }
+                else {
+                    return (...args) => {
+                        this.onQueue.push({
+                            method: prop,
+                            args,
+                        });
+                    };
+                }
+            },
+        });
+        this.proxiedTarget = new Proxy({}, {
+            get: (_target, prop) => {
+                if (this.target) {
+                    return this.target[prop];
+                }
+                else if (prop === 'on') {
+                    return this.proxiedOn;
+                }
+                else if (Object.keys(this.fallbacks).includes(prop)) {
+                    return (...args) => {
+                        this.targetQueue.push({
+                            method: prop,
+                            args,
+                            resolve: () => { },
+                        });
+                        return this.fallbacks[prop](...args);
+                    };
+                }
+                else {
+                    return (...args) => {
+                        return new Promise((resolve) => {
+                            this.targetQueue.push({
+                                method: prop,
+                                args,
+                                resolve,
+                            });
+                        });
+                    };
+                }
+            },
+        });
+    }
+    async setRealTarget(target) {
+        this.target = target;
+        for (const item of this.onQueue) {
+            this.target.on[item.method](...item.args);
+        }
+        for (const item of this.targetQueue) {
+            item.resolve(await this.target[item.method](...item.args));
+        }
+    }
+}
+exports.ApiProxy = ApiProxy;

node_modules/@vue/devtools-api/lib/cjs/time.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.now = exports.isPerformanceSupported = void 0;
+let supported;
+let perf;
+function isPerformanceSupported() {
+    var _a;
+    if (supported !== undefined) {
+        return supported;
+    }
+    if (typeof window !== 'undefined' && window.performance) {
+        supported = true;
+        perf = window.performance;
+    }
+    else if (typeof globalThis !== 'undefined' && ((_a = globalThis.perf_hooks) === null || _a === void 0 ? void 0 : _a.performance)) {
+        supported = true;
+        perf = globalThis.perf_hooks.performance;
+    }
+    else {
+        supported = false;
+    }
+    return supported;
+}
+exports.isPerformanceSupported = isPerformanceSupported;
+function now() {
+    return isPerformanceSupported() ? perf.now() : Date.now();
+}
+exports.now = now;

node_modules/@vue/devtools-api/lib/esm/api/api.d.ts

@@ -0,0 +1,108 @@
+import type { ComponentBounds, Hookable } from './hooks.js';
+import type { Context } from './context.js';
+import type { ComponentInstance, ComponentState, StateBase } from './component.js';
+import type { App } from './app.js';
+import type { ID } from './util.js';
+export interface DevtoolsPluginApi<TSettings> {
+    on: Hookable<Context>;
+    notifyComponentUpdate: (instance?: ComponentInstance) => void;
+    addTimelineLayer: (options: TimelineLayerOptions) => void;
+    addTimelineEvent: (options: TimelineEventOptions) => void;
+    addInspector: (options: CustomInspectorOptions) => void;
+    sendInspectorTree: (inspectorId: string) => void;
+    sendInspectorState: (inspectorId: string) => void;
+    selectInspectorNode: (inspectorId: string, nodeId: string) => void;
+    getComponentBounds: (instance: ComponentInstance) => Promise<ComponentBounds>;
+    getComponentName: (instance: ComponentInstance) => Promise<string>;
+    getComponentInstances: (app: App) => Promise<ComponentInstance[]>;
+    highlightElement: (instance: ComponentInstance) => void;
+    unhighlightElement: () => void;
+    getSettings: (pluginId?: string) => TSettings;
+    now: () => number;
+    /**
+     * @private
+     */
+    setSettings: (values: TSettings) => void;
+}
+export interface AppRecord {
+    id: string;
+    name: string;
+    instanceMap: Map<string, ComponentInstance>;
+    rootInstance: ComponentInstance;
+}
+export interface TimelineLayerOptions<TData = any, TMeta = any> {
+    id: string;
+    label: string;
+    color: number;
+    skipScreenshots?: boolean;
+    groupsOnly?: boolean;
+    ignoreNoDurationGroups?: boolean;
+    screenshotOverlayRender?: (event: TimelineEvent<TData, TMeta> & ScreenshotOverlayEvent, ctx: ScreenshotOverlayRenderContext) => ScreenshotOverlayRenderResult | Promise<ScreenshotOverlayRenderResult>;
+}
+export interface ScreenshotOverlayEvent {
+    layerId: string;
+    renderMeta: any;
+}
+export interface ScreenshotOverlayRenderContext<TData = any, TMeta = any> {
+    screenshot: ScreenshotData;
+    events: (TimelineEvent<TData, TMeta> & ScreenshotOverlayEvent)[];
+    index: number;
+}
+export type ScreenshotOverlayRenderResult = HTMLElement | string | false;
+export interface ScreenshotData {
+    time: number;
+}
+export interface TimelineEventOptions {
+    layerId: string;
+    event: TimelineEvent;
+    all?: boolean;
+}
+export interface TimelineEvent<TData = any, TMeta = any> {
+    time: number;
+    data: TData;
+    logType?: 'default' | 'warning' | 'error';
+    meta?: TMeta;
+    groupId?: ID;
+    title?: string;
+    subtitle?: string;
+}
+export interface TimelineMarkerOptions {
+    id: string;
+    time: number;
+    color: number;
+    label: string;
+    all?: boolean;
+}
+export interface CustomInspectorOptions {
+    id: string;
+    label: string;
+    icon?: string;
+    treeFilterPlaceholder?: string;
+    stateFilterPlaceholder?: string;
+    noSelectionText?: string;
+    actions?: {
+        icon: string;
+        tooltip?: string;
+        action: () => void | Promise<void>;
+    }[];
+    nodeActions?: {
+        icon: string;
+        tooltip?: string;
+        action: (nodeId: string) => void | Promise<void>;
+    }[];
+}
+export interface CustomInspectorNode {
+    id: string;
+    label: string;
+    children?: CustomInspectorNode[];
+    tags?: InspectorNodeTag[];
+}
+export interface InspectorNodeTag {
+    label: string;
+    textColor: number;
+    backgroundColor: number;
+    tooltip?: string;
+}
+export interface CustomInspectorState {
+    [key: string]: (StateBase | Omit<ComponentState, 'type'>)[];
+}

node_modules/@vue/devtools-api/lib/esm/api/api.js

@@ -0,0 +1 @@
+export {};

node_modules/@vue/devtools-api/lib/esm/api/app.d.ts

@@ -0,0 +1 @@
+export type App = any;

node_modules/@vue/devtools-api/lib/esm/api/app.js

@@ -0,0 +1 @@
+export {};

node_modules/@vue/devtools-api/lib/esm/api/component.d.ts

@@ -0,0 +1,78 @@
+import type { InspectorNodeTag } from './api.js';
+import type { ID } from './util.js';
+export type ComponentInstance = any;
+export interface ComponentTreeNode {
+    uid: ID;
+    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;
+}
+export interface InspectedComponentData {
+    id: string;
+    name: string;
+    file: string;
+    state: ComponentState[];
+    functional?: boolean;
+}
+export interface StateBase {
+    key: string;
+    value: any;
+    editable?: boolean;
+    objectType?: 'ref' | 'reactive' | 'computed' | 'other';
+    raw?: string;
+}
+export interface ComponentStateBase extends StateBase {
+    type: string;
+}
+export interface ComponentPropState extends ComponentStateBase {
+    meta?: {
+        type: string;
+        required: boolean;
+        /** Vue 1 only */
+        mode?: 'default' | 'sync' | 'once';
+    };
+}
+export type ComponentBuiltinCustomStateTypes = 'function' | 'map' | 'set' | 'reference' | 'component' | 'component-definition' | 'router' | 'store';
+export interface ComponentCustomState extends ComponentStateBase {
+    value: CustomState;
+}
+export 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;
+    };
+}
+export type ComponentState = ComponentStateBase | ComponentPropState | ComponentCustomState;
+export interface ComponentDevtoolsOptions {
+    hide?: boolean;
+}

node_modules/@vue/devtools-api/lib/esm/api/component.js

@@ -0,0 +1 @@
+export {};

node_modules/@vue/devtools-api/lib/esm/api/context.d.ts

@@ -0,0 +1,5 @@
+import type { AppRecord } from './api.js';
+export interface Context {
+    currentTab: string;
+    currentAppRecord: AppRecord;
+}

node_modules/@vue/devtools-api/lib/esm/api/context.js

@@ -0,0 +1 @@
+export {};

node_modules/@vue/devtools-api/lib/esm/api/hooks.d.ts

@@ -0,0 +1,180 @@
+import type { ComponentDevtoolsOptions, ComponentInstance, ComponentTreeNode, InspectedComponentData } from './component.js';
+import type { App } from './app.js';
+import type { CustomInspectorNode, CustomInspectorState, TimelineEvent } from './api.js';
+export declare const enum Hooks {
+    TRANSFORM_CALL = "transformCall",
+    GET_APP_RECORD_NAME = "getAppRecordName",
+    GET_APP_ROOT_INSTANCE = "getAppRootInstance",
+    REGISTER_APPLICATION = "registerApplication",
+    WALK_COMPONENT_TREE = "walkComponentTree",
+    VISIT_COMPONENT_TREE = "visitComponentTree",
+    WALK_COMPONENT_PARENTS = "walkComponentParents",
+    INSPECT_COMPONENT = "inspectComponent",
+    GET_COMPONENT_BOUNDS = "getComponentBounds",
+    GET_COMPONENT_NAME = "getComponentName",
+    GET_COMPONENT_INSTANCES = "getComponentInstances",
+    GET_ELEMENT_COMPONENT = "getElementComponent",
+    GET_COMPONENT_ROOT_ELEMENTS = "getComponentRootElements",
+    EDIT_COMPONENT_STATE = "editComponentState",
+    GET_COMPONENT_DEVTOOLS_OPTIONS = "getAppDevtoolsOptions",
+    GET_COMPONENT_RENDER_CODE = "getComponentRenderCode",
+    INSPECT_TIMELINE_EVENT = "inspectTimelineEvent",
+    TIMELINE_CLEARED = "timelineCleared",
+    GET_INSPECTOR_TREE = "getInspectorTree",
+    GET_INSPECTOR_STATE = "getInspectorState",
+    EDIT_INSPECTOR_STATE = "editInspectorState",
+    SET_PLUGIN_SETTINGS = "setPluginSettings"
+}
+export interface ComponentBounds {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface HookPayloads {
+    [Hooks.TRANSFORM_CALL]: {
+        callName: string;
+        inArgs: any[];
+        outArgs: any[];
+    };
+    [Hooks.GET_APP_RECORD_NAME]: {
+        app: App;
+        name: string;
+    };
+    [Hooks.GET_APP_ROOT_INSTANCE]: {
+        app: App;
+        root: ComponentInstance;
+    };
+    [Hooks.REGISTER_APPLICATION]: {
+        app: App;
+    };
+    [Hooks.WALK_COMPONENT_TREE]: {
+        componentInstance: ComponentInstance;
+        componentTreeData: ComponentTreeNode[];
+        maxDepth: number;
+        filter: string;
+        recursively: boolean;
+    };
+    [Hooks.VISIT_COMPONENT_TREE]: {
+        app: App;
+        componentInstance: ComponentInstance;
+        treeNode: ComponentTreeNode;
+        filter: string;
+    };
+    [Hooks.WALK_COMPONENT_PARENTS]: {
+        componentInstance: ComponentInstance;
+        parentInstances: ComponentInstance[];
+    };
+    [Hooks.INSPECT_COMPONENT]: {
+        app: App;
+        componentInstance: ComponentInstance;
+        instanceData: InspectedComponentData;
+    };
+    [Hooks.GET_COMPONENT_BOUNDS]: {
+        componentInstance: ComponentInstance;
+        bounds: ComponentBounds;
+    };
+    [Hooks.GET_COMPONENT_NAME]: {
+        componentInstance: ComponentInstance;
+        name: string;
+    };
+    [Hooks.GET_COMPONENT_INSTANCES]: {
+        app: App;
+        componentInstances: ComponentInstance[];
+    };
+    [Hooks.GET_ELEMENT_COMPONENT]: {
+        element: HTMLElement | any;
+        componentInstance: ComponentInstance;
+    };
+    [Hooks.GET_COMPONENT_ROOT_ELEMENTS]: {
+        componentInstance: ComponentInstance;
+        rootElements: (HTMLElement | any)[];
+    };
+    [Hooks.EDIT_COMPONENT_STATE]: {
+        app: App;
+        componentInstance: ComponentInstance;
+        path: string[];
+        type: string;
+        state: EditStatePayload;
+        set: (object: any, path?: string | (string[]), value?: any, cb?: (object: any, field: string, value: any) => void) => void;
+    };
+    [Hooks.GET_COMPONENT_DEVTOOLS_OPTIONS]: {
+        componentInstance: ComponentInstance;
+        options: ComponentDevtoolsOptions;
+    };
+    [Hooks.GET_COMPONENT_RENDER_CODE]: {
+        componentInstance: ComponentInstance;
+        code: string;
+    };
+    [Hooks.INSPECT_TIMELINE_EVENT]: {
+        app: App;
+        layerId: string;
+        event: TimelineEvent;
+        all?: boolean;
+        data: any;
+    };
+    [Hooks.TIMELINE_CLEARED]: Record<string, never>;
+    [Hooks.GET_INSPECTOR_TREE]: {
+        app: App;
+        inspectorId: string;
+        filter: string;
+        rootNodes: CustomInspectorNode[];
+    };
+    [Hooks.GET_INSPECTOR_STATE]: {
+        app: App;
+        inspectorId: string;
+        nodeId: string;
+        state: CustomInspectorState;
+    };
+    [Hooks.EDIT_INSPECTOR_STATE]: {
+        app: App;
+        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;
+    };
+    [Hooks.SET_PLUGIN_SETTINGS]: {
+        app: App;
+        pluginId: string;
+        key: string;
+        newValue: any;
+        oldValue: any;
+        settings: any;
+    };
+}
+export type EditStatePayload = {
+    value: any;
+    newKey?: string | null;
+    remove?: undefined | false;
+} | {
+    value?: undefined;
+    newKey?: undefined;
+    remove: true;
+};
+export type HookHandler<TPayload, TContext> = (payload: TPayload, ctx: TContext) => void | Promise<void>;
+export interface Hookable<TContext> {
+    transformCall: (handler: HookHandler<HookPayloads[Hooks.TRANSFORM_CALL], TContext>) => any;
+    getAppRecordName: (handler: HookHandler<HookPayloads[Hooks.GET_APP_RECORD_NAME], TContext>) => any;
+    getAppRootInstance: (handler: HookHandler<HookPayloads[Hooks.GET_APP_ROOT_INSTANCE], TContext>) => any;
+    registerApplication: (handler: HookHandler<HookPayloads[Hooks.REGISTER_APPLICATION], TContext>) => any;
+    walkComponentTree: (handler: HookHandler<HookPayloads[Hooks.WALK_COMPONENT_TREE], TContext>) => any;
+    visitComponentTree: (handler: HookHandler<HookPayloads[Hooks.VISIT_COMPONENT_TREE], TContext>) => any;
+    walkComponentParents: (handler: HookHandler<HookPayloads[Hooks.WALK_COMPONENT_PARENTS], TContext>) => any;
+    inspectComponent: (handler: HookHandler<HookPayloads[Hooks.INSPECT_COMPONENT], TContext>) => any;
+    getComponentBounds: (handler: HookHandler<HookPayloads[Hooks.GET_COMPONENT_BOUNDS], TContext>) => any;
+    getComponentName: (handler: HookHandler<HookPayloads[Hooks.GET_COMPONENT_NAME], TContext>) => any;
+    getComponentInstances: (handler: HookHandler<HookPayloads[Hooks.GET_COMPONENT_INSTANCES], TContext>) => any;
+    getElementComponent: (handler: HookHandler<HookPayloads[Hooks.GET_ELEMENT_COMPONENT], TContext>) => any;
+    getComponentRootElements: (handler: HookHandler<HookPayloads[Hooks.GET_COMPONENT_ROOT_ELEMENTS], TContext>) => any;
+    editComponentState: (handler: HookHandler<HookPayloads[Hooks.EDIT_COMPONENT_STATE], TContext>) => any;
+    getComponentDevtoolsOptions: (handler: HookHandler<HookPayloads[Hooks.GET_COMPONENT_DEVTOOLS_OPTIONS], TContext>) => any;
+    getComponentRenderCode: (handler: HookHandler<HookPayloads[Hooks.GET_COMPONENT_RENDER_CODE], TContext>) => any;
+    inspectTimelineEvent: (handler: HookHandler<HookPayloads[Hooks.INSPECT_TIMELINE_EVENT], TContext>) => any;
+    timelineCleared: (handler: HookHandler<HookPayloads[Hooks.TIMELINE_CLEARED], TContext>) => any;
+    getInspectorTree: (handler: HookHandler<HookPayloads[Hooks.GET_INSPECTOR_TREE], TContext>) => any;
+    getInspectorState: (handler: HookHandler<HookPayloads[Hooks.GET_INSPECTOR_STATE], TContext>) => any;
+    editInspectorState: (handler: HookHandler<HookPayloads[Hooks.EDIT_INSPECTOR_STATE], TContext>) => any;
+    setPluginSettings: (handler: HookHandler<HookPayloads[Hooks.SET_PLUGIN_SETTINGS], TContext>) => any;
+}

node_modules/@vue/devtools-api/lib/esm/api/hooks.js

@@ -0,0 +1 @@
+export {};

node_modules/@vue/devtools-api/lib/esm/api/index.d.ts

@@ -0,0 +1,6 @@
+export * from './api.js';
+export * from './app.js';
+export * from './component.js';
+export * from './context.js';
+export * from './hooks.js';
+export * from './util.js';

node_modules/@vue/devtools-api/lib/esm/api/index.js

@@ -0,0 +1,6 @@
+export * from './api.js';
+export * from './app.js';
+export * from './component.js';
+export * from './context.js';
+export * from './hooks.js';
+export * from './util.js';

node_modules/@vue/devtools-api/lib/esm/api/util.d.ts

@@ -0,0 +1,4 @@
+export type ID = number | string;
+export interface WithId {
+    id: ID;
+}

node_modules/@vue/devtools-api/lib/esm/api/util.js

@@ -0,0 +1 @@
+export {};

node_modules/@vue/devtools-api/lib/esm/const.d.ts

@@ -0,0 +1,2 @@
+export declare const HOOK_SETUP = "devtools-plugin:setup";
+export declare const HOOK_PLUGIN_SETTINGS_SET = "plugin:settings:set";

node_modules/@vue/devtools-api/lib/esm/const.js

@@ -0,0 +1,2 @@
+export const HOOK_SETUP = 'devtools-plugin:setup';
+export const HOOK_PLUGIN_SETTINGS_SET = 'plugin:settings:set';

node_modules/@vue/devtools-api/lib/esm/env.d.ts

@@ -0,0 +1,15 @@
+import type { ApiProxy } from './proxy.js';
+import type { PluginDescriptor, SetupFunction } from './index.js';
+export interface PluginQueueItem {
+    pluginDescriptor: PluginDescriptor;
+    setupFn: SetupFunction;
+    proxy?: ApiProxy;
+}
+interface GlobalTarget {
+    __VUE_DEVTOOLS_PLUGINS__?: PluginQueueItem[];
+    __VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__?: boolean;
+}
+export declare function getDevtoolsGlobalHook(): any;
+export declare function getTarget(): GlobalTarget;
+export declare const isProxyAvailable: boolean;
+export {};

node_modules/@vue/devtools-api/lib/esm/env.js

@@ -0,0 +1,12 @@
+export function getDevtoolsGlobalHook() {
+    return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;
+}
+export function getTarget() {
+    // @ts-expect-error navigator and windows are not available in all environments
+    return (typeof navigator !== 'undefined' && typeof window !== 'undefined')
+        ? window
+        : typeof globalThis !== 'undefined'
+            ? globalThis
+            : {};
+}
+export const isProxyAvailable = typeof Proxy === 'function';

node_modules/@vue/devtools-api/lib/esm/index.d.ts

@@ -0,0 +1,18 @@
+import type { DevtoolsPluginApi } from './api/index.js';
+import type { ExtractSettingsTypes, PluginDescriptor, PluginSettingsItem } from './plugin.js';
+export * from './api/index.js';
+export * from './plugin.js';
+export * from './time.js';
+export { PluginQueueItem } from './env.js';
+type Cast<A, B> = A extends B ? A : B;
+type Narrowable = string | number | bigint | boolean;
+type Narrow<A> = Cast<A, [] | (A extends Narrowable ? A : never) | ({
+    [K in keyof A]: Narrow<A[K]>;
+})>;
+type Exact<C, T> = {
+    [K in keyof C]: K extends keyof T ? T[K] : never;
+};
+export type SetupFunction<TSettings = any> = (api: DevtoolsPluginApi<TSettings>) => void;
+export declare function setupDevtoolsPlugin<TDescriptor extends Exact<TDescriptor, PluginDescriptor>, TSettings = ExtractSettingsTypes<TDescriptor extends {
+    settings: infer S;
+} ? S extends Record<string, PluginSettingsItem> ? S : Record<string, PluginSettingsItem> : Record<string, PluginSettingsItem>>>(pluginDescriptor: Narrow<TDescriptor>, setupFn: SetupFunction<TSettings>): void;

node_modules/@vue/devtools-api/lib/esm/index.js

@@ -0,0 +1,27 @@
+import { getDevtoolsGlobalHook, getTarget, isProxyAvailable } from './env.js';
+import { HOOK_SETUP } from './const.js';
+import { ApiProxy } from './proxy.js';
+export * from './api/index.js';
+export * from './plugin.js';
+export * from './time.js';
+export function setupDevtoolsPlugin(pluginDescriptor, setupFn) {
+    const descriptor = pluginDescriptor;
+    const target = getTarget();
+    const hook = getDevtoolsGlobalHook();
+    const enableProxy = isProxyAvailable && descriptor.enableEarlyProxy;
+    if (hook && (target.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !enableProxy)) {
+        hook.emit(HOOK_SETUP, pluginDescriptor, setupFn);
+    }
+    else {
+        const proxy = enableProxy ? new ApiProxy(descriptor, hook) : null;
+        const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || [];
+        list.push({
+            pluginDescriptor: descriptor,
+            setupFn,
+            proxy,
+        });
+        if (proxy) {
+            setupFn(proxy.proxiedTarget);
+        }
+    }
+}

node_modules/@vue/devtools-api/lib/esm/plugin.d.ts

@@ -0,0 +1,47 @@
+import type { App } from './api/index.js';
+export interface PluginDescriptor {
+    id: string;
+    label: string;
+    app: App;
+    packageName?: string;
+    homepage?: string;
+    componentStateTypes?: string[];
+    logo?: string;
+    disableAppScope?: boolean;
+    disablePluginScope?: boolean;
+    /**
+     * Run the plugin setup and expose the api even if the devtools is not opened yet.
+     * Useful to record timeline events early.
+     */
+    enableEarlyProxy?: boolean;
+    settings?: Record<string, PluginSettingsItem>;
+}
+export type PluginSettingsItem = {
+    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;
+});
+type InferSettingsType<T extends PluginSettingsItem> = [T] extends [{
+    type: 'boolean';
+}] ? boolean : [T] extends [{
+    type: 'choice';
+}] ? T['options'][number]['value'] : [T] extends [{
+    type: 'text';
+}] ? string : unknown;
+export type ExtractSettingsTypes<O extends Record<string, PluginSettingsItem>> = {
+    [K in keyof O]: InferSettingsType<O[K]>;
+};
+export {};

node_modules/@vue/devtools-api/lib/esm/plugin.js

@@ -0,0 +1 @@
+export {};

node_modules/@vue/devtools-api/lib/esm/proxy.d.ts

@@ -0,0 +1,20 @@
+import type { Context, DevtoolsPluginApi, Hookable } from './api/index.js';
+import type { PluginDescriptor } from './plugin.js';
+interface QueueItem {
+    method: string;
+    args: any[];
+    resolve?: (value?: any) => void;
+}
+export declare class ApiProxy<TTarget extends DevtoolsPluginApi<any> = DevtoolsPluginApi<any>> {
+    target: TTarget | null;
+    targetQueue: QueueItem[];
+    proxiedTarget: TTarget;
+    onQueue: QueueItem[];
+    proxiedOn: Hookable<Context>;
+    plugin: PluginDescriptor;
+    hook: any;
+    fallbacks: Record<string, any>;
+    constructor(plugin: PluginDescriptor, hook: any);
+    setRealTarget(target: TTarget): Promise<void>;
+}
+export {};

node_modules/@vue/devtools-api/lib/esm/proxy.js

@@ -0,0 +1,107 @@
+import { HOOK_PLUGIN_SETTINGS_SET } from './const.js';
+import { now } from './time.js';
+export class ApiProxy {
+    constructor(plugin, hook) {
+        this.target = null;
+        this.targetQueue = [];
+        this.onQueue = [];
+        this.plugin = plugin;
+        this.hook = hook;
+        const defaultSettings = {};
+        if (plugin.settings) {
+            for (const id in plugin.settings) {
+                const item = plugin.settings[id];
+                defaultSettings[id] = item.defaultValue;
+            }
+        }
+        const localSettingsSaveId = `__vue-devtools-plugin-settings__${plugin.id}`;
+        let currentSettings = Object.assign({}, defaultSettings);
+        try {
+            const raw = localStorage.getItem(localSettingsSaveId);
+            const data = JSON.parse(raw);
+            Object.assign(currentSettings, data);
+        }
+        catch (e) {
+            // noop
+        }
+        this.fallbacks = {
+            getSettings() {
+                return currentSettings;
+            },
+            setSettings(value) {
+                try {
+                    localStorage.setItem(localSettingsSaveId, JSON.stringify(value));
+                }
+                catch (e) {
+                    // noop
+                }
+                currentSettings = value;
+            },
+            now() {
+                return now();
+            },
+        };
+        if (hook) {
+            hook.on(HOOK_PLUGIN_SETTINGS_SET, (pluginId, value) => {
+                if (pluginId === this.plugin.id) {
+                    this.fallbacks.setSettings(value);
+                }
+            });
+        }
+        this.proxiedOn = new Proxy({}, {
+            get: (_target, prop) => {
+                if (this.target) {
+                    return this.target.on[prop];
+                }
+                else {
+                    return (...args) => {
+                        this.onQueue.push({
+                            method: prop,
+                            args,
+                        });
+                    };
+                }
+            },
+        });
+        this.proxiedTarget = new Proxy({}, {
+            get: (_target, prop) => {
+                if (this.target) {
+                    return this.target[prop];
+                }
+                else if (prop === 'on') {
+                    return this.proxiedOn;
+                }
+                else if (Object.keys(this.fallbacks).includes(prop)) {
+                    return (...args) => {
+                        this.targetQueue.push({
+                            method: prop,
+                            args,
+                            resolve: () => { },
+                        });
+                        return this.fallbacks[prop](...args);
+                    };
+                }
+                else {
+                    return (...args) => {
+                        return new Promise((resolve) => {
+                            this.targetQueue.push({
+                                method: prop,
+                                args,
+                                resolve,
+                            });
+                        });
+                    };
+                }
+            },
+        });
+    }
+    async setRealTarget(target) {
+        this.target = target;
+        for (const item of this.onQueue) {
+            this.target.on[item.method](...item.args);
+        }
+        for (const item of this.targetQueue) {
+            item.resolve(await this.target[item.method](...item.args));
+        }
+    }
+}

node_modules/@vue/devtools-api/lib/esm/time.d.ts

@@ -0,0 +1,2 @@
+export declare function isPerformanceSupported(): boolean;
+export declare function now(): number;

node_modules/@vue/devtools-api/lib/esm/time.js

@@ -0,0 +1,23 @@
+let supported;
+let perf;
+export function isPerformanceSupported() {
+    var _a;
+    if (supported !== undefined) {
+        return supported;
+    }
+    if (typeof window !== 'undefined' && window.performance) {
+        supported = true;
+        perf = window.performance;
+    }
+    else if (typeof globalThis !== 'undefined' && ((_a = globalThis.perf_hooks) === null || _a === void 0 ? void 0 : _a.performance)) {
+        supported = true;
+        perf = globalThis.perf_hooks.performance;
+    }
+    else {
+        supported = false;
+    }
+    return supported;
+}
+export function now() {
+    return isPerformanceSupported() ? perf.now() : Date.now();
+}

node_modules/@vue/devtools-api/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@vue/devtools-api",
+  "version": "6.6.4",
+  "description": "Interact with the Vue devtools from the page",
+  "author": {
+    "name": "Guillaume Chau"
+  },
+  "license": "MIT",
+  "repository": {
+    "url": "https://github.com/vuejs/vue-devtools.git",
+    "type": "git",
+    "directory": "packages/api"
+  },
+  "sideEffects": false,
+  "main": "lib/cjs/index.js",
+  "browser": "lib/esm/index.js",
+  "module": "lib/esm/index.js",
+  "types": "lib/esm/index.d.ts",
+  "files": [
+    "lib/cjs",
+    "lib/esm"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rimraf lib && yarn build:esm && yarn build:cjs",
+    "build:esm": "tsc --module es2015 --outDir lib/esm -d",
+    "build:cjs": "tsc --module commonjs --outDir lib/cjs",
+    "build:watch": "yarn tsc --module es2015 --outDir lib/esm -d -w --sourceMap"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.16",
+    "@types/webpack-env": "^1.15.1",
+    "typescript": "^5.3.3"
+  }
+}

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.

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

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

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

@@ -0,0 +1,575 @@
+//#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$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
+let __vue_devtools_shared = require("@vue/devtools-shared");
+__vue_devtools_shared = __toESM(__vue_devtools_shared);
+let __vue_devtools_kit = require("@vue/devtools-kit");
+__vue_devtools_kit = __toESM(__vue_devtools_kit);
+let vue = require("vue");
+vue = __toESM(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;

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?: {
+      icon?: string | undefined;
+      title: string;
+      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?: {
+      icon?: string | undefined;
+      title: string;
+      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 };

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?: {
+      icon?: string | undefined;
+      title: string;
+      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?: {
+      icon?: string | undefined;
+      title: string;
+      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 };

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 };

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

@@ -0,0 +1 @@
+../nanoid/bin/nanoid.js

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.

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)**.

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))
+}