@lightsoft/js-sdk 1.0.1 → 1.0.2

package/dist/index.js

@@ -1,242 +1,2247 @@
-import { ref } from 'vue';
-
-var TAG_NAME_REGEX = /<\/?\s*([a-zA-Z][a-zA-Z0-9-]*)\b/; // 获取开始或结束标签的名
-var SINGLE_TAG_REGEX = /<([^\s>]+)/; // 单标签
-var TAG_REGEX = /<\/?[a-z]+[^>]*>|[^<>]+/gi; // 开始和结束标签
-var $FOR_REGEX = /r-for\s*=\s*"([^"]+)"/; //$for 属性值
-var $IF_REGEX = /r-if\s*=\s*"([^"]+)"/; //$if 属性值
-var $STYLE_REGEX = /r-style\s*=\s*"([^"]+)"/; //$style 属性值
-var $CLASS_REGEX = /r-class\s*=\s*"([^"]+)"/; //$class 属性值
-var $ATTRS_REGEX = /\sr-[a-z]\w+\s*=\s*"[^"]*"/g; // 所有$符号的属性
-var $CONTENT_REGEX = /\{\{(.+?)\}\}/g; // $符号内容
-var RELATIONAL_SYMBOLS_REGEX = /<=|>=|\=+|>|</; // 关系符号
-var STR_REGEX = /^("|'|`)(.*)\1$/;
-var CALLBACK_REGEX = /\s*setContent\((.*?)\)\s*/g;
-var FUN_NAME_REGEX = /([a-zA-Z_$][a-zA-Z0-9_$]*)/;
-function useId() {
-    return Math.random().toString(36).substring(2, 15);
-}
-function hasSingleTag(tag) {
-    var _a;
-    return ['img', 'br', 'input'].includes((_a = tag.match(SINGLE_TAG_REGEX)) === null || _a === void 0 ? void 0 : _a[1]);
-}
-function findStartTag(currentIndex, tags) {
-    var _a, _b, _c, _d;
-    var index = 1;
-    var prevTag = tags[currentIndex - index];
-    var currentTag = tags[currentIndex];
-    var currentTagName = (_b = (_a = currentTag.tag) === null || _a === void 0 ? void 0 : _a.match(TAG_NAME_REGEX)) === null || _b === void 0 ? void 0 : _b[1];
-    var prevTagName;
-    while (currentTagName !== prevTagName) {
-        prevTag = tags[currentIndex - index] || prevTag;
-        prevTagName = (_d = (_c = prevTag.tag) === null || _c === void 0 ? void 0 : _c.match(TAG_NAME_REGEX)) === null || _d === void 0 ? void 0 : _d[1];
-        index++;
-    }
-    return prevTag;
-}
-function operatorsParse(content) {
-    if (content === void 0) { content = ''; }
-    return content.replace('&gt;', '>').replace('&lt;', '<').replaceAll('&amp;', '&');
-}
-function resolver(htmlStr) {
-    var _a, _b, _c, _d, _e, _f;
-    var tags = [];
-    var match;
-    var index = 0;
-    var annotation = false;
-    htmlStr = htmlStr.replace('<!--', '<annotation>').replace('-->', '</annotation>');
-    while ((match = TAG_REGEX.exec(htmlStr)) !== null) {
-        var tag = match[0].trim();
-        if (!tag)
-            continue;
-        if (tag.startsWith('</')) {
-            var item = {
-                type: 'node',
-                tag: tag,
+import { _ as __assign, a as __awaiter, b as __generator } from './ws-DIZYbi31.js';
+export { c as createWebSocket, g as getState, u as useSendMessage, e as useWebSocketClose, d as useWebSocketMessage } from './ws-DIZYbi31.js';
+
+var READY_STATE;
+(function (READY_STATE) {
+    // 未初始化
+    READY_STATE[READY_STATE["UNSENT"] = 0] = "UNSENT";
+    // 已打开
+    READY_STATE[READY_STATE["OPENED"] = 1] = "OPENED";
+    // 已获取响应头
+    READY_STATE[READY_STATE["HEADERS_RECEIVED"] = 2] = "HEADERS_RECEIVED";
+    // 已加载响应体
+    READY_STATE[READY_STATE["LOADING"] = 3] = "LOADING";
+    // 已完成
+    READY_STATE[READY_STATE["DONE"] = 4] = "DONE";
+})(READY_STATE || (READY_STATE = {}));
+var STATUS_CODE;
+(function (STATUS_CODE) {
+    // 2xx 成功
+    STATUS_CODE[STATUS_CODE["OK"] = 200] = "OK";
+    STATUS_CODE[STATUS_CODE["CREATED"] = 201] = "CREATED";
+    STATUS_CODE[STATUS_CODE["ACCEPTED"] = 202] = "ACCEPTED";
+    STATUS_CODE[STATUS_CODE["NO_CONTENT"] = 204] = "NO_CONTENT";
+    // 3xx 重定向
+    STATUS_CODE[STATUS_CODE["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+    STATUS_CODE[STATUS_CODE["FOUND"] = 302] = "FOUND";
+    STATUS_CODE[STATUS_CODE["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+    // 4xx 客户端错误
+    STATUS_CODE[STATUS_CODE["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    STATUS_CODE[STATUS_CODE["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    STATUS_CODE[STATUS_CODE["FORBIDDEN"] = 403] = "FORBIDDEN";
+    STATUS_CODE[STATUS_CODE["NOT_FOUND"] = 404] = "NOT_FOUND";
+    // 5xx 服务器错误
+    STATUS_CODE[STATUS_CODE["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    STATUS_CODE[STATUS_CODE["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+    STATUS_CODE[STATUS_CODE["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+})(STATUS_CODE || (STATUS_CODE = {}));
+var HTTP_STATUS_MESSAGE;
+(function (HTTP_STATUS_MESSAGE) {
+    // 2xx 成功
+    HTTP_STATUS_MESSAGE["OK"] = "\u8BF7\u6C42\u6210\u529F";
+    HTTP_STATUS_MESSAGE["CREATED"] = "\u521B\u5EFA\u6210\u529F";
+    HTTP_STATUS_MESSAGE["ACCEPTED"] = "\u5DF2\u63A5\u6536";
+    HTTP_STATUS_MESSAGE["NO_CONTENT"] = "\u65E0\u5185\u5BB9";
+    // 3xx 重定向
+    HTTP_STATUS_MESSAGE["MOVED_PERMANENTLY"] = "\u5DF2\u6C38\u4E45\u79FB\u52A8";
+    HTTP_STATUS_MESSAGE["FOUND"] = "\u5DF2\u627E\u5230";
+    HTTP_STATUS_MESSAGE["NOT_MODIFIED"] = "\u672A\u4FEE\u6539";
+    // 4xx 客户端错误
+    HTTP_STATUS_MESSAGE["BAD_REQUEST"] = "\u8BF7\u6C42\u9519\u8BEF";
+    HTTP_STATUS_MESSAGE["UNAUTHORIZED"] = "\u672A\u6388\u6743";
+    HTTP_STATUS_MESSAGE["FORBIDDEN"] = "\u7981\u6B62\u8BBF\u95EE";
+    HTTP_STATUS_MESSAGE["NOT_FOUND"] = "\u672A\u627E\u5230";
+    // 5xx 服务器错误
+    HTTP_STATUS_MESSAGE["INTERNAL_SERVER_ERROR"] = "\u670D\u52A1\u5668\u9519\u8BEF";
+    HTTP_STATUS_MESSAGE["SERVICE_UNAVAILABLE"] = "\u670D\u52A1\u4E0D\u53EF\u7528";
+    HTTP_STATUS_MESSAGE["GATEWAY_TIMEOUT"] = "\u7F51\u5173\u8D85\u65F6";
+})(HTTP_STATUS_MESSAGE || (HTTP_STATUS_MESSAGE = {}));
+var HTTP_METHOD;
+(function (HTTP_METHOD) {
+    HTTP_METHOD["GET"] = "GET";
+    HTTP_METHOD["POST"] = "POST";
+    HTTP_METHOD["PUT"] = "PUT";
+    HTTP_METHOD["DELETE"] = "DELETE";
+})(HTTP_METHOD || (HTTP_METHOD = {}));
+var HTTP_HEADER;
+(function (HTTP_HEADER) {
+    HTTP_HEADER["CONTENT_TYPE"] = "Content-Type";
+    HTTP_HEADER["ACCEPT"] = "Accept";
+    HTTP_HEADER["AUTHORIZATION"] = "Authorization";
+})(HTTP_HEADER || (HTTP_HEADER = {}));
+var HTTP_CONTENT_TYPE;
+(function (HTTP_CONTENT_TYPE) {
+    HTTP_CONTENT_TYPE["JSON"] = "application/json";
+    HTTP_CONTENT_TYPE["FORM_URLENCODED"] = "application/x-www-form-urlencoded";
+    HTTP_CONTENT_TYPE["MULTIPART_FORM_DATA"] = "multipart/form-data";
+})(HTTP_CONTENT_TYPE || (HTTP_CONTENT_TYPE = {}));
+var HTTP_STATUS;
+(function (HTTP_STATUS) {
+    HTTP_STATUS[HTTP_STATUS["OK"] = 200] = "OK";
+    HTTP_STATUS[HTTP_STATUS["CREATED"] = 201] = "CREATED";
+    HTTP_STATUS[HTTP_STATUS["ACCEPTED"] = 202] = "ACCEPTED";
+    HTTP_STATUS[HTTP_STATUS["NO_CONTENT"] = 204] = "NO_CONTENT";
+})(HTTP_STATUS || (HTTP_STATUS = {}));
+
+var Request = /** @class */ (function () {
+    function Request() {
+        this.beforeRequestOptions = {};
+        this.xhr = this.create();
+    }
+    Request.prototype.create = function () {
+        if (window.XMLHttpRequest)
+            return new XMLHttpRequest();
+        else if (window.ActiveXObject)
+            return new ActiveXObject('Microsoft.XMLHTTP');
+        throw new Error('您的浏览器暂不支持XMLHttpRequest');
+    };
+    Request.prototype.useState = function (state) {
+        switch (state) {
+            case 'SUCCESS':
+                return this.xhr.readyState === READY_STATE.DONE && this.xhr.status >= 200 && this.xhr.status < 300;
+            case 'FAIL':
+                return this.xhr.readyState === READY_STATE.DONE && (this.xhr.status < 200 || this.xhr.status >= 300);
+            case 'PENDING':
+                return this.xhr.readyState < READY_STATE.DONE;
+            default:
+                return false;
+        }
+    };
+    Request.prototype.send = function (type, url, options) {
+        if (options === void 0) { options = {}; }
+        var _a = this, xhr = _a.xhr, beforeRequestOptions = _a.beforeRequestOptions, beforeResponseCallback = _a.beforeResponseCallback;
+        var useState = this.useState.bind(this);
+        var transformResponse = this.transformResponse.bind(this);
+        return new Promise(function (resolve, reject) {
+            xhr.open(type, url, options.async || true);
+            var requestOptions = __assign(__assign({}, beforeRequestOptions), options);
+            Object.keys(requestOptions.headers || {}).forEach(function (key) {
+                var _a;
+                xhr.setRequestHeader(key, (_a = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers) === null || _a === void 0 ? void 0 : _a[key]);
+            });
+            xhr.onreadystatechange = function () {
+                var success = useState('SUCCESS');
+                var fail = useState('FAIL');
+                if (success) {
+                    beforeResponseCallback
+                        ? beforeResponseCallback(transformResponse(xhr), resolve, reject)
+                        : resolve(transformResponse(xhr));
+                }
+                else if (fail) {
+                    reject(transformResponse(xhr));
+                }
             };
-            if (annotation)
-                item.$disabledFor = true;
-            if ((_a = item === null || item === void 0 ? void 0 : item.tag) === null || _a === void 0 ? void 0 : _a.includes('</annotation>'))
-                annotation = false;
-            tags.push(item);
-            var prevTag = findStartTag(index, tags);
-            prevTag.endIndex = index;
-        }
-        else if (tag.startsWith('<')) {
-            var forMatch = (_b = tag.match($FOR_REGEX)) === null || _b === void 0 ? void 0 : _b[1];
-            var ifMatch = (_c = tag.match($IF_REGEX)) === null || _c === void 0 ? void 0 : _c[1];
-            var styleMatch = (_d = tag.match($STYLE_REGEX)) === null || _d === void 0 ? void 0 : _d[1];
-            var classMatch = (_e = tag.match($CLASS_REGEX)) === null || _e === void 0 ? void 0 : _e[1];
-            var item = {
-                type: 'node',
-                tag: tag.replace($ATTRS_REGEX, '')
+            xhr.onerror = function () {
+                reject(transformResponse(xhr));
             };
-            if (forMatch)
-                item.$for = forMatch;
-            if (ifMatch)
-                item.$if = operatorsParse(ifMatch);
-            if (styleMatch)
-                item.$style = operatorsParse(styleMatch);
-            if (classMatch)
-                item.$class = operatorsParse(classMatch);
-            if ((_f = item === null || item === void 0 ? void 0 : item.tag) === null || _f === void 0 ? void 0 : _f.includes('<annotation>'))
-                annotation = true;
-            if (annotation)
-                item.$disabledFor = true;
-            tags.push(item);
+            if (options.data instanceof FormData) {
+                xhr.send(options.data);
+            }
+            else if (type === 'POST' || type === 'PUT') {
+                xhr.send(JSON.stringify(options.data));
+            }
+            else {
+                xhr.send();
+            }
+        });
+    };
+    Request.prototype.transformResponse = function (response) {
+        return {
+            data: JSON.parse(response.responseText),
+            code: response.status,
+            message: response.statusText,
+        };
+    };
+    Request.prototype.transformQuery = function (url, query) {
+        var queryData = Object.keys(query || {});
+        if (!queryData.length)
+            return url;
+        var queryString = queryData.map(function (key) {
+            return window.encodeURIComponent(key) + '=' + window.encodeURIComponent(query[key]);
+        }).join('&');
+        url += (url.includes('?') ? '&' : '?') + queryString;
+        return url;
+    };
+    Request.prototype.beforeSend = function (callback) {
+        this.beforeRequestOptions = callback();
+    };
+    Request.prototype.beforeResponse = function (callback) {
+        this.beforeResponseCallback = callback;
+    };
+    Request.prototype.abort = function () {
+        this.xhr.abort();
+    };
+    Request.prototype.get = function (url, query, headers) {
+        if (headers === void 0) { headers = {}; }
+        var newUrl = this.transformQuery(url, query);
+        return this.send('GET', newUrl, { headers: headers });
+    };
+    Request.prototype.post = function (url, data, headers) {
+        if (headers === void 0) { headers = {}; }
+        return this.send('POST', url, { data: data, headers: headers });
+    };
+    Request.prototype.put = function (url, data, headers) {
+        if (headers === void 0) { headers = {}; }
+        return this.send('PUT', url, { data: data, headers: headers });
+    };
+    Request.prototype.delete = function (url, data, headers) {
+        if (headers === void 0) { headers = {}; }
+        return this.send('DELETE', url, { data: data, headers: headers });
+    };
+    Request.prototype.patch = function (url, data, headers) {
+        if (headers === void 0) { headers = {}; }
+        return this.send('PATCH', url, { data: data, headers: headers });
+    };
+    Request.prototype.options = function (url, data, headers) {
+        if (headers === void 0) { headers = {}; }
+        return this.send('OPTIONS', url, { data: data, headers: headers });
+    };
+    Request.prototype.head = function (url, data, headers) {
+        if (headers === void 0) { headers = {}; }
+        return this.send('HEAD', url, { data: data, headers: headers });
+    };
+    Request.prototype.trace = function (url, data, headers) {
+        if (headers === void 0) { headers = {}; }
+        return this.send('TRACE', url, { data: data, headers: headers });
+    };
+    Request.prototype.connect = function (url, data, headers) {
+        if (headers === void 0) { headers = {}; }
+        return this.send('CONNECT', url, { data: data, headers: headers });
+    };
+    return Request;
+}());
+var RequestChain = /** @class */ (function () {
+    function RequestChain() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        this.fieldList = [{}];
+        this.responses = [];
+        this.setParams.apply(this, args);
+    }
+    RequestChain.prototype.getParams = function (type, data, fields) {
+        var keys = Object.keys(fields);
+        var values = Object.values(fields);
+        if (type === 'query') {
+            var query = keys.map(function (key, index) {
+                return "".concat(key, "=").concat(data[values[index]]);
+            }).join('&');
+            return query;
         }
         else {
-            tags.push({
-                type: 'content',
-                content: tag,
+            var body_1 = {};
+            keys.forEach(function (key, index) {
+                body_1[key] = data[values[index]];
+            });
+            return body_1;
+        }
+    };
+    RequestChain.prototype.setParams = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        for (var i = 0; i < args.length; i++) {
+            var arg = args[i];
+            this.fieldList.push(arg);
+        }
+    };
+    RequestChain.prototype.chain = function (list) {
+        var _this = this;
+        return list.reduce(function (pre, cur, index) {
+            return new Promise(function (resolve, reject) {
+                pre().then(function (preRes) {
+                    var fields = _this.fieldList[index];
+                    var type = (fields === null || fields === void 0 ? void 0 : fields.query) ? 'query' : 'body';
+                    var params = _this.getParams(type, preRes, (fields === null || fields === void 0 ? void 0 : fields.query) || fields);
+                    _this.responses.push(preRes);
+                    cur(params).then(function (curRes) {
+                        _this.responses.push(curRes);
+                        resolve(_this.responses);
+                    });
+                });
             });
+        });
+    };
+    return RequestChain;
+}());
+
+/**
+* @vue/shared v3.5.18
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+/*! #__NO_SIDE_EFFECTS__ */
+// @__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({}) : {};
+!!(process.env.NODE_ENV !== "production") ? Object.freeze([]) : [];
+const NOOP = () => {
+};
+const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
+(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
+const extend = Object.assign;
+const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
+const isArray = Array.isArray;
+const isMap = (val) => toTypeString(val) === "[object Map]";
+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 objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const toRawType = (value) => {
+  return toTypeString(value).slice(8, -1);
+};
+const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+const cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+};
+const capitalize = cacheStringFunction((str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+});
+const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+let _globalThis;
+const getGlobalThis = () => {
+  return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+};
+
+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];
         }
-        index++;
+      }
     }
-    return tags;
+    return res;
+  } else if (isString(value) || isObject(value)) {
+    return value;
+  }
 }
-function callbackParse(content) {
-    if (content === void 0) { content = ''; }
-    return content.replace(CALLBACK_REGEX, function (_match, args) {
-        var _a;
-        var newArgs = args.split(',').map(function (arg) {
-            if (STR_REGEX.test(arg.trim()))
-                return arg;
-            return 'this.' + arg.trim();
-        });
-        var funName = (_a = content.match(FUN_NAME_REGEX)) === null || _a === void 0 ? void 0 : _a[0];
-        return "".concat(funName, "(").concat(newArgs, ")");
-    });
+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 contentParse(content) {
-    if (content === void 0) { content = ''; }
-    return content.replace($CONTENT_REGEX, function (_match, key) {
-        var newKey = callbackParse(key);
-        return '${this.' + newKey + '}';
-    });
+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 parseIf(ifContent) {
-    ifContent = ifContent.replace(/^\s*if\s*=\s*/, '');
-    var operator = ifContent.match(RELATIONAL_SYMBOLS_REGEX);
-    var _a = ifContent.split(RELATIONAL_SYMBOLS_REGEX), left = _a[0], right = _a[1];
-    var leftVariable = (STR_REGEX.test(left.trim()) || /\d/.test(left.trim())) ? left.trim() : "this.".concat(left.trim());
-    var rightVariable = (STR_REGEX.test(right.trim()) || /\d/.test(right.trim())) ? right.trim() : "this.".concat(right.trim());
-    var code = '';
-    code += "if(";
-    code += "".concat(leftVariable);
-    code += "".concat(operator);
-    code += "".concat(rightVariable);
-    code += ") {\n";
-    return code;
-}
-function styleParse(styleContent) {
-    var _a;
-    var styleValue = contentParse((_a = styleContent.match($CONTENT_REGEX)) === null || _a === void 0 ? void 0 : _a[0]);
-    return styleContent.replace($CONTENT_REGEX, styleValue);
+
+/**
+* @vue/reactivity v3.5.18
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+
+function warn(msg, ...args) {
+  console.warn(`[Vue warn] ${msg}`, ...args);
 }
-function classParse(classContent) {
-    var _a;
-    if (classContent === void 0) { classContent = ''; }
-    var classValue = contentParse((_a = classContent.match($CONTENT_REGEX)) === null || _a === void 0 ? void 0 : _a[0]);
-    return classContent.replace($CONTENT_REGEX, classValue);
-}
-function attributeParse(tagData) {
-    var tag = tagData.tag;
-    var styleValue = styleParse(tagData.$style || '');
-    var classValue = classParse(tagData.$class || '');
-    var _style = styleValue ? ' style="' + styleValue + '"' : '';
-    var _class = classValue ? ' class="' + classValue + '"' : '';
-    return tag.replace('>', _style + _class + '>');
-}
-function parseFor(forContent) {
-    var expressionFor = forContent.split(/\s(in)\s/);
-    var iterable = expressionFor[expressionFor.length - 1];
-    var expressionLeft = expressionFor[0].split(',');
-    var itemKey = expressionLeft[0];
-    var indexKey = expressionLeft[1];
-    var code = '';
-    code += "for (this['".concat(itemKey, "'] of this.").concat(iterable, " || []) {\n");
-    if (indexKey)
-        code += "this.".concat(indexKey, " = this.").concat(iterable, ".indexOf(this.").concat(itemKey, ");\n");
-    return code;
-}
-function compose(tags) {
-    var code = '';
-    for (var _i = 0, tags_1 = tags; _i < tags_1.length; _i++) {
-        var t = tags_1[_i];
-        var type = t.type, content = t.content;
-        if (type === 'node') {
-            if (t.$if) {
-                code += parseIf(t.$if);
-                tags[t.endIndex].isIf = true;
-            }
-            if (t.$for && !t.$disabledFor) {
-                code += parseFor(t.$for);
-                if (hasSingleTag(t.tag))
-                    t.isFor = true;
-                else
-                    tags[t.endIndex].isFor = true;
+let batchDepth = 0;
+let batchedSub;
+function startBatch() {
+  batchDepth++;
+}
+function endBatch() {
+  if (--batchDepth > 0) {
+    return;
+  }
+  let error;
+  while (batchedSub) {
+    let e = batchedSub;
+    batchedSub = void 0;
+    while (e) {
+      const next = e.next;
+      e.next = void 0;
+      e.flags &= -9;
+      if (e.flags & 1) {
+        try {
+          ;
+          e.trigger();
+        } catch (err) {
+          if (!error) error = err;
+        }
+      }
+      e = next;
+    }
+  }
+  if (error) throw error;
+}
+class Dep {
+  // TODO isolatedDeclarations "__v_skip"
+  constructor(computed) {
+    this.computed = computed;
+    this.version = 0;
+    /**
+     * Link between this dep and the current active effect
+     */
+    this.activeLink = void 0;
+    /**
+     * Doubly linked list representing the subscribing effects (tail)
+     */
+    this.subs = void 0;
+    /**
+     * For object property deps cleanup
+     */
+    this.map = void 0;
+    this.key = void 0;
+    /**
+     * Subscriber counter
+     */
+    this.sc = 0;
+    /**
+     * @internal
+     */
+    this.__v_skip = true;
+    if (!!(process.env.NODE_ENV !== "production")) {
+      this.subsHead = void 0;
+    }
+  }
+  track(debugInfo) {
+    {
+      return;
+    }
+  }
+  trigger(debugInfo) {
+    this.version++;
+    this.notify(debugInfo);
+  }
+  notify(debugInfo) {
+    startBatch();
+    try {
+      if (!!(process.env.NODE_ENV !== "production")) {
+        for (let head = this.subsHead; head; head = head.nextSub) {
+          if (head.sub.onTrigger && !(head.sub.flags & 8)) {
+            head.sub.onTrigger(
+              extend(
+                {
+                  effect: head.sub
+                },
+                debugInfo
+              )
+            );
+          }
+        }
+      }
+      for (let link = this.subs; link; link = link.prevSub) {
+        if (link.sub.notify()) {
+          ;
+          link.sub.dep.notify();
+        }
+      }
+    } finally {
+      endBatch();
+    }
+  }
+}
+const targetMap = /* @__PURE__ */ new WeakMap();
+const ITERATE_KEY = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? "Object iterate" : ""
+);
+const MAP_KEY_ITERATE_KEY = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? "Map keys iterate" : ""
+);
+const ARRAY_ITERATE_KEY = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? "Array iterate" : ""
+);
+function track(target, type, key) {
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) {
+    return;
+  }
+  const run = (dep) => {
+    if (dep) {
+      if (!!(process.env.NODE_ENV !== "production")) {
+        dep.trigger({
+          target,
+          type,
+          key,
+          newValue,
+          oldValue,
+          oldTarget
+        });
+      } else {
+        dep.trigger();
+      }
+    }
+  };
+  startBatch();
+  if (type === "clear") {
+    depsMap.forEach(run);
+  } else {
+    const targetIsArray = isArray(target);
+    const isArrayIndex = targetIsArray && isIntegerKey(key);
+    if (targetIsArray && key === "length") {
+      const newLength = Number(newValue);
+      depsMap.forEach((dep, key2) => {
+        if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
+          run(dep);
+        }
+      });
+    } else {
+      if (key !== void 0 || depsMap.has(void 0)) {
+        run(depsMap.get(key));
+      }
+      if (isArrayIndex) {
+        run(depsMap.get(ARRAY_ITERATE_KEY));
+      }
+      switch (type) {
+        case "add":
+          if (!targetIsArray) {
+            run(depsMap.get(ITERATE_KEY));
+            if (isMap(target)) {
+              run(depsMap.get(MAP_KEY_ITERATE_KEY));
             }
-            if (t.$style || t.$class) {
-                t.tag = attributeParse(t);
+          } else if (isArrayIndex) {
+            run(depsMap.get("length"));
+          }
+          break;
+        case "delete":
+          if (!targetIsArray) {
+            run(depsMap.get(ITERATE_KEY));
+            if (isMap(target)) {
+              run(depsMap.get(MAP_KEY_ITERATE_KEY));
             }
-            code += 'html +=`' + t.tag + '`;\n';
-            if (t.isFor)
-                code += '}\n';
-            if (t.isIf)
-                code += '}\n';
+          }
+          break;
+        case "set":
+          if (isMap(target)) {
+            run(depsMap.get(ITERATE_KEY));
+          }
+          break;
+      }
+    }
+  }
+  endBatch();
+}
+
+function reactiveReadArray(array) {
+  const raw = toRaw(array);
+  if (raw === array) return raw;
+  return isShallow(array) ? raw : raw.map(toReactive);
+}
+function shallowReadArray(arr) {
+  track(arr = toRaw(arr));
+  return arr;
+}
+const arrayInstrumentations = {
+  __proto__: null,
+  [Symbol.iterator]() {
+    return iterator(this, Symbol.iterator, toReactive);
+  },
+  concat(...args) {
+    return reactiveReadArray(this).concat(
+      ...args.map((x) => isArray(x) ? reactiveReadArray(x) : x)
+    );
+  },
+  entries() {
+    return iterator(this, "entries", (value) => {
+      value[1] = toReactive(value[1]);
+      return value;
+    });
+  },
+  every(fn, thisArg) {
+    return apply(this, "every", fn, thisArg, void 0, arguments);
+  },
+  filter(fn, thisArg) {
+    return apply(this, "filter", fn, thisArg, (v) => v.map(toReactive), arguments);
+  },
+  find(fn, thisArg) {
+    return apply(this, "find", fn, thisArg, toReactive, arguments);
+  },
+  findIndex(fn, thisArg) {
+    return apply(this, "findIndex", fn, thisArg, void 0, arguments);
+  },
+  findLast(fn, thisArg) {
+    return apply(this, "findLast", fn, thisArg, toReactive, arguments);
+  },
+  findLastIndex(fn, thisArg) {
+    return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
+  },
+  // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
+  forEach(fn, thisArg) {
+    return apply(this, "forEach", fn, thisArg, void 0, arguments);
+  },
+  includes(...args) {
+    return searchProxy(this, "includes", args);
+  },
+  indexOf(...args) {
+    return searchProxy(this, "indexOf", args);
+  },
+  join(separator) {
+    return reactiveReadArray(this).join(separator);
+  },
+  // keys() iterator only reads `length`, no optimisation required
+  lastIndexOf(...args) {
+    return searchProxy(this, "lastIndexOf", args);
+  },
+  map(fn, thisArg) {
+    return apply(this, "map", fn, thisArg, void 0, arguments);
+  },
+  pop() {
+    return noTracking(this, "pop");
+  },
+  push(...args) {
+    return noTracking(this, "push", args);
+  },
+  reduce(fn, ...args) {
+    return reduce(this, "reduce", fn, args);
+  },
+  reduceRight(fn, ...args) {
+    return reduce(this, "reduceRight", fn, args);
+  },
+  shift() {
+    return noTracking(this, "shift");
+  },
+  // slice could use ARRAY_ITERATE but also seems to beg for range tracking
+  some(fn, thisArg) {
+    return apply(this, "some", fn, thisArg, void 0, arguments);
+  },
+  splice(...args) {
+    return noTracking(this, "splice", args);
+  },
+  toReversed() {
+    return reactiveReadArray(this).toReversed();
+  },
+  toSorted(comparer) {
+    return reactiveReadArray(this).toSorted(comparer);
+  },
+  toSpliced(...args) {
+    return reactiveReadArray(this).toSpliced(...args);
+  },
+  unshift(...args) {
+    return noTracking(this, "unshift", args);
+  },
+  values() {
+    return iterator(this, "values", toReactive);
+  }
+};
+function iterator(self, method, wrapValue) {
+  const arr = shallowReadArray(self);
+  const iter = arr[method]();
+  if (arr !== self && !isShallow(self)) {
+    iter._next = iter.next;
+    iter.next = () => {
+      const result = iter._next();
+      if (result.value) {
+        result.value = wrapValue(result.value);
+      }
+      return result;
+    };
+  }
+  return iter;
+}
+const arrayProto = Array.prototype;
+function apply(self, method, fn, thisArg, wrappedRetFn, args) {
+  const arr = shallowReadArray(self);
+  const needsWrap = arr !== self && !isShallow(self);
+  const methodFn = arr[method];
+  if (methodFn !== arrayProto[method]) {
+    const result2 = methodFn.apply(self, args);
+    return needsWrap ? toReactive(result2) : result2;
+  }
+  let wrappedFn = fn;
+  if (arr !== self) {
+    if (needsWrap) {
+      wrappedFn = function(item, index) {
+        return fn.call(this, toReactive(item), index, self);
+      };
+    } else if (fn.length > 2) {
+      wrappedFn = function(item, index) {
+        return fn.call(this, item, index, self);
+      };
+    }
+  }
+  const result = methodFn.call(arr, wrappedFn, thisArg);
+  return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
+}
+function reduce(self, method, fn, args) {
+  const arr = shallowReadArray(self);
+  let wrappedFn = fn;
+  if (arr !== self) {
+    if (!isShallow(self)) {
+      wrappedFn = function(acc, item, index) {
+        return fn.call(this, acc, toReactive(item), index, self);
+      };
+    } else if (fn.length > 3) {
+      wrappedFn = function(acc, item, index) {
+        return fn.call(this, acc, item, index, self);
+      };
+    }
+  }
+  return arr[method](wrappedFn, ...args);
+}
+function searchProxy(self, method, args) {
+  const arr = toRaw(self);
+  const res = arr[method](...args);
+  if ((res === -1 || res === false) && isProxy(args[0])) {
+    args[0] = toRaw(args[0]);
+    return arr[method](...args);
+  }
+  return res;
+}
+function noTracking(self, method, args = []) {
+  startBatch();
+  const res = toRaw(self)[method].apply(self, args);
+  endBatch();
+  return res;
+}
+
+const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
+const builtInSymbols = new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
+);
+function hasOwnProperty(key) {
+  if (!isSymbol(key)) key = String(key);
+  const obj = toRaw(this);
+  return obj.hasOwnProperty(key);
+}
+class BaseReactiveHandler {
+  constructor(_isReadonly = false, _isShallow = false) {
+    this._isReadonly = _isReadonly;
+    this._isShallow = _isShallow;
+  }
+  get(target, key, receiver) {
+    if (key === "__v_skip") return target["__v_skip"];
+    const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_isShallow") {
+      return isShallow2;
+    } else if (key === "__v_raw") {
+      if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
+      // this means the receiver is a user proxy of the reactive proxy
+      Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
+        return target;
+      }
+      return;
+    }
+    const targetIsArray = isArray(target);
+    if (!isReadonly2) {
+      let fn;
+      if (targetIsArray && (fn = arrayInstrumentations[key])) {
+        return fn;
+      }
+      if (key === "hasOwnProperty") {
+        return hasOwnProperty;
+      }
+    }
+    const res = Reflect.get(
+      target,
+      key,
+      // if this is a proxy wrapping a ref, return methods using the raw ref
+      // as receiver so that we don't have to call `toRaw` on the ref in all
+      // its class methods
+      isRef(target) ? target : receiver
+    );
+    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+      return res;
+    }
+    if (isShallow2) {
+      return res;
+    }
+    if (isRef(res)) {
+      return targetIsArray && isIntegerKey(key) ? res : res.value;
+    }
+    if (isObject(res)) {
+      return isReadonly2 ? readonly(res) : reactive(res);
+    }
+    return res;
+  }
+}
+class MutableReactiveHandler extends BaseReactiveHandler {
+  constructor(isShallow2 = false) {
+    super(false, isShallow2);
+  }
+  set(target, key, value, receiver) {
+    let oldValue = target[key];
+    if (!this._isShallow) {
+      const isOldValueReadonly = isReadonly(oldValue);
+      if (!isShallow(value) && !isReadonly(value)) {
+        oldValue = toRaw(oldValue);
+        value = toRaw(value);
+      }
+      if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
+        if (isOldValueReadonly) {
+          return false;
+        } else {
+          oldValue.value = value;
+          return true;
         }
-        else {
-            code += 'html +=`' + contentParse(content) + '`;\n';
-        }
-    }
-    return code;
-}
-// 解析模板
-// 1. 解析标签
-// 2. 替换内容
-// 3. 返回渲染结果
-// 4. 处理循环和条件
-// 5. 返回最终的HTML字符串
-// 6. 支持嵌套标签
-// 7. 支持条件渲染
-// 8. 支持循环渲染
-// 9. 支持数据绑定
-// 10. 支持内嵌样式绑定
-// 11. 支持类绑定
-function render(html, context) {
-    if (context === void 0) { context = {}; }
-    if (!Reflect.ownKeys(context).length)
-        return '';
-    var tags = resolver(html);
-    var code = compose(tags)
-        .replaceAll('<annotation>', '<!--')
-        .replaceAll('</annotation>', '-->');
-    var renderedContent = new Function("\n                let html = ''\n;\n                ".concat(code, "\n                return html;\n\n            "));
-    return renderedContent.call(context);
-}
-function replaceElementWithPlaceholder(el, placeholderText) {
-    if (placeholderText === void 0) { placeholderText = 'PLACEHOLDER'; }
-    var comment = document.createComment(placeholderText);
-    el.replaceWith(comment);
-    return comment; // 可以用于恢复
-}
-function rebuild(selector, context) {
-    var element = document.querySelector(selector);
-    if (!element)
-        return;
-    var outerHTML = element.outerHTML;
-    element.setAttribute('hidden', 'true');
-    var id = useId();
-    replaceElementWithPlaceholder(element, id);
-    var newHtml = render(outerHTML, context);
-    document.body.innerHTML = document.body.innerHTML.replace("<!--".concat(id, "-->"), newHtml);
-    element.setAttribute('hidden', 'false');
-}
-window.s = {
-    rebuild: rebuild,
-    render: render
+      }
+    }
+    const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
+    const result = Reflect.set(
+      target,
+      key,
+      value,
+      isRef(target) ? target : receiver
+    );
+    if (target === toRaw(receiver)) {
+      if (!hadKey) {
+        trigger(target, "add", key, value);
+      } else if (hasChanged(value, oldValue)) {
+        trigger(target, "set", key, value, oldValue);
+      }
+    }
+    return result;
+  }
+  deleteProperty(target, key) {
+    const hadKey = hasOwn(target, key);
+    const oldValue = target[key];
+    const result = Reflect.deleteProperty(target, key);
+    if (result && hadKey) {
+      trigger(target, "delete", key, void 0, oldValue);
+    }
+    return result;
+  }
+  has(target, key) {
+    const result = Reflect.has(target, key);
+    if (!isSymbol(key) || !builtInSymbols.has(key)) ;
+    return result;
+  }
+  ownKeys(target) {
+    return Reflect.ownKeys(target);
+  }
+}
+class ReadonlyReactiveHandler extends BaseReactiveHandler {
+  constructor(isShallow2 = false) {
+    super(true, isShallow2);
+  }
+  set(target, key) {
+    if (!!(process.env.NODE_ENV !== "production")) {
+      warn(
+        `Set operation on key "${String(key)}" failed: target is readonly.`,
+        target
+      );
+    }
+    return true;
+  }
+  deleteProperty(target, key) {
+    if (!!(process.env.NODE_ENV !== "production")) {
+      warn(
+        `Delete operation on key "${String(key)}" failed: target is readonly.`,
+        target
+      );
+    }
+    return true;
+  }
+}
+const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
+const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
+
+const toShallow = (value) => value;
+const getProto = (v) => Reflect.getPrototypeOf(v);
+function createIterableMethod(method, isReadonly2, isShallow2) {
+  return function(...args) {
+    const target = this["__v_raw"];
+    const rawTarget = toRaw(target);
+    const targetIsMap = isMap(rawTarget);
+    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+    const innerIterator = target[method](...args);
+    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+    return {
+      // iterator protocol
+      next() {
+        const { value, done } = innerIterator.next();
+        return done ? { value, done } : {
+          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+          done
+        };
+      },
+      // iterable protocol
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  };
+}
+function createReadonlyMethod(type) {
+  return function(...args) {
+    if (!!(process.env.NODE_ENV !== "production")) {
+      const key = args[0] ? `on key "${args[0]}" ` : ``;
+      warn(
+        `${capitalize(type)} operation ${key}failed: target is readonly.`,
+        toRaw(this)
+      );
+    }
+    return type === "delete" ? false : type === "clear" ? void 0 : this;
+  };
+}
+function createInstrumentations(readonly, shallow) {
+  const instrumentations = {
+    get(key) {
+      const target = this["__v_raw"];
+      const rawTarget = toRaw(target);
+      const rawKey = toRaw(key);
+      const { has } = getProto(rawTarget);
+      const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+      if (has.call(rawTarget, key)) {
+        return wrap(target.get(key));
+      } else if (has.call(rawTarget, rawKey)) {
+        return wrap(target.get(rawKey));
+      } else if (target !== rawTarget) {
+        target.get(key);
+      }
+    },
+    get size() {
+      const target = this["__v_raw"];
+      !readonly && track(toRaw(target));
+      return Reflect.get(target, "size", target);
+    },
+    has(key) {
+      const target = this["__v_raw"];
+      toRaw(target);
+      const rawKey = toRaw(key);
+      return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+    },
+    forEach(callback, thisArg) {
+      const observed = this;
+      const target = observed["__v_raw"];
+      toRaw(target);
+      const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+      return target.forEach((value, key) => {
+        return callback.call(thisArg, wrap(value), wrap(key), observed);
+      });
+    }
+  };
+  extend(
+    instrumentations,
+    readonly ? {
+      add: createReadonlyMethod("add"),
+      set: createReadonlyMethod("set"),
+      delete: createReadonlyMethod("delete"),
+      clear: createReadonlyMethod("clear")
+    } : {
+      add(value) {
+        if (!shallow && !isShallow(value) && !isReadonly(value)) {
+          value = toRaw(value);
+        }
+        const target = toRaw(this);
+        const proto = getProto(target);
+        const hadKey = proto.has.call(target, value);
+        if (!hadKey) {
+          target.add(value);
+          trigger(target, "add", value, value);
+        }
+        return this;
+      },
+      set(key, value) {
+        if (!shallow && !isShallow(value) && !isReadonly(value)) {
+          value = toRaw(value);
+        }
+        const target = toRaw(this);
+        const { has, get } = getProto(target);
+        let hadKey = has.call(target, key);
+        if (!hadKey) {
+          key = toRaw(key);
+          hadKey = has.call(target, key);
+        } else if (!!(process.env.NODE_ENV !== "production")) {
+          checkIdentityKeys(target, has, key);
+        }
+        const oldValue = get.call(target, key);
+        target.set(key, value);
+        if (!hadKey) {
+          trigger(target, "add", key, value);
+        } else if (hasChanged(value, oldValue)) {
+          trigger(target, "set", key, value, oldValue);
+        }
+        return this;
+      },
+      delete(key) {
+        const target = toRaw(this);
+        const { has, get } = getProto(target);
+        let hadKey = has.call(target, key);
+        if (!hadKey) {
+          key = toRaw(key);
+          hadKey = has.call(target, key);
+        } else if (!!(process.env.NODE_ENV !== "production")) {
+          checkIdentityKeys(target, has, key);
+        }
+        const oldValue = get ? get.call(target, key) : void 0;
+        const result = target.delete(key);
+        if (hadKey) {
+          trigger(target, "delete", key, void 0, oldValue);
+        }
+        return result;
+      },
+      clear() {
+        const target = toRaw(this);
+        const hadItems = target.size !== 0;
+        const oldTarget = !!(process.env.NODE_ENV !== "production") ? isMap(target) ? new Map(target) : new Set(target) : void 0;
+        const result = target.clear();
+        if (hadItems) {
+          trigger(
+            target,
+            "clear",
+            void 0,
+            void 0,
+            oldTarget
+          );
+        }
+        return result;
+      }
+    }
+  );
+  const iteratorMethods = [
+    "keys",
+    "values",
+    "entries",
+    Symbol.iterator
+  ];
+  iteratorMethods.forEach((method) => {
+    instrumentations[method] = createIterableMethod(method, readonly, shallow);
+  });
+  return instrumentations;
+}
+function createInstrumentationGetter(isReadonly2, shallow) {
+  const instrumentations = createInstrumentations(isReadonly2, shallow);
+  return (target, key, receiver) => {
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_raw") {
+      return target;
+    }
+    return Reflect.get(
+      hasOwn(instrumentations, key) && key in target ? instrumentations : target,
+      key,
+      receiver
+    );
+  };
+}
+const mutableCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
+};
+const readonlyCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
+};
+function checkIdentityKeys(target, has, key) {
+  const rawKey = toRaw(key);
+  if (rawKey !== key && has.call(target, rawKey)) {
+    const type = toRawType(target);
+    warn(
+      `Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`
+    );
+  }
+}
+
+const reactiveMap = /* @__PURE__ */ new WeakMap();
+const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+const readonlyMap = /* @__PURE__ */ new WeakMap();
+const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+function targetTypeMap(rawType) {
+  switch (rawType) {
+    case "Object":
+    case "Array":
+      return 1 /* COMMON */;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2 /* COLLECTION */;
+    default:
+      return 0 /* INVALID */;
+  }
+}
+function getTargetType(value) {
+  return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap(toRawType(value));
+}
+function reactive(target) {
+  if (isReadonly(target)) {
+    return target;
+  }
+  return createReactiveObject(
+    target,
+    false,
+    mutableHandlers,
+    mutableCollectionHandlers,
+    reactiveMap
+  );
+}
+function readonly(target) {
+  return createReactiveObject(
+    target,
+    true,
+    readonlyHandlers,
+    readonlyCollectionHandlers,
+    readonlyMap
+  );
+}
+function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+  if (!isObject(target)) {
+    if (!!(process.env.NODE_ENV !== "production")) {
+      warn(
+        `value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(
+          target
+        )}`
+      );
+    }
+    return target;
+  }
+  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
+    return target;
+  }
+  const targetType = getTargetType(target);
+  if (targetType === 0 /* INVALID */) {
+    return target;
+  }
+  const existingProxy = proxyMap.get(target);
+  if (existingProxy) {
+    return existingProxy;
+  }
+  const proxy = new Proxy(
+    target,
+    targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers
+  );
+  proxyMap.set(target, proxy);
+  return proxy;
+}
+function isReactive(value) {
+  if (isReadonly(value)) {
+    return isReactive(value["__v_raw"]);
+  }
+  return !!(value && value["__v_isReactive"]);
+}
+function isReadonly(value) {
+  return !!(value && value["__v_isReadonly"]);
+}
+function isShallow(value) {
+  return !!(value && value["__v_isShallow"]);
+}
+function isProxy(value) {
+  return value ? !!value["__v_raw"] : false;
+}
+function toRaw(observed) {
+  const raw = observed && observed["__v_raw"];
+  return raw ? toRaw(raw) : observed;
+}
+const toReactive = (value) => isObject(value) ? reactive(value) : value;
+const toReadonly = (value) => isObject(value) ? readonly(value) : value;
+
+function isRef(r) {
+  return r ? r["__v_isRef"] === true : false;
+}
+function ref(value) {
+  return createRef(value, false);
+}
+function createRef(rawValue, shallow) {
+  if (isRef(rawValue)) {
+    return rawValue;
+  }
+  return new RefImpl(rawValue, shallow);
+}
+class RefImpl {
+  constructor(value, isShallow2) {
+    this.dep = new Dep();
+    this["__v_isRef"] = true;
+    this["__v_isShallow"] = false;
+    this._rawValue = isShallow2 ? value : toRaw(value);
+    this._value = isShallow2 ? value : toReactive(value);
+    this["__v_isShallow"] = isShallow2;
+  }
+  get value() {
+    if (!!(process.env.NODE_ENV !== "production")) {
+      this.dep.track({
+        target: this,
+        type: "get",
+        key: "value"
+      });
+    } else {
+      this.dep.track();
+    }
+    return this._value;
+  }
+  set value(newValue) {
+    const oldValue = this._rawValue;
+    const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
+    newValue = useDirectValue ? newValue : toRaw(newValue);
+    if (hasChanged(newValue, oldValue)) {
+      this._rawValue = newValue;
+      this._value = useDirectValue ? newValue : toReactive(newValue);
+      if (!!(process.env.NODE_ENV !== "production")) {
+        this.dep.trigger({
+          target: this,
+          type: "set",
+          key: "value",
+          newValue,
+          oldValue
+        });
+      } else {
+        this.dep.trigger();
+      }
+    }
+  }
+}
+
+/**
+* @vue/runtime-core v3.5.18
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+
+const stack = [];
+function pushWarningContext(vnode) {
+  stack.push(vnode);
+}
+function popWarningContext() {
+  stack.pop();
+}
+let isWarning = false;
+function warn$1(msg, ...args) {
+  if (isWarning) return;
+  isWarning = true;
+  const instance = stack.length ? stack[stack.length - 1].component : null;
+  const appWarnHandler = instance && instance.appContext.config.warnHandler;
+  const trace = getComponentTrace();
+  if (appWarnHandler) {
+    callWithErrorHandling(
+      appWarnHandler,
+      instance,
+      11,
+      [
+        // eslint-disable-next-line no-restricted-syntax
+        msg + args.map((a) => {
+          var _a, _b;
+          return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
+        }).join(""),
+        instance && instance.proxy,
+        trace.map(
+          ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
+        ).join("\n"),
+        trace
+      ]
+    );
+  } else {
+    const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+    if (trace.length && // avoid spamming console during tests
+    true) {
+      warnArgs.push(`
+`, ...formatTrace(trace));
+    }
+    console.warn(...warnArgs);
+  }
+  isWarning = false;
+}
+function getComponentTrace() {
+  let currentVNode = stack[stack.length - 1];
+  if (!currentVNode) {
+    return [];
+  }
+  const normalizedStack = [];
+  while (currentVNode) {
+    const last = normalizedStack[0];
+    if (last && last.vnode === currentVNode) {
+      last.recurseCount++;
+    } else {
+      normalizedStack.push({
+        vnode: currentVNode,
+        recurseCount: 0
+      });
+    }
+    const parentInstance = currentVNode.component && currentVNode.component.parent;
+    currentVNode = parentInstance && parentInstance.vnode;
+  }
+  return normalizedStack;
+}
+function formatTrace(trace) {
+  const logs = [];
+  trace.forEach((entry, i) => {
+    logs.push(...i === 0 ? [] : [`
+`], ...formatTraceEntry(entry));
+  });
+  return logs;
+}
+function formatTraceEntry({ vnode, recurseCount }) {
+  const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+  const isRoot = vnode.component ? vnode.component.parent == null : false;
+  const open = ` at <${formatComponentName(
+    vnode.component,
+    vnode.type,
+    isRoot
+  )}`;
+  const close = `>` + postfix;
+  return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
+}
+function formatProps(props) {
+  const res = [];
+  const keys = Object.keys(props);
+  keys.slice(0, 3).forEach((key) => {
+    res.push(...formatProp(key, props[key]));
+  });
+  if (keys.length > 3) {
+    res.push(` ...`);
+  }
+  return res;
+}
+function formatProp(key, value, raw) {
+  if (isString(value)) {
+    value = JSON.stringify(value);
+    return raw ? value : [`${key}=${value}`];
+  } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
+    return raw ? value : [`${key}=${value}`];
+  } else if (isRef(value)) {
+    value = formatProp(key, toRaw(value.value), true);
+    return raw ? value : [`${key}=Ref<`, value, `>`];
+  } else if (isFunction(value)) {
+    return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+  } else {
+    value = toRaw(value);
+    return raw ? value : [`${key}=`, value];
+  }
+}
+const ErrorTypeStrings$1 = {
+  ["sp"]: "serverPrefetch hook",
+  ["bc"]: "beforeCreate hook",
+  ["c"]: "created hook",
+  ["bm"]: "beforeMount hook",
+  ["m"]: "mounted hook",
+  ["bu"]: "beforeUpdate hook",
+  ["u"]: "updated",
+  ["bum"]: "beforeUnmount hook",
+  ["um"]: "unmounted hook",
+  ["a"]: "activated hook",
+  ["da"]: "deactivated hook",
+  ["ec"]: "errorCaptured hook",
+  ["rtc"]: "renderTracked hook",
+  ["rtg"]: "renderTriggered hook",
+  [0]: "setup function",
+  [1]: "render function",
+  [2]: "watcher getter",
+  [3]: "watcher callback",
+  [4]: "watcher cleanup function",
+  [5]: "native event handler",
+  [6]: "component event handler",
+  [7]: "vnode hook",
+  [8]: "directive hook",
+  [9]: "transition hook",
+  [10]: "app errorHandler",
+  [11]: "app warnHandler",
+  [12]: "ref function",
+  [13]: "async component loader",
+  [14]: "scheduler flush",
+  [15]: "component update",
+  [16]: "app unmount cleanup function"
+};
+function callWithErrorHandling(fn, instance, type, args) {
+  try {
+    return args ? fn(...args) : fn();
+  } catch (err) {
+    handleError(err, instance, type);
+  }
+}
+function handleError(err, instance, type, throwInDev = true) {
+  const contextVNode = instance ? instance.vnode : null;
+  const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
+  if (instance) {
+    let cur = instance.parent;
+    const exposedInstance = instance.proxy;
+    const errorInfo = !!(process.env.NODE_ENV !== "production") ? ErrorTypeStrings$1[type] : `https://vuejs.org/error-reference/#runtime-${type}`;
+    while (cur) {
+      const errorCapturedHooks = cur.ec;
+      if (errorCapturedHooks) {
+        for (let i = 0; i < errorCapturedHooks.length; i++) {
+          if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+            return;
+          }
+        }
+      }
+      cur = cur.parent;
+    }
+    if (errorHandler) {
+      callWithErrorHandling(errorHandler, null, 10, [
+        err,
+        exposedInstance,
+        errorInfo
+      ]);
+      return;
+    }
+  }
+  logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
+}
+function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    const info = ErrorTypeStrings$1[type];
+    if (contextVNode) {
+      pushWarningContext(contextVNode);
+    }
+    warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+    if (contextVNode) {
+      popWarningContext();
+    }
+    if (throwInDev) {
+      throw err;
+    } else {
+      console.error(err);
+    }
+  } else if (throwInProd) {
+    throw err;
+  } else {
+    console.error(err);
+  }
+}
+
+const queue = [];
+let flushIndex = -1;
+const pendingPostFlushCbs = [];
+let activePostFlushCbs = null;
+let postFlushIndex = 0;
+const resolvedPromise = /* @__PURE__ */ Promise.resolve();
+let currentFlushPromise = null;
+const RECURSION_LIMIT = 100;
+function findInsertionIndex(id) {
+  let start = flushIndex + 1;
+  let end = queue.length;
+  while (start < end) {
+    const middle = start + end >>> 1;
+    const middleJob = queue[middle];
+    const middleJobId = getId(middleJob);
+    if (middleJobId < id || middleJobId === id && middleJob.flags & 2) {
+      start = middle + 1;
+    } else {
+      end = middle;
+    }
+  }
+  return start;
+}
+function queueJob(job) {
+  if (!(job.flags & 1)) {
+    const jobId = getId(job);
+    const lastJob = queue[queue.length - 1];
+    if (!lastJob || // fast path when the job id is larger than the tail
+    !(job.flags & 2) && jobId >= getId(lastJob)) {
+      queue.push(job);
+    } else {
+      queue.splice(findInsertionIndex(jobId), 0, job);
+    }
+    job.flags |= 1;
+    queueFlush();
+  }
+}
+function queueFlush() {
+  if (!currentFlushPromise) {
+    currentFlushPromise = resolvedPromise.then(flushJobs);
+  }
+}
+function queuePostFlushCb(cb) {
+  if (!isArray(cb)) {
+    if (activePostFlushCbs && cb.id === -1) {
+      activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
+    } else if (!(cb.flags & 1)) {
+      pendingPostFlushCbs.push(cb);
+      cb.flags |= 1;
+    }
+  } else {
+    pendingPostFlushCbs.push(...cb);
+  }
+  queueFlush();
+}
+function flushPostFlushCbs(seen) {
+  if (pendingPostFlushCbs.length) {
+    const deduped = [...new Set(pendingPostFlushCbs)].sort(
+      (a, b) => getId(a) - getId(b)
+    );
+    pendingPostFlushCbs.length = 0;
+    if (activePostFlushCbs) {
+      activePostFlushCbs.push(...deduped);
+      return;
+    }
+    activePostFlushCbs = deduped;
+    if (!!(process.env.NODE_ENV !== "production")) {
+      seen = seen || /* @__PURE__ */ new Map();
+    }
+    for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+      const cb = activePostFlushCbs[postFlushIndex];
+      if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates(seen, cb)) {
+        continue;
+      }
+      if (cb.flags & 4) {
+        cb.flags &= -2;
+      }
+      if (!(cb.flags & 8)) cb();
+      cb.flags &= -2;
+    }
+    activePostFlushCbs = null;
+    postFlushIndex = 0;
+  }
+}
+const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
+function flushJobs(seen) {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    seen = seen || /* @__PURE__ */ new Map();
+  }
+  const check = !!(process.env.NODE_ENV !== "production") ? (job) => checkRecursiveUpdates(seen, job) : NOOP;
+  try {
+    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+      const job = queue[flushIndex];
+      if (job && !(job.flags & 8)) {
+        if (!!(process.env.NODE_ENV !== "production") && check(job)) {
+          continue;
+        }
+        if (job.flags & 4) {
+          job.flags &= ~1;
+        }
+        callWithErrorHandling(
+          job,
+          job.i,
+          job.i ? 15 : 14
+        );
+        if (!(job.flags & 4)) {
+          job.flags &= ~1;
+        }
+      }
+    }
+  } finally {
+    for (; flushIndex < queue.length; flushIndex++) {
+      const job = queue[flushIndex];
+      if (job) {
+        job.flags &= -2;
+      }
+    }
+    flushIndex = -1;
+    queue.length = 0;
+    flushPostFlushCbs(seen);
+    currentFlushPromise = null;
+    if (queue.length || pendingPostFlushCbs.length) {
+      flushJobs(seen);
+    }
+  }
+}
+function checkRecursiveUpdates(seen, fn) {
+  const count = seen.get(fn) || 0;
+  if (count > RECURSION_LIMIT) {
+    const instance = fn.i;
+    const componentName = instance && getComponentName(instance.type);
+    handleError(
+      `Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`,
+      null,
+      10
+    );
+    return true;
+  }
+  seen.set(fn, count + 1);
+  return false;
+}
+const hmrDirtyComponents = /* @__PURE__ */ new Map();
+if (!!(process.env.NODE_ENV !== "production")) {
+  getGlobalThis().__VUE_HMR_RUNTIME__ = {
+    createRecord: tryWrap(createRecord),
+    rerender: tryWrap(rerender),
+    reload: tryWrap(reload)
+  };
+}
+const map = /* @__PURE__ */ new Map();
+function createRecord(id, initialDef) {
+  if (map.has(id)) {
+    return false;
+  }
+  map.set(id, {
+    initialDef: normalizeClassComponent(initialDef),
+    instances: /* @__PURE__ */ new Set()
+  });
+  return true;
+}
+function normalizeClassComponent(component) {
+  return isClassComponent(component) ? component.__vccOpts : component;
+}
+function rerender(id, newRender) {
+  const record = map.get(id);
+  if (!record) {
+    return;
+  }
+  record.initialDef.render = newRender;
+  [...record.instances].forEach((instance) => {
+    if (newRender) {
+      instance.render = newRender;
+      normalizeClassComponent(instance.type).render = newRender;
+    }
+    instance.renderCache = [];
+    instance.update();
+  });
+}
+function reload(id, newComp) {
+  const record = map.get(id);
+  if (!record) return;
+  newComp = normalizeClassComponent(newComp);
+  updateComponentDef(record.initialDef, newComp);
+  const instances = [...record.instances];
+  for (let i = 0; i < instances.length; i++) {
+    const instance = instances[i];
+    const oldComp = normalizeClassComponent(instance.type);
+    let dirtyInstances = hmrDirtyComponents.get(oldComp);
+    if (!dirtyInstances) {
+      if (oldComp !== record.initialDef) {
+        updateComponentDef(oldComp, newComp);
+      }
+      hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
+    }
+    dirtyInstances.add(instance);
+    instance.appContext.propsCache.delete(instance.type);
+    instance.appContext.emitsCache.delete(instance.type);
+    instance.appContext.optionsCache.delete(instance.type);
+    if (instance.ceReload) {
+      dirtyInstances.add(instance);
+      instance.ceReload(newComp.styles);
+      dirtyInstances.delete(instance);
+    } else if (instance.parent) {
+      queueJob(() => {
+        instance.parent.update();
+        dirtyInstances.delete(instance);
+      });
+    } else if (instance.appContext.reload) {
+      instance.appContext.reload();
+    } else if (typeof window !== "undefined") {
+      window.location.reload();
+    } else {
+      console.warn(
+        "[HMR] Root or manually mounted instance modified. Full reload required."
+      );
+    }
+    if (instance.root.ce && instance !== instance.root) {
+      instance.root.ce._removeChildStyle(oldComp);
+    }
+  }
+  queuePostFlushCb(() => {
+    hmrDirtyComponents.clear();
+  });
+}
+function updateComponentDef(oldComp, newComp) {
+  extend(oldComp, newComp);
+  for (const key in oldComp) {
+    if (key !== "__file" && !(key in newComp)) {
+      delete oldComp[key];
+    }
+  }
+}
+function tryWrap(fn) {
+  return (id, arg) => {
+    try {
+      return fn(id, arg);
+    } catch (e) {
+      console.error(e);
+      console.warn(
+        `[HMR] Something went wrong during Vue component hot-reload. Full reload required.`
+      );
+    }
+  };
+}
+
+let devtools$1;
+let buffer = [];
+function setDevtoolsHook$1(hook, target) {
+  var _a, _b;
+  devtools$1 = hook;
+  if (devtools$1) {
+    devtools$1.enabled = true;
+    buffer.forEach(({ event, args }) => devtools$1.emit(event, ...args));
+    buffer = [];
+  } else if (
+    // handle late devtools injection - only do this if we are in an actual
+    // browser environment to avoid the timer handle stalling test runner exit
+    // (#4815)
+    typeof window !== "undefined" && // some envs mock window but not fully
+    window.HTMLElement && // also exclude jsdom
+    // eslint-disable-next-line no-restricted-syntax
+    !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
+  ) {
+    const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
+    replay.push((newHook) => {
+      setDevtoolsHook$1(newHook, target);
+    });
+    setTimeout(() => {
+      if (!devtools$1) {
+        target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
+        buffer = [];
+      }
+    }, 3e3);
+  } else {
+    buffer = [];
+  }
+}
+
+let currentRenderingInstance = null;
+let currentScopeId = null;
+const isTeleport = (type) => type.__isTeleport;
+function setTransitionHooks(vnode, hooks) {
+  if (vnode.shapeFlag & 6 && vnode.component) {
+    vnode.transition = hooks;
+    setTransitionHooks(vnode.component.subTree, hooks);
+  } else if (vnode.shapeFlag & 128) {
+    vnode.ssContent.transition = hooks.clone(vnode.ssContent);
+    vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
+  } else {
+    vnode.transition = hooks;
+  }
+}
+
+getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb, 1));
+getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id));
+const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
+const PublicInstanceProxyHandlers = {
+  };
+if (!!(process.env.NODE_ENV !== "production") && true) {
+  PublicInstanceProxyHandlers.ownKeys = (target) => {
+    warn$1(
+      `Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead.`
+    );
+    return Reflect.ownKeys(target);
+  };
+}
+
+const internalObjectProto = {};
+const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
+
+const isSuspense = (type) => type.__isSuspense;
+
+const Fragment = Symbol.for("v-fgt");
+const Text = Symbol.for("v-txt");
+const Comment = Symbol.for("v-cmt");
+function isVNode(value) {
+  return value ? value.__v_isVNode === true : false;
+}
+const createVNodeWithArgsTransform = (...args) => {
+  return _createVNode(
+    ...args
+  );
 };
+const normalizeKey = ({ key }) => key != null ? key : null;
+const normalizeRef = ({
+  ref,
+  ref_key,
+  ref_for
+}) => {
+  if (typeof ref === "number") {
+    ref = "" + ref;
+  }
+  return ref != null ? isString(ref) || isRef(ref) || isFunction(ref) ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } : ref : null;
+};
+function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
+  const vnode = {
+    __v_isVNode: true,
+    __v_skip: true,
+    type,
+    props,
+    key: props && normalizeKey(props),
+    ref: props && normalizeRef(props),
+    scopeId: currentScopeId,
+    slotScopeIds: null,
+    children,
+    component: null,
+    suspense: null,
+    ssContent: null,
+    ssFallback: null,
+    dirs: null,
+    transition: null,
+    el: null,
+    anchor: null,
+    target: null,
+    targetStart: null,
+    targetAnchor: null,
+    staticCount: 0,
+    shapeFlag,
+    patchFlag,
+    dynamicProps,
+    dynamicChildren: null,
+    appContext: null,
+    ctx: currentRenderingInstance
+  };
+  if (needFullChildrenNormalization) {
+    normalizeChildren(vnode, children);
+    if (shapeFlag & 128) {
+      type.normalize(vnode);
+    }
+  } else if (children) {
+    vnode.shapeFlag |= isString(children) ? 8 : 16;
+  }
+  if (!!(process.env.NODE_ENV !== "production") && vnode.key !== vnode.key) {
+    warn$1(`VNode created with invalid key (NaN). VNode type:`, vnode.type);
+  }
+  return vnode;
+}
+const createVNode = !!(process.env.NODE_ENV !== "production") ? createVNodeWithArgsTransform : _createVNode;
+function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
+  if (!type || type === NULL_DYNAMIC_COMPONENT) {
+    if (!!(process.env.NODE_ENV !== "production") && !type) {
+      warn$1(`Invalid vnode type when creating vnode: ${type}.`);
+    }
+    type = Comment;
+  }
+  if (isVNode(type)) {
+    const cloned = cloneVNode(
+      type,
+      props,
+      true
+      /* mergeRef: true */
+    );
+    if (children) {
+      normalizeChildren(cloned, children);
+    }
+    cloned.patchFlag = -2;
+    return cloned;
+  }
+  if (isClassComponent(type)) {
+    type = type.__vccOpts;
+  }
+  if (props) {
+    props = guardReactiveProps(props);
+    let { class: klass, style } = props;
+    if (klass && !isString(klass)) {
+      props.class = normalizeClass(klass);
+    }
+    if (isObject(style)) {
+      if (isProxy(style) && !isArray(style)) {
+        style = extend({}, style);
+      }
+      props.style = normalizeStyle(style);
+    }
+  }
+  const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject(type) ? 4 : isFunction(type) ? 2 : 0;
+  if (!!(process.env.NODE_ENV !== "production") && shapeFlag & 4 && isProxy(type)) {
+    type = toRaw(type);
+    warn$1(
+      `Vue received a Component that was made a reactive object. This can lead to unnecessary performance overhead and should be avoided by marking the component with \`markRaw\` or using \`shallowRef\` instead of \`ref\`.`,
+      `
+Component that was made reactive: `,
+      type
+    );
+  }
+  return createBaseVNode(
+    type,
+    props,
+    children,
+    patchFlag,
+    dynamicProps,
+    shapeFlag,
+    isBlockNode,
+    true
+  );
+}
+function guardReactiveProps(props) {
+  if (!props) return null;
+  return isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
+}
+function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
+  const { props, ref, patchFlag, children, transition } = vnode;
+  const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
+  const cloned = {
+    __v_isVNode: true,
+    __v_skip: true,
+    type: vnode.type,
+    props: mergedProps,
+    key: mergedProps && normalizeKey(mergedProps),
+    ref: extraProps && extraProps.ref ? (
+      // #2078 in the case of <component :is="vnode" ref="extra"/>
+      // if the vnode itself already has a ref, cloneVNode will need to merge
+      // the refs so the single vnode can be set on multiple refs
+      mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps)
+    ) : ref,
+    scopeId: vnode.scopeId,
+    slotScopeIds: vnode.slotScopeIds,
+    children: !!(process.env.NODE_ENV !== "production") && patchFlag === -1 && isArray(children) ? children.map(deepCloneVNode) : children,
+    target: vnode.target,
+    targetStart: vnode.targetStart,
+    targetAnchor: vnode.targetAnchor,
+    staticCount: vnode.staticCount,
+    shapeFlag: vnode.shapeFlag,
+    // if the vnode is cloned with extra props, we can no longer assume its
+    // existing patch flag to be reliable and need to add the FULL_PROPS flag.
+    // note: preserve flag for fragments since they use the flag for children
+    // fast paths only.
+    patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
+    dynamicProps: vnode.dynamicProps,
+    dynamicChildren: vnode.dynamicChildren,
+    appContext: vnode.appContext,
+    dirs: vnode.dirs,
+    transition,
+    // These should technically only be non-null on mounted VNodes. However,
+    // they *should* be copied for kept-alive vnodes. So we just always copy
+    // them since them being non-null during a mount doesn't affect the logic as
+    // they will simply be overwritten.
+    component: vnode.component,
+    suspense: vnode.suspense,
+    ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
+    ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
+    placeholder: vnode.placeholder,
+    el: vnode.el,
+    anchor: vnode.anchor,
+    ctx: vnode.ctx,
+    ce: vnode.ce
+  };
+  if (transition && cloneTransition) {
+    setTransitionHooks(
+      cloned,
+      transition.clone(cloned)
+    );
+  }
+  return cloned;
+}
+function deepCloneVNode(vnode) {
+  const cloned = cloneVNode(vnode);
+  if (isArray(vnode.children)) {
+    cloned.children = vnode.children.map(deepCloneVNode);
+  }
+  return cloned;
+}
+function createTextVNode(text = " ", flag = 0) {
+  return createVNode(Text, null, text, flag);
+}
+function normalizeChildren(vnode, children) {
+  let type = 0;
+  const { shapeFlag } = vnode;
+  if (children == null) {
+    children = null;
+  } else if (isArray(children)) {
+    type = 16;
+  } else if (typeof children === "object") {
+    if (shapeFlag & (1 | 64)) {
+      const slot = children.default;
+      if (slot) {
+        slot._c && (slot._d = false);
+        normalizeChildren(vnode, slot());
+        slot._c && (slot._d = true);
+      }
+      return;
+    } else {
+      type = 32;
+      const slotFlag = children._;
+      if (!slotFlag && !isInternalObject(children)) {
+        children._ctx = currentRenderingInstance;
+      }
+    }
+  } else if (isFunction(children)) {
+    children = { default: children, _ctx: currentRenderingInstance };
+    type = 32;
+  } else {
+    children = String(children);
+    if (shapeFlag & 64) {
+      type = 16;
+      children = [createTextVNode(children)];
+    } else {
+      type = 8;
+    }
+  }
+  vnode.children = children;
+  vnode.shapeFlag |= type;
+}
+function mergeProps(...args) {
+  const ret = {};
+  for (let i = 0; i < args.length; i++) {
+    const toMerge = args[i];
+    for (const key in toMerge) {
+      if (key === "class") {
+        if (ret.class !== toMerge.class) {
+          ret.class = normalizeClass([ret.class, toMerge.class]);
+        }
+      } else if (key === "style") {
+        ret.style = normalizeStyle([ret.style, toMerge.style]);
+      } else if (isOn(key)) {
+        const existing = ret[key];
+        const incoming = toMerge[key];
+        if (incoming && existing !== incoming && !(isArray(existing) && existing.includes(incoming))) {
+          ret[key] = existing ? [].concat(existing, incoming) : incoming;
+        }
+      } else if (key !== "") {
+        ret[key] = toMerge[key];
+      }
+    }
+  }
+  return ret;
+}
+{
+  const g = getGlobalThis();
+  const registerGlobalSetter = (key, setter) => {
+    let setters;
+    if (!(setters = g[key])) setters = g[key] = [];
+    setters.push(setter);
+    return (v) => {
+      if (setters.length > 1) setters.forEach((set) => set(v));
+      else setters[0](v);
+    };
+  };
+  registerGlobalSetter(
+    `__VUE_INSTANCE_SETTERS__`,
+    (v) => v
+  );
+  registerGlobalSetter(
+    `__VUE_SSR_SETTERS__`,
+    (v) => v
+  );
+}
+!!(process.env.NODE_ENV !== "production") ? {
+  } : {
+  };
+const classifyRE = /(?:^|[-_])(\w)/g;
+const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
+function getComponentName(Component, includeInferred = true) {
+  return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
+}
+function formatComponentName(instance, Component, isRoot = false) {
+  let name = getComponentName(Component);
+  if (!name && Component.__file) {
+    const match = Component.__file.match(/([^/\\]+)\.\w+$/);
+    if (match) {
+      name = match[1];
+    }
+  }
+  if (!name && instance && instance.parent) {
+    const inferFromRegistry = (registry) => {
+      for (const key in registry) {
+        if (registry[key] === Component) {
+          return key;
+        }
+      }
+    };
+    name = inferFromRegistry(
+      instance.components || instance.parent.type.components
+    ) || inferFromRegistry(instance.appContext.components);
+  }
+  return name ? classify(name) : isRoot ? `App` : `Anonymous`;
+}
+function isClassComponent(value) {
+  return isFunction(value) && "__vccOpts" in value;
+}
+
+function initCustomFormatter() {
+  if (!!!(process.env.NODE_ENV !== "production") || typeof window === "undefined") {
+    return;
+  }
+  const vueStyle = { style: "color:#3ba776" };
+  const numberStyle = { style: "color:#1677ff" };
+  const stringStyle = { style: "color:#f5222d" };
+  const keywordStyle = { style: "color:#eb2f96" };
+  const formatter = {
+    __vue_custom_formatter: true,
+    header(obj) {
+      if (!isObject(obj)) {
+        return null;
+      }
+      if (obj.__isVue) {
+        return ["div", vueStyle, `VueInstance`];
+      } else if (isRef(obj)) {
+        const value = obj.value;
+        return [
+          "div",
+          {},
+          ["span", vueStyle, genRefFlag(obj)],
+          "<",
+          formatValue(value),
+          `>`
+        ];
+      } else if (isReactive(obj)) {
+        return [
+          "div",
+          {},
+          ["span", vueStyle, isShallow(obj) ? "ShallowReactive" : "Reactive"],
+          "<",
+          formatValue(obj),
+          `>${isReadonly(obj) ? ` (readonly)` : ``}`
+        ];
+      } else if (isReadonly(obj)) {
+        return [
+          "div",
+          {},
+          ["span", vueStyle, isShallow(obj) ? "ShallowReadonly" : "Readonly"],
+          "<",
+          formatValue(obj),
+          ">"
+        ];
+      }
+      return null;
+    },
+    hasBody(obj) {
+      return obj && obj.__isVue;
+    },
+    body(obj) {
+      if (obj && obj.__isVue) {
+        return [
+          "div",
+          {},
+          ...formatInstance(obj.$)
+        ];
+      }
+    }
+  };
+  function formatInstance(instance) {
+    const blocks = [];
+    if (instance.type.props && instance.props) {
+      blocks.push(createInstanceBlock("props", toRaw(instance.props)));
+    }
+    if (instance.setupState !== EMPTY_OBJ) {
+      blocks.push(createInstanceBlock("setup", instance.setupState));
+    }
+    if (instance.data !== EMPTY_OBJ) {
+      blocks.push(createInstanceBlock("data", toRaw(instance.data)));
+    }
+    const computed = extractKeys(instance, "computed");
+    if (computed) {
+      blocks.push(createInstanceBlock("computed", computed));
+    }
+    const injected = extractKeys(instance, "inject");
+    if (injected) {
+      blocks.push(createInstanceBlock("injected", injected));
+    }
+    blocks.push([
+      "div",
+      {},
+      [
+        "span",
+        {
+          style: keywordStyle.style + ";opacity:0.66"
+        },
+        "$ (internal): "
+      ],
+      ["object", { object: instance }]
+    ]);
+    return blocks;
+  }
+  function createInstanceBlock(type, target) {
+    target = extend({}, target);
+    if (!Object.keys(target).length) {
+      return ["span", {}];
+    }
+    return [
+      "div",
+      { style: "line-height:1.25em;margin-bottom:0.6em" },
+      [
+        "div",
+        {
+          style: "color:#476582"
+        },
+        type
+      ],
+      [
+        "div",
+        {
+          style: "padding-left:1.25em"
+        },
+        ...Object.keys(target).map((key) => {
+          return [
+            "div",
+            {},
+            ["span", keywordStyle, key + ": "],
+            formatValue(target[key], false)
+          ];
+        })
+      ]
+    ];
+  }
+  function formatValue(v, asRaw = true) {
+    if (typeof v === "number") {
+      return ["span", numberStyle, v];
+    } else if (typeof v === "string") {
+      return ["span", stringStyle, JSON.stringify(v)];
+    } else if (typeof v === "boolean") {
+      return ["span", keywordStyle, v];
+    } else if (isObject(v)) {
+      return ["object", { object: asRaw ? toRaw(v) : v }];
+    } else {
+      return ["span", stringStyle, String(v)];
+    }
+  }
+  function extractKeys(instance, type) {
+    const Comp = instance.type;
+    if (isFunction(Comp)) {
+      return;
+    }
+    const extracted = {};
+    for (const key in instance.ctx) {
+      if (isKeyOfType(Comp, key, type)) {
+        extracted[key] = instance.ctx[key];
+      }
+    }
+    return extracted;
+  }
+  function isKeyOfType(Comp, key, type) {
+    const opts = Comp[type];
+    if (isArray(opts) && opts.includes(key) || isObject(opts) && key in opts) {
+      return true;
+    }
+    if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {
+      return true;
+    }
+    if (Comp.mixins && Comp.mixins.some((m) => isKeyOfType(m, key, type))) {
+      return true;
+    }
+  }
+  function genRefFlag(v) {
+    if (isShallow(v)) {
+      return `ShallowRef`;
+    }
+    if (v.effect) {
+      return `ComputedRef`;
+    }
+    return `Ref`;
+  }
+  if (window.devtoolsFormatters) {
+    window.devtoolsFormatters.push(formatter);
+  } else {
+    window.devtoolsFormatters = [formatter];
+  }
+}
+!!(process.env.NODE_ENV !== "production") ? warn$1 : NOOP;
+!!(process.env.NODE_ENV !== "production") || true ? devtools$1 : void 0;
+!!(process.env.NODE_ENV !== "production") || true ? setDevtoolsHook$1 : NOOP;
+
+/**
+* vue v3.5.18
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+
+function initDev() {
+  {
+    initCustomFormatter();
+  }
+}
+
+if (!!(process.env.NODE_ENV !== "production")) {
+  initDev();
+}
 
 /**
  *
@@ -249,10 +2254,10 @@ function useCountDown(num, text) {
     if (text === void 0) { text = '发送验证码'; }
     var countdownNum = ref(num);
     var countdownText = ref(text);
-    var isDisabled = ref(false);
+    var disabled = ref(false);
     var send = function () {
         countdownText.value = "".concat(countdownNum.value, "s");
-        isDisabled.value = true;
+        disabled.value = true;
         var timer = setInterval(function () {
             countdownNum.value--;
             countdownText.value = "".concat(countdownNum.value, "s");
@@ -260,45 +2265,12 @@ function useCountDown(num, text) {
                 clearInterval(timer);
                 countdownNum.value = num;
                 countdownText.value = text;
-                isDisabled.value = false;
+                disabled.value = false;
             }
         }, 1000);
     };
-    return { countdownText: countdownText, isDisabled: isDisabled, send: send };
-}
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
+    return { countdownText: countdownText, disabled: disabled, send: send };
+}
 
 var RecordType;
 (function (RecordType) {
@@ -608,4 +2580,172 @@ function findTreeDataNodeName(dept, queryString, results) {
     }
 }
 
-export { HAS_FEILD, InputLegalityValidate, InputLengthValidate, LENGTH_LIMIT, LOGIN_TYPE, RecordType, dataHandler, debounce, deepMerge, findTreeDataNode, findTreeDataNodeName, isMobileDevice, isNull, objectArrayToString, throttle, useCountDown };
+var Mask = /** @class */ (function () {
+    function Mask(selectors, opacity) {
+        if (opacity === void 0) { opacity = 0.3; }
+        this.task = [];
+        this.selectors = [];
+        this.opacity = 0.3;
+        this.elementIndex = 0;
+        this.selectors = selectors;
+        this.opacity = opacity;
+    }
+    Mask.prototype.start = function () {
+        var _this = this;
+        this.task.reduce(function (pre, cur, index) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, pre];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, new Promise(function (resolve) {
+                                cur.callback(resolve, index);
+                            })];
+                    case 2:
+                        _a.sent();
+                        this.close();
+                        return [2 /*return*/];
+                }
+            });
+        }); }, Promise.resolve());
+    };
+    Mask.prototype.process = function (handle) {
+        var _this = this;
+        this.task.push({
+            callback: function (resolve, index) {
+                _this.elementIndex = index;
+                _this.open();
+                handle(resolve, index, document.querySelector(_this.selectors[index]));
+            }
+        });
+        return this;
+    };
+    Mask.prototype.open = function (element) {
+        if ((element === null || element === void 0 ? void 0 : element.nodeType) === Node.ELEMENT_NODE)
+            this.selectors.push(element);
+        var currentElement = document.querySelector(this.selectors[this.elementIndex]);
+        if (!currentElement)
+            return;
+        currentElement.style.position = 'relative';
+        currentElement.style.boxShadow = "1px 1px 0 100vw rgba(0, 0, 0, ".concat(this.opacity, ")");
+    };
+    Mask.prototype.close = function () {
+        var currentElement = document.querySelector(this.selectors[this.elementIndex]);
+        currentElement.style.removeProperty('position');
+        currentElement.style.removeProperty('box-shadow');
+    };
+    return Mask;
+}());
+
+var Tour = /** @class */ (function () {
+    function Tour(selectors) {
+        this.selectors = [];
+        this.elementIndex = 0;
+        this.tourTargetElement = null;
+        this.tourElement = null;
+        this.tourElementContentTemplate = "\n        <style>\n            .tour-content-title {\n                font-size: 16px;\n                font-weight: 500;\n            }\n\n            .tour-buttons {\n                display: flex;\n                justify-content: end;\n                margin-top: 14px;\n            }\n\n            .tour-prev, .tour-next {\n                padding: 4px;\n                min-width: 40px;\n                text-align: center;\n                border: 1px solid #000;\n                border-radius: 4px;\n                cursor: pointer;\n            }\n\n            .tour-next {\n                margin-left: 6px;\n            }\n        </style>\n        <div class=\"tour-content\">\n            <p class=\"tour-content-title\">\n                <$title>\n            </p>\n            <p class=\"tour-content-text\">\n                <$text>\n            </p>\n        </div>\n        <div class=\"tour-buttons\">\n            <div class=\"tour-prev\">prev</div>\n            <div class=\"tour-next\"><$next></div>\n        </div>\n    ";
+        this.placeholder = {
+            title: '<$title>',
+            text: '<$text>',
+            next: '<$next>',
+        };
+        this.config = {
+            prev: '.tour-prev',
+            next: '.tour-next',
+            nextText: 'next',
+            closeText: 'close',
+        };
+        this.selectors = selectors;
+        this.tourTargetElement = document.createElement('div');
+        this.tourElement = document.createElement('div');
+    }
+    Tour.prototype.setPlaceholder = function (placeholder) {
+        this.placeholder = placeholder;
+    };
+    Tour.prototype.setContentTemplate = function (template) {
+        this.tourElementContentTemplate = template;
+    };
+    Tour.prototype.setConfig = function (config) {
+        this.config = __assign(__assign({}, this.config), config);
+    };
+    Tour.prototype.start = function () {
+        var elementName = this.selectors[this.elementIndex].el;
+        var element = document.querySelector(elementName);
+        if (element instanceof HTMLElement)
+            this.layout(element);
+    };
+    Tour.prototype.layout = function (element) {
+        var _this = this;
+        var rect = element === null || element === void 0 ? void 0 : element.getBoundingClientRect();
+        var tourTargetElement = this.tourTargetElement;
+        var tourElement = this.tourElement;
+        if (!tourTargetElement || !tourElement)
+            return;
+        tourTargetElement.style.padding = '4px';
+        tourTargetElement.style.position = 'fixed';
+        tourTargetElement.style.top = "".concat((rect === null || rect === void 0 ? void 0 : rect.top) - 4, "px");
+        tourTargetElement.style.left = "".concat((rect === null || rect === void 0 ? void 0 : rect.left) - 4, "px");
+        tourTargetElement.style.width = "".concat(rect === null || rect === void 0 ? void 0 : rect.width, "px");
+        tourTargetElement.style.height = "".concat(rect === null || rect === void 0 ? void 0 : rect.height, "px");
+        tourTargetElement.style.zIndex = '60';
+        tourTargetElement.style.boxShadow = "1px 1px 0 1000vw rgba(0, 0, 0, 0.3)";
+        document.body.appendChild(tourTargetElement);
+        tourElement.style.padding = '16px';
+        tourElement.style.position = 'fixed';
+        tourElement.style.width = "200px";
+        tourElement.style.backgroundColor = '#fff';
+        tourElement.style.borderRadius = '4px';
+        tourElement.style.zIndex = '62';
+        tourElement.innerHTML = this.tourElementContentTemplate
+            .replace(this.placeholder.title, this.selectors[this.elementIndex].title)
+            .replace(this.placeholder.text, this.selectors[this.elementIndex].text)
+            .replace(this.placeholder.next, this.elementIndex === this.selectors.length - 1 ? this.config.closeText : this.config.nextText);
+        var prevButton = tourElement.querySelector(this.config.prev);
+        var nextButton = tourElement.querySelector(this.config.next);
+        prevButton === null || prevButton === void 0 ? void 0 : prevButton.addEventListener('click', function () {
+            _this.elementIndex--;
+            if (_this.elementIndex < 0)
+                _this.elementIndex = _this.selectors.length - 1;
+            _this.start();
+        });
+        nextButton === null || nextButton === void 0 ? void 0 : nextButton.addEventListener('click', function () {
+            _this.elementIndex++;
+            if (_this.elementIndex > _this.selectors.length - 1) {
+                _this.elementIndex = 0;
+                _this.close();
+                return;
+            }
+            _this.start();
+        });
+        document.body.appendChild(tourElement);
+        if (rect.bottom + 14 + tourElement.offsetHeight >= document.documentElement.clientHeight)
+            tourElement.style.top = "".concat((rect === null || rect === void 0 ? void 0 : rect.top) - tourElement.offsetHeight - 14, "px");
+        else
+            tourElement.style.top = "".concat((rect === null || rect === void 0 ? void 0 : rect.bottom) + 14, "px");
+        if (rect.left + tourElement.offsetWidth >= document.documentElement.clientWidth)
+            tourElement.style.left = "".concat((rect === null || rect === void 0 ? void 0 : rect.left) - tourElement.offsetWidth - 14, "px");
+        else
+            tourElement.style.left = "".concat((rect === null || rect === void 0 ? void 0 : rect.left) + 14, "px");
+    };
+    Tour.prototype.close = function () {
+        var tourElement = this.tourElement;
+        document.body.removeChild(tourElement);
+        document.body.removeChild(this.tourTargetElement);
+    };
+    return Tour;
+}());
+
+/**
+ * 匹配中文字母数字
+ */
+var ZN_LETTER_NUMBER = /^[\u4E00-\u9FA5\w]+$/;
+/**
+ * 匹配 IP
+ */
+var IP = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})$/;
+/**
+ * 匹配手机号
+ */
+var PHONE = /^1[3-9]\d{9}$/;
+
+export { HAS_FEILD, IP, InputLegalityValidate, InputLengthValidate, LENGTH_LIMIT, LOGIN_TYPE, Mask, PHONE, RecordType, Request, RequestChain, Tour, ZN_LETTER_NUMBER, dataHandler, debounce, deepMerge, findTreeDataNode, findTreeDataNodeName, isMobileDevice, isNull, objectArrayToString, throttle, useCountDown };