Initial commit

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.28",
+  "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.29.0",
+    "entities": "^7.0.1",
+    "estree-walker": "^2.0.2",
+    "source-map-js": "^1.2.1",
+    "@vue/shared": "3.5.28"
+  },
+  "devDependencies": {
+    "@babel/types": "^7.29.0"
+  }
+}

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.28
+* (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 = /* @__PURE__ */ Symbol(`vModelRadio` );
+const V_MODEL_CHECKBOX = /* @__PURE__ */ Symbol(
+  `vModelCheckbox` 
+);
+const V_MODEL_TEXT = /* @__PURE__ */ Symbol(`vModelText` );
+const V_MODEL_SELECT = /* @__PURE__ */ Symbol(
+  `vModelSelect` 
+);
+const V_MODEL_DYNAMIC = /* @__PURE__ */ Symbol(
+  `vModelDynamic` 
+);
+const V_ON_WITH_MODIFIERS = /* @__PURE__ */ Symbol(
+  `vOnModifiersGuard` 
+);
+const V_ON_WITH_KEYS = /* @__PURE__ */ Symbol(
+  `vOnKeysGuard` 
+);
+const V_SHOW = /* @__PURE__ */ Symbol(`vShow` );
+const TRANSITION = /* @__PURE__ */ Symbol(`Transition` );
+const TRANSITION_GROUP = /* @__PURE__ */ 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": 54,
+  "54": "X_V_HTML_NO_EXPRESSION",
+  "X_V_HTML_WITH_CHILDREN": 55,
+  "55": "X_V_HTML_WITH_CHILDREN",
+  "X_V_TEXT_NO_EXPRESSION": 56,
+  "56": "X_V_TEXT_NO_EXPRESSION",
+  "X_V_TEXT_WITH_CHILDREN": 57,
+  "57": "X_V_TEXT_WITH_CHILDREN",
+  "X_V_MODEL_ON_INVALID_ELEMENT": 58,
+  "58": "X_V_MODEL_ON_INVALID_ELEMENT",
+  "X_V_MODEL_ARG_ON_ELEMENT": 59,
+  "59": "X_V_MODEL_ARG_ON_ELEMENT",
+  "X_V_MODEL_ON_FILE_INPUT_ELEMENT": 60,
+  "60": "X_V_MODEL_ON_FILE_INPUT_ELEMENT",
+  "X_V_MODEL_UNNECESSARY_VALUE": 61,
+  "61": "X_V_MODEL_UNNECESSARY_VALUE",
+  "X_V_SHOW_NO_EXPRESSION": 62,
+  "62": "X_V_SHOW_NO_EXPRESSION",
+  "X_TRANSITION_INVALID_CHILDREN": 63,
+  "63": "X_TRANSITION_INVALID_CHILDREN",
+  "X_IGNORED_SIDE_EFFECT_TAG": 64,
+  "64": "X_IGNORED_SIDE_EFFECT_TAG",
+  "__EXTEND_POINT__": 65,
+  "65": "__EXTEND_POINT__"
+};
+const DOMErrorMessages = {
+  [54]: `v-html is missing expression.`,
+  [55]: `v-html will override element children.`,
+  [56]: `v-text is missing expression.`,
+  [57]: `v-text will override element children.`,
+  [58]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
+  [59]: `v-model argument is not supported on plain elements.`,
+  [60]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+  [61]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
+  [62]: `v-show is missing expression.`,
+  [63]: `<Transition> expects exactly one child element or component.`,
+  [64]: `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(54, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(55, 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(56, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(57, 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(
+        59,
+        dir.arg.loc
+      )
+    );
+  }
+  function checkDuplicatedValue() {
+    const value = compilerCore.findDir(node, "bind");
+    if (value && compilerCore.isStaticArgOf(value.arg, "value")) {
+      context.onError(
+        createDOMCompilerError(
+          61,
+          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(
+                  60,
+                  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(
+        58,
+        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(62, 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(
+              63,
+              {
+                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) => !compilerCore.isCommentOrWhitespace(c)
+  );
+  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(
+        64,
+        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.28
+* (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 = /* @__PURE__ */ Symbol(``);
+const V_MODEL_CHECKBOX = /* @__PURE__ */ Symbol(
+  ``
+);
+const V_MODEL_TEXT = /* @__PURE__ */ Symbol(``);
+const V_MODEL_SELECT = /* @__PURE__ */ Symbol(
+  ``
+);
+const V_MODEL_DYNAMIC = /* @__PURE__ */ Symbol(
+  ``
+);
+const V_ON_WITH_MODIFIERS = /* @__PURE__ */ Symbol(
+  ``
+);
+const V_ON_WITH_KEYS = /* @__PURE__ */ Symbol(
+  ``
+);
+const V_SHOW = /* @__PURE__ */ Symbol(``);
+const TRANSITION = /* @__PURE__ */ Symbol(``);
+const TRANSITION_GROUP = /* @__PURE__ */ 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": 54,
+  "54": "X_V_HTML_NO_EXPRESSION",
+  "X_V_HTML_WITH_CHILDREN": 55,
+  "55": "X_V_HTML_WITH_CHILDREN",
+  "X_V_TEXT_NO_EXPRESSION": 56,
+  "56": "X_V_TEXT_NO_EXPRESSION",
+  "X_V_TEXT_WITH_CHILDREN": 57,
+  "57": "X_V_TEXT_WITH_CHILDREN",
+  "X_V_MODEL_ON_INVALID_ELEMENT": 58,
+  "58": "X_V_MODEL_ON_INVALID_ELEMENT",
+  "X_V_MODEL_ARG_ON_ELEMENT": 59,
+  "59": "X_V_MODEL_ARG_ON_ELEMENT",
+  "X_V_MODEL_ON_FILE_INPUT_ELEMENT": 60,
+  "60": "X_V_MODEL_ON_FILE_INPUT_ELEMENT",
+  "X_V_MODEL_UNNECESSARY_VALUE": 61,
+  "61": "X_V_MODEL_UNNECESSARY_VALUE",
+  "X_V_SHOW_NO_EXPRESSION": 62,
+  "62": "X_V_SHOW_NO_EXPRESSION",
+  "X_TRANSITION_INVALID_CHILDREN": 63,
+  "63": "X_TRANSITION_INVALID_CHILDREN",
+  "X_IGNORED_SIDE_EFFECT_TAG": 64,
+  "64": "X_IGNORED_SIDE_EFFECT_TAG",
+  "__EXTEND_POINT__": 65,
+  "65": "__EXTEND_POINT__"
+};
+const DOMErrorMessages = {
+  [54]: `v-html is missing expression.`,
+  [55]: `v-html will override element children.`,
+  [56]: `v-text is missing expression.`,
+  [57]: `v-text will override element children.`,
+  [58]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
+  [59]: `v-model argument is not supported on plain elements.`,
+  [60]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+  [61]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
+  [62]: `v-show is missing expression.`,
+  [63]: `<Transition> expects exactly one child element or component.`,
+  [64]: `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(54, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(55, 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(56, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(57, 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(
+        59,
+        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(
+                  60,
+                  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(
+        58,
+        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(62, 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 = 54,
+    X_V_HTML_WITH_CHILDREN = 55,
+    X_V_TEXT_NO_EXPRESSION = 56,
+    X_V_TEXT_WITH_CHILDREN = 57,
+    X_V_MODEL_ON_INVALID_ELEMENT = 58,
+    X_V_MODEL_ARG_ON_ELEMENT = 59,
+    X_V_MODEL_ON_FILE_INPUT_ELEMENT = 60,
+    X_V_MODEL_UNNECESSARY_VALUE = 61,
+    X_V_SHOW_NO_EXPRESSION = 62,
+    X_TRANSITION_INVALID_CHILDREN = 63,
+    X_IGNORED_SIDE_EFFECT_TAG = 64,
+    __EXTEND_POINT__ = 65
+}
+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.28
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+import { registerRuntimeHelpers, createSimpleExpression, createCompilerError, createObjectProperty, getConstantType, createCallExpression, TO_DISPLAY_STRING, transformModel as transformModel$1, findProp, hasDynamicKeyVBind, findDir, isStaticArgOf, transformOn as transformOn$1, isStaticExp, createCompoundExpression, checkCompatEnabled, isCommentOrWhitespace, noopDirectiveTransform, baseCompile, baseParse } from '@vue/compiler-core';
+export * from '@vue/compiler-core';
+import { isVoidTag, isHTMLTag, isSVGTag, isMathMLTag, parseStringStyle, capitalize, makeMap, extend } from '@vue/shared';
+
+const V_MODEL_RADIO = /* @__PURE__ */ Symbol(!!(process.env.NODE_ENV !== "production") ? `vModelRadio` : ``);
+const V_MODEL_CHECKBOX = /* @__PURE__ */ Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vModelCheckbox` : ``
+);
+const V_MODEL_TEXT = /* @__PURE__ */ Symbol(!!(process.env.NODE_ENV !== "production") ? `vModelText` : ``);
+const V_MODEL_SELECT = /* @__PURE__ */ Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vModelSelect` : ``
+);
+const V_MODEL_DYNAMIC = /* @__PURE__ */ Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vModelDynamic` : ``
+);
+const V_ON_WITH_MODIFIERS = /* @__PURE__ */ Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vOnModifiersGuard` : ``
+);
+const V_ON_WITH_KEYS = /* @__PURE__ */ Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vOnKeysGuard` : ``
+);
+const V_SHOW = /* @__PURE__ */ Symbol(!!(process.env.NODE_ENV !== "production") ? `vShow` : ``);
+const TRANSITION = /* @__PURE__ */ Symbol(!!(process.env.NODE_ENV !== "production") ? `Transition` : ``);
+const TRANSITION_GROUP = /* @__PURE__ */ 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": 54,
+  "54": "X_V_HTML_NO_EXPRESSION",
+  "X_V_HTML_WITH_CHILDREN": 55,
+  "55": "X_V_HTML_WITH_CHILDREN",
+  "X_V_TEXT_NO_EXPRESSION": 56,
+  "56": "X_V_TEXT_NO_EXPRESSION",
+  "X_V_TEXT_WITH_CHILDREN": 57,
+  "57": "X_V_TEXT_WITH_CHILDREN",
+  "X_V_MODEL_ON_INVALID_ELEMENT": 58,
+  "58": "X_V_MODEL_ON_INVALID_ELEMENT",
+  "X_V_MODEL_ARG_ON_ELEMENT": 59,
+  "59": "X_V_MODEL_ARG_ON_ELEMENT",
+  "X_V_MODEL_ON_FILE_INPUT_ELEMENT": 60,
+  "60": "X_V_MODEL_ON_FILE_INPUT_ELEMENT",
+  "X_V_MODEL_UNNECESSARY_VALUE": 61,
+  "61": "X_V_MODEL_UNNECESSARY_VALUE",
+  "X_V_SHOW_NO_EXPRESSION": 62,
+  "62": "X_V_SHOW_NO_EXPRESSION",
+  "X_TRANSITION_INVALID_CHILDREN": 63,
+  "63": "X_TRANSITION_INVALID_CHILDREN",
+  "X_IGNORED_SIDE_EFFECT_TAG": 64,
+  "64": "X_IGNORED_SIDE_EFFECT_TAG",
+  "__EXTEND_POINT__": 65,
+  "65": "__EXTEND_POINT__"
+};
+const DOMErrorMessages = {
+  [54]: `v-html is missing expression.`,
+  [55]: `v-html will override element children.`,
+  [56]: `v-text is missing expression.`,
+  [57]: `v-text will override element children.`,
+  [58]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
+  [59]: `v-model argument is not supported on plain elements.`,
+  [60]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+  [61]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
+  [62]: `v-show is missing expression.`,
+  [63]: `<Transition> expects exactly one child element or component.`,
+  [64]: `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(54, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(55, 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(56, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(57, 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(
+        59,
+        dir.arg.loc
+      )
+    );
+  }
+  function checkDuplicatedValue() {
+    const value = findDir(node, "bind");
+    if (value && isStaticArgOf(value.arg, "value")) {
+      context.onError(
+        createDOMCompilerError(
+          61,
+          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(
+                  60,
+                  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(
+        58,
+        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(62, 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(
+              63,
+              {
+                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) => !isCommentOrWhitespace(c)
+  );
+  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(
+        64,
+        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.28",
+  "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/compiler-core": "3.5.28",
+    "@vue/shared": "3.5.28"
+  }
+}

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,79 @@
+# @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,487 @@
+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' | 'warn' | 'helper' | 'getString' | 'propsTypeDecl' | 'propsRuntimeDefaults' | 'propsDestructuredBindings' | 'emitsTypeDecl' | 'isCE'> & Partial<Pick<ScriptCompileContext, 'scope' | 'globalScopes' | 'deps' | 'fs'>> & {
+    ast: Statement[];
+    options: SimpleTypeResolveOptions;
+};
+export type TypeResolveContext = (ScriptCompileContext | SimpleTypeResolveContext) & {
+    silentOnExtendsFailure?: boolean;
+};
+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.28",
+  "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.29.0",
+    "estree-walker": "^2.0.2",
+    "magic-string": "^0.30.21",
+    "postcss": "^8.5.6",
+    "source-map-js": "^1.2.1",
+    "@vue/compiler-core": "3.5.28",
+    "@vue/compiler-dom": "3.5.28",
+    "@vue/compiler-ssr": "3.5.28",
+    "@vue/shared": "3.5.28"
+  },
+  "devDependencies": {
+    "@babel/types": "^7.29.0",
+    "@vue/consolidate": "^1.0.0",
+    "hash-sum": "^2.0.0",
+    "lru-cache": "10.1.0",
+    "merge-source-map": "^1.1.0",
+    "minimatch": "~10.1.2",
+    "postcss-modules": "^6.0.1",
+    "postcss-selector-parser": "^7.1.1",
+    "pug": "^3.0.3",
+    "sass": "^1.97.3"
+  }
+}

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.28",
+  "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.28",
+    "@vue/compiler-dom": "3.5.28"
+  }
+}

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,690 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target2, all) => {
+  for (var name in all)
+    __defProp(target2, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DevToolsMessagingEvents: () => DevToolsMessagingEvents,
+  VueDevToolsVuePlugin: () => VueDevToolsVuePlugin,
+  createDevToolsStateContext: () => createDevToolsStateContext,
+  createViteClientRpc: () => createViteClientRpc,
+  createViteServerRpc: () => createViteServerRpc,
+  functions: () => functions,
+  getDevToolsClientUrl: () => getDevToolsClientUrl,
+  onDevToolsConnected: () => onDevToolsConnected,
+  onRpcConnected: () => onRpcConnected,
+  onRpcSeverReady: () => onRpcSeverReady,
+  onViteRpcConnected: () => onViteRpcConnected,
+  refreshCurrentPageData: () => refreshCurrentPageData,
+  rpc: () => rpc,
+  rpcServer: () => rpcServer,
+  setDevToolsClientUrl: () => setDevToolsClientUrl,
+  useDevToolsState: () => useDevToolsState,
+  viteRpc: () => viteRpc,
+  viteRpcFunctions: () => viteRpcFunctions
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_devtools_shared = require("@vue/devtools-shared");
+function setDevToolsClientUrl(url) {
+  import_devtools_shared.target.__VUE_DEVTOOLS_CLIENT_URL__ = url;
+}
+function getDevToolsClientUrl() {
+  var _a;
+  return (_a = import_devtools_shared.target.__VUE_DEVTOOLS_CLIENT_URL__) != null ? _a : (() => {
+    if (import_devtools_shared.isBrowser) {
+      const devtoolsMeta = document.querySelector("meta[name=__VUE_DEVTOOLS_CLIENT_URL__]");
+      if (devtoolsMeta)
+        return devtoolsMeta.getAttribute("content");
+    }
+    return "";
+  })();
+}
+
+// src/rpc/global.ts
+var import_devtools_kit = require("@vue/devtools-kit");
+
+// ../../node_modules/.pnpm/hookable@5.5.3/node_modules/hookable/dist/index.mjs
+function flatHooks(configHooks, hooks3 = {}, parentName) {
+  for (const key in configHooks) {
+    const subHook = configHooks[key];
+    const name = parentName ? `${parentName}:${key}` : key;
+    if (typeof subHook === "object" && subHook !== null) {
+      flatHooks(subHook, hooks3, name);
+    } else if (typeof subHook === "function") {
+      hooks3[name] = subHook;
+    }
+  }
+  return hooks3;
+}
+var defaultTask = { run: (function_) => function_() };
+var _createTask = () => defaultTask;
+var createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
+function serialTaskCaller(hooks3, args) {
+  const name = args.shift();
+  const task = createTask(name);
+  return hooks3.reduce(
+    (promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))),
+    Promise.resolve()
+  );
+}
+function parallelTaskCaller(hooks3, args) {
+  const name = args.shift();
+  const task = createTask(name);
+  return Promise.all(hooks3.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 (e) {
+      }
+    }
+    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 hooks3 = flatHooks(configHooks);
+    const removeFns = Object.keys(hooks3).map(
+      (key) => this.hook(key, hooks3[key])
+    );
+    return () => {
+      for (const unreg of removeFns.splice(0, removeFns.length)) {
+        unreg();
+      }
+    };
+  }
+  removeHooks(configHooks) {
+    const hooks3 = flatHooks(configHooks);
+    for (const key in hooks3) {
+      this.removeHook(key, hooks3[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();
+}
+
+// src/rpc/global.ts
+var hooks = createHooks();
+var DevToolsMessagingEvents = /* @__PURE__ */ ((DevToolsMessagingEvents2) => {
+  DevToolsMessagingEvents2["INSPECTOR_TREE_UPDATED"] = "inspector-tree-updated";
+  DevToolsMessagingEvents2["INSPECTOR_STATE_UPDATED"] = "inspector-state-updated";
+  DevToolsMessagingEvents2["DEVTOOLS_STATE_UPDATED"] = "devtools-state-updated";
+  DevToolsMessagingEvents2["ROUTER_INFO_UPDATED"] = "router-info-updated";
+  DevToolsMessagingEvents2["TIMELINE_EVENT_UPDATED"] = "timeline-event-updated";
+  DevToolsMessagingEvents2["INSPECTOR_UPDATED"] = "inspector-updated";
+  DevToolsMessagingEvents2["ACTIVE_APP_UNMOUNTED"] = "active-app-updated";
+  DevToolsMessagingEvents2["DESTROY_DEVTOOLS_CLIENT"] = "destroy-devtools-client";
+  DevToolsMessagingEvents2["RELOAD_DEVTOOLS_CLIENT"] = "reload-devtools-client";
+  return DevToolsMessagingEvents2;
+})(DevToolsMessagingEvents || {});
+function getDevToolsState() {
+  var _a;
+  const state = import_devtools_kit.devtools.ctx.state;
+  return {
+    connected: state.connected,
+    clientConnected: true,
+    vueVersion: ((_a = state == null ? void 0 : state.activeAppRecord) == null ? void 0 : _a.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
+  };
+}
+var functions = {
+  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;
+  },
+  devtoolsState: () => {
+    return getDevToolsState();
+  },
+  async getInspectorTree(payload) {
+    const res = await import_devtools_kit.devtools.ctx.api.getInspectorTree(payload);
+    return (0, import_devtools_kit.stringify)(res);
+  },
+  async getInspectorState(payload) {
+    const inspector = (0, import_devtools_kit.getInspector)(payload.inspectorId);
+    if (inspector)
+      inspector.selectedNodeId = payload.nodeId;
+    const res = await import_devtools_kit.devtools.ctx.api.getInspectorState(payload);
+    return (0, import_devtools_kit.stringify)(res);
+  },
+  async editInspectorState(payload) {
+    return await import_devtools_kit.devtools.ctx.api.editInspectorState(payload);
+  },
+  sendInspectorState(id) {
+    return import_devtools_kit.devtools.ctx.api.sendInspectorState(id);
+  },
+  inspectComponentInspector() {
+    return import_devtools_kit.devtools.ctx.api.inspectComponentInspector();
+  },
+  cancelInspectComponentInspector() {
+    return import_devtools_kit.devtools.ctx.api.cancelInspectComponentInspector();
+  },
+  getComponentRenderCode(id) {
+    return import_devtools_kit.devtools.ctx.api.getComponentRenderCode(id);
+  },
+  scrollToComponent(id) {
+    return import_devtools_kit.devtools.ctx.api.scrollToComponent(id);
+  },
+  inspectDOM(id) {
+    return import_devtools_kit.devtools.ctx.api.inspectDOM(id);
+  },
+  getInspectorNodeActions(id) {
+    return (0, import_devtools_kit.getInspectorNodeActions)(id);
+  },
+  getInspectorActions(id) {
+    return (0, import_devtools_kit.getInspectorActions)(id);
+  },
+  updateTimelineLayersState(state) {
+    return (0, import_devtools_kit.updateTimelineLayersState)(state);
+  },
+  callInspectorNodeAction(inspectorId, actionIndex, nodeId) {
+    var _a;
+    const nodeActions = (0, import_devtools_kit.getInspectorNodeActions)(inspectorId);
+    if (nodeActions == null ? void 0 : nodeActions.length) {
+      const item = nodeActions[actionIndex];
+      (_a = item.action) == null ? void 0 : _a.call(item, nodeId);
+    }
+  },
+  callInspectorAction(inspectorId, actionIndex) {
+    var _a;
+    const actions = (0, import_devtools_kit.getInspectorActions)(inspectorId);
+    if (actions == null ? void 0 : actions.length) {
+      const item = actions[actionIndex];
+      (_a = item.action) == null ? void 0 : _a.call(item);
+    }
+  },
+  openInEditor(options) {
+    return import_devtools_kit.devtools.ctx.api.openInEditor(options);
+  },
+  async checkVueInspectorDetected() {
+    return !!await import_devtools_kit.devtools.ctx.api.getVueInspector();
+  },
+  async enableVueInspector() {
+    var _a, _b, _c;
+    const inspector = await ((_c = (_b = (_a = import_devtools_kit.devtools) == null ? void 0 : _a.api) == null ? void 0 : _b.getVueInspector) == null ? void 0 : _c.call(_b));
+    if (inspector)
+      await inspector.enable();
+  },
+  async toggleApp(id, options) {
+    return import_devtools_kit.devtools.ctx.api.toggleApp(id, options);
+  },
+  updatePluginSettings(pluginId, key, value) {
+    return import_devtools_kit.devtools.ctx.api.updatePluginSettings(pluginId, key, value);
+  },
+  getPluginSettings(pluginId) {
+    return import_devtools_kit.devtools.ctx.api.getPluginSettings(pluginId);
+  },
+  getRouterInfo() {
+    return import_devtools_kit.devtoolsRouterInfo;
+  },
+  navigate(path) {
+    var _a;
+    return (_a = import_devtools_kit.devtoolsRouter.value) == null ? void 0 : _a.push(path).catch(() => ({}));
+  },
+  getMatchedRoutes(path) {
+    var _a, _b, _c;
+    const c = console.warn;
+    console.warn = () => {
+    };
+    const matched = (_c = (_b = (_a = import_devtools_kit.devtoolsRouter.value) == null ? void 0 : _a.resolve) == null ? void 0 : _b.call(_a, {
+      path: path || "/"
+    }).matched) != null ? _c : [];
+    console.warn = c;
+    return matched;
+  },
+  toggleClientConnected(state) {
+    (0, import_devtools_kit.toggleClientConnected)(state);
+  },
+  getCustomInspector() {
+    return (0, import_devtools_kit.getActiveInspectors)();
+  },
+  getInspectorInfo(id) {
+    return (0, import_devtools_kit.getInspectorInfo)(id);
+  },
+  highlighComponent(uid) {
+    return import_devtools_kit.devtools.ctx.hooks.callHook(import_devtools_kit.DevToolsContextHookKeys.COMPONENT_HIGHLIGHT, { uid });
+  },
+  unhighlight() {
+    return import_devtools_kit.devtools.ctx.hooks.callHook(import_devtools_kit.DevToolsContextHookKeys.COMPONENT_UNHIGHLIGHT);
+  },
+  updateDevToolsClientDetected(params) {
+    (0, import_devtools_kit.updateDevToolsClientDetected)(params);
+  },
+  // listen to devtools server events
+  initDevToolsServerListener() {
+    const rpcServer2 = (0, import_devtools_kit.getRpcServer)();
+    const broadcast = rpcServer2.broadcast;
+    import_devtools_kit.devtools.ctx.hooks.hook(import_devtools_kit.DevToolsMessagingHookKeys.SEND_INSPECTOR_TREE_TO_CLIENT, (payload) => {
+      broadcast.emit("inspector-tree-updated" /* INSPECTOR_TREE_UPDATED */, (0, import_devtools_kit.stringify)(payload));
+    });
+    import_devtools_kit.devtools.ctx.hooks.hook(import_devtools_kit.DevToolsMessagingHookKeys.SEND_INSPECTOR_STATE_TO_CLIENT, (payload) => {
+      broadcast.emit("inspector-state-updated" /* INSPECTOR_STATE_UPDATED */, (0, import_devtools_kit.stringify)(payload));
+    });
+    import_devtools_kit.devtools.ctx.hooks.hook(import_devtools_kit.DevToolsMessagingHookKeys.DEVTOOLS_STATE_UPDATED, () => {
+      broadcast.emit("devtools-state-updated" /* DEVTOOLS_STATE_UPDATED */, getDevToolsState());
+    });
+    import_devtools_kit.devtools.ctx.hooks.hook(import_devtools_kit.DevToolsMessagingHookKeys.ROUTER_INFO_UPDATED, ({ state }) => {
+      broadcast.emit("router-info-updated" /* ROUTER_INFO_UPDATED */, state);
+    });
+    import_devtools_kit.devtools.ctx.hooks.hook(import_devtools_kit.DevToolsMessagingHookKeys.SEND_TIMELINE_EVENT_TO_CLIENT, (payload) => {
+      broadcast.emit("timeline-event-updated" /* TIMELINE_EVENT_UPDATED */, (0, import_devtools_kit.stringify)(payload));
+    });
+    import_devtools_kit.devtools.ctx.hooks.hook(import_devtools_kit.DevToolsMessagingHookKeys.SEND_INSPECTOR_TO_CLIENT, (payload) => {
+      broadcast.emit("inspector-updated" /* INSPECTOR_UPDATED */, payload);
+    });
+    import_devtools_kit.devtools.ctx.hooks.hook(import_devtools_kit.DevToolsMessagingHookKeys.SEND_ACTIVE_APP_UNMOUNTED_TO_CLIENT, () => {
+      broadcast.emit("active-app-updated" /* ACTIVE_APP_UNMOUNTED */);
+    });
+  }
+};
+var rpc = new Proxy({
+  value: {},
+  functions: {}
+}, {
+  get(target2, property) {
+    const _rpc = (0, import_devtools_kit.getRpcClient)();
+    if (property === "value") {
+      return _rpc;
+    } else if (property === "functions") {
+      return _rpc.$functions;
+    }
+  }
+});
+var rpcServer = new Proxy({
+  value: {},
+  functions: {}
+}, {
+  get(target2, property) {
+    const _rpc = (0, import_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() {
+    var _a, _b;
+    (_b = (_a = rpc.value) == null ? void 0 : _a.heartbeat) == null ? void 0 : _b.call(_a).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);
+}
+
+// src/rpc/vite.ts
+var import_devtools_kit2 = require("@vue/devtools-kit");
+var hooks2 = createHooks();
+var viteRpcFunctions = {
+  on: (event, handler) => {
+    hooks2.hook(event, handler);
+  },
+  off: (event, handler) => {
+    hooks2.removeHook(event, handler);
+  },
+  once: (event, handler) => {
+    hooks2.hookOnce(event, handler);
+  },
+  emit: (event, ...args) => {
+    hooks2.callHook(event, ...args);
+  },
+  heartbeat: () => {
+    return true;
+  }
+};
+var viteRpc = new Proxy({
+  value: {},
+  functions: {}
+}, {
+  get(target2, property) {
+    const _rpc = (0, import_devtools_kit2.getViteRpcClient)();
+    if (property === "value") {
+      return _rpc;
+    } else if (property === "functions") {
+      return _rpc == null ? void 0 : _rpc.$functions;
+    }
+  }
+});
+function onViteRpcConnected(callback) {
+  let timer = null;
+  function heartbeat() {
+    var _a, _b;
+    (_b = (_a = viteRpc.value) == null ? void 0 : _a.heartbeat) == null ? void 0 : _b.call(_a).then(() => {
+      clearTimeout(timer);
+      callback();
+    }).catch(() => ({}));
+    timer = setTimeout(() => {
+      heartbeat();
+    }, 80);
+  }
+  heartbeat();
+}
+function createViteClientRpc() {
+  (0, import_devtools_kit2.createRpcClient)(viteRpcFunctions, {
+    preset: "vite"
+  });
+}
+function createViteServerRpc(functions2) {
+  (0, import_devtools_kit2.createRpcServer)(functions2, {
+    preset: "vite"
+  });
+}
+
+// src/vue-plugin/devtools-state.ts
+var import_vue = require("vue");
+var 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, import_vue.ref)(false);
+  const clientConnected = (0, import_vue.ref)(false);
+  const vueVersion = (0, import_vue.ref)("");
+  const tabs = (0, import_vue.ref)([]);
+  const commands = (0, import_vue.ref)([]);
+  const vitePluginDetected = (0, import_vue.ref)(false);
+  const appRecords = (0, import_vue.ref)([]);
+  const activeAppRecordId = (0, import_vue.ref)("");
+  const timelineLayersState = (0, import_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 getDevToolsState2() {
+    onRpcConnected(() => {
+      rpc.value.devtoolsState().then((data) => {
+        updateState(data);
+      });
+      rpc.functions.off("devtools-state-updated" /* DEVTOOLS_STATE_UPDATED */, updateState);
+      rpc.functions.on("devtools-state-updated" /* DEVTOOLS_STATE_UPDATED */, updateState);
+    });
+  }
+  return {
+    getDevToolsState: getDevToolsState2,
+    connected,
+    clientConnected,
+    vueVersion,
+    tabs,
+    commands,
+    vitePluginDetected,
+    appRecords,
+    activeAppRecordId,
+    timelineLayersState
+  };
+}
+function useDevToolsState() {
+  return (0, import_vue.inject)(VueDevToolsStateSymbol);
+}
+var fns = [];
+function onDevToolsConnected(fn) {
+  const { connected, clientConnected } = useDevToolsState();
+  fns.push(fn);
+  (0, import_vue.onUnmounted)(() => {
+    fns.splice(fns.indexOf(fn), 1);
+  });
+  const devtoolsReady = (0, import_vue.computed)(() => clientConnected.value && connected.value);
+  if (devtoolsReady.value) {
+    fn();
+  } else {
+    const stop = (0, import_vue.watch)(devtoolsReady, (v) => {
+      if (v) {
+        fn();
+        stop();
+      }
+    });
+  }
+  return () => {
+    fns.splice(fns.indexOf(fn), 1);
+  };
+}
+function refreshCurrentPageData() {
+  fns.forEach((fn) => fn());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DevToolsMessagingEvents,
+  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.cts

@@ -0,0 +1,343 @@
+import * as vue_router from 'vue-router';
+import * as _vue_devtools_kit from '@vue/devtools-kit';
+import { DevToolsV6PluginAPIHookPayloads, DevToolsV6PluginAPIHookKeys, OpenInEditorOptions, getRpcClient, getRpcServer, getViteRpcClient, CustomTab, CustomCommand, AppRecord } from '@vue/devtools-kit';
+import { ModuleNode } from 'vite';
+import { App, Ref } from 'vue';
+
+declare function setDevToolsClientUrl(url: string): void;
+declare function getDevToolsClientUrl(): any;
+
+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: _vue_devtools_kit.CustomTab[];
+        commands: _vue_devtools_kit.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(): _vue_devtools_kit.RouterInfo;
+    navigate(path: string): Promise<void | vue_router.NavigationFailure | {} | undefined>;
+    getMatchedRoutes(path: string): vue_router.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;
+
+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;
+}
+
+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;
+
+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: 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: VNode;
+        } | {
+            type: "sfc";
+            sfc: string;
+        };
+        category?: ("app" | "pinned" | "modules" | "advanced") | undefined;
+    }[]>;
+    commands: Ref<{
+        id: string;
+        title: string;
+        description?: string | undefined;
+        order?: number | undefined;
+        icon?: string | undefined;
+        action?: {
+            type: "url";
+            src: string;
+        } | undefined;
+        children?: {
+            title: string;
+            id: string;
+            icon?: string | undefined;
+            description?: string | undefined;
+            order?: number | undefined;
+            action?: {
+                type: "url";
+                src: string;
+            } | undefined;
+        }[] | undefined;
+    }[], CustomCommand[] | {
+        id: string;
+        title: string;
+        description?: string | undefined;
+        order?: number | undefined;
+        icon?: string | undefined;
+        action?: {
+            type: "url";
+            src: string;
+        } | undefined;
+        children?: {
+            title: string;
+            id: string;
+            icon?: string | undefined;
+            description?: string | undefined;
+            order?: number | undefined;
+            action?: {
+                type: "url";
+                src: string;
+            } | undefined;
+        }[] | undefined;
+    }[]>;
+    vitePluginDetected: Ref<boolean, boolean>;
+    appRecords: Ref<{
+        id: string;
+        name: string;
+        app?: _vue_devtools_kit.App;
+        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: _vue_devtools_kit.VueAppInstance;
+        routerId?: string | undefined;
+        iframe?: string | undefined;
+    }[], AppRecord[] | {
+        id: string;
+        name: string;
+        app?: _vue_devtools_kit.App;
+        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: _vue_devtools_kit.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;
+
+export { type AssetEntry, type AssetImporter, type AssetInfo, type AssetType, type CodeSnippet, DevToolsMessagingEvents, type ImageMeta, type ModuleInfo, type RPCFunctions, type 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,343 @@
+import * as vue_router from 'vue-router';
+import * as _vue_devtools_kit from '@vue/devtools-kit';
+import { DevToolsV6PluginAPIHookPayloads, DevToolsV6PluginAPIHookKeys, OpenInEditorOptions, getRpcClient, getRpcServer, getViteRpcClient, CustomTab, CustomCommand, AppRecord } from '@vue/devtools-kit';
+import { ModuleNode } from 'vite';
+import { App, Ref } from 'vue';
+
+declare function setDevToolsClientUrl(url: string): void;
+declare function getDevToolsClientUrl(): any;
+
+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: _vue_devtools_kit.CustomTab[];
+        commands: _vue_devtools_kit.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(): _vue_devtools_kit.RouterInfo;
+    navigate(path: string): Promise<void | vue_router.NavigationFailure | {} | undefined>;
+    getMatchedRoutes(path: string): vue_router.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;
+
+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;
+}
+
+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;
+
+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: 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: VNode;
+        } | {
+            type: "sfc";
+            sfc: string;
+        };
+        category?: ("app" | "pinned" | "modules" | "advanced") | undefined;
+    }[]>;
+    commands: Ref<{
+        id: string;
+        title: string;
+        description?: string | undefined;
+        order?: number | undefined;
+        icon?: string | undefined;
+        action?: {
+            type: "url";
+            src: string;
+        } | undefined;
+        children?: {
+            title: string;
+            id: string;
+            icon?: string | undefined;
+            description?: string | undefined;
+            order?: number | undefined;
+            action?: {
+                type: "url";
+                src: string;
+            } | undefined;
+        }[] | undefined;
+    }[], CustomCommand[] | {
+        id: string;
+        title: string;
+        description?: string | undefined;
+        order?: number | undefined;
+        icon?: string | undefined;
+        action?: {
+            type: "url";
+            src: string;
+        } | undefined;
+        children?: {
+            title: string;
+            id: string;
+            icon?: string | undefined;
+            description?: string | undefined;
+            order?: number | undefined;
+            action?: {
+                type: "url";
+                src: string;
+            } | undefined;
+        }[] | undefined;
+    }[]>;
+    vitePluginDetected: Ref<boolean, boolean>;
+    appRecords: Ref<{
+        id: string;
+        name: string;
+        app?: _vue_devtools_kit.App;
+        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: _vue_devtools_kit.VueAppInstance;
+        routerId?: string | undefined;
+        iframe?: string | undefined;
+    }[], AppRecord[] | {
+        id: string;
+        name: string;
+        app?: _vue_devtools_kit.App;
+        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: _vue_devtools_kit.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;
+
+export { type AssetEntry, type AssetImporter, type AssetInfo, type AssetType, type CodeSnippet, DevToolsMessagingEvents, type ImageMeta, type ModuleInfo, type RPCFunctions, type 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,646 @@
+// src/client.ts
+import { isBrowser, target } from "@vue/devtools-shared";
+function setDevToolsClientUrl(url) {
+  target.__VUE_DEVTOOLS_CLIENT_URL__ = url;
+}
+function getDevToolsClientUrl() {
+  var _a;
+  return (_a = target.__VUE_DEVTOOLS_CLIENT_URL__) != null ? _a : (() => {
+    if (isBrowser) {
+      const devtoolsMeta = document.querySelector("meta[name=__VUE_DEVTOOLS_CLIENT_URL__]");
+      if (devtoolsMeta)
+        return devtoolsMeta.getAttribute("content");
+    }
+    return "";
+  })();
+}
+
+// src/rpc/global.ts
+import { devtools, DevToolsContextHookKeys, DevToolsMessagingHookKeys, devtoolsRouter, devtoolsRouterInfo, getActiveInspectors, getInspector, getInspectorActions, getInspectorInfo, getInspectorNodeActions, getRpcClient, getRpcServer, stringify, toggleClientConnected, updateDevToolsClientDetected, updateTimelineLayersState } from "@vue/devtools-kit";
+
+// ../../node_modules/.pnpm/hookable@5.5.3/node_modules/hookable/dist/index.mjs
+function flatHooks(configHooks, hooks3 = {}, parentName) {
+  for (const key in configHooks) {
+    const subHook = configHooks[key];
+    const name = parentName ? `${parentName}:${key}` : key;
+    if (typeof subHook === "object" && subHook !== null) {
+      flatHooks(subHook, hooks3, name);
+    } else if (typeof subHook === "function") {
+      hooks3[name] = subHook;
+    }
+  }
+  return hooks3;
+}
+var defaultTask = { run: (function_) => function_() };
+var _createTask = () => defaultTask;
+var createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
+function serialTaskCaller(hooks3, args) {
+  const name = args.shift();
+  const task = createTask(name);
+  return hooks3.reduce(
+    (promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))),
+    Promise.resolve()
+  );
+}
+function parallelTaskCaller(hooks3, args) {
+  const name = args.shift();
+  const task = createTask(name);
+  return Promise.all(hooks3.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 (e) {
+      }
+    }
+    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 hooks3 = flatHooks(configHooks);
+    const removeFns = Object.keys(hooks3).map(
+      (key) => this.hook(key, hooks3[key])
+    );
+    return () => {
+      for (const unreg of removeFns.splice(0, removeFns.length)) {
+        unreg();
+      }
+    };
+  }
+  removeHooks(configHooks) {
+    const hooks3 = flatHooks(configHooks);
+    for (const key in hooks3) {
+      this.removeHook(key, hooks3[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();
+}
+
+// src/rpc/global.ts
+var hooks = createHooks();
+var DevToolsMessagingEvents = /* @__PURE__ */ ((DevToolsMessagingEvents2) => {
+  DevToolsMessagingEvents2["INSPECTOR_TREE_UPDATED"] = "inspector-tree-updated";
+  DevToolsMessagingEvents2["INSPECTOR_STATE_UPDATED"] = "inspector-state-updated";
+  DevToolsMessagingEvents2["DEVTOOLS_STATE_UPDATED"] = "devtools-state-updated";
+  DevToolsMessagingEvents2["ROUTER_INFO_UPDATED"] = "router-info-updated";
+  DevToolsMessagingEvents2["TIMELINE_EVENT_UPDATED"] = "timeline-event-updated";
+  DevToolsMessagingEvents2["INSPECTOR_UPDATED"] = "inspector-updated";
+  DevToolsMessagingEvents2["ACTIVE_APP_UNMOUNTED"] = "active-app-updated";
+  DevToolsMessagingEvents2["DESTROY_DEVTOOLS_CLIENT"] = "destroy-devtools-client";
+  DevToolsMessagingEvents2["RELOAD_DEVTOOLS_CLIENT"] = "reload-devtools-client";
+  return DevToolsMessagingEvents2;
+})(DevToolsMessagingEvents || {});
+function getDevToolsState() {
+  var _a;
+  const state = devtools.ctx.state;
+  return {
+    connected: state.connected,
+    clientConnected: true,
+    vueVersion: ((_a = state == null ? void 0 : state.activeAppRecord) == null ? void 0 : _a.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
+  };
+}
+var functions = {
+  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;
+  },
+  devtoolsState: () => {
+    return getDevToolsState();
+  },
+  async getInspectorTree(payload) {
+    const res = await devtools.ctx.api.getInspectorTree(payload);
+    return stringify(res);
+  },
+  async getInspectorState(payload) {
+    const inspector = getInspector(payload.inspectorId);
+    if (inspector)
+      inspector.selectedNodeId = payload.nodeId;
+    const res = await devtools.ctx.api.getInspectorState(payload);
+    return stringify(res);
+  },
+  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) {
+    var _a;
+    const nodeActions = getInspectorNodeActions(inspectorId);
+    if (nodeActions == null ? void 0 : nodeActions.length) {
+      const item = nodeActions[actionIndex];
+      (_a = item.action) == null ? void 0 : _a.call(item, nodeId);
+    }
+  },
+  callInspectorAction(inspectorId, actionIndex) {
+    var _a;
+    const actions = getInspectorActions(inspectorId);
+    if (actions == null ? void 0 : actions.length) {
+      const item = actions[actionIndex];
+      (_a = item.action) == null ? void 0 : _a.call(item);
+    }
+  },
+  openInEditor(options) {
+    return devtools.ctx.api.openInEditor(options);
+  },
+  async checkVueInspectorDetected() {
+    return !!await devtools.ctx.api.getVueInspector();
+  },
+  async enableVueInspector() {
+    var _a, _b, _c;
+    const inspector = await ((_c = (_b = (_a = devtools) == null ? void 0 : _a.api) == null ? void 0 : _b.getVueInspector) == null ? void 0 : _c.call(_b));
+    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) {
+    var _a;
+    return (_a = devtoolsRouter.value) == null ? void 0 : _a.push(path).catch(() => ({}));
+  },
+  getMatchedRoutes(path) {
+    var _a, _b, _c;
+    const c = console.warn;
+    console.warn = () => {
+    };
+    const matched = (_c = (_b = (_a = devtoolsRouter.value) == null ? void 0 : _a.resolve) == null ? void 0 : _b.call(_a, {
+      path: path || "/"
+    }).matched) != null ? _c : [];
+    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);
+  },
+  // listen to devtools server events
+  initDevToolsServerListener() {
+    const rpcServer2 = getRpcServer();
+    const broadcast = rpcServer2.broadcast;
+    devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_INSPECTOR_TREE_TO_CLIENT, (payload) => {
+      broadcast.emit("inspector-tree-updated" /* INSPECTOR_TREE_UPDATED */, stringify(payload));
+    });
+    devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_INSPECTOR_STATE_TO_CLIENT, (payload) => {
+      broadcast.emit("inspector-state-updated" /* INSPECTOR_STATE_UPDATED */, stringify(payload));
+    });
+    devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.DEVTOOLS_STATE_UPDATED, () => {
+      broadcast.emit("devtools-state-updated" /* DEVTOOLS_STATE_UPDATED */, getDevToolsState());
+    });
+    devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.ROUTER_INFO_UPDATED, ({ state }) => {
+      broadcast.emit("router-info-updated" /* ROUTER_INFO_UPDATED */, state);
+    });
+    devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_TIMELINE_EVENT_TO_CLIENT, (payload) => {
+      broadcast.emit("timeline-event-updated" /* TIMELINE_EVENT_UPDATED */, stringify(payload));
+    });
+    devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_INSPECTOR_TO_CLIENT, (payload) => {
+      broadcast.emit("inspector-updated" /* INSPECTOR_UPDATED */, payload);
+    });
+    devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_ACTIVE_APP_UNMOUNTED_TO_CLIENT, () => {
+      broadcast.emit("active-app-updated" /* ACTIVE_APP_UNMOUNTED */);
+    });
+  }
+};
+var rpc = new Proxy({
+  value: {},
+  functions: {}
+}, {
+  get(target2, property) {
+    const _rpc = getRpcClient();
+    if (property === "value") {
+      return _rpc;
+    } else if (property === "functions") {
+      return _rpc.$functions;
+    }
+  }
+});
+var rpcServer = new Proxy({
+  value: {},
+  functions: {}
+}, {
+  get(target2, 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() {
+    var _a, _b;
+    (_b = (_a = rpc.value) == null ? void 0 : _a.heartbeat) == null ? void 0 : _b.call(_a).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);
+}
+
+// src/rpc/vite.ts
+import { createRpcClient, createRpcServer, getViteRpcClient } from "@vue/devtools-kit";
+var hooks2 = createHooks();
+var viteRpcFunctions = {
+  on: (event, handler) => {
+    hooks2.hook(event, handler);
+  },
+  off: (event, handler) => {
+    hooks2.removeHook(event, handler);
+  },
+  once: (event, handler) => {
+    hooks2.hookOnce(event, handler);
+  },
+  emit: (event, ...args) => {
+    hooks2.callHook(event, ...args);
+  },
+  heartbeat: () => {
+    return true;
+  }
+};
+var viteRpc = new Proxy({
+  value: {},
+  functions: {}
+}, {
+  get(target2, property) {
+    const _rpc = getViteRpcClient();
+    if (property === "value") {
+      return _rpc;
+    } else if (property === "functions") {
+      return _rpc == null ? void 0 : _rpc.$functions;
+    }
+  }
+});
+function onViteRpcConnected(callback) {
+  let timer = null;
+  function heartbeat() {
+    var _a, _b;
+    (_b = (_a = viteRpc.value) == null ? void 0 : _a.heartbeat) == null ? void 0 : _b.call(_a).then(() => {
+      clearTimeout(timer);
+      callback();
+    }).catch(() => ({}));
+    timer = setTimeout(() => {
+      heartbeat();
+    }, 80);
+  }
+  heartbeat();
+}
+function createViteClientRpc() {
+  createRpcClient(viteRpcFunctions, {
+    preset: "vite"
+  });
+}
+function createViteServerRpc(functions2) {
+  createRpcServer(functions2, {
+    preset: "vite"
+  });
+}
+
+// src/vue-plugin/devtools-state.ts
+import { computed, inject, onUnmounted, ref, watch } from "vue";
+var 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 getDevToolsState2() {
+    onRpcConnected(() => {
+      rpc.value.devtoolsState().then((data) => {
+        updateState(data);
+      });
+      rpc.functions.off("devtools-state-updated" /* DEVTOOLS_STATE_UPDATED */, updateState);
+      rpc.functions.on("devtools-state-updated" /* DEVTOOLS_STATE_UPDATED */, updateState);
+    });
+  }
+  return {
+    getDevToolsState: getDevToolsState2,
+    connected,
+    clientConnected,
+    vueVersion,
+    tabs,
+    commands,
+    vitePluginDetected,
+    appRecords,
+    activeAppRecordId,
+    timelineLayersState
+  };
+}
+function useDevToolsState() {
+  return inject(VueDevToolsStateSymbol);
+}
+var 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());
+}
+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))
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

node_modules/@vue/devtools-kit/LICENSE

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

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

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

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

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

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

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

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

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

node_modules/@vue/devtools-shared/LICENSE

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

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

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

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

@@ -0,0 +1,378 @@
+"use strict";
+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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target2, all) => {
+  for (var name in all)
+    __defProp(target2, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/.pnpm/tsup@8.4.0_@microsoft+api-extractor@7.51.1_@types+node@22.13.14__jiti@2.4.2_postcss@8.5_96eb05a9d65343021e53791dd83f3773/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.4.0_@microsoft+api-extractor@7.51.1_@types+node@22.13.14__jiti@2.4.2_postcss@8.5_96eb05a9d65343021e53791dd83f3773/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js
+var require_rfdc = __commonJS({
+  "../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    module2.exports = rfdc2;
+    function copyBuffer(cur) {
+      if (cur instanceof Buffer) {
+        return Buffer.from(cur);
+      }
+      return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
+    }
+    function rfdc2(opts) {
+      opts = opts || {};
+      if (opts.circles) return rfdcCircles(opts);
+      const constructorHandlers = /* @__PURE__ */ new Map();
+      constructorHandlers.set(Date, (o) => new Date(o));
+      constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+      constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+      if (opts.constructorHandlers) {
+        for (const handler2 of opts.constructorHandlers) {
+          constructorHandlers.set(handler2[0], handler2[1]);
+        }
+      }
+      let handler = null;
+      return opts.proto ? cloneProto : clone;
+      function cloneArray(a, fn) {
+        const keys = Object.keys(a);
+        const a2 = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+          const k = keys[i];
+          const cur = a[k];
+          if (typeof cur !== "object" || cur === null) {
+            a2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a2[k] = handler(cur, fn);
+          } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+          } else {
+            a2[k] = fn(cur);
+          }
+        }
+        return a2;
+      }
+      function clone(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, clone);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, clone);
+        }
+        const o2 = {};
+        for (const k in o) {
+          if (Object.hasOwnProperty.call(o, k) === false) continue;
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, clone);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            o2[k] = clone(cur);
+          }
+        }
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, cloneProto);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, cloneProto);
+        }
+        const o2 = {};
+        for (const k in o) {
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, cloneProto);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            o2[k] = cloneProto(cur);
+          }
+        }
+        return o2;
+      }
+    }
+    function rfdcCircles(opts) {
+      const refs = [];
+      const refsNew = [];
+      const constructorHandlers = /* @__PURE__ */ new Map();
+      constructorHandlers.set(Date, (o) => new Date(o));
+      constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+      constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+      if (opts.constructorHandlers) {
+        for (const handler2 of opts.constructorHandlers) {
+          constructorHandlers.set(handler2[0], handler2[1]);
+        }
+      }
+      let handler = null;
+      return opts.proto ? cloneProto : clone;
+      function cloneArray(a, fn) {
+        const keys = Object.keys(a);
+        const a2 = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+          const k = keys[i];
+          const cur = a[k];
+          if (typeof cur !== "object" || cur === null) {
+            a2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a2[k] = handler(cur, fn);
+          } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+          } else {
+            const index = refs.indexOf(cur);
+            if (index !== -1) {
+              a2[k] = refsNew[index];
+            } else {
+              a2[k] = fn(cur);
+            }
+          }
+        }
+        return a2;
+      }
+      function clone(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, clone);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, clone);
+        }
+        const o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (const k in o) {
+          if (Object.hasOwnProperty.call(o, k) === false) continue;
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, clone);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            const i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k] = refsNew[i];
+            } else {
+              o2[k] = clone(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, cloneProto);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, cloneProto);
+        }
+        const o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (const k in o) {
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, cloneProto);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            const i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k] = refsNew[i];
+            } else {
+              o2[k] = cloneProto(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+    }
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BROADCAST_CHANNEL_NAME: () => BROADCAST_CHANNEL_NAME,
+  NOOP: () => NOOP,
+  VIEW_MODE_STORAGE_KEY: () => VIEW_MODE_STORAGE_KEY,
+  VITE_PLUGIN_CLIENT_URL_STORAGE_KEY: () => VITE_PLUGIN_CLIENT_URL_STORAGE_KEY,
+  VITE_PLUGIN_DETECTED_STORAGE_KEY: () => VITE_PLUGIN_DETECTED_STORAGE_KEY,
+  basename: () => basename,
+  camelize: () => camelize,
+  classify: () => classify,
+  deepClone: () => deepClone,
+  isArray: () => isArray,
+  isBrowser: () => isBrowser,
+  isInChromePanel: () => isInChromePanel,
+  isInElectron: () => isInElectron,
+  isInIframe: () => isInIframe,
+  isInSeparateWindow: () => isInSeparateWindow,
+  isMacOS: () => isMacOS,
+  isMap: () => isMap,
+  isNumeric: () => isNumeric,
+  isNuxtApp: () => isNuxtApp,
+  isObject: () => isObject,
+  isSet: () => isSet,
+  isUrlString: () => isUrlString,
+  kebabize: () => kebabize,
+  randomStr: () => randomStr,
+  sortByKey: () => sortByKey,
+  target: () => target
+});
+module.exports = __toCommonJS(index_exports);
+init_cjs_shims();
+
+// src/constants.ts
+init_cjs_shims();
+var VIEW_MODE_STORAGE_KEY = "__vue-devtools-view-mode__";
+var VITE_PLUGIN_DETECTED_STORAGE_KEY = "__vue-devtools-vite-plugin-detected__";
+var VITE_PLUGIN_CLIENT_URL_STORAGE_KEY = "__vue-devtools-vite-plugin-client-url__";
+var BROADCAST_CHANNEL_NAME = "__vue-devtools-broadcast-channel__";
+
+// src/env.ts
+init_cjs_shims();
+var isBrowser = typeof navigator !== "undefined";
+var target = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : {};
+var isInChromePanel = typeof target.chrome !== "undefined" && !!target.chrome.devtools;
+var isInIframe = isBrowser && target.self !== target.top;
+var _a;
+var isInElectron = typeof navigator !== "undefined" && ((_a = navigator.userAgent) == null ? void 0 : _a.toLowerCase().includes("electron"));
+var isNuxtApp = typeof window !== "undefined" && !!window.__NUXT__;
+var isInSeparateWindow = !isInIframe && !isInChromePanel && !isInElectron;
+
+// src/general.ts
+init_cjs_shims();
+var import_rfdc = __toESM(require_rfdc(), 1);
+function NOOP() {
+}
+var isNumeric = (str) => `${+str}` === str;
+var isMacOS = () => (navigator == null ? void 0 : navigator.platform) ? navigator == null ? void 0 : navigator.platform.toLowerCase().includes("mac") : /Macintosh/.test(navigator.userAgent);
+var classifyRE = /(?:^|[-_/])(\w)/g;
+var camelizeRE = /-(\w)/g;
+var kebabizeRE = /([a-z0-9])([A-Z])/g;
+function toUpper(_, c) {
+  return c ? c.toUpperCase() : "";
+}
+function classify(str) {
+  return str && `${str}`.replace(classifyRE, toUpper);
+}
+function camelize(str) {
+  return str && str.replace(camelizeRE, toUpper);
+}
+function kebabize(str) {
+  return str && str.replace(kebabizeRE, (_, lowerCaseCharacter, upperCaseLetter) => {
+    return `${lowerCaseCharacter}-${upperCaseLetter}`;
+  }).toLowerCase();
+}
+function basename(filename, ext) {
+  let normalizedFilename = filename.replace(/^[a-z]:/i, "").replace(/\\/g, "/");
+  if (normalizedFilename.endsWith(`index${ext}`)) {
+    normalizedFilename = normalizedFilename.replace(`/index${ext}`, ext);
+  }
+  const lastSlashIndex = normalizedFilename.lastIndexOf("/");
+  const baseNameWithExt = normalizedFilename.substring(lastSlashIndex + 1);
+  if (ext) {
+    const extIndex = baseNameWithExt.lastIndexOf(ext);
+    return baseNameWithExt.substring(0, extIndex);
+  }
+  return "";
+}
+function sortByKey(state) {
+  return state && state.slice().sort((a, b) => {
+    if (a.key < b.key)
+      return -1;
+    if (a.key > b.key)
+      return 1;
+    return 0;
+  });
+}
+var HTTP_URL_RE = /^https?:\/\//;
+function isUrlString(str) {
+  return str.startsWith("/") || HTTP_URL_RE.test(str);
+}
+var deepClone = (0, import_rfdc.default)({ circles: true });
+function randomStr() {
+  return Math.random().toString(36).slice(2);
+}
+function isObject(value) {
+  return typeof value === "object" && !Array.isArray(value) && value !== null;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isSet(value) {
+  return value instanceof Set;
+}
+function isMap(value) {
+  return value instanceof Map;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BROADCAST_CHANNEL_NAME,
+  NOOP,
+  VIEW_MODE_STORAGE_KEY,
+  VITE_PLUGIN_CLIENT_URL_STORAGE_KEY,
+  VITE_PLUGIN_DETECTED_STORAGE_KEY,
+  basename,
+  camelize,
+  classify,
+  deepClone,
+  isArray,
+  isBrowser,
+  isInChromePanel,
+  isInElectron,
+  isInIframe,
+  isInSeparateWindow,
+  isMacOS,
+  isMap,
+  isNumeric,
+  isNuxtApp,
+  isObject,
+  isSet,
+  isUrlString,
+  kebabize,
+  randomStr,
+  sortByKey,
+  target
+});

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

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

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

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

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

@@ -0,0 +1,341 @@
+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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  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 (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
+  mod
+));
+
+// ../../node_modules/.pnpm/tsup@8.4.0_@microsoft+api-extractor@7.51.1_@types+node@22.13.14__jiti@2.4.2_postcss@8.5_96eb05a9d65343021e53791dd83f3773/node_modules/tsup/assets/esm_shims.js
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.4.0_@microsoft+api-extractor@7.51.1_@types+node@22.13.14__jiti@2.4.2_postcss@8.5_96eb05a9d65343021e53791dd83f3773/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js
+var require_rfdc = __commonJS({
+  "../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    module.exports = rfdc2;
+    function copyBuffer(cur) {
+      if (cur instanceof Buffer) {
+        return Buffer.from(cur);
+      }
+      return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
+    }
+    function rfdc2(opts) {
+      opts = opts || {};
+      if (opts.circles) return rfdcCircles(opts);
+      const constructorHandlers = /* @__PURE__ */ new Map();
+      constructorHandlers.set(Date, (o) => new Date(o));
+      constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+      constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+      if (opts.constructorHandlers) {
+        for (const handler2 of opts.constructorHandlers) {
+          constructorHandlers.set(handler2[0], handler2[1]);
+        }
+      }
+      let handler = null;
+      return opts.proto ? cloneProto : clone;
+      function cloneArray(a, fn) {
+        const keys = Object.keys(a);
+        const a2 = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+          const k = keys[i];
+          const cur = a[k];
+          if (typeof cur !== "object" || cur === null) {
+            a2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a2[k] = handler(cur, fn);
+          } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+          } else {
+            a2[k] = fn(cur);
+          }
+        }
+        return a2;
+      }
+      function clone(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, clone);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, clone);
+        }
+        const o2 = {};
+        for (const k in o) {
+          if (Object.hasOwnProperty.call(o, k) === false) continue;
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, clone);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            o2[k] = clone(cur);
+          }
+        }
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, cloneProto);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, cloneProto);
+        }
+        const o2 = {};
+        for (const k in o) {
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, cloneProto);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            o2[k] = cloneProto(cur);
+          }
+        }
+        return o2;
+      }
+    }
+    function rfdcCircles(opts) {
+      const refs = [];
+      const refsNew = [];
+      const constructorHandlers = /* @__PURE__ */ new Map();
+      constructorHandlers.set(Date, (o) => new Date(o));
+      constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+      constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+      if (opts.constructorHandlers) {
+        for (const handler2 of opts.constructorHandlers) {
+          constructorHandlers.set(handler2[0], handler2[1]);
+        }
+      }
+      let handler = null;
+      return opts.proto ? cloneProto : clone;
+      function cloneArray(a, fn) {
+        const keys = Object.keys(a);
+        const a2 = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+          const k = keys[i];
+          const cur = a[k];
+          if (typeof cur !== "object" || cur === null) {
+            a2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a2[k] = handler(cur, fn);
+          } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+          } else {
+            const index = refs.indexOf(cur);
+            if (index !== -1) {
+              a2[k] = refsNew[index];
+            } else {
+              a2[k] = fn(cur);
+            }
+          }
+        }
+        return a2;
+      }
+      function clone(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, clone);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, clone);
+        }
+        const o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (const k in o) {
+          if (Object.hasOwnProperty.call(o, k) === false) continue;
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, clone);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            const i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k] = refsNew[i];
+            } else {
+              o2[k] = clone(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, cloneProto);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, cloneProto);
+        }
+        const o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (const k in o) {
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, cloneProto);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            const i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k] = refsNew[i];
+            } else {
+              o2[k] = cloneProto(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+    }
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+
+// src/constants.ts
+init_esm_shims();
+var VIEW_MODE_STORAGE_KEY = "__vue-devtools-view-mode__";
+var VITE_PLUGIN_DETECTED_STORAGE_KEY = "__vue-devtools-vite-plugin-detected__";
+var VITE_PLUGIN_CLIENT_URL_STORAGE_KEY = "__vue-devtools-vite-plugin-client-url__";
+var BROADCAST_CHANNEL_NAME = "__vue-devtools-broadcast-channel__";
+
+// src/env.ts
+init_esm_shims();
+var isBrowser = typeof navigator !== "undefined";
+var target = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : {};
+var isInChromePanel = typeof target.chrome !== "undefined" && !!target.chrome.devtools;
+var isInIframe = isBrowser && target.self !== target.top;
+var _a;
+var isInElectron = typeof navigator !== "undefined" && ((_a = navigator.userAgent) == null ? void 0 : _a.toLowerCase().includes("electron"));
+var isNuxtApp = typeof window !== "undefined" && !!window.__NUXT__;
+var isInSeparateWindow = !isInIframe && !isInChromePanel && !isInElectron;
+
+// src/general.ts
+init_esm_shims();
+var import_rfdc = __toESM(require_rfdc(), 1);
+function NOOP() {
+}
+var isNumeric = (str) => `${+str}` === str;
+var isMacOS = () => (navigator == null ? void 0 : navigator.platform) ? navigator == null ? void 0 : navigator.platform.toLowerCase().includes("mac") : /Macintosh/.test(navigator.userAgent);
+var classifyRE = /(?:^|[-_/])(\w)/g;
+var camelizeRE = /-(\w)/g;
+var kebabizeRE = /([a-z0-9])([A-Z])/g;
+function toUpper(_, c) {
+  return c ? c.toUpperCase() : "";
+}
+function classify(str) {
+  return str && `${str}`.replace(classifyRE, toUpper);
+}
+function camelize(str) {
+  return str && str.replace(camelizeRE, toUpper);
+}
+function kebabize(str) {
+  return str && str.replace(kebabizeRE, (_, lowerCaseCharacter, upperCaseLetter) => {
+    return `${lowerCaseCharacter}-${upperCaseLetter}`;
+  }).toLowerCase();
+}
+function basename(filename, ext) {
+  let normalizedFilename = filename.replace(/^[a-z]:/i, "").replace(/\\/g, "/");
+  if (normalizedFilename.endsWith(`index${ext}`)) {
+    normalizedFilename = normalizedFilename.replace(`/index${ext}`, ext);
+  }
+  const lastSlashIndex = normalizedFilename.lastIndexOf("/");
+  const baseNameWithExt = normalizedFilename.substring(lastSlashIndex + 1);
+  if (ext) {
+    const extIndex = baseNameWithExt.lastIndexOf(ext);
+    return baseNameWithExt.substring(0, extIndex);
+  }
+  return "";
+}
+function sortByKey(state) {
+  return state && state.slice().sort((a, b) => {
+    if (a.key < b.key)
+      return -1;
+    if (a.key > b.key)
+      return 1;
+    return 0;
+  });
+}
+var HTTP_URL_RE = /^https?:\/\//;
+function isUrlString(str) {
+  return str.startsWith("/") || HTTP_URL_RE.test(str);
+}
+var deepClone = (0, import_rfdc.default)({ circles: true });
+function randomStr() {
+  return Math.random().toString(36).slice(2);
+}
+function isObject(value) {
+  return typeof value === "object" && !Array.isArray(value) && value !== null;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isSet(value) {
+  return value instanceof Set;
+}
+function isMap(value) {
+  return value instanceof Map;
+}
+export {
+  BROADCAST_CHANNEL_NAME,
+  NOOP,
+  VIEW_MODE_STORAGE_KEY,
+  VITE_PLUGIN_CLIENT_URL_STORAGE_KEY,
+  VITE_PLUGIN_DETECTED_STORAGE_KEY,
+  basename,
+  camelize,
+  classify,
+  deepClone,
+  isArray,
+  isBrowser,
+  isInChromePanel,
+  isInElectron,
+  isInIframe,
+  isInSeparateWindow,
+  isMacOS,
+  isMap,
+  isNumeric,
+  isNuxtApp,
+  isObject,
+  isSet,
+  isUrlString,
+  kebabize,
+  randomStr,
+  sortByKey,
+  target
+};

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

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

node_modules/@vue/reactivity/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/reactivity/README.md

@@ -0,0 +1,19 @@
+# @vue/reactivity
+
+## Usage Note
+
+This package is inlined into Global & Browser ESM builds of user-facing renderers (e.g. `@vue/runtime-dom`), but also published as a package that can be used standalone. The standalone build should not be used alongside a pre-bundled build of a user-facing renderer, as they will have different internal storage for reactivity connections. A user-facing renderer should re-export all APIs from this package.
+
+For full exposed APIs, see `src/index.ts`.
+
+## Credits
+
+The implementation of this module is inspired by the following prior art in the JavaScript ecosystem:
+
+- [Meteor Tracker](https://docs.meteor.com/api/tracker.html)
+- [nx-js/observer-util](https://github.com/nx-js/observer-util)
+- [salesforce/observable-membrane](https://github.com/salesforce/observable-membrane)
+
+## Caveats
+
+- Built-in objects are not observed except for `Array`, `Map`, `WeakMap`, `Set` and `WeakSet`.

node_modules/@vue/reactivity/dist/reactivity.d.ts

@@ -0,0 +1,754 @@
+import { IfAny } from '@vue/shared';
+
+export declare enum TrackOpTypes {
+    GET = "get",
+    HAS = "has",
+    ITERATE = "iterate"
+}
+export declare enum TriggerOpTypes {
+    SET = "set",
+    ADD = "add",
+    DELETE = "delete",
+    CLEAR = "clear"
+}
+export declare enum ReactiveFlags {
+    SKIP = "__v_skip",
+    IS_REACTIVE = "__v_isReactive",
+    IS_READONLY = "__v_isReadonly",
+    IS_SHALLOW = "__v_isShallow",
+    RAW = "__v_raw",
+    IS_REF = "__v_isRef"
+}
+
+export type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>;
+declare const ReactiveMarkerSymbol: unique symbol;
+export interface ReactiveMarker {
+    [ReactiveMarkerSymbol]?: void;
+}
+export type Reactive<T> = UnwrapNestedRefs<T> & (T extends readonly any[] ? ReactiveMarker : {});
+/**
+ * Returns a reactive proxy of the object.
+ *
+ * The reactive conversion is "deep": it affects all nested properties. A
+ * reactive object also deeply unwraps any properties that are refs while
+ * maintaining reactivity.
+ *
+ * @example
+ * ```js
+ * const obj = reactive({ count: 0 })
+ * ```
+ *
+ * @param target - The source object.
+ * @see {@link https://vuejs.org/api/reactivity-core.html#reactive}
+ */
+export declare function reactive<T extends object>(target: T): Reactive<T>;
+declare const ShallowReactiveMarker: unique symbol;
+export type ShallowReactive<T> = T & {
+    [ShallowReactiveMarker]?: true;
+};
+/**
+ * Shallow version of {@link reactive}.
+ *
+ * Unlike {@link reactive}, there is no deep conversion: only root-level
+ * properties are reactive for a shallow reactive object. Property values are
+ * stored and exposed as-is - this also means properties with ref values will
+ * not be automatically unwrapped.
+ *
+ * @example
+ * ```js
+ * const state = shallowReactive({
+ *   foo: 1,
+ *   nested: {
+ *     bar: 2
+ *   }
+ * })
+ *
+ * // mutating state's own properties is reactive
+ * state.foo++
+ *
+ * // ...but does not convert nested objects
+ * isReactive(state.nested) // false
+ *
+ * // NOT reactive
+ * state.nested.bar++
+ * ```
+ *
+ * @param target - The source object.
+ * @see {@link https://vuejs.org/api/reactivity-advanced.html#shallowreactive}
+ */
+export declare function shallowReactive<T extends object>(target: T): ShallowReactive<T>;
+type Primitive = string | number | boolean | bigint | symbol | undefined | null;
+type Builtin = Primitive | Function | Date | Error | RegExp;
+export type DeepReadonly<T> = T extends Builtin ? T : T extends Map<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends WeakMap<infer K, infer V> ? WeakMap<DeepReadonly<K>, DeepReadonly<V>> : T extends Set<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends ReadonlySet<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends WeakSet<infer U> ? WeakSet<DeepReadonly<U>> : T extends Promise<infer U> ? Promise<DeepReadonly<U>> : T extends Ref<infer U, unknown> ? Readonly<Ref<DeepReadonly<U>>> : T extends {} ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : Readonly<T>;
+/**
+ * Takes an object (reactive or plain) or a ref and returns a readonly proxy to
+ * the original.
+ *
+ * A readonly proxy is deep: any nested property accessed will be readonly as
+ * well. It also has the same ref-unwrapping behavior as {@link reactive},
+ * except the unwrapped values will also be made readonly.
+ *
+ * @example
+ * ```js
+ * const original = reactive({ count: 0 })
+ *
+ * const copy = readonly(original)
+ *
+ * watchEffect(() => {
+ *   // works for reactivity tracking
+ *   console.log(copy.count)
+ * })
+ *
+ * // mutating original will trigger watchers relying on the copy
+ * original.count++
+ *
+ * // mutating the copy will fail and result in a warning
+ * copy.count++ // warning!
+ * ```
+ *
+ * @param target - The source object.
+ * @see {@link https://vuejs.org/api/reactivity-core.html#readonly}
+ */
+export declare function readonly<T extends object>(target: T): DeepReadonly<UnwrapNestedRefs<T>>;
+/**
+ * Shallow version of {@link readonly}.
+ *
+ * Unlike {@link readonly}, there is no deep conversion: only root-level
+ * properties are made readonly. Property values are stored and exposed as-is -
+ * this also means properties with ref values will not be automatically
+ * unwrapped.
+ *
+ * @example
+ * ```js
+ * const state = shallowReadonly({
+ *   foo: 1,
+ *   nested: {
+ *     bar: 2
+ *   }
+ * })
+ *
+ * // mutating state's own properties will fail
+ * state.foo++
+ *
+ * // ...but works on nested objects
+ * isReadonly(state.nested) // false
+ *
+ * // works
+ * state.nested.bar++
+ * ```
+ *
+ * @param target - The source object.
+ * @see {@link https://vuejs.org/api/reactivity-advanced.html#shallowreadonly}
+ */
+export declare function shallowReadonly<T extends object>(target: T): Readonly<T>;
+/**
+ * Checks if an object is a proxy created by {@link reactive} or
+ * {@link shallowReactive} (or {@link ref} in some cases).
+ *
+ * @example
+ * ```js
+ * isReactive(reactive({}))            // => true
+ * isReactive(readonly(reactive({})))  // => true
+ * isReactive(ref({}).value)           // => true
+ * isReactive(readonly(ref({})).value) // => true
+ * isReactive(ref(true))               // => false
+ * isReactive(shallowRef({}).value)    // => false
+ * isReactive(shallowReactive({}))     // => true
+ * ```
+ *
+ * @param value - The value to check.
+ * @see {@link https://vuejs.org/api/reactivity-utilities.html#isreactive}
+ */
+export declare function isReactive(value: unknown): boolean;
+/**
+ * Checks whether the passed value is a readonly object. The properties of a
+ * readonly object can change, but they can't be assigned directly via the
+ * passed object.
+ *
+ * The proxies created by {@link readonly} and {@link shallowReadonly} are
+ * both considered readonly, as is a computed ref without a set function.
+ *
+ * @param value - The value to check.
+ * @see {@link https://vuejs.org/api/reactivity-utilities.html#isreadonly}
+ */
+export declare function isReadonly(value: unknown): boolean;
+export declare function isShallow(value: unknown): boolean;
+/**
+ * Checks if an object is a proxy created by {@link reactive},
+ * {@link readonly}, {@link shallowReactive} or {@link shallowReadonly}.
+ *
+ * @param value - The value to check.
+ * @see {@link https://vuejs.org/api/reactivity-utilities.html#isproxy}
+ */
+export declare function isProxy(value: any): boolean;
+/**
+ * Returns the raw, original object of a Vue-created proxy.
+ *
+ * `toRaw()` can return the original object from proxies created by
+ * {@link reactive}, {@link readonly}, {@link shallowReactive} or
+ * {@link shallowReadonly}.
+ *
+ * This is an escape hatch that can be used to temporarily read without
+ * incurring proxy access / tracking overhead or write without triggering
+ * changes. It is **not** recommended to hold a persistent reference to the
+ * original object. Use with caution.
+ *
+ * @example
+ * ```js
+ * const foo = {}
+ * const reactiveFoo = reactive(foo)
+ *
+ * console.log(toRaw(reactiveFoo) === foo) // true
+ * ```
+ *
+ * @param observed - The object for which the "raw" value is requested.
+ * @see {@link https://vuejs.org/api/reactivity-advanced.html#toraw}
+ */
+export declare function toRaw<T>(observed: T): T;
+export type Raw<T> = T & {
+    [RawSymbol]?: true;
+};
+/**
+ * Marks an object so that it will never be converted to a proxy. Returns the
+ * object itself.
+ *
+ * @example
+ * ```js
+ * const foo = markRaw({})
+ * console.log(isReactive(reactive(foo))) // false
+ *
+ * // also works when nested inside other reactive objects
+ * const bar = reactive({ foo })
+ * console.log(isReactive(bar.foo)) // false
+ * ```
+ *
+ * **Warning:** `markRaw()` together with the shallow APIs such as
+ * {@link shallowReactive} allow you to selectively opt-out of the default
+ * deep reactive/readonly conversion and embed raw, non-proxied objects in your
+ * state graph.
+ *
+ * @param value - The object to be marked as "raw".
+ * @see {@link https://vuejs.org/api/reactivity-advanced.html#markraw}
+ */
+export declare function markRaw<T extends object>(value: T): Raw<T>;
+/**
+ * Returns a reactive proxy of the given value (if possible).
+ *
+ * If the given value is not an object, the original value itself is returned.
+ *
+ * @param value - The value for which a reactive proxy shall be created.
+ */
+export declare const toReactive: <T extends unknown>(value: T) => T;
+/**
+ * Returns a readonly proxy of the given value (if possible).
+ *
+ * If the given value is not an object, the original value itself is returned.
+ *
+ * @param value - The value for which a readonly proxy shall be created.
+ */
+export declare const toReadonly: <T extends unknown>(value: T) => DeepReadonly<T>;
+
+export type EffectScheduler = (...args: any[]) => any;
+export type DebuggerEvent = {
+    effect: Subscriber;
+} & DebuggerEventExtraInfo;
+export type DebuggerEventExtraInfo = {
+    target: object;
+    type: TrackOpTypes | TriggerOpTypes;
+    key: any;
+    newValue?: any;
+    oldValue?: any;
+    oldTarget?: Map<any, any> | Set<any>;
+};
+export interface DebuggerOptions {
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+}
+export interface ReactiveEffectOptions extends DebuggerOptions {
+    scheduler?: EffectScheduler;
+    allowRecurse?: boolean;
+    onStop?: () => void;
+}
+export interface ReactiveEffectRunner<T = any> {
+    (): T;
+    effect: ReactiveEffect;
+}
+export declare enum EffectFlags {
+    /**
+     * ReactiveEffect only
+     */
+    ACTIVE = 1,
+    RUNNING = 2,
+    TRACKING = 4,
+    NOTIFIED = 8,
+    DIRTY = 16,
+    ALLOW_RECURSE = 32,
+    PAUSED = 64,
+    EVALUATED = 128
+}
+/**
+ * Subscriber is a type that tracks (or subscribes to) a list of deps.
+ */
+interface Subscriber extends DebuggerOptions {
+}
+export declare class ReactiveEffect<T = any> implements Subscriber, ReactiveEffectOptions {
+    fn: () => T;
+    scheduler?: EffectScheduler;
+    onStop?: () => void;
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+    constructor(fn: () => T);
+    pause(): void;
+    resume(): void;
+    run(): T;
+    stop(): void;
+    trigger(): void;
+    get dirty(): boolean;
+}
+export declare function effect<T = any>(fn: () => T, options?: ReactiveEffectOptions): ReactiveEffectRunner<T>;
+/**
+ * Stops the effect associated with the given runner.
+ *
+ * @param runner - Association with the effect to stop tracking.
+ */
+export declare function stop(runner: ReactiveEffectRunner): void;
+/**
+ * Temporarily pauses tracking.
+ */
+export declare function pauseTracking(): void;
+/**
+ * Re-enables effect tracking (if it was paused).
+ */
+export declare function enableTracking(): void;
+/**
+ * Resets the previous global effect tracking state.
+ */
+export declare function resetTracking(): void;
+/**
+ * Registers a cleanup function for the current active effect.
+ * The cleanup function is called right before the next effect run, or when the
+ * effect is stopped.
+ *
+ * Throws a warning if there is no current active effect. The warning can be
+ * suppressed by passing `true` to the second argument.
+ *
+ * @param fn - the cleanup function to be registered
+ * @param failSilently - if `true`, will not throw warning when called without
+ * an active effect.
+ */
+export declare function onEffectCleanup(fn: () => void, failSilently?: boolean): void;
+
+declare const ComputedRefSymbol: unique symbol;
+declare const WritableComputedRefSymbol: unique symbol;
+interface BaseComputedRef<T, S = T> extends Ref<T, S> {
+    [ComputedRefSymbol]: true;
+    /**
+     * @deprecated computed no longer uses effect
+     */
+    effect: ComputedRefImpl;
+}
+export interface ComputedRef<T = any> extends BaseComputedRef<T> {
+    readonly value: T;
+}
+export interface WritableComputedRef<T, S = T> extends BaseComputedRef<T, S> {
+    [WritableComputedRefSymbol]: true;
+}
+export type ComputedGetter<T> = (oldValue?: T) => T;
+export type ComputedSetter<T> = (newValue: T) => void;
+export interface WritableComputedOptions<T, S = T> {
+    get: ComputedGetter<T>;
+    set: ComputedSetter<S>;
+}
+/**
+ * @private exported by @vue/reactivity for Vue core use, but not exported from
+ * the main vue package
+ */
+export declare class ComputedRefImpl<T = any> implements Subscriber {
+    fn: ComputedGetter<T>;
+    private readonly setter;
+    effect: this;
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+    constructor(fn: ComputedGetter<T>, setter: ComputedSetter<T> | undefined, isSSR: boolean);
+    get value(): T;
+    set value(newValue: T);
+}
+/**
+ * Takes a getter function and returns a readonly reactive ref object for the
+ * returned value from the getter. It can also take an object with get and set
+ * functions to create a writable ref object.
+ *
+ * @example
+ * ```js
+ * // Creating a readonly computed ref:
+ * const count = ref(1)
+ * const plusOne = computed(() => count.value + 1)
+ *
+ * console.log(plusOne.value) // 2
+ * plusOne.value++ // error
+ * ```
+ *
+ * ```js
+ * // Creating a writable computed ref:
+ * const count = ref(1)
+ * const plusOne = computed({
+ *   get: () => count.value + 1,
+ *   set: (val) => {
+ *     count.value = val - 1
+ *   }
+ * })
+ *
+ * plusOne.value = 1
+ * console.log(count.value) // 0
+ * ```
+ *
+ * @param getter - Function that produces the next value.
+ * @param debugOptions - For debugging. See {@link https://vuejs.org/guide/extras/reactivity-in-depth.html#computed-debugging}.
+ * @see {@link https://vuejs.org/api/reactivity-core.html#computed}
+ */
+export declare function computed<T>(getter: ComputedGetter<T>, debugOptions?: DebuggerOptions): ComputedRef<T>;
+export declare function computed<T, S = T>(options: WritableComputedOptions<T, S>, debugOptions?: DebuggerOptions): WritableComputedRef<T, S>;
+
+declare const RefSymbol: unique symbol;
+declare const RawSymbol: unique symbol;
+export interface Ref<T = any, S = T> {
+    get value(): T;
+    set value(_: S);
+    /**
+     * Type differentiator only.
+     * We need this to be in public d.ts but don't want it to show up in IDE
+     * autocomplete, so we use a private Symbol instead.
+     */
+    [RefSymbol]: true;
+}
+/**
+ * Checks if a value is a ref object.
+ *
+ * @param r - The value to inspect.
+ * @see {@link https://vuejs.org/api/reactivity-utilities.html#isref}
+ */
+export declare function isRef<T>(r: Ref<T> | unknown): r is Ref<T>;
+/**
+ * Takes an inner value and returns a reactive and mutable ref object, which
+ * has a single property `.value` that points to the inner value.
+ *
+ * @param value - The object to wrap in the ref.
+ * @see {@link https://vuejs.org/api/reactivity-core.html#ref}
+ */
+export declare function ref<T>(value: T): [T] extends [Ref] ? IfAny<T, Ref<T>, T> : Ref<UnwrapRef<T>, UnwrapRef<T> | T>;
+export declare function ref<T = any>(): Ref<T | undefined>;
+declare const ShallowRefMarker: unique symbol;
+export type ShallowRef<T = any, S = T> = Ref<T, S> & {
+    [ShallowRefMarker]?: true;
+};
+/**
+ * Shallow version of {@link ref}.
+ *
+ * @example
+ * ```js
+ * const state = shallowRef({ count: 1 })
+ *
+ * // does NOT trigger change
+ * state.value.count = 2
+ *
+ * // does trigger change
+ * state.value = { count: 2 }
+ * ```
+ *
+ * @param value - The "inner value" for the shallow ref.
+ * @see {@link https://vuejs.org/api/reactivity-advanced.html#shallowref}
+ */
+export declare function shallowRef<T>(value: T): Ref extends T ? T extends Ref ? IfAny<T, ShallowRef<T>, T> : ShallowRef<T> : ShallowRef<T>;
+export declare function shallowRef<T = any>(): ShallowRef<T | undefined>;
+/**
+ * Force trigger effects that depends on a shallow ref. This is typically used
+ * after making deep mutations to the inner value of a shallow ref.
+ *
+ * @example
+ * ```js
+ * const shallow = shallowRef({
+ *   greet: 'Hello, world'
+ * })
+ *
+ * // Logs "Hello, world" once for the first run-through
+ * watchEffect(() => {
+ *   console.log(shallow.value.greet)
+ * })
+ *
+ * // This won't trigger the effect because the ref is shallow
+ * shallow.value.greet = 'Hello, universe'
+ *
+ * // Logs "Hello, universe"
+ * triggerRef(shallow)
+ * ```
+ *
+ * @param ref - The ref whose tied effects shall be executed.
+ * @see {@link https://vuejs.org/api/reactivity-advanced.html#triggerref}
+ */
+export declare function triggerRef(ref: Ref): void;
+export type MaybeRef<T = any> = T | Ref<T> | ShallowRef<T> | WritableComputedRef<T>;
+export type MaybeRefOrGetter<T = any> = MaybeRef<T> | ComputedRef<T> | (() => T);
+/**
+ * Returns the inner value if the argument is a ref, otherwise return the
+ * argument itself. This is a sugar function for
+ * `val = isRef(val) ? val.value : val`.
+ *
+ * @example
+ * ```js
+ * function useFoo(x: number | Ref<number>) {
+ *   const unwrapped = unref(x)
+ *   // unwrapped is guaranteed to be number now
+ * }
+ * ```
+ *
+ * @param ref - Ref or plain value to be converted into the plain value.
+ * @see {@link https://vuejs.org/api/reactivity-utilities.html#unref}
+ */
+export declare function unref<T>(ref: MaybeRef<T> | ComputedRef<T>): T;
+/**
+ * Normalizes values / refs / getters to values.
+ * This is similar to {@link unref}, except that it also normalizes getters.
+ * If the argument is a getter, it will be invoked and its return value will
+ * be returned.
+ *
+ * @example
+ * ```js
+ * toValue(1) // 1
+ * toValue(ref(1)) // 1
+ * toValue(() => 1) // 1
+ * ```
+ *
+ * @param source - A getter, an existing ref, or a non-function value.
+ * @see {@link https://vuejs.org/api/reactivity-utilities.html#tovalue}
+ */
+export declare function toValue<T>(source: MaybeRefOrGetter<T>): T;
+/**
+ * Returns a proxy for the given object that shallowly unwraps properties that
+ * are refs. If the object already is reactive, it's returned as-is. If not, a
+ * new reactive proxy is created.
+ *
+ * @param objectWithRefs - Either an already-reactive object or a simple object
+ * that contains refs.
+ */
+export declare function proxyRefs<T extends object>(objectWithRefs: T): ShallowUnwrapRef<T>;
+export type CustomRefFactory<T> = (track: () => void, trigger: () => void) => {
+    get: () => T;
+    set: (value: T) => void;
+};
+/**
+ * Creates a customized ref with explicit control over its dependency tracking
+ * and updates triggering.
+ *
+ * @param factory - The function that receives the `track` and `trigger` callbacks.
+ * @see {@link https://vuejs.org/api/reactivity-advanced.html#customref}
+ */
+export declare function customRef<T>(factory: CustomRefFactory<T>): Ref<T>;
+export type ToRefs<T = any> = {
+    [K in keyof T]: ToRef<T[K]>;
+};
+/**
+ * Converts a reactive object to a plain object where each property of the
+ * resulting object is a ref pointing to the corresponding property of the
+ * original object. Each individual ref is created using {@link toRef}.
+ *
+ * @param object - Reactive object to be made into an object of linked refs.
+ * @see {@link https://vuejs.org/api/reactivity-utilities.html#torefs}
+ */
+export declare function toRefs<T extends object>(object: T): ToRefs<T>;
+export type ToRef<T> = IfAny<T, Ref<T>, [T] extends [Ref] ? T : Ref<T>>;
+/**
+ * Used to normalize values / refs / getters into refs.
+ *
+ * @example
+ * ```js
+ * // returns existing refs as-is
+ * toRef(existingRef)
+ *
+ * // creates a ref that calls the getter on .value access
+ * toRef(() => props.foo)
+ *
+ * // creates normal refs from non-function values
+ * // equivalent to ref(1)
+ * toRef(1)
+ * ```
+ *
+ * Can also be used to create a ref for a property on a source reactive object.
+ * The created ref is synced with its source property: mutating the source
+ * property will update the ref, and vice-versa.
+ *
+ * @example
+ * ```js
+ * const state = reactive({
+ *   foo: 1,
+ *   bar: 2
+ * })
+ *
+ * const fooRef = toRef(state, 'foo')
+ *
+ * // mutating the ref updates the original
+ * fooRef.value++
+ * console.log(state.foo) // 2
+ *
+ * // mutating the original also updates the ref
+ * state.foo++
+ * console.log(fooRef.value) // 3
+ * ```
+ *
+ * @param source - A getter, an existing ref, a non-function value, or a
+ *                 reactive object to create a property ref from.
+ * @param [key] - (optional) Name of the property in the reactive object.
+ * @see {@link https://vuejs.org/api/reactivity-utilities.html#toref}
+ */
+export declare function toRef<T>(value: T): T extends () => infer R ? Readonly<Ref<R>> : T extends Ref ? T : Ref<UnwrapRef<T>>;
+export declare function toRef<T extends object, K extends keyof T>(object: T, key: K): ToRef<T[K]>;
+export declare function toRef<T extends object, K extends keyof T>(object: T, key: K, defaultValue: T[K]): ToRef<Exclude<T[K], undefined>>;
+/**
+ * This is a special exported interface for other packages to declare
+ * additional types that should bail out for ref unwrapping. For example
+ * \@vue/runtime-dom can declare it like so in its d.ts:
+ *
+ * ``` ts
+ * declare module '@vue/reactivity' {
+ *   export interface RefUnwrapBailTypes {
+ *     runtimeDOMBailTypes: Node | Window
+ *   }
+ * }
+ * ```
+ */
+export interface RefUnwrapBailTypes {
+}
+export type ShallowUnwrapRef<T> = {
+    [K in keyof T]: DistributeRef<T[K]>;
+};
+type DistributeRef<T> = T extends Ref<infer V, unknown> ? V : T;
+export type UnwrapRef<T> = T extends ShallowRef<infer V, unknown> ? V : T extends Ref<infer V, unknown> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
+type UnwrapRefSimple<T> = T extends Builtin | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
+    [RawSymbol]?: true;
+} ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? {
+    [K in keyof T]: UnwrapRefSimple<T[K]>;
+} : T extends object & {
+    [ShallowReactiveMarker]?: never;
+} ? {
+    [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]>;
+} : T;
+
+export declare const ITERATE_KEY: unique symbol;
+export declare const MAP_KEY_ITERATE_KEY: unique symbol;
+export declare const ARRAY_ITERATE_KEY: unique symbol;
+/**
+ * Tracks access to a reactive property.
+ *
+ * This will check which effect is running at the moment and record it as dep
+ * which records all effects that depend on the reactive property.
+ *
+ * @param target - Object holding the reactive property.
+ * @param type - Defines the type of access to the reactive property.
+ * @param key - Identifier of the reactive property to track.
+ */
+export declare function track(target: object, type: TrackOpTypes, key: unknown): void;
+/**
+ * Finds all deps associated with the target (or a specific property) and
+ * triggers the effects stored within.
+ *
+ * @param target - The reactive object.
+ * @param type - Defines the type of the operation that needs to trigger effects.
+ * @param key - Can be used to target a specific reactive property in the target object.
+ */
+export declare function trigger(target: object, type: TriggerOpTypes, key?: unknown, newValue?: unknown, oldValue?: unknown, oldTarget?: Map<unknown, unknown> | Set<unknown>): void;
+
+export declare class EffectScope {
+    detached: boolean;
+    private _isPaused;
+    readonly __v_skip = true;
+    constructor(detached?: boolean);
+    get active(): boolean;
+    pause(): void;
+    /**
+     * Resumes the effect scope, including all child scopes and effects.
+     */
+    resume(): void;
+    run<T>(fn: () => T): T | undefined;
+    prevScope: EffectScope | undefined;
+    stop(fromParent?: boolean): void;
+}
+/**
+ * Creates an effect scope object which can capture the reactive effects (i.e.
+ * computed and watchers) created within it so that these effects can be
+ * disposed together. For detailed use cases of this API, please consult its
+ * corresponding {@link https://github.com/vuejs/rfcs/blob/master/active-rfcs/0041-reactivity-effect-scope.md | RFC}.
+ *
+ * @param detached - Can be used to create a "detached" effect scope.
+ * @see {@link https://vuejs.org/api/reactivity-advanced.html#effectscope}
+ */
+export declare function effectScope(detached?: boolean): EffectScope;
+/**
+ * Returns the current active effect scope if there is one.
+ *
+ * @see {@link https://vuejs.org/api/reactivity-advanced.html#getcurrentscope}
+ */
+export declare function getCurrentScope(): EffectScope | undefined;
+/**
+ * Registers a dispose callback on the current active effect scope. The
+ * callback will be invoked when the associated effect scope is stopped.
+ *
+ * @param fn - The callback function to attach to the scope's cleanup.
+ * @see {@link https://vuejs.org/api/reactivity-advanced.html#onscopedispose}
+ */
+export declare function onScopeDispose(fn: () => void, failSilently?: boolean): void;
+
+/**
+ * Track array iteration and return:
+ * - if input is reactive: a cloned raw array with reactive values
+ * - if input is non-reactive or shallowReactive: the original raw array
+ */
+export declare function reactiveReadArray<T>(array: T[]): T[];
+/**
+ * Track array iteration and return raw array
+ */
+export declare function shallowReadArray<T>(arr: T[]): T[];
+
+export declare enum WatchErrorCodes {
+    WATCH_GETTER = 2,
+    WATCH_CALLBACK = 3,
+    WATCH_CLEANUP = 4
+}
+export type WatchEffect = (onCleanup: OnCleanup) => void;
+export type WatchSource<T = any> = Ref<T, any> | ComputedRef<T> | (() => T);
+export type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: OnCleanup) => any;
+export type OnCleanup = (cleanupFn: () => void) => void;
+export interface WatchOptions<Immediate = boolean> extends DebuggerOptions {
+    immediate?: Immediate;
+    deep?: boolean | number;
+    once?: boolean;
+    scheduler?: WatchScheduler;
+    onWarn?: (msg: string, ...args: any[]) => void;
+}
+export type WatchStopHandle = () => void;
+export interface WatchHandle extends WatchStopHandle {
+    pause: () => void;
+    resume: () => void;
+    stop: () => void;
+}
+export type WatchScheduler = (job: () => void, isFirstRun: boolean) => void;
+/**
+ * Returns the current active effect if there is one.
+ */
+export declare function getCurrentWatcher(): ReactiveEffect<any> | undefined;
+/**
+ * Registers a cleanup callback on the current active effect. This
+ * registered cleanup callback will be invoked right before the
+ * associated effect re-runs.
+ *
+ * @param cleanupFn - The callback function to attach to the effect's cleanup.
+ * @param failSilently - if `true`, will not throw warning when called without
+ * an active effect.
+ * @param owner - The effect that this cleanup function should be attached to.
+ * By default, the current active effect.
+ */
+export declare function onWatcherCleanup(cleanupFn: () => void, failSilently?: boolean, owner?: ReactiveEffect | undefined): void;
+export declare function watch(source: WatchSource | WatchSource[] | WatchEffect | object, cb?: WatchCallback | null, options?: WatchOptions): WatchHandle;
+export declare function traverse(value: unknown, depth?: number, seen?: Map<unknown, number>): unknown;
+
+

node_modules/@vue/reactivity/index.js

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

node_modules/@vue/reactivity/package.json

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

node_modules/@vue/runtime-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/runtime-core/README.md

@@ -0,0 +1,28 @@
+# @vue/runtime-core
+
+> This package is published only for typing and building custom renderers. It is NOT meant to be used in applications.
+
+For full exposed APIs, see `src/index.ts`.
+
+## Building a Custom Renderer
+
+```ts
+import { createRenderer } from '@vue/runtime-core'
+
+const { render, createApp } = createRenderer({
+  patchProp,
+  insert,
+  remove,
+  createElement,
+  // ...
+})
+
+// `render` is the low-level API
+// `createApp` returns an app instance with configurable context shared
+// by the entire app tree.
+export { render, createApp }
+
+export * from '@vue/runtime-core'
+```
+
+See `@vue/runtime-dom` for how a DOM-targeting renderer is implemented.