jwt-ui 1.0.7-8 → 1.0.8

package/lib/jwt-ui.common.js

@@ -9,11 +9,19 @@
 /* harmony export */   "HD": function() { return /* binding */ isString; },
 /* harmony export */   "Kn": function() { return /* binding */ isObject; },
 /* harmony export */   "RI": function() { return /* binding */ hasOwn; },
+/* harmony export */   "S0": function() { return /* binding */ isIntegerKey; },
+/* harmony export */   "W7": function() { return /* binding */ toRawType; },
 /* harmony export */   "_A": function() { return /* binding */ camelize; },
+/* harmony export */   "_N": function() { return /* binding */ isMap; },
+/* harmony export */   "aU": function() { return /* binding */ hasChanged; },
 /* harmony export */   "dG": function() { return /* binding */ NOOP; },
-/* harmony export */   "mf": function() { return /* binding */ isFunction; }
+/* harmony export */   "fY": function() { return /* binding */ makeMap; },
+/* harmony export */   "kJ": function() { return /* binding */ isArray; },
+/* harmony export */   "l7": function() { return /* binding */ extend; },
+/* harmony export */   "mf": function() { return /* binding */ isFunction; },
+/* harmony export */   "yk": function() { return /* binding */ isSymbol; }
 /* harmony export */ });
-/* unused harmony exports EMPTY_ARR, EMPTY_OBJ, NO, PatchFlagNames, capitalize, def, escapeHtml, escapeHtmlComment, extend, genPropsAccessExp, generateCodeFrame, getGlobalThis, hasChanged, hyphenate, includeBooleanAttr, invokeArrayFns, isArray, isBooleanAttr, isBuiltInDirective, isDate, isGloballyWhitelisted, isHTMLTag, isIntegerKey, isKnownHtmlAttr, isKnownSvgAttr, isMap, isModelListener, isNoUnitNumericStyleProp, isOn, isPlainObject, isPromise, isReservedProp, isSSRSafeAttrName, isSVGTag, isSet, isSpecialBooleanAttr, isSymbol, isVoidTag, looseEqual, looseIndexOf, makeMap, normalizeClass, normalizeProps, normalizeStyle, objectToString, parseStringStyle, propsToAttrMap, remove, slotFlagsText, stringifyStyle, toDisplayString, toHandlerKey, toNumber, toRawType, toTypeString */
+/* unused harmony exports EMPTY_ARR, EMPTY_OBJ, NO, PatchFlagNames, capitalize, def, escapeHtml, escapeHtmlComment, genPropsAccessExp, generateCodeFrame, getGlobalThis, hyphenate, includeBooleanAttr, invokeArrayFns, isBooleanAttr, isBuiltInDirective, isDate, isGloballyWhitelisted, isHTMLTag, isKnownHtmlAttr, isKnownSvgAttr, isModelListener, isNoUnitNumericStyleProp, isOn, isPlainObject, isPromise, isReservedProp, isSSRSafeAttrName, isSVGTag, isSet, isSpecialBooleanAttr, isVoidTag, looseEqual, looseIndexOf, normalizeClass, normalizeProps, normalizeStyle, objectToString, parseStringStyle, propsToAttrMap, remove, slotFlagsText, stringifyStyle, toDisplayString, toHandlerKey, toNumber, toTypeString */
 /**
  * Make a map and return a function for checking if a key
  * is in that map.
@@ -40034,7 +40042,7 @@ const __exports__ = /*#__PURE__*/(0,exportHelper/* default */.Z)(JwtCascaderArea
 
 /***/ }),
 
-/***/ 5462:
+/***/ 8007:
 /***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -40048,10 +40056,10 @@ __webpack_require__.d(__webpack_exports__, {
 
 // EXTERNAL MODULE: external {"commonjs":"vue","commonjs2":"vue","root":"Vue"}
 var external_commonjs_vue_commonjs2_vue_root_Vue_ = __webpack_require__(3797);
-;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/packages/JwtEditor/index.vue?vue&type=template&id=15382e44&scoped=true
+;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/packages/JwtEditor/index.vue?vue&type=template&id=0d651e8c&scoped=true
 
 
-const _withScopeId = n => (_pushScopeId("data-v-15382e44"), n = n(), _popScopeId(), n);
+const _withScopeId = n => (_pushScopeId("data-v-0d651e8c"), n = n(), _popScopeId(), n);
 
 const _hoisted_1 = {
   class: "base-wang-editor-wrapper",
@@ -40087,7 +40095,7 @@ function render(_ctx, _cache, $props, $setup, $data, $options) {
     onOnFocus: _ctx.handleFocus
   }, null, 8, ["default-config", "default-html", "mode", "onCustomAlert", "onOnBlur", "onOnChange", "onOnCreated", "onOnDestroyed", "onOnFocus"])]);
 }
-;// CONCATENATED MODULE: ./src/packages/JwtEditor/index.vue?vue&type=template&id=15382e44&scoped=true
+;// CONCATENATED MODULE: ./src/packages/JwtEditor/index.vue?vue&type=template&id=0d651e8c&scoped=true
 
 // EXTERNAL MODULE: ./node_modules/@wangeditor/editor/dist/index.esm.js
 var index_esm = __webpack_require__(7877);
@@ -40349,7 +40357,8 @@ var Toolbar = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
 
     const state = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.reactive)({
       // defaultHtml,
-      defaultContent
+      defaultContent,
+      initOnce: false
     });
     const toolbarConfig = {
       insertKeys: {
@@ -40448,6 +40457,7 @@ var Toolbar = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
       }); // 1.2 插入内容
 
       editor.dangerouslyInsertHtml(defaultHtml.value);
+      state.initOnce = true;
     }; // 替换附件里面的内容
 
 
@@ -40467,10 +40477,21 @@ var Toolbar = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
       return html;
     };
 
-    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
-      setTimeout(() => {
-        updateContent();
-      }, 200);
+    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(() => props.modelValue, newValue => {
+      // console.log('person变化了', newValue)
+      // 这里直接执行的话是在onBeforeMount之前所以放在nextTick一个微任务里面
+      (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
+        if (!state.initOnce) {
+          if (newValue && newValue !== '<p><br></p>') {
+            updateContent();
+          }
+        }
+      });
+    } // { immediate: true }
+    );
+    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {// setTimeout(() => {
+      //   updateContent();
+      // }, 200);
     }); // 组件销毁时，也及时销毁编辑器
 
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onBeforeUnmount)(() => {
@@ -40499,10 +40520,10 @@ var Toolbar = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
 }));
 ;// CONCATENATED MODULE: ./src/packages/JwtEditor/index.vue?vue&type=script&lang=js
  
-;// CONCATENATED MODULE: ./node_modules/mini-css-extract-plugin/dist/loader.js??clonedRuleSet-22.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-22.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-22.use[2]!./node_modules/sass-loader/dist/cjs.js??clonedRuleSet-22.use[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/packages/JwtEditor/index.vue?vue&type=style&index=0&id=15382e44&lang=scss&scoped=true
+;// CONCATENATED MODULE: ./node_modules/mini-css-extract-plugin/dist/loader.js??clonedRuleSet-22.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-22.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-22.use[2]!./node_modules/sass-loader/dist/cjs.js??clonedRuleSet-22.use[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/packages/JwtEditor/index.vue?vue&type=style&index=0&id=0d651e8c&lang=scss&scoped=true
 // extracted by mini-css-extract-plugin
 
-;// CONCATENATED MODULE: ./src/packages/JwtEditor/index.vue?vue&type=style&index=0&id=15382e44&lang=scss&scoped=true
+;// CONCATENATED MODULE: ./src/packages/JwtEditor/index.vue?vue&type=style&index=0&id=0d651e8c&lang=scss&scoped=true
 
 // EXTERNAL MODULE: ./node_modules/vue-loader/dist/exportHelper.js
 var exportHelper = __webpack_require__(3744);
@@ -40514,7 +40535,7 @@ var exportHelper = __webpack_require__(3744);
 ;
 
 
-const __exports__ = /*#__PURE__*/(0,exportHelper/* default */.Z)(JwtEditorvue_type_script_lang_js, [['render',render],['__scopeId',"data-v-15382e44"]])
+const __exports__ = /*#__PURE__*/(0,exportHelper/* default */.Z)(JwtEditorvue_type_script_lang_js, [['render',render],['__scopeId',"data-v-0d651e8c"]])
 
 /* harmony default export */ var JwtEditor = (__exports__);
 
@@ -41966,7 +41987,7 @@ const __exports__ = /*#__PURE__*/(0,exportHelper/* default */.Z)(JwtImagevue_typ
 
 /***/ }),
 
-/***/ 5859:
+/***/ 1914:
 /***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -41980,7 +42001,7 @@ __webpack_require__.d(__webpack_exports__, {
 
 // EXTERNAL MODULE: external {"commonjs":"vue","commonjs2":"vue","root":"Vue"}
 var external_commonjs_vue_commonjs2_vue_root_Vue_ = __webpack_require__(3797);
-;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/packages/JwtInput/index.vue?vue&type=template&id=172e66e8&scoped=true
+;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/packages/JwtInput/index.vue?vue&type=template&id=72e5e110&scoped=true
 
 function render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_el_input = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.resolveComponent)("el-input");
@@ -41997,7 +42018,7 @@ function render(_ctx, _cache, $props, $setup, $data, $options) {
     onBlur: _ctx.handleBlur
   }), null, 16, ["modelValue", "style", "onBlur"]);
 }
-;// CONCATENATED MODULE: ./src/packages/JwtInput/index.vue?vue&type=template&id=172e66e8&scoped=true
+;// CONCATENATED MODULE: ./src/packages/JwtInput/index.vue?vue&type=template&id=72e5e110&scoped=true
 
 ;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/packages/JwtInput/index.vue?vue&type=script&lang=js
 
@@ -42018,7 +42039,12 @@ function render(_ctx, _cache, $props, $setup, $data, $options) {
     changeBg: {
       type: String,
       default: 'blue'
-    } // 改变时背景颜色
+    },
+    // 改变时背景颜色
+    textColor: {
+      type: String,
+      default: ''
+    } // 文字颜色
 
   },
   emits: ['update:modelValue', 'blur'],
@@ -42057,10 +42083,10 @@ function render(_ctx, _cache, $props, $setup, $data, $options) {
 }));
 ;// CONCATENATED MODULE: ./src/packages/JwtInput/index.vue?vue&type=script&lang=js
  
-;// CONCATENATED MODULE: ./node_modules/mini-css-extract-plugin/dist/loader.js??clonedRuleSet-22.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-22.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-22.use[2]!./node_modules/sass-loader/dist/cjs.js??clonedRuleSet-22.use[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/packages/JwtInput/index.vue?vue&type=style&index=0&id=172e66e8&lang=scss&scoped=true
+;// CONCATENATED MODULE: ./node_modules/mini-css-extract-plugin/dist/loader.js??clonedRuleSet-22.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-22.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-22.use[2]!./node_modules/sass-loader/dist/cjs.js??clonedRuleSet-22.use[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/packages/JwtInput/index.vue?vue&type=style&index=0&id=72e5e110&lang=scss&scoped=true
 // extracted by mini-css-extract-plugin
 
-;// CONCATENATED MODULE: ./src/packages/JwtInput/index.vue?vue&type=style&index=0&id=172e66e8&lang=scss&scoped=true
+;// CONCATENATED MODULE: ./src/packages/JwtInput/index.vue?vue&type=style&index=0&id=72e5e110&lang=scss&scoped=true
 
 // EXTERNAL MODULE: ./node_modules/vue-loader/dist/exportHelper.js
 var exportHelper = __webpack_require__(3744);
@@ -42072,7 +42098,7 @@ var exportHelper = __webpack_require__(3744);
 ;
 
 
-const __exports__ = /*#__PURE__*/(0,exportHelper/* default */.Z)(JwtInputvue_type_script_lang_js, [['render',render],['__scopeId',"data-v-172e66e8"]])
+const __exports__ = /*#__PURE__*/(0,exportHelper/* default */.Z)(JwtInputvue_type_script_lang_js, [['render',render],['__scopeId',"data-v-72e5e110"]])
 
 /* harmony default export */ var JwtInput = (__exports__);
 
@@ -42461,7 +42487,7 @@ const __exports__ = /*#__PURE__*/(0,exportHelper/* default */.Z)(JwtSelectServer
 
 /***/ }),
 
-/***/ 4619:
+/***/ 4282:
 /***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -45394,42 +45420,6 @@ const focusNode = (el) => {
 
 //# sourceMappingURL=aria.mjs.map
 
-;// CONCATENATED MODULE: ./node_modules/element-plus/es/utils/dom/event.mjs
-const on = (element, event, handler, useCapture = false) => {
-  if (element && event && handler) {
-    element == null ? void 0 : element.addEventListener(event, handler, useCapture);
-  }
-};
-const off = (element, event, handler, useCapture = false) => {
-  if (element && event && handler) {
-    element == null ? void 0 : element.removeEventListener(event, handler, useCapture);
-  }
-};
-const once = (el, event, fn) => {
-  const listener = function(...args) {
-    if (fn) {
-      fn.apply(this, args);
-    }
-    off(el, event, listener);
-  };
-  on(el, event, listener);
-};
-const composeEventHandlers = (theirsHandler, oursHandler, { checkForDefaultPrevented = true } = {}) => {
-  const handleEvent = (event) => {
-    const shouldPrevent = theirsHandler == null ? void 0 : theirsHandler(event);
-    if (checkForDefaultPrevented === false || !shouldPrevent) {
-      return oursHandler == null ? void 0 : oursHandler(event);
-    }
-  };
-  return handleEvent;
-};
-const whenMouse = (handler) => {
-  return (e) => e.pointerType === "mouse" ? handler(e) : void 0;
-};
-
-
-//# sourceMappingURL=event.mjs.map
-
 ;// CONCATENATED MODULE: ./node_modules/element-plus/es/directives/trap-focus/index.mjs
 
 
@@ -45437,7 +45427,6 @@ const whenMouse = (handler) => {
 
 
 
-
 const FOCUSABLE_CHILDREN = "_trap-focus-children";
 const TRAP_FOCUS_HANDLER = "_trap-focus-handler";
 const FOCUS_STACK = [];
@@ -45473,7 +45462,7 @@ const TrapFocus = {
     el[FOCUSABLE_CHILDREN] = obtainAllFocusableElements(el);
     FOCUS_STACK.push(el);
     if (FOCUS_STACK.length <= 1) {
-      on(document, "keydown", FOCUS_HANDLER);
+      document.addEventListener("keydown", FOCUS_HANDLER);
     }
   },
   updated(el) {
@@ -45484,7 +45473,7 @@ const TrapFocus = {
   unmounted() {
     FOCUS_STACK.shift();
     if (FOCUS_STACK.length === 0) {
-      off(document, "keydown", FOCUS_HANDLER);
+      document.removeEventListener("keydown", FOCUS_HANDLER);
     }
   }
 };
@@ -45607,13 +45596,13 @@ const FOCUS_TRAP_INJECTION_KEY = Symbol("elFocusTrap");
 
 
 let registeredEscapeHandlers = [];
+const cachedHandler = (e) => {
+  const event = e;
+  if (event.key === aria/* EVENT_CODE.esc */.n.esc) {
+    registeredEscapeHandlers.forEach((registeredHandler) => registeredHandler(event));
+  }
+};
 const useEscapeKeydown = (handler) => {
-  const cachedHandler = (e) => {
-    const event = e;
-    if (event.key === aria/* EVENT_CODE.esc */.n.esc) {
-      registeredEscapeHandlers.forEach((registeredHandler) => registeredHandler(event));
-    }
-  };
   (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
     if (registeredEscapeHandlers.length === 0) {
       document.addEventListener("keydown", cachedHandler);
@@ -47480,6 +47469,1211 @@ const useDraggable = (targetRef, dragRef, draggable) => {
 
 //# sourceMappingURL=index.mjs.map
 
+;// CONCATENATED MODULE: ./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+
+
+function warn(msg, ...args) {
+    console.warn(`[Vue warn] ${msg}`, ...args);
+}
+
+let activeEffectScope;
+class EffectScope {
+    constructor(detached = false) {
+        /**
+         * @internal
+         */
+        this.active = true;
+        /**
+         * @internal
+         */
+        this.effects = [];
+        /**
+         * @internal
+         */
+        this.cleanups = [];
+        if (!detached && activeEffectScope) {
+            this.parent = activeEffectScope;
+            this.index =
+                (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
+        }
+    }
+    run(fn) {
+        if (this.active) {
+            const currentEffectScope = activeEffectScope;
+            try {
+                activeEffectScope = this;
+                return fn();
+            }
+            finally {
+                activeEffectScope = currentEffectScope;
+            }
+        }
+        else if ((false)) {}
+    }
+    /**
+     * This should only be called on non-detached scopes
+     * @internal
+     */
+    on() {
+        activeEffectScope = this;
+    }
+    /**
+     * This should only be called on non-detached scopes
+     * @internal
+     */
+    off() {
+        activeEffectScope = this.parent;
+    }
+    stop(fromParent) {
+        if (this.active) {
+            let i, l;
+            for (i = 0, l = this.effects.length; i < l; i++) {
+                this.effects[i].stop();
+            }
+            for (i = 0, l = this.cleanups.length; i < l; i++) {
+                this.cleanups[i]();
+            }
+            if (this.scopes) {
+                for (i = 0, l = this.scopes.length; i < l; i++) {
+                    this.scopes[i].stop(true);
+                }
+            }
+            // nested scope, dereference from parent to avoid memory leaks
+            if (this.parent && !fromParent) {
+                // optimized O(1) removal
+                const last = this.parent.scopes.pop();
+                if (last && last !== this) {
+                    this.parent.scopes[this.index] = last;
+                    last.index = this.index;
+                }
+            }
+            this.active = false;
+        }
+    }
+}
+function effectScope(detached) {
+    return new EffectScope(detached);
+}
+function recordEffectScope(effect, scope = activeEffectScope) {
+    if (scope && scope.active) {
+        scope.effects.push(effect);
+    }
+}
+function getCurrentScope() {
+    return activeEffectScope;
+}
+function onScopeDispose(fn) {
+    if (activeEffectScope) {
+        activeEffectScope.cleanups.push(fn);
+    }
+    else if ((false)) {}
+}
+
+const createDep = (effects) => {
+    const dep = new Set(effects);
+    dep.w = 0;
+    dep.n = 0;
+    return dep;
+};
+const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
+const newTracked = (dep) => (dep.n & trackOpBit) > 0;
+const initDepMarkers = ({ deps }) => {
+    if (deps.length) {
+        for (let i = 0; i < deps.length; i++) {
+            deps[i].w |= trackOpBit; // set was tracked
+        }
+    }
+};
+const finalizeDepMarkers = (effect) => {
+    const { deps } = effect;
+    if (deps.length) {
+        let ptr = 0;
+        for (let i = 0; i < deps.length; i++) {
+            const dep = deps[i];
+            if (wasTracked(dep) && !newTracked(dep)) {
+                dep.delete(effect);
+            }
+            else {
+                deps[ptr++] = dep;
+            }
+            // clear bits
+            dep.w &= ~trackOpBit;
+            dep.n &= ~trackOpBit;
+        }
+        deps.length = ptr;
+    }
+};
+
+const targetMap = new WeakMap();
+// The number of effects currently being tracked recursively.
+let effectTrackDepth = 0;
+let trackOpBit = 1;
+/**
+ * The bitwise track markers support at most 30 levels of recursion.
+ * This value is chosen to enable modern JS engines to use a SMI on all platforms.
+ * When recursion depth is greater, fall back to using a full cleanup.
+ */
+const maxMarkerBits = 30;
+let activeEffect;
+const ITERATE_KEY = Symbol(( false) ? 0 : '');
+const MAP_KEY_ITERATE_KEY = Symbol(( false) ? 0 : '');
+class ReactiveEffect {
+    constructor(fn, scheduler = null, scope) {
+        this.fn = fn;
+        this.scheduler = scheduler;
+        this.active = true;
+        this.deps = [];
+        this.parent = undefined;
+        recordEffectScope(this, scope);
+    }
+    run() {
+        if (!this.active) {
+            return this.fn();
+        }
+        let parent = activeEffect;
+        let lastShouldTrack = shouldTrack;
+        while (parent) {
+            if (parent === this) {
+                return;
+            }
+            parent = parent.parent;
+        }
+        try {
+            this.parent = activeEffect;
+            activeEffect = this;
+            shouldTrack = true;
+            trackOpBit = 1 << ++effectTrackDepth;
+            if (effectTrackDepth <= maxMarkerBits) {
+                initDepMarkers(this);
+            }
+            else {
+                cleanupEffect(this);
+            }
+            return this.fn();
+        }
+        finally {
+            if (effectTrackDepth <= maxMarkerBits) {
+                finalizeDepMarkers(this);
+            }
+            trackOpBit = 1 << --effectTrackDepth;
+            activeEffect = this.parent;
+            shouldTrack = lastShouldTrack;
+            this.parent = undefined;
+            if (this.deferStop) {
+                this.stop();
+            }
+        }
+    }
+    stop() {
+        // stopped while running itself - defer the cleanup
+        if (activeEffect === this) {
+            this.deferStop = true;
+        }
+        else if (this.active) {
+            cleanupEffect(this);
+            if (this.onStop) {
+                this.onStop();
+            }
+            this.active = false;
+        }
+    }
+}
+function cleanupEffect(effect) {
+    const { deps } = effect;
+    if (deps.length) {
+        for (let i = 0; i < deps.length; i++) {
+            deps[i].delete(effect);
+        }
+        deps.length = 0;
+    }
+}
+function effect(fn, options) {
+    if (fn.effect) {
+        fn = fn.effect.fn;
+    }
+    const _effect = new ReactiveEffect(fn);
+    if (options) {
+        extend(_effect, options);
+        if (options.scope)
+            recordEffectScope(_effect, options.scope);
+    }
+    if (!options || !options.lazy) {
+        _effect.run();
+    }
+    const runner = _effect.run.bind(_effect);
+    runner.effect = _effect;
+    return runner;
+}
+function stop(runner) {
+    runner.effect.stop();
+}
+let shouldTrack = true;
+const trackStack = [];
+function pauseTracking() {
+    trackStack.push(shouldTrack);
+    shouldTrack = false;
+}
+function enableTracking() {
+    trackStack.push(shouldTrack);
+    shouldTrack = true;
+}
+function resetTracking() {
+    const last = trackStack.pop();
+    shouldTrack = last === undefined ? true : last;
+}
+function track(target, type, key) {
+    if (shouldTrack && activeEffect) {
+        let depsMap = targetMap.get(target);
+        if (!depsMap) {
+            targetMap.set(target, (depsMap = new Map()));
+        }
+        let dep = depsMap.get(key);
+        if (!dep) {
+            depsMap.set(key, (dep = createDep()));
+        }
+        const eventInfo = ( false)
+            ? 0
+            : undefined;
+        trackEffects(dep, eventInfo);
+    }
+}
+function trackEffects(dep, debuggerEventExtraInfo) {
+    let shouldTrack = false;
+    if (effectTrackDepth <= maxMarkerBits) {
+        if (!newTracked(dep)) {
+            dep.n |= trackOpBit; // set newly tracked
+            shouldTrack = !wasTracked(dep);
+        }
+    }
+    else {
+        // Full cleanup mode.
+        shouldTrack = !dep.has(activeEffect);
+    }
+    if (shouldTrack) {
+        dep.add(activeEffect);
+        activeEffect.deps.push(dep);
+        if (false) {}
+    }
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+    const depsMap = targetMap.get(target);
+    if (!depsMap) {
+        // never been tracked
+        return;
+    }
+    let deps = [];
+    if (type === "clear" /* CLEAR */) {
+        // collection being cleared
+        // trigger all effects for target
+        deps = [...depsMap.values()];
+    }
+    else if (key === 'length' && (0,shared_esm_bundler/* isArray */.kJ)(target)) {
+        depsMap.forEach((dep, key) => {
+            if (key === 'length' || key >= newValue) {
+                deps.push(dep);
+            }
+        });
+    }
+    else {
+        // schedule runs for SET | ADD | DELETE
+        if (key !== void 0) {
+            deps.push(depsMap.get(key));
+        }
+        // also run for iteration key on ADD | DELETE | Map.SET
+        switch (type) {
+            case "add" /* ADD */:
+                if (!(0,shared_esm_bundler/* isArray */.kJ)(target)) {
+                    deps.push(depsMap.get(ITERATE_KEY));
+                    if ((0,shared_esm_bundler/* isMap */._N)(target)) {
+                        deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+                    }
+                }
+                else if ((0,shared_esm_bundler/* isIntegerKey */.S0)(key)) {
+                    // new index added to array -> length changes
+                    deps.push(depsMap.get('length'));
+                }
+                break;
+            case "delete" /* DELETE */:
+                if (!(0,shared_esm_bundler/* isArray */.kJ)(target)) {
+                    deps.push(depsMap.get(ITERATE_KEY));
+                    if ((0,shared_esm_bundler/* isMap */._N)(target)) {
+                        deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+                    }
+                }
+                break;
+            case "set" /* SET */:
+                if ((0,shared_esm_bundler/* isMap */._N)(target)) {
+                    deps.push(depsMap.get(ITERATE_KEY));
+                }
+                break;
+        }
+    }
+    const eventInfo = ( false)
+        ? 0
+        : undefined;
+    if (deps.length === 1) {
+        if (deps[0]) {
+            if ((false)) {}
+            else {
+                triggerEffects(deps[0]);
+            }
+        }
+    }
+    else {
+        const effects = [];
+        for (const dep of deps) {
+            if (dep) {
+                effects.push(...dep);
+            }
+        }
+        if ((false)) {}
+        else {
+            triggerEffects(createDep(effects));
+        }
+    }
+}
+function triggerEffects(dep, debuggerEventExtraInfo) {
+    // spread into array for stabilization
+    const effects = (0,shared_esm_bundler/* isArray */.kJ)(dep) ? dep : [...dep];
+    for (const effect of effects) {
+        if (effect.computed) {
+            triggerEffect(effect, debuggerEventExtraInfo);
+        }
+    }
+    for (const effect of effects) {
+        if (!effect.computed) {
+            triggerEffect(effect, debuggerEventExtraInfo);
+        }
+    }
+}
+function triggerEffect(effect, debuggerEventExtraInfo) {
+    if (effect !== activeEffect || effect.allowRecurse) {
+        if (false) {}
+        if (effect.scheduler) {
+            effect.scheduler();
+        }
+        else {
+            effect.run();
+        }
+    }
+}
+
+const isNonTrackableKeys = /*#__PURE__*/ (0,shared_esm_bundler/* makeMap */.fY)(`__proto__,__v_isRef,__isVue`);
+const builtInSymbols = new Set(
+/*#__PURE__*/
+Object.getOwnPropertyNames(Symbol)
+    // ios10.x Object.getOwnPropertyNames(Symbol) can enumerate 'arguments' and 'caller'
+    // but accessing them on Symbol leads to TypeError because Symbol is a strict mode
+    // function
+    .filter(key => key !== 'arguments' && key !== 'caller')
+    .map(key => Symbol[key])
+    .filter(shared_esm_bundler/* isSymbol */.yk));
+const reactivity_esm_bundler_get = /*#__PURE__*/ createGetter();
+const shallowGet = /*#__PURE__*/ createGetter(false, true);
+const readonlyGet = /*#__PURE__*/ createGetter(true);
+const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
+const arrayInstrumentations = /*#__PURE__*/ createArrayInstrumentations();
+function createArrayInstrumentations() {
+    const instrumentations = {};
+    ['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
+        instrumentations[key] = function (...args) {
+            const arr = toRaw(this);
+            for (let i = 0, l = this.length; i < l; i++) {
+                track(arr, "get" /* GET */, i + '');
+            }
+            // we run the method using the original args first (which may be reactive)
+            const res = arr[key](...args);
+            if (res === -1 || res === false) {
+                // if that didn't work, run it again using raw values.
+                return arr[key](...args.map(toRaw));
+            }
+            else {
+                return res;
+            }
+        };
+    });
+    ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
+        instrumentations[key] = function (...args) {
+            pauseTracking();
+            const res = toRaw(this)[key].apply(this, args);
+            resetTracking();
+            return res;
+        };
+    });
+    return instrumentations;
+}
+function createGetter(isReadonly = false, shallow = false) {
+    return function get(target, key, receiver) {
+        if (key === "__v_isReactive" /* IS_REACTIVE */) {
+            return !isReadonly;
+        }
+        else if (key === "__v_isReadonly" /* IS_READONLY */) {
+            return isReadonly;
+        }
+        else if (key === "__v_isShallow" /* IS_SHALLOW */) {
+            return shallow;
+        }
+        else if (key === "__v_raw" /* RAW */ &&
+            receiver ===
+                (isReadonly
+                    ? shallow
+                        ? shallowReadonlyMap
+                        : readonlyMap
+                    : shallow
+                        ? shallowReactiveMap
+                        : reactiveMap).get(target)) {
+            return target;
+        }
+        const targetIsArray = (0,shared_esm_bundler/* isArray */.kJ)(target);
+        if (!isReadonly && targetIsArray && (0,shared_esm_bundler/* hasOwn */.RI)(arrayInstrumentations, key)) {
+            return Reflect.get(arrayInstrumentations, key, receiver);
+        }
+        const res = Reflect.get(target, key, receiver);
+        if ((0,shared_esm_bundler/* isSymbol */.yk)(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+            return res;
+        }
+        if (!isReadonly) {
+            track(target, "get" /* GET */, key);
+        }
+        if (shallow) {
+            return res;
+        }
+        if (isRef(res)) {
+            // ref unwrapping - skip unwrap for Array + integer key.
+            return targetIsArray && (0,shared_esm_bundler/* isIntegerKey */.S0)(key) ? res : res.value;
+        }
+        if ((0,shared_esm_bundler/* isObject */.Kn)(res)) {
+            // Convert returned value into a proxy as well. we do the isObject check
+            // here to avoid invalid value warning. Also need to lazy access readonly
+            // and reactive here to avoid circular dependency.
+            return isReadonly ? readonly(res) : reactive(res);
+        }
+        return res;
+    };
+}
+const set = /*#__PURE__*/ createSetter();
+const shallowSet = /*#__PURE__*/ createSetter(true);
+function createSetter(shallow = false) {
+    return function set(target, key, value, receiver) {
+        let oldValue = target[key];
+        if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
+            return false;
+        }
+        if (!shallow && !isReadonly(value)) {
+            if (!isShallow(value)) {
+                value = toRaw(value);
+                oldValue = toRaw(oldValue);
+            }
+            if (!(0,shared_esm_bundler/* isArray */.kJ)(target) && isRef(oldValue) && !isRef(value)) {
+                oldValue.value = value;
+                return true;
+            }
+        }
+        const hadKey = (0,shared_esm_bundler/* isArray */.kJ)(target) && (0,shared_esm_bundler/* isIntegerKey */.S0)(key)
+            ? Number(key) < target.length
+            : (0,shared_esm_bundler/* hasOwn */.RI)(target, key);
+        const result = Reflect.set(target, key, value, receiver);
+        // don't trigger if target is something up in the prototype chain of original
+        if (target === toRaw(receiver)) {
+            if (!hadKey) {
+                trigger(target, "add" /* ADD */, key, value);
+            }
+            else if ((0,shared_esm_bundler/* hasChanged */.aU)(value, oldValue)) {
+                trigger(target, "set" /* SET */, key, value, oldValue);
+            }
+        }
+        return result;
+    };
+}
+function deleteProperty(target, key) {
+    const hadKey = (0,shared_esm_bundler/* hasOwn */.RI)(target, key);
+    const oldValue = target[key];
+    const result = Reflect.deleteProperty(target, key);
+    if (result && hadKey) {
+        trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
+    }
+    return result;
+}
+function has(target, key) {
+    const result = Reflect.has(target, key);
+    if (!(0,shared_esm_bundler/* isSymbol */.yk)(key) || !builtInSymbols.has(key)) {
+        track(target, "has" /* HAS */, key);
+    }
+    return result;
+}
+function ownKeys(target) {
+    track(target, "iterate" /* ITERATE */, (0,shared_esm_bundler/* isArray */.kJ)(target) ? 'length' : ITERATE_KEY);
+    return Reflect.ownKeys(target);
+}
+const mutableHandlers = {
+    get: reactivity_esm_bundler_get,
+    set,
+    deleteProperty,
+    has,
+    ownKeys
+};
+const readonlyHandlers = {
+    get: readonlyGet,
+    set(target, key) {
+        if ((false)) {}
+        return true;
+    },
+    deleteProperty(target, key) {
+        if ((false)) {}
+        return true;
+    }
+};
+const shallowReactiveHandlers = /*#__PURE__*/ (0,shared_esm_bundler/* extend */.l7)({}, mutableHandlers, {
+    get: shallowGet,
+    set: shallowSet
+});
+// Props handlers are special in the sense that it should not unwrap top-level
+// refs (in order to allow refs to be explicitly passed down), but should
+// retain the reactivity of the normal readonly object.
+const shallowReadonlyHandlers = /*#__PURE__*/ (0,shared_esm_bundler/* extend */.l7)({}, readonlyHandlers, {
+    get: shallowReadonlyGet
+});
+
+const toShallow = (value) => value;
+const getProto = (v) => Reflect.getPrototypeOf(v);
+function get$1(target, key, isReadonly = false, isShallow = false) {
+    // #1772: readonly(reactive(Map)) should return readonly + reactive version
+    // of the value
+    target = target["__v_raw" /* RAW */];
+    const rawTarget = toRaw(target);
+    const rawKey = toRaw(key);
+    if (!isReadonly) {
+        if (key !== rawKey) {
+            track(rawTarget, "get" /* GET */, key);
+        }
+        track(rawTarget, "get" /* GET */, rawKey);
+    }
+    const { has } = getProto(rawTarget);
+    const wrap = isShallow ? toShallow : isReadonly ? 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) {
+        // #3602 readonly(reactive(Map))
+        // ensure that the nested reactive `Map` can do tracking for itself
+        target.get(key);
+    }
+}
+function has$1(key, isReadonly = false) {
+    const target = this["__v_raw" /* RAW */];
+    const rawTarget = toRaw(target);
+    const rawKey = toRaw(key);
+    if (!isReadonly) {
+        if (key !== rawKey) {
+            track(rawTarget, "has" /* HAS */, key);
+        }
+        track(rawTarget, "has" /* HAS */, rawKey);
+    }
+    return key === rawKey
+        ? target.has(key)
+        : target.has(key) || target.has(rawKey);
+}
+function reactivity_esm_bundler_size(target, isReadonly = false) {
+    target = target["__v_raw" /* RAW */];
+    !isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY);
+    return Reflect.get(target, 'size', target);
+}
+function add(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" /* ADD */, value, value);
+    }
+    return this;
+}
+function set$1(key, 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 ((false)) {}
+    const oldValue = get.call(target, key);
+    target.set(key, value);
+    if (!hadKey) {
+        trigger(target, "add" /* ADD */, key, value);
+    }
+    else if ((0,shared_esm_bundler/* hasChanged */.aU)(value, oldValue)) {
+        trigger(target, "set" /* SET */, key, value, oldValue);
+    }
+    return this;
+}
+function deleteEntry(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 ((false)) {}
+    const oldValue = get ? get.call(target, key) : undefined;
+    // forward the operation before queueing reactions
+    const result = target.delete(key);
+    if (hadKey) {
+        trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
+    }
+    return result;
+}
+function clear() {
+    const target = toRaw(this);
+    const hadItems = target.size !== 0;
+    const oldTarget = ( false)
+        ? 0
+        : undefined;
+    // forward the operation before queueing reactions
+    const result = target.clear();
+    if (hadItems) {
+        trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget);
+    }
+    return result;
+}
+function createForEach(isReadonly, isShallow) {
+    return function forEach(callback, thisArg) {
+        const observed = this;
+        const target = observed["__v_raw" /* RAW */];
+        const rawTarget = toRaw(target);
+        const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+        !isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY);
+        return target.forEach((value, key) => {
+            // important: make sure the callback is
+            // 1. invoked with the reactive map as `this` and 3rd arg
+            // 2. the value received should be a corresponding reactive/readonly.
+            return callback.call(thisArg, wrap(value), wrap(key), observed);
+        });
+    };
+}
+function createIterableMethod(method, isReadonly, isShallow) {
+    return function (...args) {
+        const target = this["__v_raw" /* RAW */];
+        const rawTarget = toRaw(target);
+        const targetIsMap = (0,shared_esm_bundler/* isMap */._N)(rawTarget);
+        const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
+        const isKeyOnly = method === 'keys' && targetIsMap;
+        const innerIterator = target[method](...args);
+        const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+        !isReadonly &&
+            track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
+        // return a wrapped iterator which returns observed versions of the
+        // values emitted from the real iterator
+        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 ((false)) {}
+        return type === "delete" /* DELETE */ ? false : this;
+    };
+}
+function createInstrumentations() {
+    const mutableInstrumentations = {
+        get(key) {
+            return get$1(this, key);
+        },
+        get size() {
+            return reactivity_esm_bundler_size(this);
+        },
+        has: has$1,
+        add,
+        set: set$1,
+        delete: deleteEntry,
+        clear,
+        forEach: createForEach(false, false)
+    };
+    const shallowInstrumentations = {
+        get(key) {
+            return get$1(this, key, false, true);
+        },
+        get size() {
+            return reactivity_esm_bundler_size(this);
+        },
+        has: has$1,
+        add,
+        set: set$1,
+        delete: deleteEntry,
+        clear,
+        forEach: createForEach(false, true)
+    };
+    const readonlyInstrumentations = {
+        get(key) {
+            return get$1(this, key, true);
+        },
+        get size() {
+            return reactivity_esm_bundler_size(this, true);
+        },
+        has(key) {
+            return has$1.call(this, key, true);
+        },
+        add: createReadonlyMethod("add" /* ADD */),
+        set: createReadonlyMethod("set" /* SET */),
+        delete: createReadonlyMethod("delete" /* DELETE */),
+        clear: createReadonlyMethod("clear" /* CLEAR */),
+        forEach: createForEach(true, false)
+    };
+    const shallowReadonlyInstrumentations = {
+        get(key) {
+            return get$1(this, key, true, true);
+        },
+        get size() {
+            return reactivity_esm_bundler_size(this, true);
+        },
+        has(key) {
+            return has$1.call(this, key, true);
+        },
+        add: createReadonlyMethod("add" /* ADD */),
+        set: createReadonlyMethod("set" /* SET */),
+        delete: createReadonlyMethod("delete" /* DELETE */),
+        clear: createReadonlyMethod("clear" /* CLEAR */),
+        forEach: createForEach(true, true)
+    };
+    const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
+    iteratorMethods.forEach(method => {
+        mutableInstrumentations[method] = createIterableMethod(method, false, false);
+        readonlyInstrumentations[method] = createIterableMethod(method, true, false);
+        shallowInstrumentations[method] = createIterableMethod(method, false, true);
+        shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
+    });
+    return [
+        mutableInstrumentations,
+        readonlyInstrumentations,
+        shallowInstrumentations,
+        shallowReadonlyInstrumentations
+    ];
+}
+const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations();
+function createInstrumentationGetter(isReadonly, shallow) {
+    const instrumentations = shallow
+        ? isReadonly
+            ? shallowReadonlyInstrumentations
+            : shallowInstrumentations
+        : isReadonly
+            ? readonlyInstrumentations
+            : mutableInstrumentations;
+    return (target, key, receiver) => {
+        if (key === "__v_isReactive" /* IS_REACTIVE */) {
+            return !isReadonly;
+        }
+        else if (key === "__v_isReadonly" /* IS_READONLY */) {
+            return isReadonly;
+        }
+        else if (key === "__v_raw" /* RAW */) {
+            return target;
+        }
+        return Reflect.get((0,shared_esm_bundler/* hasOwn */.RI)(instrumentations, key) && key in target
+            ? instrumentations
+            : target, key, receiver);
+    };
+}
+const mutableCollectionHandlers = {
+    get: /*#__PURE__*/ createInstrumentationGetter(false, false)
+};
+const shallowCollectionHandlers = {
+    get: /*#__PURE__*/ createInstrumentationGetter(false, true)
+};
+const readonlyCollectionHandlers = {
+    get: /*#__PURE__*/ createInstrumentationGetter(true, false)
+};
+const shallowReadonlyCollectionHandlers = {
+    get: /*#__PURE__*/ createInstrumentationGetter(true, true)
+};
+function checkIdentityKeys(target, has, key) {
+    const rawKey = toRaw(key);
+    if (rawKey !== key && has.call(target, rawKey)) {
+        const type = toRawType(target);
+        console.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 = new WeakMap();
+const shallowReactiveMap = new WeakMap();
+const readonlyMap = new WeakMap();
+const shallowReadonlyMap = 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" /* SKIP */] || !Object.isExtensible(value)
+        ? 0 /* INVALID */
+        : targetTypeMap((0,shared_esm_bundler/* toRawType */.W7)(value));
+}
+function reactive(target) {
+    // if trying to observe a readonly proxy, return the readonly version.
+    if (isReadonly(target)) {
+        return target;
+    }
+    return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
+}
+/**
+ * Return a shallowly-reactive copy of the original object, where only the root
+ * level properties are reactive. It also does not auto-unwrap refs (even at the
+ * root level).
+ */
+function shallowReactive(target) {
+    return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
+}
+/**
+ * Creates a readonly copy of the original object. Note the returned copy is not
+ * made reactive, but `readonly` can be called on an already reactive object.
+ */
+function readonly(target) {
+    return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
+}
+/**
+ * Returns a reactive-copy of the original object, where only the root level
+ * properties are readonly, and does NOT unwrap refs nor recursively convert
+ * returned properties.
+ * This is used for creating the props proxy object for stateful components.
+ */
+function shallowReadonly(target) {
+    return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
+}
+function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
+    if (!(0,shared_esm_bundler/* isObject */.Kn)(target)) {
+        if ((false)) {}
+        return target;
+    }
+    // target is already a Proxy, return it.
+    // exception: calling readonly() on a reactive object
+    if (target["__v_raw" /* RAW */] &&
+        !(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
+        return target;
+    }
+    // target already has corresponding Proxy
+    const existingProxy = proxyMap.get(target);
+    if (existingProxy) {
+        return existingProxy;
+    }
+    // only specific value types can be observed.
+    const targetType = getTargetType(target);
+    if (targetType === 0 /* INVALID */) {
+        return target;
+    }
+    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" /* RAW */]);
+    }
+    return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
+}
+function isReadonly(value) {
+    return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
+}
+function isShallow(value) {
+    return !!(value && value["__v_isShallow" /* IS_SHALLOW */]);
+}
+function isProxy(value) {
+    return isReactive(value) || isReadonly(value);
+}
+function toRaw(observed) {
+    const raw = observed && observed["__v_raw" /* RAW */];
+    return raw ? toRaw(raw) : observed;
+}
+function markRaw(value) {
+    def(value, "__v_skip" /* SKIP */, true);
+    return value;
+}
+const toReactive = (value) => (0,shared_esm_bundler/* isObject */.Kn)(value) ? reactive(value) : value;
+const toReadonly = (value) => (0,shared_esm_bundler/* isObject */.Kn)(value) ? readonly(value) : value;
+
+function trackRefValue(ref) {
+    if (shouldTrack && activeEffect) {
+        ref = toRaw(ref);
+        if ((false)) {}
+        else {
+            trackEffects(ref.dep || (ref.dep = createDep()));
+        }
+    }
+}
+function triggerRefValue(ref, newVal) {
+    ref = toRaw(ref);
+    if (ref.dep) {
+        if ((false)) {}
+        else {
+            triggerEffects(ref.dep);
+        }
+    }
+}
+function isRef(r) {
+    return !!(r && r.__v_isRef === true);
+}
+function ref(value) {
+    return createRef(value, false);
+}
+function shallowRef(value) {
+    return createRef(value, true);
+}
+function createRef(rawValue, shallow) {
+    if (isRef(rawValue)) {
+        return rawValue;
+    }
+    return new RefImpl(rawValue, shallow);
+}
+class RefImpl {
+    constructor(value, __v_isShallow) {
+        this.__v_isShallow = __v_isShallow;
+        this.dep = undefined;
+        this.__v_isRef = true;
+        this._rawValue = __v_isShallow ? value : toRaw(value);
+        this._value = __v_isShallow ? value : toReactive(value);
+    }
+    get value() {
+        trackRefValue(this);
+        return this._value;
+    }
+    set value(newVal) {
+        newVal = this.__v_isShallow ? newVal : toRaw(newVal);
+        if (hasChanged(newVal, this._rawValue)) {
+            this._rawValue = newVal;
+            this._value = this.__v_isShallow ? newVal : toReactive(newVal);
+            triggerRefValue(this, newVal);
+        }
+    }
+}
+function triggerRef(ref) {
+    triggerRefValue(ref, ( false) ? 0 : void 0);
+}
+function unref(ref) {
+    return isRef(ref) ? ref.value : ref;
+}
+const shallowUnwrapHandlers = {
+    get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
+    set: (target, key, value, receiver) => {
+        const oldValue = target[key];
+        if (isRef(oldValue) && !isRef(value)) {
+            oldValue.value = value;
+            return true;
+        }
+        else {
+            return Reflect.set(target, key, value, receiver);
+        }
+    }
+};
+function proxyRefs(objectWithRefs) {
+    return isReactive(objectWithRefs)
+        ? objectWithRefs
+        : new Proxy(objectWithRefs, shallowUnwrapHandlers);
+}
+class CustomRefImpl {
+    constructor(factory) {
+        this.dep = undefined;
+        this.__v_isRef = true;
+        const { get, set } = factory(() => trackRefValue(this), () => triggerRefValue(this));
+        this._get = get;
+        this._set = set;
+    }
+    get value() {
+        return this._get();
+    }
+    set value(newVal) {
+        this._set(newVal);
+    }
+}
+function customRef(factory) {
+    return new CustomRefImpl(factory);
+}
+function toRefs(object) {
+    if (false) {}
+    const ret = isArray(object) ? new Array(object.length) : {};
+    for (const key in object) {
+        ret[key] = toRef(object, key);
+    }
+    return ret;
+}
+class ObjectRefImpl {
+    constructor(_object, _key, _defaultValue) {
+        this._object = _object;
+        this._key = _key;
+        this._defaultValue = _defaultValue;
+        this.__v_isRef = true;
+    }
+    get value() {
+        const val = this._object[this._key];
+        return val === undefined ? this._defaultValue : val;
+    }
+    set value(newVal) {
+        this._object[this._key] = newVal;
+    }
+}
+function toRef(object, key, defaultValue) {
+    const val = object[key];
+    return isRef(val)
+        ? val
+        : new ObjectRefImpl(object, key, defaultValue);
+}
+
+class ComputedRefImpl {
+    constructor(getter, _setter, isReadonly, isSSR) {
+        this._setter = _setter;
+        this.dep = undefined;
+        this.__v_isRef = true;
+        this._dirty = true;
+        this.effect = new ReactiveEffect(getter, () => {
+            if (!this._dirty) {
+                this._dirty = true;
+                triggerRefValue(this);
+            }
+        });
+        this.effect.computed = this;
+        this.effect.active = this._cacheable = !isSSR;
+        this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
+    }
+    get value() {
+        // the computed ref may get wrapped by other proxies e.g. readonly() #3376
+        const self = toRaw(this);
+        trackRefValue(self);
+        if (self._dirty || !self._cacheable) {
+            self._dirty = false;
+            self._value = self.effect.run();
+        }
+        return self._value;
+    }
+    set value(newValue) {
+        this._setter(newValue);
+    }
+}
+function computed(getterOrOptions, debugOptions, isSSR = false) {
+    let getter;
+    let setter;
+    const onlyGetter = (0,shared_esm_bundler/* isFunction */.mf)(getterOrOptions);
+    if (onlyGetter) {
+        getter = getterOrOptions;
+        setter = ( false)
+            ? 0
+            : shared_esm_bundler/* NOOP */.dG;
+    }
+    else {
+        getter = getterOrOptions.get;
+        setter = getterOrOptions.set;
+    }
+    const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
+    if (false) {}
+    return cRef;
+}
+
+var _a;
+const tick = /*#__PURE__*/ (/* unused pure expression or super */ null && (Promise.resolve()));
+const queue = (/* unused pure expression or super */ null && ([]));
+let queued = false;
+const scheduler = (fn) => {
+    queue.push(fn);
+    if (!queued) {
+        queued = true;
+        tick.then(flush);
+    }
+};
+const flush = () => {
+    for (let i = 0; i < queue.length; i++) {
+        queue[i]();
+    }
+    queue.length = 0;
+    queued = false;
+};
+class DeferredComputedRefImpl {
+    constructor(getter) {
+        this.dep = undefined;
+        this._dirty = true;
+        this.__v_isRef = true;
+        this[_a] = true;
+        let compareTarget;
+        let hasCompareTarget = false;
+        let scheduled = false;
+        this.effect = new ReactiveEffect(getter, (computedTrigger) => {
+            if (this.dep) {
+                if (computedTrigger) {
+                    compareTarget = this._value;
+                    hasCompareTarget = true;
+                }
+                else if (!scheduled) {
+                    const valueToCompare = hasCompareTarget ? compareTarget : this._value;
+                    scheduled = true;
+                    hasCompareTarget = false;
+                    scheduler(() => {
+                        if (this.effect.active && this._get() !== valueToCompare) {
+                            triggerRefValue(this);
+                        }
+                        scheduled = false;
+                    });
+                }
+                // chained upstream computeds are notified synchronously to ensure
+                // value invalidation in case of sync access; normal effects are
+                // deferred to be triggered in scheduler.
+                for (const e of this.dep) {
+                    if (e.computed instanceof DeferredComputedRefImpl) {
+                        e.scheduler(true /* computedTrigger */);
+                    }
+                }
+            }
+            this._dirty = true;
+        });
+        this.effect.computed = this;
+    }
+    _get() {
+        if (this._dirty) {
+            this._dirty = false;
+            return (this._value = this.effect.run());
+        }
+        return this._value;
+    }
+    get value() {
+        trackRefValue(this);
+        // the computed ref may get wrapped by other proxies e.g. readonly() #3376
+        return toRaw(this)._get();
+    }
+}
+_a = "__v_isReadonly" /* IS_READONLY */;
+function deferredComputed(getter) {
+    return new DeferredComputedRefImpl(getter);
+}
+
+
+
 ;// CONCATENATED MODULE: ./node_modules/element-plus/es/utils/dom/scroll.mjs
 
 
@@ -47509,14 +48703,14 @@ const getScrollContainer = (el, isVertical) => {
   return parent;
 };
 let scrollBarWidth;
-const getScrollBarWidth = () => {
+const getScrollBarWidth = (namespace) => {
   var _a;
   if (!shared/* isClient */.C5)
     return 0;
   if (scrollBarWidth !== void 0)
     return scrollBarWidth;
   const outer = document.createElement("div");
-  outer.className = "el-scrollbar__wrap";
+  outer.className = `${namespace}-scrollbar__wrap`;
   outer.style.visibility = "hidden";
   outer.style.width = "100px";
   outer.style.position = "absolute";
@@ -47567,11 +48761,15 @@ function scrollIntoView(container, selected) {
 
 
 
+
+
 const useLockscreen = (trigger) => {
   if (!(0,external_commonjs_vue_commonjs2_vue_root_Vue_.isRef)(trigger)) {
     (0,error/* throwError */._)("[useLockscreen]", "You need to pass a ref param to this function");
   }
-  if (!shared/* isClient */.C5 || (0,style/* hasClass */.pv)(document.body, "el-popup-parent--hidden")) {
+  const ns = (0,use_namespace/* useNamespace */.s)("popup");
+  const hiddenCls = computed(() => ns.bm("parent", "hidden"));
+  if (!shared/* isClient */.C5 || (0,style/* hasClass */.pv)(document.body, hiddenCls.value)) {
     return;
   }
   let scrollBarWidth = 0;
@@ -47579,7 +48777,7 @@ const useLockscreen = (trigger) => {
   let bodyPaddingRight = "0";
   let computedBodyPaddingRight = 0;
   const cleanup = () => {
-    (0,style/* removeClass */.IV)(document.body, "el-popup-parent--hidden");
+    (0,style/* removeClass */.IV)(document.body, hiddenCls.value);
     if (withoutHiddenClass) {
       document.body.style.paddingRight = bodyPaddingRight;
     }
@@ -47589,18 +48787,18 @@ const useLockscreen = (trigger) => {
       cleanup();
       return;
     }
-    withoutHiddenClass = !(0,style/* hasClass */.pv)(document.body, "el-popup-parent--hidden");
+    withoutHiddenClass = !(0,style/* hasClass */.pv)(document.body, hiddenCls.value);
     if (withoutHiddenClass) {
       bodyPaddingRight = document.body.style.paddingRight;
       computedBodyPaddingRight = Number.parseInt((0,style/* getStyle */.C2)(document.body, "paddingRight"), 10);
     }
-    scrollBarWidth = getScrollBarWidth();
+    scrollBarWidth = getScrollBarWidth(ns.namespace.value);
     const bodyHasOverflow = document.documentElement.clientHeight < document.body.scrollHeight;
     const bodyOverflowY = (0,style/* getStyle */.C2)(document.body, "overflowY");
     if (scrollBarWidth > 0 && (bodyHasOverflow || bodyOverflowY === "scroll") && withoutHiddenClass) {
       document.body.style.paddingRight = `${computedBodyPaddingRight + scrollBarWidth}px`;
     }
-    (0,style/* addClass */.cn)(document.body, "el-popup-parent--hidden");
+    (0,style/* addClass */.cn)(document.body, hiddenCls.value);
   });
   (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onScopeDispose)(() => cleanup());
 };
@@ -47654,7 +48852,6 @@ const useRestoreActive = (toggle, initialFocus) => {
 
 
 
-
 
 
 const src_sfc_main = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.defineComponent)({
@@ -47812,12 +49009,12 @@ const src_sfc_main = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.defineComp
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(async () => {
       await (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
       if (props.closeOnHashChange) {
-        on(window, "hashchange", doClose);
+        window.addEventListener("hashchange", doClose);
       }
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onBeforeUnmount)(() => {
       if (props.closeOnHashChange) {
-        off(window, "hashchange", doClose);
+        window.removeEventListener("hashchange", doClose);
       }
     });
     function doClose() {
@@ -50226,16 +51423,16 @@ const __exports__ = /*#__PURE__*/(0,exportHelper/* default */.Z)(JwtUploadImagev
 
 var map = {
 	"./JwtCascaderArea/index.vue": 3724,
-	"./JwtEditor/index.vue": 5462,
+	"./JwtEditor/index.vue": 8007,
 	"./JwtForm/index.vue": 4751,
 	"./JwtHeaderButton/index.vue": 6886,
 	"./JwtIcon/index.vue": 8916,
 	"./JwtIconSelect/index.vue": 7047,
 	"./JwtImage/index.vue": 8328,
-	"./JwtInput/index.vue": 5859,
+	"./JwtInput/index.vue": 1914,
 	"./JwtRateIcon/index.vue": 5939,
 	"./JwtSelectServer/index.vue": 1279,
-	"./JwtTable/index.vue": 4619,
+	"./JwtTable/index.vue": 4282,
 	"./JwtTableButton/index.vue": 9033,
 	"./JwtTableOnly/index.vue": 4016,
 	"./JwtTags/index.vue": 1382,
@@ -63820,7 +65017,9 @@ const normalizeOptions = (params) => {
     ...messageDefaults,
     ...options
   };
-  if ((0,shared_esm_bundler/* isString */.HD)(normalized.appendTo)) {
+  if (!normalized.appendTo) {
+    normalized.appendTo = document.body;
+  } else if ((0,shared_esm_bundler/* isString */.HD)(normalized.appendTo)) {
     let appendTo = document.querySelector(normalized.appendTo);
     if (!(0,types/* isElement */.kK)(appendTo)) {
       (0,error/* debugWarn */.N)("ElMessage", "the appendTo option is not an HTMLElement. Falling back to document.body.");
@@ -64196,14 +65395,18 @@ const useNamespace = (block) => {
   const cssVar = (object) => {
     const styles = {};
     for (const key in object) {
-      styles[`--${namespace.value}-${key}`] = object[key];
+      if (object[key]) {
+        styles[`--${namespace.value}-${key}`] = object[key];
+      }
     }
     return styles;
   };
   const cssVarBlock = (object) => {
     const styles = {};
     for (const key in object) {
-      styles[`--${namespace.value}-${block}-${key}`] = object[key];
+      if (object[key]) {
+        styles[`--${namespace.value}-${block}-${key}`] = object[key];
+      }
     }
     return styles;
   };