Initial commit - full huishou project

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/node_modules/@vue/shared/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/babel-plugin-jsx/node_modules/@vue/shared/README.md

@@ -0,0 +1,3 @@
+# @vue/shared
+
+Internal utility functions and constants shared across `@vue` packages.

node_modules/@vue/babel-plugin-jsx/node_modules/@vue/shared/dist/shared.cjs.js

@@ -0,0 +1,612 @@
+/**
+* @vue/shared v3.5.34
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// @__NO_SIDE_EFFECTS__
+function makeMap(str) {
+  const map = /* @__PURE__ */ Object.create(null);
+  for (const key of str.split(",")) map[key] = 1;
+  return (val) => val in map;
+}
+
+const EMPTY_OBJ = Object.freeze({}) ;
+const EMPTY_ARR = Object.freeze([]) ;
+const NOOP = () => {
+};
+const NO = () => false;
+const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
+(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
+const isModelListener = (key) => key.startsWith("onUpdate:");
+const extend = Object.assign;
+const remove = (arr, el) => {
+  const i = arr.indexOf(el);
+  if (i > -1) {
+    arr.splice(i, 1);
+  }
+};
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key) => hasOwnProperty.call(val, key);
+const isArray = Array.isArray;
+const isMap = (val) => toTypeString(val) === "[object Map]";
+const isSet = (val) => toTypeString(val) === "[object Set]";
+const isDate = (val) => toTypeString(val) === "[object Date]";
+const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
+const isFunction = (val) => typeof val === "function";
+const isString = (val) => typeof val === "string";
+const isSymbol = (val) => typeof val === "symbol";
+const isObject = (val) => val !== null && typeof val === "object";
+const isPromise = (val) => {
+  return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const toRawType = (value) => {
+  return toTypeString(value).slice(8, -1);
+};
+const isPlainObject = (val) => toTypeString(val) === "[object Object]";
+const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+const isReservedProp = /* @__PURE__ */ makeMap(
+  // the leading comma is intentional so empty string "" is also included
+  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
+);
+const isBuiltInDirective = /* @__PURE__ */ makeMap(
+  "bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
+);
+const cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return ((str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  });
+};
+const camelizeRE = /-\w/g;
+const camelize = cacheStringFunction(
+  (str) => {
+    return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
+  }
+);
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction(
+  (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
+);
+const capitalize = cacheStringFunction((str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+});
+const toHandlerKey = cacheStringFunction(
+  (str) => {
+    const s = str ? `on${capitalize(str)}` : ``;
+    return s;
+  }
+);
+const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+const invokeArrayFns = (fns, ...arg) => {
+  for (let i = 0; i < fns.length; i++) {
+    fns[i](...arg);
+  }
+};
+const def = (obj, key, value, writable = false) => {
+  Object.defineProperty(obj, key, {
+    configurable: true,
+    enumerable: false,
+    writable,
+    value
+  });
+};
+const looseToNumber = (val) => {
+  const n = parseFloat(val);
+  return isNaN(n) ? val : n;
+};
+const toNumber = (val) => {
+  const n = isString(val) ? Number(val) : NaN;
+  return isNaN(n) ? val : n;
+};
+let _globalThis;
+const getGlobalThis = () => {
+  return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+};
+const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
+function genPropsAccessExp(name) {
+  return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;
+}
+function genCacheKey(source, options) {
+  return source + JSON.stringify(
+    options,
+    (_, val) => typeof val === "function" ? val.toString() : val
+  );
+}
+
+const PatchFlags = {
+  "TEXT": 1,
+  "1": "TEXT",
+  "CLASS": 2,
+  "2": "CLASS",
+  "STYLE": 4,
+  "4": "STYLE",
+  "PROPS": 8,
+  "8": "PROPS",
+  "FULL_PROPS": 16,
+  "16": "FULL_PROPS",
+  "NEED_HYDRATION": 32,
+  "32": "NEED_HYDRATION",
+  "STABLE_FRAGMENT": 64,
+  "64": "STABLE_FRAGMENT",
+  "KEYED_FRAGMENT": 128,
+  "128": "KEYED_FRAGMENT",
+  "UNKEYED_FRAGMENT": 256,
+  "256": "UNKEYED_FRAGMENT",
+  "NEED_PATCH": 512,
+  "512": "NEED_PATCH",
+  "DYNAMIC_SLOTS": 1024,
+  "1024": "DYNAMIC_SLOTS",
+  "DEV_ROOT_FRAGMENT": 2048,
+  "2048": "DEV_ROOT_FRAGMENT",
+  "CACHED": -1,
+  "-1": "CACHED",
+  "BAIL": -2,
+  "-2": "BAIL"
+};
+const PatchFlagNames = {
+  [1]: `TEXT`,
+  [2]: `CLASS`,
+  [4]: `STYLE`,
+  [8]: `PROPS`,
+  [16]: `FULL_PROPS`,
+  [32]: `NEED_HYDRATION`,
+  [64]: `STABLE_FRAGMENT`,
+  [128]: `KEYED_FRAGMENT`,
+  [256]: `UNKEYED_FRAGMENT`,
+  [512]: `NEED_PATCH`,
+  [1024]: `DYNAMIC_SLOTS`,
+  [2048]: `DEV_ROOT_FRAGMENT`,
+  [-1]: `CACHED`,
+  [-2]: `BAIL`
+};
+
+const ShapeFlags = {
+  "ELEMENT": 1,
+  "1": "ELEMENT",
+  "FUNCTIONAL_COMPONENT": 2,
+  "2": "FUNCTIONAL_COMPONENT",
+  "STATEFUL_COMPONENT": 4,
+  "4": "STATEFUL_COMPONENT",
+  "TEXT_CHILDREN": 8,
+  "8": "TEXT_CHILDREN",
+  "ARRAY_CHILDREN": 16,
+  "16": "ARRAY_CHILDREN",
+  "SLOTS_CHILDREN": 32,
+  "32": "SLOTS_CHILDREN",
+  "TELEPORT": 64,
+  "64": "TELEPORT",
+  "SUSPENSE": 128,
+  "128": "SUSPENSE",
+  "COMPONENT_SHOULD_KEEP_ALIVE": 256,
+  "256": "COMPONENT_SHOULD_KEEP_ALIVE",
+  "COMPONENT_KEPT_ALIVE": 512,
+  "512": "COMPONENT_KEPT_ALIVE",
+  "COMPONENT": 6,
+  "6": "COMPONENT"
+};
+
+const SlotFlags = {
+  "STABLE": 1,
+  "1": "STABLE",
+  "DYNAMIC": 2,
+  "2": "DYNAMIC",
+  "FORWARDED": 3,
+  "3": "FORWARDED"
+};
+const slotFlagsText = {
+  [1]: "STABLE",
+  [2]: "DYNAMIC",
+  [3]: "FORWARDED"
+};
+
+const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol";
+const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
+const isGloballyWhitelisted = isGloballyAllowed;
+
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+  start = Math.max(0, Math.min(start, source.length));
+  end = Math.max(0, Math.min(end, source.length));
+  if (start > end) return "";
+  let lines = source.split(/(\r?\n)/);
+  const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
+  lines = lines.filter((_, idx) => idx % 2 === 0);
+  let count = 0;
+  const res = [];
+  for (let i = 0; i < lines.length; i++) {
+    count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
+    if (count >= start) {
+      for (let j = i - range; j <= i + range || end > count; j++) {
+        if (j < 0 || j >= lines.length) continue;
+        const line = j + 1;
+        res.push(
+          `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`
+        );
+        const lineLength = lines[j].length;
+        const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
+        if (j === i) {
+          const pad = start - (count - (lineLength + newLineSeqLength));
+          const length = Math.max(
+            1,
+            end > count ? lineLength - pad : end - start
+          );
+          res.push(`   |  ` + " ".repeat(pad) + "^".repeat(length));
+        } else if (j > i) {
+          if (end > count) {
+            const length = Math.max(Math.min(end - count, lineLength), 1);
+            res.push(`   |  ` + "^".repeat(length));
+          }
+          count += lineLength + newLineSeqLength;
+        }
+      }
+      break;
+    }
+  }
+  return res.join("\n");
+}
+
+function normalizeStyle(value) {
+  if (isArray(value)) {
+    const res = {};
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
+      if (normalized) {
+        for (const key in normalized) {
+          res[key] = normalized[key];
+        }
+      }
+    }
+    return res;
+  } else if (isString(value) || isObject(value)) {
+    return value;
+  }
+}
+const listDelimiterRE = /;(?![^(]*\))/g;
+const propertyDelimiterRE = /:([^]+)/;
+const styleCommentRE = /\/\*[^]*?\*\//g;
+function parseStringStyle(cssText) {
+  const ret = {};
+  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
+    if (item) {
+      const tmp = item.split(propertyDelimiterRE);
+      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+    }
+  });
+  return ret;
+}
+function stringifyStyle(styles) {
+  if (!styles) return "";
+  if (isString(styles)) return styles;
+  let ret = "";
+  for (const key in styles) {
+    const value = styles[key];
+    if (isString(value) || typeof value === "number") {
+      const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
+      ret += `${normalizedKey}:${value};`;
+    }
+  }
+  return ret;
+}
+function normalizeClass(value) {
+  let res = "";
+  if (isString(value)) {
+    res = value;
+  } else if (isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const normalized = normalizeClass(value[i]);
+      if (normalized) {
+        res += normalized + " ";
+      }
+    }
+  } else if (isObject(value)) {
+    for (const name in value) {
+      if (value[name]) {
+        res += name + " ";
+      }
+    }
+  }
+  return res.trim();
+}
+function normalizeProps(props) {
+  if (!props) return null;
+  let { class: klass, style } = props;
+  if (klass && !isString(klass)) {
+    props.class = normalizeClass(klass);
+  }
+  if (style) {
+    props.style = normalizeStyle(style);
+  }
+  return props;
+}
+
+const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
+const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
+const MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics";
+const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
+const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
+const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
+const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
+const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
+
+const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
+const isBooleanAttr = /* @__PURE__ */ makeMap(
+  specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
+);
+function includeBooleanAttr(value) {
+  return !!value || value === "";
+}
+const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
+const attrValidationCache = {};
+function isSSRSafeAttrName(name) {
+  if (attrValidationCache.hasOwnProperty(name)) {
+    return attrValidationCache[name];
+  }
+  const isUnsafe = unsafeAttrCharRE.test(name);
+  if (isUnsafe) {
+    console.error(`unsafe attribute name: ${name}`);
+  }
+  return attrValidationCache[name] = !isUnsafe;
+}
+const propsToAttrMap = {
+  acceptCharset: "accept-charset",
+  className: "class",
+  htmlFor: "for",
+  httpEquiv: "http-equiv"
+};
+const isKnownHtmlAttr = /* @__PURE__ */ makeMap(
+  `accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`
+);
+const isKnownSvgAttr = /* @__PURE__ */ makeMap(
+  `xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`
+);
+const isKnownMathMLAttr = /* @__PURE__ */ makeMap(
+  `accent,accentunder,actiontype,align,alignmentscope,altimg,altimg-height,altimg-valign,altimg-width,alttext,bevelled,close,columnsalign,columnlines,columnspan,denomalign,depth,dir,display,displaystyle,encoding,equalcolumns,equalrows,fence,fontstyle,fontweight,form,frame,framespacing,groupalign,height,href,id,indentalign,indentalignfirst,indentalignlast,indentshift,indentshiftfirst,indentshiftlast,indextype,justify,largetop,largeop,lquote,lspace,mathbackground,mathcolor,mathsize,mathvariant,maxsize,minlabelspacing,mode,other,overflow,position,rowalign,rowlines,rowspan,rquote,rspace,scriptlevel,scriptminsize,scriptsizemultiplier,selection,separator,separators,shift,side,src,stackalign,stretchy,subscriptshift,superscriptshift,symmetric,voffset,width,widths,xlink:href,xlink:show,xlink:type,xmlns`
+);
+function isRenderableAttrValue(value) {
+  if (value == null) {
+    return false;
+  }
+  const type = typeof value;
+  return type === "string" || type === "number" || type === "boolean";
+}
+
+const escapeRE = /["'&<>]/;
+function escapeHtml(string) {
+  const str = "" + string;
+  const match = escapeRE.exec(str);
+  if (!match) {
+    return str;
+  }
+  let html = "";
+  let escaped;
+  let index;
+  let lastIndex = 0;
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        escaped = "&quot;";
+        break;
+      case 38:
+        escaped = "&amp;";
+        break;
+      case 39:
+        escaped = "&#39;";
+        break;
+      case 60:
+        escaped = "&lt;";
+        break;
+      case 62:
+        escaped = "&gt;";
+        break;
+      default:
+        continue;
+    }
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+    lastIndex = index + 1;
+    html += escaped;
+  }
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+}
+const commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;
+function escapeHtmlComment(src) {
+  return src.replace(commentStripRE, "");
+}
+const cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
+function getEscapedCssVarName(key, doubleEscape) {
+  return key.replace(
+    cssVarNameEscapeSymbolsRE,
+    (s) => doubleEscape ? s === '"' ? '\\\\\\"' : `\\\\${s}` : `\\${s}`
+  );
+}
+
+function looseCompareArrays(a, b) {
+  if (a.length !== b.length) return false;
+  let equal = true;
+  for (let i = 0; equal && i < a.length; i++) {
+    equal = looseEqual(a[i], b[i]);
+  }
+  return equal;
+}
+function looseEqual(a, b) {
+  if (a === b) return true;
+  let aValidType = isDate(a);
+  let bValidType = isDate(b);
+  if (aValidType || bValidType) {
+    return aValidType && bValidType ? a.getTime() === b.getTime() : false;
+  }
+  aValidType = isSymbol(a);
+  bValidType = isSymbol(b);
+  if (aValidType || bValidType) {
+    return a === b;
+  }
+  aValidType = isArray(a);
+  bValidType = isArray(b);
+  if (aValidType || bValidType) {
+    return aValidType && bValidType ? looseCompareArrays(a, b) : false;
+  }
+  aValidType = isObject(a);
+  bValidType = isObject(b);
+  if (aValidType || bValidType) {
+    if (!aValidType || !bValidType) {
+      return false;
+    }
+    const aKeysCount = Object.keys(a).length;
+    const bKeysCount = Object.keys(b).length;
+    if (aKeysCount !== bKeysCount) {
+      return false;
+    }
+    for (const key in a) {
+      const aHasKey = a.hasOwnProperty(key);
+      const bHasKey = b.hasOwnProperty(key);
+      if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+  }
+  return String(a) === String(b);
+}
+function looseIndexOf(arr, val) {
+  return arr.findIndex((item) => looseEqual(item, val));
+}
+
+const isRef = (val) => {
+  return !!(val && val["__v_isRef"] === true);
+};
+const toDisplayString = (val) => {
+  return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
+};
+const replacer = (_key, val) => {
+  if (isRef(val)) {
+    return replacer(_key, val.value);
+  } else if (isMap(val)) {
+    return {
+      [`Map(${val.size})`]: [...val.entries()].reduce(
+        (entries, [key, val2], i) => {
+          entries[stringifySymbol(key, i) + " =>"] = val2;
+          return entries;
+        },
+        {}
+      )
+    };
+  } else if (isSet(val)) {
+    return {
+      [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
+    };
+  } else if (isSymbol(val)) {
+    return stringifySymbol(val);
+  } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
+    return String(val);
+  }
+  return val;
+};
+const stringifySymbol = (v, i = "") => {
+  var _a;
+  return (
+    // Symbol.description in es2019+ so we need to cast here to pass
+    // the lib: es2016 check
+    isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v
+  );
+};
+
+function normalizeCssVarValue(value) {
+  if (value == null) {
+    return "initial";
+  }
+  if (typeof value === "string") {
+    return value === "" ? " " : value;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    {
+      console.warn(
+        "[Vue warn] Invalid value used for CSS binding. Expected a string or a finite number but received:",
+        value
+      );
+    }
+  }
+  return String(value);
+}
+
+exports.EMPTY_ARR = EMPTY_ARR;
+exports.EMPTY_OBJ = EMPTY_OBJ;
+exports.NO = NO;
+exports.NOOP = NOOP;
+exports.PatchFlagNames = PatchFlagNames;
+exports.PatchFlags = PatchFlags;
+exports.ShapeFlags = ShapeFlags;
+exports.SlotFlags = SlotFlags;
+exports.camelize = camelize;
+exports.capitalize = capitalize;
+exports.cssVarNameEscapeSymbolsRE = cssVarNameEscapeSymbolsRE;
+exports.def = def;
+exports.escapeHtml = escapeHtml;
+exports.escapeHtmlComment = escapeHtmlComment;
+exports.extend = extend;
+exports.genCacheKey = genCacheKey;
+exports.genPropsAccessExp = genPropsAccessExp;
+exports.generateCodeFrame = generateCodeFrame;
+exports.getEscapedCssVarName = getEscapedCssVarName;
+exports.getGlobalThis = getGlobalThis;
+exports.hasChanged = hasChanged;
+exports.hasOwn = hasOwn;
+exports.hyphenate = hyphenate;
+exports.includeBooleanAttr = includeBooleanAttr;
+exports.invokeArrayFns = invokeArrayFns;
+exports.isArray = isArray;
+exports.isBooleanAttr = isBooleanAttr;
+exports.isBuiltInDirective = isBuiltInDirective;
+exports.isDate = isDate;
+exports.isFunction = isFunction;
+exports.isGloballyAllowed = isGloballyAllowed;
+exports.isGloballyWhitelisted = isGloballyWhitelisted;
+exports.isHTMLTag = isHTMLTag;
+exports.isIntegerKey = isIntegerKey;
+exports.isKnownHtmlAttr = isKnownHtmlAttr;
+exports.isKnownMathMLAttr = isKnownMathMLAttr;
+exports.isKnownSvgAttr = isKnownSvgAttr;
+exports.isMap = isMap;
+exports.isMathMLTag = isMathMLTag;
+exports.isModelListener = isModelListener;
+exports.isObject = isObject;
+exports.isOn = isOn;
+exports.isPlainObject = isPlainObject;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isRenderableAttrValue = isRenderableAttrValue;
+exports.isReservedProp = isReservedProp;
+exports.isSSRSafeAttrName = isSSRSafeAttrName;
+exports.isSVGTag = isSVGTag;
+exports.isSet = isSet;
+exports.isSpecialBooleanAttr = isSpecialBooleanAttr;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isVoidTag = isVoidTag;
+exports.looseEqual = looseEqual;
+exports.looseIndexOf = looseIndexOf;
+exports.looseToNumber = looseToNumber;
+exports.makeMap = makeMap;
+exports.normalizeClass = normalizeClass;
+exports.normalizeCssVarValue = normalizeCssVarValue;
+exports.normalizeProps = normalizeProps;
+exports.normalizeStyle = normalizeStyle;
+exports.objectToString = objectToString;
+exports.parseStringStyle = parseStringStyle;
+exports.propsToAttrMap = propsToAttrMap;
+exports.remove = remove;
+exports.slotFlagsText = slotFlagsText;
+exports.stringifyStyle = stringifyStyle;
+exports.toDisplayString = toDisplayString;
+exports.toHandlerKey = toHandlerKey;
+exports.toNumber = toNumber;
+exports.toRawType = toRawType;
+exports.toTypeString = toTypeString;

node_modules/@vue/babel-plugin-jsx/node_modules/@vue/shared/dist/shared.cjs.prod.js

@@ -0,0 +1,604 @@
+/**
+* @vue/shared v3.5.34
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// @__NO_SIDE_EFFECTS__
+function makeMap(str) {
+  const map = /* @__PURE__ */ Object.create(null);
+  for (const key of str.split(",")) map[key] = 1;
+  return (val) => val in map;
+}
+
+const EMPTY_OBJ = {};
+const EMPTY_ARR = [];
+const NOOP = () => {
+};
+const NO = () => false;
+const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
+(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
+const isModelListener = (key) => key.startsWith("onUpdate:");
+const extend = Object.assign;
+const remove = (arr, el) => {
+  const i = arr.indexOf(el);
+  if (i > -1) {
+    arr.splice(i, 1);
+  }
+};
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key) => hasOwnProperty.call(val, key);
+const isArray = Array.isArray;
+const isMap = (val) => toTypeString(val) === "[object Map]";
+const isSet = (val) => toTypeString(val) === "[object Set]";
+const isDate = (val) => toTypeString(val) === "[object Date]";
+const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
+const isFunction = (val) => typeof val === "function";
+const isString = (val) => typeof val === "string";
+const isSymbol = (val) => typeof val === "symbol";
+const isObject = (val) => val !== null && typeof val === "object";
+const isPromise = (val) => {
+  return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const toRawType = (value) => {
+  return toTypeString(value).slice(8, -1);
+};
+const isPlainObject = (val) => toTypeString(val) === "[object Object]";
+const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+const isReservedProp = /* @__PURE__ */ makeMap(
+  // the leading comma is intentional so empty string "" is also included
+  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
+);
+const isBuiltInDirective = /* @__PURE__ */ makeMap(
+  "bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
+);
+const cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return ((str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  });
+};
+const camelizeRE = /-\w/g;
+const camelize = cacheStringFunction(
+  (str) => {
+    return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
+  }
+);
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction(
+  (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
+);
+const capitalize = cacheStringFunction((str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+});
+const toHandlerKey = cacheStringFunction(
+  (str) => {
+    const s = str ? `on${capitalize(str)}` : ``;
+    return s;
+  }
+);
+const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+const invokeArrayFns = (fns, ...arg) => {
+  for (let i = 0; i < fns.length; i++) {
+    fns[i](...arg);
+  }
+};
+const def = (obj, key, value, writable = false) => {
+  Object.defineProperty(obj, key, {
+    configurable: true,
+    enumerable: false,
+    writable,
+    value
+  });
+};
+const looseToNumber = (val) => {
+  const n = parseFloat(val);
+  return isNaN(n) ? val : n;
+};
+const toNumber = (val) => {
+  const n = isString(val) ? Number(val) : NaN;
+  return isNaN(n) ? val : n;
+};
+let _globalThis;
+const getGlobalThis = () => {
+  return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+};
+const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
+function genPropsAccessExp(name) {
+  return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;
+}
+function genCacheKey(source, options) {
+  return source + JSON.stringify(
+    options,
+    (_, val) => typeof val === "function" ? val.toString() : val
+  );
+}
+
+const PatchFlags = {
+  "TEXT": 1,
+  "1": "TEXT",
+  "CLASS": 2,
+  "2": "CLASS",
+  "STYLE": 4,
+  "4": "STYLE",
+  "PROPS": 8,
+  "8": "PROPS",
+  "FULL_PROPS": 16,
+  "16": "FULL_PROPS",
+  "NEED_HYDRATION": 32,
+  "32": "NEED_HYDRATION",
+  "STABLE_FRAGMENT": 64,
+  "64": "STABLE_FRAGMENT",
+  "KEYED_FRAGMENT": 128,
+  "128": "KEYED_FRAGMENT",
+  "UNKEYED_FRAGMENT": 256,
+  "256": "UNKEYED_FRAGMENT",
+  "NEED_PATCH": 512,
+  "512": "NEED_PATCH",
+  "DYNAMIC_SLOTS": 1024,
+  "1024": "DYNAMIC_SLOTS",
+  "DEV_ROOT_FRAGMENT": 2048,
+  "2048": "DEV_ROOT_FRAGMENT",
+  "CACHED": -1,
+  "-1": "CACHED",
+  "BAIL": -2,
+  "-2": "BAIL"
+};
+const PatchFlagNames = {
+  [1]: `TEXT`,
+  [2]: `CLASS`,
+  [4]: `STYLE`,
+  [8]: `PROPS`,
+  [16]: `FULL_PROPS`,
+  [32]: `NEED_HYDRATION`,
+  [64]: `STABLE_FRAGMENT`,
+  [128]: `KEYED_FRAGMENT`,
+  [256]: `UNKEYED_FRAGMENT`,
+  [512]: `NEED_PATCH`,
+  [1024]: `DYNAMIC_SLOTS`,
+  [2048]: `DEV_ROOT_FRAGMENT`,
+  [-1]: `CACHED`,
+  [-2]: `BAIL`
+};
+
+const ShapeFlags = {
+  "ELEMENT": 1,
+  "1": "ELEMENT",
+  "FUNCTIONAL_COMPONENT": 2,
+  "2": "FUNCTIONAL_COMPONENT",
+  "STATEFUL_COMPONENT": 4,
+  "4": "STATEFUL_COMPONENT",
+  "TEXT_CHILDREN": 8,
+  "8": "TEXT_CHILDREN",
+  "ARRAY_CHILDREN": 16,
+  "16": "ARRAY_CHILDREN",
+  "SLOTS_CHILDREN": 32,
+  "32": "SLOTS_CHILDREN",
+  "TELEPORT": 64,
+  "64": "TELEPORT",
+  "SUSPENSE": 128,
+  "128": "SUSPENSE",
+  "COMPONENT_SHOULD_KEEP_ALIVE": 256,
+  "256": "COMPONENT_SHOULD_KEEP_ALIVE",
+  "COMPONENT_KEPT_ALIVE": 512,
+  "512": "COMPONENT_KEPT_ALIVE",
+  "COMPONENT": 6,
+  "6": "COMPONENT"
+};
+
+const SlotFlags = {
+  "STABLE": 1,
+  "1": "STABLE",
+  "DYNAMIC": 2,
+  "2": "DYNAMIC",
+  "FORWARDED": 3,
+  "3": "FORWARDED"
+};
+const slotFlagsText = {
+  [1]: "STABLE",
+  [2]: "DYNAMIC",
+  [3]: "FORWARDED"
+};
+
+const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol";
+const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
+const isGloballyWhitelisted = isGloballyAllowed;
+
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+  start = Math.max(0, Math.min(start, source.length));
+  end = Math.max(0, Math.min(end, source.length));
+  if (start > end) return "";
+  let lines = source.split(/(\r?\n)/);
+  const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
+  lines = lines.filter((_, idx) => idx % 2 === 0);
+  let count = 0;
+  const res = [];
+  for (let i = 0; i < lines.length; i++) {
+    count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
+    if (count >= start) {
+      for (let j = i - range; j <= i + range || end > count; j++) {
+        if (j < 0 || j >= lines.length) continue;
+        const line = j + 1;
+        res.push(
+          `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`
+        );
+        const lineLength = lines[j].length;
+        const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
+        if (j === i) {
+          const pad = start - (count - (lineLength + newLineSeqLength));
+          const length = Math.max(
+            1,
+            end > count ? lineLength - pad : end - start
+          );
+          res.push(`   |  ` + " ".repeat(pad) + "^".repeat(length));
+        } else if (j > i) {
+          if (end > count) {
+            const length = Math.max(Math.min(end - count, lineLength), 1);
+            res.push(`   |  ` + "^".repeat(length));
+          }
+          count += lineLength + newLineSeqLength;
+        }
+      }
+      break;
+    }
+  }
+  return res.join("\n");
+}
+
+function normalizeStyle(value) {
+  if (isArray(value)) {
+    const res = {};
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
+      if (normalized) {
+        for (const key in normalized) {
+          res[key] = normalized[key];
+        }
+      }
+    }
+    return res;
+  } else if (isString(value) || isObject(value)) {
+    return value;
+  }
+}
+const listDelimiterRE = /;(?![^(]*\))/g;
+const propertyDelimiterRE = /:([^]+)/;
+const styleCommentRE = /\/\*[^]*?\*\//g;
+function parseStringStyle(cssText) {
+  const ret = {};
+  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
+    if (item) {
+      const tmp = item.split(propertyDelimiterRE);
+      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+    }
+  });
+  return ret;
+}
+function stringifyStyle(styles) {
+  if (!styles) return "";
+  if (isString(styles)) return styles;
+  let ret = "";
+  for (const key in styles) {
+    const value = styles[key];
+    if (isString(value) || typeof value === "number") {
+      const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
+      ret += `${normalizedKey}:${value};`;
+    }
+  }
+  return ret;
+}
+function normalizeClass(value) {
+  let res = "";
+  if (isString(value)) {
+    res = value;
+  } else if (isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const normalized = normalizeClass(value[i]);
+      if (normalized) {
+        res += normalized + " ";
+      }
+    }
+  } else if (isObject(value)) {
+    for (const name in value) {
+      if (value[name]) {
+        res += name + " ";
+      }
+    }
+  }
+  return res.trim();
+}
+function normalizeProps(props) {
+  if (!props) return null;
+  let { class: klass, style } = props;
+  if (klass && !isString(klass)) {
+    props.class = normalizeClass(klass);
+  }
+  if (style) {
+    props.style = normalizeStyle(style);
+  }
+  return props;
+}
+
+const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
+const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
+const MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics";
+const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
+const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
+const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
+const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
+const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
+
+const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
+const isBooleanAttr = /* @__PURE__ */ makeMap(
+  specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
+);
+function includeBooleanAttr(value) {
+  return !!value || value === "";
+}
+const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
+const attrValidationCache = {};
+function isSSRSafeAttrName(name) {
+  if (attrValidationCache.hasOwnProperty(name)) {
+    return attrValidationCache[name];
+  }
+  const isUnsafe = unsafeAttrCharRE.test(name);
+  if (isUnsafe) {
+    console.error(`unsafe attribute name: ${name}`);
+  }
+  return attrValidationCache[name] = !isUnsafe;
+}
+const propsToAttrMap = {
+  acceptCharset: "accept-charset",
+  className: "class",
+  htmlFor: "for",
+  httpEquiv: "http-equiv"
+};
+const isKnownHtmlAttr = /* @__PURE__ */ makeMap(
+  `accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`
+);
+const isKnownSvgAttr = /* @__PURE__ */ makeMap(
+  `xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`
+);
+const isKnownMathMLAttr = /* @__PURE__ */ makeMap(
+  `accent,accentunder,actiontype,align,alignmentscope,altimg,altimg-height,altimg-valign,altimg-width,alttext,bevelled,close,columnsalign,columnlines,columnspan,denomalign,depth,dir,display,displaystyle,encoding,equalcolumns,equalrows,fence,fontstyle,fontweight,form,frame,framespacing,groupalign,height,href,id,indentalign,indentalignfirst,indentalignlast,indentshift,indentshiftfirst,indentshiftlast,indextype,justify,largetop,largeop,lquote,lspace,mathbackground,mathcolor,mathsize,mathvariant,maxsize,minlabelspacing,mode,other,overflow,position,rowalign,rowlines,rowspan,rquote,rspace,scriptlevel,scriptminsize,scriptsizemultiplier,selection,separator,separators,shift,side,src,stackalign,stretchy,subscriptshift,superscriptshift,symmetric,voffset,width,widths,xlink:href,xlink:show,xlink:type,xmlns`
+);
+function isRenderableAttrValue(value) {
+  if (value == null) {
+    return false;
+  }
+  const type = typeof value;
+  return type === "string" || type === "number" || type === "boolean";
+}
+
+const escapeRE = /["'&<>]/;
+function escapeHtml(string) {
+  const str = "" + string;
+  const match = escapeRE.exec(str);
+  if (!match) {
+    return str;
+  }
+  let html = "";
+  let escaped;
+  let index;
+  let lastIndex = 0;
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        escaped = "&quot;";
+        break;
+      case 38:
+        escaped = "&amp;";
+        break;
+      case 39:
+        escaped = "&#39;";
+        break;
+      case 60:
+        escaped = "&lt;";
+        break;
+      case 62:
+        escaped = "&gt;";
+        break;
+      default:
+        continue;
+    }
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+    lastIndex = index + 1;
+    html += escaped;
+  }
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+}
+const commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;
+function escapeHtmlComment(src) {
+  return src.replace(commentStripRE, "");
+}
+const cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
+function getEscapedCssVarName(key, doubleEscape) {
+  return key.replace(
+    cssVarNameEscapeSymbolsRE,
+    (s) => doubleEscape ? s === '"' ? '\\\\\\"' : `\\\\${s}` : `\\${s}`
+  );
+}
+
+function looseCompareArrays(a, b) {
+  if (a.length !== b.length) return false;
+  let equal = true;
+  for (let i = 0; equal && i < a.length; i++) {
+    equal = looseEqual(a[i], b[i]);
+  }
+  return equal;
+}
+function looseEqual(a, b) {
+  if (a === b) return true;
+  let aValidType = isDate(a);
+  let bValidType = isDate(b);
+  if (aValidType || bValidType) {
+    return aValidType && bValidType ? a.getTime() === b.getTime() : false;
+  }
+  aValidType = isSymbol(a);
+  bValidType = isSymbol(b);
+  if (aValidType || bValidType) {
+    return a === b;
+  }
+  aValidType = isArray(a);
+  bValidType = isArray(b);
+  if (aValidType || bValidType) {
+    return aValidType && bValidType ? looseCompareArrays(a, b) : false;
+  }
+  aValidType = isObject(a);
+  bValidType = isObject(b);
+  if (aValidType || bValidType) {
+    if (!aValidType || !bValidType) {
+      return false;
+    }
+    const aKeysCount = Object.keys(a).length;
+    const bKeysCount = Object.keys(b).length;
+    if (aKeysCount !== bKeysCount) {
+      return false;
+    }
+    for (const key in a) {
+      const aHasKey = a.hasOwnProperty(key);
+      const bHasKey = b.hasOwnProperty(key);
+      if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+  }
+  return String(a) === String(b);
+}
+function looseIndexOf(arr, val) {
+  return arr.findIndex((item) => looseEqual(item, val));
+}
+
+const isRef = (val) => {
+  return !!(val && val["__v_isRef"] === true);
+};
+const toDisplayString = (val) => {
+  return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
+};
+const replacer = (_key, val) => {
+  if (isRef(val)) {
+    return replacer(_key, val.value);
+  } else if (isMap(val)) {
+    return {
+      [`Map(${val.size})`]: [...val.entries()].reduce(
+        (entries, [key, val2], i) => {
+          entries[stringifySymbol(key, i) + " =>"] = val2;
+          return entries;
+        },
+        {}
+      )
+    };
+  } else if (isSet(val)) {
+    return {
+      [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
+    };
+  } else if (isSymbol(val)) {
+    return stringifySymbol(val);
+  } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
+    return String(val);
+  }
+  return val;
+};
+const stringifySymbol = (v, i = "") => {
+  var _a;
+  return (
+    // Symbol.description in es2019+ so we need to cast here to pass
+    // the lib: es2016 check
+    isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v
+  );
+};
+
+function normalizeCssVarValue(value) {
+  if (value == null) {
+    return "initial";
+  }
+  if (typeof value === "string") {
+    return value === "" ? " " : value;
+  }
+  return String(value);
+}
+
+exports.EMPTY_ARR = EMPTY_ARR;
+exports.EMPTY_OBJ = EMPTY_OBJ;
+exports.NO = NO;
+exports.NOOP = NOOP;
+exports.PatchFlagNames = PatchFlagNames;
+exports.PatchFlags = PatchFlags;
+exports.ShapeFlags = ShapeFlags;
+exports.SlotFlags = SlotFlags;
+exports.camelize = camelize;
+exports.capitalize = capitalize;
+exports.cssVarNameEscapeSymbolsRE = cssVarNameEscapeSymbolsRE;
+exports.def = def;
+exports.escapeHtml = escapeHtml;
+exports.escapeHtmlComment = escapeHtmlComment;
+exports.extend = extend;
+exports.genCacheKey = genCacheKey;
+exports.genPropsAccessExp = genPropsAccessExp;
+exports.generateCodeFrame = generateCodeFrame;
+exports.getEscapedCssVarName = getEscapedCssVarName;
+exports.getGlobalThis = getGlobalThis;
+exports.hasChanged = hasChanged;
+exports.hasOwn = hasOwn;
+exports.hyphenate = hyphenate;
+exports.includeBooleanAttr = includeBooleanAttr;
+exports.invokeArrayFns = invokeArrayFns;
+exports.isArray = isArray;
+exports.isBooleanAttr = isBooleanAttr;
+exports.isBuiltInDirective = isBuiltInDirective;
+exports.isDate = isDate;
+exports.isFunction = isFunction;
+exports.isGloballyAllowed = isGloballyAllowed;
+exports.isGloballyWhitelisted = isGloballyWhitelisted;
+exports.isHTMLTag = isHTMLTag;
+exports.isIntegerKey = isIntegerKey;
+exports.isKnownHtmlAttr = isKnownHtmlAttr;
+exports.isKnownMathMLAttr = isKnownMathMLAttr;
+exports.isKnownSvgAttr = isKnownSvgAttr;
+exports.isMap = isMap;
+exports.isMathMLTag = isMathMLTag;
+exports.isModelListener = isModelListener;
+exports.isObject = isObject;
+exports.isOn = isOn;
+exports.isPlainObject = isPlainObject;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isRenderableAttrValue = isRenderableAttrValue;
+exports.isReservedProp = isReservedProp;
+exports.isSSRSafeAttrName = isSSRSafeAttrName;
+exports.isSVGTag = isSVGTag;
+exports.isSet = isSet;
+exports.isSpecialBooleanAttr = isSpecialBooleanAttr;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isVoidTag = isVoidTag;
+exports.looseEqual = looseEqual;
+exports.looseIndexOf = looseIndexOf;
+exports.looseToNumber = looseToNumber;
+exports.makeMap = makeMap;
+exports.normalizeClass = normalizeClass;
+exports.normalizeCssVarValue = normalizeCssVarValue;
+exports.normalizeProps = normalizeProps;
+exports.normalizeStyle = normalizeStyle;
+exports.objectToString = objectToString;
+exports.parseStringStyle = parseStringStyle;
+exports.propsToAttrMap = propsToAttrMap;
+exports.remove = remove;
+exports.slotFlagsText = slotFlagsText;
+exports.stringifyStyle = stringifyStyle;
+exports.toDisplayString = toDisplayString;
+exports.toHandlerKey = toHandlerKey;
+exports.toNumber = toNumber;
+exports.toRawType = toRawType;
+exports.toTypeString = toTypeString;

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

@@ -0,0 +1,334 @@
+/**
+ * Make a map and return a function for checking if a key
+ * is in that map.
+ * IMPORTANT: all calls of this function must be prefixed with
+ * \/\*#\_\_PURE\_\_\*\/
+ * So that rollup can tree-shake them if necessary.
+ */
+export declare function makeMap(str: string): (key: string) => boolean;
+
+export declare const EMPTY_OBJ: {
+    readonly [key: string]: any;
+};
+export declare const EMPTY_ARR: readonly never[];
+export declare const NOOP: () => void;
+/**
+ * Always return false.
+ */
+export declare const NO: () => boolean;
+export declare const isOn: (key: string) => boolean;
+export declare const isModelListener: (key: string) => key is `onUpdate:${string}`;
+export declare const extend: typeof Object.assign;
+export declare const remove: <T>(arr: T[], el: T) => void;
+export declare const hasOwn: (val: object, key: string | symbol) => key is keyof typeof val;
+export declare const isArray: typeof Array.isArray;
+export declare const isMap: (val: unknown) => val is Map<any, any>;
+export declare const isSet: (val: unknown) => val is Set<any>;
+export declare const isDate: (val: unknown) => val is Date;
+export declare const isRegExp: (val: unknown) => val is RegExp;
+export declare const isFunction: (val: unknown) => val is Function;
+export declare const isString: (val: unknown) => val is string;
+export declare const isSymbol: (val: unknown) => val is symbol;
+export declare const isObject: (val: unknown) => val is Record<any, any>;
+export declare const isPromise: <T = any>(val: unknown) => val is Promise<T>;
+export declare const objectToString: typeof Object.prototype.toString;
+export declare const toTypeString: (value: unknown) => string;
+export declare const toRawType: (value: unknown) => string;
+export declare const isPlainObject: (val: unknown) => val is object;
+export declare const isIntegerKey: (key: unknown) => boolean;
+export declare const isReservedProp: (key: string) => boolean;
+export declare const isBuiltInDirective: (key: string) => boolean;
+/**
+ * @private
+ */
+export declare const camelize: (str: string) => string;
+/**
+ * @private
+ */
+export declare const hyphenate: (str: string) => string;
+/**
+ * @private
+ */
+export declare const capitalize: <T extends string>(str: T) => Capitalize<T>;
+/**
+ * @private
+ */
+export declare const toHandlerKey: <T extends string>(str: T) => T extends '' ? '' : `on${Capitalize<T>}`;
+export declare const hasChanged: (value: any, oldValue: any) => boolean;
+export declare const invokeArrayFns: (fns: Function[], ...arg: any[]) => void;
+export declare const def: (obj: object, key: string | symbol, value: any, writable?: boolean) => void;
+/**
+ * "123-foo" will be parsed to 123
+ * This is used for the .number modifier in v-model
+ */
+export declare const looseToNumber: (val: any) => any;
+/**
+ * Only concerns number-like strings
+ * "123-foo" will be returned as-is
+ */
+export declare const toNumber: (val: any) => any;
+export declare const getGlobalThis: () => any;
+export declare function genPropsAccessExp(name: string): string;
+export declare function genCacheKey(source: string, options: any): string;
+
+/**
+ * Patch flags are optimization hints generated by the compiler.
+ * when a block with dynamicChildren is encountered during diff, the algorithm
+ * enters "optimized mode". In this mode, we know that the vdom is produced by
+ * a render function generated by the compiler, so the algorithm only needs to
+ * handle updates explicitly marked by these patch flags.
+ *
+ * Patch flags can be combined using the | bitwise operator and can be checked
+ * using the & operator, e.g.
+ *
+ * ```js
+ * const flag = TEXT | CLASS
+ * if (flag & TEXT) { ... }
+ * ```
+ *
+ * Check the `patchElement` function in '../../runtime-core/src/renderer.ts' to see how the
+ * flags are handled during diff.
+ */
+export declare enum PatchFlags {
+    /**
+     * Indicates an element with dynamic textContent (children fast path)
+     */
+    TEXT = 1,
+    /**
+     * Indicates an element with dynamic class binding.
+     */
+    CLASS = 2,
+    /**
+     * Indicates an element with dynamic style
+     * The compiler pre-compiles static string styles into static objects
+     * + detects and hoists inline static objects
+     * e.g. `style="color: red"` and `:style="{ color: 'red' }"` both get hoisted
+     * as:
+     * ```js
+     * const style = { color: 'red' }
+     * render() { return e('div', { style }) }
+     * ```
+     */
+    STYLE = 4,
+    /**
+     * Indicates an element that has non-class/style dynamic props.
+     * Can also be on a component that has any dynamic props (includes
+     * class/style). when this flag is present, the vnode also has a dynamicProps
+     * array that contains the keys of the props that may change so the runtime
+     * can diff them faster (without having to worry about removed props)
+     */
+    PROPS = 8,
+    /**
+     * Indicates an element with props with dynamic keys. When keys change, a full
+     * diff is always needed to remove the old key. This flag is mutually
+     * exclusive with CLASS, STYLE and PROPS.
+     */
+    FULL_PROPS = 16,
+    /**
+     * Indicates an element that requires props hydration
+     * (but not necessarily patching)
+     * e.g. event listeners & v-bind with prop modifier
+     */
+    NEED_HYDRATION = 32,
+    /**
+     * Indicates a fragment whose children order doesn't change.
+     */
+    STABLE_FRAGMENT = 64,
+    /**
+     * Indicates a fragment with keyed or partially keyed children
+     */
+    KEYED_FRAGMENT = 128,
+    /**
+     * Indicates a fragment with unkeyed children.
+     */
+    UNKEYED_FRAGMENT = 256,
+    /**
+     * Indicates an element that only needs non-props patching, e.g. ref or
+     * directives (onVnodeXXX hooks). since every patched vnode checks for refs
+     * and onVnodeXXX hooks, it simply marks the vnode so that a parent block
+     * will track it.
+     */
+    NEED_PATCH = 512,
+    /**
+     * Indicates a component with dynamic slots (e.g. slot that references a v-for
+     * iterated value, or dynamic slot names).
+     * Components with this flag are always force updated.
+     */
+    DYNAMIC_SLOTS = 1024,
+    /**
+     * Indicates a fragment that was created only because the user has placed
+     * comments at the root level of a template. This is a dev-only flag since
+     * comments are stripped in production.
+     */
+    DEV_ROOT_FRAGMENT = 2048,
+    /**
+     * SPECIAL FLAGS -------------------------------------------------------------
+     * Special flags are negative integers. They are never matched against using
+     * bitwise operators (bitwise matching should only happen in branches where
+     * patchFlag > 0), and are mutually exclusive. When checking for a special
+     * flag, simply check patchFlag === FLAG.
+     */
+    /**
+     * Indicates a cached static vnode. This is also a hint for hydration to skip
+     * the entire sub tree since static content never needs to be updated.
+     */
+    CACHED = -1,
+    /**
+     * A special flag that indicates that the diffing algorithm should bail out
+     * of optimized mode. For example, on block fragments created by renderSlot()
+     * when encountering non-compiler generated slots (i.e. manually written
+     * render functions, which should always be fully diffed)
+     * OR manually cloneVNodes
+     */
+    BAIL = -2
+}
+/**
+ * dev only flag -> name mapping
+ */
+export declare const PatchFlagNames: Record<PatchFlags, string>;
+
+export declare enum ShapeFlags {
+    ELEMENT = 1,
+    FUNCTIONAL_COMPONENT = 2,
+    STATEFUL_COMPONENT = 4,
+    TEXT_CHILDREN = 8,
+    ARRAY_CHILDREN = 16,
+    SLOTS_CHILDREN = 32,
+    TELEPORT = 64,
+    SUSPENSE = 128,
+    COMPONENT_SHOULD_KEEP_ALIVE = 256,
+    COMPONENT_KEPT_ALIVE = 512,
+    COMPONENT = 6
+}
+
+export declare enum SlotFlags {
+    /**
+     * 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.
+     */
+    STABLE = 1,
+    /**
+     * 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.
+     */
+    DYNAMIC = 2,
+    /**
+     * `<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`)
+     */
+    FORWARDED = 3
+}
+/**
+ * Dev only
+ */
+export declare const slotFlagsText: Record<SlotFlags, string>;
+
+export declare const isGloballyAllowed: (key: string) => boolean;
+/** @deprecated use `isGloballyAllowed` instead */
+export declare const isGloballyWhitelisted: (key: string) => boolean;
+
+export declare function generateCodeFrame(source: string, start?: number, end?: number): string;
+
+export type NormalizedStyle = Record<string, string | number>;
+export declare function normalizeStyle(value: unknown): NormalizedStyle | string | undefined;
+export declare function parseStringStyle(cssText: string): NormalizedStyle;
+export declare function stringifyStyle(styles: NormalizedStyle | string | undefined): string;
+export declare function normalizeClass(value: unknown): string;
+export declare function normalizeProps(props: Record<string, any> | null): Record<string, any> | null;
+
+/**
+ * Compiler only.
+ * Do NOT use in runtime code paths unless behind `__DEV__` flag.
+ */
+export declare const isHTMLTag: (key: string) => boolean;
+/**
+ * Compiler only.
+ * Do NOT use in runtime code paths unless behind `__DEV__` flag.
+ */
+export declare const isSVGTag: (key: string) => boolean;
+/**
+ * Compiler only.
+ * Do NOT use in runtime code paths unless behind `__DEV__` flag.
+ */
+export declare const isMathMLTag: (key: string) => boolean;
+/**
+ * Compiler only.
+ * Do NOT use in runtime code paths unless behind `__DEV__` flag.
+ */
+export declare const isVoidTag: (key: string) => boolean;
+
+export declare const isSpecialBooleanAttr: (key: string) => boolean;
+/**
+ * The full list is needed during SSR to produce the correct initial markup.
+ */
+export declare const isBooleanAttr: (key: string) => boolean;
+/**
+ * Boolean attributes should be included if the value is truthy or ''.
+ * e.g. `<select multiple>` compiles to `{ multiple: '' }`
+ */
+export declare function includeBooleanAttr(value: unknown): boolean;
+export declare function isSSRSafeAttrName(name: string): boolean;
+export declare const propsToAttrMap: Record<string, string | undefined>;
+/**
+ * Known attributes, this is used for stringification of runtime static nodes
+ * so that we don't stringify bindings that cannot be set from HTML.
+ * Don't also forget to allow `data-*` and `aria-*`!
+ * Generated from https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes
+ */
+export declare const isKnownHtmlAttr: (key: string) => boolean;
+/**
+ * Generated from https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute
+ */
+export declare const isKnownSvgAttr: (key: string) => boolean;
+/**
+ * Generated from https://developer.mozilla.org/en-US/docs/Web/MathML/Attribute
+ */
+export declare const isKnownMathMLAttr: (key: string) => boolean;
+/**
+ * Shared between server-renderer and runtime-core hydration logic
+ */
+export declare function isRenderableAttrValue(value: unknown): boolean;
+
+export declare function escapeHtml(string: unknown): string;
+export declare function escapeHtmlComment(src: string): string;
+export declare const cssVarNameEscapeSymbolsRE: RegExp;
+export declare function getEscapedCssVarName(key: string, doubleEscape: boolean): string;
+
+export declare function looseEqual(a: any, b: any): boolean;
+export declare function looseIndexOf(arr: any[], val: any): number;
+
+/**
+ * For converting {{ interpolation }} values to displayed strings.
+ * @private
+ */
+export declare const toDisplayString: (val: unknown) => string;
+
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type LooseRequired<T> = {
+    [P in keyof (T & Required<T>)]: T[P];
+};
+export type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+export type IsKeyValues<T, K = string> = IfAny<T, false, T extends object ? (keyof T extends K ? true : false) : false>;
+/**
+ * Utility for extracting the parameters from a function overload (for typed emits)
+ * https://github.com/microsoft/TypeScript/issues/32164#issuecomment-1146737709
+ */
+export type OverloadParameters<T extends (...args: any[]) => any> = Parameters<OverloadUnion<T>>;
+type OverloadProps<TOverload> = Pick<TOverload, keyof TOverload>;
+type OverloadUnionRecursive<TOverload, TPartialOverload = unknown> = TOverload extends (...args: infer TArgs) => infer TReturn ? TPartialOverload extends TOverload ? never : OverloadUnionRecursive<TPartialOverload & TOverload, TPartialOverload & ((...args: TArgs) => TReturn) & OverloadProps<TOverload>> | ((...args: TArgs) => TReturn) : never;
+type OverloadUnion<TOverload extends (...args: any[]) => any> = Exclude<OverloadUnionRecursive<(() => never) & TOverload>, TOverload extends () => never ? never : () => never>;
+
+/**
+ * Normalize CSS var value created by `v-bind` in `<style>` block
+ * See https://github.com/vuejs/core/pull/12461#issuecomment-2495804664
+ */
+export declare function normalizeCssVarValue(value: unknown): string;
+
+

node_modules/@vue/babel-plugin-jsx/node_modules/@vue/shared/dist/shared.esm-bundler.js

@@ -0,0 +1,536 @@
+/**
+* @vue/shared v3.5.34
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+// @__NO_SIDE_EFFECTS__
+function makeMap(str) {
+  const map = /* @__PURE__ */ Object.create(null);
+  for (const key of str.split(",")) map[key] = 1;
+  return (val) => val in map;
+}
+
+const EMPTY_OBJ = !!(process.env.NODE_ENV !== "production") ? Object.freeze({}) : {};
+const EMPTY_ARR = !!(process.env.NODE_ENV !== "production") ? Object.freeze([]) : [];
+const NOOP = () => {
+};
+const NO = () => false;
+const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
+(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
+const isModelListener = (key) => key.startsWith("onUpdate:");
+const extend = Object.assign;
+const remove = (arr, el) => {
+  const i = arr.indexOf(el);
+  if (i > -1) {
+    arr.splice(i, 1);
+  }
+};
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key) => hasOwnProperty.call(val, key);
+const isArray = Array.isArray;
+const isMap = (val) => toTypeString(val) === "[object Map]";
+const isSet = (val) => toTypeString(val) === "[object Set]";
+const isDate = (val) => toTypeString(val) === "[object Date]";
+const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
+const isFunction = (val) => typeof val === "function";
+const isString = (val) => typeof val === "string";
+const isSymbol = (val) => typeof val === "symbol";
+const isObject = (val) => val !== null && typeof val === "object";
+const isPromise = (val) => {
+  return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const toRawType = (value) => {
+  return toTypeString(value).slice(8, -1);
+};
+const isPlainObject = (val) => toTypeString(val) === "[object Object]";
+const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+const isReservedProp = /* @__PURE__ */ makeMap(
+  // the leading comma is intentional so empty string "" is also included
+  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
+);
+const isBuiltInDirective = /* @__PURE__ */ makeMap(
+  "bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
+);
+const cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return ((str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  });
+};
+const camelizeRE = /-\w/g;
+const camelize = cacheStringFunction(
+  (str) => {
+    return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
+  }
+);
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction(
+  (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
+);
+const capitalize = cacheStringFunction((str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+});
+const toHandlerKey = cacheStringFunction(
+  (str) => {
+    const s = str ? `on${capitalize(str)}` : ``;
+    return s;
+  }
+);
+const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+const invokeArrayFns = (fns, ...arg) => {
+  for (let i = 0; i < fns.length; i++) {
+    fns[i](...arg);
+  }
+};
+const def = (obj, key, value, writable = false) => {
+  Object.defineProperty(obj, key, {
+    configurable: true,
+    enumerable: false,
+    writable,
+    value
+  });
+};
+const looseToNumber = (val) => {
+  const n = parseFloat(val);
+  return isNaN(n) ? val : n;
+};
+const toNumber = (val) => {
+  const n = isString(val) ? Number(val) : NaN;
+  return isNaN(n) ? val : n;
+};
+let _globalThis;
+const getGlobalThis = () => {
+  return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+};
+const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
+function genPropsAccessExp(name) {
+  return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;
+}
+function genCacheKey(source, options) {
+  return source + JSON.stringify(
+    options,
+    (_, val) => typeof val === "function" ? val.toString() : val
+  );
+}
+
+const PatchFlags = {
+  "TEXT": 1,
+  "1": "TEXT",
+  "CLASS": 2,
+  "2": "CLASS",
+  "STYLE": 4,
+  "4": "STYLE",
+  "PROPS": 8,
+  "8": "PROPS",
+  "FULL_PROPS": 16,
+  "16": "FULL_PROPS",
+  "NEED_HYDRATION": 32,
+  "32": "NEED_HYDRATION",
+  "STABLE_FRAGMENT": 64,
+  "64": "STABLE_FRAGMENT",
+  "KEYED_FRAGMENT": 128,
+  "128": "KEYED_FRAGMENT",
+  "UNKEYED_FRAGMENT": 256,
+  "256": "UNKEYED_FRAGMENT",
+  "NEED_PATCH": 512,
+  "512": "NEED_PATCH",
+  "DYNAMIC_SLOTS": 1024,
+  "1024": "DYNAMIC_SLOTS",
+  "DEV_ROOT_FRAGMENT": 2048,
+  "2048": "DEV_ROOT_FRAGMENT",
+  "CACHED": -1,
+  "-1": "CACHED",
+  "BAIL": -2,
+  "-2": "BAIL"
+};
+const PatchFlagNames = {
+  [1]: `TEXT`,
+  [2]: `CLASS`,
+  [4]: `STYLE`,
+  [8]: `PROPS`,
+  [16]: `FULL_PROPS`,
+  [32]: `NEED_HYDRATION`,
+  [64]: `STABLE_FRAGMENT`,
+  [128]: `KEYED_FRAGMENT`,
+  [256]: `UNKEYED_FRAGMENT`,
+  [512]: `NEED_PATCH`,
+  [1024]: `DYNAMIC_SLOTS`,
+  [2048]: `DEV_ROOT_FRAGMENT`,
+  [-1]: `CACHED`,
+  [-2]: `BAIL`
+};
+
+const ShapeFlags = {
+  "ELEMENT": 1,
+  "1": "ELEMENT",
+  "FUNCTIONAL_COMPONENT": 2,
+  "2": "FUNCTIONAL_COMPONENT",
+  "STATEFUL_COMPONENT": 4,
+  "4": "STATEFUL_COMPONENT",
+  "TEXT_CHILDREN": 8,
+  "8": "TEXT_CHILDREN",
+  "ARRAY_CHILDREN": 16,
+  "16": "ARRAY_CHILDREN",
+  "SLOTS_CHILDREN": 32,
+  "32": "SLOTS_CHILDREN",
+  "TELEPORT": 64,
+  "64": "TELEPORT",
+  "SUSPENSE": 128,
+  "128": "SUSPENSE",
+  "COMPONENT_SHOULD_KEEP_ALIVE": 256,
+  "256": "COMPONENT_SHOULD_KEEP_ALIVE",
+  "COMPONENT_KEPT_ALIVE": 512,
+  "512": "COMPONENT_KEPT_ALIVE",
+  "COMPONENT": 6,
+  "6": "COMPONENT"
+};
+
+const SlotFlags = {
+  "STABLE": 1,
+  "1": "STABLE",
+  "DYNAMIC": 2,
+  "2": "DYNAMIC",
+  "FORWARDED": 3,
+  "3": "FORWARDED"
+};
+const slotFlagsText = {
+  [1]: "STABLE",
+  [2]: "DYNAMIC",
+  [3]: "FORWARDED"
+};
+
+const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol";
+const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
+const isGloballyWhitelisted = isGloballyAllowed;
+
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+  start = Math.max(0, Math.min(start, source.length));
+  end = Math.max(0, Math.min(end, source.length));
+  if (start > end) return "";
+  let lines = source.split(/(\r?\n)/);
+  const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
+  lines = lines.filter((_, idx) => idx % 2 === 0);
+  let count = 0;
+  const res = [];
+  for (let i = 0; i < lines.length; i++) {
+    count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
+    if (count >= start) {
+      for (let j = i - range; j <= i + range || end > count; j++) {
+        if (j < 0 || j >= lines.length) continue;
+        const line = j + 1;
+        res.push(
+          `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`
+        );
+        const lineLength = lines[j].length;
+        const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
+        if (j === i) {
+          const pad = start - (count - (lineLength + newLineSeqLength));
+          const length = Math.max(
+            1,
+            end > count ? lineLength - pad : end - start
+          );
+          res.push(`   |  ` + " ".repeat(pad) + "^".repeat(length));
+        } else if (j > i) {
+          if (end > count) {
+            const length = Math.max(Math.min(end - count, lineLength), 1);
+            res.push(`   |  ` + "^".repeat(length));
+          }
+          count += lineLength + newLineSeqLength;
+        }
+      }
+      break;
+    }
+  }
+  return res.join("\n");
+}
+
+function normalizeStyle(value) {
+  if (isArray(value)) {
+    const res = {};
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
+      if (normalized) {
+        for (const key in normalized) {
+          res[key] = normalized[key];
+        }
+      }
+    }
+    return res;
+  } else if (isString(value) || isObject(value)) {
+    return value;
+  }
+}
+const listDelimiterRE = /;(?![^(]*\))/g;
+const propertyDelimiterRE = /:([^]+)/;
+const styleCommentRE = /\/\*[^]*?\*\//g;
+function parseStringStyle(cssText) {
+  const ret = {};
+  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
+    if (item) {
+      const tmp = item.split(propertyDelimiterRE);
+      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+    }
+  });
+  return ret;
+}
+function stringifyStyle(styles) {
+  if (!styles) return "";
+  if (isString(styles)) return styles;
+  let ret = "";
+  for (const key in styles) {
+    const value = styles[key];
+    if (isString(value) || typeof value === "number") {
+      const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
+      ret += `${normalizedKey}:${value};`;
+    }
+  }
+  return ret;
+}
+function normalizeClass(value) {
+  let res = "";
+  if (isString(value)) {
+    res = value;
+  } else if (isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const normalized = normalizeClass(value[i]);
+      if (normalized) {
+        res += normalized + " ";
+      }
+    }
+  } else if (isObject(value)) {
+    for (const name in value) {
+      if (value[name]) {
+        res += name + " ";
+      }
+    }
+  }
+  return res.trim();
+}
+function normalizeProps(props) {
+  if (!props) return null;
+  let { class: klass, style } = props;
+  if (klass && !isString(klass)) {
+    props.class = normalizeClass(klass);
+  }
+  if (style) {
+    props.style = normalizeStyle(style);
+  }
+  return props;
+}
+
+const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
+const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
+const MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics";
+const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
+const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
+const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
+const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
+const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
+
+const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
+const isBooleanAttr = /* @__PURE__ */ makeMap(
+  specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
+);
+function includeBooleanAttr(value) {
+  return !!value || value === "";
+}
+const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
+const attrValidationCache = {};
+function isSSRSafeAttrName(name) {
+  if (attrValidationCache.hasOwnProperty(name)) {
+    return attrValidationCache[name];
+  }
+  const isUnsafe = unsafeAttrCharRE.test(name);
+  if (isUnsafe) {
+    console.error(`unsafe attribute name: ${name}`);
+  }
+  return attrValidationCache[name] = !isUnsafe;
+}
+const propsToAttrMap = {
+  acceptCharset: "accept-charset",
+  className: "class",
+  htmlFor: "for",
+  httpEquiv: "http-equiv"
+};
+const isKnownHtmlAttr = /* @__PURE__ */ makeMap(
+  `accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`
+);
+const isKnownSvgAttr = /* @__PURE__ */ makeMap(
+  `xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`
+);
+const isKnownMathMLAttr = /* @__PURE__ */ makeMap(
+  `accent,accentunder,actiontype,align,alignmentscope,altimg,altimg-height,altimg-valign,altimg-width,alttext,bevelled,close,columnsalign,columnlines,columnspan,denomalign,depth,dir,display,displaystyle,encoding,equalcolumns,equalrows,fence,fontstyle,fontweight,form,frame,framespacing,groupalign,height,href,id,indentalign,indentalignfirst,indentalignlast,indentshift,indentshiftfirst,indentshiftlast,indextype,justify,largetop,largeop,lquote,lspace,mathbackground,mathcolor,mathsize,mathvariant,maxsize,minlabelspacing,mode,other,overflow,position,rowalign,rowlines,rowspan,rquote,rspace,scriptlevel,scriptminsize,scriptsizemultiplier,selection,separator,separators,shift,side,src,stackalign,stretchy,subscriptshift,superscriptshift,symmetric,voffset,width,widths,xlink:href,xlink:show,xlink:type,xmlns`
+);
+function isRenderableAttrValue(value) {
+  if (value == null) {
+    return false;
+  }
+  const type = typeof value;
+  return type === "string" || type === "number" || type === "boolean";
+}
+
+const escapeRE = /["'&<>]/;
+function escapeHtml(string) {
+  const str = "" + string;
+  const match = escapeRE.exec(str);
+  if (!match) {
+    return str;
+  }
+  let html = "";
+  let escaped;
+  let index;
+  let lastIndex = 0;
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        escaped = "&quot;";
+        break;
+      case 38:
+        escaped = "&amp;";
+        break;
+      case 39:
+        escaped = "&#39;";
+        break;
+      case 60:
+        escaped = "&lt;";
+        break;
+      case 62:
+        escaped = "&gt;";
+        break;
+      default:
+        continue;
+    }
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+    lastIndex = index + 1;
+    html += escaped;
+  }
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+}
+const commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;
+function escapeHtmlComment(src) {
+  return src.replace(commentStripRE, "");
+}
+const cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
+function getEscapedCssVarName(key, doubleEscape) {
+  return key.replace(
+    cssVarNameEscapeSymbolsRE,
+    (s) => doubleEscape ? s === '"' ? '\\\\\\"' : `\\\\${s}` : `\\${s}`
+  );
+}
+
+function looseCompareArrays(a, b) {
+  if (a.length !== b.length) return false;
+  let equal = true;
+  for (let i = 0; equal && i < a.length; i++) {
+    equal = looseEqual(a[i], b[i]);
+  }
+  return equal;
+}
+function looseEqual(a, b) {
+  if (a === b) return true;
+  let aValidType = isDate(a);
+  let bValidType = isDate(b);
+  if (aValidType || bValidType) {
+    return aValidType && bValidType ? a.getTime() === b.getTime() : false;
+  }
+  aValidType = isSymbol(a);
+  bValidType = isSymbol(b);
+  if (aValidType || bValidType) {
+    return a === b;
+  }
+  aValidType = isArray(a);
+  bValidType = isArray(b);
+  if (aValidType || bValidType) {
+    return aValidType && bValidType ? looseCompareArrays(a, b) : false;
+  }
+  aValidType = isObject(a);
+  bValidType = isObject(b);
+  if (aValidType || bValidType) {
+    if (!aValidType || !bValidType) {
+      return false;
+    }
+    const aKeysCount = Object.keys(a).length;
+    const bKeysCount = Object.keys(b).length;
+    if (aKeysCount !== bKeysCount) {
+      return false;
+    }
+    for (const key in a) {
+      const aHasKey = a.hasOwnProperty(key);
+      const bHasKey = b.hasOwnProperty(key);
+      if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+  }
+  return String(a) === String(b);
+}
+function looseIndexOf(arr, val) {
+  return arr.findIndex((item) => looseEqual(item, val));
+}
+
+const isRef = (val) => {
+  return !!(val && val["__v_isRef"] === true);
+};
+const toDisplayString = (val) => {
+  return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
+};
+const replacer = (_key, val) => {
+  if (isRef(val)) {
+    return replacer(_key, val.value);
+  } else if (isMap(val)) {
+    return {
+      [`Map(${val.size})`]: [...val.entries()].reduce(
+        (entries, [key, val2], i) => {
+          entries[stringifySymbol(key, i) + " =>"] = val2;
+          return entries;
+        },
+        {}
+      )
+    };
+  } else if (isSet(val)) {
+    return {
+      [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
+    };
+  } else if (isSymbol(val)) {
+    return stringifySymbol(val);
+  } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
+    return String(val);
+  }
+  return val;
+};
+const stringifySymbol = (v, i = "") => {
+  var _a;
+  return (
+    // Symbol.description in es2019+ so we need to cast here to pass
+    // the lib: es2016 check
+    isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v
+  );
+};
+
+function normalizeCssVarValue(value) {
+  if (value == null) {
+    return "initial";
+  }
+  if (typeof value === "string") {
+    return value === "" ? " " : value;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    if (!!(process.env.NODE_ENV !== "production")) {
+      console.warn(
+        "[Vue warn] Invalid value used for CSS binding. Expected a string or a finite number but received:",
+        value
+      );
+    }
+  }
+  return String(value);
+}
+
+export { EMPTY_ARR, EMPTY_OBJ, NO, NOOP, PatchFlagNames, PatchFlags, ShapeFlags, SlotFlags, camelize, capitalize, cssVarNameEscapeSymbolsRE, def, escapeHtml, escapeHtmlComment, extend, genCacheKey, genPropsAccessExp, generateCodeFrame, getEscapedCssVarName, getGlobalThis, hasChanged, hasOwn, hyphenate, includeBooleanAttr, invokeArrayFns, isArray, isBooleanAttr, isBuiltInDirective, isDate, isFunction, isGloballyAllowed, isGloballyWhitelisted, isHTMLTag, isIntegerKey, isKnownHtmlAttr, isKnownMathMLAttr, isKnownSvgAttr, isMap, isMathMLTag, isModelListener, isObject, isOn, isPlainObject, isPromise, isRegExp, isRenderableAttrValue, isReservedProp, isSSRSafeAttrName, isSVGTag, isSet, isSpecialBooleanAttr, isString, isSymbol, isVoidTag, looseEqual, looseIndexOf, looseToNumber, makeMap, normalizeClass, normalizeCssVarValue, normalizeProps, normalizeStyle, objectToString, parseStringStyle, propsToAttrMap, remove, slotFlagsText, stringifyStyle, toDisplayString, toHandlerKey, toNumber, toRawType, toTypeString };

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

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

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

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

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