granblue-party/dist.js

(() => {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __commonJS = (cb, mod) => function __require() {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target3) => (target3 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    // If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. "__esModule" has not been set), then set
    // "default" to the CommonJS "module.exports" for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target3, "default", { value: mod, enumerable: true }) : target3,
    mod
  ));

  // src/App.vue
  var require_App = __commonJS({
    "src/App.vue"() {
    }
  });

  // node_modules/vue/dist/vue.js
  var require_vue = __commonJS({
    "node_modules/vue/dist/vue.js"(exports, module) {
      (function(global2, factory) {
        typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, global2.Vue = factory());
      })(exports, (function() {
        "use strict";
        var emptyObject2 = Object.freeze({});
        var isArray2 = Array.isArray;
        function isUndef2(v) {
          return v === void 0 || v === null;
        }
        function isDef2(v) {
          return v !== void 0 && v !== null;
        }
        function isTrue2(v) {
          return v === true;
        }
        function isFalse2(v) {
          return v === false;
        }
        function isPrimitive2(value) {
          return typeof value === "string" || typeof value === "number" || // $flow-disable-line
          typeof value === "symbol" || typeof value === "boolean";
        }
        function isFunction2(value) {
          return typeof value === "function";
        }
        function isObject3(obj) {
          return obj !== null && typeof obj === "object";
        }
        var _toString2 = Object.prototype.toString;
        function toRawType(value) {
          return _toString2.call(value).slice(8, -1);
        }
        function isPlainObject2(obj) {
          return _toString2.call(obj) === "[object Object]";
        }
        function isRegExp2(v) {
          return _toString2.call(v) === "[object RegExp]";
        }
        function isValidArrayIndex2(val) {
          var n = parseFloat(String(val));
          return n >= 0 && Math.floor(n) === n && isFinite(val);
        }
        function isPromise3(val) {
          return isDef2(val) && typeof val.then === "function" && typeof val.catch === "function";
        }
        function toString2(val) {
          return val == null ? "" : Array.isArray(val) || isPlainObject2(val) && val.toString === _toString2 ? JSON.stringify(val, replacer2, 2) : String(val);
        }
        function replacer2(_key, val) {
          if (val && val.__v_isRef) {
            return val.value;
          }
          return val;
        }
        function toNumber2(val) {
          var n = parseFloat(val);
          return isNaN(n) ? val : n;
        }
        function makeMap2(str2, expectsLowerCase) {
          var map = /* @__PURE__ */ Object.create(null);
          var list = str2.split(",");
          for (var i = 0; i < list.length; i++) {
            map[list[i]] = true;
          }
          return expectsLowerCase ? function(val) {
            return map[val.toLowerCase()];
          } : function(val) {
            return map[val];
          };
        }
        var isBuiltInTag2 = makeMap2("slot,component", true);
        var isReservedAttribute2 = makeMap2("key,ref,slot,slot-scope,is");
        function remove$22(arr, item) {
          var len2 = arr.length;
          if (len2) {
            if (item === arr[len2 - 1]) {
              arr.length = len2 - 1;
              return;
            }
            var index4 = arr.indexOf(item);
            if (index4 > -1) {
              return arr.splice(index4, 1);
            }
          }
        }
        var hasOwnProperty2 = Object.prototype.hasOwnProperty;
        function hasOwn2(obj, key) {
          return hasOwnProperty2.call(obj, key);
        }
        function cached2(fn) {
          var cache = /* @__PURE__ */ Object.create(null);
          return function cachedFn(str2) {
            var hit = cache[str2];
            return hit || (cache[str2] = fn(str2));
          };
        }
        var camelizeRE2 = /-(\w)/g;
        var camelize2 = cached2(function(str2) {
          return str2.replace(camelizeRE2, function(_, c) {
            return c ? c.toUpperCase() : "";
          });
        });
        var capitalize2 = cached2(function(str2) {
          return str2.charAt(0).toUpperCase() + str2.slice(1);
        });
        var hyphenateRE2 = /\B([A-Z])/g;
        var hyphenate2 = cached2(function(str2) {
          return str2.replace(hyphenateRE2, "-$1").toLowerCase();
        });
        function polyfillBind2(fn, ctx) {
          function boundFn(a) {
            var l = arguments.length;
            return l ? l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a) : fn.call(ctx);
          }
          boundFn._length = fn.length;
          return boundFn;
        }
        function nativeBind2(fn, ctx) {
          return fn.bind(ctx);
        }
        var bind$1 = Function.prototype.bind ? nativeBind2 : polyfillBind2;
        function toArray2(list, start) {
          start = start || 0;
          var i = list.length - start;
          var ret = new Array(i);
          while (i--) {
            ret[i] = list[i + start];
          }
          return ret;
        }
        function extend2(to, _from) {
          for (var key in _from) {
            to[key] = _from[key];
          }
          return to;
        }
        function toObject2(arr) {
          var res = {};
          for (var i = 0; i < arr.length; i++) {
            if (arr[i]) {
              extend2(res, arr[i]);
            }
          }
          return res;
        }
        function noop2(a, b, c) {
        }
        var no2 = function(a, b, c) {
          return false;
        };
        var identity2 = function(_) {
          return _;
        };
        function genStaticKeys$1(modules3) {
          return modules3.reduce(function(keys, m) {
            return keys.concat(m.staticKeys || []);
          }, []).join(",");
        }
        function looseEqual2(a, b) {
          if (a === b)
            return true;
          var isObjectA = isObject3(a);
          var isObjectB = isObject3(b);
          if (isObjectA && isObjectB) {
            try {
              var isArrayA = Array.isArray(a);
              var isArrayB = Array.isArray(b);
              if (isArrayA && isArrayB) {
                return a.length === b.length && a.every(function(e, i) {
                  return looseEqual2(e, b[i]);
                });
              } else if (a instanceof Date && b instanceof Date) {
                return a.getTime() === b.getTime();
              } else if (!isArrayA && !isArrayB) {
                var keysA = Object.keys(a);
                var keysB = Object.keys(b);
                return keysA.length === keysB.length && keysA.every(function(key) {
                  return looseEqual2(a[key], b[key]);
                });
              } else {
                return false;
              }
            } catch (e) {
              return false;
            }
          } else if (!isObjectA && !isObjectB) {
            return String(a) === String(b);
          } else {
            return false;
          }
        }
        function looseIndexOf2(arr, val) {
          for (var i = 0; i < arr.length; i++) {
            if (looseEqual2(arr[i], val))
              return i;
          }
          return -1;
        }
        function once2(fn) {
          var called = false;
          return function() {
            if (!called) {
              called = true;
              fn.apply(this, arguments);
            }
          };
        }
        function hasChanged2(x, y) {
          if (x === y) {
            return x === 0 && 1 / x !== 1 / y;
          } else {
            return x === x || y === y;
          }
        }
        var SSR_ATTR2 = "data-server-rendered";
        var ASSET_TYPES2 = ["component", "directive", "filter"];
        var LIFECYCLE_HOOKS2 = [
          "beforeCreate",
          "created",
          "beforeMount",
          "mounted",
          "beforeUpdate",
          "updated",
          "beforeDestroy",
          "destroyed",
          "activated",
          "deactivated",
          "errorCaptured",
          "serverPrefetch",
          "renderTracked",
          "renderTriggered"
        ];
        var config2 = {
          /**
           * Option merge strategies (used in core/util/options)
           */
          // $flow-disable-line
          optionMergeStrategies: /* @__PURE__ */ Object.create(null),
          /**
           * Whether to suppress warnings.
           */
          silent: false,
          /**
           * Show production mode tip message on boot?
           */
          productionTip: true,
          /**
           * Whether to enable devtools
           */
          devtools: true,
          /**
           * Whether to record perf
           */
          performance: false,
          /**
           * Error handler for watcher errors
           */
          errorHandler: null,
          /**
           * Warn handler for watcher warns
           */
          warnHandler: null,
          /**
           * Ignore certain custom elements
           */
          ignoredElements: [],
          /**
           * Custom user key aliases for v-on
           */
          // $flow-disable-line
          keyCodes: /* @__PURE__ */ Object.create(null),
          /**
           * Check if a tag is reserved so that it cannot be registered as a
           * component. This is platform-dependent and may be overwritten.
           */
          isReservedTag: no2,
          /**
           * Check if an attribute is reserved so that it cannot be used as a component
           * prop. This is platform-dependent and may be overwritten.
           */
          isReservedAttr: no2,
          /**
           * Check if a tag is an unknown element.
           * Platform-dependent.
           */
          isUnknownElement: no2,
          /**
           * Get the namespace of an element
           */
          getTagNamespace: noop2,
          /**
           * Parse the real tag name for the specific platform.
           */
          parsePlatformTagName: identity2,
          /**
           * Check if an attribute must be bound using property, e.g. value
           * Platform-dependent.
           */
          mustUseProp: no2,
          /**
           * Perform updates asynchronously. Intended to be used by Vue Test Utils
           * This will significantly reduce performance if set to false.
           */
          async: true,
          /**
           * Exposed for legacy reasons
           */
          _lifecycleHooks: LIFECYCLE_HOOKS2
        };
        var unicodeRegExp2 = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
        function isReserved2(str2) {
          var c = (str2 + "").charCodeAt(0);
          return c === 36 || c === 95;
        }
        function def2(obj, key, val, enumerable) {
          Object.defineProperty(obj, key, {
            value: val,
            enumerable: !!enumerable,
            writable: true,
            configurable: true
          });
        }
        var bailRE2 = new RegExp("[^".concat(unicodeRegExp2.source, ".$_\\d]"));
        function parsePath2(path) {
          if (bailRE2.test(path)) {
            return;
          }
          var segments = path.split(".");
          return function(obj) {
            for (var i = 0; i < segments.length; i++) {
              if (!obj)
                return;
              obj = obj[segments[i]];
            }
            return obj;
          };
        }
        var hasProto2 = "__proto__" in {};
        var inBrowser2 = typeof window !== "undefined";
        var UA2 = inBrowser2 && window.navigator.userAgent.toLowerCase();
        var isIE2 = UA2 && /msie|trident/.test(UA2);
        var isIE92 = UA2 && UA2.indexOf("msie 9.0") > 0;
        var isEdge2 = UA2 && UA2.indexOf("edge/") > 0;
        UA2 && UA2.indexOf("android") > 0;
        var isIOS2 = UA2 && /iphone|ipad|ipod|ios/.test(UA2);
        UA2 && /chrome\/\d+/.test(UA2) && !isEdge2;
        UA2 && /phantomjs/.test(UA2);
        var isFF2 = UA2 && UA2.match(/firefox\/(\d+)/);
        var nativeWatch2 = {}.watch;
        var supportsPassive2 = false;
        if (inBrowser2) {
          try {
            var opts = {};
            Object.defineProperty(opts, "passive", {
              get: function() {
                supportsPassive2 = true;
              }
            });
            window.addEventListener("test-passive", null, opts);
          } catch (e) {
          }
        }
        var _isServer2;
        var isServerRendering2 = function() {
          if (_isServer2 === void 0) {
            if (!inBrowser2 && typeof global !== "undefined") {
              _isServer2 = global["process"] && global["process"].env.VUE_ENV === "server";
            } else {
              _isServer2 = false;
            }
          }
          return _isServer2;
        };
        var devtools2 = inBrowser2 && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
        function isNative2(Ctor) {
          return typeof Ctor === "function" && /native code/.test(Ctor.toString());
        }
        var hasSymbol2 = typeof Symbol !== "undefined" && isNative2(Symbol) && typeof Reflect !== "undefined" && isNative2(Reflect.ownKeys);
        var _Set2;
        if (typeof Set !== "undefined" && isNative2(Set)) {
          _Set2 = Set;
        } else {
          _Set2 = /** @class */
          (function() {
            function Set2() {
              this.set = /* @__PURE__ */ Object.create(null);
            }
            Set2.prototype.has = function(key) {
              return this.set[key] === true;
            };
            Set2.prototype.add = function(key) {
              this.set[key] = true;
            };
            Set2.prototype.clear = function() {
              this.set = /* @__PURE__ */ Object.create(null);
            };
            return Set2;
          })();
        }
        var currentInstance2 = null;
        function getCurrentInstance() {
          return currentInstance2 && { proxy: currentInstance2 };
        }
        function setCurrentInstance2(vm) {
          if (vm === void 0) {
            vm = null;
          }
          if (!vm)
            currentInstance2 && currentInstance2._scope.off();
          currentInstance2 = vm;
          vm && vm._scope.on();
        }
        var VNode2 = (
          /** @class */
          (function() {
            function VNode3(tag, data, children, text2, elm, context, componentOptions, asyncFactory) {
              this.tag = tag;
              this.data = data;
              this.children = children;
              this.text = text2;
              this.elm = elm;
              this.ns = void 0;
              this.context = context;
              this.fnContext = void 0;
              this.fnOptions = void 0;
              this.fnScopeId = void 0;
              this.key = data && data.key;
              this.componentOptions = componentOptions;
              this.componentInstance = void 0;
              this.parent = void 0;
              this.raw = false;
              this.isStatic = false;
              this.isRootInsert = true;
              this.isComment = false;
              this.isCloned = false;
              this.isOnce = false;
              this.asyncFactory = asyncFactory;
              this.asyncMeta = void 0;
              this.isAsyncPlaceholder = false;
            }
            Object.defineProperty(VNode3.prototype, "child", {
              // DEPRECATED: alias for componentInstance for backwards compat.
              /* istanbul ignore next */
              get: function() {
                return this.componentInstance;
              },
              enumerable: false,
              configurable: true
            });
            return VNode3;
          })()
        );
        var createEmptyVNode2 = function(text2) {
          if (text2 === void 0) {
            text2 = "";
          }
          var node = new VNode2();
          node.text = text2;
          node.isComment = true;
          return node;
        };
        function createTextVNode2(val) {
          return new VNode2(void 0, void 0, void 0, String(val));
        }
        function cloneVNode2(vnode) {
          var cloned = new VNode2(
            vnode.tag,
            vnode.data,
            // #7975
            // clone children array to avoid mutating original in case of cloning
            // a child.
            vnode.children && vnode.children.slice(),
            vnode.text,
            vnode.elm,
            vnode.context,
            vnode.componentOptions,
            vnode.asyncFactory
          );
          cloned.ns = vnode.ns;
          cloned.isStatic = vnode.isStatic;
          cloned.key = vnode.key;
          cloned.isComment = vnode.isComment;
          cloned.fnContext = vnode.fnContext;
          cloned.fnOptions = vnode.fnOptions;
          cloned.fnScopeId = vnode.fnScopeId;
          cloned.asyncMeta = vnode.asyncMeta;
          cloned.isCloned = true;
          return cloned;
        }
        var initProxy;
        {
          var allowedGlobals_1 = makeMap2(
            "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,require"
            // for Webpack/Browserify
          );
          var warnNonPresent_1 = function(target4, key) {
            warn$2('Property or method "'.concat(key, '" is not defined on the instance but ') + "referenced during render. Make sure that this property is reactive, either in the data option, or for class-based components, by initializing the property. See: https://v2.vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.", target4);
          };
          var warnReservedPrefix_1 = function(target4, key) {
            warn$2('Property "'.concat(key, '" must be accessed with "$data.').concat(key, '" because ') + 'properties starting with "$" or "_" are not proxied in the Vue instance to prevent conflicts with Vue internals. See: https://v2.vuejs.org/v2/api/#data', target4);
          };
          var hasProxy_1 = typeof Proxy !== "undefined" && isNative2(Proxy);
          if (hasProxy_1) {
            var isBuiltInModifier_1 = makeMap2("stop,prevent,self,ctrl,shift,alt,meta,exact");
            config2.keyCodes = new Proxy(config2.keyCodes, {
              set: function(target4, key, value) {
                if (isBuiltInModifier_1(key)) {
                  warn$2("Avoid overwriting built-in modifier in config.keyCodes: .".concat(key));
                  return false;
                } else {
                  target4[key] = value;
                  return true;
                }
              }
            });
          }
          var hasHandler_1 = {
            has: function(target4, key) {
              var has3 = key in target4;
              var isAllowed = allowedGlobals_1(key) || typeof key === "string" && key.charAt(0) === "_" && !(key in target4.$data);
              if (!has3 && !isAllowed) {
                if (key in target4.$data)
                  warnReservedPrefix_1(target4, key);
                else
                  warnNonPresent_1(target4, key);
              }
              return has3 || !isAllowed;
            }
          };
          var getHandler_1 = {
            get: function(target4, key) {
              if (typeof key === "string" && !(key in target4)) {
                if (key in target4.$data)
                  warnReservedPrefix_1(target4, key);
                else
                  warnNonPresent_1(target4, key);
              }
              return target4[key];
            }
          };
          initProxy = function initProxy2(vm) {
            if (hasProxy_1) {
              var options = vm.$options;
              var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
              vm._renderProxy = new Proxy(vm, handlers);
            } else {
              vm._renderProxy = vm;
            }
          };
        }
        var __assign = function() {
          __assign = Object.assign || function __assign2(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;
        };
        var uid$22 = 0;
        var pendingCleanupDeps2 = [];
        var cleanupDeps2 = function() {
          for (var i = 0; i < pendingCleanupDeps2.length; i++) {
            var dep = pendingCleanupDeps2[i];
            dep.subs = dep.subs.filter(function(s) {
              return s;
            });
            dep._pending = false;
          }
          pendingCleanupDeps2.length = 0;
        };
        var Dep2 = (
          /** @class */
          (function() {
            function Dep3() {
              this._pending = false;
              this.id = uid$22++;
              this.subs = [];
            }
            Dep3.prototype.addSub = function(sub) {
              this.subs.push(sub);
            };
            Dep3.prototype.removeSub = function(sub) {
              this.subs[this.subs.indexOf(sub)] = null;
              if (!this._pending) {
                this._pending = true;
                pendingCleanupDeps2.push(this);
              }
            };
            Dep3.prototype.depend = function(info) {
              if (Dep3.target) {
                Dep3.target.addDep(this);
                if (info && Dep3.target.onTrack) {
                  Dep3.target.onTrack(__assign({ effect: Dep3.target }, info));
                }
              }
            };
            Dep3.prototype.notify = function(info) {
              var subs = this.subs.filter(function(s) {
                return s;
              });
              if (!config2.async) {
                subs.sort(function(a, b) {
                  return a.id - b.id;
                });
              }
              for (var i = 0, l = subs.length; i < l; i++) {
                var sub = subs[i];
                if (info) {
                  sub.onTrigger && sub.onTrigger(__assign({ effect: subs[i] }, info));
                }
                sub.update();
              }
            };
            return Dep3;
          })()
        );
        Dep2.target = null;
        var targetStack2 = [];
        function pushTarget2(target4) {
          targetStack2.push(target4);
          Dep2.target = target4;
        }
        function popTarget2() {
          targetStack2.pop();
          Dep2.target = targetStack2[targetStack2.length - 1];
        }
        var arrayProto2 = Array.prototype;
        var arrayMethods2 = Object.create(arrayProto2);
        var methodsToPatch2 = [
          "push",
          "pop",
          "shift",
          "unshift",
          "splice",
          "sort",
          "reverse"
        ];
        methodsToPatch2.forEach(function(method) {
          var original = arrayProto2[method];
          def2(arrayMethods2, method, function mutator() {
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
              args[_i] = arguments[_i];
            }
            var result = original.apply(this, args);
            var ob = this.__ob__;
            var inserted;
            switch (method) {
              case "push":
              case "unshift":
                inserted = args;
                break;
              case "splice":
                inserted = args.slice(2);
                break;
            }
            if (inserted)
              ob.observeArray(inserted);
            {
              ob.dep.notify({
                type: "array mutation",
                target: this,
                key: method
              });
            }
            return result;
          });
        });
        var arrayKeys2 = Object.getOwnPropertyNames(arrayMethods2);
        var NO_INITIAL_VALUE2 = {};
        var shouldObserve2 = true;
        function toggleObserving2(value) {
          shouldObserve2 = value;
        }
        var mockDep2 = {
          notify: noop2,
          depend: noop2,
          addSub: noop2,
          removeSub: noop2
        };
        var Observer2 = (
          /** @class */
          (function() {
            function Observer3(value, shallow, mock) {
              if (shallow === void 0) {
                shallow = false;
              }
              if (mock === void 0) {
                mock = false;
              }
              this.value = value;
              this.shallow = shallow;
              this.mock = mock;
              this.dep = mock ? mockDep2 : new Dep2();
              this.vmCount = 0;
              def2(value, "__ob__", this);
              if (isArray2(value)) {
                if (!mock) {
                  if (hasProto2) {
                    value.__proto__ = arrayMethods2;
                  } else {
                    for (var i = 0, l = arrayKeys2.length; i < l; i++) {
                      var key = arrayKeys2[i];
                      def2(value, key, arrayMethods2[key]);
                    }
                  }
                }
                if (!shallow) {
                  this.observeArray(value);
                }
              } else {
                var keys = Object.keys(value);
                for (var i = 0; i < keys.length; i++) {
                  var key = keys[i];
                  defineReactive2(value, key, NO_INITIAL_VALUE2, void 0, shallow, mock);
                }
              }
            }
            Observer3.prototype.observeArray = function(value) {
              for (var i = 0, l = value.length; i < l; i++) {
                observe2(value[i], false, this.mock);
              }
            };
            return Observer3;
          })()
        );
        function observe2(value, shallow, ssrMockReactivity) {
          if (value && hasOwn2(value, "__ob__") && value.__ob__ instanceof Observer2) {
            return value.__ob__;
          }
          if (shouldObserve2 && (ssrMockReactivity || !isServerRendering2()) && (isArray2(value) || isPlainObject2(value)) && Object.isExtensible(value) && !value.__v_skip && !isRef2(value) && !(value instanceof VNode2)) {
            return new Observer2(value, shallow, ssrMockReactivity);
          }
        }
        function defineReactive2(obj, key, val, customSetter, shallow, mock, observeEvenIfShallow) {
          if (observeEvenIfShallow === void 0) {
            observeEvenIfShallow = false;
          }
          var dep = new Dep2();
          var property = Object.getOwnPropertyDescriptor(obj, key);
          if (property && property.configurable === false) {
            return;
          }
          var getter = property && property.get;
          var setter = property && property.set;
          if ((!getter || setter) && (val === NO_INITIAL_VALUE2 || arguments.length === 2)) {
            val = obj[key];
          }
          var childOb = shallow ? val && val.__ob__ : observe2(val, false, mock);
          Object.defineProperty(obj, key, {
            enumerable: true,
            configurable: true,
            get: function reactiveGetter() {
              var value = getter ? getter.call(obj) : val;
              if (Dep2.target) {
                {
                  dep.depend({
                    target: obj,
                    type: "get",
                    key
                  });
                }
                if (childOb) {
                  childOb.dep.depend();
                  if (isArray2(value)) {
                    dependArray2(value);
                  }
                }
              }
              return isRef2(value) && !shallow ? value.value : value;
            },
            set: function reactiveSetter(newVal) {
              var value = getter ? getter.call(obj) : val;
              if (!hasChanged2(value, newVal)) {
                return;
              }
              if (customSetter) {
                customSetter();
              }
              if (setter) {
                setter.call(obj, newVal);
              } else if (getter) {
                return;
              } else if (!shallow && isRef2(value) && !isRef2(newVal)) {
                value.value = newVal;
                return;
              } else {
                val = newVal;
              }
              childOb = shallow ? newVal && newVal.__ob__ : observe2(newVal, false, mock);
              {
                dep.notify({
                  type: "set",
                  target: obj,
                  key,
                  newValue: newVal,
                  oldValue: value
                });
              }
            }
          });
          return dep;
        }
        function set2(target4, key, val) {
          if (isUndef2(target4) || isPrimitive2(target4)) {
            warn$2("Cannot set reactive property on undefined, null, or primitive value: ".concat(target4));
          }
          if (isReadonly2(target4)) {
            warn$2('Set operation on key "'.concat(key, '" failed: target is readonly.'));
            return;
          }
          var ob = target4.__ob__;
          if (isArray2(target4) && isValidArrayIndex2(key)) {
            target4.length = Math.max(target4.length, key);
            target4.splice(key, 1, val);
            if (ob && !ob.shallow && ob.mock) {
              observe2(val, false, true);
            }
            return val;
          }
          if (key in target4 && !(key in Object.prototype)) {
            target4[key] = val;
            return val;
          }
          if (target4._isVue || ob && ob.vmCount) {
            warn$2("Avoid adding reactive properties to a Vue instance or its root $data at runtime - declare it upfront in the data option.");
            return val;
          }
          if (!ob) {
            target4[key] = val;
            return val;
          }
          defineReactive2(ob.value, key, val, void 0, ob.shallow, ob.mock);
          {
            ob.dep.notify({
              type: "add",
              target: target4,
              key,
              newValue: val,
              oldValue: void 0
            });
          }
          return val;
        }
        function del2(target4, key) {
          if (isUndef2(target4) || isPrimitive2(target4)) {
            warn$2("Cannot delete reactive property on undefined, null, or primitive value: ".concat(target4));
          }
          if (isArray2(target4) && isValidArrayIndex2(key)) {
            target4.splice(key, 1);
            return;
          }
          var ob = target4.__ob__;
          if (target4._isVue || ob && ob.vmCount) {
            warn$2("Avoid deleting properties on a Vue instance or its root $data - just set it to null.");
            return;
          }
          if (isReadonly2(target4)) {
            warn$2('Delete operation on key "'.concat(key, '" failed: target is readonly.'));
            return;
          }
          if (!hasOwn2(target4, key)) {
            return;
          }
          delete target4[key];
          if (!ob) {
            return;
          }
          {
            ob.dep.notify({
              type: "delete",
              target: target4,
              key
            });
          }
        }
        function dependArray2(value) {
          for (var e = void 0, i = 0, l = value.length; i < l; i++) {
            e = value[i];
            if (e && e.__ob__) {
              e.__ob__.dep.depend();
            }
            if (isArray2(e)) {
              dependArray2(e);
            }
          }
        }
        function reactive(target4) {
          makeReactive2(target4, false);
          return target4;
        }
        function shallowReactive2(target4) {
          makeReactive2(target4, true);
          def2(target4, "__v_isShallow", true);
          return target4;
        }
        function makeReactive2(target4, shallow) {
          if (!isReadonly2(target4)) {
            {
              if (isArray2(target4)) {
                warn$2("Avoid using Array as root value for ".concat(shallow ? "shallowReactive()" : "reactive()", " as it cannot be tracked in watch() or watchEffect(). Use ").concat(shallow ? "shallowRef()" : "ref()", " instead. This is a Vue-2-only limitation."));
              }
              var existingOb = target4 && target4.__ob__;
              if (existingOb && existingOb.shallow !== shallow) {
                warn$2("Target is already a ".concat(existingOb.shallow ? "" : "non-", "shallow reactive object, and cannot be converted to ").concat(shallow ? "" : "non-", "shallow."));
              }
            }
            var ob = observe2(
              target4,
              shallow,
              isServerRendering2()
              /* ssr mock reactivity */
            );
            if (!ob) {
              if (target4 == null || isPrimitive2(target4)) {
                warn$2("value cannot be made reactive: ".concat(String(target4)));
              }
              if (isCollectionType(target4)) {
                warn$2("Vue 2 does not support reactive collection types such as Map or Set.");
              }
            }
          }
        }
        function isReactive(value) {
          if (isReadonly2(value)) {
            return isReactive(value[
              "__v_raw"
              /* ReactiveFlags.RAW */
            ]);
          }
          return !!(value && value.__ob__);
        }
        function isShallow(value) {
          return !!(value && value.__v_isShallow);
        }
        function isReadonly2(value) {
          return !!(value && value.__v_isReadonly);
        }
        function isProxy(value) {
          return isReactive(value) || isReadonly2(value);
        }
        function toRaw(observed) {
          var raw = observed && observed[
            "__v_raw"
            /* ReactiveFlags.RAW */
          ];
          return raw ? toRaw(raw) : observed;
        }
        function markRaw(value) {
          if (Object.isExtensible(value)) {
            def2(value, "__v_skip", true);
          }
          return value;
        }
        function isCollectionType(value) {
          var type = toRawType(value);
          return type === "Map" || type === "WeakMap" || type === "Set" || type === "WeakSet";
        }
        var RefFlag = "__v_isRef";
        function isRef2(r) {
          return !!(r && r.__v_isRef === true);
        }
        function ref$1(value) {
          return createRef(value, false);
        }
        function shallowRef(value) {
          return createRef(value, true);
        }
        function createRef(rawValue, shallow) {
          if (isRef2(rawValue)) {
            return rawValue;
          }
          var ref3 = {};
          def2(ref3, RefFlag, true);
          def2(ref3, "__v_isShallow", shallow);
          def2(ref3, "dep", defineReactive2(ref3, "value", rawValue, null, shallow, isServerRendering2()));
          return ref3;
        }
        function triggerRef(ref3) {
          if (!ref3.dep) {
            warn$2("received object is not a triggerable ref.");
          }
          {
            ref3.dep && ref3.dep.notify({
              type: "set",
              target: ref3,
              key: "value"
            });
          }
        }
        function unref(ref3) {
          return isRef2(ref3) ? ref3.value : ref3;
        }
        function proxyRefs(objectWithRefs) {
          if (isReactive(objectWithRefs)) {
            return objectWithRefs;
          }
          var proxy3 = {};
          var keys = Object.keys(objectWithRefs);
          for (var i = 0; i < keys.length; i++) {
            proxyWithRefUnwrap2(proxy3, objectWithRefs, keys[i]);
          }
          return proxy3;
        }
        function proxyWithRefUnwrap2(target4, source, key) {
          Object.defineProperty(target4, key, {
            enumerable: true,
            configurable: true,
            get: function() {
              var val = source[key];
              if (isRef2(val)) {
                return val.value;
              } else {
                var ob = val && val.__ob__;
                if (ob)
                  ob.dep.depend();
                return val;
              }
            },
            set: function(value) {
              var oldValue = source[key];
              if (isRef2(oldValue) && !isRef2(value)) {
                oldValue.value = value;
              } else {
                source[key] = value;
              }
            }
          });
        }
        function customRef(factory) {
          var dep = new Dep2();
          var _a2 = factory(function() {
            {
              dep.depend({
                target: ref3,
                type: "get",
                key: "value"
              });
            }
          }, function() {
            {
              dep.notify({
                target: ref3,
                type: "set",
                key: "value"
              });
            }
          }), get2 = _a2.get, set3 = _a2.set;
          var ref3 = {
            get value() {
              return get2();
            },
            set value(newVal) {
              set3(newVal);
            }
          };
          def2(ref3, RefFlag, true);
          return ref3;
        }
        function toRefs(object) {
          if (!isReactive(object)) {
            warn$2("toRefs() expects a reactive object but received a plain one.");
          }
          var ret = isArray2(object) ? new Array(object.length) : {};
          for (var key in object) {
            ret[key] = toRef(object, key);
          }
          return ret;
        }
        function toRef(object, key, defaultValue) {
          var val = object[key];
          if (isRef2(val)) {
            return val;
          }
          var ref3 = {
            get value() {
              var val2 = object[key];
              return val2 === void 0 ? defaultValue : val2;
            },
            set value(newVal) {
              object[key] = newVal;
            }
          };
          def2(ref3, RefFlag, true);
          return ref3;
        }
        var rawToReadonlyFlag = "__v_rawToReadonly";
        var rawToShallowReadonlyFlag = "__v_rawToShallowReadonly";
        function readonly(target4) {
          return createReadonly(target4, false);
        }
        function createReadonly(target4, shallow) {
          if (!isPlainObject2(target4)) {
            {
              if (isArray2(target4)) {
                warn$2("Vue 2 does not support readonly arrays.");
              } else if (isCollectionType(target4)) {
                warn$2("Vue 2 does not support readonly collection types such as Map or Set.");
              } else {
                warn$2("value cannot be made readonly: ".concat(typeof target4));
              }
            }
            return target4;
          }
          if (!Object.isExtensible(target4)) {
            warn$2("Vue 2 does not support creating readonly proxy for non-extensible object.");
          }
          if (isReadonly2(target4)) {
            return target4;
          }
          var existingFlag = shallow ? rawToShallowReadonlyFlag : rawToReadonlyFlag;
          var existingProxy = target4[existingFlag];
          if (existingProxy) {
            return existingProxy;
          }
          var proxy3 = Object.create(Object.getPrototypeOf(target4));
          def2(target4, existingFlag, proxy3);
          def2(proxy3, "__v_isReadonly", true);
          def2(proxy3, "__v_raw", target4);
          if (isRef2(target4)) {
            def2(proxy3, RefFlag, true);
          }
          if (shallow || isShallow(target4)) {
            def2(proxy3, "__v_isShallow", true);
          }
          var keys = Object.keys(target4);
          for (var i = 0; i < keys.length; i++) {
            defineReadonlyProperty(proxy3, target4, keys[i], shallow);
          }
          return proxy3;
        }
        function defineReadonlyProperty(proxy3, target4, key, shallow) {
          Object.defineProperty(proxy3, key, {
            enumerable: true,
            configurable: true,
            get: function() {
              var val = target4[key];
              return shallow || !isPlainObject2(val) ? val : readonly(val);
            },
            set: function() {
              warn$2('Set operation on key "'.concat(key, '" failed: target is readonly.'));
            }
          });
        }
        function shallowReadonly(target4) {
          return createReadonly(target4, true);
        }
        function computed(getterOrOptions, debugOptions) {
          var getter;
          var setter;
          var onlyGetter = isFunction2(getterOrOptions);
          if (onlyGetter) {
            getter = getterOrOptions;
            setter = function() {
              warn$2("Write operation failed: computed value is readonly");
            };
          } else {
            getter = getterOrOptions.get;
            setter = getterOrOptions.set;
          }
          var watcher = isServerRendering2() ? null : new Watcher2(currentInstance2, getter, noop2, { lazy: true });
          if (watcher && debugOptions) {
            watcher.onTrack = debugOptions.onTrack;
            watcher.onTrigger = debugOptions.onTrigger;
          }
          var ref3 = {
            // some libs rely on the presence effect for checking computed refs
            // from normal refs, but the implementation doesn't matter
            effect: watcher,
            get value() {
              if (watcher) {
                if (watcher.dirty) {
                  watcher.evaluate();
                }
                if (Dep2.target) {
                  if (Dep2.target.onTrack) {
                    Dep2.target.onTrack({
                      effect: Dep2.target,
                      target: ref3,
                      type: "get",
                      key: "value"
                    });
                  }
                  watcher.depend();
                }
                return watcher.value;
              } else {
                return getter();
              }
            },
            set value(newVal) {
              setter(newVal);
            }
          };
          def2(ref3, RefFlag, true);
          def2(ref3, "__v_isReadonly", onlyGetter);
          return ref3;
        }
        var mark;
        var measure;
        {
          var perf_1 = inBrowser2 && window.performance;
          if (perf_1 && // @ts-ignore
          perf_1.mark && // @ts-ignore
          perf_1.measure && // @ts-ignore
          perf_1.clearMarks && // @ts-ignore
          perf_1.clearMeasures) {
            mark = function(tag) {
              return perf_1.mark(tag);
            };
            measure = function(name, startTag, endTag2) {
              perf_1.measure(name, startTag, endTag2);
              perf_1.clearMarks(startTag);
              perf_1.clearMarks(endTag2);
            };
          }
        }
        var normalizeEvent2 = cached2(function(name) {
          var passive = name.charAt(0) === "&";
          name = passive ? name.slice(1) : name;
          var once3 = name.charAt(0) === "~";
          name = once3 ? name.slice(1) : name;
          var capture = name.charAt(0) === "!";
          name = capture ? name.slice(1) : name;
          return {
            name,
            once: once3,
            capture,
            passive
          };
        });
        function createFnInvoker2(fns, vm) {
          function invoker() {
            var fns2 = invoker.fns;
            if (isArray2(fns2)) {
              var cloned = fns2.slice();
              for (var i = 0; i < cloned.length; i++) {
                invokeWithErrorHandling2(cloned[i], null, arguments, vm, "v-on handler");
              }
            } else {
              return invokeWithErrorHandling2(fns2, null, arguments, vm, "v-on handler");
            }
          }
          invoker.fns = fns;
          return invoker;
        }
        function updateListeners2(on2, oldOn, add3, remove3, createOnceHandler3, vm) {
          var name, cur, old, event;
          for (name in on2) {
            cur = on2[name];
            old = oldOn[name];
            event = normalizeEvent2(name);
            if (isUndef2(cur)) {
              warn$2('Invalid handler for event "'.concat(event.name, '": got ') + String(cur), vm);
            } else if (isUndef2(old)) {
              if (isUndef2(cur.fns)) {
                cur = on2[name] = createFnInvoker2(cur, vm);
              }
              if (isTrue2(event.once)) {
                cur = on2[name] = createOnceHandler3(event.name, cur, event.capture);
              }
              add3(event.name, cur, event.capture, event.passive, event.params);
            } else if (cur !== old) {
              old.fns = cur;
              on2[name] = old;
            }
          }
          for (name in oldOn) {
            if (isUndef2(on2[name])) {
              event = normalizeEvent2(name);
              remove3(event.name, oldOn[name], event.capture);
            }
          }
        }
        function mergeVNodeHook2(def3, hookKey, hook) {
          if (def3 instanceof VNode2) {
            def3 = def3.data.hook || (def3.data.hook = {});
          }
          var invoker;
          var oldHook = def3[hookKey];
          function wrappedHook() {
            hook.apply(this, arguments);
            remove$22(invoker.fns, wrappedHook);
          }
          if (isUndef2(oldHook)) {
            invoker = createFnInvoker2([wrappedHook]);
          } else {
            if (isDef2(oldHook.fns) && isTrue2(oldHook.merged)) {
              invoker = oldHook;
              invoker.fns.push(wrappedHook);
            } else {
              invoker = createFnInvoker2([oldHook, wrappedHook]);
            }
          }
          invoker.merged = true;
          def3[hookKey] = invoker;
        }
        function extractPropsFromVNodeData2(data, Ctor, tag) {
          var propOptions = Ctor.options.props;
          if (isUndef2(propOptions)) {
            return;
          }
          var res = {};
          var attrs3 = data.attrs, props3 = data.props;
          if (isDef2(attrs3) || isDef2(props3)) {
            for (var key in propOptions) {
              var altKey = hyphenate2(key);
              {
                var keyInLowerCase = key.toLowerCase();
                if (key !== keyInLowerCase && attrs3 && hasOwn2(attrs3, keyInLowerCase)) {
                  tip('Prop "'.concat(keyInLowerCase, '" is passed to component ') + "".concat(formatComponentName(
                    // @ts-expect-error tag is string
                    tag || Ctor
                  ), ", but the declared prop name is") + ' "'.concat(key, '". ') + "Note that HTML attributes are case-insensitive and camelCased props need to use their kebab-case equivalents when using in-DOM " + 'templates. You should probably use "'.concat(altKey, '" instead of "').concat(key, '".'));
                }
              }
              checkProp2(res, props3, key, altKey, true) || checkProp2(res, attrs3, key, altKey, false);
            }
          }
          return res;
        }
        function checkProp2(res, hash2, key, altKey, preserve) {
          if (isDef2(hash2)) {
            if (hasOwn2(hash2, key)) {
              res[key] = hash2[key];
              if (!preserve) {
                delete hash2[key];
              }
              return true;
            } else if (hasOwn2(hash2, altKey)) {
              res[key] = hash2[altKey];
              if (!preserve) {
                delete hash2[altKey];
              }
              return true;
            }
          }
          return false;
        }
        function simpleNormalizeChildren2(children) {
          for (var i = 0; i < children.length; i++) {
            if (isArray2(children[i])) {
              return Array.prototype.concat.apply([], children);
            }
          }
          return children;
        }
        function normalizeChildren2(children) {
          return isPrimitive2(children) ? [createTextVNode2(children)] : isArray2(children) ? normalizeArrayChildren2(children) : void 0;
        }
        function isTextNode2(node) {
          return isDef2(node) && isDef2(node.text) && isFalse2(node.isComment);
        }
        function normalizeArrayChildren2(children, nestedIndex) {
          var res = [];
          var i, c, lastIndex, last;
          for (i = 0; i < children.length; i++) {
            c = children[i];
            if (isUndef2(c) || typeof c === "boolean")
              continue;
            lastIndex = res.length - 1;
            last = res[lastIndex];
            if (isArray2(c)) {
              if (c.length > 0) {
                c = normalizeArrayChildren2(c, "".concat(nestedIndex || "", "_").concat(i));
                if (isTextNode2(c[0]) && isTextNode2(last)) {
                  res[lastIndex] = createTextVNode2(last.text + c[0].text);
                  c.shift();
                }
                res.push.apply(res, c);
              }
            } else if (isPrimitive2(c)) {
              if (isTextNode2(last)) {
                res[lastIndex] = createTextVNode2(last.text + c);
              } else if (c !== "") {
                res.push(createTextVNode2(c));
              }
            } else {
              if (isTextNode2(c) && isTextNode2(last)) {
                res[lastIndex] = createTextVNode2(last.text + c.text);
              } else {
                if (isTrue2(children._isVList) && isDef2(c.tag) && isUndef2(c.key) && isDef2(nestedIndex)) {
                  c.key = "__vlist".concat(nestedIndex, "_").concat(i, "__");
                }
                res.push(c);
              }
            }
          }
          return res;
        }
        var SIMPLE_NORMALIZE2 = 1;
        var ALWAYS_NORMALIZE2 = 2;
        function createElement$12(context, tag, data, children, normalizationType, alwaysNormalize) {
          if (isArray2(data) || isPrimitive2(data)) {
            normalizationType = children;
            children = data;
            data = void 0;
          }
          if (isTrue2(alwaysNormalize)) {
            normalizationType = ALWAYS_NORMALIZE2;
          }
          return _createElement2(context, tag, data, children, normalizationType);
        }
        function _createElement2(context, tag, data, children, normalizationType) {
          if (isDef2(data) && isDef2(data.__ob__)) {
            warn$2("Avoid using observed data object as vnode data: ".concat(JSON.stringify(data), "\n") + "Always create fresh vnode data objects in each render!", context);
            return createEmptyVNode2();
          }
          if (isDef2(data) && isDef2(data.is)) {
            tag = data.is;
          }
          if (!tag) {
            return createEmptyVNode2();
          }
          if (isDef2(data) && isDef2(data.key) && !isPrimitive2(data.key)) {
            warn$2("Avoid using non-primitive value as key, use string/number value instead.", context);
          }
          if (isArray2(children) && isFunction2(children[0])) {
            data = data || {};
            data.scopedSlots = { default: children[0] };
            children.length = 0;
          }
          if (normalizationType === ALWAYS_NORMALIZE2) {
            children = normalizeChildren2(children);
          } else if (normalizationType === SIMPLE_NORMALIZE2) {
            children = simpleNormalizeChildren2(children);
          }
          var vnode, ns;
          if (typeof tag === "string") {
            var Ctor = void 0;
            ns = context.$vnode && context.$vnode.ns || config2.getTagNamespace(tag);
            if (config2.isReservedTag(tag)) {
              if (isDef2(data) && isDef2(data.nativeOn) && data.tag !== "component") {
                warn$2("The .native modifier for v-on is only valid on components but it was used on <".concat(tag, ">."), context);
              }
              vnode = new VNode2(config2.parsePlatformTagName(tag), data, children, void 0, void 0, context);
            } else if ((!data || !data.pre) && isDef2(Ctor = resolveAsset2(context.$options, "components", tag))) {
              vnode = createComponent2(Ctor, data, context, children, tag);
            } else {
              vnode = new VNode2(tag, data, children, void 0, void 0, context);
            }
          } else {
            vnode = createComponent2(tag, data, context, children);
          }
          if (isArray2(vnode)) {
            return vnode;
          } else if (isDef2(vnode)) {
            if (isDef2(ns))
              applyNS2(vnode, ns);
            if (isDef2(data))
              registerDeepBindings2(data);
            return vnode;
          } else {
            return createEmptyVNode2();
          }
        }
        function applyNS2(vnode, ns, force) {
          vnode.ns = ns;
          if (vnode.tag === "foreignObject") {
            ns = void 0;
            force = true;
          }
          if (isDef2(vnode.children)) {
            for (var i = 0, l = vnode.children.length; i < l; i++) {
              var child = vnode.children[i];
              if (isDef2(child.tag) && (isUndef2(child.ns) || isTrue2(force) && child.tag !== "svg")) {
                applyNS2(child, ns, force);
              }
            }
          }
        }
        function registerDeepBindings2(data) {
          if (isObject3(data.style)) {
            traverse2(data.style);
          }
          if (isObject3(data.class)) {
            traverse2(data.class);
          }
        }
        function renderList2(val, render) {
          var ret = null, i, l, keys, key;
          if (isArray2(val) || typeof val === "string") {
            ret = new Array(val.length);
            for (i = 0, l = val.length; i < l; i++) {
              ret[i] = render(val[i], i);
            }
          } else if (typeof val === "number") {
            ret = new Array(val);
            for (i = 0; i < val; i++) {
              ret[i] = render(i + 1, i);
            }
          } else if (isObject3(val)) {
            if (hasSymbol2 && val[Symbol.iterator]) {
              ret = [];
              var iterator = val[Symbol.iterator]();
              var result = iterator.next();
              while (!result.done) {
                ret.push(render(result.value, ret.length));
                result = iterator.next();
              }
            } else {
              keys = Object.keys(val);
              ret = new Array(keys.length);
              for (i = 0, l = keys.length; i < l; i++) {
                key = keys[i];
                ret[i] = render(val[key], key, i);
              }
            }
          }
          if (!isDef2(ret)) {
            ret = [];
          }
          ret._isVList = true;
          return ret;
        }
        function renderSlot2(name, fallbackRender, props3, bindObject) {
          var scopedSlotFn = this.$scopedSlots[name];
          var nodes;
          if (scopedSlotFn) {
            props3 = props3 || {};
            if (bindObject) {
              if (!isObject3(bindObject)) {
                warn$2("slot v-bind without argument expects an Object", this);
              }
              props3 = extend2(extend2({}, bindObject), props3);
            }
            nodes = scopedSlotFn(props3) || (isFunction2(fallbackRender) ? fallbackRender() : fallbackRender);
          } else {
            nodes = this.$slots[name] || (isFunction2(fallbackRender) ? fallbackRender() : fallbackRender);
          }
          var target4 = props3 && props3.slot;
          if (target4) {
            return this.$createElement("template", { slot: target4 }, nodes);
          } else {
            return nodes;
          }
        }
        function resolveFilter2(id) {
          return resolveAsset2(this.$options, "filters", id, true) || identity2;
        }
        function isKeyNotMatch2(expect, actual) {
          if (isArray2(expect)) {
            return expect.indexOf(actual) === -1;
          } else {
            return expect !== actual;
          }
        }
        function checkKeyCodes2(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
          var mappedKeyCode = config2.keyCodes[key] || builtInKeyCode;
          if (builtInKeyName && eventKeyName && !config2.keyCodes[key]) {
            return isKeyNotMatch2(builtInKeyName, eventKeyName);
          } else if (mappedKeyCode) {
            return isKeyNotMatch2(mappedKeyCode, eventKeyCode);
          } else if (eventKeyName) {
            return hyphenate2(eventKeyName) !== key;
          }
          return eventKeyCode === void 0;
        }
        function bindObjectProps2(data, tag, value, asProp, isSync) {
          if (value) {
            if (!isObject3(value)) {
              warn$2("v-bind without argument expects an Object or Array value", this);
            } else {
              if (isArray2(value)) {
                value = toObject2(value);
              }
              var hash2 = void 0;
              var _loop_1 = function(key2) {
                if (key2 === "class" || key2 === "style" || isReservedAttribute2(key2)) {
                  hash2 = data;
                } else {
                  var type = data.attrs && data.attrs.type;
                  hash2 = asProp || config2.mustUseProp(tag, type, key2) ? data.domProps || (data.domProps = {}) : data.attrs || (data.attrs = {});
                }
                var camelizedKey = camelize2(key2);
                var hyphenatedKey = hyphenate2(key2);
                if (!(camelizedKey in hash2) && !(hyphenatedKey in hash2)) {
                  hash2[key2] = value[key2];
                  if (isSync) {
                    var on2 = data.on || (data.on = {});
                    on2["update:".concat(key2)] = function($event) {
                      value[key2] = $event;
                    };
                  }
                }
              };
              for (var key in value) {
                _loop_1(key);
              }
            }
          }
          return data;
        }
        function renderStatic2(index4, isInFor) {
          var cached3 = this._staticTrees || (this._staticTrees = []);
          var tree = cached3[index4];
          if (tree && !isInFor) {
            return tree;
          }
          tree = cached3[index4] = this.$options.staticRenderFns[index4].call(
            this._renderProxy,
            this._c,
            this
            // for render fns generated for functional component templates
          );
          markStatic$1(tree, "__static__".concat(index4), false);
          return tree;
        }
        function markOnce2(tree, index4, key) {
          markStatic$1(tree, "__once__".concat(index4).concat(key ? "_".concat(key) : ""), true);
          return tree;
        }
        function markStatic$1(tree, key, isOnce) {
          if (isArray2(tree)) {
            for (var i = 0; i < tree.length; i++) {
              if (tree[i] && typeof tree[i] !== "string") {
                markStaticNode2(tree[i], "".concat(key, "_").concat(i), isOnce);
              }
            }
          } else {
            markStaticNode2(tree, key, isOnce);
          }
        }
        function markStaticNode2(node, key, isOnce) {
          node.isStatic = true;
          node.key = key;
          node.isOnce = isOnce;
        }
        function bindObjectListeners2(data, value) {
          if (value) {
            if (!isPlainObject2(value)) {
              warn$2("v-on without argument expects an Object value", this);
            } else {
              var on2 = data.on = data.on ? extend2({}, data.on) : {};
              for (var key in value) {
                var existing = on2[key];
                var ours = value[key];
                on2[key] = existing ? [].concat(existing, ours) : ours;
              }
            }
          }
          return data;
        }
        function resolveScopedSlots2(fns, res, hasDynamicKeys, contentHashKey) {
          res = res || { $stable: !hasDynamicKeys };
          for (var i = 0; i < fns.length; i++) {
            var slot = fns[i];
            if (isArray2(slot)) {
              resolveScopedSlots2(slot, res, hasDynamicKeys);
            } else if (slot) {
              if (slot.proxy) {
                slot.fn.proxy = true;
              }
              res[slot.key] = slot.fn;
            }
          }
          if (contentHashKey) {
            res.$key = contentHashKey;
          }
          return res;
        }
        function bindDynamicKeys2(baseObj, values) {
          for (var i = 0; i < values.length; i += 2) {
            var key = values[i];
            if (typeof key === "string" && key) {
              baseObj[values[i]] = values[i + 1];
            } else if (key !== "" && key !== null) {
              warn$2("Invalid value for dynamic directive argument (expected string or null): ".concat(key), this);
            }
          }
          return baseObj;
        }
        function prependModifier2(value, symbol) {
          return typeof value === "string" ? symbol + value : value;
        }
        function installRenderHelpers2(target4) {
          target4._o = markOnce2;
          target4._n = toNumber2;
          target4._s = toString2;
          target4._l = renderList2;
          target4._t = renderSlot2;
          target4._q = looseEqual2;
          target4._i = looseIndexOf2;
          target4._m = renderStatic2;
          target4._f = resolveFilter2;
          target4._k = checkKeyCodes2;
          target4._b = bindObjectProps2;
          target4._v = createTextVNode2;
          target4._e = createEmptyVNode2;
          target4._u = resolveScopedSlots2;
          target4._g = bindObjectListeners2;
          target4._d = bindDynamicKeys2;
          target4._p = prependModifier2;
        }
        function resolveSlots2(children, context) {
          if (!children || !children.length) {
            return {};
          }
          var slots = {};
          for (var i = 0, l = children.length; i < l; i++) {
            var child = children[i];
            var data = child.data;
            if (data && data.attrs && data.attrs.slot) {
              delete data.attrs.slot;
            }
            if ((child.context === context || child.fnContext === context) && data && data.slot != null) {
              var name_1 = data.slot;
              var slot = slots[name_1] || (slots[name_1] = []);
              if (child.tag === "template") {
                slot.push.apply(slot, child.children || []);
              } else {
                slot.push(child);
              }
            } else {
              (slots.default || (slots.default = [])).push(child);
            }
          }
          for (var name_2 in slots) {
            if (slots[name_2].every(isWhitespace2)) {
              delete slots[name_2];
            }
          }
          return slots;
        }
        function isWhitespace2(node) {
          return node.isComment && !node.asyncFactory || node.text === " ";
        }
        function isAsyncPlaceholder2(node) {
          return node.isComment && node.asyncFactory;
        }
        function normalizeScopedSlots2(ownerVm, scopedSlots, normalSlots, prevScopedSlots) {
          var res;
          var hasNormalSlots = Object.keys(normalSlots).length > 0;
          var isStable = scopedSlots ? !!scopedSlots.$stable : !hasNormalSlots;
          var key = scopedSlots && scopedSlots.$key;
          if (!scopedSlots) {
            res = {};
          } else if (scopedSlots._normalized) {
            return scopedSlots._normalized;
          } else if (isStable && prevScopedSlots && prevScopedSlots !== emptyObject2 && key === prevScopedSlots.$key && !hasNormalSlots && !prevScopedSlots.$hasNormal) {
            return prevScopedSlots;
          } else {
            res = {};
            for (var key_1 in scopedSlots) {
              if (scopedSlots[key_1] && key_1[0] !== "$") {
                res[key_1] = normalizeScopedSlot2(ownerVm, normalSlots, key_1, scopedSlots[key_1]);
              }
            }
          }
          for (var key_2 in normalSlots) {
            if (!(key_2 in res)) {
              res[key_2] = proxyNormalSlot2(normalSlots, key_2);
            }
          }
          if (scopedSlots && Object.isExtensible(scopedSlots)) {
            scopedSlots._normalized = res;
          }
          def2(res, "$stable", isStable);
          def2(res, "$key", key);
          def2(res, "$hasNormal", hasNormalSlots);
          return res;
        }
        function normalizeScopedSlot2(vm, normalSlots, key, fn) {
          var normalized = function() {
            var cur = currentInstance2;
            setCurrentInstance2(vm);
            var res = arguments.length ? fn.apply(null, arguments) : fn({});
            res = res && typeof res === "object" && !isArray2(res) ? [res] : normalizeChildren2(res);
            var vnode = res && res[0];
            setCurrentInstance2(cur);
            return res && (!vnode || res.length === 1 && vnode.isComment && !isAsyncPlaceholder2(vnode)) ? void 0 : res;
          };
          if (fn.proxy) {
            Object.defineProperty(normalSlots, key, {
              get: normalized,
              enumerable: true,
              configurable: true
            });
          }
          return normalized;
        }
        function proxyNormalSlot2(slots, key) {
          return function() {
            return slots[key];
          };
        }
        function initSetup2(vm) {
          var options = vm.$options;
          var setup = options.setup;
          if (setup) {
            var ctx = vm._setupContext = createSetupContext2(vm);
            setCurrentInstance2(vm);
            pushTarget2();
            var setupResult = invokeWithErrorHandling2(setup, null, [vm._props || shallowReactive2({}), ctx], vm, "setup");
            popTarget2();
            setCurrentInstance2();
            if (isFunction2(setupResult)) {
              options.render = setupResult;
            } else if (isObject3(setupResult)) {
              if (setupResult instanceof VNode2) {
                warn$2("setup() should not return VNodes directly - return a render function instead.");
              }
              vm._setupState = setupResult;
              if (!setupResult.__sfc) {
                for (var key in setupResult) {
                  if (!isReserved2(key)) {
                    proxyWithRefUnwrap2(vm, setupResult, key);
                  } else {
                    warn$2("Avoid using variables that start with _ or $ in setup().");
                  }
                }
              } else {
                var proxy3 = vm._setupProxy = {};
                for (var key in setupResult) {
                  if (key !== "__sfc") {
                    proxyWithRefUnwrap2(proxy3, setupResult, key);
                  }
                }
              }
            } else if (setupResult !== void 0) {
              warn$2("setup() should return an object. Received: ".concat(setupResult === null ? "null" : typeof setupResult));
            }
          }
        }
        function createSetupContext2(vm) {
          var exposeCalled = false;
          return {
            get attrs() {
              if (!vm._attrsProxy) {
                var proxy3 = vm._attrsProxy = {};
                def2(proxy3, "_v_attr_proxy", true);
                syncSetupProxy2(proxy3, vm.$attrs, emptyObject2, vm, "$attrs");
              }
              return vm._attrsProxy;
            },
            get listeners() {
              if (!vm._listenersProxy) {
                var proxy3 = vm._listenersProxy = {};
                syncSetupProxy2(proxy3, vm.$listeners, emptyObject2, vm, "$listeners");
              }
              return vm._listenersProxy;
            },
            get slots() {
              return initSlotsProxy2(vm);
            },
            emit: bind$1(vm.$emit, vm),
            expose: function(exposed) {
              {
                if (exposeCalled) {
                  warn$2("expose() should be called only once per setup().", vm);
                }
                exposeCalled = true;
              }
              if (exposed) {
                Object.keys(exposed).forEach(function(key) {
                  return proxyWithRefUnwrap2(vm, exposed, key);
                });
              }
            }
          };
        }
        function syncSetupProxy2(to, from, prev, instance, type) {
          var changed = false;
          for (var key in from) {
            if (!(key in to)) {
              changed = true;
              defineProxyAttr2(to, key, instance, type);
            } else if (from[key] !== prev[key]) {
              changed = true;
            }
          }
          for (var key in to) {
            if (!(key in from)) {
              changed = true;
              delete to[key];
            }
          }
          return changed;
        }
        function defineProxyAttr2(proxy3, key, instance, type) {
          Object.defineProperty(proxy3, key, {
            enumerable: true,
            configurable: true,
            get: function() {
              return instance[type][key];
            }
          });
        }
        function initSlotsProxy2(vm) {
          if (!vm._slotsProxy) {
            syncSetupSlots2(vm._slotsProxy = {}, vm.$scopedSlots);
          }
          return vm._slotsProxy;
        }
        function syncSetupSlots2(to, from) {
          for (var key in from) {
            to[key] = from[key];
          }
          for (var key in to) {
            if (!(key in from)) {
              delete to[key];
            }
          }
        }
        function useSlots() {
          return getContext().slots;
        }
        function useAttrs() {
          return getContext().attrs;
        }
        function useListeners() {
          return getContext().listeners;
        }
        function getContext() {
          if (!currentInstance2) {
            warn$2("useContext() called without active instance.");
          }
          var vm = currentInstance2;
          return vm._setupContext || (vm._setupContext = createSetupContext2(vm));
        }
        function mergeDefaults(raw, defaults) {
          var props3 = isArray2(raw) ? raw.reduce(function(normalized, p) {
            return normalized[p] = {}, normalized;
          }, {}) : raw;
          for (var key in defaults) {
            var opt = props3[key];
            if (opt) {
              if (isArray2(opt) || isFunction2(opt)) {
                props3[key] = { type: opt, default: defaults[key] };
              } else {
                opt.default = defaults[key];
              }
            } else if (opt === null) {
              props3[key] = { default: defaults[key] };
            } else {
              warn$2('props default key "'.concat(key, '" has no corresponding declaration.'));
            }
          }
          return props3;
        }
        function initRender2(vm) {
          vm._vnode = null;
          vm._staticTrees = null;
          var options = vm.$options;
          var parentVnode = vm.$vnode = options._parentVnode;
          var renderContext = parentVnode && parentVnode.context;
          vm.$slots = resolveSlots2(options._renderChildren, renderContext);
          vm.$scopedSlots = parentVnode ? normalizeScopedSlots2(vm.$parent, parentVnode.data.scopedSlots, vm.$slots) : emptyObject2;
          vm._c = function(a, b, c, d) {
            return createElement$12(vm, a, b, c, d, false);
          };
          vm.$createElement = function(a, b, c, d) {
            return createElement$12(vm, a, b, c, d, true);
          };
          var parentData = parentVnode && parentVnode.data;
          {
            defineReactive2(vm, "$attrs", parentData && parentData.attrs || emptyObject2, function() {
              !isUpdatingChildComponent && warn$2("$attrs is readonly.", vm);
            }, true);
            defineReactive2(vm, "$listeners", options._parentListeners || emptyObject2, function() {
              !isUpdatingChildComponent && warn$2("$listeners is readonly.", vm);
            }, true);
          }
        }
        var currentRenderingInstance2 = null;
        function renderMixin2(Vue5) {
          installRenderHelpers2(Vue5.prototype);
          Vue5.prototype.$nextTick = function(fn) {
            return nextTick2(fn, this);
          };
          Vue5.prototype._render = function() {
            var vm = this;
            var _a2 = vm.$options, render = _a2.render, _parentVnode = _a2._parentVnode;
            if (_parentVnode && vm._isMounted) {
              vm.$scopedSlots = normalizeScopedSlots2(vm.$parent, _parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
              if (vm._slotsProxy) {
                syncSetupSlots2(vm._slotsProxy, vm.$scopedSlots);
              }
            }
            vm.$vnode = _parentVnode;
            var prevInst = currentInstance2;
            var prevRenderInst = currentRenderingInstance2;
            var vnode;
            try {
              setCurrentInstance2(vm);
              currentRenderingInstance2 = vm;
              vnode = render.call(vm._renderProxy, vm.$createElement);
            } catch (e) {
              handleError2(e, vm, "render");
              if (vm.$options.renderError) {
                try {
                  vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                } catch (e2) {
                  handleError2(e2, vm, "renderError");
                  vnode = vm._vnode;
                }
              } else {
                vnode = vm._vnode;
              }
            } finally {
              currentRenderingInstance2 = prevRenderInst;
              setCurrentInstance2(prevInst);
            }
            if (isArray2(vnode) && vnode.length === 1) {
              vnode = vnode[0];
            }
            if (!(vnode instanceof VNode2)) {
              if (isArray2(vnode)) {
                warn$2("Multiple root nodes returned from render function. Render function should return a single root node.", vm);
              }
              vnode = createEmptyVNode2();
            }
            vnode.parent = _parentVnode;
            return vnode;
          };
        }
        function ensureCtor2(comp, base) {
          if (comp.__esModule || hasSymbol2 && comp[Symbol.toStringTag] === "Module") {
            comp = comp.default;
          }
          return isObject3(comp) ? base.extend(comp) : comp;
        }
        function createAsyncPlaceholder2(factory, data, context, children, tag) {
          var node = createEmptyVNode2();
          node.asyncFactory = factory;
          node.asyncMeta = { data, context, children, tag };
          return node;
        }
        function resolveAsyncComponent2(factory, baseCtor) {
          if (isTrue2(factory.error) && isDef2(factory.errorComp)) {
            return factory.errorComp;
          }
          if (isDef2(factory.resolved)) {
            return factory.resolved;
          }
          var owner = currentRenderingInstance2;
          if (owner && isDef2(factory.owners) && factory.owners.indexOf(owner) === -1) {
            factory.owners.push(owner);
          }
          if (isTrue2(factory.loading) && isDef2(factory.loadingComp)) {
            return factory.loadingComp;
          }
          if (owner && !isDef2(factory.owners)) {
            var owners_1 = factory.owners = [owner];
            var sync_1 = true;
            var timerLoading_1 = null;
            var timerTimeout_1 = null;
            owner.$on("hook:destroyed", function() {
              return remove$22(owners_1, owner);
            });
            var forceRender_1 = function(renderCompleted) {
              for (var i = 0, l = owners_1.length; i < l; i++) {
                owners_1[i].$forceUpdate();
              }
              if (renderCompleted) {
                owners_1.length = 0;
                if (timerLoading_1 !== null) {
                  clearTimeout(timerLoading_1);
                  timerLoading_1 = null;
                }
                if (timerTimeout_1 !== null) {
                  clearTimeout(timerTimeout_1);
                  timerTimeout_1 = null;
                }
              }
            };
            var resolve = once2(function(res) {
              factory.resolved = ensureCtor2(res, baseCtor);
              if (!sync_1) {
                forceRender_1(true);
              } else {
                owners_1.length = 0;
              }
            });
            var reject_1 = once2(function(reason) {
              warn$2("Failed to resolve async component: ".concat(String(factory)) + (reason ? "\nReason: ".concat(reason) : ""));
              if (isDef2(factory.errorComp)) {
                factory.error = true;
                forceRender_1(true);
              }
            });
            var res_1 = factory(resolve, reject_1);
            if (isObject3(res_1)) {
              if (isPromise3(res_1)) {
                if (isUndef2(factory.resolved)) {
                  res_1.then(resolve, reject_1);
                }
              } else if (isPromise3(res_1.component)) {
                res_1.component.then(resolve, reject_1);
                if (isDef2(res_1.error)) {
                  factory.errorComp = ensureCtor2(res_1.error, baseCtor);
                }
                if (isDef2(res_1.loading)) {
                  factory.loadingComp = ensureCtor2(res_1.loading, baseCtor);
                  if (res_1.delay === 0) {
                    factory.loading = true;
                  } else {
                    timerLoading_1 = setTimeout(function() {
                      timerLoading_1 = null;
                      if (isUndef2(factory.resolved) && isUndef2(factory.error)) {
                        factory.loading = true;
                        forceRender_1(false);
                      }
                    }, res_1.delay || 200);
                  }
                }
                if (isDef2(res_1.timeout)) {
                  timerTimeout_1 = setTimeout(function() {
                    timerTimeout_1 = null;
                    if (isUndef2(factory.resolved)) {
                      reject_1("timeout (".concat(res_1.timeout, "ms)"));
                    }
                  }, res_1.timeout);
                }
              }
            }
            sync_1 = false;
            return factory.loading ? factory.loadingComp : factory.resolved;
          }
        }
        function getFirstComponentChild2(children) {
          if (isArray2(children)) {
            for (var i = 0; i < children.length; i++) {
              var c = children[i];
              if (isDef2(c) && (isDef2(c.componentOptions) || isAsyncPlaceholder2(c))) {
                return c;
              }
            }
          }
        }
        function initEvents2(vm) {
          vm._events = /* @__PURE__ */ Object.create(null);
          vm._hasHookEvent = false;
          var listeners = vm.$options._parentListeners;
          if (listeners) {
            updateComponentListeners2(vm, listeners);
          }
        }
        var target$12;
        function add$12(event, fn) {
          target$12.$on(event, fn);
        }
        function remove$12(event, fn) {
          target$12.$off(event, fn);
        }
        function createOnceHandler$12(event, fn) {
          var _target = target$12;
          return function onceHandler() {
            var res = fn.apply(null, arguments);
            if (res !== null) {
              _target.$off(event, onceHandler);
            }
          };
        }
        function updateComponentListeners2(vm, listeners, oldListeners) {
          target$12 = vm;
          updateListeners2(listeners, oldListeners || {}, add$12, remove$12, createOnceHandler$12, vm);
          target$12 = void 0;
        }
        function eventsMixin2(Vue5) {
          var hookRE = /^hook:/;
          Vue5.prototype.$on = function(event, fn) {
            var vm = this;
            if (isArray2(event)) {
              for (var i = 0, l = event.length; i < l; i++) {
                vm.$on(event[i], fn);
              }
            } else {
              (vm._events[event] || (vm._events[event] = [])).push(fn);
              if (hookRE.test(event)) {
                vm._hasHookEvent = true;
              }
            }
            return vm;
          };
          Vue5.prototype.$once = function(event, fn) {
            var vm = this;
            function on2() {
              vm.$off(event, on2);
              fn.apply(vm, arguments);
            }
            on2.fn = fn;
            vm.$on(event, on2);
            return vm;
          };
          Vue5.prototype.$off = function(event, fn) {
            var vm = this;
            if (!arguments.length) {
              vm._events = /* @__PURE__ */ Object.create(null);
              return vm;
            }
            if (isArray2(event)) {
              for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
                vm.$off(event[i_1], fn);
              }
              return vm;
            }
            var cbs = vm._events[event];
            if (!cbs) {
              return vm;
            }
            if (!fn) {
              vm._events[event] = null;
              return vm;
            }
            var cb;
            var i = cbs.length;
            while (i--) {
              cb = cbs[i];
              if (cb === fn || cb.fn === fn) {
                cbs.splice(i, 1);
                break;
              }
            }
            return vm;
          };
          Vue5.prototype.$emit = function(event) {
            var vm = this;
            {
              var lowerCaseEvent = event.toLowerCase();
              if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
                tip('Event "'.concat(lowerCaseEvent, '" is emitted in component ') + "".concat(formatComponentName(vm), ' but the handler is registered for "').concat(event, '". ') + "Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. " + 'You should probably use "'.concat(hyphenate2(event), '" instead of "').concat(event, '".'));
              }
            }
            var cbs = vm._events[event];
            if (cbs) {
              cbs = cbs.length > 1 ? toArray2(cbs) : cbs;
              var args = toArray2(arguments, 1);
              var info = 'event handler for "'.concat(event, '"');
              for (var i = 0, l = cbs.length; i < l; i++) {
                invokeWithErrorHandling2(cbs[i], vm, args, vm, info);
              }
            }
            return vm;
          };
        }
        var activeEffectScope2;
        var EffectScope2 = (
          /** @class */
          (function() {
            function EffectScope3(detached) {
              if (detached === void 0) {
                detached = false;
              }
              this.detached = detached;
              this.active = true;
              this.effects = [];
              this.cleanups = [];
              this.parent = activeEffectScope2;
              if (!detached && activeEffectScope2) {
                this.index = (activeEffectScope2.scopes || (activeEffectScope2.scopes = [])).push(this) - 1;
              }
            }
            EffectScope3.prototype.run = function(fn) {
              if (this.active) {
                var currentEffectScope = activeEffectScope2;
                try {
                  activeEffectScope2 = this;
                  return fn();
                } finally {
                  activeEffectScope2 = currentEffectScope;
                }
              } else {
                warn$2("cannot run an inactive effect scope.");
              }
            };
            EffectScope3.prototype.on = function() {
              activeEffectScope2 = this;
            };
            EffectScope3.prototype.off = function() {
              activeEffectScope2 = this.parent;
            };
            EffectScope3.prototype.stop = function(fromParent) {
              if (this.active) {
                var i = void 0, l = void 0;
                for (i = 0, l = this.effects.length; i < l; i++) {
                  this.effects[i].teardown();
                }
                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);
                  }
                }
                if (!this.detached && this.parent && !fromParent) {
                  var last = this.parent.scopes.pop();
                  if (last && last !== this) {
                    this.parent.scopes[this.index] = last;
                    last.index = this.index;
                  }
                }
                this.parent = void 0;
                this.active = false;
              }
            };
            return EffectScope3;
          })()
        );
        function effectScope(detached) {
          return new EffectScope2(detached);
        }
        function recordEffectScope2(effect2, scope) {
          if (scope === void 0) {
            scope = activeEffectScope2;
          }
          if (scope && scope.active) {
            scope.effects.push(effect2);
          }
        }
        function getCurrentScope2() {
          return activeEffectScope2;
        }
        function onScopeDispose(fn) {
          if (activeEffectScope2) {
            activeEffectScope2.cleanups.push(fn);
          } else {
            warn$2("onScopeDispose() is called when there is no active effect scope to be associated with.");
          }
        }
        var activeInstance2 = null;
        var isUpdatingChildComponent = false;
        function setActiveInstance2(vm) {
          var prevActiveInstance = activeInstance2;
          activeInstance2 = vm;
          return function() {
            activeInstance2 = prevActiveInstance;
          };
        }
        function initLifecycle2(vm) {
          var options = vm.$options;
          var parent = options.parent;
          if (parent && !options.abstract) {
            while (parent.$options.abstract && parent.$parent) {
              parent = parent.$parent;
            }
            parent.$children.push(vm);
          }
          vm.$parent = parent;
          vm.$root = parent ? parent.$root : vm;
          vm.$children = [];
          vm.$refs = {};
          vm._provided = parent ? parent._provided : /* @__PURE__ */ Object.create(null);
          vm._watcher = null;
          vm._inactive = null;
          vm._directInactive = false;
          vm._isMounted = false;
          vm._isDestroyed = false;
          vm._isBeingDestroyed = false;
        }
        function lifecycleMixin2(Vue5) {
          Vue5.prototype._update = function(vnode, hydrating) {
            var vm = this;
            var prevEl = vm.$el;
            var prevVnode = vm._vnode;
            var restoreActiveInstance = setActiveInstance2(vm);
            vm._vnode = vnode;
            if (!prevVnode) {
              vm.$el = vm.__patch__(
                vm.$el,
                vnode,
                hydrating,
                false
                /* removeOnly */
              );
            } else {
              vm.$el = vm.__patch__(prevVnode, vnode);
            }
            restoreActiveInstance();
            if (prevEl) {
              prevEl.__vue__ = null;
            }
            if (vm.$el) {
              vm.$el.__vue__ = vm;
            }
            var wrapper = vm;
            while (wrapper && wrapper.$vnode && wrapper.$parent && wrapper.$vnode === wrapper.$parent._vnode) {
              wrapper.$parent.$el = wrapper.$el;
              wrapper = wrapper.$parent;
            }
          };
          Vue5.prototype.$forceUpdate = function() {
            var vm = this;
            if (vm._watcher) {
              vm._watcher.update();
            }
          };
          Vue5.prototype.$destroy = function() {
            var vm = this;
            if (vm._isBeingDestroyed) {
              return;
            }
            callHook$12(vm, "beforeDestroy");
            vm._isBeingDestroyed = true;
            var parent = vm.$parent;
            if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
              remove$22(parent.$children, vm);
            }
            vm._scope.stop();
            if (vm._data.__ob__) {
              vm._data.__ob__.vmCount--;
            }
            vm._isDestroyed = true;
            vm.__patch__(vm._vnode, null);
            callHook$12(vm, "destroyed");
            vm.$off();
            if (vm.$el) {
              vm.$el.__vue__ = null;
            }
            if (vm.$vnode) {
              vm.$vnode.parent = null;
            }
          };
        }
        function mountComponent2(vm, el, hydrating) {
          vm.$el = el;
          if (!vm.$options.render) {
            vm.$options.render = createEmptyVNode2;
            {
              if (vm.$options.template && vm.$options.template.charAt(0) !== "#" || vm.$options.el || el) {
                warn$2("You are using the runtime-only build of Vue where the template compiler is not available. Either pre-compile the templates into render functions, or use the compiler-included build.", vm);
              } else {
                warn$2("Failed to mount component: template or render function not defined.", vm);
              }
            }
          }
          callHook$12(vm, "beforeMount");
          var updateComponent;
          if (config2.performance && mark) {
            updateComponent = function() {
              var name = vm._name;
              var id = vm._uid;
              var startTag = "vue-perf-start:".concat(id);
              var endTag2 = "vue-perf-end:".concat(id);
              mark(startTag);
              var vnode = vm._render();
              mark(endTag2);
              measure("vue ".concat(name, " render"), startTag, endTag2);
              mark(startTag);
              vm._update(vnode, hydrating);
              mark(endTag2);
              measure("vue ".concat(name, " patch"), startTag, endTag2);
            };
          } else {
            updateComponent = function() {
              vm._update(vm._render(), hydrating);
            };
          }
          var watcherOptions = {
            before: function() {
              if (vm._isMounted && !vm._isDestroyed) {
                callHook$12(vm, "beforeUpdate");
              }
            }
          };
          {
            watcherOptions.onTrack = function(e) {
              return callHook$12(vm, "renderTracked", [e]);
            };
            watcherOptions.onTrigger = function(e) {
              return callHook$12(vm, "renderTriggered", [e]);
            };
          }
          new Watcher2(
            vm,
            updateComponent,
            noop2,
            watcherOptions,
            true
            /* isRenderWatcher */
          );
          hydrating = false;
          var preWatchers = vm._preWatchers;
          if (preWatchers) {
            for (var i = 0; i < preWatchers.length; i++) {
              preWatchers[i].run();
            }
          }
          if (vm.$vnode == null) {
            vm._isMounted = true;
            callHook$12(vm, "mounted");
          }
          return vm;
        }
        function updateChildComponent2(vm, propsData, listeners, parentVnode, renderChildren) {
          {
            isUpdatingChildComponent = true;
          }
          var newScopedSlots = parentVnode.data.scopedSlots;
          var oldScopedSlots = vm.$scopedSlots;
          var hasDynamicScopedSlot = !!(newScopedSlots && !newScopedSlots.$stable || oldScopedSlots !== emptyObject2 && !oldScopedSlots.$stable || newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key || !newScopedSlots && vm.$scopedSlots.$key);
          var needsForceUpdate = !!(renderChildren || // has new static slots
          vm.$options._renderChildren || // has old static slots
          hasDynamicScopedSlot);
          var prevVNode = vm.$vnode;
          vm.$options._parentVnode = parentVnode;
          vm.$vnode = parentVnode;
          if (vm._vnode) {
            vm._vnode.parent = parentVnode;
          }
          vm.$options._renderChildren = renderChildren;
          var attrs3 = parentVnode.data.attrs || emptyObject2;
          if (vm._attrsProxy) {
            if (syncSetupProxy2(vm._attrsProxy, attrs3, prevVNode.data && prevVNode.data.attrs || emptyObject2, vm, "$attrs")) {
              needsForceUpdate = true;
            }
          }
          vm.$attrs = attrs3;
          listeners = listeners || emptyObject2;
          var prevListeners = vm.$options._parentListeners;
          if (vm._listenersProxy) {
            syncSetupProxy2(vm._listenersProxy, listeners, prevListeners || emptyObject2, vm, "$listeners");
          }
          vm.$listeners = vm.$options._parentListeners = listeners;
          updateComponentListeners2(vm, listeners, prevListeners);
          if (propsData && vm.$options.props) {
            toggleObserving2(false);
            var props3 = vm._props;
            var propKeys = vm.$options._propKeys || [];
            for (var i = 0; i < propKeys.length; i++) {
              var key = propKeys[i];
              var propOptions = vm.$options.props;
              props3[key] = validateProp2(key, propOptions, propsData, vm);
            }
            toggleObserving2(true);
            vm.$options.propsData = propsData;
          }
          if (needsForceUpdate) {
            vm.$slots = resolveSlots2(renderChildren, parentVnode.context);
            vm.$forceUpdate();
          }
          {
            isUpdatingChildComponent = false;
          }
        }
        function isInInactiveTree2(vm) {
          while (vm && (vm = vm.$parent)) {
            if (vm._inactive)
              return true;
          }
          return false;
        }
        function activateChildComponent2(vm, direct) {
          if (direct) {
            vm._directInactive = false;
            if (isInInactiveTree2(vm)) {
              return;
            }
          } else if (vm._directInactive) {
            return;
          }
          if (vm._inactive || vm._inactive === null) {
            vm._inactive = false;
            for (var i = 0; i < vm.$children.length; i++) {
              activateChildComponent2(vm.$children[i]);
            }
            callHook$12(vm, "activated");
          }
        }
        function deactivateChildComponent2(vm, direct) {
          if (direct) {
            vm._directInactive = true;
            if (isInInactiveTree2(vm)) {
              return;
            }
          }
          if (!vm._inactive) {
            vm._inactive = true;
            for (var i = 0; i < vm.$children.length; i++) {
              deactivateChildComponent2(vm.$children[i]);
            }
            callHook$12(vm, "deactivated");
          }
        }
        function callHook$12(vm, hook, args, setContext) {
          if (setContext === void 0) {
            setContext = true;
          }
          pushTarget2();
          var prevInst = currentInstance2;
          var prevScope = getCurrentScope2();
          setContext && setCurrentInstance2(vm);
          var handlers = vm.$options[hook];
          var info = "".concat(hook, " hook");
          if (handlers) {
            for (var i = 0, j = handlers.length; i < j; i++) {
              invokeWithErrorHandling2(handlers[i], vm, args || null, vm, info);
            }
          }
          if (vm._hasHookEvent) {
            vm.$emit("hook:" + hook);
          }
          if (setContext) {
            setCurrentInstance2(prevInst);
            prevScope && prevScope.on();
          }
          popTarget2();
        }
        var MAX_UPDATE_COUNT = 100;
        var queue2 = [];
        var activatedChildren2 = [];
        var has2 = {};
        var circular = {};
        var waiting2 = false;
        var flushing2 = false;
        var index$1 = 0;
        function resetSchedulerState2() {
          index$1 = queue2.length = activatedChildren2.length = 0;
          has2 = {};
          {
            circular = {};
          }
          waiting2 = flushing2 = false;
        }
        var currentFlushTimestamp2 = 0;
        var getNow2 = Date.now;
        if (inBrowser2 && !isIE2) {
          var performance_1 = window.performance;
          if (performance_1 && typeof performance_1.now === "function" && getNow2() > document.createEvent("Event").timeStamp) {
            getNow2 = function() {
              return performance_1.now();
            };
          }
        }
        var sortCompareFn2 = function(a, b) {
          if (a.post) {
            if (!b.post)
              return 1;
          } else if (b.post) {
            return -1;
          }
          return a.id - b.id;
        };
        function flushSchedulerQueue2() {
          currentFlushTimestamp2 = getNow2();
          flushing2 = true;
          var watcher, id;
          queue2.sort(sortCompareFn2);
          for (index$1 = 0; index$1 < queue2.length; index$1++) {
            watcher = queue2[index$1];
            if (watcher.before) {
              watcher.before();
            }
            id = watcher.id;
            has2[id] = null;
            watcher.run();
            if (has2[id] != null) {
              circular[id] = (circular[id] || 0) + 1;
              if (circular[id] > MAX_UPDATE_COUNT) {
                warn$2("You may have an infinite update loop " + (watcher.user ? 'in watcher with expression "'.concat(watcher.expression, '"') : "in a component render function."), watcher.vm);
                break;
              }
            }
          }
          var activatedQueue = activatedChildren2.slice();
          var updatedQueue = queue2.slice();
          resetSchedulerState2();
          callActivatedHooks2(activatedQueue);
          callUpdatedHooks2(updatedQueue);
          cleanupDeps2();
          if (devtools2 && config2.devtools) {
            devtools2.emit("flush");
          }
        }
        function callUpdatedHooks2(queue3) {
          var i = queue3.length;
          while (i--) {
            var watcher = queue3[i];
            var vm = watcher.vm;
            if (vm && vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
              callHook$12(vm, "updated");
            }
          }
        }
        function queueActivatedComponent2(vm) {
          vm._inactive = false;
          activatedChildren2.push(vm);
        }
        function callActivatedHooks2(queue3) {
          for (var i = 0; i < queue3.length; i++) {
            queue3[i]._inactive = true;
            activateChildComponent2(
              queue3[i],
              true
              /* true */
            );
          }
        }
        function queueWatcher2(watcher) {
          var id = watcher.id;
          if (has2[id] != null) {
            return;
          }
          if (watcher === Dep2.target && watcher.noRecurse) {
            return;
          }
          has2[id] = true;
          if (!flushing2) {
            queue2.push(watcher);
          } else {
            var i = queue2.length - 1;
            while (i > index$1 && queue2[i].id > watcher.id) {
              i--;
            }
            queue2.splice(i + 1, 0, watcher);
          }
          if (!waiting2) {
            waiting2 = true;
            if (!config2.async) {
              flushSchedulerQueue2();
              return;
            }
            nextTick2(flushSchedulerQueue2);
          }
        }
        var WATCHER2 = "watcher";
        var WATCHER_CB2 = "".concat(WATCHER2, " callback");
        var WATCHER_GETTER2 = "".concat(WATCHER2, " getter");
        var WATCHER_CLEANUP2 = "".concat(WATCHER2, " cleanup");
        function watchEffect(effect2, options) {
          return doWatch(effect2, null, options);
        }
        function watchPostEffect(effect2, options) {
          return doWatch(effect2, null, __assign(__assign({}, options), { flush: "post" }));
        }
        function watchSyncEffect(effect2, options) {
          return doWatch(effect2, null, __assign(__assign({}, options), { flush: "sync" }));
        }
        var INITIAL_WATCHER_VALUE = {};
        function watch2(source, cb, options) {
          if (typeof cb !== "function") {
            warn$2("`watch(fn, options?)` signature has been moved to a separate API. Use `watchEffect(fn, options?)` instead. `watch` now only supports `watch(source, cb, options?) signature.");
          }
          return doWatch(source, cb, options);
        }
        function doWatch(source, cb, _a2) {
          var _b = _a2 === void 0 ? emptyObject2 : _a2, immediate = _b.immediate, deep = _b.deep, _c = _b.flush, flush = _c === void 0 ? "pre" : _c, onTrack = _b.onTrack, onTrigger = _b.onTrigger;
          if (!cb) {
            if (immediate !== void 0) {
              warn$2('watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.');
            }
            if (deep !== void 0) {
              warn$2('watch() "deep" option is only respected when using the watch(source, callback, options?) signature.');
            }
          }
          var warnInvalidSource = function(s) {
            warn$2("Invalid watch source: ".concat(s, ". A watch source can only be a getter/effect ") + "function, a ref, a reactive object, or an array of these types.");
          };
          var instance = currentInstance2;
          var call = function(fn, type, args) {
            if (args === void 0) {
              args = null;
            }
            var res = invokeWithErrorHandling2(fn, null, args, instance, type);
            if (deep && res && res.__ob__)
              res.__ob__.dep.depend();
            return res;
          };
          var getter;
          var forceTrigger = false;
          var isMultiSource = false;
          if (isRef2(source)) {
            getter = function() {
              return source.value;
            };
            forceTrigger = isShallow(source);
          } else if (isReactive(source)) {
            getter = function() {
              source.__ob__.dep.depend();
              return source;
            };
            deep = true;
          } else if (isArray2(source)) {
            isMultiSource = true;
            forceTrigger = source.some(function(s) {
              return isReactive(s) || isShallow(s);
            });
            getter = function() {
              return source.map(function(s) {
                if (isRef2(s)) {
                  return s.value;
                } else if (isReactive(s)) {
                  s.__ob__.dep.depend();
                  return traverse2(s);
                } else if (isFunction2(s)) {
                  return call(s, WATCHER_GETTER2);
                } else {
                  warnInvalidSource(s);
                }
              });
            };
          } else if (isFunction2(source)) {
            if (cb) {
              getter = function() {
                return call(source, WATCHER_GETTER2);
              };
            } else {
              getter = function() {
                if (instance && instance._isDestroyed) {
                  return;
                }
                if (cleanup) {
                  cleanup();
                }
                return call(source, WATCHER2, [onCleanup]);
              };
            }
          } else {
            getter = noop2;
            warnInvalidSource(source);
          }
          if (cb && deep) {
            var baseGetter_1 = getter;
            getter = function() {
              return traverse2(baseGetter_1());
            };
          }
          var cleanup;
          var onCleanup = function(fn) {
            cleanup = watcher.onStop = function() {
              call(fn, WATCHER_CLEANUP2);
            };
          };
          if (isServerRendering2()) {
            onCleanup = noop2;
            if (!cb) {
              getter();
            } else if (immediate) {
              call(cb, WATCHER_CB2, [
                getter(),
                isMultiSource ? [] : void 0,
                onCleanup
              ]);
            }
            return noop2;
          }
          var watcher = new Watcher2(currentInstance2, getter, noop2, {
            lazy: true
          });
          watcher.noRecurse = !cb;
          var oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE;
          watcher.run = function() {
            if (!watcher.active) {
              return;
            }
            if (cb) {
              var newValue = watcher.get();
              if (deep || forceTrigger || (isMultiSource ? newValue.some(function(v, i) {
                return hasChanged2(v, oldValue[i]);
              }) : hasChanged2(newValue, oldValue))) {
                if (cleanup) {
                  cleanup();
                }
                call(cb, WATCHER_CB2, [
                  newValue,
                  // pass undefined as the old value when it's changed for the first time
                  oldValue === INITIAL_WATCHER_VALUE ? void 0 : oldValue,
                  onCleanup
                ]);
                oldValue = newValue;
              }
            } else {
              watcher.get();
            }
          };
          if (flush === "sync") {
            watcher.update = watcher.run;
          } else if (flush === "post") {
            watcher.post = true;
            watcher.update = function() {
              return queueWatcher2(watcher);
            };
          } else {
            watcher.update = function() {
              if (instance && instance === currentInstance2 && !instance._isMounted) {
                var buffer = instance._preWatchers || (instance._preWatchers = []);
                if (buffer.indexOf(watcher) < 0)
                  buffer.push(watcher);
              } else {
                queueWatcher2(watcher);
              }
            };
          }
          {
            watcher.onTrack = onTrack;
            watcher.onTrigger = onTrigger;
          }
          if (cb) {
            if (immediate) {
              watcher.run();
            } else {
              oldValue = watcher.get();
            }
          } else if (flush === "post" && instance) {
            instance.$once("hook:mounted", function() {
              return watcher.get();
            });
          } else {
            watcher.get();
          }
          return function() {
            watcher.teardown();
          };
        }
        function provide(key, value) {
          if (!currentInstance2) {
            {
              warn$2("provide() can only be used inside setup().");
            }
          } else {
            resolveProvided2(currentInstance2)[key] = value;
          }
        }
        function resolveProvided2(vm) {
          var existing = vm._provided;
          var parentProvides = vm.$parent && vm.$parent._provided;
          if (parentProvides === existing) {
            return vm._provided = Object.create(parentProvides);
          } else {
            return existing;
          }
        }
        function inject(key, defaultValue, treatDefaultAsFactory) {
          if (treatDefaultAsFactory === void 0) {
            treatDefaultAsFactory = false;
          }
          var instance = currentInstance2;
          if (instance) {
            var provides = instance.$parent && instance.$parent._provided;
            if (provides && key in provides) {
              return provides[key];
            } else if (arguments.length > 1) {
              return treatDefaultAsFactory && isFunction2(defaultValue) ? defaultValue.call(instance) : defaultValue;
            } else {
              warn$2('injection "'.concat(String(key), '" not found.'));
            }
          } else {
            warn$2("inject() can only be used inside setup() or functional components.");
          }
        }
        function h(type, props3, children) {
          if (!currentInstance2) {
            warn$2("globally imported h() can only be invoked when there is an active component instance, e.g. synchronously in a component's render or setup function.");
          }
          return createElement$12(currentInstance2, type, props3, children, 2, true);
        }
        function handleError2(err, vm, info) {
          pushTarget2();
          try {
            if (vm) {
              var cur = vm;
              while (cur = cur.$parent) {
                var hooks3 = cur.$options.errorCaptured;
                if (hooks3) {
                  for (var i = 0; i < hooks3.length; i++) {
                    try {
                      var capture = hooks3[i].call(cur, err, vm, info) === false;
                      if (capture)
                        return;
                    } catch (e) {
                      globalHandleError2(e, cur, "errorCaptured hook");
                    }
                  }
                }
              }
            }
            globalHandleError2(err, vm, info);
          } finally {
            popTarget2();
          }
        }
        function invokeWithErrorHandling2(handler, context, args, vm, info) {
          var res;
          try {
            res = args ? handler.apply(context, args) : handler.call(context);
            if (res && !res._isVue && isPromise3(res) && !res._handled) {
              res.catch(function(e) {
                return handleError2(e, vm, info + " (Promise/async)");
              });
              res._handled = true;
            }
          } catch (e) {
            handleError2(e, vm, info);
          }
          return res;
        }
        function globalHandleError2(err, vm, info) {
          if (config2.errorHandler) {
            try {
              return config2.errorHandler.call(null, err, vm, info);
            } catch (e) {
              if (e !== err) {
                logError2(e, null, "config.errorHandler");
              }
            }
          }
          logError2(err, vm, info);
        }
        function logError2(err, vm, info) {
          {
            warn$2("Error in ".concat(info, ': "').concat(err.toString(), '"'), vm);
          }
          if (inBrowser2 && typeof console !== "undefined") {
            console.error(err);
          } else {
            throw err;
          }
        }
        var isUsingMicroTask2 = false;
        var callbacks2 = [];
        var pending2 = false;
        function flushCallbacks2() {
          pending2 = false;
          var copies = callbacks2.slice(0);
          callbacks2.length = 0;
          for (var i = 0; i < copies.length; i++) {
            copies[i]();
          }
        }
        var timerFunc2;
        if (typeof Promise !== "undefined" && isNative2(Promise)) {
          var p_1 = Promise.resolve();
          timerFunc2 = function() {
            p_1.then(flushCallbacks2);
            if (isIOS2)
              setTimeout(noop2);
          };
          isUsingMicroTask2 = true;
        } else if (!isIE2 && typeof MutationObserver !== "undefined" && (isNative2(MutationObserver) || // PhantomJS and iOS 7.x
        MutationObserver.toString() === "[object MutationObserverConstructor]")) {
          var counter_1 = 1;
          var observer = new MutationObserver(flushCallbacks2);
          var textNode_1 = document.createTextNode(String(counter_1));
          observer.observe(textNode_1, {
            characterData: true
          });
          timerFunc2 = function() {
            counter_1 = (counter_1 + 1) % 2;
            textNode_1.data = String(counter_1);
          };
          isUsingMicroTask2 = true;
        } else if (typeof setImmediate !== "undefined" && isNative2(setImmediate)) {
          timerFunc2 = function() {
            setImmediate(flushCallbacks2);
          };
        } else {
          timerFunc2 = function() {
            setTimeout(flushCallbacks2, 0);
          };
        }
        function nextTick2(cb, ctx) {
          var _resolve;
          callbacks2.push(function() {
            if (cb) {
              try {
                cb.call(ctx);
              } catch (e) {
                handleError2(e, ctx, "nextTick");
              }
            } else if (_resolve) {
              _resolve(ctx);
            }
          });
          if (!pending2) {
            pending2 = true;
            timerFunc2();
          }
          if (!cb && typeof Promise !== "undefined") {
            return new Promise(function(resolve) {
              _resolve = resolve;
            });
          }
        }
        function useCssModule(name) {
          {
            {
              warn$2("useCssModule() is not supported in the global build.");
            }
            return emptyObject2;
          }
        }
        function useCssVars(getter) {
          if (!inBrowser2 && true)
            return;
          var instance = currentInstance2;
          if (!instance) {
            warn$2("useCssVars is called without current active component instance.");
            return;
          }
          watchPostEffect(function() {
            var el = instance.$el;
            var vars = getter(instance, instance._setupProxy);
            if (el && el.nodeType === 1) {
              var style3 = el.style;
              for (var key in vars) {
                style3.setProperty("--".concat(key), vars[key]);
              }
            }
          });
        }
        function defineAsyncComponent(source) {
          if (isFunction2(source)) {
            source = { loader: source };
          }
          var loader = source.loader, loadingComponent = source.loadingComponent, errorComponent = source.errorComponent, _a2 = source.delay, delay = _a2 === void 0 ? 200 : _a2, timeout = source.timeout, _b = source.suspensible, suspensible = _b === void 0 ? false : _b, userOnError = source.onError;
          if (suspensible) {
            warn$2("The suspensible option for async components is not supported in Vue2. It is ignored.");
          }
          var pendingRequest = null;
          var retries = 0;
          var retry = function() {
            retries++;
            pendingRequest = null;
            return load();
          };
          var load = function() {
            var thisRequest;
            return pendingRequest || (thisRequest = pendingRequest = loader().catch(function(err) {
              err = err instanceof Error ? err : new Error(String(err));
              if (userOnError) {
                return new Promise(function(resolve, reject) {
                  var userRetry = function() {
                    return resolve(retry());
                  };
                  var userFail = function() {
                    return reject(err);
                  };
                  userOnError(err, userRetry, userFail, retries + 1);
                });
              } else {
                throw err;
              }
            }).then(function(comp) {
              if (thisRequest !== pendingRequest && pendingRequest) {
                return pendingRequest;
              }
              if (!comp) {
                warn$2("Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.");
              }
              if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
                comp = comp.default;
              }
              if (comp && !isObject3(comp) && !isFunction2(comp)) {
                throw new Error("Invalid async component load result: ".concat(comp));
              }
              return comp;
            }));
          };
          return function() {
            var component = load();
            return {
              component,
              delay,
              timeout,
              error: errorComponent,
              loading: loadingComponent
            };
          };
        }
        function createLifeCycle2(hookName) {
          return function(fn, target4) {
            if (target4 === void 0) {
              target4 = currentInstance2;
            }
            if (!target4) {
              warn$2("".concat(formatName(hookName), " is called when there is no active component instance to be ") + "associated with. Lifecycle injection APIs can only be used during execution of setup().");
              return;
            }
            return injectHook2(target4, hookName, fn);
          };
        }
        function formatName(name) {
          if (name === "beforeDestroy") {
            name = "beforeUnmount";
          } else if (name === "destroyed") {
            name = "unmounted";
          }
          return "on".concat(name[0].toUpperCase() + name.slice(1));
        }
        function injectHook2(instance, hookName, fn) {
          var options = instance.$options;
          options[hookName] = mergeLifecycleHook2(options[hookName], fn);
        }
        var onBeforeMount2 = createLifeCycle2("beforeMount");
        var onMounted2 = createLifeCycle2("mounted");
        var onBeforeUpdate2 = createLifeCycle2("beforeUpdate");
        var onUpdated2 = createLifeCycle2("updated");
        var onBeforeUnmount2 = createLifeCycle2("beforeDestroy");
        var onUnmounted2 = createLifeCycle2("destroyed");
        var onActivated2 = createLifeCycle2("activated");
        var onDeactivated2 = createLifeCycle2("deactivated");
        var onServerPrefetch2 = createLifeCycle2("serverPrefetch");
        var onRenderTracked2 = createLifeCycle2("renderTracked");
        var onRenderTriggered2 = createLifeCycle2("renderTriggered");
        var injectErrorCapturedHook2 = createLifeCycle2("errorCaptured");
        function onErrorCaptured(hook, target4) {
          if (target4 === void 0) {
            target4 = currentInstance2;
          }
          injectErrorCapturedHook2(hook, target4);
        }
        var version2 = "2.7.16";
        function defineComponent(options) {
          return options;
        }
        var vca = /* @__PURE__ */ Object.freeze({
          __proto__: null,
          version: version2,
          defineComponent,
          ref: ref$1,
          shallowRef,
          isRef: isRef2,
          toRef,
          toRefs,
          unref,
          proxyRefs,
          customRef,
          triggerRef,
          reactive,
          isReactive,
          isReadonly: isReadonly2,
          isShallow,
          isProxy,
          shallowReactive: shallowReactive2,
          markRaw,
          toRaw,
          readonly,
          shallowReadonly,
          computed,
          watch: watch2,
          watchEffect,
          watchPostEffect,
          watchSyncEffect,
          EffectScope: EffectScope2,
          effectScope,
          onScopeDispose,
          getCurrentScope: getCurrentScope2,
          provide,
          inject,
          h,
          getCurrentInstance,
          useSlots,
          useAttrs,
          useListeners,
          mergeDefaults,
          nextTick: nextTick2,
          set: set2,
          del: del2,
          useCssModule,
          useCssVars,
          defineAsyncComponent,
          onBeforeMount: onBeforeMount2,
          onMounted: onMounted2,
          onBeforeUpdate: onBeforeUpdate2,
          onUpdated: onUpdated2,
          onBeforeUnmount: onBeforeUnmount2,
          onUnmounted: onUnmounted2,
          onActivated: onActivated2,
          onDeactivated: onDeactivated2,
          onServerPrefetch: onServerPrefetch2,
          onRenderTracked: onRenderTracked2,
          onRenderTriggered: onRenderTriggered2,
          onErrorCaptured
        });
        var seenObjects2 = new _Set2();
        function traverse2(val) {
          _traverse2(val, seenObjects2);
          seenObjects2.clear();
          return val;
        }
        function _traverse2(val, seen) {
          var i, keys;
          var isA = isArray2(val);
          if (!isA && !isObject3(val) || val.__v_skip || Object.isFrozen(val) || val instanceof VNode2) {
            return;
          }
          if (val.__ob__) {
            var depId = val.__ob__.dep.id;
            if (seen.has(depId)) {
              return;
            }
            seen.add(depId);
          }
          if (isA) {
            i = val.length;
            while (i--)
              _traverse2(val[i], seen);
          } else if (isRef2(val)) {
            _traverse2(val.value, seen);
          } else {
            keys = Object.keys(val);
            i = keys.length;
            while (i--)
              _traverse2(val[keys[i]], seen);
          }
        }
        var uid$12 = 0;
        var Watcher2 = (
          /** @class */
          (function() {
            function Watcher3(vm, expOrFn, cb, options, isRenderWatcher) {
              recordEffectScope2(
                this,
                // if the active effect scope is manually created (not a component scope),
                // prioritize it
                activeEffectScope2 && !activeEffectScope2._vm ? activeEffectScope2 : vm ? vm._scope : void 0
              );
              if ((this.vm = vm) && isRenderWatcher) {
                vm._watcher = this;
              }
              if (options) {
                this.deep = !!options.deep;
                this.user = !!options.user;
                this.lazy = !!options.lazy;
                this.sync = !!options.sync;
                this.before = options.before;
                {
                  this.onTrack = options.onTrack;
                  this.onTrigger = options.onTrigger;
                }
              } else {
                this.deep = this.user = this.lazy = this.sync = false;
              }
              this.cb = cb;
              this.id = ++uid$12;
              this.active = true;
              this.post = false;
              this.dirty = this.lazy;
              this.deps = [];
              this.newDeps = [];
              this.depIds = new _Set2();
              this.newDepIds = new _Set2();
              this.expression = expOrFn.toString();
              if (isFunction2(expOrFn)) {
                this.getter = expOrFn;
              } else {
                this.getter = parsePath2(expOrFn);
                if (!this.getter) {
                  this.getter = noop2;
                  warn$2('Failed watching path: "'.concat(expOrFn, '" ') + "Watcher only accepts simple dot-delimited paths. For full control, use a function instead.", vm);
                }
              }
              this.value = this.lazy ? void 0 : this.get();
            }
            Watcher3.prototype.get = function() {
              pushTarget2(this);
              var value;
              var vm = this.vm;
              try {
                value = this.getter.call(vm, vm);
              } catch (e) {
                if (this.user) {
                  handleError2(e, vm, 'getter for watcher "'.concat(this.expression, '"'));
                } else {
                  throw e;
                }
              } finally {
                if (this.deep) {
                  traverse2(value);
                }
                popTarget2();
                this.cleanupDeps();
              }
              return value;
            };
            Watcher3.prototype.addDep = function(dep) {
              var id = dep.id;
              if (!this.newDepIds.has(id)) {
                this.newDepIds.add(id);
                this.newDeps.push(dep);
                if (!this.depIds.has(id)) {
                  dep.addSub(this);
                }
              }
            };
            Watcher3.prototype.cleanupDeps = function() {
              var i = this.deps.length;
              while (i--) {
                var dep = this.deps[i];
                if (!this.newDepIds.has(dep.id)) {
                  dep.removeSub(this);
                }
              }
              var tmp = this.depIds;
              this.depIds = this.newDepIds;
              this.newDepIds = tmp;
              this.newDepIds.clear();
              tmp = this.deps;
              this.deps = this.newDeps;
              this.newDeps = tmp;
              this.newDeps.length = 0;
            };
            Watcher3.prototype.update = function() {
              if (this.lazy) {
                this.dirty = true;
              } else if (this.sync) {
                this.run();
              } else {
                queueWatcher2(this);
              }
            };
            Watcher3.prototype.run = function() {
              if (this.active) {
                var value = this.get();
                if (value !== this.value || // Deep watchers and watchers on Object/Arrays should fire even
                // when the value is the same, because the value may
                // have mutated.
                isObject3(value) || this.deep) {
                  var oldValue = this.value;
                  this.value = value;
                  if (this.user) {
                    var info = 'callback for watcher "'.concat(this.expression, '"');
                    invokeWithErrorHandling2(this.cb, this.vm, [value, oldValue], this.vm, info);
                  } else {
                    this.cb.call(this.vm, value, oldValue);
                  }
                }
              }
            };
            Watcher3.prototype.evaluate = function() {
              this.value = this.get();
              this.dirty = false;
            };
            Watcher3.prototype.depend = function() {
              var i = this.deps.length;
              while (i--) {
                this.deps[i].depend();
              }
            };
            Watcher3.prototype.teardown = function() {
              if (this.vm && !this.vm._isBeingDestroyed) {
                remove$22(this.vm._scope.effects, this);
              }
              if (this.active) {
                var i = this.deps.length;
                while (i--) {
                  this.deps[i].removeSub(this);
                }
                this.active = false;
                if (this.onStop) {
                  this.onStop();
                }
              }
            };
            return Watcher3;
          })()
        );
        var sharedPropertyDefinition2 = {
          enumerable: true,
          configurable: true,
          get: noop2,
          set: noop2
        };
        function proxy2(target4, sourceKey, key) {
          sharedPropertyDefinition2.get = function proxyGetter() {
            return this[sourceKey][key];
          };
          sharedPropertyDefinition2.set = function proxySetter(val) {
            this[sourceKey][key] = val;
          };
          Object.defineProperty(target4, key, sharedPropertyDefinition2);
        }
        function initState2(vm) {
          var opts2 = vm.$options;
          if (opts2.props)
            initProps$12(vm, opts2.props);
          initSetup2(vm);
          if (opts2.methods)
            initMethods2(vm, opts2.methods);
          if (opts2.data) {
            initData2(vm);
          } else {
            var ob = observe2(vm._data = {});
            ob && ob.vmCount++;
          }
          if (opts2.computed)
            initComputed$12(vm, opts2.computed);
          if (opts2.watch && opts2.watch !== nativeWatch2) {
            initWatch2(vm, opts2.watch);
          }
        }
        function initProps$12(vm, propsOptions) {
          var propsData = vm.$options.propsData || {};
          var props3 = vm._props = shallowReactive2({});
          var keys = vm.$options._propKeys = [];
          var isRoot = !vm.$parent;
          if (!isRoot) {
            toggleObserving2(false);
          }
          var _loop_1 = function(key2) {
            keys.push(key2);
            var value = validateProp2(key2, propsOptions, propsData, vm);
            {
              var hyphenatedKey = hyphenate2(key2);
              if (isReservedAttribute2(hyphenatedKey) || config2.isReservedAttr(hyphenatedKey)) {
                warn$2('"'.concat(hyphenatedKey, '" is a reserved attribute and cannot be used as component prop.'), vm);
              }
              defineReactive2(
                props3,
                key2,
                value,
                function() {
                  if (!isRoot && !isUpdatingChildComponent) {
                    warn$2("Avoid mutating a prop directly since the value will be overwritten whenever the parent component re-renders. Instead, use a data or computed property based on the prop's " + 'value. Prop being mutated: "'.concat(key2, '"'), vm);
                  }
                },
                true
                /* shallow */
              );
            }
            if (!(key2 in vm)) {
              proxy2(vm, "_props", key2);
            }
          };
          for (var key in propsOptions) {
            _loop_1(key);
          }
          toggleObserving2(true);
        }
        function initData2(vm) {
          var data = vm.$options.data;
          data = vm._data = isFunction2(data) ? getData2(data, vm) : data || {};
          if (!isPlainObject2(data)) {
            data = {};
            warn$2("data functions should return an object:\nhttps://v2.vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
          }
          var keys = Object.keys(data);
          var props3 = vm.$options.props;
          var methods = vm.$options.methods;
          var i = keys.length;
          while (i--) {
            var key = keys[i];
            {
              if (methods && hasOwn2(methods, key)) {
                warn$2('Method "'.concat(key, '" has already been defined as a data property.'), vm);
              }
            }
            if (props3 && hasOwn2(props3, key)) {
              warn$2('The data property "'.concat(key, '" is already declared as a prop. ') + "Use prop default value instead.", vm);
            } else if (!isReserved2(key)) {
              proxy2(vm, "_data", key);
            }
          }
          var ob = observe2(data);
          ob && ob.vmCount++;
        }
        function getData2(data, vm) {
          pushTarget2();
          try {
            return data.call(vm, vm);
          } catch (e) {
            handleError2(e, vm, "data()");
            return {};
          } finally {
            popTarget2();
          }
        }
        var computedWatcherOptions2 = { lazy: true };
        function initComputed$12(vm, computed2) {
          var watchers = vm._computedWatchers = /* @__PURE__ */ Object.create(null);
          var isSSR = isServerRendering2();
          for (var key in computed2) {
            var userDef = computed2[key];
            var getter = isFunction2(userDef) ? userDef : userDef.get;
            if (getter == null) {
              warn$2('Getter is missing for computed property "'.concat(key, '".'), vm);
            }
            if (!isSSR) {
              watchers[key] = new Watcher2(vm, getter || noop2, noop2, computedWatcherOptions2);
            }
            if (!(key in vm)) {
              defineComputed2(vm, key, userDef);
            } else {
              if (key in vm.$data) {
                warn$2('The computed property "'.concat(key, '" is already defined in data.'), vm);
              } else if (vm.$options.props && key in vm.$options.props) {
                warn$2('The computed property "'.concat(key, '" is already defined as a prop.'), vm);
              } else if (vm.$options.methods && key in vm.$options.methods) {
                warn$2('The computed property "'.concat(key, '" is already defined as a method.'), vm);
              }
            }
          }
        }
        function defineComputed2(target4, key, userDef) {
          var shouldCache = !isServerRendering2();
          if (isFunction2(userDef)) {
            sharedPropertyDefinition2.get = shouldCache ? createComputedGetter2(key) : createGetterInvoker2(userDef);
            sharedPropertyDefinition2.set = noop2;
          } else {
            sharedPropertyDefinition2.get = userDef.get ? shouldCache && userDef.cache !== false ? createComputedGetter2(key) : createGetterInvoker2(userDef.get) : noop2;
            sharedPropertyDefinition2.set = userDef.set || noop2;
          }
          if (sharedPropertyDefinition2.set === noop2) {
            sharedPropertyDefinition2.set = function() {
              warn$2('Computed property "'.concat(key, '" was assigned to but it has no setter.'), this);
            };
          }
          Object.defineProperty(target4, key, sharedPropertyDefinition2);
        }
        function createComputedGetter2(key) {
          return function computedGetter() {
            var watcher = this._computedWatchers && this._computedWatchers[key];
            if (watcher) {
              if (watcher.dirty) {
                watcher.evaluate();
              }
              if (Dep2.target) {
                if (Dep2.target.onTrack) {
                  Dep2.target.onTrack({
                    effect: Dep2.target,
                    target: this,
                    type: "get",
                    key
                  });
                }
                watcher.depend();
              }
              return watcher.value;
            }
          };
        }
        function createGetterInvoker2(fn) {
          return function computedGetter() {
            return fn.call(this, this);
          };
        }
        function initMethods2(vm, methods) {
          var props3 = vm.$options.props;
          for (var key in methods) {
            {
              if (typeof methods[key] !== "function") {
                warn$2('Method "'.concat(key, '" has type "').concat(typeof methods[key], '" in the component definition. ') + "Did you reference the function correctly?", vm);
              }
              if (props3 && hasOwn2(props3, key)) {
                warn$2('Method "'.concat(key, '" has already been defined as a prop.'), vm);
              }
              if (key in vm && isReserved2(key)) {
                warn$2('Method "'.concat(key, '" conflicts with an existing Vue instance method. ') + "Avoid defining component methods that start with _ or $.");
              }
            }
            vm[key] = typeof methods[key] !== "function" ? noop2 : bind$1(methods[key], vm);
          }
        }
        function initWatch2(vm, watch3) {
          for (var key in watch3) {
            var handler = watch3[key];
            if (isArray2(handler)) {
              for (var i = 0; i < handler.length; i++) {
                createWatcher2(vm, key, handler[i]);
              }
            } else {
              createWatcher2(vm, key, handler);
            }
          }
        }
        function createWatcher2(vm, expOrFn, handler, options) {
          if (isPlainObject2(handler)) {
            options = handler;
            handler = handler.handler;
          }
          if (typeof handler === "string") {
            handler = vm[handler];
          }
          return vm.$watch(expOrFn, handler, options);
        }
        function stateMixin2(Vue5) {
          var dataDef = {};
          dataDef.get = function() {
            return this._data;
          };
          var propsDef = {};
          propsDef.get = function() {
            return this._props;
          };
          {
            dataDef.set = function() {
              warn$2("Avoid replacing instance root $data. Use nested data properties instead.", this);
            };
            propsDef.set = function() {
              warn$2("$props is readonly.", this);
            };
          }
          Object.defineProperty(Vue5.prototype, "$data", dataDef);
          Object.defineProperty(Vue5.prototype, "$props", propsDef);
          Vue5.prototype.$set = set2;
          Vue5.prototype.$delete = del2;
          Vue5.prototype.$watch = function(expOrFn, cb, options) {
            var vm = this;
            if (isPlainObject2(cb)) {
              return createWatcher2(vm, expOrFn, cb, options);
            }
            options = options || {};
            options.user = true;
            var watcher = new Watcher2(vm, expOrFn, cb, options);
            if (options.immediate) {
              var info = 'callback for immediate watcher "'.concat(watcher.expression, '"');
              pushTarget2();
              invokeWithErrorHandling2(cb, vm, [watcher.value], vm, info);
              popTarget2();
            }
            return function unwatchFn() {
              watcher.teardown();
            };
          };
        }
        function initProvide2(vm) {
          var provideOption = vm.$options.provide;
          if (provideOption) {
            var provided = isFunction2(provideOption) ? provideOption.call(vm) : provideOption;
            if (!isObject3(provided)) {
              return;
            }
            var source = resolveProvided2(vm);
            var keys = hasSymbol2 ? Reflect.ownKeys(provided) : Object.keys(provided);
            for (var i = 0; i < keys.length; i++) {
              var key = keys[i];
              Object.defineProperty(source, key, Object.getOwnPropertyDescriptor(provided, key));
            }
          }
        }
        function initInjections2(vm) {
          var result = resolveInject2(vm.$options.inject, vm);
          if (result) {
            toggleObserving2(false);
            Object.keys(result).forEach(function(key) {
              {
                defineReactive2(vm, key, result[key], function() {
                  warn$2("Avoid mutating an injected value directly since the changes will be overwritten whenever the provided component re-renders. " + 'injection being mutated: "'.concat(key, '"'), vm);
                });
              }
            });
            toggleObserving2(true);
          }
        }
        function resolveInject2(inject2, vm) {
          if (inject2) {
            var result = /* @__PURE__ */ Object.create(null);
            var keys = hasSymbol2 ? Reflect.ownKeys(inject2) : Object.keys(inject2);
            for (var i = 0; i < keys.length; i++) {
              var key = keys[i];
              if (key === "__ob__")
                continue;
              var provideKey = inject2[key].from;
              if (provideKey in vm._provided) {
                result[key] = vm._provided[provideKey];
              } else if ("default" in inject2[key]) {
                var provideDefault = inject2[key].default;
                result[key] = isFunction2(provideDefault) ? provideDefault.call(vm) : provideDefault;
              } else {
                warn$2('Injection "'.concat(key, '" not found'), vm);
              }
            }
            return result;
          }
        }
        var uid2 = 0;
        function initMixin$12(Vue5) {
          Vue5.prototype._init = function(options) {
            var vm = this;
            vm._uid = uid2++;
            var startTag, endTag2;
            if (config2.performance && mark) {
              startTag = "vue-perf-start:".concat(vm._uid);
              endTag2 = "vue-perf-end:".concat(vm._uid);
              mark(startTag);
            }
            vm._isVue = true;
            vm.__v_skip = true;
            vm._scope = new EffectScope2(
              true
              /* detached */
            );
            vm._scope.parent = void 0;
            vm._scope._vm = true;
            if (options && options._isComponent) {
              initInternalComponent2(vm, options);
            } else {
              vm.$options = mergeOptions2(resolveConstructorOptions2(vm.constructor), options || {}, vm);
            }
            {
              initProxy(vm);
            }
            vm._self = vm;
            initLifecycle2(vm);
            initEvents2(vm);
            initRender2(vm);
            callHook$12(
              vm,
              "beforeCreate",
              void 0,
              false
              /* setContext */
            );
            initInjections2(vm);
            initState2(vm);
            initProvide2(vm);
            callHook$12(vm, "created");
            if (config2.performance && mark) {
              vm._name = formatComponentName(vm, false);
              mark(endTag2);
              measure("vue ".concat(vm._name, " init"), startTag, endTag2);
            }
            if (vm.$options.el) {
              vm.$mount(vm.$options.el);
            }
          };
        }
        function initInternalComponent2(vm, options) {
          var opts2 = vm.$options = Object.create(vm.constructor.options);
          var parentVnode = options._parentVnode;
          opts2.parent = options.parent;
          opts2._parentVnode = parentVnode;
          var vnodeComponentOptions = parentVnode.componentOptions;
          opts2.propsData = vnodeComponentOptions.propsData;
          opts2._parentListeners = vnodeComponentOptions.listeners;
          opts2._renderChildren = vnodeComponentOptions.children;
          opts2._componentTag = vnodeComponentOptions.tag;
          if (options.render) {
            opts2.render = options.render;
            opts2.staticRenderFns = options.staticRenderFns;
          }
        }
        function resolveConstructorOptions2(Ctor) {
          var options = Ctor.options;
          if (Ctor.super) {
            var superOptions = resolveConstructorOptions2(Ctor.super);
            var cachedSuperOptions = Ctor.superOptions;
            if (superOptions !== cachedSuperOptions) {
              Ctor.superOptions = superOptions;
              var modifiedOptions = resolveModifiedOptions2(Ctor);
              if (modifiedOptions) {
                extend2(Ctor.extendOptions, modifiedOptions);
              }
              options = Ctor.options = mergeOptions2(superOptions, Ctor.extendOptions);
              if (options.name) {
                options.components[options.name] = Ctor;
              }
            }
          }
          return options;
        }
        function resolveModifiedOptions2(Ctor) {
          var modified;
          var latest = Ctor.options;
          var sealed = Ctor.sealedOptions;
          for (var key in latest) {
            if (latest[key] !== sealed[key]) {
              if (!modified)
                modified = {};
              modified[key] = latest[key];
            }
          }
          return modified;
        }
        function FunctionalRenderContext2(data, props3, children, parent, Ctor) {
          var _this = this;
          var options = Ctor.options;
          var contextVm;
          if (hasOwn2(parent, "_uid")) {
            contextVm = Object.create(parent);
            contextVm._original = parent;
          } else {
            contextVm = parent;
            parent = parent._original;
          }
          var isCompiled = isTrue2(options._compiled);
          var needNormalization = !isCompiled;
          this.data = data;
          this.props = props3;
          this.children = children;
          this.parent = parent;
          this.listeners = data.on || emptyObject2;
          this.injections = resolveInject2(options.inject, parent);
          this.slots = function() {
            if (!_this.$slots) {
              normalizeScopedSlots2(parent, data.scopedSlots, _this.$slots = resolveSlots2(children, parent));
            }
            return _this.$slots;
          };
          Object.defineProperty(this, "scopedSlots", {
            enumerable: true,
            get: function() {
              return normalizeScopedSlots2(parent, data.scopedSlots, this.slots());
            }
          });
          if (isCompiled) {
            this.$options = options;
            this.$slots = this.slots();
            this.$scopedSlots = normalizeScopedSlots2(parent, data.scopedSlots, this.$slots);
          }
          if (options._scopeId) {
            this._c = function(a, b, c, d) {
              var vnode = createElement$12(contextVm, a, b, c, d, needNormalization);
              if (vnode && !isArray2(vnode)) {
                vnode.fnScopeId = options._scopeId;
                vnode.fnContext = parent;
              }
              return vnode;
            };
          } else {
            this._c = function(a, b, c, d) {
              return createElement$12(contextVm, a, b, c, d, needNormalization);
            };
          }
        }
        installRenderHelpers2(FunctionalRenderContext2.prototype);
        function createFunctionalComponent2(Ctor, propsData, data, contextVm, children) {
          var options = Ctor.options;
          var props3 = {};
          var propOptions = options.props;
          if (isDef2(propOptions)) {
            for (var key in propOptions) {
              props3[key] = validateProp2(key, propOptions, propsData || emptyObject2);
            }
          } else {
            if (isDef2(data.attrs))
              mergeProps2(props3, data.attrs);
            if (isDef2(data.props))
              mergeProps2(props3, data.props);
          }
          var renderContext = new FunctionalRenderContext2(data, props3, children, contextVm, Ctor);
          var vnode = options.render.call(null, renderContext._c, renderContext);
          if (vnode instanceof VNode2) {
            return cloneAndMarkFunctionalResult2(vnode, data, renderContext.parent, options, renderContext);
          } else if (isArray2(vnode)) {
            var vnodes = normalizeChildren2(vnode) || [];
            var res = new Array(vnodes.length);
            for (var i = 0; i < vnodes.length; i++) {
              res[i] = cloneAndMarkFunctionalResult2(vnodes[i], data, renderContext.parent, options, renderContext);
            }
            return res;
          }
        }
        function cloneAndMarkFunctionalResult2(vnode, data, contextVm, options, renderContext) {
          var clone = cloneVNode2(vnode);
          clone.fnContext = contextVm;
          clone.fnOptions = options;
          {
            (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
          }
          if (data.slot) {
            (clone.data || (clone.data = {})).slot = data.slot;
          }
          return clone;
        }
        function mergeProps2(to, from) {
          for (var key in from) {
            to[camelize2(key)] = from[key];
          }
        }
        function getComponentName2(options) {
          return options.name || options.__name || options._componentTag;
        }
        var componentVNodeHooks2 = {
          init: function(vnode, hydrating) {
            if (vnode.componentInstance && !vnode.componentInstance._isDestroyed && vnode.data.keepAlive) {
              var mountedNode = vnode;
              componentVNodeHooks2.prepatch(mountedNode, mountedNode);
            } else {
              var child = vnode.componentInstance = createComponentInstanceForVnode2(vnode, activeInstance2);
              child.$mount(hydrating ? vnode.elm : void 0, hydrating);
            }
          },
          prepatch: function(oldVnode, vnode) {
            var options = vnode.componentOptions;
            var child = vnode.componentInstance = oldVnode.componentInstance;
            updateChildComponent2(
              child,
              options.propsData,
              // updated props
              options.listeners,
              // updated listeners
              vnode,
              // new parent vnode
              options.children
              // new children
            );
          },
          insert: function(vnode) {
            var context = vnode.context, componentInstance = vnode.componentInstance;
            if (!componentInstance._isMounted) {
              componentInstance._isMounted = true;
              callHook$12(componentInstance, "mounted");
            }
            if (vnode.data.keepAlive) {
              if (context._isMounted) {
                queueActivatedComponent2(componentInstance);
              } else {
                activateChildComponent2(
                  componentInstance,
                  true
                  /* direct */
                );
              }
            }
          },
          destroy: function(vnode) {
            var componentInstance = vnode.componentInstance;
            if (!componentInstance._isDestroyed) {
              if (!vnode.data.keepAlive) {
                componentInstance.$destroy();
              } else {
                deactivateChildComponent2(
                  componentInstance,
                  true
                  /* direct */
                );
              }
            }
          }
        };
        var hooksToMerge2 = Object.keys(componentVNodeHooks2);
        function createComponent2(Ctor, data, context, children, tag) {
          if (isUndef2(Ctor)) {
            return;
          }
          var baseCtor = context.$options._base;
          if (isObject3(Ctor)) {
            Ctor = baseCtor.extend(Ctor);
          }
          if (typeof Ctor !== "function") {
            {
              warn$2("Invalid Component definition: ".concat(String(Ctor)), context);
            }
            return;
          }
          var asyncFactory;
          if (isUndef2(Ctor.cid)) {
            asyncFactory = Ctor;
            Ctor = resolveAsyncComponent2(asyncFactory, baseCtor);
            if (Ctor === void 0) {
              return createAsyncPlaceholder2(asyncFactory, data, context, children, tag);
            }
          }
          data = data || {};
          resolveConstructorOptions2(Ctor);
          if (isDef2(data.model)) {
            transformModel2(Ctor.options, data);
          }
          var propsData = extractPropsFromVNodeData2(data, Ctor, tag);
          if (isTrue2(Ctor.options.functional)) {
            return createFunctionalComponent2(Ctor, propsData, data, context, children);
          }
          var listeners = data.on;
          data.on = data.nativeOn;
          if (isTrue2(Ctor.options.abstract)) {
            var slot = data.slot;
            data = {};
            if (slot) {
              data.slot = slot;
            }
          }
          installComponentHooks2(data);
          var name = getComponentName2(Ctor.options) || tag;
          var vnode = new VNode2(
            // @ts-expect-error
            "vue-component-".concat(Ctor.cid).concat(name ? "-".concat(name) : ""),
            data,
            void 0,
            void 0,
            void 0,
            context,
            // @ts-expect-error
            { Ctor, propsData, listeners, tag, children },
            asyncFactory
          );
          return vnode;
        }
        function createComponentInstanceForVnode2(vnode, parent) {
          var options = {
            _isComponent: true,
            _parentVnode: vnode,
            parent
          };
          var inlineTemplate = vnode.data.inlineTemplate;
          if (isDef2(inlineTemplate)) {
            options.render = inlineTemplate.render;
            options.staticRenderFns = inlineTemplate.staticRenderFns;
          }
          return new vnode.componentOptions.Ctor(options);
        }
        function installComponentHooks2(data) {
          var hooks3 = data.hook || (data.hook = {});
          for (var i = 0; i < hooksToMerge2.length; i++) {
            var key = hooksToMerge2[i];
            var existing = hooks3[key];
            var toMerge = componentVNodeHooks2[key];
            if (existing !== toMerge && !(existing && existing._merged)) {
              hooks3[key] = existing ? mergeHook2(toMerge, existing) : toMerge;
            }
          }
        }
        function mergeHook2(f1, f2) {
          var merged = function(a, b) {
            f1(a, b);
            f2(a, b);
          };
          merged._merged = true;
          return merged;
        }
        function transformModel2(options, data) {
          var prop = options.model && options.model.prop || "value";
          var event = options.model && options.model.event || "input";
          (data.attrs || (data.attrs = {}))[prop] = data.model.value;
          var on2 = data.on || (data.on = {});
          var existing = on2[event];
          var callback = data.model.callback;
          if (isDef2(existing)) {
            if (isArray2(existing) ? existing.indexOf(callback) === -1 : existing !== callback) {
              on2[event] = [callback].concat(existing);
            }
          } else {
            on2[event] = callback;
          }
        }
        var warn$2 = noop2;
        var tip = noop2;
        var generateComponentTrace;
        var formatComponentName;
        {
          var hasConsole_1 = typeof console !== "undefined";
          var classifyRE_1 = /(?:^|[-_])(\w)/g;
          var classify_1 = function(str2) {
            return str2.replace(classifyRE_1, function(c) {
              return c.toUpperCase();
            }).replace(/[-_]/g, "");
          };
          warn$2 = function(msg, vm) {
            if (vm === void 0) {
              vm = currentInstance2;
            }
            var trace = vm ? generateComponentTrace(vm) : "";
            if (config2.warnHandler) {
              config2.warnHandler.call(null, msg, vm, trace);
            } else if (hasConsole_1 && !config2.silent) {
              console.error("[Vue warn]: ".concat(msg).concat(trace));
            }
          };
          tip = function(msg, vm) {
            if (hasConsole_1 && !config2.silent) {
              console.warn("[Vue tip]: ".concat(msg) + (vm ? generateComponentTrace(vm) : ""));
            }
          };
          formatComponentName = function(vm, includeFile) {
            if (vm.$root === vm) {
              return "<Root>";
            }
            var options = isFunction2(vm) && vm.cid != null ? vm.options : vm._isVue ? vm.$options || vm.constructor.options : vm;
            var name = getComponentName2(options);
            var file = options.__file;
            if (!name && file) {
              var match = file.match(/([^/\\]+)\.vue$/);
              name = match && match[1];
            }
            return (name ? "<".concat(classify_1(name), ">") : "<Anonymous>") + (file && includeFile !== false ? " at ".concat(file) : "");
          };
          var repeat_1 = function(str2, n) {
            var res = "";
            while (n) {
              if (n % 2 === 1)
                res += str2;
              if (n > 1)
                str2 += str2;
              n >>= 1;
            }
            return res;
          };
          generateComponentTrace = function(vm) {
            if (vm._isVue && vm.$parent) {
              var tree = [];
              var currentRecursiveSequence = 0;
              while (vm) {
                if (tree.length > 0) {
                  var last = tree[tree.length - 1];
                  if (last.constructor === vm.constructor) {
                    currentRecursiveSequence++;
                    vm = vm.$parent;
                    continue;
                  } else if (currentRecursiveSequence > 0) {
                    tree[tree.length - 1] = [last, currentRecursiveSequence];
                    currentRecursiveSequence = 0;
                  }
                }
                tree.push(vm);
                vm = vm.$parent;
              }
              return "\n\nfound in\n\n" + tree.map(function(vm2, i) {
                return "".concat(i === 0 ? "---> " : repeat_1(" ", 5 + i * 2)).concat(isArray2(vm2) ? "".concat(formatComponentName(vm2[0]), "... (").concat(vm2[1], " recursive calls)") : formatComponentName(vm2));
              }).join("\n");
            } else {
              return "\n\n(found in ".concat(formatComponentName(vm), ")");
            }
          };
        }
        var strats2 = config2.optionMergeStrategies;
        {
          strats2.el = strats2.propsData = function(parent, child, vm, key) {
            if (!vm) {
              warn$2('option "'.concat(key, '" can only be used during instance ') + "creation with the `new` keyword.");
            }
            return defaultStrat2(parent, child);
          };
        }
        function mergeData2(to, from, recursive) {
          if (recursive === void 0) {
            recursive = true;
          }
          if (!from)
            return to;
          var key, toVal, fromVal;
          var keys = hasSymbol2 ? Reflect.ownKeys(from) : Object.keys(from);
          for (var i = 0; i < keys.length; i++) {
            key = keys[i];
            if (key === "__ob__")
              continue;
            toVal = to[key];
            fromVal = from[key];
            if (!recursive || !hasOwn2(to, key)) {
              set2(to, key, fromVal);
            } else if (toVal !== fromVal && isPlainObject2(toVal) && isPlainObject2(fromVal)) {
              mergeData2(toVal, fromVal);
            }
          }
          return to;
        }
        function mergeDataOrFn2(parentVal, childVal, vm) {
          if (!vm) {
            if (!childVal) {
              return parentVal;
            }
            if (!parentVal) {
              return childVal;
            }
            return function mergedDataFn() {
              return mergeData2(isFunction2(childVal) ? childVal.call(this, this) : childVal, isFunction2(parentVal) ? parentVal.call(this, this) : parentVal);
            };
          } else {
            return function mergedInstanceDataFn() {
              var instanceData = isFunction2(childVal) ? childVal.call(vm, vm) : childVal;
              var defaultData = isFunction2(parentVal) ? parentVal.call(vm, vm) : parentVal;
              if (instanceData) {
                return mergeData2(instanceData, defaultData);
              } else {
                return defaultData;
              }
            };
          }
        }
        strats2.data = function(parentVal, childVal, vm) {
          if (!vm) {
            if (childVal && typeof childVal !== "function") {
              warn$2('The "data" option should be a function that returns a per-instance value in component definitions.', vm);
              return parentVal;
            }
            return mergeDataOrFn2(parentVal, childVal);
          }
          return mergeDataOrFn2(parentVal, childVal, vm);
        };
        function mergeLifecycleHook2(parentVal, childVal) {
          var res = childVal ? parentVal ? parentVal.concat(childVal) : isArray2(childVal) ? childVal : [childVal] : parentVal;
          return res ? dedupeHooks2(res) : res;
        }
        function dedupeHooks2(hooks3) {
          var res = [];
          for (var i = 0; i < hooks3.length; i++) {
            if (res.indexOf(hooks3[i]) === -1) {
              res.push(hooks3[i]);
            }
          }
          return res;
        }
        LIFECYCLE_HOOKS2.forEach(function(hook) {
          strats2[hook] = mergeLifecycleHook2;
        });
        function mergeAssets2(parentVal, childVal, vm, key) {
          var res = Object.create(parentVal || null);
          if (childVal) {
            assertObjectType(key, childVal, vm);
            return extend2(res, childVal);
          } else {
            return res;
          }
        }
        ASSET_TYPES2.forEach(function(type) {
          strats2[type + "s"] = mergeAssets2;
        });
        strats2.watch = function(parentVal, childVal, vm, key) {
          if (parentVal === nativeWatch2)
            parentVal = void 0;
          if (childVal === nativeWatch2)
            childVal = void 0;
          if (!childVal)
            return Object.create(parentVal || null);
          {
            assertObjectType(key, childVal, vm);
          }
          if (!parentVal)
            return childVal;
          var ret = {};
          extend2(ret, parentVal);
          for (var key_1 in childVal) {
            var parent_1 = ret[key_1];
            var child = childVal[key_1];
            if (parent_1 && !isArray2(parent_1)) {
              parent_1 = [parent_1];
            }
            ret[key_1] = parent_1 ? parent_1.concat(child) : isArray2(child) ? child : [child];
          }
          return ret;
        };
        strats2.props = strats2.methods = strats2.inject = strats2.computed = function(parentVal, childVal, vm, key) {
          if (childVal && true) {
            assertObjectType(key, childVal, vm);
          }
          if (!parentVal)
            return childVal;
          var ret = /* @__PURE__ */ Object.create(null);
          extend2(ret, parentVal);
          if (childVal)
            extend2(ret, childVal);
          return ret;
        };
        strats2.provide = function(parentVal, childVal) {
          if (!parentVal)
            return childVal;
          return function() {
            var ret = /* @__PURE__ */ Object.create(null);
            mergeData2(ret, isFunction2(parentVal) ? parentVal.call(this) : parentVal);
            if (childVal) {
              mergeData2(
                ret,
                isFunction2(childVal) ? childVal.call(this) : childVal,
                false
                // non-recursive
              );
            }
            return ret;
          };
        };
        var defaultStrat2 = function(parentVal, childVal) {
          return childVal === void 0 ? parentVal : childVal;
        };
        function checkComponents(options) {
          for (var key in options.components) {
            validateComponentName(key);
          }
        }
        function validateComponentName(name) {
          if (!new RegExp("^[a-zA-Z][\\-\\.0-9_".concat(unicodeRegExp2.source, "]*$")).test(name)) {
            warn$2('Invalid component name: "' + name + '". Component names should conform to valid custom element name in html5 specification.');
          }
          if (isBuiltInTag2(name) || config2.isReservedTag(name)) {
            warn$2("Do not use built-in or reserved HTML elements as component id: " + name);
          }
        }
        function normalizeProps2(options, vm) {
          var props3 = options.props;
          if (!props3)
            return;
          var res = {};
          var i, val, name;
          if (isArray2(props3)) {
            i = props3.length;
            while (i--) {
              val = props3[i];
              if (typeof val === "string") {
                name = camelize2(val);
                res[name] = { type: null };
              } else {
                warn$2("props must be strings when using array syntax.");
              }
            }
          } else if (isPlainObject2(props3)) {
            for (var key in props3) {
              val = props3[key];
              name = camelize2(key);
              res[name] = isPlainObject2(val) ? val : { type: val };
            }
          } else {
            warn$2('Invalid value for option "props": expected an Array or an Object, ' + "but got ".concat(toRawType(props3), "."), vm);
          }
          options.props = res;
        }
        function normalizeInject2(options, vm) {
          var inject2 = options.inject;
          if (!inject2)
            return;
          var normalized = options.inject = {};
          if (isArray2(inject2)) {
            for (var i = 0; i < inject2.length; i++) {
              normalized[inject2[i]] = { from: inject2[i] };
            }
          } else if (isPlainObject2(inject2)) {
            for (var key in inject2) {
              var val = inject2[key];
              normalized[key] = isPlainObject2(val) ? extend2({ from: key }, val) : { from: val };
            }
          } else {
            warn$2('Invalid value for option "inject": expected an Array or an Object, ' + "but got ".concat(toRawType(inject2), "."), vm);
          }
        }
        function normalizeDirectives$12(options) {
          var dirs = options.directives;
          if (dirs) {
            for (var key in dirs) {
              var def3 = dirs[key];
              if (isFunction2(def3)) {
                dirs[key] = { bind: def3, update: def3 };
              }
            }
          }
        }
        function assertObjectType(name, value, vm) {
          if (!isPlainObject2(value)) {
            warn$2('Invalid value for option "'.concat(name, '": expected an Object, ') + "but got ".concat(toRawType(value), "."), vm);
          }
        }
        function mergeOptions2(parent, child, vm) {
          {
            checkComponents(child);
          }
          if (isFunction2(child)) {
            child = child.options;
          }
          normalizeProps2(child, vm);
          normalizeInject2(child, vm);
          normalizeDirectives$12(child);
          if (!child._base) {
            if (child.extends) {
              parent = mergeOptions2(parent, child.extends, vm);
            }
            if (child.mixins) {
              for (var i = 0, l = child.mixins.length; i < l; i++) {
                parent = mergeOptions2(parent, child.mixins[i], vm);
              }
            }
          }
          var options = {};
          var key;
          for (key in parent) {
            mergeField(key);
          }
          for (key in child) {
            if (!hasOwn2(parent, key)) {
              mergeField(key);
            }
          }
          function mergeField(key2) {
            var strat = strats2[key2] || defaultStrat2;
            options[key2] = strat(parent[key2], child[key2], vm, key2);
          }
          return options;
        }
        function resolveAsset2(options, type, id, warnMissing) {
          if (typeof id !== "string") {
            return;
          }
          var assets = options[type];
          if (hasOwn2(assets, id))
            return assets[id];
          var camelizedId = camelize2(id);
          if (hasOwn2(assets, camelizedId))
            return assets[camelizedId];
          var PascalCaseId = capitalize2(camelizedId);
          if (hasOwn2(assets, PascalCaseId))
            return assets[PascalCaseId];
          var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
          if (warnMissing && !res) {
            warn$2("Failed to resolve " + type.slice(0, -1) + ": " + id);
          }
          return res;
        }
        function validateProp2(key, propOptions, propsData, vm) {
          var prop = propOptions[key];
          var absent = !hasOwn2(propsData, key);
          var value = propsData[key];
          var booleanIndex = getTypeIndex2(Boolean, prop.type);
          if (booleanIndex > -1) {
            if (absent && !hasOwn2(prop, "default")) {
              value = false;
            } else if (value === "" || value === hyphenate2(key)) {
              var stringIndex = getTypeIndex2(String, prop.type);
              if (stringIndex < 0 || booleanIndex < stringIndex) {
                value = true;
              }
            }
          }
          if (value === void 0) {
            value = getPropDefaultValue2(vm, prop, key);
            var prevShouldObserve = shouldObserve2;
            toggleObserving2(true);
            observe2(value);
            toggleObserving2(prevShouldObserve);
          }
          {
            assertProp(prop, key, value, vm, absent);
          }
          return value;
        }
        function getPropDefaultValue2(vm, prop, key) {
          if (!hasOwn2(prop, "default")) {
            return void 0;
          }
          var def3 = prop.default;
          if (isObject3(def3)) {
            warn$2('Invalid default value for prop "' + key + '": Props with type Object/Array must use a factory function to return the default value.', vm);
          }
          if (vm && vm.$options.propsData && vm.$options.propsData[key] === void 0 && vm._props[key] !== void 0) {
            return vm._props[key];
          }
          return isFunction2(def3) && getType2(prop.type) !== "Function" ? def3.call(vm) : def3;
        }
        function assertProp(prop, name, value, vm, absent) {
          if (prop.required && absent) {
            warn$2('Missing required prop: "' + name + '"', vm);
            return;
          }
          if (value == null && !prop.required) {
            return;
          }
          var type = prop.type;
          var valid = !type || type === true;
          var expectedTypes = [];
          if (type) {
            if (!isArray2(type)) {
              type = [type];
            }
            for (var i = 0; i < type.length && !valid; i++) {
              var assertedType = assertType(value, type[i], vm);
              expectedTypes.push(assertedType.expectedType || "");
              valid = assertedType.valid;
            }
          }
          var haveExpectedTypes = expectedTypes.some(function(t) {
            return t;
          });
          if (!valid && haveExpectedTypes) {
            warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
            return;
          }
          var validator = prop.validator;
          if (validator) {
            if (!validator(value)) {
              warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
            }
          }
        }
        var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
        function assertType(value, type, vm) {
          var valid;
          var expectedType = getType2(type);
          if (simpleCheckRE.test(expectedType)) {
            var t = typeof value;
            valid = t === expectedType.toLowerCase();
            if (!valid && t === "object") {
              valid = value instanceof type;
            }
          } else if (expectedType === "Object") {
            valid = isPlainObject2(value);
          } else if (expectedType === "Array") {
            valid = isArray2(value);
          } else {
            try {
              valid = value instanceof type;
            } catch (e) {
              warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
              valid = false;
            }
          }
          return {
            valid,
            expectedType
          };
        }
        var functionTypeCheckRE2 = /^\s*function (\w+)/;
        function getType2(fn) {
          var match = fn && fn.toString().match(functionTypeCheckRE2);
          return match ? match[1] : "";
        }
        function isSameType2(a, b) {
          return getType2(a) === getType2(b);
        }
        function getTypeIndex2(type, expectedTypes) {
          if (!isArray2(expectedTypes)) {
            return isSameType2(expectedTypes, type) ? 0 : -1;
          }
          for (var i = 0, len2 = expectedTypes.length; i < len2; i++) {
            if (isSameType2(expectedTypes[i], type)) {
              return i;
            }
          }
          return -1;
        }
        function getInvalidTypeMessage(name, value, expectedTypes) {
          var message = 'Invalid prop: type check failed for prop "'.concat(name, '".') + " Expected ".concat(expectedTypes.map(capitalize2).join(", "));
          var expectedType = expectedTypes[0];
          var receivedType = toRawType(value);
          if (expectedTypes.length === 1 && isExplicable(expectedType) && isExplicable(typeof value) && !isBoolean(expectedType, receivedType)) {
            message += " with value ".concat(styleValue(value, expectedType));
          }
          message += ", got ".concat(receivedType, " ");
          if (isExplicable(receivedType)) {
            message += "with value ".concat(styleValue(value, receivedType), ".");
          }
          return message;
        }
        function styleValue(value, type) {
          if (type === "String") {
            return '"'.concat(value, '"');
          } else if (type === "Number") {
            return "".concat(Number(value));
          } else {
            return "".concat(value);
          }
        }
        var EXPLICABLE_TYPES = ["string", "number", "boolean"];
        function isExplicable(value) {
          return EXPLICABLE_TYPES.some(function(elem) {
            return value.toLowerCase() === elem;
          });
        }
        function isBoolean() {
          var args = [];
          for (var _i = 0; _i < arguments.length; _i++) {
            args[_i] = arguments[_i];
          }
          return args.some(function(elem) {
            return elem.toLowerCase() === "boolean";
          });
        }
        function Vue4(options) {
          if (!(this instanceof Vue4)) {
            warn$2("Vue is a constructor and should be called with the `new` keyword");
          }
          this._init(options);
        }
        initMixin$12(Vue4);
        stateMixin2(Vue4);
        eventsMixin2(Vue4);
        lifecycleMixin2(Vue4);
        renderMixin2(Vue4);
        function initUse2(Vue5) {
          Vue5.use = function(plugin) {
            var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
            if (installedPlugins.indexOf(plugin) > -1) {
              return this;
            }
            var args = toArray2(arguments, 1);
            args.unshift(this);
            if (isFunction2(plugin.install)) {
              plugin.install.apply(plugin, args);
            } else if (isFunction2(plugin)) {
              plugin.apply(null, args);
            }
            installedPlugins.push(plugin);
            return this;
          };
        }
        function initMixin2(Vue5) {
          Vue5.mixin = function(mixin) {
            this.options = mergeOptions2(this.options, mixin);
            return this;
          };
        }
        function initExtend2(Vue5) {
          Vue5.cid = 0;
          var cid = 1;
          Vue5.extend = function(extendOptions) {
            extendOptions = extendOptions || {};
            var Super = this;
            var SuperId = Super.cid;
            var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
            if (cachedCtors[SuperId]) {
              return cachedCtors[SuperId];
            }
            var name = getComponentName2(extendOptions) || getComponentName2(Super.options);
            if (name) {
              validateComponentName(name);
            }
            var Sub = function VueComponent(options) {
              this._init(options);
            };
            Sub.prototype = Object.create(Super.prototype);
            Sub.prototype.constructor = Sub;
            Sub.cid = cid++;
            Sub.options = mergeOptions2(Super.options, extendOptions);
            Sub["super"] = Super;
            if (Sub.options.props) {
              initProps2(Sub);
            }
            if (Sub.options.computed) {
              initComputed2(Sub);
            }
            Sub.extend = Super.extend;
            Sub.mixin = Super.mixin;
            Sub.use = Super.use;
            ASSET_TYPES2.forEach(function(type) {
              Sub[type] = Super[type];
            });
            if (name) {
              Sub.options.components[name] = Sub;
            }
            Sub.superOptions = Super.options;
            Sub.extendOptions = extendOptions;
            Sub.sealedOptions = extend2({}, Sub.options);
            cachedCtors[SuperId] = Sub;
            return Sub;
          };
        }
        function initProps2(Comp) {
          var props3 = Comp.options.props;
          for (var key in props3) {
            proxy2(Comp.prototype, "_props", key);
          }
        }
        function initComputed2(Comp) {
          var computed2 = Comp.options.computed;
          for (var key in computed2) {
            defineComputed2(Comp.prototype, key, computed2[key]);
          }
        }
        function initAssetRegisters2(Vue5) {
          ASSET_TYPES2.forEach(function(type) {
            Vue5[type] = function(id, definition) {
              if (!definition) {
                return this.options[type + "s"][id];
              } else {
                if (type === "component") {
                  validateComponentName(id);
                }
                if (type === "component" && isPlainObject2(definition)) {
                  definition.name = definition.name || id;
                  definition = this.options._base.extend(definition);
                }
                if (type === "directive" && isFunction2(definition)) {
                  definition = { bind: definition, update: definition };
                }
                this.options[type + "s"][id] = definition;
                return definition;
              }
            };
          });
        }
        function _getComponentName2(opts2) {
          return opts2 && (getComponentName2(opts2.Ctor.options) || opts2.tag);
        }
        function matches2(pattern, name) {
          if (isArray2(pattern)) {
            return pattern.indexOf(name) > -1;
          } else if (typeof pattern === "string") {
            return pattern.split(",").indexOf(name) > -1;
          } else if (isRegExp2(pattern)) {
            return pattern.test(name);
          }
          return false;
        }
        function pruneCache2(keepAliveInstance, filter) {
          var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode, $vnode = keepAliveInstance.$vnode;
          for (var key in cache) {
            var entry = cache[key];
            if (entry) {
              var name_1 = entry.name;
              if (name_1 && !filter(name_1)) {
                pruneCacheEntry2(cache, key, keys, _vnode);
              }
            }
          }
          $vnode.componentOptions.children = void 0;
        }
        function pruneCacheEntry2(cache, key, keys, current) {
          var entry = cache[key];
          if (entry && (!current || entry.tag !== current.tag)) {
            entry.componentInstance.$destroy();
          }
          cache[key] = null;
          remove$22(keys, key);
        }
        var patternTypes2 = [String, RegExp, Array];
        var KeepAlive2 = {
          name: "keep-alive",
          abstract: true,
          props: {
            include: patternTypes2,
            exclude: patternTypes2,
            max: [String, Number]
          },
          methods: {
            cacheVNode: function() {
              var _a2 = this, cache = _a2.cache, keys = _a2.keys, vnodeToCache = _a2.vnodeToCache, keyToCache = _a2.keyToCache;
              if (vnodeToCache) {
                var tag = vnodeToCache.tag, componentInstance = vnodeToCache.componentInstance, componentOptions = vnodeToCache.componentOptions;
                cache[keyToCache] = {
                  name: _getComponentName2(componentOptions),
                  tag,
                  componentInstance
                };
                keys.push(keyToCache);
                if (this.max && keys.length > parseInt(this.max)) {
                  pruneCacheEntry2(cache, keys[0], keys, this._vnode);
                }
                this.vnodeToCache = null;
              }
            }
          },
          created: function() {
            this.cache = /* @__PURE__ */ Object.create(null);
            this.keys = [];
          },
          destroyed: function() {
            for (var key in this.cache) {
              pruneCacheEntry2(this.cache, key, this.keys);
            }
          },
          mounted: function() {
            var _this = this;
            this.cacheVNode();
            this.$watch("include", function(val) {
              pruneCache2(_this, function(name) {
                return matches2(val, name);
              });
            });
            this.$watch("exclude", function(val) {
              pruneCache2(_this, function(name) {
                return !matches2(val, name);
              });
            });
          },
          updated: function() {
            this.cacheVNode();
          },
          render: function() {
            var slot = this.$slots.default;
            var vnode = getFirstComponentChild2(slot);
            var componentOptions = vnode && vnode.componentOptions;
            if (componentOptions) {
              var name_2 = _getComponentName2(componentOptions);
              var _a2 = this, include = _a2.include, exclude = _a2.exclude;
              if (
                // not included
                include && (!name_2 || !matches2(include, name_2)) || // excluded
                exclude && name_2 && matches2(exclude, name_2)
              ) {
                return vnode;
              }
              var _b = this, cache = _b.cache, keys = _b.keys;
              var key = vnode.key == null ? (
                // same constructor may get registered as different local components
                // so cid alone is not enough (#3269)
                componentOptions.Ctor.cid + (componentOptions.tag ? "::".concat(componentOptions.tag) : "")
              ) : vnode.key;
              if (cache[key]) {
                vnode.componentInstance = cache[key].componentInstance;
                remove$22(keys, key);
                keys.push(key);
              } else {
                this.vnodeToCache = vnode;
                this.keyToCache = key;
              }
              vnode.data.keepAlive = true;
            }
            return vnode || slot && slot[0];
          }
        };
        var builtInComponents2 = {
          KeepAlive: KeepAlive2
        };
        function initGlobalAPI2(Vue5) {
          var configDef = {};
          configDef.get = function() {
            return config2;
          };
          {
            configDef.set = function() {
              warn$2("Do not replace the Vue.config object, set individual fields instead.");
            };
          }
          Object.defineProperty(Vue5, "config", configDef);
          Vue5.util = {
            warn: warn$2,
            extend: extend2,
            mergeOptions: mergeOptions2,
            defineReactive: defineReactive2
          };
          Vue5.set = set2;
          Vue5.delete = del2;
          Vue5.nextTick = nextTick2;
          Vue5.observable = function(obj) {
            observe2(obj);
            return obj;
          };
          Vue5.options = /* @__PURE__ */ Object.create(null);
          ASSET_TYPES2.forEach(function(type) {
            Vue5.options[type + "s"] = /* @__PURE__ */ Object.create(null);
          });
          Vue5.options._base = Vue5;
          extend2(Vue5.options.components, builtInComponents2);
          initUse2(Vue5);
          initMixin2(Vue5);
          initExtend2(Vue5);
          initAssetRegisters2(Vue5);
        }
        initGlobalAPI2(Vue4);
        Object.defineProperty(Vue4.prototype, "$isServer", {
          get: isServerRendering2
        });
        Object.defineProperty(Vue4.prototype, "$ssrContext", {
          get: function() {
            return this.$vnode && this.$vnode.ssrContext;
          }
        });
        Object.defineProperty(Vue4, "FunctionalRenderContext", {
          value: FunctionalRenderContext2
        });
        Vue4.version = version2;
        var isReservedAttr2 = makeMap2("style,class");
        var acceptValue2 = makeMap2("input,textarea,option,select,progress");
        var mustUseProp2 = function(tag, type, attr) {
          return attr === "value" && acceptValue2(tag) && type !== "button" || attr === "selected" && tag === "option" || attr === "checked" && tag === "input" || attr === "muted" && tag === "video";
        };
        var isEnumeratedAttr2 = makeMap2("contenteditable,draggable,spellcheck");
        var isValidContentEditableValue2 = makeMap2("events,caret,typing,plaintext-only");
        var convertEnumeratedValue2 = function(key, value) {
          return isFalsyAttrValue2(value) || value === "false" ? "false" : (
            // allow arbitrary string value for contenteditable
            key === "contenteditable" && isValidContentEditableValue2(value) ? value : "true"
          );
        };
        var isBooleanAttr2 = makeMap2("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible");
        var xlinkNS2 = "http://www.w3.org/1999/xlink";
        var isXlink2 = function(name) {
          return name.charAt(5) === ":" && name.slice(0, 5) === "xlink";
        };
        var getXlinkProp2 = function(name) {
          return isXlink2(name) ? name.slice(6, name.length) : "";
        };
        var isFalsyAttrValue2 = function(val) {
          return val == null || val === false;
        };
        function genClassForVnode2(vnode) {
          var data = vnode.data;
          var parentNode3 = vnode;
          var childNode = vnode;
          while (isDef2(childNode.componentInstance)) {
            childNode = childNode.componentInstance._vnode;
            if (childNode && childNode.data) {
              data = mergeClassData2(childNode.data, data);
            }
          }
          while (isDef2(parentNode3 = parentNode3.parent)) {
            if (parentNode3 && parentNode3.data) {
              data = mergeClassData2(data, parentNode3.data);
            }
          }
          return renderClass2(data.staticClass, data.class);
        }
        function mergeClassData2(child, parent) {
          return {
            staticClass: concat2(child.staticClass, parent.staticClass),
            class: isDef2(child.class) ? [child.class, parent.class] : parent.class
          };
        }
        function renderClass2(staticClass, dynamicClass) {
          if (isDef2(staticClass) || isDef2(dynamicClass)) {
            return concat2(staticClass, stringifyClass2(dynamicClass));
          }
          return "";
        }
        function concat2(a, b) {
          return a ? b ? a + " " + b : a : b || "";
        }
        function stringifyClass2(value) {
          if (Array.isArray(value)) {
            return stringifyArray2(value);
          }
          if (isObject3(value)) {
            return stringifyObject2(value);
          }
          if (typeof value === "string") {
            return value;
          }
          return "";
        }
        function stringifyArray2(value) {
          var res = "";
          var stringified;
          for (var i = 0, l = value.length; i < l; i++) {
            if (isDef2(stringified = stringifyClass2(value[i])) && stringified !== "") {
              if (res)
                res += " ";
              res += stringified;
            }
          }
          return res;
        }
        function stringifyObject2(value) {
          var res = "";
          for (var key in value) {
            if (value[key]) {
              if (res)
                res += " ";
              res += key;
            }
          }
          return res;
        }
        var namespaceMap2 = {
          svg: "http://www.w3.org/2000/svg",
          math: "http://www.w3.org/1998/Math/MathML"
        };
        var isHTMLTag2 = makeMap2("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot");
        var isSVG2 = makeMap2("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view", true);
        var isPreTag = function(tag) {
          return tag === "pre";
        };
        var isReservedTag2 = function(tag) {
          return isHTMLTag2(tag) || isSVG2(tag);
        };
        function getTagNamespace2(tag) {
          if (isSVG2(tag)) {
            return "svg";
          }
          if (tag === "math") {
            return "math";
          }
        }
        var unknownElementCache2 = /* @__PURE__ */ Object.create(null);
        function isUnknownElement2(tag) {
          if (!inBrowser2) {
            return true;
          }
          if (isReservedTag2(tag)) {
            return false;
          }
          tag = tag.toLowerCase();
          if (unknownElementCache2[tag] != null) {
            return unknownElementCache2[tag];
          }
          var el = document.createElement(tag);
          if (tag.indexOf("-") > -1) {
            return unknownElementCache2[tag] = el.constructor === window.HTMLUnknownElement || el.constructor === window.HTMLElement;
          } else {
            return unknownElementCache2[tag] = /HTMLUnknownElement/.test(el.toString());
          }
        }
        var isTextInputType2 = makeMap2("text,number,password,search,email,tel,url");
        function query2(el) {
          if (typeof el === "string") {
            var selected = document.querySelector(el);
            if (!selected) {
              warn$2("Cannot find element: " + el);
              return document.createElement("div");
            }
            return selected;
          } else {
            return el;
          }
        }
        function createElement2(tagName3, vnode) {
          var elm = document.createElement(tagName3);
          if (tagName3 !== "select") {
            return elm;
          }
          if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== void 0) {
            elm.setAttribute("multiple", "multiple");
          }
          return elm;
        }
        function createElementNS2(namespace, tagName3) {
          return document.createElementNS(namespaceMap2[namespace], tagName3);
        }
        function createTextNode2(text2) {
          return document.createTextNode(text2);
        }
        function createComment2(text2) {
          return document.createComment(text2);
        }
        function insertBefore2(parentNode3, newNode, referenceNode) {
          parentNode3.insertBefore(newNode, referenceNode);
        }
        function removeChild3(node, child) {
          node.removeChild(child);
        }
        function appendChild2(node, child) {
          node.appendChild(child);
        }
        function parentNode2(node) {
          return node.parentNode;
        }
        function nextSibling2(node) {
          return node.nextSibling;
        }
        function tagName2(node) {
          return node.tagName;
        }
        function setTextContent2(node, text2) {
          node.textContent = text2;
        }
        function setStyleScope2(node, scopeId) {
          node.setAttribute(scopeId, "");
        }
        var nodeOps2 = /* @__PURE__ */ Object.freeze({
          __proto__: null,
          createElement: createElement2,
          createElementNS: createElementNS2,
          createTextNode: createTextNode2,
          createComment: createComment2,
          insertBefore: insertBefore2,
          removeChild: removeChild3,
          appendChild: appendChild2,
          parentNode: parentNode2,
          nextSibling: nextSibling2,
          tagName: tagName2,
          setTextContent: setTextContent2,
          setStyleScope: setStyleScope2
        });
        var ref2 = {
          create: function(_, vnode) {
            registerRef2(vnode);
          },
          update: function(oldVnode, vnode) {
            if (oldVnode.data.ref !== vnode.data.ref) {
              registerRef2(oldVnode, true);
              registerRef2(vnode);
            }
          },
          destroy: function(vnode) {
            registerRef2(vnode, true);
          }
        };
        function registerRef2(vnode, isRemoval) {
          var ref3 = vnode.data.ref;
          if (!isDef2(ref3))
            return;
          var vm = vnode.context;
          var refValue = vnode.componentInstance || vnode.elm;
          var value = isRemoval ? null : refValue;
          var $refsValue = isRemoval ? void 0 : refValue;
          if (isFunction2(ref3)) {
            invokeWithErrorHandling2(ref3, vm, [value], vm, "template ref function");
            return;
          }
          var isFor = vnode.data.refInFor;
          var _isString = typeof ref3 === "string" || typeof ref3 === "number";
          var _isRef = isRef2(ref3);
          var refs = vm.$refs;
          if (_isString || _isRef) {
            if (isFor) {
              var existing = _isString ? refs[ref3] : ref3.value;
              if (isRemoval) {
                isArray2(existing) && remove$22(existing, refValue);
              } else {
                if (!isArray2(existing)) {
                  if (_isString) {
                    refs[ref3] = [refValue];
                    setSetupRef2(vm, ref3, refs[ref3]);
                  } else {
                    ref3.value = [refValue];
                  }
                } else if (!existing.includes(refValue)) {
                  existing.push(refValue);
                }
              }
            } else if (_isString) {
              if (isRemoval && refs[ref3] !== refValue) {
                return;
              }
              refs[ref3] = $refsValue;
              setSetupRef2(vm, ref3, value);
            } else if (_isRef) {
              if (isRemoval && ref3.value !== refValue) {
                return;
              }
              ref3.value = value;
            } else {
              warn$2("Invalid template ref type: ".concat(typeof ref3));
            }
          }
        }
        function setSetupRef2(_a2, key, val) {
          var _setupState = _a2._setupState;
          if (_setupState && hasOwn2(_setupState, key)) {
            if (isRef2(_setupState[key])) {
              _setupState[key].value = val;
            } else {
              _setupState[key] = val;
            }
          }
        }
        var emptyNode2 = new VNode2("", {}, []);
        var hooks2 = ["create", "activate", "update", "remove", "destroy"];
        function sameVnode2(a, b) {
          return a.key === b.key && a.asyncFactory === b.asyncFactory && (a.tag === b.tag && a.isComment === b.isComment && isDef2(a.data) === isDef2(b.data) && sameInputType2(a, b) || isTrue2(a.isAsyncPlaceholder) && isUndef2(b.asyncFactory.error));
        }
        function sameInputType2(a, b) {
          if (a.tag !== "input")
            return true;
          var i;
          var typeA = isDef2(i = a.data) && isDef2(i = i.attrs) && i.type;
          var typeB = isDef2(i = b.data) && isDef2(i = i.attrs) && i.type;
          return typeA === typeB || isTextInputType2(typeA) && isTextInputType2(typeB);
        }
        function createKeyToOldIdx2(children, beginIdx, endIdx) {
          var i, key;
          var map = {};
          for (i = beginIdx; i <= endIdx; ++i) {
            key = children[i].key;
            if (isDef2(key))
              map[key] = i;
          }
          return map;
        }
        function createPatchFunction2(backend) {
          var i, j;
          var cbs = {};
          var modules3 = backend.modules, nodeOps3 = backend.nodeOps;
          for (i = 0; i < hooks2.length; ++i) {
            cbs[hooks2[i]] = [];
            for (j = 0; j < modules3.length; ++j) {
              if (isDef2(modules3[j][hooks2[i]])) {
                cbs[hooks2[i]].push(modules3[j][hooks2[i]]);
              }
            }
          }
          function emptyNodeAt(elm) {
            return new VNode2(nodeOps3.tagName(elm).toLowerCase(), {}, [], void 0, elm);
          }
          function createRmCb(childElm, listeners) {
            function remove3() {
              if (--remove3.listeners === 0) {
                removeNode(childElm);
              }
            }
            remove3.listeners = listeners;
            return remove3;
          }
          function removeNode(el) {
            var parent = nodeOps3.parentNode(el);
            if (isDef2(parent)) {
              nodeOps3.removeChild(parent, el);
            }
          }
          function isUnknownElement3(vnode, inVPre) {
            return !inVPre && !vnode.ns && !(config2.ignoredElements.length && config2.ignoredElements.some(function(ignore) {
              return isRegExp2(ignore) ? ignore.test(vnode.tag) : ignore === vnode.tag;
            })) && config2.isUnknownElement(vnode.tag);
          }
          var creatingElmInVPre = 0;
          function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index4) {
            if (isDef2(vnode.elm) && isDef2(ownerArray)) {
              vnode = ownerArray[index4] = cloneVNode2(vnode);
            }
            vnode.isRootInsert = !nested;
            if (createComponent3(vnode, insertedVnodeQueue, parentElm, refElm)) {
              return;
            }
            var data = vnode.data;
            var children = vnode.children;
            var tag = vnode.tag;
            if (isDef2(tag)) {
              {
                if (data && data.pre) {
                  creatingElmInVPre++;
                }
                if (isUnknownElement3(vnode, creatingElmInVPre)) {
                  warn$2("Unknown custom element: <" + tag + '> - did you register the component correctly? For recursive components, make sure to provide the "name" option.', vnode.context);
                }
              }
              vnode.elm = vnode.ns ? nodeOps3.createElementNS(vnode.ns, tag) : nodeOps3.createElement(tag, vnode);
              setScope(vnode);
              createChildren(vnode, children, insertedVnodeQueue);
              if (isDef2(data)) {
                invokeCreateHooks(vnode, insertedVnodeQueue);
              }
              insert(parentElm, vnode.elm, refElm);
              if (data && data.pre) {
                creatingElmInVPre--;
              }
            } else if (isTrue2(vnode.isComment)) {
              vnode.elm = nodeOps3.createComment(vnode.text);
              insert(parentElm, vnode.elm, refElm);
            } else {
              vnode.elm = nodeOps3.createTextNode(vnode.text);
              insert(parentElm, vnode.elm, refElm);
            }
          }
          function createComponent3(vnode, insertedVnodeQueue, parentElm, refElm) {
            var i2 = vnode.data;
            if (isDef2(i2)) {
              var isReactivated = isDef2(vnode.componentInstance) && i2.keepAlive;
              if (isDef2(i2 = i2.hook) && isDef2(i2 = i2.init)) {
                i2(
                  vnode,
                  false
                  /* hydrating */
                );
              }
              if (isDef2(vnode.componentInstance)) {
                initComponent(vnode, insertedVnodeQueue);
                insert(parentElm, vnode.elm, refElm);
                if (isTrue2(isReactivated)) {
                  reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
                }
                return true;
              }
            }
          }
          function initComponent(vnode, insertedVnodeQueue) {
            if (isDef2(vnode.data.pendingInsert)) {
              insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
              vnode.data.pendingInsert = null;
            }
            vnode.elm = vnode.componentInstance.$el;
            if (isPatchable(vnode)) {
              invokeCreateHooks(vnode, insertedVnodeQueue);
              setScope(vnode);
            } else {
              registerRef2(vnode);
              insertedVnodeQueue.push(vnode);
            }
          }
          function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
            var i2;
            var innerNode = vnode;
            while (innerNode.componentInstance) {
              innerNode = innerNode.componentInstance._vnode;
              if (isDef2(i2 = innerNode.data) && isDef2(i2 = i2.transition)) {
                for (i2 = 0; i2 < cbs.activate.length; ++i2) {
                  cbs.activate[i2](emptyNode2, innerNode);
                }
                insertedVnodeQueue.push(innerNode);
                break;
              }
            }
            insert(parentElm, vnode.elm, refElm);
          }
          function insert(parent, elm, ref3) {
            if (isDef2(parent)) {
              if (isDef2(ref3)) {
                if (nodeOps3.parentNode(ref3) === parent) {
                  nodeOps3.insertBefore(parent, elm, ref3);
                }
              } else {
                nodeOps3.appendChild(parent, elm);
              }
            }
          }
          function createChildren(vnode, children, insertedVnodeQueue) {
            if (isArray2(children)) {
              {
                checkDuplicateKeys(children);
              }
              for (var i_1 = 0; i_1 < children.length; ++i_1) {
                createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
              }
            } else if (isPrimitive2(vnode.text)) {
              nodeOps3.appendChild(vnode.elm, nodeOps3.createTextNode(String(vnode.text)));
            }
          }
          function isPatchable(vnode) {
            while (vnode.componentInstance) {
              vnode = vnode.componentInstance._vnode;
            }
            return isDef2(vnode.tag);
          }
          function invokeCreateHooks(vnode, insertedVnodeQueue) {
            for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
              cbs.create[i_2](emptyNode2, vnode);
            }
            i = vnode.data.hook;
            if (isDef2(i)) {
              if (isDef2(i.create))
                i.create(emptyNode2, vnode);
              if (isDef2(i.insert))
                insertedVnodeQueue.push(vnode);
            }
          }
          function setScope(vnode) {
            var i2;
            if (isDef2(i2 = vnode.fnScopeId)) {
              nodeOps3.setStyleScope(vnode.elm, i2);
            } else {
              var ancestor = vnode;
              while (ancestor) {
                if (isDef2(i2 = ancestor.context) && isDef2(i2 = i2.$options._scopeId)) {
                  nodeOps3.setStyleScope(vnode.elm, i2);
                }
                ancestor = ancestor.parent;
              }
            }
            if (isDef2(i2 = activeInstance2) && i2 !== vnode.context && i2 !== vnode.fnContext && isDef2(i2 = i2.$options._scopeId)) {
              nodeOps3.setStyleScope(vnode.elm, i2);
            }
          }
          function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
            for (; startIdx <= endIdx; ++startIdx) {
              createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
            }
          }
          function invokeDestroyHook(vnode) {
            var i2, j2;
            var data = vnode.data;
            if (isDef2(data)) {
              if (isDef2(i2 = data.hook) && isDef2(i2 = i2.destroy))
                i2(vnode);
              for (i2 = 0; i2 < cbs.destroy.length; ++i2)
                cbs.destroy[i2](vnode);
            }
            if (isDef2(i2 = vnode.children)) {
              for (j2 = 0; j2 < vnode.children.length; ++j2) {
                invokeDestroyHook(vnode.children[j2]);
              }
            }
          }
          function removeVnodes(vnodes, startIdx, endIdx) {
            for (; startIdx <= endIdx; ++startIdx) {
              var ch = vnodes[startIdx];
              if (isDef2(ch)) {
                if (isDef2(ch.tag)) {
                  removeAndInvokeRemoveHook(ch);
                  invokeDestroyHook(ch);
                } else {
                  removeNode(ch.elm);
                }
              }
            }
          }
          function removeAndInvokeRemoveHook(vnode, rm) {
            if (isDef2(rm) || isDef2(vnode.data)) {
              var i_3;
              var listeners = cbs.remove.length + 1;
              if (isDef2(rm)) {
                rm.listeners += listeners;
              } else {
                rm = createRmCb(vnode.elm, listeners);
              }
              if (isDef2(i_3 = vnode.componentInstance) && isDef2(i_3 = i_3._vnode) && isDef2(i_3.data)) {
                removeAndInvokeRemoveHook(i_3, rm);
              }
              for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
                cbs.remove[i_3](vnode, rm);
              }
              if (isDef2(i_3 = vnode.data.hook) && isDef2(i_3 = i_3.remove)) {
                i_3(vnode, rm);
              } else {
                rm();
              }
            } else {
              removeNode(vnode.elm);
            }
          }
          function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
            var oldStartIdx = 0;
            var newStartIdx = 0;
            var oldEndIdx = oldCh.length - 1;
            var oldStartVnode = oldCh[0];
            var oldEndVnode = oldCh[oldEndIdx];
            var newEndIdx = newCh.length - 1;
            var newStartVnode = newCh[0];
            var newEndVnode = newCh[newEndIdx];
            var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
            var canMove = !removeOnly;
            {
              checkDuplicateKeys(newCh);
            }
            while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
              if (isUndef2(oldStartVnode)) {
                oldStartVnode = oldCh[++oldStartIdx];
              } else if (isUndef2(oldEndVnode)) {
                oldEndVnode = oldCh[--oldEndIdx];
              } else if (sameVnode2(oldStartVnode, newStartVnode)) {
                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
                oldStartVnode = oldCh[++oldStartIdx];
                newStartVnode = newCh[++newStartIdx];
              } else if (sameVnode2(oldEndVnode, newEndVnode)) {
                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
                oldEndVnode = oldCh[--oldEndIdx];
                newEndVnode = newCh[--newEndIdx];
              } else if (sameVnode2(oldStartVnode, newEndVnode)) {
                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
                canMove && nodeOps3.insertBefore(parentElm, oldStartVnode.elm, nodeOps3.nextSibling(oldEndVnode.elm));
                oldStartVnode = oldCh[++oldStartIdx];
                newEndVnode = newCh[--newEndIdx];
              } else if (sameVnode2(oldEndVnode, newStartVnode)) {
                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
                canMove && nodeOps3.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
                oldEndVnode = oldCh[--oldEndIdx];
                newStartVnode = newCh[++newStartIdx];
              } else {
                if (isUndef2(oldKeyToIdx))
                  oldKeyToIdx = createKeyToOldIdx2(oldCh, oldStartIdx, oldEndIdx);
                idxInOld = isDef2(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
                if (isUndef2(idxInOld)) {
                  createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
                } else {
                  vnodeToMove = oldCh[idxInOld];
                  if (sameVnode2(vnodeToMove, newStartVnode)) {
                    patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
                    oldCh[idxInOld] = void 0;
                    canMove && nodeOps3.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
                  } else {
                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
                  }
                }
                newStartVnode = newCh[++newStartIdx];
              }
            }
            if (oldStartIdx > oldEndIdx) {
              refElm = isUndef2(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
              addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
            } else if (newStartIdx > newEndIdx) {
              removeVnodes(oldCh, oldStartIdx, oldEndIdx);
            }
          }
          function checkDuplicateKeys(children) {
            var seenKeys = {};
            for (var i_4 = 0; i_4 < children.length; i_4++) {
              var vnode = children[i_4];
              var key = vnode.key;
              if (isDef2(key)) {
                if (seenKeys[key]) {
                  warn$2("Duplicate keys detected: '".concat(key, "'. This may cause an update error."), vnode.context);
                } else {
                  seenKeys[key] = true;
                }
              }
            }
          }
          function findIdxInOld(node, oldCh, start, end) {
            for (var i_5 = start; i_5 < end; i_5++) {
              var c = oldCh[i_5];
              if (isDef2(c) && sameVnode2(node, c))
                return i_5;
            }
          }
          function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index4, removeOnly) {
            if (oldVnode === vnode) {
              return;
            }
            if (isDef2(vnode.elm) && isDef2(ownerArray)) {
              vnode = ownerArray[index4] = cloneVNode2(vnode);
            }
            var elm = vnode.elm = oldVnode.elm;
            if (isTrue2(oldVnode.isAsyncPlaceholder)) {
              if (isDef2(vnode.asyncFactory.resolved)) {
                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
              } else {
                vnode.isAsyncPlaceholder = true;
              }
              return;
            }
            if (isTrue2(vnode.isStatic) && isTrue2(oldVnode.isStatic) && vnode.key === oldVnode.key && (isTrue2(vnode.isCloned) || isTrue2(vnode.isOnce))) {
              vnode.componentInstance = oldVnode.componentInstance;
              return;
            }
            var i2;
            var data = vnode.data;
            if (isDef2(data) && isDef2(i2 = data.hook) && isDef2(i2 = i2.prepatch)) {
              i2(oldVnode, vnode);
            }
            var oldCh = oldVnode.children;
            var ch = vnode.children;
            if (isDef2(data) && isPatchable(vnode)) {
              for (i2 = 0; i2 < cbs.update.length; ++i2)
                cbs.update[i2](oldVnode, vnode);
              if (isDef2(i2 = data.hook) && isDef2(i2 = i2.update))
                i2(oldVnode, vnode);
            }
            if (isUndef2(vnode.text)) {
              if (isDef2(oldCh) && isDef2(ch)) {
                if (oldCh !== ch)
                  updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
              } else if (isDef2(ch)) {
                {
                  checkDuplicateKeys(ch);
                }
                if (isDef2(oldVnode.text))
                  nodeOps3.setTextContent(elm, "");
                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
              } else if (isDef2(oldCh)) {
                removeVnodes(oldCh, 0, oldCh.length - 1);
              } else if (isDef2(oldVnode.text)) {
                nodeOps3.setTextContent(elm, "");
              }
            } else if (oldVnode.text !== vnode.text) {
              nodeOps3.setTextContent(elm, vnode.text);
            }
            if (isDef2(data)) {
              if (isDef2(i2 = data.hook) && isDef2(i2 = i2.postpatch))
                i2(oldVnode, vnode);
            }
          }
          function invokeInsertHook(vnode, queue3, initial) {
            if (isTrue2(initial) && isDef2(vnode.parent)) {
              vnode.parent.data.pendingInsert = queue3;
            } else {
              for (var i_6 = 0; i_6 < queue3.length; ++i_6) {
                queue3[i_6].data.hook.insert(queue3[i_6]);
              }
            }
          }
          var hydrationBailed = false;
          var isRenderedModule = makeMap2("attrs,class,staticClass,staticStyle,key");
          function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
            var i2;
            var tag = vnode.tag, data = vnode.data, children = vnode.children;
            inVPre = inVPre || data && data.pre;
            vnode.elm = elm;
            if (isTrue2(vnode.isComment) && isDef2(vnode.asyncFactory)) {
              vnode.isAsyncPlaceholder = true;
              return true;
            }
            {
              if (!assertNodeMatch(elm, vnode, inVPre)) {
                return false;
              }
            }
            if (isDef2(data)) {
              if (isDef2(i2 = data.hook) && isDef2(i2 = i2.init))
                i2(
                  vnode,
                  true
                  /* hydrating */
                );
              if (isDef2(i2 = vnode.componentInstance)) {
                initComponent(vnode, insertedVnodeQueue);
                return true;
              }
            }
            if (isDef2(tag)) {
              if (isDef2(children)) {
                if (!elm.hasChildNodes()) {
                  createChildren(vnode, children, insertedVnodeQueue);
                } else {
                  if (isDef2(i2 = data) && isDef2(i2 = i2.domProps) && isDef2(i2 = i2.innerHTML)) {
                    if (i2 !== elm.innerHTML) {
                      if (typeof console !== "undefined" && !hydrationBailed) {
                        hydrationBailed = true;
                        console.warn("Parent: ", elm);
                        console.warn("server innerHTML: ", i2);
                        console.warn("client innerHTML: ", elm.innerHTML);
                      }
                      return false;
                    }
                  } else {
                    var childrenMatch = true;
                    var childNode = elm.firstChild;
                    for (var i_7 = 0; i_7 < children.length; i_7++) {
                      if (!childNode || !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
                        childrenMatch = false;
                        break;
                      }
                      childNode = childNode.nextSibling;
                    }
                    if (!childrenMatch || childNode) {
                      if (typeof console !== "undefined" && !hydrationBailed) {
                        hydrationBailed = true;
                        console.warn("Parent: ", elm);
                        console.warn("Mismatching childNodes vs. VNodes: ", elm.childNodes, children);
                      }
                      return false;
                    }
                  }
                }
              }
              if (isDef2(data)) {
                var fullInvoke = false;
                for (var key in data) {
                  if (!isRenderedModule(key)) {
                    fullInvoke = true;
                    invokeCreateHooks(vnode, insertedVnodeQueue);
                    break;
                  }
                }
                if (!fullInvoke && data["class"]) {
                  traverse2(data["class"]);
                }
              }
            } else if (elm.data !== vnode.text) {
              elm.data = vnode.text;
            }
            return true;
          }
          function assertNodeMatch(node, vnode, inVPre) {
            if (isDef2(vnode.tag)) {
              return vnode.tag.indexOf("vue-component") === 0 || !isUnknownElement3(vnode, inVPre) && vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase());
            } else {
              return node.nodeType === (vnode.isComment ? 8 : 3);
            }
          }
          return function patch3(oldVnode, vnode, hydrating, removeOnly) {
            if (isUndef2(vnode)) {
              if (isDef2(oldVnode))
                invokeDestroyHook(oldVnode);
              return;
            }
            var isInitialPatch = false;
            var insertedVnodeQueue = [];
            if (isUndef2(oldVnode)) {
              isInitialPatch = true;
              createElm(vnode, insertedVnodeQueue);
            } else {
              var isRealElement = isDef2(oldVnode.nodeType);
              if (!isRealElement && sameVnode2(oldVnode, vnode)) {
                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
              } else {
                if (isRealElement) {
                  if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR2)) {
                    oldVnode.removeAttribute(SSR_ATTR2);
                    hydrating = true;
                  }
                  if (isTrue2(hydrating)) {
                    if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
                      invokeInsertHook(vnode, insertedVnodeQueue, true);
                      return oldVnode;
                    } else {
                      warn$2("The client-side rendered virtual DOM tree is not matching server-rendered content. This is likely caused by incorrect HTML markup, for example nesting block-level elements inside <p>, or missing <tbody>. Bailing hydration and performing full client-side render.");
                    }
                  }
                  oldVnode = emptyNodeAt(oldVnode);
                }
                var oldElm = oldVnode.elm;
                var parentElm = nodeOps3.parentNode(oldElm);
                createElm(
                  vnode,
                  insertedVnodeQueue,
                  // extremely rare edge case: do not insert if old element is in a
                  // leaving transition. Only happens when combining transition +
                  // keep-alive + HOCs. (#4590)
                  oldElm._leaveCb ? null : parentElm,
                  nodeOps3.nextSibling(oldElm)
                );
                if (isDef2(vnode.parent)) {
                  var ancestor = vnode.parent;
                  var patchable = isPatchable(vnode);
                  while (ancestor) {
                    for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
                      cbs.destroy[i_8](ancestor);
                    }
                    ancestor.elm = vnode.elm;
                    if (patchable) {
                      for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
                        cbs.create[i_9](emptyNode2, ancestor);
                      }
                      var insert_1 = ancestor.data.hook.insert;
                      if (insert_1.merged) {
                        var cloned = insert_1.fns.slice(1);
                        for (var i_10 = 0; i_10 < cloned.length; i_10++) {
                          cloned[i_10]();
                        }
                      }
                    } else {
                      registerRef2(ancestor);
                    }
                    ancestor = ancestor.parent;
                  }
                }
                if (isDef2(parentElm)) {
                  removeVnodes([oldVnode], 0, 0);
                } else if (isDef2(oldVnode.tag)) {
                  invokeDestroyHook(oldVnode);
                }
              }
            }
            invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
            return vnode.elm;
          };
        }
        var directives$1 = {
          create: updateDirectives2,
          update: updateDirectives2,
          destroy: function unbindDirectives2(vnode) {
            updateDirectives2(vnode, emptyNode2);
          }
        };
        function updateDirectives2(oldVnode, vnode) {
          if (oldVnode.data.directives || vnode.data.directives) {
            _update2(oldVnode, vnode);
          }
        }
        function _update2(oldVnode, vnode) {
          var isCreate = oldVnode === emptyNode2;
          var isDestroy = vnode === emptyNode2;
          var oldDirs = normalizeDirectives2(oldVnode.data.directives, oldVnode.context);
          var newDirs = normalizeDirectives2(vnode.data.directives, vnode.context);
          var dirsWithInsert = [];
          var dirsWithPostpatch = [];
          var key, oldDir, dir;
          for (key in newDirs) {
            oldDir = oldDirs[key];
            dir = newDirs[key];
            if (!oldDir) {
              callHook2(dir, "bind", vnode, oldVnode);
              if (dir.def && dir.def.inserted) {
                dirsWithInsert.push(dir);
              }
            } else {
              dir.oldValue = oldDir.value;
              dir.oldArg = oldDir.arg;
              callHook2(dir, "update", vnode, oldVnode);
              if (dir.def && dir.def.componentUpdated) {
                dirsWithPostpatch.push(dir);
              }
            }
          }
          if (dirsWithInsert.length) {
            var callInsert = function() {
              for (var i = 0; i < dirsWithInsert.length; i++) {
                callHook2(dirsWithInsert[i], "inserted", vnode, oldVnode);
              }
            };
            if (isCreate) {
              mergeVNodeHook2(vnode, "insert", callInsert);
            } else {
              callInsert();
            }
          }
          if (dirsWithPostpatch.length) {
            mergeVNodeHook2(vnode, "postpatch", function() {
              for (var i = 0; i < dirsWithPostpatch.length; i++) {
                callHook2(dirsWithPostpatch[i], "componentUpdated", vnode, oldVnode);
              }
            });
          }
          if (!isCreate) {
            for (key in oldDirs) {
              if (!newDirs[key]) {
                callHook2(oldDirs[key], "unbind", oldVnode, oldVnode, isDestroy);
              }
            }
          }
        }
        var emptyModifiers2 = /* @__PURE__ */ Object.create(null);
        function normalizeDirectives2(dirs, vm) {
          var res = /* @__PURE__ */ Object.create(null);
          if (!dirs) {
            return res;
          }
          var i, dir;
          for (i = 0; i < dirs.length; i++) {
            dir = dirs[i];
            if (!dir.modifiers) {
              dir.modifiers = emptyModifiers2;
            }
            res[getRawDirName2(dir)] = dir;
            if (vm._setupState && vm._setupState.__sfc) {
              var setupDef = dir.def || resolveAsset2(vm, "_setupState", "v-" + dir.name);
              if (typeof setupDef === "function") {
                dir.def = {
                  bind: setupDef,
                  update: setupDef
                };
              } else {
                dir.def = setupDef;
              }
            }
            dir.def = dir.def || resolveAsset2(vm.$options, "directives", dir.name, true);
          }
          return res;
        }
        function getRawDirName2(dir) {
          return dir.rawName || "".concat(dir.name, ".").concat(Object.keys(dir.modifiers || {}).join("."));
        }
        function callHook2(dir, hook, vnode, oldVnode, isDestroy) {
          var fn = dir.def && dir.def[hook];
          if (fn) {
            try {
              fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
            } catch (e) {
              handleError2(e, vnode.context, "directive ".concat(dir.name, " ").concat(hook, " hook"));
            }
          }
        }
        var baseModules2 = [ref2, directives$1];
        function updateAttrs2(oldVnode, vnode) {
          var opts2 = vnode.componentOptions;
          if (isDef2(opts2) && opts2.Ctor.options.inheritAttrs === false) {
            return;
          }
          if (isUndef2(oldVnode.data.attrs) && isUndef2(vnode.data.attrs)) {
            return;
          }
          var key, cur, old;
          var elm = vnode.elm;
          var oldAttrs = oldVnode.data.attrs || {};
          var attrs3 = vnode.data.attrs || {};
          if (isDef2(attrs3.__ob__) || isTrue2(attrs3._v_attr_proxy)) {
            attrs3 = vnode.data.attrs = extend2({}, attrs3);
          }
          for (key in attrs3) {
            cur = attrs3[key];
            old = oldAttrs[key];
            if (old !== cur) {
              setAttr2(elm, key, cur, vnode.data.pre);
            }
          }
          if ((isIE2 || isEdge2) && attrs3.value !== oldAttrs.value) {
            setAttr2(elm, "value", attrs3.value);
          }
          for (key in oldAttrs) {
            if (isUndef2(attrs3[key])) {
              if (isXlink2(key)) {
                elm.removeAttributeNS(xlinkNS2, getXlinkProp2(key));
              } else if (!isEnumeratedAttr2(key)) {
                elm.removeAttribute(key);
              }
            }
          }
        }
        function setAttr2(el, key, value, isInPre) {
          if (isInPre || el.tagName.indexOf("-") > -1) {
            baseSetAttr2(el, key, value);
          } else if (isBooleanAttr2(key)) {
            if (isFalsyAttrValue2(value)) {
              el.removeAttribute(key);
            } else {
              value = key === "allowfullscreen" && el.tagName === "EMBED" ? "true" : key;
              el.setAttribute(key, value);
            }
          } else if (isEnumeratedAttr2(key)) {
            el.setAttribute(key, convertEnumeratedValue2(key, value));
          } else if (isXlink2(key)) {
            if (isFalsyAttrValue2(value)) {
              el.removeAttributeNS(xlinkNS2, getXlinkProp2(key));
            } else {
              el.setAttributeNS(xlinkNS2, key, value);
            }
          } else {
            baseSetAttr2(el, key, value);
          }
        }
        function baseSetAttr2(el, key, value) {
          if (isFalsyAttrValue2(value)) {
            el.removeAttribute(key);
          } else {
            if (isIE2 && !isIE92 && el.tagName === "TEXTAREA" && key === "placeholder" && value !== "" && !el.__ieph) {
              var blocker_1 = function(e) {
                e.stopImmediatePropagation();
                el.removeEventListener("input", blocker_1);
              };
              el.addEventListener("input", blocker_1);
              el.__ieph = true;
            }
            el.setAttribute(key, value);
          }
        }
        var attrs2 = {
          create: updateAttrs2,
          update: updateAttrs2
        };
        function updateClass2(oldVnode, vnode) {
          var el = vnode.elm;
          var data = vnode.data;
          var oldData = oldVnode.data;
          if (isUndef2(data.staticClass) && isUndef2(data.class) && (isUndef2(oldData) || isUndef2(oldData.staticClass) && isUndef2(oldData.class))) {
            return;
          }
          var cls = genClassForVnode2(vnode);
          var transitionClass = el._transitionClasses;
          if (isDef2(transitionClass)) {
            cls = concat2(cls, stringifyClass2(transitionClass));
          }
          if (cls !== el._prevClass) {
            el.setAttribute("class", cls);
            el._prevClass = cls;
          }
        }
        var klass$1 = {
          create: updateClass2,
          update: updateClass2
        };
        var validDivisionCharRE = /[\w).+\-_$\]]/;
        function parseFilters(exp) {
          var inSingle = false;
          var inDouble = false;
          var inTemplateString = false;
          var inRegex = false;
          var curly = 0;
          var square = 0;
          var paren = 0;
          var lastFilterIndex = 0;
          var c, prev, i, expression, filters;
          for (i = 0; i < exp.length; i++) {
            prev = c;
            c = exp.charCodeAt(i);
            if (inSingle) {
              if (c === 39 && prev !== 92)
                inSingle = false;
            } else if (inDouble) {
              if (c === 34 && prev !== 92)
                inDouble = false;
            } else if (inTemplateString) {
              if (c === 96 && prev !== 92)
                inTemplateString = false;
            } else if (inRegex) {
              if (c === 47 && prev !== 92)
                inRegex = false;
            } else if (c === 124 && // pipe
            exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) {
              if (expression === void 0) {
                lastFilterIndex = i + 1;
                expression = exp.slice(0, i).trim();
              } else {
                pushFilter();
              }
            } else {
              switch (c) {
                case 34:
                  inDouble = true;
                  break;
                // "
                case 39:
                  inSingle = true;
                  break;
                // '
                case 96:
                  inTemplateString = true;
                  break;
                // `
                case 40:
                  paren++;
                  break;
                // (
                case 41:
                  paren--;
                  break;
                // )
                case 91:
                  square++;
                  break;
                // [
                case 93:
                  square--;
                  break;
                // ]
                case 123:
                  curly++;
                  break;
                // {
                case 125:
                  curly--;
                  break;
              }
              if (c === 47) {
                var j = i - 1;
                var p = void 0;
                for (; j >= 0; j--) {
                  p = exp.charAt(j);
                  if (p !== " ")
                    break;
                }
                if (!p || !validDivisionCharRE.test(p)) {
                  inRegex = true;
                }
              }
            }
          }
          if (expression === void 0) {
            expression = exp.slice(0, i).trim();
          } else if (lastFilterIndex !== 0) {
            pushFilter();
          }
          function pushFilter() {
            (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
            lastFilterIndex = i + 1;
          }
          if (filters) {
            for (i = 0; i < filters.length; i++) {
              expression = wrapFilter(expression, filters[i]);
            }
          }
          return expression;
        }
        function wrapFilter(exp, filter) {
          var i = filter.indexOf("(");
          if (i < 0) {
            return '_f("'.concat(filter, '")(').concat(exp, ")");
          } else {
            var name_1 = filter.slice(0, i);
            var args = filter.slice(i + 1);
            return '_f("'.concat(name_1, '")(').concat(exp).concat(args !== ")" ? "," + args : args);
          }
        }
        function baseWarn(msg, range2) {
          console.error("[Vue compiler]: ".concat(msg));
        }
        function pluckModuleFunction(modules3, key) {
          return modules3 ? modules3.map(function(m) {
            return m[key];
          }).filter(function(_) {
            return _;
          }) : [];
        }
        function addProp(el, name, value, range2, dynamic) {
          (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range2));
          el.plain = false;
        }
        function addAttr(el, name, value, range2, dynamic) {
          var attrs3 = dynamic ? el.dynamicAttrs || (el.dynamicAttrs = []) : el.attrs || (el.attrs = []);
          attrs3.push(rangeSetItem({ name, value, dynamic }, range2));
          el.plain = false;
        }
        function addRawAttr(el, name, value, range2) {
          el.attrsMap[name] = value;
          el.attrsList.push(rangeSetItem({ name, value }, range2));
        }
        function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range2) {
          (el.directives || (el.directives = [])).push(rangeSetItem({
            name,
            rawName,
            value,
            arg,
            isDynamicArg,
            modifiers
          }, range2));
          el.plain = false;
        }
        function prependModifierMarker(symbol, name, dynamic) {
          return dynamic ? "_p(".concat(name, ',"').concat(symbol, '")') : symbol + name;
        }
        function addHandler(el, name, value, modifiers, important, warn3, range2, dynamic) {
          modifiers = modifiers || emptyObject2;
          if (warn3 && modifiers.prevent && modifiers.passive) {
            warn3("passive and prevent can't be used together. Passive handler can't prevent default event.", range2);
          }
          if (modifiers.right) {
            if (dynamic) {
              name = "(".concat(name, ")==='click'?'contextmenu':(").concat(name, ")");
            } else if (name === "click") {
              name = "contextmenu";
              delete modifiers.right;
            }
          } else if (modifiers.middle) {
            if (dynamic) {
              name = "(".concat(name, ")==='click'?'mouseup':(").concat(name, ")");
            } else if (name === "click") {
              name = "mouseup";
            }
          }
          if (modifiers.capture) {
            delete modifiers.capture;
            name = prependModifierMarker("!", name, dynamic);
          }
          if (modifiers.once) {
            delete modifiers.once;
            name = prependModifierMarker("~", name, dynamic);
          }
          if (modifiers.passive) {
            delete modifiers.passive;
            name = prependModifierMarker("&", name, dynamic);
          }
          var events3;
          if (modifiers.native) {
            delete modifiers.native;
            events3 = el.nativeEvents || (el.nativeEvents = {});
          } else {
            events3 = el.events || (el.events = {});
          }
          var newHandler = rangeSetItem({ value: value.trim(), dynamic }, range2);
          if (modifiers !== emptyObject2) {
            newHandler.modifiers = modifiers;
          }
          var handlers = events3[name];
          if (Array.isArray(handlers)) {
            important ? handlers.unshift(newHandler) : handlers.push(newHandler);
          } else if (handlers) {
            events3[name] = important ? [newHandler, handlers] : [handlers, newHandler];
          } else {
            events3[name] = newHandler;
          }
          el.plain = false;
        }
        function getRawBindingAttr(el, name) {
          return el.rawAttrsMap[":" + name] || el.rawAttrsMap["v-bind:" + name] || el.rawAttrsMap[name];
        }
        function getBindingAttr(el, name, getStatic) {
          var dynamicValue = getAndRemoveAttr(el, ":" + name) || getAndRemoveAttr(el, "v-bind:" + name);
          if (dynamicValue != null) {
            return parseFilters(dynamicValue);
          } else if (getStatic !== false) {
            var staticValue = getAndRemoveAttr(el, name);
            if (staticValue != null) {
              return JSON.stringify(staticValue);
            }
          }
        }
        function getAndRemoveAttr(el, name, removeFromMap) {
          var val;
          if ((val = el.attrsMap[name]) != null) {
            var list = el.attrsList;
            for (var i = 0, l = list.length; i < l; i++) {
              if (list[i].name === name) {
                list.splice(i, 1);
                break;
              }
            }
          }
          if (removeFromMap) {
            delete el.attrsMap[name];
          }
          return val;
        }
        function getAndRemoveAttrByRegex(el, name) {
          var list = el.attrsList;
          for (var i = 0, l = list.length; i < l; i++) {
            var attr = list[i];
            if (name.test(attr.name)) {
              list.splice(i, 1);
              return attr;
            }
          }
        }
        function rangeSetItem(item, range2) {
          if (range2) {
            if (range2.start != null) {
              item.start = range2.start;
            }
            if (range2.end != null) {
              item.end = range2.end;
            }
          }
          return item;
        }
        function genComponentModel(el, value, modifiers) {
          var _a2 = modifiers || {}, number = _a2.number, trim = _a2.trim;
          var baseValueExpression = "$$v";
          var valueExpression = baseValueExpression;
          if (trim) {
            valueExpression = "(typeof ".concat(baseValueExpression, " === 'string'") + "? ".concat(baseValueExpression, ".trim()") + ": ".concat(baseValueExpression, ")");
          }
          if (number) {
            valueExpression = "_n(".concat(valueExpression, ")");
          }
          var assignment = genAssignmentCode(value, valueExpression);
          el.model = {
            value: "(".concat(value, ")"),
            expression: JSON.stringify(value),
            callback: "function (".concat(baseValueExpression, ") {").concat(assignment, "}")
          };
        }
        function genAssignmentCode(value, assignment) {
          var res = parseModel(value);
          if (res.key === null) {
            return "".concat(value, "=").concat(assignment);
          } else {
            return "$set(".concat(res.exp, ", ").concat(res.key, ", ").concat(assignment, ")");
          }
        }
        var len, str, chr, index3, expressionPos, expressionEndPos;
        function parseModel(val) {
          val = val.trim();
          len = val.length;
          if (val.indexOf("[") < 0 || val.lastIndexOf("]") < len - 1) {
            index3 = val.lastIndexOf(".");
            if (index3 > -1) {
              return {
                exp: val.slice(0, index3),
                key: '"' + val.slice(index3 + 1) + '"'
              };
            } else {
              return {
                exp: val,
                key: null
              };
            }
          }
          str = val;
          index3 = expressionPos = expressionEndPos = 0;
          while (!eof()) {
            chr = next();
            if (isStringStart(chr)) {
              parseString(chr);
            } else if (chr === 91) {
              parseBracket(chr);
            }
          }
          return {
            exp: val.slice(0, expressionPos),
            key: val.slice(expressionPos + 1, expressionEndPos)
          };
        }
        function next() {
          return str.charCodeAt(++index3);
        }
        function eof() {
          return index3 >= len;
        }
        function isStringStart(chr2) {
          return chr2 === 34 || chr2 === 39;
        }
        function parseBracket(chr2) {
          var inBracket = 1;
          expressionPos = index3;
          while (!eof()) {
            chr2 = next();
            if (isStringStart(chr2)) {
              parseString(chr2);
              continue;
            }
            if (chr2 === 91)
              inBracket++;
            if (chr2 === 93)
              inBracket--;
            if (inBracket === 0) {
              expressionEndPos = index3;
              break;
            }
          }
        }
        function parseString(chr2) {
          var stringQuote = chr2;
          while (!eof()) {
            chr2 = next();
            if (chr2 === stringQuote) {
              break;
            }
          }
        }
        var warn$1;
        var RANGE_TOKEN2 = "__r";
        var CHECKBOX_RADIO_TOKEN2 = "__c";
        function model$1(el, dir, _warn) {
          warn$1 = _warn;
          var value = dir.value;
          var modifiers = dir.modifiers;
          var tag = el.tag;
          var type = el.attrsMap.type;
          {
            if (tag === "input" && type === "file") {
              warn$1("<".concat(el.tag, ' v-model="').concat(value, '" type="file">:\n') + "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap["v-model"]);
            }
          }
          if (el.component) {
            genComponentModel(el, value, modifiers);
            return false;
          } else if (tag === "select") {
            genSelect(el, value, modifiers);
          } else if (tag === "input" && type === "checkbox") {
            genCheckboxModel(el, value, modifiers);
          } else if (tag === "input" && type === "radio") {
            genRadioModel(el, value, modifiers);
          } else if (tag === "input" || tag === "textarea") {
            genDefaultModel(el, value, modifiers);
          } else if (!config2.isReservedTag(tag)) {
            genComponentModel(el, value, modifiers);
            return false;
          } else {
            warn$1("<".concat(el.tag, ' v-model="').concat(value, '">: ') + "v-model is not supported on this element type. If you are working with contenteditable, it's recommended to wrap a library dedicated for that purpose inside a custom component.", el.rawAttrsMap["v-model"]);
          }
          return true;
        }
        function genCheckboxModel(el, value, modifiers) {
          var number = modifiers && modifiers.number;
          var valueBinding = getBindingAttr(el, "value") || "null";
          var trueValueBinding = getBindingAttr(el, "true-value") || "true";
          var falseValueBinding = getBindingAttr(el, "false-value") || "false";
          addProp(el, "checked", "Array.isArray(".concat(value, ")") + "?_i(".concat(value, ",").concat(valueBinding, ")>-1") + (trueValueBinding === "true" ? ":(".concat(value, ")") : ":_q(".concat(value, ",").concat(trueValueBinding, ")")));
          addHandler(el, "change", "var $$a=".concat(value, ",") + "$$el=$event.target," + "$$c=$$el.checked?(".concat(trueValueBinding, "):(").concat(falseValueBinding, ");") + "if(Array.isArray($$a)){" + "var $$v=".concat(number ? "_n(" + valueBinding + ")" : valueBinding, ",") + "$$i=_i($$a,$$v);" + "if($$el.checked){$$i<0&&(".concat(genAssignmentCode(value, "$$a.concat([$$v])"), ")}") + "else{$$i>-1&&(".concat(genAssignmentCode(value, "$$a.slice(0,$$i).concat($$a.slice($$i+1))"), ")}") + "}else{".concat(genAssignmentCode(value, "$$c"), "}"), null, true);
        }
        function genRadioModel(el, value, modifiers) {
          var number = modifiers && modifiers.number;
          var valueBinding = getBindingAttr(el, "value") || "null";
          valueBinding = number ? "_n(".concat(valueBinding, ")") : valueBinding;
          addProp(el, "checked", "_q(".concat(value, ",").concat(valueBinding, ")"));
          addHandler(el, "change", genAssignmentCode(value, valueBinding), null, true);
        }
        function genSelect(el, value, modifiers) {
          var number = modifiers && modifiers.number;
          var selectedVal = 'Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;' + "return ".concat(number ? "_n(val)" : "val", "})");
          var assignment = "$event.target.multiple ? $$selectedVal : $$selectedVal[0]";
          var code = "var $$selectedVal = ".concat(selectedVal, ";");
          code = "".concat(code, " ").concat(genAssignmentCode(value, assignment));
          addHandler(el, "change", code, null, true);
        }
        function genDefaultModel(el, value, modifiers) {
          var type = el.attrsMap.type;
          {
            var value_1 = el.attrsMap["v-bind:value"] || el.attrsMap[":value"];
            var typeBinding = el.attrsMap["v-bind:type"] || el.attrsMap[":type"];
            if (value_1 && !typeBinding) {
              var binding = el.attrsMap["v-bind:value"] ? "v-bind:value" : ":value";
              warn$1("".concat(binding, '="').concat(value_1, '" conflicts with v-model on the same element ') + "because the latter already expands to a value binding internally", el.rawAttrsMap[binding]);
            }
          }
          var _a2 = modifiers || {}, lazy = _a2.lazy, number = _a2.number, trim = _a2.trim;
          var needCompositionGuard = !lazy && type !== "range";
          var event = lazy ? "change" : type === "range" ? RANGE_TOKEN2 : "input";
          var valueExpression = "$event.target.value";
          if (trim) {
            valueExpression = "$event.target.value.trim()";
          }
          if (number) {
            valueExpression = "_n(".concat(valueExpression, ")");
          }
          var code = genAssignmentCode(value, valueExpression);
          if (needCompositionGuard) {
            code = "if($event.target.composing)return;".concat(code);
          }
          addProp(el, "value", "(".concat(value, ")"));
          addHandler(el, event, code, null, true);
          if (trim || number) {
            addHandler(el, "blur", "$forceUpdate()");
          }
        }
        function normalizeEvents2(on2) {
          if (isDef2(on2[RANGE_TOKEN2])) {
            var event_1 = isIE2 ? "change" : "input";
            on2[event_1] = [].concat(on2[RANGE_TOKEN2], on2[event_1] || []);
            delete on2[RANGE_TOKEN2];
          }
          if (isDef2(on2[CHECKBOX_RADIO_TOKEN2])) {
            on2.change = [].concat(on2[CHECKBOX_RADIO_TOKEN2], on2.change || []);
            delete on2[CHECKBOX_RADIO_TOKEN2];
          }
        }
        var target3;
        function createOnceHandler2(event, handler, capture) {
          var _target = target3;
          return function onceHandler() {
            var res = handler.apply(null, arguments);
            if (res !== null) {
              remove2(event, onceHandler, capture, _target);
            }
          };
        }
        var useMicrotaskFix2 = isUsingMicroTask2 && !(isFF2 && Number(isFF2[1]) <= 53);
        function add2(name, handler, capture, passive) {
          if (useMicrotaskFix2) {
            var attachedTimestamp_1 = currentFlushTimestamp2;
            var original_1 = handler;
            handler = original_1._wrapper = function(e) {
              if (
                // no bubbling, should always fire.
                // this is just a safety net in case event.timeStamp is unreliable in
                // certain weird environments...
                e.target === e.currentTarget || // event is fired after handler attachment
                e.timeStamp >= attachedTimestamp_1 || // bail for environments that have buggy event.timeStamp implementations
                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                // #9681 QtWebEngine event.timeStamp is negative value
                e.timeStamp <= 0 || // #9448 bail if event is fired in another document in a multi-page
                // electron/nw.js app, since event.timeStamp will be using a different
                // starting reference
                e.target.ownerDocument !== document
              ) {
                return original_1.apply(this, arguments);
              }
            };
          }
          target3.addEventListener(name, handler, supportsPassive2 ? { capture, passive } : capture);
        }
        function remove2(name, handler, capture, _target) {
          (_target || target3).removeEventListener(
            name,
            //@ts-expect-error
            handler._wrapper || handler,
            capture
          );
        }
        function updateDOMListeners2(oldVnode, vnode) {
          if (isUndef2(oldVnode.data.on) && isUndef2(vnode.data.on)) {
            return;
          }
          var on2 = vnode.data.on || {};
          var oldOn = oldVnode.data.on || {};
          target3 = vnode.elm || oldVnode.elm;
          normalizeEvents2(on2);
          updateListeners2(on2, oldOn, add2, remove2, createOnceHandler2, vnode.context);
          target3 = void 0;
        }
        var events2 = {
          create: updateDOMListeners2,
          update: updateDOMListeners2,
          // @ts-expect-error emptyNode has actually data
          destroy: function(vnode) {
            return updateDOMListeners2(vnode, emptyNode2);
          }
        };
        var svgContainer2;
        function updateDOMProps2(oldVnode, vnode) {
          if (isUndef2(oldVnode.data.domProps) && isUndef2(vnode.data.domProps)) {
            return;
          }
          var key, cur;
          var elm = vnode.elm;
          var oldProps = oldVnode.data.domProps || {};
          var props3 = vnode.data.domProps || {};
          if (isDef2(props3.__ob__) || isTrue2(props3._v_attr_proxy)) {
            props3 = vnode.data.domProps = extend2({}, props3);
          }
          for (key in oldProps) {
            if (!(key in props3)) {
              elm[key] = "";
            }
          }
          for (key in props3) {
            cur = props3[key];
            if (key === "textContent" || key === "innerHTML") {
              if (vnode.children)
                vnode.children.length = 0;
              if (cur === oldProps[key])
                continue;
              if (elm.childNodes.length === 1) {
                elm.removeChild(elm.childNodes[0]);
              }
            }
            if (key === "value" && elm.tagName !== "PROGRESS") {
              elm._value = cur;
              var strCur = isUndef2(cur) ? "" : String(cur);
              if (shouldUpdateValue2(elm, strCur)) {
                elm.value = strCur;
              }
            } else if (key === "innerHTML" && isSVG2(elm.tagName) && isUndef2(elm.innerHTML)) {
              svgContainer2 = svgContainer2 || document.createElement("div");
              svgContainer2.innerHTML = "<svg>".concat(cur, "</svg>");
              var svg = svgContainer2.firstChild;
              while (elm.firstChild) {
                elm.removeChild(elm.firstChild);
              }
              while (svg.firstChild) {
                elm.appendChild(svg.firstChild);
              }
            } else if (
              // skip the update if old and new VDOM state is the same.
              // `value` is handled separately because the DOM value may be temporarily
              // out of sync with VDOM state due to focus, composition and modifiers.
              // This  #4521 by skipping the unnecessary `checked` update.
              cur !== oldProps[key]
            ) {
              try {
                elm[key] = cur;
              } catch (e) {
              }
            }
          }
        }
        function shouldUpdateValue2(elm, checkVal) {
          return (
            //@ts-expect-error
            !elm.composing && (elm.tagName === "OPTION" || isNotInFocusAndDirty2(elm, checkVal) || isDirtyWithModifiers2(elm, checkVal))
          );
        }
        function isNotInFocusAndDirty2(elm, checkVal) {
          var notInFocus = true;
          try {
            notInFocus = document.activeElement !== elm;
          } catch (e) {
          }
          return notInFocus && elm.value !== checkVal;
        }
        function isDirtyWithModifiers2(elm, newVal) {
          var value = elm.value;
          var modifiers = elm._vModifiers;
          if (isDef2(modifiers)) {
            if (modifiers.number) {
              return toNumber2(value) !== toNumber2(newVal);
            }
            if (modifiers.trim) {
              return value.trim() !== newVal.trim();
            }
          }
          return value !== newVal;
        }
        var domProps2 = {
          create: updateDOMProps2,
          update: updateDOMProps2
        };
        var parseStyleText2 = cached2(function(cssText) {
          var res = {};
          var listDelimiter = /;(?![^(]*\))/g;
          var propertyDelimiter = /:(.+)/;
          cssText.split(listDelimiter).forEach(function(item) {
            if (item) {
              var tmp = item.split(propertyDelimiter);
              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
            }
          });
          return res;
        });
        function normalizeStyleData2(data) {
          var style3 = normalizeStyleBinding2(data.style);
          return data.staticStyle ? extend2(data.staticStyle, style3) : style3;
        }
        function normalizeStyleBinding2(bindingStyle) {
          if (Array.isArray(bindingStyle)) {
            return toObject2(bindingStyle);
          }
          if (typeof bindingStyle === "string") {
            return parseStyleText2(bindingStyle);
          }
          return bindingStyle;
        }
        function getStyle2(vnode, checkChild) {
          var res = {};
          var styleData;
          if (checkChild) {
            var childNode = vnode;
            while (childNode.componentInstance) {
              childNode = childNode.componentInstance._vnode;
              if (childNode && childNode.data && (styleData = normalizeStyleData2(childNode.data))) {
                extend2(res, styleData);
              }
            }
          }
          if (styleData = normalizeStyleData2(vnode.data)) {
            extend2(res, styleData);
          }
          var parentNode3 = vnode;
          while (parentNode3 = parentNode3.parent) {
            if (parentNode3.data && (styleData = normalizeStyleData2(parentNode3.data))) {
              extend2(res, styleData);
            }
          }
          return res;
        }
        var cssVarRE2 = /^--/;
        var importantRE2 = /\s*!important$/;
        var setProp2 = function(el, name, val) {
          if (cssVarRE2.test(name)) {
            el.style.setProperty(name, val);
          } else if (importantRE2.test(val)) {
            el.style.setProperty(hyphenate2(name), val.replace(importantRE2, ""), "important");
          } else {
            var normalizedName = normalize2(name);
            if (Array.isArray(val)) {
              for (var i = 0, len2 = val.length; i < len2; i++) {
                el.style[normalizedName] = val[i];
              }
            } else {
              el.style[normalizedName] = val;
            }
          }
        };
        var vendorNames2 = ["Webkit", "Moz", "ms"];
        var emptyStyle2;
        var normalize2 = cached2(function(prop) {
          emptyStyle2 = emptyStyle2 || document.createElement("div").style;
          prop = camelize2(prop);
          if (prop !== "filter" && prop in emptyStyle2) {
            return prop;
          }
          var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
          for (var i = 0; i < vendorNames2.length; i++) {
            var name_1 = vendorNames2[i] + capName;
            if (name_1 in emptyStyle2) {
              return name_1;
            }
          }
        });
        function updateStyle2(oldVnode, vnode) {
          var data = vnode.data;
          var oldData = oldVnode.data;
          if (isUndef2(data.staticStyle) && isUndef2(data.style) && isUndef2(oldData.staticStyle) && isUndef2(oldData.style)) {
            return;
          }
          var cur, name;
          var el = vnode.elm;
          var oldStaticStyle = oldData.staticStyle;
          var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
          var oldStyle = oldStaticStyle || oldStyleBinding;
          var style3 = normalizeStyleBinding2(vnode.data.style) || {};
          vnode.data.normalizedStyle = isDef2(style3.__ob__) ? extend2({}, style3) : style3;
          var newStyle = getStyle2(vnode, true);
          for (name in oldStyle) {
            if (isUndef2(newStyle[name])) {
              setProp2(el, name, "");
            }
          }
          for (name in newStyle) {
            cur = newStyle[name];
            setProp2(el, name, cur == null ? "" : cur);
          }
        }
        var style$1 = {
          create: updateStyle2,
          update: updateStyle2
        };
        var whitespaceRE$1 = /\s+/;
        function addClass2(el, cls) {
          if (!cls || !(cls = cls.trim())) {
            return;
          }
          if (el.classList) {
            if (cls.indexOf(" ") > -1) {
              cls.split(whitespaceRE$1).forEach(function(c) {
                return el.classList.add(c);
              });
            } else {
              el.classList.add(cls);
            }
          } else {
            var cur = " ".concat(el.getAttribute("class") || "", " ");
            if (cur.indexOf(" " + cls + " ") < 0) {
              el.setAttribute("class", (cur + cls).trim());
            }
          }
        }
        function removeClass2(el, cls) {
          if (!cls || !(cls = cls.trim())) {
            return;
          }
          if (el.classList) {
            if (cls.indexOf(" ") > -1) {
              cls.split(whitespaceRE$1).forEach(function(c) {
                return el.classList.remove(c);
              });
            } else {
              el.classList.remove(cls);
            }
            if (!el.classList.length) {
              el.removeAttribute("class");
            }
          } else {
            var cur = " ".concat(el.getAttribute("class") || "", " ");
            var tar = " " + cls + " ";
            while (cur.indexOf(tar) >= 0) {
              cur = cur.replace(tar, " ");
            }
            cur = cur.trim();
            if (cur) {
              el.setAttribute("class", cur);
            } else {
              el.removeAttribute("class");
            }
          }
        }
        function resolveTransition2(def3) {
          if (!def3) {
            return;
          }
          if (typeof def3 === "object") {
            var res = {};
            if (def3.css !== false) {
              extend2(res, autoCssTransition2(def3.name || "v"));
            }
            extend2(res, def3);
            return res;
          } else if (typeof def3 === "string") {
            return autoCssTransition2(def3);
          }
        }
        var autoCssTransition2 = cached2(function(name) {
          return {
            enterClass: "".concat(name, "-enter"),
            enterToClass: "".concat(name, "-enter-to"),
            enterActiveClass: "".concat(name, "-enter-active"),
            leaveClass: "".concat(name, "-leave"),
            leaveToClass: "".concat(name, "-leave-to"),
            leaveActiveClass: "".concat(name, "-leave-active")
          };
        });
        var hasTransition2 = inBrowser2 && !isIE92;
        var TRANSITION2 = "transition";
        var ANIMATION2 = "animation";
        var transitionProp2 = "transition";
        var transitionEndEvent2 = "transitionend";
        var animationProp2 = "animation";
        var animationEndEvent2 = "animationend";
        if (hasTransition2) {
          if (window.ontransitionend === void 0 && window.onwebkittransitionend !== void 0) {
            transitionProp2 = "WebkitTransition";
            transitionEndEvent2 = "webkitTransitionEnd";
          }
          if (window.onanimationend === void 0 && window.onwebkitanimationend !== void 0) {
            animationProp2 = "WebkitAnimation";
            animationEndEvent2 = "webkitAnimationEnd";
          }
        }
        var raf2 = inBrowser2 ? window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : setTimeout : (
          /* istanbul ignore next */
          function(fn) {
            return fn();
          }
        );
        function nextFrame2(fn) {
          raf2(function() {
            raf2(fn);
          });
        }
        function addTransitionClass2(el, cls) {
          var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
          if (transitionClasses.indexOf(cls) < 0) {
            transitionClasses.push(cls);
            addClass2(el, cls);
          }
        }
        function removeTransitionClass2(el, cls) {
          if (el._transitionClasses) {
            remove$22(el._transitionClasses, cls);
          }
          removeClass2(el, cls);
        }
        function whenTransitionEnds2(el, expectedType, cb) {
          var _a2 = getTransitionInfo2(el, expectedType), type = _a2.type, timeout = _a2.timeout, propCount = _a2.propCount;
          if (!type)
            return cb();
          var event = type === TRANSITION2 ? transitionEndEvent2 : animationEndEvent2;
          var ended = 0;
          var end = function() {
            el.removeEventListener(event, onEnd);
            cb();
          };
          var onEnd = function(e) {
            if (e.target === el) {
              if (++ended >= propCount) {
                end();
              }
            }
          };
          setTimeout(function() {
            if (ended < propCount) {
              end();
            }
          }, timeout + 1);
          el.addEventListener(event, onEnd);
        }
        var transformRE2 = /\b(transform|all)(,|$)/;
        function getTransitionInfo2(el, expectedType) {
          var styles = window.getComputedStyle(el);
          var transitionDelays = (styles[transitionProp2 + "Delay"] || "").split(", ");
          var transitionDurations = (styles[transitionProp2 + "Duration"] || "").split(", ");
          var transitionTimeout = getTimeout2(transitionDelays, transitionDurations);
          var animationDelays = (styles[animationProp2 + "Delay"] || "").split(", ");
          var animationDurations = (styles[animationProp2 + "Duration"] || "").split(", ");
          var animationTimeout = getTimeout2(animationDelays, animationDurations);
          var type;
          var timeout = 0;
          var propCount = 0;
          if (expectedType === TRANSITION2) {
            if (transitionTimeout > 0) {
              type = TRANSITION2;
              timeout = transitionTimeout;
              propCount = transitionDurations.length;
            }
          } else if (expectedType === ANIMATION2) {
            if (animationTimeout > 0) {
              type = ANIMATION2;
              timeout = animationTimeout;
              propCount = animationDurations.length;
            }
          } else {
            timeout = Math.max(transitionTimeout, animationTimeout);
            type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION2 : ANIMATION2 : null;
            propCount = type ? type === TRANSITION2 ? transitionDurations.length : animationDurations.length : 0;
          }
          var hasTransform = type === TRANSITION2 && transformRE2.test(styles[transitionProp2 + "Property"]);
          return {
            type,
            timeout,
            propCount,
            hasTransform
          };
        }
        function getTimeout2(delays, durations) {
          while (delays.length < durations.length) {
            delays = delays.concat(delays);
          }
          return Math.max.apply(null, durations.map(function(d, i) {
            return toMs2(d) + toMs2(delays[i]);
          }));
        }
        function toMs2(s) {
          return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
        }
        function enter2(vnode, toggleDisplay) {
          var el = vnode.elm;
          if (isDef2(el._leaveCb)) {
            el._leaveCb.cancelled = true;
            el._leaveCb();
          }
          var data = resolveTransition2(vnode.data.transition);
          if (isUndef2(data)) {
            return;
          }
          if (isDef2(el._enterCb) || el.nodeType !== 1) {
            return;
          }
          var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter3 = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
          var context = activeInstance2;
          var transitionNode = activeInstance2.$vnode;
          while (transitionNode && transitionNode.parent) {
            context = transitionNode.context;
            transitionNode = transitionNode.parent;
          }
          var isAppear = !context._isMounted || !vnode.isRootInsert;
          if (isAppear && !appear && appear !== "") {
            return;
          }
          var startClass = isAppear && appearClass ? appearClass : enterClass;
          var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
          var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
          var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
          var enterHook = isAppear ? isFunction2(appear) ? appear : enter3 : enter3;
          var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
          var enterCancelledHook = isAppear ? appearCancelled || enterCancelled : enterCancelled;
          var explicitEnterDuration = toNumber2(isObject3(duration) ? duration.enter : duration);
          if (explicitEnterDuration != null) {
            checkDuration(explicitEnterDuration, "enter", vnode);
          }
          var expectsCSS = css !== false && !isIE92;
          var userWantsControl = getHookArgumentsLength2(enterHook);
          var cb = el._enterCb = once2(function() {
            if (expectsCSS) {
              removeTransitionClass2(el, toClass);
              removeTransitionClass2(el, activeClass);
            }
            if (cb.cancelled) {
              if (expectsCSS) {
                removeTransitionClass2(el, startClass);
              }
              enterCancelledHook && enterCancelledHook(el);
            } else {
              afterEnterHook && afterEnterHook(el);
            }
            el._enterCb = null;
          });
          if (!vnode.data.show) {
            mergeVNodeHook2(vnode, "insert", function() {
              var parent = el.parentNode;
              var pendingNode = parent && parent._pending && parent._pending[vnode.key];
              if (pendingNode && pendingNode.tag === vnode.tag && pendingNode.elm._leaveCb) {
                pendingNode.elm._leaveCb();
              }
              enterHook && enterHook(el, cb);
            });
          }
          beforeEnterHook && beforeEnterHook(el);
          if (expectsCSS) {
            addTransitionClass2(el, startClass);
            addTransitionClass2(el, activeClass);
            nextFrame2(function() {
              removeTransitionClass2(el, startClass);
              if (!cb.cancelled) {
                addTransitionClass2(el, toClass);
                if (!userWantsControl) {
                  if (isValidDuration2(explicitEnterDuration)) {
                    setTimeout(cb, explicitEnterDuration);
                  } else {
                    whenTransitionEnds2(el, type, cb);
                  }
                }
              }
            });
          }
          if (vnode.data.show) {
            toggleDisplay && toggleDisplay();
            enterHook && enterHook(el, cb);
          }
          if (!expectsCSS && !userWantsControl) {
            cb();
          }
        }
        function leave2(vnode, rm) {
          var el = vnode.elm;
          if (isDef2(el._enterCb)) {
            el._enterCb.cancelled = true;
            el._enterCb();
          }
          var data = resolveTransition2(vnode.data.transition);
          if (isUndef2(data) || el.nodeType !== 1) {
            return rm();
          }
          if (isDef2(el._leaveCb)) {
            return;
          }
          var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave3 = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
          var expectsCSS = css !== false && !isIE92;
          var userWantsControl = getHookArgumentsLength2(leave3);
          var explicitLeaveDuration = toNumber2(isObject3(duration) ? duration.leave : duration);
          if (isDef2(explicitLeaveDuration)) {
            checkDuration(explicitLeaveDuration, "leave", vnode);
          }
          var cb = el._leaveCb = once2(function() {
            if (el.parentNode && el.parentNode._pending) {
              el.parentNode._pending[vnode.key] = null;
            }
            if (expectsCSS) {
              removeTransitionClass2(el, leaveToClass);
              removeTransitionClass2(el, leaveActiveClass);
            }
            if (cb.cancelled) {
              if (expectsCSS) {
                removeTransitionClass2(el, leaveClass);
              }
              leaveCancelled && leaveCancelled(el);
            } else {
              rm();
              afterLeave && afterLeave(el);
            }
            el._leaveCb = null;
          });
          if (delayLeave) {
            delayLeave(performLeave);
          } else {
            performLeave();
          }
          function performLeave() {
            if (cb.cancelled) {
              return;
            }
            if (!vnode.data.show && el.parentNode) {
              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
            }
            beforeLeave && beforeLeave(el);
            if (expectsCSS) {
              addTransitionClass2(el, leaveClass);
              addTransitionClass2(el, leaveActiveClass);
              nextFrame2(function() {
                removeTransitionClass2(el, leaveClass);
                if (!cb.cancelled) {
                  addTransitionClass2(el, leaveToClass);
                  if (!userWantsControl) {
                    if (isValidDuration2(explicitLeaveDuration)) {
                      setTimeout(cb, explicitLeaveDuration);
                    } else {
                      whenTransitionEnds2(el, type, cb);
                    }
                  }
                }
              });
            }
            leave3 && leave3(el, cb);
            if (!expectsCSS && !userWantsControl) {
              cb();
            }
          }
        }
        function checkDuration(val, name, vnode) {
          if (typeof val !== "number") {
            warn$2("<transition> explicit ".concat(name, " duration is not a valid number - ") + "got ".concat(JSON.stringify(val), "."), vnode.context);
          } else if (isNaN(val)) {
            warn$2("<transition> explicit ".concat(name, " duration is NaN - ") + "the duration expression might be incorrect.", vnode.context);
          }
        }
        function isValidDuration2(val) {
          return typeof val === "number" && !isNaN(val);
        }
        function getHookArgumentsLength2(fn) {
          if (isUndef2(fn)) {
            return false;
          }
          var invokerFns = fn.fns;
          if (isDef2(invokerFns)) {
            return getHookArgumentsLength2(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
          } else {
            return (fn._length || fn.length) > 1;
          }
        }
        function _enter2(_, vnode) {
          if (vnode.data.show !== true) {
            enter2(vnode);
          }
        }
        var transition2 = inBrowser2 ? {
          create: _enter2,
          activate: _enter2,
          remove: function(vnode, rm) {
            if (vnode.data.show !== true) {
              leave2(vnode, rm);
            } else {
              rm();
            }
          }
        } : {};
        var platformModules2 = [attrs2, klass$1, events2, domProps2, style$1, transition2];
        var modules$1 = platformModules2.concat(baseModules2);
        var patch2 = createPatchFunction2({ nodeOps: nodeOps2, modules: modules$1 });
        if (isIE92) {
          document.addEventListener("selectionchange", function() {
            var el = document.activeElement;
            if (el && el.vmodel) {
              trigger2(el, "input");
            }
          });
        }
        var directive2 = {
          inserted: function(el, binding, vnode, oldVnode) {
            if (vnode.tag === "select") {
              if (oldVnode.elm && !oldVnode.elm._vOptions) {
                mergeVNodeHook2(vnode, "postpatch", function() {
                  directive2.componentUpdated(el, binding, vnode);
                });
              } else {
                setSelected2(el, binding, vnode.context);
              }
              el._vOptions = [].map.call(el.options, getValue2);
            } else if (vnode.tag === "textarea" || isTextInputType2(el.type)) {
              el._vModifiers = binding.modifiers;
              if (!binding.modifiers.lazy) {
                el.addEventListener("compositionstart", onCompositionStart2);
                el.addEventListener("compositionend", onCompositionEnd2);
                el.addEventListener("change", onCompositionEnd2);
                if (isIE92) {
                  el.vmodel = true;
                }
              }
            }
          },
          componentUpdated: function(el, binding, vnode) {
            if (vnode.tag === "select") {
              setSelected2(el, binding, vnode.context);
              var prevOptions_1 = el._vOptions;
              var curOptions_1 = el._vOptions = [].map.call(el.options, getValue2);
              if (curOptions_1.some(function(o, i) {
                return !looseEqual2(o, prevOptions_1[i]);
              })) {
                var needReset = el.multiple ? binding.value.some(function(v) {
                  return hasNoMatchingOption2(v, curOptions_1);
                }) : binding.value !== binding.oldValue && hasNoMatchingOption2(binding.value, curOptions_1);
                if (needReset) {
                  trigger2(el, "change");
                }
              }
            }
          }
        };
        function setSelected2(el, binding, vm) {
          actuallySetSelected2(el, binding, vm);
          if (isIE2 || isEdge2) {
            setTimeout(function() {
              actuallySetSelected2(el, binding, vm);
            }, 0);
          }
        }
        function actuallySetSelected2(el, binding, vm) {
          var value = binding.value;
          var isMultiple = el.multiple;
          if (isMultiple && !Array.isArray(value)) {
            warn$2('<select multiple v-model="'.concat(binding.expression, '"> ') + "expects an Array value for its binding, but got ".concat(Object.prototype.toString.call(value).slice(8, -1)), vm);
            return;
          }
          var selected, option;
          for (var i = 0, l = el.options.length; i < l; i++) {
            option = el.options[i];
            if (isMultiple) {
              selected = looseIndexOf2(value, getValue2(option)) > -1;
              if (option.selected !== selected) {
                option.selected = selected;
              }
            } else {
              if (looseEqual2(getValue2(option), value)) {
                if (el.selectedIndex !== i) {
                  el.selectedIndex = i;
                }
                return;
              }
            }
          }
          if (!isMultiple) {
            el.selectedIndex = -1;
          }
        }
        function hasNoMatchingOption2(value, options) {
          return options.every(function(o) {
            return !looseEqual2(o, value);
          });
        }
        function getValue2(option) {
          return "_value" in option ? option._value : option.value;
        }
        function onCompositionStart2(e) {
          e.target.composing = true;
        }
        function onCompositionEnd2(e) {
          if (!e.target.composing)
            return;
          e.target.composing = false;
          trigger2(e.target, "input");
        }
        function trigger2(el, type) {
          var e = document.createEvent("HTMLEvents");
          e.initEvent(type, true, true);
          el.dispatchEvent(e);
        }
        function locateNode2(vnode) {
          return vnode.componentInstance && (!vnode.data || !vnode.data.transition) ? locateNode2(vnode.componentInstance._vnode) : vnode;
        }
        var show2 = {
          bind: function(el, _a2, vnode) {
            var value = _a2.value;
            vnode = locateNode2(vnode);
            var transition3 = vnode.data && vnode.data.transition;
            var originalDisplay = el.__vOriginalDisplay = el.style.display === "none" ? "" : el.style.display;
            if (value && transition3) {
              vnode.data.show = true;
              enter2(vnode, function() {
                el.style.display = originalDisplay;
              });
            } else {
              el.style.display = value ? originalDisplay : "none";
            }
          },
          update: function(el, _a2, vnode) {
            var value = _a2.value, oldValue = _a2.oldValue;
            if (!value === !oldValue)
              return;
            vnode = locateNode2(vnode);
            var transition3 = vnode.data && vnode.data.transition;
            if (transition3) {
              vnode.data.show = true;
              if (value) {
                enter2(vnode, function() {
                  el.style.display = el.__vOriginalDisplay;
                });
              } else {
                leave2(vnode, function() {
                  el.style.display = "none";
                });
              }
            } else {
              el.style.display = value ? el.__vOriginalDisplay : "none";
            }
          },
          unbind: function(el, binding, vnode, oldVnode, isDestroy) {
            if (!isDestroy) {
              el.style.display = el.__vOriginalDisplay;
            }
          }
        };
        var platformDirectives2 = {
          model: directive2,
          show: show2
        };
        var transitionProps2 = {
          name: String,
          appear: Boolean,
          css: Boolean,
          mode: String,
          type: String,
          enterClass: String,
          leaveClass: String,
          enterToClass: String,
          leaveToClass: String,
          enterActiveClass: String,
          leaveActiveClass: String,
          appearClass: String,
          appearActiveClass: String,
          appearToClass: String,
          duration: [Number, String, Object]
        };
        function getRealChild2(vnode) {
          var compOptions = vnode && vnode.componentOptions;
          if (compOptions && compOptions.Ctor.options.abstract) {
            return getRealChild2(getFirstComponentChild2(compOptions.children));
          } else {
            return vnode;
          }
        }
        function extractTransitionData2(comp) {
          var data = {};
          var options = comp.$options;
          for (var key in options.propsData) {
            data[key] = comp[key];
          }
          var listeners = options._parentListeners;
          for (var key in listeners) {
            data[camelize2(key)] = listeners[key];
          }
          return data;
        }
        function placeholder2(h2, rawChild) {
          if (/\d-keep-alive$/.test(rawChild.tag)) {
            return h2("keep-alive", {
              props: rawChild.componentOptions.propsData
            });
          }
        }
        function hasParentTransition2(vnode) {
          while (vnode = vnode.parent) {
            if (vnode.data.transition) {
              return true;
            }
          }
        }
        function isSameChild2(child, oldChild) {
          return oldChild.key === child.key && oldChild.tag === child.tag;
        }
        var isNotTextNode2 = function(c) {
          return c.tag || isAsyncPlaceholder2(c);
        };
        var isVShowDirective2 = function(d) {
          return d.name === "show";
        };
        var Transition2 = {
          name: "transition",
          props: transitionProps2,
          abstract: true,
          render: function(h2) {
            var _this = this;
            var children = this.$slots.default;
            if (!children) {
              return;
            }
            children = children.filter(isNotTextNode2);
            if (!children.length) {
              return;
            }
            if (children.length > 1) {
              warn$2("<transition> can only be used on a single element. Use <transition-group> for lists.", this.$parent);
            }
            var mode = this.mode;
            if (mode && mode !== "in-out" && mode !== "out-in") {
              warn$2("invalid <transition> mode: " + mode, this.$parent);
            }
            var rawChild = children[0];
            if (hasParentTransition2(this.$vnode)) {
              return rawChild;
            }
            var child = getRealChild2(rawChild);
            if (!child) {
              return rawChild;
            }
            if (this._leaving) {
              return placeholder2(h2, rawChild);
            }
            var id = "__transition-".concat(this._uid, "-");
            child.key = child.key == null ? child.isComment ? id + "comment" : id + child.tag : isPrimitive2(child.key) ? String(child.key).indexOf(id) === 0 ? child.key : id + child.key : child.key;
            var data = (child.data || (child.data = {})).transition = extractTransitionData2(this);
            var oldRawChild = this._vnode;
            var oldChild = getRealChild2(oldRawChild);
            if (child.data.directives && child.data.directives.some(isVShowDirective2)) {
              child.data.show = true;
            }
            if (oldChild && oldChild.data && !isSameChild2(child, oldChild) && !isAsyncPlaceholder2(oldChild) && // #6687 component root is a comment node
            !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)) {
              var oldData = oldChild.data.transition = extend2({}, data);
              if (mode === "out-in") {
                this._leaving = true;
                mergeVNodeHook2(oldData, "afterLeave", function() {
                  _this._leaving = false;
                  _this.$forceUpdate();
                });
                return placeholder2(h2, rawChild);
              } else if (mode === "in-out") {
                if (isAsyncPlaceholder2(child)) {
                  return oldRawChild;
                }
                var delayedLeave_1;
                var performLeave = function() {
                  delayedLeave_1();
                };
                mergeVNodeHook2(data, "afterEnter", performLeave);
                mergeVNodeHook2(data, "enterCancelled", performLeave);
                mergeVNodeHook2(oldData, "delayLeave", function(leave3) {
                  delayedLeave_1 = leave3;
                });
              }
            }
            return rawChild;
          }
        };
        var props2 = extend2({
          tag: String,
          moveClass: String
        }, transitionProps2);
        delete props2.mode;
        var TransitionGroup2 = {
          props: props2,
          beforeMount: function() {
            var _this = this;
            var update3 = this._update;
            this._update = function(vnode, hydrating) {
              var restoreActiveInstance = setActiveInstance2(_this);
              _this.__patch__(
                _this._vnode,
                _this.kept,
                false,
                // hydrating
                true
                // removeOnly (!important, avoids unnecessary moves)
              );
              _this._vnode = _this.kept;
              restoreActiveInstance();
              update3.call(_this, vnode, hydrating);
            };
          },
          render: function(h2) {
            var tag = this.tag || this.$vnode.data.tag || "span";
            var map = /* @__PURE__ */ Object.create(null);
            var prevChildren = this.prevChildren = this.children;
            var rawChildren = this.$slots.default || [];
            var children = this.children = [];
            var transitionData = extractTransitionData2(this);
            for (var i = 0; i < rawChildren.length; i++) {
              var c = rawChildren[i];
              if (c.tag) {
                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
                  children.push(c);
                  map[c.key] = c;
                  (c.data || (c.data = {})).transition = transitionData;
                } else {
                  var opts2 = c.componentOptions;
                  var name_1 = opts2 ? getComponentName2(opts2.Ctor.options) || opts2.tag || "" : c.tag;
                  warn$2("<transition-group> children must be keyed: <".concat(name_1, ">"));
                }
              }
            }
            if (prevChildren) {
              var kept = [];
              var removed = [];
              for (var i = 0; i < prevChildren.length; i++) {
                var c = prevChildren[i];
                c.data.transition = transitionData;
                c.data.pos = c.elm.getBoundingClientRect();
                if (map[c.key]) {
                  kept.push(c);
                } else {
                  removed.push(c);
                }
              }
              this.kept = h2(tag, null, kept);
              this.removed = removed;
            }
            return h2(tag, null, children);
          },
          updated: function() {
            var children = this.prevChildren;
            var moveClass = this.moveClass || (this.name || "v") + "-move";
            if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
              return;
            }
            children.forEach(callPendingCbs2);
            children.forEach(recordPosition2);
            children.forEach(applyTranslation2);
            this._reflow = document.body.offsetHeight;
            children.forEach(function(c) {
              if (c.data.moved) {
                var el_1 = c.elm;
                var s = el_1.style;
                addTransitionClass2(el_1, moveClass);
                s.transform = s.WebkitTransform = s.transitionDuration = "";
                el_1.addEventListener(transitionEndEvent2, el_1._moveCb = function cb(e) {
                  if (e && e.target !== el_1) {
                    return;
                  }
                  if (!e || /transform$/.test(e.propertyName)) {
                    el_1.removeEventListener(transitionEndEvent2, cb);
                    el_1._moveCb = null;
                    removeTransitionClass2(el_1, moveClass);
                  }
                });
              }
            });
          },
          methods: {
            hasMove: function(el, moveClass) {
              if (!hasTransition2) {
                return false;
              }
              if (this._hasMove) {
                return this._hasMove;
              }
              var clone = el.cloneNode();
              if (el._transitionClasses) {
                el._transitionClasses.forEach(function(cls) {
                  removeClass2(clone, cls);
                });
              }
              addClass2(clone, moveClass);
              clone.style.display = "none";
              this.$el.appendChild(clone);
              var info = getTransitionInfo2(clone);
              this.$el.removeChild(clone);
              return this._hasMove = info.hasTransform;
            }
          }
        };
        function callPendingCbs2(c) {
          if (c.elm._moveCb) {
            c.elm._moveCb();
          }
          if (c.elm._enterCb) {
            c.elm._enterCb();
          }
        }
        function recordPosition2(c) {
          c.data.newPos = c.elm.getBoundingClientRect();
        }
        function applyTranslation2(c) {
          var oldPos = c.data.pos;
          var newPos = c.data.newPos;
          var dx = oldPos.left - newPos.left;
          var dy = oldPos.top - newPos.top;
          if (dx || dy) {
            c.data.moved = true;
            var s = c.elm.style;
            s.transform = s.WebkitTransform = "translate(".concat(dx, "px,").concat(dy, "px)");
            s.transitionDuration = "0s";
          }
        }
        var platformComponents2 = {
          Transition: Transition2,
          TransitionGroup: TransitionGroup2
        };
        Vue4.config.mustUseProp = mustUseProp2;
        Vue4.config.isReservedTag = isReservedTag2;
        Vue4.config.isReservedAttr = isReservedAttr2;
        Vue4.config.getTagNamespace = getTagNamespace2;
        Vue4.config.isUnknownElement = isUnknownElement2;
        extend2(Vue4.options.directives, platformDirectives2);
        extend2(Vue4.options.components, platformComponents2);
        Vue4.prototype.__patch__ = inBrowser2 ? patch2 : noop2;
        Vue4.prototype.$mount = function(el, hydrating) {
          el = el && inBrowser2 ? query2(el) : void 0;
          return mountComponent2(this, el, hydrating);
        };
        if (inBrowser2) {
          setTimeout(function() {
            if (config2.devtools) {
              if (devtools2) {
                devtools2.emit("init", Vue4);
              } else {
                console[console.info ? "info" : "log"]("Download the Vue Devtools extension for a better development experience:\nhttps://github.com/vuejs/vue-devtools");
              }
            }
            if (config2.productionTip !== false && typeof console !== "undefined") {
              console[console.info ? "info" : "log"]("You are running Vue in development mode.\nMake sure to turn on production mode when deploying for production.\nSee more tips at https://vuejs.org/guide/deployment.html");
            }
          }, 0);
        }
        var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
        var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
        var buildRegex = cached2(function(delimiters2) {
          var open = delimiters2[0].replace(regexEscapeRE, "\\$&");
          var close = delimiters2[1].replace(regexEscapeRE, "\\$&");
          return new RegExp(open + "((?:.|\\n)+?)" + close, "g");
        });
        function parseText(text2, delimiters2) {
          var tagRE = delimiters2 ? buildRegex(delimiters2) : defaultTagRE;
          if (!tagRE.test(text2)) {
            return;
          }
          var tokens = [];
          var rawTokens = [];
          var lastIndex = tagRE.lastIndex = 0;
          var match, index4, tokenValue;
          while (match = tagRE.exec(text2)) {
            index4 = match.index;
            if (index4 > lastIndex) {
              rawTokens.push(tokenValue = text2.slice(lastIndex, index4));
              tokens.push(JSON.stringify(tokenValue));
            }
            var exp = parseFilters(match[1].trim());
            tokens.push("_s(".concat(exp, ")"));
            rawTokens.push({ "@binding": exp });
            lastIndex = index4 + match[0].length;
          }
          if (lastIndex < text2.length) {
            rawTokens.push(tokenValue = text2.slice(lastIndex));
            tokens.push(JSON.stringify(tokenValue));
          }
          return {
            expression: tokens.join("+"),
            tokens: rawTokens
          };
        }
        function transformNode$1(el, options) {
          var warn3 = options.warn || baseWarn;
          var staticClass = getAndRemoveAttr(el, "class");
          if (staticClass) {
            var res = parseText(staticClass, options.delimiters);
            if (res) {
              warn3('class="'.concat(staticClass, '": ') + 'Interpolation inside attributes has been removed. Use v-bind or the colon shorthand instead. For example, instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap["class"]);
            }
          }
          if (staticClass) {
            el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, " ").trim());
          }
          var classBinding = getBindingAttr(
            el,
            "class",
            false
            /* getStatic */
          );
          if (classBinding) {
            el.classBinding = classBinding;
          }
        }
        function genData$2(el) {
          var data = "";
          if (el.staticClass) {
            data += "staticClass:".concat(el.staticClass, ",");
          }
          if (el.classBinding) {
            data += "class:".concat(el.classBinding, ",");
          }
          return data;
        }
        var klass2 = {
          staticKeys: ["staticClass"],
          transformNode: transformNode$1,
          genData: genData$2
        };
        function transformNode(el, options) {
          var warn3 = options.warn || baseWarn;
          var staticStyle = getAndRemoveAttr(el, "style");
          if (staticStyle) {
            {
              var res = parseText(staticStyle, options.delimiters);
              if (res) {
                warn3('style="'.concat(staticStyle, '": ') + 'Interpolation inside attributes has been removed. Use v-bind or the colon shorthand instead. For example, instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap["style"]);
              }
            }
            el.staticStyle = JSON.stringify(parseStyleText2(staticStyle));
          }
          var styleBinding = getBindingAttr(
            el,
            "style",
            false
            /* getStatic */
          );
          if (styleBinding) {
            el.styleBinding = styleBinding;
          }
        }
        function genData$1(el) {
          var data = "";
          if (el.staticStyle) {
            data += "staticStyle:".concat(el.staticStyle, ",");
          }
          if (el.styleBinding) {
            data += "style:(".concat(el.styleBinding, "),");
          }
          return data;
        }
        var style2 = {
          staticKeys: ["staticStyle"],
          transformNode,
          genData: genData$1
        };
        var decoder;
        var he = {
          decode: function(html2) {
            decoder = decoder || document.createElement("div");
            decoder.innerHTML = html2;
            return decoder.textContent;
          }
        };
        var isUnaryTag = makeMap2("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr");
        var canBeLeftOpenTag = makeMap2("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source");
        var isNonPhrasingTag = makeMap2("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track");
        var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
        var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
        var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z".concat(unicodeRegExp2.source, "]*");
        var qnameCapture = "((?:".concat(ncname, "\\:)?").concat(ncname, ")");
        var startTagOpen = new RegExp("^<".concat(qnameCapture));
        var startTagClose = /^\s*(\/?)>/;
        var endTag = new RegExp("^<\\/".concat(qnameCapture, "[^>]*>"));
        var doctype = /^<!DOCTYPE [^>]+>/i;
        var comment = /^<!\--/;
        var conditionalComment = /^<!\[/;
        var isPlainTextElement = makeMap2("script,style,textarea", true);
        var reCache = {};
        var decodingMap = {
          "&lt;": "<",
          "&gt;": ">",
          "&quot;": '"',
          "&amp;": "&",
          "&#10;": "\n",
          "&#9;": "	",
          "&#39;": "'"
        };
        var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
        var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
        var isIgnoreNewlineTag = makeMap2("pre,textarea", true);
        var shouldIgnoreFirstNewline = function(tag, html2) {
          return tag && isIgnoreNewlineTag(tag) && html2[0] === "\n";
        };
        function decodeAttr(value, shouldDecodeNewlines2) {
          var re = shouldDecodeNewlines2 ? encodedAttrWithNewLines : encodedAttr;
          return value.replace(re, function(match) {
            return decodingMap[match];
          });
        }
        function parseHTML(html2, options) {
          var stack = [];
          var expectHTML = options.expectHTML;
          var isUnaryTag2 = options.isUnaryTag || no2;
          var canBeLeftOpenTag2 = options.canBeLeftOpenTag || no2;
          var index4 = 0;
          var last, lastTag;
          var _loop_1 = function() {
            last = html2;
            if (!lastTag || !isPlainTextElement(lastTag)) {
              var textEnd = html2.indexOf("<");
              if (textEnd === 0) {
                if (comment.test(html2)) {
                  var commentEnd = html2.indexOf("-->");
                  if (commentEnd >= 0) {
                    if (options.shouldKeepComment && options.comment) {
                      options.comment(html2.substring(4, commentEnd), index4, index4 + commentEnd + 3);
                    }
                    advance(commentEnd + 3);
                    return "continue";
                  }
                }
                if (conditionalComment.test(html2)) {
                  var conditionalEnd = html2.indexOf("]>");
                  if (conditionalEnd >= 0) {
                    advance(conditionalEnd + 2);
                    return "continue";
                  }
                }
                var doctypeMatch = html2.match(doctype);
                if (doctypeMatch) {
                  advance(doctypeMatch[0].length);
                  return "continue";
                }
                var endTagMatch = html2.match(endTag);
                if (endTagMatch) {
                  var curIndex = index4;
                  advance(endTagMatch[0].length);
                  parseEndTag(endTagMatch[1], curIndex, index4);
                  return "continue";
                }
                var startTagMatch = parseStartTag();
                if (startTagMatch) {
                  handleStartTag(startTagMatch);
                  if (shouldIgnoreFirstNewline(startTagMatch.tagName, html2)) {
                    advance(1);
                  }
                  return "continue";
                }
              }
              var text2 = void 0, rest = void 0, next2 = void 0;
              if (textEnd >= 0) {
                rest = html2.slice(textEnd);
                while (!endTag.test(rest) && !startTagOpen.test(rest) && !comment.test(rest) && !conditionalComment.test(rest)) {
                  next2 = rest.indexOf("<", 1);
                  if (next2 < 0)
                    break;
                  textEnd += next2;
                  rest = html2.slice(textEnd);
                }
                text2 = html2.substring(0, textEnd);
              }
              if (textEnd < 0) {
                text2 = html2;
              }
              if (text2) {
                advance(text2.length);
              }
              if (options.chars && text2) {
                options.chars(text2, index4 - text2.length, index4);
              }
            } else {
              var endTagLength_1 = 0;
              var stackedTag_1 = lastTag.toLowerCase();
              var reStackedTag = reCache[stackedTag_1] || (reCache[stackedTag_1] = new RegExp("([\\s\\S]*?)(</" + stackedTag_1 + "[^>]*>)", "i"));
              var rest = html2.replace(reStackedTag, function(all, text3, endTag2) {
                endTagLength_1 = endTag2.length;
                if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== "noscript") {
                  text3 = text3.replace(/<!\--([\s\S]*?)-->/g, "$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g, "$1");
                }
                if (shouldIgnoreFirstNewline(stackedTag_1, text3)) {
                  text3 = text3.slice(1);
                }
                if (options.chars) {
                  options.chars(text3);
                }
                return "";
              });
              index4 += html2.length - rest.length;
              html2 = rest;
              parseEndTag(stackedTag_1, index4 - endTagLength_1, index4);
            }
            if (html2 === last) {
              options.chars && options.chars(html2);
              if (!stack.length && options.warn) {
                options.warn('Mal-formatted tag at end of template: "'.concat(html2, '"'), {
                  start: index4 + html2.length
                });
              }
              return "break";
            }
          };
          while (html2) {
            var state_1 = _loop_1();
            if (state_1 === "break")
              break;
          }
          parseEndTag();
          function advance(n) {
            index4 += n;
            html2 = html2.substring(n);
          }
          function parseStartTag() {
            var start = html2.match(startTagOpen);
            if (start) {
              var match = {
                tagName: start[1],
                attrs: [],
                start: index4
              };
              advance(start[0].length);
              var end = void 0, attr = void 0;
              while (!(end = html2.match(startTagClose)) && (attr = html2.match(dynamicArgAttribute) || html2.match(attribute))) {
                attr.start = index4;
                advance(attr[0].length);
                attr.end = index4;
                match.attrs.push(attr);
              }
              if (end) {
                match.unarySlash = end[1];
                advance(end[0].length);
                match.end = index4;
                return match;
              }
            }
          }
          function handleStartTag(match) {
            var tagName3 = match.tagName;
            var unarySlash = match.unarySlash;
            if (expectHTML) {
              if (lastTag === "p" && isNonPhrasingTag(tagName3)) {
                parseEndTag(lastTag);
              }
              if (canBeLeftOpenTag2(tagName3) && lastTag === tagName3) {
                parseEndTag(tagName3);
              }
            }
            var unary = isUnaryTag2(tagName3) || !!unarySlash;
            var l = match.attrs.length;
            var attrs3 = new Array(l);
            for (var i = 0; i < l; i++) {
              var args = match.attrs[i];
              var value = args[3] || args[4] || args[5] || "";
              var shouldDecodeNewlines2 = tagName3 === "a" && args[1] === "href" ? options.shouldDecodeNewlinesForHref : options.shouldDecodeNewlines;
              attrs3[i] = {
                name: args[1],
                value: decodeAttr(value, shouldDecodeNewlines2)
              };
              if (options.outputSourceRange) {
                attrs3[i].start = args.start + args[0].match(/^\s*/).length;
                attrs3[i].end = args.end;
              }
            }
            if (!unary) {
              stack.push({
                tag: tagName3,
                lowerCasedTag: tagName3.toLowerCase(),
                attrs: attrs3,
                start: match.start,
                end: match.end
              });
              lastTag = tagName3;
            }
            if (options.start) {
              options.start(tagName3, attrs3, unary, match.start, match.end);
            }
          }
          function parseEndTag(tagName3, start, end) {
            var pos, lowerCasedTagName;
            if (start == null)
              start = index4;
            if (end == null)
              end = index4;
            if (tagName3) {
              lowerCasedTagName = tagName3.toLowerCase();
              for (pos = stack.length - 1; pos >= 0; pos--) {
                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
                  break;
                }
              }
            } else {
              pos = 0;
            }
            if (pos >= 0) {
              for (var i = stack.length - 1; i >= pos; i--) {
                if ((i > pos || !tagName3) && options.warn) {
                  options.warn("tag <".concat(stack[i].tag, "> has no matching end tag."), {
                    start: stack[i].start,
                    end: stack[i].end
                  });
                }
                if (options.end) {
                  options.end(stack[i].tag, start, end);
                }
              }
              stack.length = pos;
              lastTag = pos && stack[pos - 1].tag;
            } else if (lowerCasedTagName === "br") {
              if (options.start) {
                options.start(tagName3, [], true, start, end);
              }
            } else if (lowerCasedTagName === "p") {
              if (options.start) {
                options.start(tagName3, [], false, start, end);
              }
              if (options.end) {
                options.end(tagName3, start, end);
              }
            }
          }
        }
        var onRE = /^@|^v-on:/;
        var dirRE = /^v-|^@|^:|^#/;
        var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
        var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
        var stripParensRE = /^\(|\)$/g;
        var dynamicArgRE = /^\[.*\]$/;
        var argRE = /:(.*)$/;
        var bindRE = /^:|^\.|^v-bind:/;
        var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
        var slotRE = /^v-slot(:|$)|^#/;
        var lineBreakRE = /[\r\n]/;
        var whitespaceRE2 = /[ \f\t\r\n]+/g;
        var invalidAttributeRE = /[\s"'<>\/=]/;
        var decodeHTMLCached = cached2(he.decode);
        var emptySlotScopeToken = "_empty_";
        var warn2;
        var delimiters;
        var transforms;
        var preTransforms;
        var postTransforms;
        var platformIsPreTag;
        var platformMustUseProp;
        var platformGetTagNamespace;
        var maybeComponent;
        function createASTElement(tag, attrs3, parent) {
          return {
            type: 1,
            tag,
            attrsList: attrs3,
            attrsMap: makeAttrsMap(attrs3),
            rawAttrsMap: {},
            parent,
            children: []
          };
        }
        function parse(template, options) {
          warn2 = options.warn || baseWarn;
          platformIsPreTag = options.isPreTag || no2;
          platformMustUseProp = options.mustUseProp || no2;
          platformGetTagNamespace = options.getTagNamespace || no2;
          var isReservedTag3 = options.isReservedTag || no2;
          maybeComponent = function(el) {
            return !!(el.component || el.attrsMap[":is"] || el.attrsMap["v-bind:is"] || !(el.attrsMap.is ? isReservedTag3(el.attrsMap.is) : isReservedTag3(el.tag)));
          };
          transforms = pluckModuleFunction(options.modules, "transformNode");
          preTransforms = pluckModuleFunction(options.modules, "preTransformNode");
          postTransforms = pluckModuleFunction(options.modules, "postTransformNode");
          delimiters = options.delimiters;
          var stack = [];
          var preserveWhitespace = options.preserveWhitespace !== false;
          var whitespaceOption = options.whitespace;
          var root;
          var currentParent;
          var inVPre = false;
          var inPre = false;
          var warned = false;
          function warnOnce(msg, range2) {
            if (!warned) {
              warned = true;
              warn2(msg, range2);
            }
          }
          function closeElement(element) {
            trimEndingWhitespace(element);
            if (!inVPre && !element.processed) {
              element = processElement(element, options);
            }
            if (!stack.length && element !== root) {
              if (root.if && (element.elseif || element.else)) {
                {
                  checkRootConstraints(element);
                }
                addIfCondition(root, {
                  exp: element.elseif,
                  block: element
                });
              } else {
                warnOnce("Component template should contain exactly one root element. If you are using v-if on multiple elements, use v-else-if to chain them instead.", { start: element.start });
              }
            }
            if (currentParent && !element.forbidden) {
              if (element.elseif || element.else) {
                processIfConditions(element, currentParent);
              } else {
                if (element.slotScope) {
                  var name_1 = element.slotTarget || '"default"';
                  (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
                }
                currentParent.children.push(element);
                element.parent = currentParent;
              }
            }
            element.children = element.children.filter(function(c) {
              return !c.slotScope;
            });
            trimEndingWhitespace(element);
            if (element.pre) {
              inVPre = false;
            }
            if (platformIsPreTag(element.tag)) {
              inPre = false;
            }
            for (var i = 0; i < postTransforms.length; i++) {
              postTransforms[i](element, options);
            }
          }
          function trimEndingWhitespace(el) {
            if (!inPre) {
              var lastNode = void 0;
              while ((lastNode = el.children[el.children.length - 1]) && lastNode.type === 3 && lastNode.text === " ") {
                el.children.pop();
              }
            }
          }
          function checkRootConstraints(el) {
            if (el.tag === "slot" || el.tag === "template") {
              warnOnce("Cannot use <".concat(el.tag, "> as component root element because it may ") + "contain multiple nodes.", { start: el.start });
            }
            if (el.attrsMap.hasOwnProperty("v-for")) {
              warnOnce("Cannot use v-for on stateful component root element because it renders multiple elements.", el.rawAttrsMap["v-for"]);
            }
          }
          parseHTML(template, {
            warn: warn2,
            expectHTML: options.expectHTML,
            isUnaryTag: options.isUnaryTag,
            canBeLeftOpenTag: options.canBeLeftOpenTag,
            shouldDecodeNewlines: options.shouldDecodeNewlines,
            shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
            shouldKeepComment: options.comments,
            outputSourceRange: options.outputSourceRange,
            start: function(tag, attrs3, unary, start, end) {
              var ns = currentParent && currentParent.ns || platformGetTagNamespace(tag);
              if (isIE2 && ns === "svg") {
                attrs3 = guardIESVGBug(attrs3);
              }
              var element = createASTElement(tag, attrs3, currentParent);
              if (ns) {
                element.ns = ns;
              }
              {
                if (options.outputSourceRange) {
                  element.start = start;
                  element.end = end;
                  element.rawAttrsMap = element.attrsList.reduce(function(cumulated, attr) {
                    cumulated[attr.name] = attr;
                    return cumulated;
                  }, {});
                }
                attrs3.forEach(function(attr) {
                  if (invalidAttributeRE.test(attr.name)) {
                    warn2("Invalid dynamic argument expression: attribute names cannot contain spaces, quotes, <, >, / or =.", options.outputSourceRange ? {
                      start: attr.start + attr.name.indexOf("["),
                      end: attr.start + attr.name.length
                    } : void 0);
                  }
                });
              }
              if (isForbiddenTag(element) && !isServerRendering2()) {
                element.forbidden = true;
                warn2("Templates should only be responsible for mapping the state to the UI. Avoid placing tags with side-effects in your templates, such as " + "<".concat(tag, ">") + ", as they will not be parsed.", { start: element.start });
              }
              for (var i = 0; i < preTransforms.length; i++) {
                element = preTransforms[i](element, options) || element;
              }
              if (!inVPre) {
                processPre(element);
                if (element.pre) {
                  inVPre = true;
                }
              }
              if (platformIsPreTag(element.tag)) {
                inPre = true;
              }
              if (inVPre) {
                processRawAttrs(element);
              } else if (!element.processed) {
                processFor(element);
                processIf(element);
                processOnce(element);
              }
              if (!root) {
                root = element;
                {
                  checkRootConstraints(root);
                }
              }
              if (!unary) {
                currentParent = element;
                stack.push(element);
              } else {
                closeElement(element);
              }
            },
            end: function(tag, start, end) {
              var element = stack[stack.length - 1];
              stack.length -= 1;
              currentParent = stack[stack.length - 1];
              if (options.outputSourceRange) {
                element.end = end;
              }
              closeElement(element);
            },
            chars: function(text2, start, end) {
              if (!currentParent) {
                {
                  if (text2 === template) {
                    warnOnce("Component template requires a root element, rather than just text.", { start });
                  } else if (text2 = text2.trim()) {
                    warnOnce('text "'.concat(text2, '" outside root element will be ignored.'), {
                      start
                    });
                  }
                }
                return;
              }
              if (isIE2 && currentParent.tag === "textarea" && currentParent.attrsMap.placeholder === text2) {
                return;
              }
              var children = currentParent.children;
              if (inPre || text2.trim()) {
                text2 = isTextTag(currentParent) ? text2 : decodeHTMLCached(text2);
              } else if (!children.length) {
                text2 = "";
              } else if (whitespaceOption) {
                if (whitespaceOption === "condense") {
                  text2 = lineBreakRE.test(text2) ? "" : " ";
                } else {
                  text2 = " ";
                }
              } else {
                text2 = preserveWhitespace ? " " : "";
              }
              if (text2) {
                if (!inPre && whitespaceOption === "condense") {
                  text2 = text2.replace(whitespaceRE2, " ");
                }
                var res = void 0;
                var child = void 0;
                if (!inVPre && text2 !== " " && (res = parseText(text2, delimiters))) {
                  child = {
                    type: 2,
                    expression: res.expression,
                    tokens: res.tokens,
                    text: text2
                  };
                } else if (text2 !== " " || !children.length || children[children.length - 1].text !== " ") {
                  child = {
                    type: 3,
                    text: text2
                  };
                }
                if (child) {
                  if (options.outputSourceRange) {
                    child.start = start;
                    child.end = end;
                  }
                  children.push(child);
                }
              }
            },
            comment: function(text2, start, end) {
              if (currentParent) {
                var child = {
                  type: 3,
                  text: text2,
                  isComment: true
                };
                if (options.outputSourceRange) {
                  child.start = start;
                  child.end = end;
                }
                currentParent.children.push(child);
              }
            }
          });
          return root;
        }
        function processPre(el) {
          if (getAndRemoveAttr(el, "v-pre") != null) {
            el.pre = true;
          }
        }
        function processRawAttrs(el) {
          var list = el.attrsList;
          var len2 = list.length;
          if (len2) {
            var attrs3 = el.attrs = new Array(len2);
            for (var i = 0; i < len2; i++) {
              attrs3[i] = {
                name: list[i].name,
                value: JSON.stringify(list[i].value)
              };
              if (list[i].start != null) {
                attrs3[i].start = list[i].start;
                attrs3[i].end = list[i].end;
              }
            }
          } else if (!el.pre) {
            el.plain = true;
          }
        }
        function processElement(element, options) {
          processKey(element);
          element.plain = !element.key && !element.scopedSlots && !element.attrsList.length;
          processRef(element);
          processSlotContent(element);
          processSlotOutlet(element);
          processComponent(element);
          for (var i = 0; i < transforms.length; i++) {
            element = transforms[i](element, options) || element;
          }
          processAttrs(element);
          return element;
        }
        function processKey(el) {
          var exp = getBindingAttr(el, "key");
          if (exp) {
            {
              if (el.tag === "template") {
                warn2("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, "key"));
              }
              if (el.for) {
                var iterator = el.iterator2 || el.iterator1;
                var parent_1 = el.parent;
                if (iterator && iterator === exp && parent_1 && parent_1.tag === "transition-group") {
                  warn2(
                    "Do not use v-for index as key on <transition-group> children, this is the same as not using keys.",
                    getRawBindingAttr(el, "key"),
                    true
                    /* tip */
                  );
                }
              }
            }
            el.key = exp;
          }
        }
        function processRef(el) {
          var ref3 = getBindingAttr(el, "ref");
          if (ref3) {
            el.ref = ref3;
            el.refInFor = checkInFor(el);
          }
        }
        function processFor(el) {
          var exp;
          if (exp = getAndRemoveAttr(el, "v-for")) {
            var res = parseFor(exp);
            if (res) {
              extend2(el, res);
            } else {
              warn2("Invalid v-for expression: ".concat(exp), el.rawAttrsMap["v-for"]);
            }
          }
        }
        function parseFor(exp) {
          var inMatch = exp.match(forAliasRE);
          if (!inMatch)
            return;
          var res = {};
          res.for = inMatch[2].trim();
          var alias = inMatch[1].trim().replace(stripParensRE, "");
          var iteratorMatch = alias.match(forIteratorRE);
          if (iteratorMatch) {
            res.alias = alias.replace(forIteratorRE, "").trim();
            res.iterator1 = iteratorMatch[1].trim();
            if (iteratorMatch[2]) {
              res.iterator2 = iteratorMatch[2].trim();
            }
          } else {
            res.alias = alias;
          }
          return res;
        }
        function processIf(el) {
          var exp = getAndRemoveAttr(el, "v-if");
          if (exp) {
            el.if = exp;
            addIfCondition(el, {
              exp,
              block: el
            });
          } else {
            if (getAndRemoveAttr(el, "v-else") != null) {
              el.else = true;
            }
            var elseif = getAndRemoveAttr(el, "v-else-if");
            if (elseif) {
              el.elseif = elseif;
            }
          }
        }
        function processIfConditions(el, parent) {
          var prev = findPrevElement(parent.children);
          if (prev && prev.if) {
            addIfCondition(prev, {
              exp: el.elseif,
              block: el
            });
          } else {
            warn2("v-".concat(el.elseif ? 'else-if="' + el.elseif + '"' : "else", " ") + "used on element <".concat(el.tag, "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? "v-else-if" : "v-else"]);
          }
        }
        function findPrevElement(children) {
          var i = children.length;
          while (i--) {
            if (children[i].type === 1) {
              return children[i];
            } else {
              if (children[i].text !== " ") {
                warn2('text "'.concat(children[i].text.trim(), '" between v-if and v-else(-if) ') + "will be ignored.", children[i]);
              }
              children.pop();
            }
          }
        }
        function addIfCondition(el, condition) {
          if (!el.ifConditions) {
            el.ifConditions = [];
          }
          el.ifConditions.push(condition);
        }
        function processOnce(el) {
          var once3 = getAndRemoveAttr(el, "v-once");
          if (once3 != null) {
            el.once = true;
          }
        }
        function processSlotContent(el) {
          var slotScope;
          if (el.tag === "template") {
            slotScope = getAndRemoveAttr(el, "scope");
            if (slotScope) {
              warn2('the "scope" attribute for scoped slots have been deprecated and replaced by "slot-scope" since 2.5. The new "slot-scope" attribute can also be used on plain elements in addition to <template> to denote scoped slots.', el.rawAttrsMap["scope"], true);
            }
            el.slotScope = slotScope || getAndRemoveAttr(el, "slot-scope");
          } else if (slotScope = getAndRemoveAttr(el, "slot-scope")) {
            if (el.attrsMap["v-for"]) {
              warn2("Ambiguous combined usage of slot-scope and v-for on <".concat(el.tag, "> ") + "(v-for takes higher priority). Use a wrapper <template> for the scoped slot to make it clearer.", el.rawAttrsMap["slot-scope"], true);
            }
            el.slotScope = slotScope;
          }
          var slotTarget = getBindingAttr(el, "slot");
          if (slotTarget) {
            el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
            el.slotTargetDynamic = !!(el.attrsMap[":slot"] || el.attrsMap["v-bind:slot"]);
            if (el.tag !== "template" && !el.slotScope) {
              addAttr(el, "slot", slotTarget, getRawBindingAttr(el, "slot"));
            }
          }
          {
            if (el.tag === "template") {
              var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
              if (slotBinding) {
                {
                  if (el.slotTarget || el.slotScope) {
                    warn2("Unexpected mixed usage of different slot syntaxes.", el);
                  }
                  if (el.parent && !maybeComponent(el.parent)) {
                    warn2("<template v-slot> can only appear at the root level inside the receiving component", el);
                  }
                }
                var _a2 = getSlotName(slotBinding), name_2 = _a2.name, dynamic = _a2.dynamic;
                el.slotTarget = name_2;
                el.slotTargetDynamic = dynamic;
                el.slotScope = slotBinding.value || emptySlotScopeToken;
              }
            } else {
              var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
              if (slotBinding) {
                {
                  if (!maybeComponent(el)) {
                    warn2("v-slot can only be used on components or <template>.", slotBinding);
                  }
                  if (el.slotScope || el.slotTarget) {
                    warn2("Unexpected mixed usage of different slot syntaxes.", el);
                  }
                  if (el.scopedSlots) {
                    warn2("To avoid scope ambiguity, the default slot should also use <template> syntax when there are other named slots.", slotBinding);
                  }
                }
                var slots = el.scopedSlots || (el.scopedSlots = {});
                var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
                var slotContainer_1 = slots[name_3] = createASTElement("template", [], el);
                slotContainer_1.slotTarget = name_3;
                slotContainer_1.slotTargetDynamic = dynamic;
                slotContainer_1.children = el.children.filter(function(c) {
                  if (!c.slotScope) {
                    c.parent = slotContainer_1;
                    return true;
                  }
                });
                slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
                el.children = [];
                el.plain = false;
              }
            }
          }
        }
        function getSlotName(binding) {
          var name = binding.name.replace(slotRE, "");
          if (!name) {
            if (binding.name[0] !== "#") {
              name = "default";
            } else {
              warn2("v-slot shorthand syntax requires a slot name.", binding);
            }
          }
          return dynamicArgRE.test(name) ? (
            // dynamic [name]
            { name: name.slice(1, -1), dynamic: true }
          ) : (
            // static name
            { name: '"'.concat(name, '"'), dynamic: false }
          );
        }
        function processSlotOutlet(el) {
          if (el.tag === "slot") {
            el.slotName = getBindingAttr(el, "name");
            if (el.key) {
              warn2("`key` does not work on <slot> because slots are abstract outlets and can possibly expand into multiple elements. Use the key on a wrapping element instead.", getRawBindingAttr(el, "key"));
            }
          }
        }
        function processComponent(el) {
          var binding;
          if (binding = getBindingAttr(el, "is")) {
            el.component = binding;
          }
          if (getAndRemoveAttr(el, "inline-template") != null) {
            el.inlineTemplate = true;
          }
        }
        function processAttrs(el) {
          var list = el.attrsList;
          var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
          for (i = 0, l = list.length; i < l; i++) {
            name = rawName = list[i].name;
            value = list[i].value;
            if (dirRE.test(name)) {
              el.hasBindings = true;
              modifiers = parseModifiers(name.replace(dirRE, ""));
              if (modifiers) {
                name = name.replace(modifierRE, "");
              }
              if (bindRE.test(name)) {
                name = name.replace(bindRE, "");
                value = parseFilters(value);
                isDynamic = dynamicArgRE.test(name);
                if (isDynamic) {
                  name = name.slice(1, -1);
                }
                if (value.trim().length === 0) {
                  warn2('The value for a v-bind expression cannot be empty. Found in "v-bind:'.concat(name, '"'));
                }
                if (modifiers) {
                  if (modifiers.prop && !isDynamic) {
                    name = camelize2(name);
                    if (name === "innerHtml")
                      name = "innerHTML";
                  }
                  if (modifiers.camel && !isDynamic) {
                    name = camelize2(name);
                  }
                  if (modifiers.sync) {
                    syncGen = genAssignmentCode(value, "$event");
                    if (!isDynamic) {
                      addHandler(el, "update:".concat(camelize2(name)), syncGen, null, false, warn2, list[i]);
                      if (hyphenate2(name) !== camelize2(name)) {
                        addHandler(el, "update:".concat(hyphenate2(name)), syncGen, null, false, warn2, list[i]);
                      }
                    } else {
                      addHandler(
                        el,
                        '"update:"+('.concat(name, ")"),
                        syncGen,
                        null,
                        false,
                        warn2,
                        list[i],
                        true
                        // dynamic
                      );
                    }
                  }
                }
                if (modifiers && modifiers.prop || !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)) {
                  addProp(el, name, value, list[i], isDynamic);
                } else {
                  addAttr(el, name, value, list[i], isDynamic);
                }
              } else if (onRE.test(name)) {
                name = name.replace(onRE, "");
                isDynamic = dynamicArgRE.test(name);
                if (isDynamic) {
                  name = name.slice(1, -1);
                }
                addHandler(el, name, value, modifiers, false, warn2, list[i], isDynamic);
              } else {
                name = name.replace(dirRE, "");
                var argMatch = name.match(argRE);
                var arg = argMatch && argMatch[1];
                isDynamic = false;
                if (arg) {
                  name = name.slice(0, -(arg.length + 1));
                  if (dynamicArgRE.test(arg)) {
                    arg = arg.slice(1, -1);
                    isDynamic = true;
                  }
                }
                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
                if (name === "model") {
                  checkForAliasModel(el, value);
                }
              }
            } else {
              {
                var res = parseText(value, delimiters);
                if (res) {
                  warn2("".concat(name, '="').concat(value, '": ') + 'Interpolation inside attributes has been removed. Use v-bind or the colon shorthand instead. For example, instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
                }
              }
              addAttr(el, name, JSON.stringify(value), list[i]);
              if (!el.component && name === "muted" && platformMustUseProp(el.tag, el.attrsMap.type, name)) {
                addProp(el, name, "true", list[i]);
              }
            }
          }
        }
        function checkInFor(el) {
          var parent = el;
          while (parent) {
            if (parent.for !== void 0) {
              return true;
            }
            parent = parent.parent;
          }
          return false;
        }
        function parseModifiers(name) {
          var match = name.match(modifierRE);
          if (match) {
            var ret_1 = {};
            match.forEach(function(m) {
              ret_1[m.slice(1)] = true;
            });
            return ret_1;
          }
        }
        function makeAttrsMap(attrs3) {
          var map = {};
          for (var i = 0, l = attrs3.length; i < l; i++) {
            if (map[attrs3[i].name] && !isIE2 && !isEdge2) {
              warn2("duplicate attribute: " + attrs3[i].name, attrs3[i]);
            }
            map[attrs3[i].name] = attrs3[i].value;
          }
          return map;
        }
        function isTextTag(el) {
          return el.tag === "script" || el.tag === "style";
        }
        function isForbiddenTag(el) {
          return el.tag === "style" || el.tag === "script" && (!el.attrsMap.type || el.attrsMap.type === "text/javascript");
        }
        var ieNSBug = /^xmlns:NS\d+/;
        var ieNSPrefix = /^NS\d+:/;
        function guardIESVGBug(attrs3) {
          var res = [];
          for (var i = 0; i < attrs3.length; i++) {
            var attr = attrs3[i];
            if (!ieNSBug.test(attr.name)) {
              attr.name = attr.name.replace(ieNSPrefix, "");
              res.push(attr);
            }
          }
          return res;
        }
        function checkForAliasModel(el, value) {
          var _el = el;
          while (_el) {
            if (_el.for && _el.alias === value) {
              warn2("<".concat(el.tag, ' v-model="').concat(value, '">: ') + "You are binding v-model directly to a v-for iteration alias. This will not be able to modify the v-for source array because writing to the alias is like modifying a function local variable. Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap["v-model"]);
            }
            _el = _el.parent;
          }
        }
        function preTransformNode(el, options) {
          if (el.tag === "input") {
            var map = el.attrsMap;
            if (!map["v-model"]) {
              return;
            }
            var typeBinding = void 0;
            if (map[":type"] || map["v-bind:type"]) {
              typeBinding = getBindingAttr(el, "type");
            }
            if (!map.type && !typeBinding && map["v-bind"]) {
              typeBinding = "(".concat(map["v-bind"], ").type");
            }
            if (typeBinding) {
              var ifCondition = getAndRemoveAttr(el, "v-if", true);
              var ifConditionExtra = ifCondition ? "&&(".concat(ifCondition, ")") : "";
              var hasElse = getAndRemoveAttr(el, "v-else", true) != null;
              var elseIfCondition = getAndRemoveAttr(el, "v-else-if", true);
              var branch0 = cloneASTElement(el);
              processFor(branch0);
              addRawAttr(branch0, "type", "checkbox");
              processElement(branch0, options);
              branch0.processed = true;
              branch0.if = "(".concat(typeBinding, ")==='checkbox'") + ifConditionExtra;
              addIfCondition(branch0, {
                exp: branch0.if,
                block: branch0
              });
              var branch1 = cloneASTElement(el);
              getAndRemoveAttr(branch1, "v-for", true);
              addRawAttr(branch1, "type", "radio");
              processElement(branch1, options);
              addIfCondition(branch0, {
                exp: "(".concat(typeBinding, ")==='radio'") + ifConditionExtra,
                block: branch1
              });
              var branch2 = cloneASTElement(el);
              getAndRemoveAttr(branch2, "v-for", true);
              addRawAttr(branch2, ":type", typeBinding);
              processElement(branch2, options);
              addIfCondition(branch0, {
                exp: ifCondition,
                block: branch2
              });
              if (hasElse) {
                branch0.else = true;
              } else if (elseIfCondition) {
                branch0.elseif = elseIfCondition;
              }
              return branch0;
            }
          }
        }
        function cloneASTElement(el) {
          return createASTElement(el.tag, el.attrsList.slice(), el.parent);
        }
        var model = {
          preTransformNode
        };
        var modules2 = [klass2, style2, model];
        function text(el, dir) {
          if (dir.value) {
            addProp(el, "textContent", "_s(".concat(dir.value, ")"), dir);
          }
        }
        function html(el, dir) {
          if (dir.value) {
            addProp(el, "innerHTML", "_s(".concat(dir.value, ")"), dir);
          }
        }
        var directives2 = {
          model: model$1,
          text,
          html
        };
        var baseOptions = {
          expectHTML: true,
          modules: modules2,
          directives: directives2,
          isPreTag,
          isUnaryTag,
          mustUseProp: mustUseProp2,
          canBeLeftOpenTag,
          isReservedTag: isReservedTag2,
          getTagNamespace: getTagNamespace2,
          staticKeys: genStaticKeys$1(modules2)
        };
        var isStaticKey;
        var isPlatformReservedTag;
        var genStaticKeysCached = cached2(genStaticKeys);
        function optimize(root, options) {
          if (!root)
            return;
          isStaticKey = genStaticKeysCached(options.staticKeys || "");
          isPlatformReservedTag = options.isReservedTag || no2;
          markStatic2(root);
          markStaticRoots(root, false);
        }
        function genStaticKeys(keys) {
          return makeMap2("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap" + (keys ? "," + keys : ""));
        }
        function markStatic2(node) {
          node.static = isStatic(node);
          if (node.type === 1) {
            if (!isPlatformReservedTag(node.tag) && node.tag !== "slot" && node.attrsMap["inline-template"] == null) {
              return;
            }
            for (var i = 0, l = node.children.length; i < l; i++) {
              var child = node.children[i];
              markStatic2(child);
              if (!child.static) {
                node.static = false;
              }
            }
            if (node.ifConditions) {
              for (var i = 1, l = node.ifConditions.length; i < l; i++) {
                var block = node.ifConditions[i].block;
                markStatic2(block);
                if (!block.static) {
                  node.static = false;
                }
              }
            }
          }
        }
        function markStaticRoots(node, isInFor) {
          if (node.type === 1) {
            if (node.static || node.once) {
              node.staticInFor = isInFor;
            }
            if (node.static && node.children.length && !(node.children.length === 1 && node.children[0].type === 3)) {
              node.staticRoot = true;
              return;
            } else {
              node.staticRoot = false;
            }
            if (node.children) {
              for (var i = 0, l = node.children.length; i < l; i++) {
                markStaticRoots(node.children[i], isInFor || !!node.for);
              }
            }
            if (node.ifConditions) {
              for (var i = 1, l = node.ifConditions.length; i < l; i++) {
                markStaticRoots(node.ifConditions[i].block, isInFor);
              }
            }
          }
        }
        function isStatic(node) {
          if (node.type === 2) {
            return false;
          }
          if (node.type === 3) {
            return true;
          }
          return !!(node.pre || !node.hasBindings && // no dynamic bindings
          !node.if && !node.for && // not v-if or v-for or v-else
          !isBuiltInTag2(node.tag) && // not a built-in
          isPlatformReservedTag(node.tag) && // not a component
          !isDirectChildOfTemplateFor(node) && Object.keys(node).every(isStaticKey));
        }
        function isDirectChildOfTemplateFor(node) {
          while (node.parent) {
            node = node.parent;
            if (node.tag !== "template") {
              return false;
            }
            if (node.for) {
              return true;
            }
          }
          return false;
        }
        var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
        var fnInvokeRE = /\([^)]*?\);*$/;
        var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
        var keyCodes = {
          esc: 27,
          tab: 9,
          enter: 13,
          space: 32,
          up: 38,
          left: 37,
          right: 39,
          down: 40,
          delete: [8, 46]
        };
        var keyNames = {
          // #7880: IE11 and Edge use `Esc` for Escape key name.
          esc: ["Esc", "Escape"],
          tab: "Tab",
          enter: "Enter",
          // #9112: IE11 uses `Spacebar` for Space key name.
          space: [" ", "Spacebar"],
          // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
          up: ["Up", "ArrowUp"],
          left: ["Left", "ArrowLeft"],
          right: ["Right", "ArrowRight"],
          down: ["Down", "ArrowDown"],
          // #9112: IE11 uses `Del` for Delete key name.
          delete: ["Backspace", "Delete", "Del"]
        };
        var genGuard = function(condition) {
          return "if(".concat(condition, ")return null;");
        };
        var modifierCode = {
          stop: "$event.stopPropagation();",
          prevent: "$event.preventDefault();",
          self: genGuard("$event.target !== $event.currentTarget"),
          ctrl: genGuard("!$event.ctrlKey"),
          shift: genGuard("!$event.shiftKey"),
          alt: genGuard("!$event.altKey"),
          meta: genGuard("!$event.metaKey"),
          left: genGuard("'button' in $event && $event.button !== 0"),
          middle: genGuard("'button' in $event && $event.button !== 1"),
          right: genGuard("'button' in $event && $event.button !== 2")
        };
        function genHandlers(events3, isNative3) {
          var prefix = isNative3 ? "nativeOn:" : "on:";
          var staticHandlers = "";
          var dynamicHandlers = "";
          for (var name_1 in events3) {
            var handlerCode = genHandler(events3[name_1]);
            if (events3[name_1] && events3[name_1].dynamic) {
              dynamicHandlers += "".concat(name_1, ",").concat(handlerCode, ",");
            } else {
              staticHandlers += '"'.concat(name_1, '":').concat(handlerCode, ",");
            }
          }
          staticHandlers = "{".concat(staticHandlers.slice(0, -1), "}");
          if (dynamicHandlers) {
            return prefix + "_d(".concat(staticHandlers, ",[").concat(dynamicHandlers.slice(0, -1), "])");
          } else {
            return prefix + staticHandlers;
          }
        }
        function genHandler(handler) {
          if (!handler) {
            return "function(){}";
          }
          if (Array.isArray(handler)) {
            return "[".concat(handler.map(function(handler2) {
              return genHandler(handler2);
            }).join(","), "]");
          }
          var isMethodPath = simplePathRE.test(handler.value);
          var isFunctionExpression = fnExpRE.test(handler.value);
          var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ""));
          if (!handler.modifiers) {
            if (isMethodPath || isFunctionExpression) {
              return handler.value;
            }
            return "function($event){".concat(isFunctionInvocation ? "return ".concat(handler.value) : handler.value, "}");
          } else {
            var code = "";
            var genModifierCode = "";
            var keys = [];
            var _loop_1 = function(key2) {
              if (modifierCode[key2]) {
                genModifierCode += modifierCode[key2];
                if (keyCodes[key2]) {
                  keys.push(key2);
                }
              } else if (key2 === "exact") {
                var modifiers_1 = handler.modifiers;
                genModifierCode += genGuard(["ctrl", "shift", "alt", "meta"].filter(function(keyModifier) {
                  return !modifiers_1[keyModifier];
                }).map(function(keyModifier) {
                  return "$event.".concat(keyModifier, "Key");
                }).join("||"));
              } else {
                keys.push(key2);
              }
            };
            for (var key in handler.modifiers) {
              _loop_1(key);
            }
            if (keys.length) {
              code += genKeyFilter(keys);
            }
            if (genModifierCode) {
              code += genModifierCode;
            }
            var handlerCode = isMethodPath ? "return ".concat(handler.value, ".apply(null, arguments)") : isFunctionExpression ? "return (".concat(handler.value, ").apply(null, arguments)") : isFunctionInvocation ? "return ".concat(handler.value) : handler.value;
            return "function($event){".concat(code).concat(handlerCode, "}");
          }
        }
        function genKeyFilter(keys) {
          return (
            // make sure the key filters only apply to KeyboardEvents
            // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
            // key events that do not have keyCode property...
            "if(!$event.type.indexOf('key')&&" + "".concat(keys.map(genFilterCode).join("&&"), ")return null;")
          );
        }
        function genFilterCode(key) {
          var keyVal = parseInt(key, 10);
          if (keyVal) {
            return "$event.keyCode!==".concat(keyVal);
          }
          var keyCode = keyCodes[key];
          var keyName = keyNames[key];
          return "_k($event.keyCode," + "".concat(JSON.stringify(key), ",") + "".concat(JSON.stringify(keyCode), ",") + "$event.key," + "".concat(JSON.stringify(keyName)) + ")";
        }
        function on(el, dir) {
          if (dir.modifiers) {
            warn$2("v-on without argument does not support modifiers.");
          }
          el.wrapListeners = function(code) {
            return "_g(".concat(code, ",").concat(dir.value, ")");
          };
        }
        function bind2(el, dir) {
          el.wrapData = function(code) {
            return "_b(".concat(code, ",'").concat(el.tag, "',").concat(dir.value, ",").concat(dir.modifiers && dir.modifiers.prop ? "true" : "false").concat(dir.modifiers && dir.modifiers.sync ? ",true" : "", ")");
          };
        }
        var baseDirectives = {
          on,
          bind: bind2,
          cloak: noop2
        };
        var CodegenState = (
          /** @class */
          /* @__PURE__ */ (function() {
            function CodegenState2(options) {
              this.options = options;
              this.warn = options.warn || baseWarn;
              this.transforms = pluckModuleFunction(options.modules, "transformCode");
              this.dataGenFns = pluckModuleFunction(options.modules, "genData");
              this.directives = extend2(extend2({}, baseDirectives), options.directives);
              var isReservedTag3 = options.isReservedTag || no2;
              this.maybeComponent = function(el) {
                return !!el.component || !isReservedTag3(el.tag);
              };
              this.onceId = 0;
              this.staticRenderFns = [];
              this.pre = false;
            }
            return CodegenState2;
          })()
        );
        function generate(ast, options) {
          var state = new CodegenState(options);
          var code = ast ? ast.tag === "script" ? "null" : genElement(ast, state) : '_c("div")';
          return {
            render: "with(this){return ".concat(code, "}"),
            staticRenderFns: state.staticRenderFns
          };
        }
        function genElement(el, state) {
          if (el.parent) {
            el.pre = el.pre || el.parent.pre;
          }
          if (el.staticRoot && !el.staticProcessed) {
            return genStatic(el, state);
          } else if (el.once && !el.onceProcessed) {
            return genOnce(el, state);
          } else if (el.for && !el.forProcessed) {
            return genFor(el, state);
          } else if (el.if && !el.ifProcessed) {
            return genIf(el, state);
          } else if (el.tag === "template" && !el.slotTarget && !state.pre) {
            return genChildren(el, state) || "void 0";
          } else if (el.tag === "slot") {
            return genSlot(el, state);
          } else {
            var code = void 0;
            if (el.component) {
              code = genComponent(el.component, el, state);
            } else {
              var data = void 0;
              var maybeComponent2 = state.maybeComponent(el);
              if (!el.plain || el.pre && maybeComponent2) {
                data = genData(el, state);
              }
              var tag = void 0;
              var bindings = state.options.bindings;
              if (maybeComponent2 && bindings && bindings.__isScriptSetup !== false) {
                tag = checkBindingType(bindings, el.tag);
              }
              if (!tag)
                tag = "'".concat(el.tag, "'");
              var children = el.inlineTemplate ? null : genChildren(el, state, true);
              code = "_c(".concat(tag).concat(
                data ? ",".concat(data) : ""
                // data
              ).concat(
                children ? ",".concat(children) : "",
                ")"
              );
            }
            for (var i = 0; i < state.transforms.length; i++) {
              code = state.transforms[i](el, code);
            }
            return code;
          }
        }
        function checkBindingType(bindings, key) {
          var camelName = camelize2(key);
          var PascalName = capitalize2(camelName);
          var checkType = function(type) {
            if (bindings[key] === type) {
              return key;
            }
            if (bindings[camelName] === type) {
              return camelName;
            }
            if (bindings[PascalName] === type) {
              return PascalName;
            }
          };
          var fromConst = checkType(
            "setup-const"
            /* BindingTypes.SETUP_CONST */
          ) || checkType(
            "setup-reactive-const"
            /* BindingTypes.SETUP_REACTIVE_CONST */
          );
          if (fromConst) {
            return fromConst;
          }
          var fromMaybeRef = checkType(
            "setup-let"
            /* BindingTypes.SETUP_LET */
          ) || checkType(
            "setup-ref"
            /* BindingTypes.SETUP_REF */
          ) || checkType(
            "setup-maybe-ref"
            /* BindingTypes.SETUP_MAYBE_REF */
          );
          if (fromMaybeRef) {
            return fromMaybeRef;
          }
        }
        function genStatic(el, state) {
          el.staticProcessed = true;
          var originalPreState = state.pre;
          if (el.pre) {
            state.pre = el.pre;
          }
          state.staticRenderFns.push("with(this){return ".concat(genElement(el, state), "}"));
          state.pre = originalPreState;
          return "_m(".concat(state.staticRenderFns.length - 1).concat(el.staticInFor ? ",true" : "", ")");
        }
        function genOnce(el, state) {
          el.onceProcessed = true;
          if (el.if && !el.ifProcessed) {
            return genIf(el, state);
          } else if (el.staticInFor) {
            var key = "";
            var parent_1 = el.parent;
            while (parent_1) {
              if (parent_1.for) {
                key = parent_1.key;
                break;
              }
              parent_1 = parent_1.parent;
            }
            if (!key) {
              state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap["v-once"]);
              return genElement(el, state);
            }
            return "_o(".concat(genElement(el, state), ",").concat(state.onceId++, ",").concat(key, ")");
          } else {
            return genStatic(el, state);
          }
        }
        function genIf(el, state, altGen, altEmpty) {
          el.ifProcessed = true;
          return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
        }
        function genIfConditions(conditions, state, altGen, altEmpty) {
          if (!conditions.length) {
            return altEmpty || "_e()";
          }
          var condition = conditions.shift();
          if (condition.exp) {
            return "(".concat(condition.exp, ")?").concat(genTernaryExp(condition.block), ":").concat(genIfConditions(conditions, state, altGen, altEmpty));
          } else {
            return "".concat(genTernaryExp(condition.block));
          }
          function genTernaryExp(el) {
            return altGen ? altGen(el, state) : el.once ? genOnce(el, state) : genElement(el, state);
          }
        }
        function genFor(el, state, altGen, altHelper) {
          var exp = el.for;
          var alias = el.alias;
          var iterator1 = el.iterator1 ? ",".concat(el.iterator1) : "";
          var iterator2 = el.iterator2 ? ",".concat(el.iterator2) : "";
          if (state.maybeComponent(el) && el.tag !== "slot" && el.tag !== "template" && !el.key) {
            state.warn(
              "<".concat(el.tag, ' v-for="').concat(alias, " in ").concat(exp, '">: component lists rendered with ') + "v-for should have explicit keys. See https://v2.vuejs.org/v2/guide/list.html#key for more info.",
              el.rawAttrsMap["v-for"],
              true
              /* tip */
            );
          }
          el.forProcessed = true;
          return "".concat(altHelper || "_l", "((").concat(exp, "),") + "function(".concat(alias).concat(iterator1).concat(iterator2, "){") + "return ".concat((altGen || genElement)(el, state)) + "})";
        }
        function genData(el, state) {
          var data = "{";
          var dirs = genDirectives(el, state);
          if (dirs)
            data += dirs + ",";
          if (el.key) {
            data += "key:".concat(el.key, ",");
          }
          if (el.ref) {
            data += "ref:".concat(el.ref, ",");
          }
          if (el.refInFor) {
            data += "refInFor:true,";
          }
          if (el.pre) {
            data += "pre:true,";
          }
          if (el.component) {
            data += 'tag:"'.concat(el.tag, '",');
          }
          for (var i = 0; i < state.dataGenFns.length; i++) {
            data += state.dataGenFns[i](el);
          }
          if (el.attrs) {
            data += "attrs:".concat(genProps(el.attrs), ",");
          }
          if (el.props) {
            data += "domProps:".concat(genProps(el.props), ",");
          }
          if (el.events) {
            data += "".concat(genHandlers(el.events, false), ",");
          }
          if (el.nativeEvents) {
            data += "".concat(genHandlers(el.nativeEvents, true), ",");
          }
          if (el.slotTarget && !el.slotScope) {
            data += "slot:".concat(el.slotTarget, ",");
          }
          if (el.scopedSlots) {
            data += "".concat(genScopedSlots(el, el.scopedSlots, state), ",");
          }
          if (el.model) {
            data += "model:{value:".concat(el.model.value, ",callback:").concat(el.model.callback, ",expression:").concat(el.model.expression, "},");
          }
          if (el.inlineTemplate) {
            var inlineTemplate = genInlineTemplate(el, state);
            if (inlineTemplate) {
              data += "".concat(inlineTemplate, ",");
            }
          }
          data = data.replace(/,$/, "") + "}";
          if (el.dynamicAttrs) {
            data = "_b(".concat(data, ',"').concat(el.tag, '",').concat(genProps(el.dynamicAttrs), ")");
          }
          if (el.wrapData) {
            data = el.wrapData(data);
          }
          if (el.wrapListeners) {
            data = el.wrapListeners(data);
          }
          return data;
        }
        function genDirectives(el, state) {
          var dirs = el.directives;
          if (!dirs)
            return;
          var res = "directives:[";
          var hasRuntime = false;
          var i, l, dir, needRuntime;
          for (i = 0, l = dirs.length; i < l; i++) {
            dir = dirs[i];
            needRuntime = true;
            var gen = state.directives[dir.name];
            if (gen) {
              needRuntime = !!gen(el, dir, state.warn);
            }
            if (needRuntime) {
              hasRuntime = true;
              res += '{name:"'.concat(dir.name, '",rawName:"').concat(dir.rawName, '"').concat(dir.value ? ",value:(".concat(dir.value, "),expression:").concat(JSON.stringify(dir.value)) : "").concat(dir.arg ? ",arg:".concat(dir.isDynamicArg ? dir.arg : '"'.concat(dir.arg, '"')) : "").concat(dir.modifiers ? ",modifiers:".concat(JSON.stringify(dir.modifiers)) : "", "},");
            }
          }
          if (hasRuntime) {
            return res.slice(0, -1) + "]";
          }
        }
        function genInlineTemplate(el, state) {
          var ast = el.children[0];
          if (el.children.length !== 1 || ast.type !== 1) {
            state.warn("Inline-template components must have exactly one child element.", { start: el.start });
          }
          if (ast && ast.type === 1) {
            var inlineRenderFns = generate(ast, state.options);
            return "inlineTemplate:{render:function(){".concat(inlineRenderFns.render, "},staticRenderFns:[").concat(inlineRenderFns.staticRenderFns.map(function(code) {
              return "function(){".concat(code, "}");
            }).join(","), "]}");
          }
        }
        function genScopedSlots(el, slots, state) {
          var needsForceUpdate = el.for || Object.keys(slots).some(function(key) {
            var slot = slots[key];
            return slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot);
          });
          var needsKey = !!el.if;
          if (!needsForceUpdate) {
            var parent_2 = el.parent;
            while (parent_2) {
              if (parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken || parent_2.for) {
                needsForceUpdate = true;
                break;
              }
              if (parent_2.if) {
                needsKey = true;
              }
              parent_2 = parent_2.parent;
            }
          }
          var generatedSlots = Object.keys(slots).map(function(key) {
            return genScopedSlot(slots[key], state);
          }).join(",");
          return "scopedSlots:_u([".concat(generatedSlots, "]").concat(needsForceUpdate ? ",null,true" : "").concat(!needsForceUpdate && needsKey ? ",null,false,".concat(hash(generatedSlots)) : "", ")");
        }
        function hash(str2) {
          var hash2 = 5381;
          var i = str2.length;
          while (i) {
            hash2 = hash2 * 33 ^ str2.charCodeAt(--i);
          }
          return hash2 >>> 0;
        }
        function containsSlotChild(el) {
          if (el.type === 1) {
            if (el.tag === "slot") {
              return true;
            }
            return el.children.some(containsSlotChild);
          }
          return false;
        }
        function genScopedSlot(el, state) {
          var isLegacySyntax = el.attrsMap["slot-scope"];
          if (el.if && !el.ifProcessed && !isLegacySyntax) {
            return genIf(el, state, genScopedSlot, "null");
          }
          if (el.for && !el.forProcessed) {
            return genFor(el, state, genScopedSlot);
          }
          var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
          var fn = "function(".concat(slotScope, "){") + "return ".concat(el.tag === "template" ? el.if && isLegacySyntax ? "(".concat(el.if, ")?").concat(genChildren(el, state) || "undefined", ":undefined") : genChildren(el, state) || "undefined" : genElement(el, state), "}");
          var reverseProxy = slotScope ? "" : ",proxy:true";
          return "{key:".concat(el.slotTarget || '"default"', ",fn:").concat(fn).concat(reverseProxy, "}");
        }
        function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
          var children = el.children;
          if (children.length) {
            var el_1 = children[0];
            if (children.length === 1 && el_1.for && el_1.tag !== "template" && el_1.tag !== "slot") {
              var normalizationType_1 = checkSkip ? state.maybeComponent(el_1) ? ",1" : ",0" : "";
              return "".concat((altGenElement || genElement)(el_1, state)).concat(normalizationType_1);
            }
            var normalizationType = checkSkip ? getNormalizationType(children, state.maybeComponent) : 0;
            var gen_1 = altGenNode || genNode;
            return "[".concat(children.map(function(c) {
              return gen_1(c, state);
            }).join(","), "]").concat(normalizationType ? ",".concat(normalizationType) : "");
          }
        }
        function getNormalizationType(children, maybeComponent2) {
          var res = 0;
          for (var i = 0; i < children.length; i++) {
            var el = children[i];
            if (el.type !== 1) {
              continue;
            }
            if (needsNormalization(el) || el.ifConditions && el.ifConditions.some(function(c) {
              return needsNormalization(c.block);
            })) {
              res = 2;
              break;
            }
            if (maybeComponent2(el) || el.ifConditions && el.ifConditions.some(function(c) {
              return maybeComponent2(c.block);
            })) {
              res = 1;
            }
          }
          return res;
        }
        function needsNormalization(el) {
          return el.for !== void 0 || el.tag === "template" || el.tag === "slot";
        }
        function genNode(node, state) {
          if (node.type === 1) {
            return genElement(node, state);
          } else if (node.type === 3 && node.isComment) {
            return genComment(node);
          } else {
            return genText(node);
          }
        }
        function genText(text2) {
          return "_v(".concat(text2.type === 2 ? text2.expression : transformSpecialNewlines(JSON.stringify(text2.text)), ")");
        }
        function genComment(comment2) {
          return "_e(".concat(JSON.stringify(comment2.text), ")");
        }
        function genSlot(el, state) {
          var slotName = el.slotName || '"default"';
          var children = genChildren(el, state);
          var res = "_t(".concat(slotName).concat(children ? ",function(){return ".concat(children, "}") : "");
          var attrs3 = el.attrs || el.dynamicAttrs ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function(attr) {
            return {
              // slot props are camelized
              name: camelize2(attr.name),
              value: attr.value,
              dynamic: attr.dynamic
            };
          })) : null;
          var bind3 = el.attrsMap["v-bind"];
          if ((attrs3 || bind3) && !children) {
            res += ",null";
          }
          if (attrs3) {
            res += ",".concat(attrs3);
          }
          if (bind3) {
            res += "".concat(attrs3 ? "" : ",null", ",").concat(bind3);
          }
          return res + ")";
        }
        function genComponent(componentName, el, state) {
          var children = el.inlineTemplate ? null : genChildren(el, state, true);
          return "_c(".concat(componentName, ",").concat(genData(el, state)).concat(children ? ",".concat(children) : "", ")");
        }
        function genProps(props3) {
          var staticProps = "";
          var dynamicProps = "";
          for (var i = 0; i < props3.length; i++) {
            var prop = props3[i];
            var value = transformSpecialNewlines(prop.value);
            if (prop.dynamic) {
              dynamicProps += "".concat(prop.name, ",").concat(value, ",");
            } else {
              staticProps += '"'.concat(prop.name, '":').concat(value, ",");
            }
          }
          staticProps = "{".concat(staticProps.slice(0, -1), "}");
          if (dynamicProps) {
            return "_d(".concat(staticProps, ",[").concat(dynamicProps.slice(0, -1), "])");
          } else {
            return staticProps;
          }
        }
        function transformSpecialNewlines(text2) {
          return text2.replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
        }
        var prohibitedKeywordRE = new RegExp("\\b" + "do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b") + "\\b");
        var unaryOperatorsRE = new RegExp("\\b" + "delete,typeof,void".split(",").join("\\s*\\([^\\)]*\\)|\\b") + "\\s*\\([^\\)]*\\)");
        var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
        function detectErrors(ast, warn3) {
          if (ast) {
            checkNode(ast, warn3);
          }
        }
        function checkNode(node, warn3) {
          if (node.type === 1) {
            for (var name_1 in node.attrsMap) {
              if (dirRE.test(name_1)) {
                var value = node.attrsMap[name_1];
                if (value) {
                  var range2 = node.rawAttrsMap[name_1];
                  if (name_1 === "v-for") {
                    checkFor(node, 'v-for="'.concat(value, '"'), warn3, range2);
                  } else if (name_1 === "v-slot" || name_1[0] === "#") {
                    checkFunctionParameterExpression(value, "".concat(name_1, '="').concat(value, '"'), warn3, range2);
                  } else if (onRE.test(name_1)) {
                    checkEvent(value, "".concat(name_1, '="').concat(value, '"'), warn3, range2);
                  } else {
                    checkExpression(value, "".concat(name_1, '="').concat(value, '"'), warn3, range2);
                  }
                }
              }
            }
            if (node.children) {
              for (var i = 0; i < node.children.length; i++) {
                checkNode(node.children[i], warn3);
              }
            }
          } else if (node.type === 2) {
            checkExpression(node.expression, node.text, warn3, node);
          }
        }
        function checkEvent(exp, text2, warn3, range2) {
          var stripped = exp.replace(stripStringRE, "");
          var keywordMatch = stripped.match(unaryOperatorsRE);
          if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== "$") {
            warn3("avoid using JavaScript unary operator as property name: " + '"'.concat(keywordMatch[0], '" in expression ').concat(text2.trim()), range2);
          }
          checkExpression(exp, text2, warn3, range2);
        }
        function checkFor(node, text2, warn3, range2) {
          checkExpression(node.for || "", text2, warn3, range2);
          checkIdentifier(node.alias, "v-for alias", text2, warn3, range2);
          checkIdentifier(node.iterator1, "v-for iterator", text2, warn3, range2);
          checkIdentifier(node.iterator2, "v-for iterator", text2, warn3, range2);
        }
        function checkIdentifier(ident, type, text2, warn3, range2) {
          if (typeof ident === "string") {
            try {
              new Function("var ".concat(ident, "=_"));
            } catch (e) {
              warn3("invalid ".concat(type, ' "').concat(ident, '" in expression: ').concat(text2.trim()), range2);
            }
          }
        }
        function checkExpression(exp, text2, warn3, range2) {
          try {
            new Function("return ".concat(exp));
          } catch (e) {
            var keywordMatch = exp.replace(stripStringRE, "").match(prohibitedKeywordRE);
            if (keywordMatch) {
              warn3("avoid using JavaScript keyword as property name: " + '"'.concat(keywordMatch[0], '"\n  Raw expression: ').concat(text2.trim()), range2);
            } else {
              warn3("invalid expression: ".concat(e.message, " in\n\n") + "    ".concat(exp, "\n\n") + "  Raw expression: ".concat(text2.trim(), "\n"), range2);
            }
          }
        }
        function checkFunctionParameterExpression(exp, text2, warn3, range2) {
          try {
            new Function(exp, "");
          } catch (e) {
            warn3("invalid function parameter expression: ".concat(e.message, " in\n\n") + "    ".concat(exp, "\n\n") + "  Raw expression: ".concat(text2.trim(), "\n"), range2);
          }
        }
        var range = 2;
        function generateCodeFrame(source, start, end) {
          if (start === void 0) {
            start = 0;
          }
          if (end === void 0) {
            end = source.length;
          }
          var lines = source.split(/\r?\n/);
          var count = 0;
          var res = [];
          for (var i = 0; i < lines.length; i++) {
            count += lines[i].length + 1;
            if (count >= start) {
              for (var j = i - range; j <= i + range || end > count; j++) {
                if (j < 0 || j >= lines.length)
                  continue;
                res.push("".concat(j + 1).concat(repeat2(" ", 3 - String(j + 1).length), "|  ").concat(lines[j]));
                var lineLength = lines[j].length;
                if (j === i) {
                  var pad2 = start - (count - lineLength) + 1;
                  var length_1 = end > count ? lineLength - pad2 : end - start;
                  res.push("   |  " + repeat2(" ", pad2) + repeat2("^", length_1));
                } else if (j > i) {
                  if (end > count) {
                    var length_2 = Math.min(end - count, lineLength);
                    res.push("   |  " + repeat2("^", length_2));
                  }
                  count += lineLength + 1;
                }
              }
              break;
            }
          }
          return res.join("\n");
        }
        function repeat2(str2, n) {
          var result = "";
          if (n > 0) {
            while (true) {
              if (n & 1)
                result += str2;
              n >>>= 1;
              if (n <= 0)
                break;
              str2 += str2;
            }
          }
          return result;
        }
        function createFunction(code, errors) {
          try {
            return new Function(code);
          } catch (err) {
            errors.push({ err, code });
            return noop2;
          }
        }
        function createCompileToFunctionFn(compile) {
          var cache = /* @__PURE__ */ Object.create(null);
          return function compileToFunctions2(template, options, vm) {
            options = extend2({}, options);
            var warn3 = options.warn || warn$2;
            delete options.warn;
            {
              try {
                new Function("return 1");
              } catch (e) {
                if (e.toString().match(/unsafe-eval|CSP/)) {
                  warn3("It seems you are using the standalone build of Vue.js in an environment with Content Security Policy that prohibits unsafe-eval. The template compiler cannot work in this environment. Consider relaxing the policy to allow unsafe-eval or pre-compiling your templates into render functions.");
                }
              }
            }
            var key = options.delimiters ? String(options.delimiters) + template : template;
            if (cache[key]) {
              return cache[key];
            }
            var compiled = compile(template, options);
            {
              if (compiled.errors && compiled.errors.length) {
                if (options.outputSourceRange) {
                  compiled.errors.forEach(function(e) {
                    warn3("Error compiling template:\n\n".concat(e.msg, "\n\n") + generateCodeFrame(template, e.start, e.end), vm);
                  });
                } else {
                  warn3("Error compiling template:\n\n".concat(template, "\n\n") + compiled.errors.map(function(e) {
                    return "- ".concat(e);
                  }).join("\n") + "\n", vm);
                }
              }
              if (compiled.tips && compiled.tips.length) {
                if (options.outputSourceRange) {
                  compiled.tips.forEach(function(e) {
                    return tip(e.msg, vm);
                  });
                } else {
                  compiled.tips.forEach(function(msg) {
                    return tip(msg, vm);
                  });
                }
              }
            }
            var res = {};
            var fnGenErrors = [];
            res.render = createFunction(compiled.render, fnGenErrors);
            res.staticRenderFns = compiled.staticRenderFns.map(function(code) {
              return createFunction(code, fnGenErrors);
            });
            {
              if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
                warn3("Failed to generate render function:\n\n" + fnGenErrors.map(function(_a2) {
                  var err = _a2.err, code = _a2.code;
                  return "".concat(err.toString(), " in\n\n").concat(code, "\n");
                }).join("\n"), vm);
              }
            }
            return cache[key] = res;
          };
        }
        function createCompilerCreator(baseCompile) {
          return function createCompiler2(baseOptions2) {
            function compile(template, options) {
              var finalOptions = Object.create(baseOptions2);
              var errors = [];
              var tips = [];
              var warn3 = function(msg, range2, tip2) {
                (tip2 ? tips : errors).push(msg);
              };
              if (options) {
                if (options.outputSourceRange) {
                  var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
                  warn3 = function(msg, range2, tip2) {
                    var data = typeof msg === "string" ? { msg } : msg;
                    if (range2) {
                      if (range2.start != null) {
                        data.start = range2.start + leadingSpaceLength_1;
                      }
                      if (range2.end != null) {
                        data.end = range2.end + leadingSpaceLength_1;
                      }
                    }
                    (tip2 ? tips : errors).push(data);
                  };
                }
                if (options.modules) {
                  finalOptions.modules = (baseOptions2.modules || []).concat(options.modules);
                }
                if (options.directives) {
                  finalOptions.directives = extend2(Object.create(baseOptions2.directives || null), options.directives);
                }
                for (var key in options) {
                  if (key !== "modules" && key !== "directives") {
                    finalOptions[key] = options[key];
                  }
                }
              }
              finalOptions.warn = warn3;
              var compiled = baseCompile(template.trim(), finalOptions);
              {
                detectErrors(compiled.ast, warn3);
              }
              compiled.errors = errors;
              compiled.tips = tips;
              return compiled;
            }
            return {
              compile,
              compileToFunctions: createCompileToFunctionFn(compile)
            };
          };
        }
        var createCompiler = createCompilerCreator(function baseCompile(template, options) {
          var ast = parse(template.trim(), options);
          if (options.optimize !== false) {
            optimize(ast, options);
          }
          var code = generate(ast, options);
          return {
            ast,
            render: code.render,
            staticRenderFns: code.staticRenderFns
          };
        });
        var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
        var div;
        function getShouldDecode(href) {
          div = div || document.createElement("div");
          div.innerHTML = href ? '<a href="\n"/>' : '<div a="\n"/>';
          return div.innerHTML.indexOf("&#10;") > 0;
        }
        var shouldDecodeNewlines = inBrowser2 ? getShouldDecode(false) : false;
        var shouldDecodeNewlinesForHref = inBrowser2 ? getShouldDecode(true) : false;
        var idToTemplate = cached2(function(id) {
          var el = query2(id);
          return el && el.innerHTML;
        });
        var mount = Vue4.prototype.$mount;
        Vue4.prototype.$mount = function(el, hydrating) {
          el = el && query2(el);
          if (el === document.body || el === document.documentElement) {
            warn$2("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
            return this;
          }
          var options = this.$options;
          if (!options.render) {
            var template = options.template;
            if (template) {
              if (typeof template === "string") {
                if (template.charAt(0) === "#") {
                  template = idToTemplate(template);
                  if (!template) {
                    warn$2("Template element not found or is empty: ".concat(options.template), this);
                  }
                }
              } else if (template.nodeType) {
                template = template.innerHTML;
              } else {
                {
                  warn$2("invalid template option:" + template, this);
                }
                return this;
              }
            } else if (el) {
              template = getOuterHTML(el);
            }
            if (template) {
              if (config2.performance && mark) {
                mark("compile");
              }
              var _a2 = compileToFunctions(template, {
                outputSourceRange: true,
                shouldDecodeNewlines,
                shouldDecodeNewlinesForHref,
                delimiters: options.delimiters,
                comments: options.comments
              }, this), render = _a2.render, staticRenderFns = _a2.staticRenderFns;
              options.render = render;
              options.staticRenderFns = staticRenderFns;
              if (config2.performance && mark) {
                mark("compile end");
                measure("vue ".concat(this._name, " compile"), "compile", "compile end");
              }
            }
          }
          return mount.call(this, el, hydrating);
        };
        function getOuterHTML(el) {
          if (el.outerHTML) {
            return el.outerHTML;
          } else {
            var container = document.createElement("div");
            container.appendChild(el.cloneNode(true));
            return container.innerHTML;
          }
        }
        Vue4.compile = compileToFunctions;
        function effect(fn, scheduler) {
          var watcher = new Watcher2(currentInstance2, fn, noop2, {
            sync: true
          });
          if (scheduler) {
            watcher.update = function() {
              scheduler(function() {
                return watcher.run();
              });
            };
          }
        }
        extend2(Vue4, vca);
        Vue4.effect = effect;
        return Vue4;
      }));
    }
  });

  // node_modules/vue/dist/vue.runtime.esm.js
  var emptyObject = Object.freeze({});
  var isArray = Array.isArray;
  function isUndef(v) {
    return v === void 0 || v === null;
  }
  function isDef(v) {
    return v !== void 0 && v !== null;
  }
  function isTrue(v) {
    return v === true;
  }
  function isFalse(v) {
    return v === false;
  }
  function isPrimitive(value) {
    return typeof value === "string" || typeof value === "number" || // $flow-disable-line
    typeof value === "symbol" || typeof value === "boolean";
  }
  function isFunction(value) {
    return typeof value === "function";
  }
  function isObject(obj) {
    return obj !== null && typeof obj === "object";
  }
  var _toString = Object.prototype.toString;
  function isPlainObject(obj) {
    return _toString.call(obj) === "[object Object]";
  }
  function isRegExp(v) {
    return _toString.call(v) === "[object RegExp]";
  }
  function isValidArrayIndex(val) {
    var n = parseFloat(String(val));
    return n >= 0 && Math.floor(n) === n && isFinite(val);
  }
  function isPromise(val) {
    return isDef(val) && typeof val.then === "function" && typeof val.catch === "function";
  }
  function toString(val) {
    return val == null ? "" : Array.isArray(val) || isPlainObject(val) && val.toString === _toString ? JSON.stringify(val, replacer, 2) : String(val);
  }
  function replacer(_key, val) {
    if (val && val.__v_isRef) {
      return val.value;
    }
    return val;
  }
  function toNumber(val) {
    var n = parseFloat(val);
    return isNaN(n) ? val : n;
  }
  function makeMap(str, expectsLowerCase) {
    var map = /* @__PURE__ */ Object.create(null);
    var list = str.split(",");
    for (var i = 0; i < list.length; i++) {
      map[list[i]] = true;
    }
    return expectsLowerCase ? function(val) {
      return map[val.toLowerCase()];
    } : function(val) {
      return map[val];
    };
  }
  var isBuiltInTag = makeMap("slot,component", true);
  var isReservedAttribute = makeMap("key,ref,slot,slot-scope,is");
  function remove$2(arr, item) {
    var len = arr.length;
    if (len) {
      if (item === arr[len - 1]) {
        arr.length = len - 1;
        return;
      }
      var index3 = arr.indexOf(item);
      if (index3 > -1) {
        return arr.splice(index3, 1);
      }
    }
  }
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  function hasOwn(obj, key) {
    return hasOwnProperty.call(obj, key);
  }
  function cached(fn) {
    var cache = /* @__PURE__ */ Object.create(null);
    return function cachedFn(str) {
      var hit = cache[str];
      return hit || (cache[str] = fn(str));
    };
  }
  var camelizeRE = /-(\w)/g;
  var camelize = cached(function(str) {
    return str.replace(camelizeRE, function(_, c) {
      return c ? c.toUpperCase() : "";
    });
  });
  var capitalize = cached(function(str) {
    return str.charAt(0).toUpperCase() + str.slice(1);
  });
  var hyphenateRE = /\B([A-Z])/g;
  var hyphenate = cached(function(str) {
    return str.replace(hyphenateRE, "-$1").toLowerCase();
  });
  function polyfillBind(fn, ctx) {
    function boundFn(a) {
      var l = arguments.length;
      return l ? l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a) : fn.call(ctx);
    }
    boundFn._length = fn.length;
    return boundFn;
  }
  function nativeBind(fn, ctx) {
    return fn.bind(ctx);
  }
  var bind = Function.prototype.bind ? nativeBind : polyfillBind;
  function toArray(list, start) {
    start = start || 0;
    var i = list.length - start;
    var ret = new Array(i);
    while (i--) {
      ret[i] = list[i + start];
    }
    return ret;
  }
  function extend(to, _from) {
    for (var key in _from) {
      to[key] = _from[key];
    }
    return to;
  }
  function toObject(arr) {
    var res = {};
    for (var i = 0; i < arr.length; i++) {
      if (arr[i]) {
        extend(res, arr[i]);
      }
    }
    return res;
  }
  function noop(a, b, c) {
  }
  var no = function(a, b, c) {
    return false;
  };
  var identity = function(_) {
    return _;
  };
  function looseEqual(a, b) {
    if (a === b)
      return true;
    var isObjectA = isObject(a);
    var isObjectB = isObject(b);
    if (isObjectA && isObjectB) {
      try {
        var isArrayA = Array.isArray(a);
        var isArrayB = Array.isArray(b);
        if (isArrayA && isArrayB) {
          return a.length === b.length && a.every(function(e, i) {
            return looseEqual(e, b[i]);
          });
        } else if (a instanceof Date && b instanceof Date) {
          return a.getTime() === b.getTime();
        } else if (!isArrayA && !isArrayB) {
          var keysA = Object.keys(a);
          var keysB = Object.keys(b);
          return keysA.length === keysB.length && keysA.every(function(key) {
            return looseEqual(a[key], b[key]);
          });
        } else {
          return false;
        }
      } catch (e) {
        return false;
      }
    } else if (!isObjectA && !isObjectB) {
      return String(a) === String(b);
    } else {
      return false;
    }
  }
  function looseIndexOf(arr, val) {
    for (var i = 0; i < arr.length; i++) {
      if (looseEqual(arr[i], val))
        return i;
    }
    return -1;
  }
  function once(fn) {
    var called = false;
    return function() {
      if (!called) {
        called = true;
        fn.apply(this, arguments);
      }
    };
  }
  function hasChanged(x, y) {
    if (x === y) {
      return x === 0 && 1 / x !== 1 / y;
    } else {
      return x === x || y === y;
    }
  }
  var SSR_ATTR = "data-server-rendered";
  var ASSET_TYPES = ["component", "directive", "filter"];
  var LIFECYCLE_HOOKS = [
    "beforeCreate",
    "created",
    "beforeMount",
    "mounted",
    "beforeUpdate",
    "updated",
    "beforeDestroy",
    "destroyed",
    "activated",
    "deactivated",
    "errorCaptured",
    "serverPrefetch",
    "renderTracked",
    "renderTriggered"
  ];
  var config = {
    /**
     * Option merge strategies (used in core/util/options)
     */
    // $flow-disable-line
    optionMergeStrategies: /* @__PURE__ */ Object.create(null),
    /**
     * Whether to suppress warnings.
     */
    silent: false,
    /**
     * Show production mode tip message on boot?
     */
    productionTip: false,
    /**
     * Whether to enable devtools
     */
    devtools: false,
    /**
     * Whether to record perf
     */
    performance: false,
    /**
     * Error handler for watcher errors
     */
    errorHandler: null,
    /**
     * Warn handler for watcher warns
     */
    warnHandler: null,
    /**
     * Ignore certain custom elements
     */
    ignoredElements: [],
    /**
     * Custom user key aliases for v-on
     */
    // $flow-disable-line
    keyCodes: /* @__PURE__ */ Object.create(null),
    /**
     * Check if a tag is reserved so that it cannot be registered as a
     * component. This is platform-dependent and may be overwritten.
     */
    isReservedTag: no,
    /**
     * Check if an attribute is reserved so that it cannot be used as a component
     * prop. This is platform-dependent and may be overwritten.
     */
    isReservedAttr: no,
    /**
     * Check if a tag is an unknown element.
     * Platform-dependent.
     */
    isUnknownElement: no,
    /**
     * Get the namespace of an element
     */
    getTagNamespace: noop,
    /**
     * Parse the real tag name for the specific platform.
     */
    parsePlatformTagName: identity,
    /**
     * Check if an attribute must be bound using property, e.g. value
     * Platform-dependent.
     */
    mustUseProp: no,
    /**
     * Perform updates asynchronously. Intended to be used by Vue Test Utils
     * This will significantly reduce performance if set to false.
     */
    async: true,
    /**
     * Exposed for legacy reasons
     */
    _lifecycleHooks: LIFECYCLE_HOOKS
  };
  var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
  function isReserved(str) {
    var c = (str + "").charCodeAt(0);
    return c === 36 || c === 95;
  }
  function def(obj, key, val, enumerable) {
    Object.defineProperty(obj, key, {
      value: val,
      enumerable: !!enumerable,
      writable: true,
      configurable: true
    });
  }
  var bailRE = new RegExp("[^".concat(unicodeRegExp.source, ".$_\\d]"));
  function parsePath(path) {
    if (bailRE.test(path)) {
      return;
    }
    var segments = path.split(".");
    return function(obj) {
      for (var i = 0; i < segments.length; i++) {
        if (!obj)
          return;
        obj = obj[segments[i]];
      }
      return obj;
    };
  }
  var hasProto = "__proto__" in {};
  var inBrowser = typeof window !== "undefined";
  var UA = inBrowser && window.navigator.userAgent.toLowerCase();
  var isIE = UA && /msie|trident/.test(UA);
  var isIE9 = UA && UA.indexOf("msie 9.0") > 0;
  var isEdge = UA && UA.indexOf("edge/") > 0;
  UA && UA.indexOf("android") > 0;
  var isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);
  UA && /chrome\/\d+/.test(UA) && !isEdge;
  UA && /phantomjs/.test(UA);
  var isFF = UA && UA.match(/firefox\/(\d+)/);
  var nativeWatch = {}.watch;
  var supportsPassive = false;
  if (inBrowser) {
    try {
      opts = {};
      Object.defineProperty(opts, "passive", {
        get: function() {
          supportsPassive = true;
        }
      });
      window.addEventListener("test-passive", null, opts);
    } catch (e) {
    }
  }
  var opts;
  var _isServer;
  var isServerRendering = function() {
    if (_isServer === void 0) {
      if (!inBrowser && typeof global !== "undefined") {
        _isServer = global["process"] && global["process"].env.VUE_ENV === "server";
      } else {
        _isServer = false;
      }
    }
    return _isServer;
  };
  var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
  function isNative(Ctor) {
    return typeof Ctor === "function" && /native code/.test(Ctor.toString());
  }
  var hasSymbol = typeof Symbol !== "undefined" && isNative(Symbol) && typeof Reflect !== "undefined" && isNative(Reflect.ownKeys);
  var _Set;
  if (typeof Set !== "undefined" && isNative(Set)) {
    _Set = Set;
  } else {
    _Set = /** @class */
    (function() {
      function Set2() {
        this.set = /* @__PURE__ */ Object.create(null);
      }
      Set2.prototype.has = function(key) {
        return this.set[key] === true;
      };
      Set2.prototype.add = function(key) {
        this.set[key] = true;
      };
      Set2.prototype.clear = function() {
        this.set = /* @__PURE__ */ Object.create(null);
      };
      return Set2;
    })();
  }
  var currentInstance = null;
  function setCurrentInstance(vm) {
    if (vm === void 0) {
      vm = null;
    }
    if (!vm)
      currentInstance && currentInstance._scope.off();
    currentInstance = vm;
    vm && vm._scope.on();
  }
  var VNode = (
    /** @class */
    (function() {
      function VNode2(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
        this.tag = tag;
        this.data = data;
        this.children = children;
        this.text = text;
        this.elm = elm;
        this.ns = void 0;
        this.context = context;
        this.fnContext = void 0;
        this.fnOptions = void 0;
        this.fnScopeId = void 0;
        this.key = data && data.key;
        this.componentOptions = componentOptions;
        this.componentInstance = void 0;
        this.parent = void 0;
        this.raw = false;
        this.isStatic = false;
        this.isRootInsert = true;
        this.isComment = false;
        this.isCloned = false;
        this.isOnce = false;
        this.asyncFactory = asyncFactory;
        this.asyncMeta = void 0;
        this.isAsyncPlaceholder = false;
      }
      Object.defineProperty(VNode2.prototype, "child", {
        // DEPRECATED: alias for componentInstance for backwards compat.
        /* istanbul ignore next */
        get: function() {
          return this.componentInstance;
        },
        enumerable: false,
        configurable: true
      });
      return VNode2;
    })()
  );
  var createEmptyVNode = function(text) {
    if (text === void 0) {
      text = "";
    }
    var node = new VNode();
    node.text = text;
    node.isComment = true;
    return node;
  };
  function createTextVNode(val) {
    return new VNode(void 0, void 0, void 0, String(val));
  }
  function cloneVNode(vnode) {
    var cloned = new VNode(
      vnode.tag,
      vnode.data,
      // #7975
      // clone children array to avoid mutating original in case of cloning
      // a child.
      vnode.children && vnode.children.slice(),
      vnode.text,
      vnode.elm,
      vnode.context,
      vnode.componentOptions,
      vnode.asyncFactory
    );
    cloned.ns = vnode.ns;
    cloned.isStatic = vnode.isStatic;
    cloned.key = vnode.key;
    cloned.isComment = vnode.isComment;
    cloned.fnContext = vnode.fnContext;
    cloned.fnOptions = vnode.fnOptions;
    cloned.fnScopeId = vnode.fnScopeId;
    cloned.asyncMeta = vnode.asyncMeta;
    cloned.isCloned = true;
    return cloned;
  }
  var uid$2 = 0;
  var pendingCleanupDeps = [];
  var cleanupDeps = function() {
    for (var i = 0; i < pendingCleanupDeps.length; i++) {
      var dep = pendingCleanupDeps[i];
      dep.subs = dep.subs.filter(function(s) {
        return s;
      });
      dep._pending = false;
    }
    pendingCleanupDeps.length = 0;
  };
  var Dep = (
    /** @class */
    (function() {
      function Dep2() {
        this._pending = false;
        this.id = uid$2++;
        this.subs = [];
      }
      Dep2.prototype.addSub = function(sub) {
        this.subs.push(sub);
      };
      Dep2.prototype.removeSub = function(sub) {
        this.subs[this.subs.indexOf(sub)] = null;
        if (!this._pending) {
          this._pending = true;
          pendingCleanupDeps.push(this);
        }
      };
      Dep2.prototype.depend = function(info) {
        if (Dep2.target) {
          Dep2.target.addDep(this);
          if (false) {
            Dep2.target.onTrack(__assign({ effect: Dep2.target }, info));
          }
        }
      };
      Dep2.prototype.notify = function(info) {
        var subs = this.subs.filter(function(s) {
          return s;
        });
        if (false) {
          subs.sort(function(a, b) {
            return a.id - b.id;
          });
        }
        for (var i = 0, l = subs.length; i < l; i++) {
          var sub = subs[i];
          if (false) {
            sub.onTrigger && sub.onTrigger(__assign({ effect: subs[i] }, info));
          }
          sub.update();
        }
      };
      return Dep2;
    })()
  );
  Dep.target = null;
  var targetStack = [];
  function pushTarget(target3) {
    targetStack.push(target3);
    Dep.target = target3;
  }
  function popTarget() {
    targetStack.pop();
    Dep.target = targetStack[targetStack.length - 1];
  }
  var arrayProto = Array.prototype;
  var arrayMethods = Object.create(arrayProto);
  var methodsToPatch = [
    "push",
    "pop",
    "shift",
    "unshift",
    "splice",
    "sort",
    "reverse"
  ];
  methodsToPatch.forEach(function(method) {
    var original = arrayProto[method];
    def(arrayMethods, method, function mutator() {
      var args = [];
      for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
      }
      var result = original.apply(this, args);
      var ob = this.__ob__;
      var inserted;
      switch (method) {
        case "push":
        case "unshift":
          inserted = args;
          break;
        case "splice":
          inserted = args.slice(2);
          break;
      }
      if (inserted)
        ob.observeArray(inserted);
      if (false) {
        ob.dep.notify({
          type: "array mutation",
          target: this,
          key: method
        });
      } else {
        ob.dep.notify();
      }
      return result;
    });
  });
  var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
  var NO_INITIAL_VALUE = {};
  var shouldObserve = true;
  function toggleObserving(value) {
    shouldObserve = value;
  }
  var mockDep = {
    notify: noop,
    depend: noop,
    addSub: noop,
    removeSub: noop
  };
  var Observer = (
    /** @class */
    (function() {
      function Observer2(value, shallow, mock) {
        if (shallow === void 0) {
          shallow = false;
        }
        if (mock === void 0) {
          mock = false;
        }
        this.value = value;
        this.shallow = shallow;
        this.mock = mock;
        this.dep = mock ? mockDep : new Dep();
        this.vmCount = 0;
        def(value, "__ob__", this);
        if (isArray(value)) {
          if (!mock) {
            if (hasProto) {
              value.__proto__ = arrayMethods;
            } else {
              for (var i = 0, l = arrayKeys.length; i < l; i++) {
                var key = arrayKeys[i];
                def(value, key, arrayMethods[key]);
              }
            }
          }
          if (!shallow) {
            this.observeArray(value);
          }
        } else {
          var keys = Object.keys(value);
          for (var i = 0; i < keys.length; i++) {
            var key = keys[i];
            defineReactive(value, key, NO_INITIAL_VALUE, void 0, shallow, mock);
          }
        }
      }
      Observer2.prototype.observeArray = function(value) {
        for (var i = 0, l = value.length; i < l; i++) {
          observe(value[i], false, this.mock);
        }
      };
      return Observer2;
    })()
  );
  function observe(value, shallow, ssrMockReactivity) {
    if (value && hasOwn(value, "__ob__") && value.__ob__ instanceof Observer) {
      return value.__ob__;
    }
    if (shouldObserve && (ssrMockReactivity || !isServerRendering()) && (isArray(value) || isPlainObject(value)) && Object.isExtensible(value) && !value.__v_skip && !isRef(value) && !(value instanceof VNode)) {
      return new Observer(value, shallow, ssrMockReactivity);
    }
  }
  function defineReactive(obj, key, val, customSetter, shallow, mock, observeEvenIfShallow) {
    if (observeEvenIfShallow === void 0) {
      observeEvenIfShallow = false;
    }
    var dep = new Dep();
    var property = Object.getOwnPropertyDescriptor(obj, key);
    if (property && property.configurable === false) {
      return;
    }
    var getter = property && property.get;
    var setter = property && property.set;
    if ((!getter || setter) && (val === NO_INITIAL_VALUE || arguments.length === 2)) {
      val = obj[key];
    }
    var childOb = shallow ? val && val.__ob__ : observe(val, false, mock);
    Object.defineProperty(obj, key, {
      enumerable: true,
      configurable: true,
      get: function reactiveGetter() {
        var value = getter ? getter.call(obj) : val;
        if (Dep.target) {
          if (false) {
            dep.depend({
              target: obj,
              type: "get",
              key
            });
          } else {
            dep.depend();
          }
          if (childOb) {
            childOb.dep.depend();
            if (isArray(value)) {
              dependArray(value);
            }
          }
        }
        return isRef(value) && !shallow ? value.value : value;
      },
      set: function reactiveSetter(newVal) {
        var value = getter ? getter.call(obj) : val;
        if (!hasChanged(value, newVal)) {
          return;
        }
        if (false) {
          customSetter();
        }
        if (setter) {
          setter.call(obj, newVal);
        } else if (getter) {
          return;
        } else if (!shallow && isRef(value) && !isRef(newVal)) {
          value.value = newVal;
          return;
        } else {
          val = newVal;
        }
        childOb = shallow ? newVal && newVal.__ob__ : observe(newVal, false, mock);
        if (false) {
          dep.notify({
            type: "set",
            target: obj,
            key,
            newValue: newVal,
            oldValue: value
          });
        } else {
          dep.notify();
        }
      }
    });
    return dep;
  }
  function set(target3, key, val) {
    if (false) {
      warn("Cannot set reactive property on undefined, null, or primitive value: ".concat(target3));
    }
    if (isReadonly(target3)) {
      return;
    }
    var ob = target3.__ob__;
    if (isArray(target3) && isValidArrayIndex(key)) {
      target3.length = Math.max(target3.length, key);
      target3.splice(key, 1, val);
      if (ob && !ob.shallow && ob.mock) {
        observe(val, false, true);
      }
      return val;
    }
    if (key in target3 && !(key in Object.prototype)) {
      target3[key] = val;
      return val;
    }
    if (target3._isVue || ob && ob.vmCount) {
      return val;
    }
    if (!ob) {
      target3[key] = val;
      return val;
    }
    defineReactive(ob.value, key, val, void 0, ob.shallow, ob.mock);
    if (false) {
      ob.dep.notify({
        type: "add",
        target: target3,
        key,
        newValue: val,
        oldValue: void 0
      });
    } else {
      ob.dep.notify();
    }
    return val;
  }
  function del(target3, key) {
    if (false) {
      warn("Cannot delete reactive property on undefined, null, or primitive value: ".concat(target3));
    }
    if (isArray(target3) && isValidArrayIndex(key)) {
      target3.splice(key, 1);
      return;
    }
    var ob = target3.__ob__;
    if (target3._isVue || ob && ob.vmCount) {
      return;
    }
    if (isReadonly(target3)) {
      return;
    }
    if (!hasOwn(target3, key)) {
      return;
    }
    delete target3[key];
    if (!ob) {
      return;
    }
    if (false) {
      ob.dep.notify({
        type: "delete",
        target: target3,
        key
      });
    } else {
      ob.dep.notify();
    }
  }
  function dependArray(value) {
    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
      e = value[i];
      if (e && e.__ob__) {
        e.__ob__.dep.depend();
      }
      if (isArray(e)) {
        dependArray(e);
      }
    }
  }
  function shallowReactive(target3) {
    makeReactive(target3, true);
    def(target3, "__v_isShallow", true);
    return target3;
  }
  function makeReactive(target3, shallow) {
    if (!isReadonly(target3)) {
      if (false) {
        if (isArray(target3)) {
          warn("Avoid using Array as root value for ".concat(shallow ? "shallowReactive()" : "reactive()", " as it cannot be tracked in watch() or watchEffect(). Use ").concat(shallow ? "shallowRef()" : "ref()", " instead. This is a Vue-2-only limitation."));
        }
        var existingOb = target3 && target3.__ob__;
        if (existingOb && existingOb.shallow !== shallow) {
          warn("Target is already a ".concat(existingOb.shallow ? "" : "non-", "shallow reactive object, and cannot be converted to ").concat(shallow ? "" : "non-", "shallow."));
        }
      }
      var ob = observe(
        target3,
        shallow,
        isServerRendering()
        /* ssr mock reactivity */
      );
      if (false) {
        if (target3 == null || isPrimitive(target3)) {
          warn("value cannot be made reactive: ".concat(String(target3)));
        }
        if (isCollectionType(target3)) {
          warn("Vue 2 does not support reactive collection types such as Map or Set.");
        }
      }
    }
  }
  function isReadonly(value) {
    return !!(value && value.__v_isReadonly);
  }
  function isRef(r) {
    return !!(r && r.__v_isRef === true);
  }
  function proxyWithRefUnwrap(target3, source, key) {
    Object.defineProperty(target3, key, {
      enumerable: true,
      configurable: true,
      get: function() {
        var val = source[key];
        if (isRef(val)) {
          return val.value;
        } else {
          var ob = val && val.__ob__;
          if (ob)
            ob.dep.depend();
          return val;
        }
      },
      set: function(value) {
        var oldValue = source[key];
        if (isRef(oldValue) && !isRef(value)) {
          oldValue.value = value;
        } else {
          source[key] = value;
        }
      }
    });
  }
  var WATCHER = "watcher";
  var WATCHER_CB = "".concat(WATCHER, " callback");
  var WATCHER_GETTER = "".concat(WATCHER, " getter");
  var WATCHER_CLEANUP = "".concat(WATCHER, " cleanup");
  var activeEffectScope;
  var EffectScope = (
    /** @class */
    (function() {
      function EffectScope2(detached) {
        if (detached === void 0) {
          detached = false;
        }
        this.detached = detached;
        this.active = true;
        this.effects = [];
        this.cleanups = [];
        this.parent = activeEffectScope;
        if (!detached && activeEffectScope) {
          this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
        }
      }
      EffectScope2.prototype.run = function(fn) {
        if (this.active) {
          var currentEffectScope = activeEffectScope;
          try {
            activeEffectScope = this;
            return fn();
          } finally {
            activeEffectScope = currentEffectScope;
          }
        } else if (false) {
          warn("cannot run an inactive effect scope.");
        }
      };
      EffectScope2.prototype.on = function() {
        activeEffectScope = this;
      };
      EffectScope2.prototype.off = function() {
        activeEffectScope = this.parent;
      };
      EffectScope2.prototype.stop = function(fromParent) {
        if (this.active) {
          var i = void 0, l = void 0;
          for (i = 0, l = this.effects.length; i < l; i++) {
            this.effects[i].teardown();
          }
          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);
            }
          }
          if (!this.detached && this.parent && !fromParent) {
            var last = this.parent.scopes.pop();
            if (last && last !== this) {
              this.parent.scopes[this.index] = last;
              last.index = this.index;
            }
          }
          this.parent = void 0;
          this.active = false;
        }
      };
      return EffectScope2;
    })()
  );
  function recordEffectScope(effect, scope) {
    if (scope === void 0) {
      scope = activeEffectScope;
    }
    if (scope && scope.active) {
      scope.effects.push(effect);
    }
  }
  function getCurrentScope() {
    return activeEffectScope;
  }
  function resolveProvided(vm) {
    var existing = vm._provided;
    var parentProvides = vm.$parent && vm.$parent._provided;
    if (parentProvides === existing) {
      return vm._provided = Object.create(parentProvides);
    } else {
      return existing;
    }
  }
  var normalizeEvent = cached(function(name) {
    var passive = name.charAt(0) === "&";
    name = passive ? name.slice(1) : name;
    var once2 = name.charAt(0) === "~";
    name = once2 ? name.slice(1) : name;
    var capture = name.charAt(0) === "!";
    name = capture ? name.slice(1) : name;
    return {
      name,
      once: once2,
      capture,
      passive
    };
  });
  function createFnInvoker(fns, vm) {
    function invoker() {
      var fns2 = invoker.fns;
      if (isArray(fns2)) {
        var cloned = fns2.slice();
        for (var i = 0; i < cloned.length; i++) {
          invokeWithErrorHandling(cloned[i], null, arguments, vm, "v-on handler");
        }
      } else {
        return invokeWithErrorHandling(fns2, null, arguments, vm, "v-on handler");
      }
    }
    invoker.fns = fns;
    return invoker;
  }
  function updateListeners(on, oldOn, add2, remove2, createOnceHandler2, vm) {
    var name, cur, old, event;
    for (name in on) {
      cur = on[name];
      old = oldOn[name];
      event = normalizeEvent(name);
      if (isUndef(cur)) {
      } else if (isUndef(old)) {
        if (isUndef(cur.fns)) {
          cur = on[name] = createFnInvoker(cur, vm);
        }
        if (isTrue(event.once)) {
          cur = on[name] = createOnceHandler2(event.name, cur, event.capture);
        }
        add2(event.name, cur, event.capture, event.passive, event.params);
      } else if (cur !== old) {
        old.fns = cur;
        on[name] = old;
      }
    }
    for (name in oldOn) {
      if (isUndef(on[name])) {
        event = normalizeEvent(name);
        remove2(event.name, oldOn[name], event.capture);
      }
    }
  }
  function mergeVNodeHook(def2, hookKey, hook) {
    if (def2 instanceof VNode) {
      def2 = def2.data.hook || (def2.data.hook = {});
    }
    var invoker;
    var oldHook = def2[hookKey];
    function wrappedHook() {
      hook.apply(this, arguments);
      remove$2(invoker.fns, wrappedHook);
    }
    if (isUndef(oldHook)) {
      invoker = createFnInvoker([wrappedHook]);
    } else {
      if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
        invoker = oldHook;
        invoker.fns.push(wrappedHook);
      } else {
        invoker = createFnInvoker([oldHook, wrappedHook]);
      }
    }
    invoker.merged = true;
    def2[hookKey] = invoker;
  }
  function extractPropsFromVNodeData(data, Ctor, tag) {
    var propOptions = Ctor.options.props;
    if (isUndef(propOptions)) {
      return;
    }
    var res = {};
    var attrs2 = data.attrs, props2 = data.props;
    if (isDef(attrs2) || isDef(props2)) {
      for (var key in propOptions) {
        var altKey = hyphenate(key);
        if (false) {
          var keyInLowerCase = key.toLowerCase();
          if (key !== keyInLowerCase && attrs2 && hasOwn(attrs2, keyInLowerCase)) {
            tip('Prop "'.concat(keyInLowerCase, '" is passed to component ') + "".concat(formatComponentName(
              // @ts-expect-error tag is string
              tag || Ctor
            ), ", but the declared prop name is") + ' "'.concat(key, '". ') + "Note that HTML attributes are case-insensitive and camelCased props need to use their kebab-case equivalents when using in-DOM " + 'templates. You should probably use "'.concat(altKey, '" instead of "').concat(key, '".'));
          }
        }
        checkProp(res, props2, key, altKey, true) || checkProp(res, attrs2, key, altKey, false);
      }
    }
    return res;
  }
  function checkProp(res, hash, key, altKey, preserve) {
    if (isDef(hash)) {
      if (hasOwn(hash, key)) {
        res[key] = hash[key];
        if (!preserve) {
          delete hash[key];
        }
        return true;
      } else if (hasOwn(hash, altKey)) {
        res[key] = hash[altKey];
        if (!preserve) {
          delete hash[altKey];
        }
        return true;
      }
    }
    return false;
  }
  function simpleNormalizeChildren(children) {
    for (var i = 0; i < children.length; i++) {
      if (isArray(children[i])) {
        return Array.prototype.concat.apply([], children);
      }
    }
    return children;
  }
  function normalizeChildren(children) {
    return isPrimitive(children) ? [createTextVNode(children)] : isArray(children) ? normalizeArrayChildren(children) : void 0;
  }
  function isTextNode(node) {
    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
  }
  function normalizeArrayChildren(children, nestedIndex) {
    var res = [];
    var i, c, lastIndex, last;
    for (i = 0; i < children.length; i++) {
      c = children[i];
      if (isUndef(c) || typeof c === "boolean")
        continue;
      lastIndex = res.length - 1;
      last = res[lastIndex];
      if (isArray(c)) {
        if (c.length > 0) {
          c = normalizeArrayChildren(c, "".concat(nestedIndex || "", "_").concat(i));
          if (isTextNode(c[0]) && isTextNode(last)) {
            res[lastIndex] = createTextVNode(last.text + c[0].text);
            c.shift();
          }
          res.push.apply(res, c);
        }
      } else if (isPrimitive(c)) {
        if (isTextNode(last)) {
          res[lastIndex] = createTextVNode(last.text + c);
        } else if (c !== "") {
          res.push(createTextVNode(c));
        }
      } else {
        if (isTextNode(c) && isTextNode(last)) {
          res[lastIndex] = createTextVNode(last.text + c.text);
        } else {
          if (isTrue(children._isVList) && isDef(c.tag) && isUndef(c.key) && isDef(nestedIndex)) {
            c.key = "__vlist".concat(nestedIndex, "_").concat(i, "__");
          }
          res.push(c);
        }
      }
    }
    return res;
  }
  function renderList(val, render) {
    var ret = null, i, l, keys, key;
    if (isArray(val) || typeof val === "string") {
      ret = new Array(val.length);
      for (i = 0, l = val.length; i < l; i++) {
        ret[i] = render(val[i], i);
      }
    } else if (typeof val === "number") {
      ret = new Array(val);
      for (i = 0; i < val; i++) {
        ret[i] = render(i + 1, i);
      }
    } else if (isObject(val)) {
      if (hasSymbol && val[Symbol.iterator]) {
        ret = [];
        var iterator = val[Symbol.iterator]();
        var result = iterator.next();
        while (!result.done) {
          ret.push(render(result.value, ret.length));
          result = iterator.next();
        }
      } else {
        keys = Object.keys(val);
        ret = new Array(keys.length);
        for (i = 0, l = keys.length; i < l; i++) {
          key = keys[i];
          ret[i] = render(val[key], key, i);
        }
      }
    }
    if (!isDef(ret)) {
      ret = [];
    }
    ret._isVList = true;
    return ret;
  }
  function renderSlot(name, fallbackRender, props2, bindObject) {
    var scopedSlotFn = this.$scopedSlots[name];
    var nodes;
    if (scopedSlotFn) {
      props2 = props2 || {};
      if (bindObject) {
        if (false) {
          warn("slot v-bind without argument expects an Object", this);
        }
        props2 = extend(extend({}, bindObject), props2);
      }
      nodes = scopedSlotFn(props2) || (isFunction(fallbackRender) ? fallbackRender() : fallbackRender);
    } else {
      nodes = this.$slots[name] || (isFunction(fallbackRender) ? fallbackRender() : fallbackRender);
    }
    var target3 = props2 && props2.slot;
    if (target3) {
      return this.$createElement("template", { slot: target3 }, nodes);
    } else {
      return nodes;
    }
  }
  function resolveFilter(id) {
    return resolveAsset(this.$options, "filters", id, true) || identity;
  }
  function isKeyNotMatch(expect, actual) {
    if (isArray(expect)) {
      return expect.indexOf(actual) === -1;
    } else {
      return expect !== actual;
    }
  }
  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
      return isKeyNotMatch(builtInKeyName, eventKeyName);
    } else if (mappedKeyCode) {
      return isKeyNotMatch(mappedKeyCode, eventKeyCode);
    } else if (eventKeyName) {
      return hyphenate(eventKeyName) !== key;
    }
    return eventKeyCode === void 0;
  }
  function bindObjectProps(data, tag, value, asProp, isSync) {
    if (value) {
      if (!isObject(value)) {
      } else {
        if (isArray(value)) {
          value = toObject(value);
        }
        var hash = void 0;
        var _loop_1 = function(key2) {
          if (key2 === "class" || key2 === "style" || isReservedAttribute(key2)) {
            hash = data;
          } else {
            var type = data.attrs && data.attrs.type;
            hash = asProp || config.mustUseProp(tag, type, key2) ? data.domProps || (data.domProps = {}) : data.attrs || (data.attrs = {});
          }
          var camelizedKey = camelize(key2);
          var hyphenatedKey = hyphenate(key2);
          if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
            hash[key2] = value[key2];
            if (isSync) {
              var on = data.on || (data.on = {});
              on["update:".concat(key2)] = function($event) {
                value[key2] = $event;
              };
            }
          }
        };
        for (var key in value) {
          _loop_1(key);
        }
      }
    }
    return data;
  }
  function renderStatic(index3, isInFor) {
    var cached2 = this._staticTrees || (this._staticTrees = []);
    var tree = cached2[index3];
    if (tree && !isInFor) {
      return tree;
    }
    tree = cached2[index3] = this.$options.staticRenderFns[index3].call(
      this._renderProxy,
      this._c,
      this
      // for render fns generated for functional component templates
    );
    markStatic(tree, "__static__".concat(index3), false);
    return tree;
  }
  function markOnce(tree, index3, key) {
    markStatic(tree, "__once__".concat(index3).concat(key ? "_".concat(key) : ""), true);
    return tree;
  }
  function markStatic(tree, key, isOnce) {
    if (isArray(tree)) {
      for (var i = 0; i < tree.length; i++) {
        if (tree[i] && typeof tree[i] !== "string") {
          markStaticNode(tree[i], "".concat(key, "_").concat(i), isOnce);
        }
      }
    } else {
      markStaticNode(tree, key, isOnce);
    }
  }
  function markStaticNode(node, key, isOnce) {
    node.isStatic = true;
    node.key = key;
    node.isOnce = isOnce;
  }
  function bindObjectListeners(data, value) {
    if (value) {
      if (!isPlainObject(value)) {
      } else {
        var on = data.on = data.on ? extend({}, data.on) : {};
        for (var key in value) {
          var existing = on[key];
          var ours = value[key];
          on[key] = existing ? [].concat(existing, ours) : ours;
        }
      }
    }
    return data;
  }
  function resolveScopedSlots(fns, res, hasDynamicKeys, contentHashKey) {
    res = res || { $stable: !hasDynamicKeys };
    for (var i = 0; i < fns.length; i++) {
      var slot = fns[i];
      if (isArray(slot)) {
        resolveScopedSlots(slot, res, hasDynamicKeys);
      } else if (slot) {
        if (slot.proxy) {
          slot.fn.proxy = true;
        }
        res[slot.key] = slot.fn;
      }
    }
    if (contentHashKey) {
      res.$key = contentHashKey;
    }
    return res;
  }
  function bindDynamicKeys(baseObj, values) {
    for (var i = 0; i < values.length; i += 2) {
      var key = values[i];
      if (typeof key === "string" && key) {
        baseObj[values[i]] = values[i + 1];
      } else if (false) {
        warn("Invalid value for dynamic directive argument (expected string or null): ".concat(key), this);
      }
    }
    return baseObj;
  }
  function prependModifier(value, symbol) {
    return typeof value === "string" ? symbol + value : value;
  }
  function installRenderHelpers(target3) {
    target3._o = markOnce;
    target3._n = toNumber;
    target3._s = toString;
    target3._l = renderList;
    target3._t = renderSlot;
    target3._q = looseEqual;
    target3._i = looseIndexOf;
    target3._m = renderStatic;
    target3._f = resolveFilter;
    target3._k = checkKeyCodes;
    target3._b = bindObjectProps;
    target3._v = createTextVNode;
    target3._e = createEmptyVNode;
    target3._u = resolveScopedSlots;
    target3._g = bindObjectListeners;
    target3._d = bindDynamicKeys;
    target3._p = prependModifier;
  }
  function resolveSlots(children, context) {
    if (!children || !children.length) {
      return {};
    }
    var slots = {};
    for (var i = 0, l = children.length; i < l; i++) {
      var child = children[i];
      var data = child.data;
      if (data && data.attrs && data.attrs.slot) {
        delete data.attrs.slot;
      }
      if ((child.context === context || child.fnContext === context) && data && data.slot != null) {
        var name_1 = data.slot;
        var slot = slots[name_1] || (slots[name_1] = []);
        if (child.tag === "template") {
          slot.push.apply(slot, child.children || []);
        } else {
          slot.push(child);
        }
      } else {
        (slots.default || (slots.default = [])).push(child);
      }
    }
    for (var name_2 in slots) {
      if (slots[name_2].every(isWhitespace)) {
        delete slots[name_2];
      }
    }
    return slots;
  }
  function isWhitespace(node) {
    return node.isComment && !node.asyncFactory || node.text === " ";
  }
  function isAsyncPlaceholder(node) {
    return node.isComment && node.asyncFactory;
  }
  function normalizeScopedSlots(ownerVm, scopedSlots, normalSlots, prevScopedSlots) {
    var res;
    var hasNormalSlots = Object.keys(normalSlots).length > 0;
    var isStable = scopedSlots ? !!scopedSlots.$stable : !hasNormalSlots;
    var key = scopedSlots && scopedSlots.$key;
    if (!scopedSlots) {
      res = {};
    } else if (scopedSlots._normalized) {
      return scopedSlots._normalized;
    } else if (isStable && prevScopedSlots && prevScopedSlots !== emptyObject && key === prevScopedSlots.$key && !hasNormalSlots && !prevScopedSlots.$hasNormal) {
      return prevScopedSlots;
    } else {
      res = {};
      for (var key_1 in scopedSlots) {
        if (scopedSlots[key_1] && key_1[0] !== "$") {
          res[key_1] = normalizeScopedSlot(ownerVm, normalSlots, key_1, scopedSlots[key_1]);
        }
      }
    }
    for (var key_2 in normalSlots) {
      if (!(key_2 in res)) {
        res[key_2] = proxyNormalSlot(normalSlots, key_2);
      }
    }
    if (scopedSlots && Object.isExtensible(scopedSlots)) {
      scopedSlots._normalized = res;
    }
    def(res, "$stable", isStable);
    def(res, "$key", key);
    def(res, "$hasNormal", hasNormalSlots);
    return res;
  }
  function normalizeScopedSlot(vm, normalSlots, key, fn) {
    var normalized = function() {
      var cur = currentInstance;
      setCurrentInstance(vm);
      var res = arguments.length ? fn.apply(null, arguments) : fn({});
      res = res && typeof res === "object" && !isArray(res) ? [res] : normalizeChildren(res);
      var vnode = res && res[0];
      setCurrentInstance(cur);
      return res && (!vnode || res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode)) ? void 0 : res;
    };
    if (fn.proxy) {
      Object.defineProperty(normalSlots, key, {
        get: normalized,
        enumerable: true,
        configurable: true
      });
    }
    return normalized;
  }
  function proxyNormalSlot(slots, key) {
    return function() {
      return slots[key];
    };
  }
  function initSetup(vm) {
    var options = vm.$options;
    var setup = options.setup;
    if (setup) {
      var ctx = vm._setupContext = createSetupContext(vm);
      setCurrentInstance(vm);
      pushTarget();
      var setupResult = invokeWithErrorHandling(setup, null, [vm._props || shallowReactive({}), ctx], vm, "setup");
      popTarget();
      setCurrentInstance();
      if (isFunction(setupResult)) {
        options.render = setupResult;
      } else if (isObject(setupResult)) {
        if (false) {
          warn("setup() should not return VNodes directly - return a render function instead.");
        }
        vm._setupState = setupResult;
        if (!setupResult.__sfc) {
          for (var key in setupResult) {
            if (!isReserved(key)) {
              proxyWithRefUnwrap(vm, setupResult, key);
            } else if (false) {
              warn("Avoid using variables that start with _ or $ in setup().");
            }
          }
        } else {
          var proxy2 = vm._setupProxy = {};
          for (var key in setupResult) {
            if (key !== "__sfc") {
              proxyWithRefUnwrap(proxy2, setupResult, key);
            }
          }
        }
      } else if (false) {
        warn("setup() should return an object. Received: ".concat(setupResult === null ? "null" : typeof setupResult));
      }
    }
  }
  function createSetupContext(vm) {
    var exposeCalled = false;
    return {
      get attrs() {
        if (!vm._attrsProxy) {
          var proxy2 = vm._attrsProxy = {};
          def(proxy2, "_v_attr_proxy", true);
          syncSetupProxy(proxy2, vm.$attrs, emptyObject, vm, "$attrs");
        }
        return vm._attrsProxy;
      },
      get listeners() {
        if (!vm._listenersProxy) {
          var proxy2 = vm._listenersProxy = {};
          syncSetupProxy(proxy2, vm.$listeners, emptyObject, vm, "$listeners");
        }
        return vm._listenersProxy;
      },
      get slots() {
        return initSlotsProxy(vm);
      },
      emit: bind(vm.$emit, vm),
      expose: function(exposed) {
        if (false) {
          if (exposeCalled) {
            warn("expose() should be called only once per setup().", vm);
          }
          exposeCalled = true;
        }
        if (exposed) {
          Object.keys(exposed).forEach(function(key) {
            return proxyWithRefUnwrap(vm, exposed, key);
          });
        }
      }
    };
  }
  function syncSetupProxy(to, from, prev, instance, type) {
    var changed = false;
    for (var key in from) {
      if (!(key in to)) {
        changed = true;
        defineProxyAttr(to, key, instance, type);
      } else if (from[key] !== prev[key]) {
        changed = true;
      }
    }
    for (var key in to) {
      if (!(key in from)) {
        changed = true;
        delete to[key];
      }
    }
    return changed;
  }
  function defineProxyAttr(proxy2, key, instance, type) {
    Object.defineProperty(proxy2, key, {
      enumerable: true,
      configurable: true,
      get: function() {
        return instance[type][key];
      }
    });
  }
  function initSlotsProxy(vm) {
    if (!vm._slotsProxy) {
      syncSetupSlots(vm._slotsProxy = {}, vm.$scopedSlots);
    }
    return vm._slotsProxy;
  }
  function syncSetupSlots(to, from) {
    for (var key in from) {
      to[key] = from[key];
    }
    for (var key in to) {
      if (!(key in from)) {
        delete to[key];
      }
    }
  }
  function initRender(vm) {
    vm._vnode = null;
    vm._staticTrees = null;
    var options = vm.$options;
    var parentVnode = vm.$vnode = options._parentVnode;
    var renderContext = parentVnode && parentVnode.context;
    vm.$slots = resolveSlots(options._renderChildren, renderContext);
    vm.$scopedSlots = parentVnode ? normalizeScopedSlots(vm.$parent, parentVnode.data.scopedSlots, vm.$slots) : emptyObject;
    vm._c = function(a, b, c, d) {
      return createElement$1(vm, a, b, c, d, false);
    };
    vm.$createElement = function(a, b, c, d) {
      return createElement$1(vm, a, b, c, d, true);
    };
    var parentData = parentVnode && parentVnode.data;
    if (false) {
      defineReactive(vm, "$attrs", parentData && parentData.attrs || emptyObject, function() {
        !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
      }, true);
      defineReactive(vm, "$listeners", options._parentListeners || emptyObject, function() {
        !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
      }, true);
    } else {
      defineReactive(vm, "$attrs", parentData && parentData.attrs || emptyObject, null, true);
      defineReactive(vm, "$listeners", options._parentListeners || emptyObject, null, true);
    }
  }
  var currentRenderingInstance = null;
  function renderMixin(Vue4) {
    installRenderHelpers(Vue4.prototype);
    Vue4.prototype.$nextTick = function(fn) {
      return nextTick(fn, this);
    };
    Vue4.prototype._render = function() {
      var vm = this;
      var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
      if (_parentVnode && vm._isMounted) {
        vm.$scopedSlots = normalizeScopedSlots(vm.$parent, _parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
        if (vm._slotsProxy) {
          syncSetupSlots(vm._slotsProxy, vm.$scopedSlots);
        }
      }
      vm.$vnode = _parentVnode;
      var prevInst = currentInstance;
      var prevRenderInst = currentRenderingInstance;
      var vnode;
      try {
        setCurrentInstance(vm);
        currentRenderingInstance = vm;
        vnode = render.call(vm._renderProxy, vm.$createElement);
      } catch (e) {
        handleError(e, vm, "render");
        if (false) {
          try {
            vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
          } catch (e2) {
            handleError(e2, vm, "renderError");
            vnode = vm._vnode;
          }
        } else {
          vnode = vm._vnode;
        }
      } finally {
        currentRenderingInstance = prevRenderInst;
        setCurrentInstance(prevInst);
      }
      if (isArray(vnode) && vnode.length === 1) {
        vnode = vnode[0];
      }
      if (!(vnode instanceof VNode)) {
        if (false) {
          warn("Multiple root nodes returned from render function. Render function should return a single root node.", vm);
        }
        vnode = createEmptyVNode();
      }
      vnode.parent = _parentVnode;
      return vnode;
    };
  }
  function ensureCtor(comp, base) {
    if (comp.__esModule || hasSymbol && comp[Symbol.toStringTag] === "Module") {
      comp = comp.default;
    }
    return isObject(comp) ? base.extend(comp) : comp;
  }
  function createAsyncPlaceholder(factory, data, context, children, tag) {
    var node = createEmptyVNode();
    node.asyncFactory = factory;
    node.asyncMeta = { data, context, children, tag };
    return node;
  }
  function resolveAsyncComponent(factory, baseCtor) {
    if (isTrue(factory.error) && isDef(factory.errorComp)) {
      return factory.errorComp;
    }
    if (isDef(factory.resolved)) {
      return factory.resolved;
    }
    var owner = currentRenderingInstance;
    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
      factory.owners.push(owner);
    }
    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
      return factory.loadingComp;
    }
    if (owner && !isDef(factory.owners)) {
      var owners_1 = factory.owners = [owner];
      var sync_1 = true;
      var timerLoading_1 = null;
      var timerTimeout_1 = null;
      owner.$on("hook:destroyed", function() {
        return remove$2(owners_1, owner);
      });
      var forceRender_1 = function(renderCompleted) {
        for (var i = 0, l = owners_1.length; i < l; i++) {
          owners_1[i].$forceUpdate();
        }
        if (renderCompleted) {
          owners_1.length = 0;
          if (timerLoading_1 !== null) {
            clearTimeout(timerLoading_1);
            timerLoading_1 = null;
          }
          if (timerTimeout_1 !== null) {
            clearTimeout(timerTimeout_1);
            timerTimeout_1 = null;
          }
        }
      };
      var resolve = once(function(res) {
        factory.resolved = ensureCtor(res, baseCtor);
        if (!sync_1) {
          forceRender_1(true);
        } else {
          owners_1.length = 0;
        }
      });
      var reject_1 = once(function(reason) {
        if (isDef(factory.errorComp)) {
          factory.error = true;
          forceRender_1(true);
        }
      });
      var res_1 = factory(resolve, reject_1);
      if (isObject(res_1)) {
        if (isPromise(res_1)) {
          if (isUndef(factory.resolved)) {
            res_1.then(resolve, reject_1);
          }
        } else if (isPromise(res_1.component)) {
          res_1.component.then(resolve, reject_1);
          if (isDef(res_1.error)) {
            factory.errorComp = ensureCtor(res_1.error, baseCtor);
          }
          if (isDef(res_1.loading)) {
            factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
            if (res_1.delay === 0) {
              factory.loading = true;
            } else {
              timerLoading_1 = setTimeout(function() {
                timerLoading_1 = null;
                if (isUndef(factory.resolved) && isUndef(factory.error)) {
                  factory.loading = true;
                  forceRender_1(false);
                }
              }, res_1.delay || 200);
            }
          }
          if (isDef(res_1.timeout)) {
            timerTimeout_1 = setTimeout(function() {
              timerTimeout_1 = null;
              if (isUndef(factory.resolved)) {
                reject_1(false ? "timeout (".concat(res_1.timeout, "ms)") : null);
              }
            }, res_1.timeout);
          }
        }
      }
      sync_1 = false;
      return factory.loading ? factory.loadingComp : factory.resolved;
    }
  }
  function getFirstComponentChild(children) {
    if (isArray(children)) {
      for (var i = 0; i < children.length; i++) {
        var c = children[i];
        if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
          return c;
        }
      }
    }
  }
  var SIMPLE_NORMALIZE = 1;
  var ALWAYS_NORMALIZE = 2;
  function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
    if (isArray(data) || isPrimitive(data)) {
      normalizationType = children;
      children = data;
      data = void 0;
    }
    if (isTrue(alwaysNormalize)) {
      normalizationType = ALWAYS_NORMALIZE;
    }
    return _createElement(context, tag, data, children, normalizationType);
  }
  function _createElement(context, tag, data, children, normalizationType) {
    if (isDef(data) && isDef(data.__ob__)) {
      return createEmptyVNode();
    }
    if (isDef(data) && isDef(data.is)) {
      tag = data.is;
    }
    if (!tag) {
      return createEmptyVNode();
    }
    if (false) {
      warn("Avoid using non-primitive value as key, use string/number value instead.", context);
    }
    if (isArray(children) && isFunction(children[0])) {
      data = data || {};
      data.scopedSlots = { default: children[0] };
      children.length = 0;
    }
    if (normalizationType === ALWAYS_NORMALIZE) {
      children = normalizeChildren(children);
    } else if (normalizationType === SIMPLE_NORMALIZE) {
      children = simpleNormalizeChildren(children);
    }
    var vnode, ns;
    if (typeof tag === "string") {
      var Ctor = void 0;
      ns = context.$vnode && context.$vnode.ns || config.getTagNamespace(tag);
      if (config.isReservedTag(tag)) {
        if (false) {
          warn("The .native modifier for v-on is only valid on components but it was used on <".concat(tag, ">."), context);
        }
        vnode = new VNode(config.parsePlatformTagName(tag), data, children, void 0, void 0, context);
      } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, "components", tag))) {
        vnode = createComponent(Ctor, data, context, children, tag);
      } else {
        vnode = new VNode(tag, data, children, void 0, void 0, context);
      }
    } else {
      vnode = createComponent(tag, data, context, children);
    }
    if (isArray(vnode)) {
      return vnode;
    } else if (isDef(vnode)) {
      if (isDef(ns))
        applyNS(vnode, ns);
      if (isDef(data))
        registerDeepBindings(data);
      return vnode;
    } else {
      return createEmptyVNode();
    }
  }
  function applyNS(vnode, ns, force) {
    vnode.ns = ns;
    if (vnode.tag === "foreignObject") {
      ns = void 0;
      force = true;
    }
    if (isDef(vnode.children)) {
      for (var i = 0, l = vnode.children.length; i < l; i++) {
        var child = vnode.children[i];
        if (isDef(child.tag) && (isUndef(child.ns) || isTrue(force) && child.tag !== "svg")) {
          applyNS(child, ns, force);
        }
      }
    }
  }
  function registerDeepBindings(data) {
    if (isObject(data.style)) {
      traverse(data.style);
    }
    if (isObject(data.class)) {
      traverse(data.class);
    }
  }
  function handleError(err, vm, info) {
    pushTarget();
    try {
      if (vm) {
        var cur = vm;
        while (cur = cur.$parent) {
          var hooks2 = cur.$options.errorCaptured;
          if (hooks2) {
            for (var i = 0; i < hooks2.length; i++) {
              try {
                var capture = hooks2[i].call(cur, err, vm, info) === false;
                if (capture)
                  return;
              } catch (e) {
                globalHandleError(e, cur, "errorCaptured hook");
              }
            }
          }
        }
      }
      globalHandleError(err, vm, info);
    } finally {
      popTarget();
    }
  }
  function invokeWithErrorHandling(handler, context, args, vm, info) {
    var res;
    try {
      res = args ? handler.apply(context, args) : handler.call(context);
      if (res && !res._isVue && isPromise(res) && !res._handled) {
        res.catch(function(e) {
          return handleError(e, vm, info + " (Promise/async)");
        });
        res._handled = true;
      }
    } catch (e) {
      handleError(e, vm, info);
    }
    return res;
  }
  function globalHandleError(err, vm, info) {
    if (config.errorHandler) {
      try {
        return config.errorHandler.call(null, err, vm, info);
      } catch (e) {
        if (e !== err) {
          logError(e, null, "config.errorHandler");
        }
      }
    }
    logError(err, vm, info);
  }
  function logError(err, vm, info) {
    if (false) {
      warn("Error in ".concat(info, ': "').concat(err.toString(), '"'), vm);
    }
    if (inBrowser && typeof console !== "undefined") {
      console.error(err);
    } else {
      throw err;
    }
  }
  var isUsingMicroTask = false;
  var callbacks = [];
  var pending = false;
  function flushCallbacks() {
    pending = false;
    var copies = callbacks.slice(0);
    callbacks.length = 0;
    for (var i = 0; i < copies.length; i++) {
      copies[i]();
    }
  }
  var timerFunc;
  if (typeof Promise !== "undefined" && isNative(Promise)) {
    p_1 = Promise.resolve();
    timerFunc = function() {
      p_1.then(flushCallbacks);
      if (isIOS)
        setTimeout(noop);
    };
    isUsingMicroTask = true;
  } else if (!isIE && typeof MutationObserver !== "undefined" && (isNative(MutationObserver) || // PhantomJS and iOS 7.x
  MutationObserver.toString() === "[object MutationObserverConstructor]")) {
    counter_1 = 1;
    observer = new MutationObserver(flushCallbacks);
    textNode_1 = document.createTextNode(String(counter_1));
    observer.observe(textNode_1, {
      characterData: true
    });
    timerFunc = function() {
      counter_1 = (counter_1 + 1) % 2;
      textNode_1.data = String(counter_1);
    };
    isUsingMicroTask = true;
  } else if (typeof setImmediate !== "undefined" && isNative(setImmediate)) {
    timerFunc = function() {
      setImmediate(flushCallbacks);
    };
  } else {
    timerFunc = function() {
      setTimeout(flushCallbacks, 0);
    };
  }
  var p_1;
  var counter_1;
  var observer;
  var textNode_1;
  function nextTick(cb, ctx) {
    var _resolve;
    callbacks.push(function() {
      if (cb) {
        try {
          cb.call(ctx);
        } catch (e) {
          handleError(e, ctx, "nextTick");
        }
      } else if (_resolve) {
        _resolve(ctx);
      }
    });
    if (!pending) {
      pending = true;
      timerFunc();
    }
    if (!cb && typeof Promise !== "undefined") {
      return new Promise(function(resolve) {
        _resolve = resolve;
      });
    }
  }
  function createLifeCycle(hookName) {
    return function(fn, target3) {
      if (target3 === void 0) {
        target3 = currentInstance;
      }
      if (!target3) {
        return;
      }
      return injectHook(target3, hookName, fn);
    };
  }
  function injectHook(instance, hookName, fn) {
    var options = instance.$options;
    options[hookName] = mergeLifecycleHook(options[hookName], fn);
  }
  var onBeforeMount = createLifeCycle("beforeMount");
  var onMounted = createLifeCycle("mounted");
  var onBeforeUpdate = createLifeCycle("beforeUpdate");
  var onUpdated = createLifeCycle("updated");
  var onBeforeUnmount = createLifeCycle("beforeDestroy");
  var onUnmounted = createLifeCycle("destroyed");
  var onActivated = createLifeCycle("activated");
  var onDeactivated = createLifeCycle("deactivated");
  var onServerPrefetch = createLifeCycle("serverPrefetch");
  var onRenderTracked = createLifeCycle("renderTracked");
  var onRenderTriggered = createLifeCycle("renderTriggered");
  var injectErrorCapturedHook = createLifeCycle("errorCaptured");
  var version = "2.7.16";
  var seenObjects = new _Set();
  function traverse(val) {
    _traverse(val, seenObjects);
    seenObjects.clear();
    return val;
  }
  function _traverse(val, seen) {
    var i, keys;
    var isA = isArray(val);
    if (!isA && !isObject(val) || val.__v_skip || Object.isFrozen(val) || val instanceof VNode) {
      return;
    }
    if (val.__ob__) {
      var depId = val.__ob__.dep.id;
      if (seen.has(depId)) {
        return;
      }
      seen.add(depId);
    }
    if (isA) {
      i = val.length;
      while (i--)
        _traverse(val[i], seen);
    } else if (isRef(val)) {
      _traverse(val.value, seen);
    } else {
      keys = Object.keys(val);
      i = keys.length;
      while (i--)
        _traverse(val[keys[i]], seen);
    }
  }
  var uid$1 = 0;
  var Watcher = (
    /** @class */
    (function() {
      function Watcher2(vm, expOrFn, cb, options, isRenderWatcher) {
        recordEffectScope(
          this,
          // if the active effect scope is manually created (not a component scope),
          // prioritize it
          activeEffectScope && !activeEffectScope._vm ? activeEffectScope : vm ? vm._scope : void 0
        );
        if ((this.vm = vm) && isRenderWatcher) {
          vm._watcher = this;
        }
        if (options) {
          this.deep = !!options.deep;
          this.user = !!options.user;
          this.lazy = !!options.lazy;
          this.sync = !!options.sync;
          this.before = options.before;
          if (false) {
            this.onTrack = options.onTrack;
            this.onTrigger = options.onTrigger;
          }
        } else {
          this.deep = this.user = this.lazy = this.sync = false;
        }
        this.cb = cb;
        this.id = ++uid$1;
        this.active = true;
        this.post = false;
        this.dirty = this.lazy;
        this.deps = [];
        this.newDeps = [];
        this.depIds = new _Set();
        this.newDepIds = new _Set();
        this.expression = false ? expOrFn.toString() : "";
        if (isFunction(expOrFn)) {
          this.getter = expOrFn;
        } else {
          this.getter = parsePath(expOrFn);
          if (!this.getter) {
            this.getter = noop;
          }
        }
        this.value = this.lazy ? void 0 : this.get();
      }
      Watcher2.prototype.get = function() {
        pushTarget(this);
        var value;
        var vm = this.vm;
        try {
          value = this.getter.call(vm, vm);
        } catch (e) {
          if (this.user) {
            handleError(e, vm, 'getter for watcher "'.concat(this.expression, '"'));
          } else {
            throw e;
          }
        } finally {
          if (this.deep) {
            traverse(value);
          }
          popTarget();
          this.cleanupDeps();
        }
        return value;
      };
      Watcher2.prototype.addDep = function(dep) {
        var id = dep.id;
        if (!this.newDepIds.has(id)) {
          this.newDepIds.add(id);
          this.newDeps.push(dep);
          if (!this.depIds.has(id)) {
            dep.addSub(this);
          }
        }
      };
      Watcher2.prototype.cleanupDeps = function() {
        var i = this.deps.length;
        while (i--) {
          var dep = this.deps[i];
          if (!this.newDepIds.has(dep.id)) {
            dep.removeSub(this);
          }
        }
        var tmp = this.depIds;
        this.depIds = this.newDepIds;
        this.newDepIds = tmp;
        this.newDepIds.clear();
        tmp = this.deps;
        this.deps = this.newDeps;
        this.newDeps = tmp;
        this.newDeps.length = 0;
      };
      Watcher2.prototype.update = function() {
        if (this.lazy) {
          this.dirty = true;
        } else if (this.sync) {
          this.run();
        } else {
          queueWatcher(this);
        }
      };
      Watcher2.prototype.run = function() {
        if (this.active) {
          var value = this.get();
          if (value !== this.value || // Deep watchers and watchers on Object/Arrays should fire even
          // when the value is the same, because the value may
          // have mutated.
          isObject(value) || this.deep) {
            var oldValue = this.value;
            this.value = value;
            if (this.user) {
              var info = 'callback for watcher "'.concat(this.expression, '"');
              invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
            } else {
              this.cb.call(this.vm, value, oldValue);
            }
          }
        }
      };
      Watcher2.prototype.evaluate = function() {
        this.value = this.get();
        this.dirty = false;
      };
      Watcher2.prototype.depend = function() {
        var i = this.deps.length;
        while (i--) {
          this.deps[i].depend();
        }
      };
      Watcher2.prototype.teardown = function() {
        if (this.vm && !this.vm._isBeingDestroyed) {
          remove$2(this.vm._scope.effects, this);
        }
        if (this.active) {
          var i = this.deps.length;
          while (i--) {
            this.deps[i].removeSub(this);
          }
          this.active = false;
          if (this.onStop) {
            this.onStop();
          }
        }
      };
      return Watcher2;
    })()
  );
  if (false) {
    perf_1 = inBrowser && window.performance;
    if (perf_1 && // @ts-ignore
    perf_1.mark && // @ts-ignore
    perf_1.measure && // @ts-ignore
    perf_1.clearMarks && // @ts-ignore
    perf_1.clearMeasures) {
      mark = function(tag) {
        return perf_1.mark(tag);
      };
      measure = function(name, startTag, endTag) {
        perf_1.measure(name, startTag, endTag);
        perf_1.clearMarks(startTag);
        perf_1.clearMarks(endTag);
      };
    }
  }
  var perf_1;
  function initEvents(vm) {
    vm._events = /* @__PURE__ */ Object.create(null);
    vm._hasHookEvent = false;
    var listeners = vm.$options._parentListeners;
    if (listeners) {
      updateComponentListeners(vm, listeners);
    }
  }
  var target$1;
  function add$1(event, fn) {
    target$1.$on(event, fn);
  }
  function remove$1(event, fn) {
    target$1.$off(event, fn);
  }
  function createOnceHandler$1(event, fn) {
    var _target = target$1;
    return function onceHandler() {
      var res = fn.apply(null, arguments);
      if (res !== null) {
        _target.$off(event, onceHandler);
      }
    };
  }
  function updateComponentListeners(vm, listeners, oldListeners) {
    target$1 = vm;
    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
    target$1 = void 0;
  }
  function eventsMixin(Vue4) {
    var hookRE = /^hook:/;
    Vue4.prototype.$on = function(event, fn) {
      var vm = this;
      if (isArray(event)) {
        for (var i = 0, l = event.length; i < l; i++) {
          vm.$on(event[i], fn);
        }
      } else {
        (vm._events[event] || (vm._events[event] = [])).push(fn);
        if (hookRE.test(event)) {
          vm._hasHookEvent = true;
        }
      }
      return vm;
    };
    Vue4.prototype.$once = function(event, fn) {
      var vm = this;
      function on() {
        vm.$off(event, on);
        fn.apply(vm, arguments);
      }
      on.fn = fn;
      vm.$on(event, on);
      return vm;
    };
    Vue4.prototype.$off = function(event, fn) {
      var vm = this;
      if (!arguments.length) {
        vm._events = /* @__PURE__ */ Object.create(null);
        return vm;
      }
      if (isArray(event)) {
        for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
          vm.$off(event[i_1], fn);
        }
        return vm;
      }
      var cbs = vm._events[event];
      if (!cbs) {
        return vm;
      }
      if (!fn) {
        vm._events[event] = null;
        return vm;
      }
      var cb;
      var i = cbs.length;
      while (i--) {
        cb = cbs[i];
        if (cb === fn || cb.fn === fn) {
          cbs.splice(i, 1);
          break;
        }
      }
      return vm;
    };
    Vue4.prototype.$emit = function(event) {
      var vm = this;
      if (false) {
        var lowerCaseEvent = event.toLowerCase();
        if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
          tip('Event "'.concat(lowerCaseEvent, '" is emitted in component ') + "".concat(formatComponentName(vm), ' but the handler is registered for "').concat(event, '". ') + "Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. " + 'You should probably use "'.concat(hyphenate(event), '" instead of "').concat(event, '".'));
        }
      }
      var cbs = vm._events[event];
      if (cbs) {
        cbs = cbs.length > 1 ? toArray(cbs) : cbs;
        var args = toArray(arguments, 1);
        var info = 'event handler for "'.concat(event, '"');
        for (var i = 0, l = cbs.length; i < l; i++) {
          invokeWithErrorHandling(cbs[i], vm, args, vm, info);
        }
      }
      return vm;
    };
  }
  var activeInstance = null;
  function setActiveInstance(vm) {
    var prevActiveInstance = activeInstance;
    activeInstance = vm;
    return function() {
      activeInstance = prevActiveInstance;
    };
  }
  function initLifecycle(vm) {
    var options = vm.$options;
    var parent = options.parent;
    if (parent && !options.abstract) {
      while (parent.$options.abstract && parent.$parent) {
        parent = parent.$parent;
      }
      parent.$children.push(vm);
    }
    vm.$parent = parent;
    vm.$root = parent ? parent.$root : vm;
    vm.$children = [];
    vm.$refs = {};
    vm._provided = parent ? parent._provided : /* @__PURE__ */ Object.create(null);
    vm._watcher = null;
    vm._inactive = null;
    vm._directInactive = false;
    vm._isMounted = false;
    vm._isDestroyed = false;
    vm._isBeingDestroyed = false;
  }
  function lifecycleMixin(Vue4) {
    Vue4.prototype._update = function(vnode, hydrating) {
      var vm = this;
      var prevEl = vm.$el;
      var prevVnode = vm._vnode;
      var restoreActiveInstance = setActiveInstance(vm);
      vm._vnode = vnode;
      if (!prevVnode) {
        vm.$el = vm.__patch__(
          vm.$el,
          vnode,
          hydrating,
          false
          /* removeOnly */
        );
      } else {
        vm.$el = vm.__patch__(prevVnode, vnode);
      }
      restoreActiveInstance();
      if (prevEl) {
        prevEl.__vue__ = null;
      }
      if (vm.$el) {
        vm.$el.__vue__ = vm;
      }
      var wrapper = vm;
      while (wrapper && wrapper.$vnode && wrapper.$parent && wrapper.$vnode === wrapper.$parent._vnode) {
        wrapper.$parent.$el = wrapper.$el;
        wrapper = wrapper.$parent;
      }
    };
    Vue4.prototype.$forceUpdate = function() {
      var vm = this;
      if (vm._watcher) {
        vm._watcher.update();
      }
    };
    Vue4.prototype.$destroy = function() {
      var vm = this;
      if (vm._isBeingDestroyed) {
        return;
      }
      callHook$1(vm, "beforeDestroy");
      vm._isBeingDestroyed = true;
      var parent = vm.$parent;
      if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
        remove$2(parent.$children, vm);
      }
      vm._scope.stop();
      if (vm._data.__ob__) {
        vm._data.__ob__.vmCount--;
      }
      vm._isDestroyed = true;
      vm.__patch__(vm._vnode, null);
      callHook$1(vm, "destroyed");
      vm.$off();
      if (vm.$el) {
        vm.$el.__vue__ = null;
      }
      if (vm.$vnode) {
        vm.$vnode.parent = null;
      }
    };
  }
  function mountComponent(vm, el, hydrating) {
    vm.$el = el;
    if (!vm.$options.render) {
      vm.$options.render = createEmptyVNode;
      if (false) {
        if (vm.$options.template && vm.$options.template.charAt(0) !== "#" || vm.$options.el || el) {
          warn("You are using the runtime-only build of Vue where the template compiler is not available. Either pre-compile the templates into render functions, or use the compiler-included build.", vm);
        } else {
          warn("Failed to mount component: template or render function not defined.", vm);
        }
      }
    }
    callHook$1(vm, "beforeMount");
    var updateComponent;
    if (false) {
      updateComponent = function() {
        var name = vm._name;
        var id = vm._uid;
        var startTag = "vue-perf-start:".concat(id);
        var endTag = "vue-perf-end:".concat(id);
        mark(startTag);
        var vnode = vm._render();
        mark(endTag);
        measure("vue ".concat(name, " render"), startTag, endTag);
        mark(startTag);
        vm._update(vnode, hydrating);
        mark(endTag);
        measure("vue ".concat(name, " patch"), startTag, endTag);
      };
    } else {
      updateComponent = function() {
        vm._update(vm._render(), hydrating);
      };
    }
    var watcherOptions = {
      before: function() {
        if (vm._isMounted && !vm._isDestroyed) {
          callHook$1(vm, "beforeUpdate");
        }
      }
    };
    if (false) {
      watcherOptions.onTrack = function(e) {
        return callHook$1(vm, "renderTracked", [e]);
      };
      watcherOptions.onTrigger = function(e) {
        return callHook$1(vm, "renderTriggered", [e]);
      };
    }
    new Watcher(
      vm,
      updateComponent,
      noop,
      watcherOptions,
      true
      /* isRenderWatcher */
    );
    hydrating = false;
    var preWatchers = vm._preWatchers;
    if (preWatchers) {
      for (var i = 0; i < preWatchers.length; i++) {
        preWatchers[i].run();
      }
    }
    if (vm.$vnode == null) {
      vm._isMounted = true;
      callHook$1(vm, "mounted");
    }
    return vm;
  }
  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
    if (false) {
      isUpdatingChildComponent = true;
    }
    var newScopedSlots = parentVnode.data.scopedSlots;
    var oldScopedSlots = vm.$scopedSlots;
    var hasDynamicScopedSlot = !!(newScopedSlots && !newScopedSlots.$stable || oldScopedSlots !== emptyObject && !oldScopedSlots.$stable || newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key || !newScopedSlots && vm.$scopedSlots.$key);
    var needsForceUpdate = !!(renderChildren || // has new static slots
    vm.$options._renderChildren || // has old static slots
    hasDynamicScopedSlot);
    var prevVNode = vm.$vnode;
    vm.$options._parentVnode = parentVnode;
    vm.$vnode = parentVnode;
    if (vm._vnode) {
      vm._vnode.parent = parentVnode;
    }
    vm.$options._renderChildren = renderChildren;
    var attrs2 = parentVnode.data.attrs || emptyObject;
    if (vm._attrsProxy) {
      if (syncSetupProxy(vm._attrsProxy, attrs2, prevVNode.data && prevVNode.data.attrs || emptyObject, vm, "$attrs")) {
        needsForceUpdate = true;
      }
    }
    vm.$attrs = attrs2;
    listeners = listeners || emptyObject;
    var prevListeners = vm.$options._parentListeners;
    if (vm._listenersProxy) {
      syncSetupProxy(vm._listenersProxy, listeners, prevListeners || emptyObject, vm, "$listeners");
    }
    vm.$listeners = vm.$options._parentListeners = listeners;
    updateComponentListeners(vm, listeners, prevListeners);
    if (propsData && vm.$options.props) {
      toggleObserving(false);
      var props2 = vm._props;
      var propKeys = vm.$options._propKeys || [];
      for (var i = 0; i < propKeys.length; i++) {
        var key = propKeys[i];
        var propOptions = vm.$options.props;
        props2[key] = validateProp(key, propOptions, propsData, vm);
      }
      toggleObserving(true);
      vm.$options.propsData = propsData;
    }
    if (needsForceUpdate) {
      vm.$slots = resolveSlots(renderChildren, parentVnode.context);
      vm.$forceUpdate();
    }
    if (false) {
      isUpdatingChildComponent = false;
    }
  }
  function isInInactiveTree(vm) {
    while (vm && (vm = vm.$parent)) {
      if (vm._inactive)
        return true;
    }
    return false;
  }
  function activateChildComponent(vm, direct) {
    if (direct) {
      vm._directInactive = false;
      if (isInInactiveTree(vm)) {
        return;
      }
    } else if (vm._directInactive) {
      return;
    }
    if (vm._inactive || vm._inactive === null) {
      vm._inactive = false;
      for (var i = 0; i < vm.$children.length; i++) {
        activateChildComponent(vm.$children[i]);
      }
      callHook$1(vm, "activated");
    }
  }
  function deactivateChildComponent(vm, direct) {
    if (direct) {
      vm._directInactive = true;
      if (isInInactiveTree(vm)) {
        return;
      }
    }
    if (!vm._inactive) {
      vm._inactive = true;
      for (var i = 0; i < vm.$children.length; i++) {
        deactivateChildComponent(vm.$children[i]);
      }
      callHook$1(vm, "deactivated");
    }
  }
  function callHook$1(vm, hook, args, setContext) {
    if (setContext === void 0) {
      setContext = true;
    }
    pushTarget();
    var prevInst = currentInstance;
    var prevScope = getCurrentScope();
    setContext && setCurrentInstance(vm);
    var handlers = vm.$options[hook];
    var info = "".concat(hook, " hook");
    if (handlers) {
      for (var i = 0, j = handlers.length; i < j; i++) {
        invokeWithErrorHandling(handlers[i], vm, args || null, vm, info);
      }
    }
    if (vm._hasHookEvent) {
      vm.$emit("hook:" + hook);
    }
    if (setContext) {
      setCurrentInstance(prevInst);
      prevScope && prevScope.on();
    }
    popTarget();
  }
  var queue = [];
  var activatedChildren = [];
  var has = {};
  var waiting = false;
  var flushing = false;
  var index = 0;
  function resetSchedulerState() {
    index = queue.length = activatedChildren.length = 0;
    has = {};
    if (false) {
      circular = {};
    }
    waiting = flushing = false;
  }
  var currentFlushTimestamp = 0;
  var getNow = Date.now;
  if (inBrowser && !isIE) {
    performance_1 = window.performance;
    if (performance_1 && typeof performance_1.now === "function" && getNow() > document.createEvent("Event").timeStamp) {
      getNow = function() {
        return performance_1.now();
      };
    }
  }
  var performance_1;
  var sortCompareFn = function(a, b) {
    if (a.post) {
      if (!b.post)
        return 1;
    } else if (b.post) {
      return -1;
    }
    return a.id - b.id;
  };
  function flushSchedulerQueue() {
    currentFlushTimestamp = getNow();
    flushing = true;
    var watcher, id;
    queue.sort(sortCompareFn);
    for (index = 0; index < queue.length; index++) {
      watcher = queue[index];
      if (watcher.before) {
        watcher.before();
      }
      id = watcher.id;
      has[id] = null;
      watcher.run();
      if (false) {
        circular[id] = (circular[id] || 0) + 1;
        if (circular[id] > MAX_UPDATE_COUNT) {
          warn("You may have an infinite update loop " + (watcher.user ? 'in watcher with expression "'.concat(watcher.expression, '"') : "in a component render function."), watcher.vm);
          break;
        }
      }
    }
    var activatedQueue = activatedChildren.slice();
    var updatedQueue = queue.slice();
    resetSchedulerState();
    callActivatedHooks(activatedQueue);
    callUpdatedHooks(updatedQueue);
    cleanupDeps();
    if (devtools && config.devtools) {
      devtools.emit("flush");
    }
  }
  function callUpdatedHooks(queue2) {
    var i = queue2.length;
    while (i--) {
      var watcher = queue2[i];
      var vm = watcher.vm;
      if (vm && vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
        callHook$1(vm, "updated");
      }
    }
  }
  function queueActivatedComponent(vm) {
    vm._inactive = false;
    activatedChildren.push(vm);
  }
  function callActivatedHooks(queue2) {
    for (var i = 0; i < queue2.length; i++) {
      queue2[i]._inactive = true;
      activateChildComponent(
        queue2[i],
        true
        /* true */
      );
    }
  }
  function queueWatcher(watcher) {
    var id = watcher.id;
    if (has[id] != null) {
      return;
    }
    if (watcher === Dep.target && watcher.noRecurse) {
      return;
    }
    has[id] = true;
    if (!flushing) {
      queue.push(watcher);
    } else {
      var i = queue.length - 1;
      while (i > index && queue[i].id > watcher.id) {
        i--;
      }
      queue.splice(i + 1, 0, watcher);
    }
    if (!waiting) {
      waiting = true;
      if (false) {
        flushSchedulerQueue();
        return;
      }
      nextTick(flushSchedulerQueue);
    }
  }
  function initProvide(vm) {
    var provideOption = vm.$options.provide;
    if (provideOption) {
      var provided = isFunction(provideOption) ? provideOption.call(vm) : provideOption;
      if (!isObject(provided)) {
        return;
      }
      var source = resolveProvided(vm);
      var keys = hasSymbol ? Reflect.ownKeys(provided) : Object.keys(provided);
      for (var i = 0; i < keys.length; i++) {
        var key = keys[i];
        Object.defineProperty(source, key, Object.getOwnPropertyDescriptor(provided, key));
      }
    }
  }
  function initInjections(vm) {
    var result = resolveInject(vm.$options.inject, vm);
    if (result) {
      toggleObserving(false);
      Object.keys(result).forEach(function(key) {
        if (false) {
          defineReactive(vm, key, result[key], function() {
            warn("Avoid mutating an injected value directly since the changes will be overwritten whenever the provided component re-renders. " + 'injection being mutated: "'.concat(key, '"'), vm);
          });
        } else {
          defineReactive(vm, key, result[key]);
        }
      });
      toggleObserving(true);
    }
  }
  function resolveInject(inject, vm) {
    if (inject) {
      var result = /* @__PURE__ */ Object.create(null);
      var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
      for (var i = 0; i < keys.length; i++) {
        var key = keys[i];
        if (key === "__ob__")
          continue;
        var provideKey = inject[key].from;
        if (provideKey in vm._provided) {
          result[key] = vm._provided[provideKey];
        } else if ("default" in inject[key]) {
          var provideDefault = inject[key].default;
          result[key] = isFunction(provideDefault) ? provideDefault.call(vm) : provideDefault;
        } else if (false) {
          warn('Injection "'.concat(key, '" not found'), vm);
        }
      }
      return result;
    }
  }
  function FunctionalRenderContext(data, props2, children, parent, Ctor) {
    var _this = this;
    var options = Ctor.options;
    var contextVm;
    if (hasOwn(parent, "_uid")) {
      contextVm = Object.create(parent);
      contextVm._original = parent;
    } else {
      contextVm = parent;
      parent = parent._original;
    }
    var isCompiled = isTrue(options._compiled);
    var needNormalization = !isCompiled;
    this.data = data;
    this.props = props2;
    this.children = children;
    this.parent = parent;
    this.listeners = data.on || emptyObject;
    this.injections = resolveInject(options.inject, parent);
    this.slots = function() {
      if (!_this.$slots) {
        normalizeScopedSlots(parent, data.scopedSlots, _this.$slots = resolveSlots(children, parent));
      }
      return _this.$slots;
    };
    Object.defineProperty(this, "scopedSlots", {
      enumerable: true,
      get: function() {
        return normalizeScopedSlots(parent, data.scopedSlots, this.slots());
      }
    });
    if (isCompiled) {
      this.$options = options;
      this.$slots = this.slots();
      this.$scopedSlots = normalizeScopedSlots(parent, data.scopedSlots, this.$slots);
    }
    if (options._scopeId) {
      this._c = function(a, b, c, d) {
        var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
        if (vnode && !isArray(vnode)) {
          vnode.fnScopeId = options._scopeId;
          vnode.fnContext = parent;
        }
        return vnode;
      };
    } else {
      this._c = function(a, b, c, d) {
        return createElement$1(contextVm, a, b, c, d, needNormalization);
      };
    }
  }
  installRenderHelpers(FunctionalRenderContext.prototype);
  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
    var options = Ctor.options;
    var props2 = {};
    var propOptions = options.props;
    if (isDef(propOptions)) {
      for (var key in propOptions) {
        props2[key] = validateProp(key, propOptions, propsData || emptyObject);
      }
    } else {
      if (isDef(data.attrs))
        mergeProps(props2, data.attrs);
      if (isDef(data.props))
        mergeProps(props2, data.props);
    }
    var renderContext = new FunctionalRenderContext(data, props2, children, contextVm, Ctor);
    var vnode = options.render.call(null, renderContext._c, renderContext);
    if (vnode instanceof VNode) {
      return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
    } else if (isArray(vnode)) {
      var vnodes = normalizeChildren(vnode) || [];
      var res = new Array(vnodes.length);
      for (var i = 0; i < vnodes.length; i++) {
        res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
      }
      return res;
    }
  }
  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
    var clone = cloneVNode(vnode);
    clone.fnContext = contextVm;
    clone.fnOptions = options;
    if (false) {
      (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
    }
    if (data.slot) {
      (clone.data || (clone.data = {})).slot = data.slot;
    }
    return clone;
  }
  function mergeProps(to, from) {
    for (var key in from) {
      to[camelize(key)] = from[key];
    }
  }
  function getComponentName(options) {
    return options.name || options.__name || options._componentTag;
  }
  var componentVNodeHooks = {
    init: function(vnode, hydrating) {
      if (vnode.componentInstance && !vnode.componentInstance._isDestroyed && vnode.data.keepAlive) {
        var mountedNode = vnode;
        componentVNodeHooks.prepatch(mountedNode, mountedNode);
      } else {
        var child = vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance);
        child.$mount(hydrating ? vnode.elm : void 0, hydrating);
      }
    },
    prepatch: function(oldVnode, vnode) {
      var options = vnode.componentOptions;
      var child = vnode.componentInstance = oldVnode.componentInstance;
      updateChildComponent(
        child,
        options.propsData,
        // updated props
        options.listeners,
        // updated listeners
        vnode,
        // new parent vnode
        options.children
        // new children
      );
    },
    insert: function(vnode) {
      var context = vnode.context, componentInstance = vnode.componentInstance;
      if (!componentInstance._isMounted) {
        componentInstance._isMounted = true;
        callHook$1(componentInstance, "mounted");
      }
      if (vnode.data.keepAlive) {
        if (context._isMounted) {
          queueActivatedComponent(componentInstance);
        } else {
          activateChildComponent(
            componentInstance,
            true
            /* direct */
          );
        }
      }
    },
    destroy: function(vnode) {
      var componentInstance = vnode.componentInstance;
      if (!componentInstance._isDestroyed) {
        if (!vnode.data.keepAlive) {
          componentInstance.$destroy();
        } else {
          deactivateChildComponent(
            componentInstance,
            true
            /* direct */
          );
        }
      }
    }
  };
  var hooksToMerge = Object.keys(componentVNodeHooks);
  function createComponent(Ctor, data, context, children, tag) {
    if (isUndef(Ctor)) {
      return;
    }
    var baseCtor = context.$options._base;
    if (isObject(Ctor)) {
      Ctor = baseCtor.extend(Ctor);
    }
    if (typeof Ctor !== "function") {
      if (false) {
        warn("Invalid Component definition: ".concat(String(Ctor)), context);
      }
      return;
    }
    var asyncFactory;
    if (isUndef(Ctor.cid)) {
      asyncFactory = Ctor;
      Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
      if (Ctor === void 0) {
        return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
      }
    }
    data = data || {};
    resolveConstructorOptions(Ctor);
    if (isDef(data.model)) {
      transformModel(Ctor.options, data);
    }
    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
    if (isTrue(Ctor.options.functional)) {
      return createFunctionalComponent(Ctor, propsData, data, context, children);
    }
    var listeners = data.on;
    data.on = data.nativeOn;
    if (isTrue(Ctor.options.abstract)) {
      var slot = data.slot;
      data = {};
      if (slot) {
        data.slot = slot;
      }
    }
    installComponentHooks(data);
    var name = getComponentName(Ctor.options) || tag;
    var vnode = new VNode(
      // @ts-expect-error
      "vue-component-".concat(Ctor.cid).concat(name ? "-".concat(name) : ""),
      data,
      void 0,
      void 0,
      void 0,
      context,
      // @ts-expect-error
      { Ctor, propsData, listeners, tag, children },
      asyncFactory
    );
    return vnode;
  }
  function createComponentInstanceForVnode(vnode, parent) {
    var options = {
      _isComponent: true,
      _parentVnode: vnode,
      parent
    };
    var inlineTemplate = vnode.data.inlineTemplate;
    if (isDef(inlineTemplate)) {
      options.render = inlineTemplate.render;
      options.staticRenderFns = inlineTemplate.staticRenderFns;
    }
    return new vnode.componentOptions.Ctor(options);
  }
  function installComponentHooks(data) {
    var hooks2 = data.hook || (data.hook = {});
    for (var i = 0; i < hooksToMerge.length; i++) {
      var key = hooksToMerge[i];
      var existing = hooks2[key];
      var toMerge = componentVNodeHooks[key];
      if (existing !== toMerge && !(existing && existing._merged)) {
        hooks2[key] = existing ? mergeHook(toMerge, existing) : toMerge;
      }
    }
  }
  function mergeHook(f1, f2) {
    var merged = function(a, b) {
      f1(a, b);
      f2(a, b);
    };
    merged._merged = true;
    return merged;
  }
  function transformModel(options, data) {
    var prop = options.model && options.model.prop || "value";
    var event = options.model && options.model.event || "input";
    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
    var on = data.on || (data.on = {});
    var existing = on[event];
    var callback = data.model.callback;
    if (isDef(existing)) {
      if (isArray(existing) ? existing.indexOf(callback) === -1 : existing !== callback) {
        on[event] = [callback].concat(existing);
      }
    } else {
      on[event] = callback;
    }
  }
  var warn = noop;
  if (false) {
    hasConsole_1 = typeof console !== "undefined";
    classifyRE_1 = /(?:^|[-_])(\w)/g;
    classify_1 = function(str) {
      return str.replace(classifyRE_1, function(c) {
        return c.toUpperCase();
      }).replace(/[-_]/g, "");
    };
    warn = function(msg, vm) {
      if (vm === void 0) {
        vm = currentInstance;
      }
      var trace = vm ? generateComponentTrace(vm) : "";
      if (config.warnHandler) {
        config.warnHandler.call(null, msg, vm, trace);
      } else if (hasConsole_1 && !config.silent) {
        console.error("[Vue warn]: ".concat(msg).concat(trace));
      }
    };
    tip = function(msg, vm) {
      if (hasConsole_1 && !config.silent) {
        console.warn("[Vue tip]: ".concat(msg) + (vm ? generateComponentTrace(vm) : ""));
      }
    };
    formatComponentName = function(vm, includeFile) {
      if (vm.$root === vm) {
        return "<Root>";
      }
      var options = isFunction(vm) && vm.cid != null ? vm.options : vm._isVue ? vm.$options || vm.constructor.options : vm;
      var name = getComponentName(options);
      var file = options.__file;
      if (!name && file) {
        var match = file.match(/([^/\\]+)\.vue$/);
        name = match && match[1];
      }
      return (name ? "<".concat(classify_1(name), ">") : "<Anonymous>") + (file && includeFile !== false ? " at ".concat(file) : "");
    };
    repeat_1 = function(str, n) {
      var res = "";
      while (n) {
        if (n % 2 === 1)
          res += str;
        if (n > 1)
          str += str;
        n >>= 1;
      }
      return res;
    };
    generateComponentTrace = function(vm) {
      if (vm._isVue && vm.$parent) {
        var tree = [];
        var currentRecursiveSequence = 0;
        while (vm) {
          if (tree.length > 0) {
            var last = tree[tree.length - 1];
            if (last.constructor === vm.constructor) {
              currentRecursiveSequence++;
              vm = vm.$parent;
              continue;
            } else if (currentRecursiveSequence > 0) {
              tree[tree.length - 1] = [last, currentRecursiveSequence];
              currentRecursiveSequence = 0;
            }
          }
          tree.push(vm);
          vm = vm.$parent;
        }
        return "\n\nfound in\n\n" + tree.map(function(vm2, i) {
          return "".concat(i === 0 ? "---> " : repeat_1(" ", 5 + i * 2)).concat(isArray(vm2) ? "".concat(formatComponentName(vm2[0]), "... (").concat(vm2[1], " recursive calls)") : formatComponentName(vm2));
        }).join("\n");
      } else {
        return "\n\n(found in ".concat(formatComponentName(vm), ")");
      }
    };
  }
  var hasConsole_1;
  var classifyRE_1;
  var classify_1;
  var repeat_1;
  var strats = config.optionMergeStrategies;
  if (false) {
    strats.el = strats.propsData = function(parent, child, vm, key) {
      if (!vm) {
        warn('option "'.concat(key, '" can only be used during instance ') + "creation with the `new` keyword.");
      }
      return defaultStrat(parent, child);
    };
  }
  function mergeData(to, from, recursive) {
    if (recursive === void 0) {
      recursive = true;
    }
    if (!from)
      return to;
    var key, toVal, fromVal;
    var keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from);
    for (var i = 0; i < keys.length; i++) {
      key = keys[i];
      if (key === "__ob__")
        continue;
      toVal = to[key];
      fromVal = from[key];
      if (!recursive || !hasOwn(to, key)) {
        set(to, key, fromVal);
      } else if (toVal !== fromVal && isPlainObject(toVal) && isPlainObject(fromVal)) {
        mergeData(toVal, fromVal);
      }
    }
    return to;
  }
  function mergeDataOrFn(parentVal, childVal, vm) {
    if (!vm) {
      if (!childVal) {
        return parentVal;
      }
      if (!parentVal) {
        return childVal;
      }
      return function mergedDataFn() {
        return mergeData(isFunction(childVal) ? childVal.call(this, this) : childVal, isFunction(parentVal) ? parentVal.call(this, this) : parentVal);
      };
    } else {
      return function mergedInstanceDataFn() {
        var instanceData = isFunction(childVal) ? childVal.call(vm, vm) : childVal;
        var defaultData = isFunction(parentVal) ? parentVal.call(vm, vm) : parentVal;
        if (instanceData) {
          return mergeData(instanceData, defaultData);
        } else {
          return defaultData;
        }
      };
    }
  }
  strats.data = function(parentVal, childVal, vm) {
    if (!vm) {
      if (childVal && typeof childVal !== "function") {
        return parentVal;
      }
      return mergeDataOrFn(parentVal, childVal);
    }
    return mergeDataOrFn(parentVal, childVal, vm);
  };
  function mergeLifecycleHook(parentVal, childVal) {
    var res = childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal;
    return res ? dedupeHooks(res) : res;
  }
  function dedupeHooks(hooks2) {
    var res = [];
    for (var i = 0; i < hooks2.length; i++) {
      if (res.indexOf(hooks2[i]) === -1) {
        res.push(hooks2[i]);
      }
    }
    return res;
  }
  LIFECYCLE_HOOKS.forEach(function(hook) {
    strats[hook] = mergeLifecycleHook;
  });
  function mergeAssets(parentVal, childVal, vm, key) {
    var res = Object.create(parentVal || null);
    if (childVal) {
      return extend(res, childVal);
    } else {
      return res;
    }
  }
  ASSET_TYPES.forEach(function(type) {
    strats[type + "s"] = mergeAssets;
  });
  strats.watch = function(parentVal, childVal, vm, key) {
    if (parentVal === nativeWatch)
      parentVal = void 0;
    if (childVal === nativeWatch)
      childVal = void 0;
    if (!childVal)
      return Object.create(parentVal || null);
    if (false) {
      assertObjectType(key, childVal, vm);
    }
    if (!parentVal)
      return childVal;
    var ret = {};
    extend(ret, parentVal);
    for (var key_1 in childVal) {
      var parent_1 = ret[key_1];
      var child = childVal[key_1];
      if (parent_1 && !isArray(parent_1)) {
        parent_1 = [parent_1];
      }
      ret[key_1] = parent_1 ? parent_1.concat(child) : isArray(child) ? child : [child];
    }
    return ret;
  };
  strats.props = strats.methods = strats.inject = strats.computed = function(parentVal, childVal, vm, key) {
    if (childVal && false) {
      assertObjectType(key, childVal, vm);
    }
    if (!parentVal)
      return childVal;
    var ret = /* @__PURE__ */ Object.create(null);
    extend(ret, parentVal);
    if (childVal)
      extend(ret, childVal);
    return ret;
  };
  strats.provide = function(parentVal, childVal) {
    if (!parentVal)
      return childVal;
    return function() {
      var ret = /* @__PURE__ */ Object.create(null);
      mergeData(ret, isFunction(parentVal) ? parentVal.call(this) : parentVal);
      if (childVal) {
        mergeData(
          ret,
          isFunction(childVal) ? childVal.call(this) : childVal,
          false
          // non-recursive
        );
      }
      return ret;
    };
  };
  var defaultStrat = function(parentVal, childVal) {
    return childVal === void 0 ? parentVal : childVal;
  };
  function normalizeProps(options, vm) {
    var props2 = options.props;
    if (!props2)
      return;
    var res = {};
    var i, val, name;
    if (isArray(props2)) {
      i = props2.length;
      while (i--) {
        val = props2[i];
        if (typeof val === "string") {
          name = camelize(val);
          res[name] = { type: null };
        } else if (false) {
          warn("props must be strings when using array syntax.");
        }
      }
    } else if (isPlainObject(props2)) {
      for (var key in props2) {
        val = props2[key];
        name = camelize(key);
        res[name] = isPlainObject(val) ? val : { type: val };
      }
    } else if (false) {
      warn('Invalid value for option "props": expected an Array or an Object, ' + "but got ".concat(toRawType(props2), "."), vm);
    }
    options.props = res;
  }
  function normalizeInject(options, vm) {
    var inject = options.inject;
    if (!inject)
      return;
    var normalized = options.inject = {};
    if (isArray(inject)) {
      for (var i = 0; i < inject.length; i++) {
        normalized[inject[i]] = { from: inject[i] };
      }
    } else if (isPlainObject(inject)) {
      for (var key in inject) {
        var val = inject[key];
        normalized[key] = isPlainObject(val) ? extend({ from: key }, val) : { from: val };
      }
    } else if (false) {
      warn('Invalid value for option "inject": expected an Array or an Object, ' + "but got ".concat(toRawType(inject), "."), vm);
    }
  }
  function normalizeDirectives$1(options) {
    var dirs = options.directives;
    if (dirs) {
      for (var key in dirs) {
        var def2 = dirs[key];
        if (isFunction(def2)) {
          dirs[key] = { bind: def2, update: def2 };
        }
      }
    }
  }
  function mergeOptions(parent, child, vm) {
    if (false) {
      checkComponents(child);
    }
    if (isFunction(child)) {
      child = child.options;
    }
    normalizeProps(child, vm);
    normalizeInject(child, vm);
    normalizeDirectives$1(child);
    if (!child._base) {
      if (child.extends) {
        parent = mergeOptions(parent, child.extends, vm);
      }
      if (child.mixins) {
        for (var i = 0, l = child.mixins.length; i < l; i++) {
          parent = mergeOptions(parent, child.mixins[i], vm);
        }
      }
    }
    var options = {};
    var key;
    for (key in parent) {
      mergeField(key);
    }
    for (key in child) {
      if (!hasOwn(parent, key)) {
        mergeField(key);
      }
    }
    function mergeField(key2) {
      var strat = strats[key2] || defaultStrat;
      options[key2] = strat(parent[key2], child[key2], vm, key2);
    }
    return options;
  }
  function resolveAsset(options, type, id, warnMissing) {
    if (typeof id !== "string") {
      return;
    }
    var assets = options[type];
    if (hasOwn(assets, id))
      return assets[id];
    var camelizedId = camelize(id);
    if (hasOwn(assets, camelizedId))
      return assets[camelizedId];
    var PascalCaseId = capitalize(camelizedId);
    if (hasOwn(assets, PascalCaseId))
      return assets[PascalCaseId];
    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
    if (false) {
      warn("Failed to resolve " + type.slice(0, -1) + ": " + id);
    }
    return res;
  }
  function validateProp(key, propOptions, propsData, vm) {
    var prop = propOptions[key];
    var absent = !hasOwn(propsData, key);
    var value = propsData[key];
    var booleanIndex = getTypeIndex(Boolean, prop.type);
    if (booleanIndex > -1) {
      if (absent && !hasOwn(prop, "default")) {
        value = false;
      } else if (value === "" || value === hyphenate(key)) {
        var stringIndex = getTypeIndex(String, prop.type);
        if (stringIndex < 0 || booleanIndex < stringIndex) {
          value = true;
        }
      }
    }
    if (value === void 0) {
      value = getPropDefaultValue(vm, prop, key);
      var prevShouldObserve = shouldObserve;
      toggleObserving(true);
      observe(value);
      toggleObserving(prevShouldObserve);
    }
    if (false) {
      assertProp(prop, key, value, vm, absent);
    }
    return value;
  }
  function getPropDefaultValue(vm, prop, key) {
    if (!hasOwn(prop, "default")) {
      return void 0;
    }
    var def2 = prop.default;
    if (false) {
      warn('Invalid default value for prop "' + key + '": Props with type Object/Array must use a factory function to return the default value.', vm);
    }
    if (vm && vm.$options.propsData && vm.$options.propsData[key] === void 0 && vm._props[key] !== void 0) {
      return vm._props[key];
    }
    return isFunction(def2) && getType(prop.type) !== "Function" ? def2.call(vm) : def2;
  }
  var functionTypeCheckRE = /^\s*function (\w+)/;
  function getType(fn) {
    var match = fn && fn.toString().match(functionTypeCheckRE);
    return match ? match[1] : "";
  }
  function isSameType(a, b) {
    return getType(a) === getType(b);
  }
  function getTypeIndex(type, expectedTypes) {
    if (!isArray(expectedTypes)) {
      return isSameType(expectedTypes, type) ? 0 : -1;
    }
    for (var i = 0, len = expectedTypes.length; i < len; i++) {
      if (isSameType(expectedTypes[i], type)) {
        return i;
      }
    }
    return -1;
  }
  if (false) {
    allowedGlobals_1 = makeMap(
      "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,require"
      // for Webpack/Browserify
    );
    warnNonPresent_1 = function(target3, key) {
      warn('Property or method "'.concat(key, '" is not defined on the instance but ') + "referenced during render. Make sure that this property is reactive, either in the data option, or for class-based components, by initializing the property. See: https://v2.vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.", target3);
    };
    warnReservedPrefix_1 = function(target3, key) {
      warn('Property "'.concat(key, '" must be accessed with "$data.').concat(key, '" because ') + 'properties starting with "$" or "_" are not proxied in the Vue instance to prevent conflicts with Vue internals. See: https://v2.vuejs.org/v2/api/#data', target3);
    };
    hasProxy_1 = typeof Proxy !== "undefined" && isNative(Proxy);
    if (hasProxy_1) {
      isBuiltInModifier_1 = makeMap("stop,prevent,self,ctrl,shift,alt,meta,exact");
      config.keyCodes = new Proxy(config.keyCodes, {
        set: function(target3, key, value) {
          if (isBuiltInModifier_1(key)) {
            warn("Avoid overwriting built-in modifier in config.keyCodes: .".concat(key));
            return false;
          } else {
            target3[key] = value;
            return true;
          }
        }
      });
    }
    hasHandler_1 = {
      has: function(target3, key) {
        var has2 = key in target3;
        var isAllowed = allowedGlobals_1(key) || typeof key === "string" && key.charAt(0) === "_" && !(key in target3.$data);
        if (!has2 && !isAllowed) {
          if (key in target3.$data)
            warnReservedPrefix_1(target3, key);
          else
            warnNonPresent_1(target3, key);
        }
        return has2 || !isAllowed;
      }
    };
    getHandler_1 = {
      get: function(target3, key) {
        if (typeof key === "string" && !(key in target3)) {
          if (key in target3.$data)
            warnReservedPrefix_1(target3, key);
          else
            warnNonPresent_1(target3, key);
        }
        return target3[key];
      }
    };
    initProxy = function initProxy(vm) {
      if (hasProxy_1) {
        var options = vm.$options;
        var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
        vm._renderProxy = new Proxy(vm, handlers);
      } else {
        vm._renderProxy = vm;
      }
    };
  }
  var allowedGlobals_1;
  var warnNonPresent_1;
  var warnReservedPrefix_1;
  var hasProxy_1;
  var isBuiltInModifier_1;
  var hasHandler_1;
  var getHandler_1;
  var sharedPropertyDefinition = {
    enumerable: true,
    configurable: true,
    get: noop,
    set: noop
  };
  function proxy(target3, sourceKey, key) {
    sharedPropertyDefinition.get = function proxyGetter() {
      return this[sourceKey][key];
    };
    sharedPropertyDefinition.set = function proxySetter(val) {
      this[sourceKey][key] = val;
    };
    Object.defineProperty(target3, key, sharedPropertyDefinition);
  }
  function initState(vm) {
    var opts = vm.$options;
    if (opts.props)
      initProps$1(vm, opts.props);
    initSetup(vm);
    if (opts.methods)
      initMethods(vm, opts.methods);
    if (opts.data) {
      initData(vm);
    } else {
      var ob = observe(vm._data = {});
      ob && ob.vmCount++;
    }
    if (opts.computed)
      initComputed$1(vm, opts.computed);
    if (opts.watch && opts.watch !== nativeWatch) {
      initWatch(vm, opts.watch);
    }
  }
  function initProps$1(vm, propsOptions) {
    var propsData = vm.$options.propsData || {};
    var props2 = vm._props = shallowReactive({});
    var keys = vm.$options._propKeys = [];
    var isRoot = !vm.$parent;
    if (!isRoot) {
      toggleObserving(false);
    }
    var _loop_1 = function(key2) {
      keys.push(key2);
      var value = validateProp(key2, propsOptions, propsData, vm);
      if (false) {
        var hyphenatedKey = hyphenate(key2);
        if (isReservedAttribute(hyphenatedKey) || config.isReservedAttr(hyphenatedKey)) {
          warn('"'.concat(hyphenatedKey, '" is a reserved attribute and cannot be used as component prop.'), vm);
        }
        defineReactive(
          props2,
          key2,
          value,
          function() {
            if (!isRoot && !isUpdatingChildComponent) {
              warn("Avoid mutating a prop directly since the value will be overwritten whenever the parent component re-renders. Instead, use a data or computed property based on the prop's " + 'value. Prop being mutated: "'.concat(key2, '"'), vm);
            }
          },
          true
          /* shallow */
        );
      } else {
        defineReactive(
          props2,
          key2,
          value,
          void 0,
          true
          /* shallow */
        );
      }
      if (!(key2 in vm)) {
        proxy(vm, "_props", key2);
      }
    };
    for (var key in propsOptions) {
      _loop_1(key);
    }
    toggleObserving(true);
  }
  function initData(vm) {
    var data = vm.$options.data;
    data = vm._data = isFunction(data) ? getData(data, vm) : data || {};
    if (!isPlainObject(data)) {
      data = {};
    }
    var keys = Object.keys(data);
    var props2 = vm.$options.props;
    var methods = vm.$options.methods;
    var i = keys.length;
    while (i--) {
      var key = keys[i];
      if (false) {
        if (methods && hasOwn(methods, key)) {
          warn('Method "'.concat(key, '" has already been defined as a data property.'), vm);
        }
      }
      if (props2 && hasOwn(props2, key)) {
      } else if (!isReserved(key)) {
        proxy(vm, "_data", key);
      }
    }
    var ob = observe(data);
    ob && ob.vmCount++;
  }
  function getData(data, vm) {
    pushTarget();
    try {
      return data.call(vm, vm);
    } catch (e) {
      handleError(e, vm, "data()");
      return {};
    } finally {
      popTarget();
    }
  }
  var computedWatcherOptions = { lazy: true };
  function initComputed$1(vm, computed) {
    var watchers = vm._computedWatchers = /* @__PURE__ */ Object.create(null);
    var isSSR = isServerRendering();
    for (var key in computed) {
      var userDef = computed[key];
      var getter = isFunction(userDef) ? userDef : userDef.get;
      if (false) {
        warn('Getter is missing for computed property "'.concat(key, '".'), vm);
      }
      if (!isSSR) {
        watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
      }
      if (!(key in vm)) {
        defineComputed(vm, key, userDef);
      } else if (false) {
        if (key in vm.$data) {
          warn('The computed property "'.concat(key, '" is already defined in data.'), vm);
        } else if (vm.$options.props && key in vm.$options.props) {
          warn('The computed property "'.concat(key, '" is already defined as a prop.'), vm);
        } else if (vm.$options.methods && key in vm.$options.methods) {
          warn('The computed property "'.concat(key, '" is already defined as a method.'), vm);
        }
      }
    }
  }
  function defineComputed(target3, key, userDef) {
    var shouldCache = !isServerRendering();
    if (isFunction(userDef)) {
      sharedPropertyDefinition.get = shouldCache ? createComputedGetter(key) : createGetterInvoker(userDef);
      sharedPropertyDefinition.set = noop;
    } else {
      sharedPropertyDefinition.get = userDef.get ? shouldCache && userDef.cache !== false ? createComputedGetter(key) : createGetterInvoker(userDef.get) : noop;
      sharedPropertyDefinition.set = userDef.set || noop;
    }
    if (false) {
      sharedPropertyDefinition.set = function() {
        warn('Computed property "'.concat(key, '" was assigned to but it has no setter.'), this);
      };
    }
    Object.defineProperty(target3, key, sharedPropertyDefinition);
  }
  function createComputedGetter(key) {
    return function computedGetter() {
      var watcher = this._computedWatchers && this._computedWatchers[key];
      if (watcher) {
        if (watcher.dirty) {
          watcher.evaluate();
        }
        if (Dep.target) {
          if (false) {
            Dep.target.onTrack({
              effect: Dep.target,
              target: this,
              type: "get",
              key
            });
          }
          watcher.depend();
        }
        return watcher.value;
      }
    };
  }
  function createGetterInvoker(fn) {
    return function computedGetter() {
      return fn.call(this, this);
    };
  }
  function initMethods(vm, methods) {
    var props2 = vm.$options.props;
    for (var key in methods) {
      if (false) {
        if (typeof methods[key] !== "function") {
          warn('Method "'.concat(key, '" has type "').concat(typeof methods[key], '" in the component definition. ') + "Did you reference the function correctly?", vm);
        }
        if (props2 && hasOwn(props2, key)) {
          warn('Method "'.concat(key, '" has already been defined as a prop.'), vm);
        }
        if (key in vm && isReserved(key)) {
          warn('Method "'.concat(key, '" conflicts with an existing Vue instance method. ') + "Avoid defining component methods that start with _ or $.");
        }
      }
      vm[key] = typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
    }
  }
  function initWatch(vm, watch2) {
    for (var key in watch2) {
      var handler = watch2[key];
      if (isArray(handler)) {
        for (var i = 0; i < handler.length; i++) {
          createWatcher(vm, key, handler[i]);
        }
      } else {
        createWatcher(vm, key, handler);
      }
    }
  }
  function createWatcher(vm, expOrFn, handler, options) {
    if (isPlainObject(handler)) {
      options = handler;
      handler = handler.handler;
    }
    if (typeof handler === "string") {
      handler = vm[handler];
    }
    return vm.$watch(expOrFn, handler, options);
  }
  function stateMixin(Vue4) {
    var dataDef = {};
    dataDef.get = function() {
      return this._data;
    };
    var propsDef = {};
    propsDef.get = function() {
      return this._props;
    };
    if (false) {
      dataDef.set = function() {
        warn("Avoid replacing instance root $data. Use nested data properties instead.", this);
      };
      propsDef.set = function() {
        warn("$props is readonly.", this);
      };
    }
    Object.defineProperty(Vue4.prototype, "$data", dataDef);
    Object.defineProperty(Vue4.prototype, "$props", propsDef);
    Vue4.prototype.$set = set;
    Vue4.prototype.$delete = del;
    Vue4.prototype.$watch = function(expOrFn, cb, options) {
      var vm = this;
      if (isPlainObject(cb)) {
        return createWatcher(vm, expOrFn, cb, options);
      }
      options = options || {};
      options.user = true;
      var watcher = new Watcher(vm, expOrFn, cb, options);
      if (options.immediate) {
        var info = 'callback for immediate watcher "'.concat(watcher.expression, '"');
        pushTarget();
        invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
        popTarget();
      }
      return function unwatchFn() {
        watcher.teardown();
      };
    };
  }
  var uid = 0;
  function initMixin$1(Vue4) {
    Vue4.prototype._init = function(options) {
      var vm = this;
      vm._uid = uid++;
      var startTag, endTag;
      if (false) {
        startTag = "vue-perf-start:".concat(vm._uid);
        endTag = "vue-perf-end:".concat(vm._uid);
        mark(startTag);
      }
      vm._isVue = true;
      vm.__v_skip = true;
      vm._scope = new EffectScope(
        true
        /* detached */
      );
      vm._scope.parent = void 0;
      vm._scope._vm = true;
      if (options && options._isComponent) {
        initInternalComponent(vm, options);
      } else {
        vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
      }
      if (false) {
        initProxy(vm);
      } else {
        vm._renderProxy = vm;
      }
      vm._self = vm;
      initLifecycle(vm);
      initEvents(vm);
      initRender(vm);
      callHook$1(
        vm,
        "beforeCreate",
        void 0,
        false
        /* setContext */
      );
      initInjections(vm);
      initState(vm);
      initProvide(vm);
      callHook$1(vm, "created");
      if (false) {
        vm._name = formatComponentName(vm, false);
        mark(endTag);
        measure("vue ".concat(vm._name, " init"), startTag, endTag);
      }
      if (vm.$options.el) {
        vm.$mount(vm.$options.el);
      }
    };
  }
  function initInternalComponent(vm, options) {
    var opts = vm.$options = Object.create(vm.constructor.options);
    var parentVnode = options._parentVnode;
    opts.parent = options.parent;
    opts._parentVnode = parentVnode;
    var vnodeComponentOptions = parentVnode.componentOptions;
    opts.propsData = vnodeComponentOptions.propsData;
    opts._parentListeners = vnodeComponentOptions.listeners;
    opts._renderChildren = vnodeComponentOptions.children;
    opts._componentTag = vnodeComponentOptions.tag;
    if (options.render) {
      opts.render = options.render;
      opts.staticRenderFns = options.staticRenderFns;
    }
  }
  function resolveConstructorOptions(Ctor) {
    var options = Ctor.options;
    if (Ctor.super) {
      var superOptions = resolveConstructorOptions(Ctor.super);
      var cachedSuperOptions = Ctor.superOptions;
      if (superOptions !== cachedSuperOptions) {
        Ctor.superOptions = superOptions;
        var modifiedOptions = resolveModifiedOptions(Ctor);
        if (modifiedOptions) {
          extend(Ctor.extendOptions, modifiedOptions);
        }
        options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
        if (options.name) {
          options.components[options.name] = Ctor;
        }
      }
    }
    return options;
  }
  function resolveModifiedOptions(Ctor) {
    var modified;
    var latest = Ctor.options;
    var sealed = Ctor.sealedOptions;
    for (var key in latest) {
      if (latest[key] !== sealed[key]) {
        if (!modified)
          modified = {};
        modified[key] = latest[key];
      }
    }
    return modified;
  }
  function Vue(options) {
    if (false) {
      warn("Vue is a constructor and should be called with the `new` keyword");
    }
    this._init(options);
  }
  initMixin$1(Vue);
  stateMixin(Vue);
  eventsMixin(Vue);
  lifecycleMixin(Vue);
  renderMixin(Vue);
  function initUse(Vue4) {
    Vue4.use = function(plugin) {
      var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
      if (installedPlugins.indexOf(plugin) > -1) {
        return this;
      }
      var args = toArray(arguments, 1);
      args.unshift(this);
      if (isFunction(plugin.install)) {
        plugin.install.apply(plugin, args);
      } else if (isFunction(plugin)) {
        plugin.apply(null, args);
      }
      installedPlugins.push(plugin);
      return this;
    };
  }
  function initMixin(Vue4) {
    Vue4.mixin = function(mixin) {
      this.options = mergeOptions(this.options, mixin);
      return this;
    };
  }
  function initExtend(Vue4) {
    Vue4.cid = 0;
    var cid = 1;
    Vue4.extend = function(extendOptions) {
      extendOptions = extendOptions || {};
      var Super = this;
      var SuperId = Super.cid;
      var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
      if (cachedCtors[SuperId]) {
        return cachedCtors[SuperId];
      }
      var name = getComponentName(extendOptions) || getComponentName(Super.options);
      if (false) {
        validateComponentName(name);
      }
      var Sub = function VueComponent(options) {
        this._init(options);
      };
      Sub.prototype = Object.create(Super.prototype);
      Sub.prototype.constructor = Sub;
      Sub.cid = cid++;
      Sub.options = mergeOptions(Super.options, extendOptions);
      Sub["super"] = Super;
      if (Sub.options.props) {
        initProps(Sub);
      }
      if (Sub.options.computed) {
        initComputed(Sub);
      }
      Sub.extend = Super.extend;
      Sub.mixin = Super.mixin;
      Sub.use = Super.use;
      ASSET_TYPES.forEach(function(type) {
        Sub[type] = Super[type];
      });
      if (name) {
        Sub.options.components[name] = Sub;
      }
      Sub.superOptions = Super.options;
      Sub.extendOptions = extendOptions;
      Sub.sealedOptions = extend({}, Sub.options);
      cachedCtors[SuperId] = Sub;
      return Sub;
    };
  }
  function initProps(Comp) {
    var props2 = Comp.options.props;
    for (var key in props2) {
      proxy(Comp.prototype, "_props", key);
    }
  }
  function initComputed(Comp) {
    var computed = Comp.options.computed;
    for (var key in computed) {
      defineComputed(Comp.prototype, key, computed[key]);
    }
  }
  function initAssetRegisters(Vue4) {
    ASSET_TYPES.forEach(function(type) {
      Vue4[type] = function(id, definition) {
        if (!definition) {
          return this.options[type + "s"][id];
        } else {
          if (false) {
            validateComponentName(id);
          }
          if (type === "component" && isPlainObject(definition)) {
            definition.name = definition.name || id;
            definition = this.options._base.extend(definition);
          }
          if (type === "directive" && isFunction(definition)) {
            definition = { bind: definition, update: definition };
          }
          this.options[type + "s"][id] = definition;
          return definition;
        }
      };
    });
  }
  function _getComponentName(opts) {
    return opts && (getComponentName(opts.Ctor.options) || opts.tag);
  }
  function matches(pattern, name) {
    if (isArray(pattern)) {
      return pattern.indexOf(name) > -1;
    } else if (typeof pattern === "string") {
      return pattern.split(",").indexOf(name) > -1;
    } else if (isRegExp(pattern)) {
      return pattern.test(name);
    }
    return false;
  }
  function pruneCache(keepAliveInstance, filter) {
    var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode, $vnode = keepAliveInstance.$vnode;
    for (var key in cache) {
      var entry = cache[key];
      if (entry) {
        var name_1 = entry.name;
        if (name_1 && !filter(name_1)) {
          pruneCacheEntry(cache, key, keys, _vnode);
        }
      }
    }
    $vnode.componentOptions.children = void 0;
  }
  function pruneCacheEntry(cache, key, keys, current) {
    var entry = cache[key];
    if (entry && (!current || entry.tag !== current.tag)) {
      entry.componentInstance.$destroy();
    }
    cache[key] = null;
    remove$2(keys, key);
  }
  var patternTypes = [String, RegExp, Array];
  var KeepAlive = {
    name: "keep-alive",
    abstract: true,
    props: {
      include: patternTypes,
      exclude: patternTypes,
      max: [String, Number]
    },
    methods: {
      cacheVNode: function() {
        var _a = this, cache = _a.cache, keys = _a.keys, vnodeToCache = _a.vnodeToCache, keyToCache = _a.keyToCache;
        if (vnodeToCache) {
          var tag = vnodeToCache.tag, componentInstance = vnodeToCache.componentInstance, componentOptions = vnodeToCache.componentOptions;
          cache[keyToCache] = {
            name: _getComponentName(componentOptions),
            tag,
            componentInstance
          };
          keys.push(keyToCache);
          if (this.max && keys.length > parseInt(this.max)) {
            pruneCacheEntry(cache, keys[0], keys, this._vnode);
          }
          this.vnodeToCache = null;
        }
      }
    },
    created: function() {
      this.cache = /* @__PURE__ */ Object.create(null);
      this.keys = [];
    },
    destroyed: function() {
      for (var key in this.cache) {
        pruneCacheEntry(this.cache, key, this.keys);
      }
    },
    mounted: function() {
      var _this = this;
      this.cacheVNode();
      this.$watch("include", function(val) {
        pruneCache(_this, function(name) {
          return matches(val, name);
        });
      });
      this.$watch("exclude", function(val) {
        pruneCache(_this, function(name) {
          return !matches(val, name);
        });
      });
    },
    updated: function() {
      this.cacheVNode();
    },
    render: function() {
      var slot = this.$slots.default;
      var vnode = getFirstComponentChild(slot);
      var componentOptions = vnode && vnode.componentOptions;
      if (componentOptions) {
        var name_2 = _getComponentName(componentOptions);
        var _a = this, include = _a.include, exclude = _a.exclude;
        if (
          // not included
          include && (!name_2 || !matches(include, name_2)) || // excluded
          exclude && name_2 && matches(exclude, name_2)
        ) {
          return vnode;
        }
        var _b = this, cache = _b.cache, keys = _b.keys;
        var key = vnode.key == null ? (
          // same constructor may get registered as different local components
          // so cid alone is not enough (#3269)
          componentOptions.Ctor.cid + (componentOptions.tag ? "::".concat(componentOptions.tag) : "")
        ) : vnode.key;
        if (cache[key]) {
          vnode.componentInstance = cache[key].componentInstance;
          remove$2(keys, key);
          keys.push(key);
        } else {
          this.vnodeToCache = vnode;
          this.keyToCache = key;
        }
        vnode.data.keepAlive = true;
      }
      return vnode || slot && slot[0];
    }
  };
  var builtInComponents = {
    KeepAlive
  };
  function initGlobalAPI(Vue4) {
    var configDef = {};
    configDef.get = function() {
      return config;
    };
    if (false) {
      configDef.set = function() {
        warn("Do not replace the Vue.config object, set individual fields instead.");
      };
    }
    Object.defineProperty(Vue4, "config", configDef);
    Vue4.util = {
      warn,
      extend,
      mergeOptions,
      defineReactive
    };
    Vue4.set = set;
    Vue4.delete = del;
    Vue4.nextTick = nextTick;
    Vue4.observable = function(obj) {
      observe(obj);
      return obj;
    };
    Vue4.options = /* @__PURE__ */ Object.create(null);
    ASSET_TYPES.forEach(function(type) {
      Vue4.options[type + "s"] = /* @__PURE__ */ Object.create(null);
    });
    Vue4.options._base = Vue4;
    extend(Vue4.options.components, builtInComponents);
    initUse(Vue4);
    initMixin(Vue4);
    initExtend(Vue4);
    initAssetRegisters(Vue4);
  }
  initGlobalAPI(Vue);
  Object.defineProperty(Vue.prototype, "$isServer", {
    get: isServerRendering
  });
  Object.defineProperty(Vue.prototype, "$ssrContext", {
    get: function() {
      return this.$vnode && this.$vnode.ssrContext;
    }
  });
  Object.defineProperty(Vue, "FunctionalRenderContext", {
    value: FunctionalRenderContext
  });
  Vue.version = version;
  var isReservedAttr = makeMap("style,class");
  var acceptValue = makeMap("input,textarea,option,select,progress");
  var mustUseProp = function(tag, type, attr) {
    return attr === "value" && acceptValue(tag) && type !== "button" || attr === "selected" && tag === "option" || attr === "checked" && tag === "input" || attr === "muted" && tag === "video";
  };
  var isEnumeratedAttr = makeMap("contenteditable,draggable,spellcheck");
  var isValidContentEditableValue = makeMap("events,caret,typing,plaintext-only");
  var convertEnumeratedValue = function(key, value) {
    return isFalsyAttrValue(value) || value === "false" ? "false" : (
      // allow arbitrary string value for contenteditable
      key === "contenteditable" && isValidContentEditableValue(value) ? value : "true"
    );
  };
  var isBooleanAttr = makeMap("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible");
  var xlinkNS = "http://www.w3.org/1999/xlink";
  var isXlink = function(name) {
    return name.charAt(5) === ":" && name.slice(0, 5) === "xlink";
  };
  var getXlinkProp = function(name) {
    return isXlink(name) ? name.slice(6, name.length) : "";
  };
  var isFalsyAttrValue = function(val) {
    return val == null || val === false;
  };
  function genClassForVnode(vnode) {
    var data = vnode.data;
    var parentNode2 = vnode;
    var childNode = vnode;
    while (isDef(childNode.componentInstance)) {
      childNode = childNode.componentInstance._vnode;
      if (childNode && childNode.data) {
        data = mergeClassData(childNode.data, data);
      }
    }
    while (isDef(parentNode2 = parentNode2.parent)) {
      if (parentNode2 && parentNode2.data) {
        data = mergeClassData(data, parentNode2.data);
      }
    }
    return renderClass(data.staticClass, data.class);
  }
  function mergeClassData(child, parent) {
    return {
      staticClass: concat(child.staticClass, parent.staticClass),
      class: isDef(child.class) ? [child.class, parent.class] : parent.class
    };
  }
  function renderClass(staticClass, dynamicClass) {
    if (isDef(staticClass) || isDef(dynamicClass)) {
      return concat(staticClass, stringifyClass(dynamicClass));
    }
    return "";
  }
  function concat(a, b) {
    return a ? b ? a + " " + b : a : b || "";
  }
  function stringifyClass(value) {
    if (Array.isArray(value)) {
      return stringifyArray(value);
    }
    if (isObject(value)) {
      return stringifyObject(value);
    }
    if (typeof value === "string") {
      return value;
    }
    return "";
  }
  function stringifyArray(value) {
    var res = "";
    var stringified;
    for (var i = 0, l = value.length; i < l; i++) {
      if (isDef(stringified = stringifyClass(value[i])) && stringified !== "") {
        if (res)
          res += " ";
        res += stringified;
      }
    }
    return res;
  }
  function stringifyObject(value) {
    var res = "";
    for (var key in value) {
      if (value[key]) {
        if (res)
          res += " ";
        res += key;
      }
    }
    return res;
  }
  var namespaceMap = {
    svg: "http://www.w3.org/2000/svg",
    math: "http://www.w3.org/1998/Math/MathML"
  };
  var isHTMLTag = makeMap("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot");
  var isSVG = makeMap("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view", true);
  var isReservedTag = function(tag) {
    return isHTMLTag(tag) || isSVG(tag);
  };
  function getTagNamespace(tag) {
    if (isSVG(tag)) {
      return "svg";
    }
    if (tag === "math") {
      return "math";
    }
  }
  var unknownElementCache = /* @__PURE__ */ Object.create(null);
  function isUnknownElement(tag) {
    if (!inBrowser) {
      return true;
    }
    if (isReservedTag(tag)) {
      return false;
    }
    tag = tag.toLowerCase();
    if (unknownElementCache[tag] != null) {
      return unknownElementCache[tag];
    }
    var el = document.createElement(tag);
    if (tag.indexOf("-") > -1) {
      return unknownElementCache[tag] = el.constructor === window.HTMLUnknownElement || el.constructor === window.HTMLElement;
    } else {
      return unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString());
    }
  }
  var isTextInputType = makeMap("text,number,password,search,email,tel,url");
  function query(el) {
    if (typeof el === "string") {
      var selected = document.querySelector(el);
      if (!selected) {
        return document.createElement("div");
      }
      return selected;
    } else {
      return el;
    }
  }
  function createElement(tagName2, vnode) {
    var elm = document.createElement(tagName2);
    if (tagName2 !== "select") {
      return elm;
    }
    if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== void 0) {
      elm.setAttribute("multiple", "multiple");
    }
    return elm;
  }
  function createElementNS(namespace, tagName2) {
    return document.createElementNS(namespaceMap[namespace], tagName2);
  }
  function createTextNode(text) {
    return document.createTextNode(text);
  }
  function createComment(text) {
    return document.createComment(text);
  }
  function insertBefore(parentNode2, newNode, referenceNode) {
    parentNode2.insertBefore(newNode, referenceNode);
  }
  function removeChild(node, child) {
    node.removeChild(child);
  }
  function appendChild(node, child) {
    node.appendChild(child);
  }
  function parentNode(node) {
    return node.parentNode;
  }
  function nextSibling(node) {
    return node.nextSibling;
  }
  function tagName(node) {
    return node.tagName;
  }
  function setTextContent(node, text) {
    node.textContent = text;
  }
  function setStyleScope(node, scopeId) {
    node.setAttribute(scopeId, "");
  }
  var nodeOps = /* @__PURE__ */ Object.freeze({
    __proto__: null,
    createElement,
    createElementNS,
    createTextNode,
    createComment,
    insertBefore,
    removeChild,
    appendChild,
    parentNode,
    nextSibling,
    tagName,
    setTextContent,
    setStyleScope
  });
  var ref = {
    create: function(_, vnode) {
      registerRef(vnode);
    },
    update: function(oldVnode, vnode) {
      if (oldVnode.data.ref !== vnode.data.ref) {
        registerRef(oldVnode, true);
        registerRef(vnode);
      }
    },
    destroy: function(vnode) {
      registerRef(vnode, true);
    }
  };
  function registerRef(vnode, isRemoval) {
    var ref2 = vnode.data.ref;
    if (!isDef(ref2))
      return;
    var vm = vnode.context;
    var refValue = vnode.componentInstance || vnode.elm;
    var value = isRemoval ? null : refValue;
    var $refsValue = isRemoval ? void 0 : refValue;
    if (isFunction(ref2)) {
      invokeWithErrorHandling(ref2, vm, [value], vm, "template ref function");
      return;
    }
    var isFor = vnode.data.refInFor;
    var _isString = typeof ref2 === "string" || typeof ref2 === "number";
    var _isRef = isRef(ref2);
    var refs = vm.$refs;
    if (_isString || _isRef) {
      if (isFor) {
        var existing = _isString ? refs[ref2] : ref2.value;
        if (isRemoval) {
          isArray(existing) && remove$2(existing, refValue);
        } else {
          if (!isArray(existing)) {
            if (_isString) {
              refs[ref2] = [refValue];
              setSetupRef(vm, ref2, refs[ref2]);
            } else {
              ref2.value = [refValue];
            }
          } else if (!existing.includes(refValue)) {
            existing.push(refValue);
          }
        }
      } else if (_isString) {
        if (isRemoval && refs[ref2] !== refValue) {
          return;
        }
        refs[ref2] = $refsValue;
        setSetupRef(vm, ref2, value);
      } else if (_isRef) {
        if (isRemoval && ref2.value !== refValue) {
          return;
        }
        ref2.value = value;
      } else if (false) {
        warn("Invalid template ref type: ".concat(typeof ref2));
      }
    }
  }
  function setSetupRef(_a, key, val) {
    var _setupState = _a._setupState;
    if (_setupState && hasOwn(_setupState, key)) {
      if (isRef(_setupState[key])) {
        _setupState[key].value = val;
      } else {
        _setupState[key] = val;
      }
    }
  }
  var emptyNode = new VNode("", {}, []);
  var hooks = ["create", "activate", "update", "remove", "destroy"];
  function sameVnode(a, b) {
    return a.key === b.key && a.asyncFactory === b.asyncFactory && (a.tag === b.tag && a.isComment === b.isComment && isDef(a.data) === isDef(b.data) && sameInputType(a, b) || isTrue(a.isAsyncPlaceholder) && isUndef(b.asyncFactory.error));
  }
  function sameInputType(a, b) {
    if (a.tag !== "input")
      return true;
    var i;
    var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;
    var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;
    return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB);
  }
  function createKeyToOldIdx(children, beginIdx, endIdx) {
    var i, key;
    var map = {};
    for (i = beginIdx; i <= endIdx; ++i) {
      key = children[i].key;
      if (isDef(key))
        map[key] = i;
    }
    return map;
  }
  function createPatchFunction(backend) {
    var i, j;
    var cbs = {};
    var modules2 = backend.modules, nodeOps2 = backend.nodeOps;
    for (i = 0; i < hooks.length; ++i) {
      cbs[hooks[i]] = [];
      for (j = 0; j < modules2.length; ++j) {
        if (isDef(modules2[j][hooks[i]])) {
          cbs[hooks[i]].push(modules2[j][hooks[i]]);
        }
      }
    }
    function emptyNodeAt(elm) {
      return new VNode(nodeOps2.tagName(elm).toLowerCase(), {}, [], void 0, elm);
    }
    function createRmCb(childElm, listeners) {
      function remove2() {
        if (--remove2.listeners === 0) {
          removeNode(childElm);
        }
      }
      remove2.listeners = listeners;
      return remove2;
    }
    function removeNode(el) {
      var parent = nodeOps2.parentNode(el);
      if (isDef(parent)) {
        nodeOps2.removeChild(parent, el);
      }
    }
    function isUnknownElement2(vnode, inVPre) {
      return !inVPre && !vnode.ns && !(config.ignoredElements.length && config.ignoredElements.some(function(ignore) {
        return isRegExp(ignore) ? ignore.test(vnode.tag) : ignore === vnode.tag;
      })) && config.isUnknownElement(vnode.tag);
    }
    var creatingElmInVPre = 0;
    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index3) {
      if (isDef(vnode.elm) && isDef(ownerArray)) {
        vnode = ownerArray[index3] = cloneVNode(vnode);
      }
      vnode.isRootInsert = !nested;
      if (createComponent2(vnode, insertedVnodeQueue, parentElm, refElm)) {
        return;
      }
      var data = vnode.data;
      var children = vnode.children;
      var tag = vnode.tag;
      if (isDef(tag)) {
        if (false) {
          if (data && data.pre) {
            creatingElmInVPre++;
          }
          if (isUnknownElement2(vnode, creatingElmInVPre)) {
            warn("Unknown custom element: <" + tag + '> - did you register the component correctly? For recursive components, make sure to provide the "name" option.', vnode.context);
          }
        }
        vnode.elm = vnode.ns ? nodeOps2.createElementNS(vnode.ns, tag) : nodeOps2.createElement(tag, vnode);
        setScope(vnode);
        createChildren(vnode, children, insertedVnodeQueue);
        if (isDef(data)) {
          invokeCreateHooks(vnode, insertedVnodeQueue);
        }
        insert(parentElm, vnode.elm, refElm);
        if (false) {
          creatingElmInVPre--;
        }
      } else if (isTrue(vnode.isComment)) {
        vnode.elm = nodeOps2.createComment(vnode.text);
        insert(parentElm, vnode.elm, refElm);
      } else {
        vnode.elm = nodeOps2.createTextNode(vnode.text);
        insert(parentElm, vnode.elm, refElm);
      }
    }
    function createComponent2(vnode, insertedVnodeQueue, parentElm, refElm) {
      var i2 = vnode.data;
      if (isDef(i2)) {
        var isReactivated = isDef(vnode.componentInstance) && i2.keepAlive;
        if (isDef(i2 = i2.hook) && isDef(i2 = i2.init)) {
          i2(
            vnode,
            false
            /* hydrating */
          );
        }
        if (isDef(vnode.componentInstance)) {
          initComponent(vnode, insertedVnodeQueue);
          insert(parentElm, vnode.elm, refElm);
          if (isTrue(isReactivated)) {
            reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
          }
          return true;
        }
      }
    }
    function initComponent(vnode, insertedVnodeQueue) {
      if (isDef(vnode.data.pendingInsert)) {
        insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
        vnode.data.pendingInsert = null;
      }
      vnode.elm = vnode.componentInstance.$el;
      if (isPatchable(vnode)) {
        invokeCreateHooks(vnode, insertedVnodeQueue);
        setScope(vnode);
      } else {
        registerRef(vnode);
        insertedVnodeQueue.push(vnode);
      }
    }
    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
      var i2;
      var innerNode = vnode;
      while (innerNode.componentInstance) {
        innerNode = innerNode.componentInstance._vnode;
        if (isDef(i2 = innerNode.data) && isDef(i2 = i2.transition)) {
          for (i2 = 0; i2 < cbs.activate.length; ++i2) {
            cbs.activate[i2](emptyNode, innerNode);
          }
          insertedVnodeQueue.push(innerNode);
          break;
        }
      }
      insert(parentElm, vnode.elm, refElm);
    }
    function insert(parent, elm, ref2) {
      if (isDef(parent)) {
        if (isDef(ref2)) {
          if (nodeOps2.parentNode(ref2) === parent) {
            nodeOps2.insertBefore(parent, elm, ref2);
          }
        } else {
          nodeOps2.appendChild(parent, elm);
        }
      }
    }
    function createChildren(vnode, children, insertedVnodeQueue) {
      if (isArray(children)) {
        if (false) {
          checkDuplicateKeys(children);
        }
        for (var i_1 = 0; i_1 < children.length; ++i_1) {
          createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
        }
      } else if (isPrimitive(vnode.text)) {
        nodeOps2.appendChild(vnode.elm, nodeOps2.createTextNode(String(vnode.text)));
      }
    }
    function isPatchable(vnode) {
      while (vnode.componentInstance) {
        vnode = vnode.componentInstance._vnode;
      }
      return isDef(vnode.tag);
    }
    function invokeCreateHooks(vnode, insertedVnodeQueue) {
      for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
        cbs.create[i_2](emptyNode, vnode);
      }
      i = vnode.data.hook;
      if (isDef(i)) {
        if (isDef(i.create))
          i.create(emptyNode, vnode);
        if (isDef(i.insert))
          insertedVnodeQueue.push(vnode);
      }
    }
    function setScope(vnode) {
      var i2;
      if (isDef(i2 = vnode.fnScopeId)) {
        nodeOps2.setStyleScope(vnode.elm, i2);
      } else {
        var ancestor = vnode;
        while (ancestor) {
          if (isDef(i2 = ancestor.context) && isDef(i2 = i2.$options._scopeId)) {
            nodeOps2.setStyleScope(vnode.elm, i2);
          }
          ancestor = ancestor.parent;
        }
      }
      if (isDef(i2 = activeInstance) && i2 !== vnode.context && i2 !== vnode.fnContext && isDef(i2 = i2.$options._scopeId)) {
        nodeOps2.setStyleScope(vnode.elm, i2);
      }
    }
    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
      for (; startIdx <= endIdx; ++startIdx) {
        createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
      }
    }
    function invokeDestroyHook(vnode) {
      var i2, j2;
      var data = vnode.data;
      if (isDef(data)) {
        if (isDef(i2 = data.hook) && isDef(i2 = i2.destroy))
          i2(vnode);
        for (i2 = 0; i2 < cbs.destroy.length; ++i2)
          cbs.destroy[i2](vnode);
      }
      if (isDef(i2 = vnode.children)) {
        for (j2 = 0; j2 < vnode.children.length; ++j2) {
          invokeDestroyHook(vnode.children[j2]);
        }
      }
    }
    function removeVnodes(vnodes, startIdx, endIdx) {
      for (; startIdx <= endIdx; ++startIdx) {
        var ch = vnodes[startIdx];
        if (isDef(ch)) {
          if (isDef(ch.tag)) {
            removeAndInvokeRemoveHook(ch);
            invokeDestroyHook(ch);
          } else {
            removeNode(ch.elm);
          }
        }
      }
    }
    function removeAndInvokeRemoveHook(vnode, rm) {
      if (isDef(rm) || isDef(vnode.data)) {
        var i_3;
        var listeners = cbs.remove.length + 1;
        if (isDef(rm)) {
          rm.listeners += listeners;
        } else {
          rm = createRmCb(vnode.elm, listeners);
        }
        if (isDef(i_3 = vnode.componentInstance) && isDef(i_3 = i_3._vnode) && isDef(i_3.data)) {
          removeAndInvokeRemoveHook(i_3, rm);
        }
        for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
          cbs.remove[i_3](vnode, rm);
        }
        if (isDef(i_3 = vnode.data.hook) && isDef(i_3 = i_3.remove)) {
          i_3(vnode, rm);
        } else {
          rm();
        }
      } else {
        removeNode(vnode.elm);
      }
    }
    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
      var oldStartIdx = 0;
      var newStartIdx = 0;
      var oldEndIdx = oldCh.length - 1;
      var oldStartVnode = oldCh[0];
      var oldEndVnode = oldCh[oldEndIdx];
      var newEndIdx = newCh.length - 1;
      var newStartVnode = newCh[0];
      var newEndVnode = newCh[newEndIdx];
      var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
      var canMove = !removeOnly;
      if (false) {
        checkDuplicateKeys(newCh);
      }
      while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
        if (isUndef(oldStartVnode)) {
          oldStartVnode = oldCh[++oldStartIdx];
        } else if (isUndef(oldEndVnode)) {
          oldEndVnode = oldCh[--oldEndIdx];
        } else if (sameVnode(oldStartVnode, newStartVnode)) {
          patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
          oldStartVnode = oldCh[++oldStartIdx];
          newStartVnode = newCh[++newStartIdx];
        } else if (sameVnode(oldEndVnode, newEndVnode)) {
          patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
          oldEndVnode = oldCh[--oldEndIdx];
          newEndVnode = newCh[--newEndIdx];
        } else if (sameVnode(oldStartVnode, newEndVnode)) {
          patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
          canMove && nodeOps2.insertBefore(parentElm, oldStartVnode.elm, nodeOps2.nextSibling(oldEndVnode.elm));
          oldStartVnode = oldCh[++oldStartIdx];
          newEndVnode = newCh[--newEndIdx];
        } else if (sameVnode(oldEndVnode, newStartVnode)) {
          patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
          canMove && nodeOps2.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
          oldEndVnode = oldCh[--oldEndIdx];
          newStartVnode = newCh[++newStartIdx];
        } else {
          if (isUndef(oldKeyToIdx))
            oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
          idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
          if (isUndef(idxInOld)) {
            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
          } else {
            vnodeToMove = oldCh[idxInOld];
            if (sameVnode(vnodeToMove, newStartVnode)) {
              patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
              oldCh[idxInOld] = void 0;
              canMove && nodeOps2.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
            } else {
              createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
            }
          }
          newStartVnode = newCh[++newStartIdx];
        }
      }
      if (oldStartIdx > oldEndIdx) {
        refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
        addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
      } else if (newStartIdx > newEndIdx) {
        removeVnodes(oldCh, oldStartIdx, oldEndIdx);
      }
    }
    function checkDuplicateKeys(children) {
      var seenKeys = {};
      for (var i_4 = 0; i_4 < children.length; i_4++) {
        var vnode = children[i_4];
        var key = vnode.key;
        if (isDef(key)) {
          if (seenKeys[key]) {
            warn("Duplicate keys detected: '".concat(key, "'. This may cause an update error."), vnode.context);
          } else {
            seenKeys[key] = true;
          }
        }
      }
    }
    function findIdxInOld(node, oldCh, start, end) {
      for (var i_5 = start; i_5 < end; i_5++) {
        var c = oldCh[i_5];
        if (isDef(c) && sameVnode(node, c))
          return i_5;
      }
    }
    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index3, removeOnly) {
      if (oldVnode === vnode) {
        return;
      }
      if (isDef(vnode.elm) && isDef(ownerArray)) {
        vnode = ownerArray[index3] = cloneVNode(vnode);
      }
      var elm = vnode.elm = oldVnode.elm;
      if (isTrue(oldVnode.isAsyncPlaceholder)) {
        if (isDef(vnode.asyncFactory.resolved)) {
          hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
        } else {
          vnode.isAsyncPlaceholder = true;
        }
        return;
      }
      if (isTrue(vnode.isStatic) && isTrue(oldVnode.isStatic) && vnode.key === oldVnode.key && (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
        vnode.componentInstance = oldVnode.componentInstance;
        return;
      }
      var i2;
      var data = vnode.data;
      if (isDef(data) && isDef(i2 = data.hook) && isDef(i2 = i2.prepatch)) {
        i2(oldVnode, vnode);
      }
      var oldCh = oldVnode.children;
      var ch = vnode.children;
      if (isDef(data) && isPatchable(vnode)) {
        for (i2 = 0; i2 < cbs.update.length; ++i2)
          cbs.update[i2](oldVnode, vnode);
        if (isDef(i2 = data.hook) && isDef(i2 = i2.update))
          i2(oldVnode, vnode);
      }
      if (isUndef(vnode.text)) {
        if (isDef(oldCh) && isDef(ch)) {
          if (oldCh !== ch)
            updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
        } else if (isDef(ch)) {
          if (false) {
            checkDuplicateKeys(ch);
          }
          if (isDef(oldVnode.text))
            nodeOps2.setTextContent(elm, "");
          addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
        } else if (isDef(oldCh)) {
          removeVnodes(oldCh, 0, oldCh.length - 1);
        } else if (isDef(oldVnode.text)) {
          nodeOps2.setTextContent(elm, "");
        }
      } else if (oldVnode.text !== vnode.text) {
        nodeOps2.setTextContent(elm, vnode.text);
      }
      if (isDef(data)) {
        if (isDef(i2 = data.hook) && isDef(i2 = i2.postpatch))
          i2(oldVnode, vnode);
      }
    }
    function invokeInsertHook(vnode, queue2, initial) {
      if (isTrue(initial) && isDef(vnode.parent)) {
        vnode.parent.data.pendingInsert = queue2;
      } else {
        for (var i_6 = 0; i_6 < queue2.length; ++i_6) {
          queue2[i_6].data.hook.insert(queue2[i_6]);
        }
      }
    }
    var hydrationBailed = false;
    var isRenderedModule = makeMap("attrs,class,staticClass,staticStyle,key");
    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
      var i2;
      var tag = vnode.tag, data = vnode.data, children = vnode.children;
      inVPre = inVPre || data && data.pre;
      vnode.elm = elm;
      if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
        vnode.isAsyncPlaceholder = true;
        return true;
      }
      if (false) {
        if (!assertNodeMatch(elm, vnode, inVPre)) {
          return false;
        }
      }
      if (isDef(data)) {
        if (isDef(i2 = data.hook) && isDef(i2 = i2.init))
          i2(
            vnode,
            true
            /* hydrating */
          );
        if (isDef(i2 = vnode.componentInstance)) {
          initComponent(vnode, insertedVnodeQueue);
          return true;
        }
      }
      if (isDef(tag)) {
        if (isDef(children)) {
          if (!elm.hasChildNodes()) {
            createChildren(vnode, children, insertedVnodeQueue);
          } else {
            if (isDef(i2 = data) && isDef(i2 = i2.domProps) && isDef(i2 = i2.innerHTML)) {
              if (i2 !== elm.innerHTML) {
                if (false) {
                  hydrationBailed = true;
                  console.warn("Parent: ", elm);
                  console.warn("server innerHTML: ", i2);
                  console.warn("client innerHTML: ", elm.innerHTML);
                }
                return false;
              }
            } else {
              var childrenMatch = true;
              var childNode = elm.firstChild;
              for (var i_7 = 0; i_7 < children.length; i_7++) {
                if (!childNode || !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
                  childrenMatch = false;
                  break;
                }
                childNode = childNode.nextSibling;
              }
              if (!childrenMatch || childNode) {
                if (false) {
                  hydrationBailed = true;
                  console.warn("Parent: ", elm);
                  console.warn("Mismatching childNodes vs. VNodes: ", elm.childNodes, children);
                }
                return false;
              }
            }
          }
        }
        if (isDef(data)) {
          var fullInvoke = false;
          for (var key in data) {
            if (!isRenderedModule(key)) {
              fullInvoke = true;
              invokeCreateHooks(vnode, insertedVnodeQueue);
              break;
            }
          }
          if (!fullInvoke && data["class"]) {
            traverse(data["class"]);
          }
        }
      } else if (elm.data !== vnode.text) {
        elm.data = vnode.text;
      }
      return true;
    }
    function assertNodeMatch(node, vnode, inVPre) {
      if (isDef(vnode.tag)) {
        return vnode.tag.indexOf("vue-component") === 0 || !isUnknownElement2(vnode, inVPre) && vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase());
      } else {
        return node.nodeType === (vnode.isComment ? 8 : 3);
      }
    }
    return function patch2(oldVnode, vnode, hydrating, removeOnly) {
      if (isUndef(vnode)) {
        if (isDef(oldVnode))
          invokeDestroyHook(oldVnode);
        return;
      }
      var isInitialPatch = false;
      var insertedVnodeQueue = [];
      if (isUndef(oldVnode)) {
        isInitialPatch = true;
        createElm(vnode, insertedVnodeQueue);
      } else {
        var isRealElement = isDef(oldVnode.nodeType);
        if (!isRealElement && sameVnode(oldVnode, vnode)) {
          patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
        } else {
          if (isRealElement) {
            if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
              oldVnode.removeAttribute(SSR_ATTR);
              hydrating = true;
            }
            if (isTrue(hydrating)) {
              if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
                invokeInsertHook(vnode, insertedVnodeQueue, true);
                return oldVnode;
              } else if (false) {
                warn("The client-side rendered virtual DOM tree is not matching server-rendered content. This is likely caused by incorrect HTML markup, for example nesting block-level elements inside <p>, or missing <tbody>. Bailing hydration and performing full client-side render.");
              }
            }
            oldVnode = emptyNodeAt(oldVnode);
          }
          var oldElm = oldVnode.elm;
          var parentElm = nodeOps2.parentNode(oldElm);
          createElm(
            vnode,
            insertedVnodeQueue,
            // extremely rare edge case: do not insert if old element is in a
            // leaving transition. Only happens when combining transition +
            // keep-alive + HOCs. (#4590)
            oldElm._leaveCb ? null : parentElm,
            nodeOps2.nextSibling(oldElm)
          );
          if (isDef(vnode.parent)) {
            var ancestor = vnode.parent;
            var patchable = isPatchable(vnode);
            while (ancestor) {
              for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
                cbs.destroy[i_8](ancestor);
              }
              ancestor.elm = vnode.elm;
              if (patchable) {
                for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
                  cbs.create[i_9](emptyNode, ancestor);
                }
                var insert_1 = ancestor.data.hook.insert;
                if (insert_1.merged) {
                  var cloned = insert_1.fns.slice(1);
                  for (var i_10 = 0; i_10 < cloned.length; i_10++) {
                    cloned[i_10]();
                  }
                }
              } else {
                registerRef(ancestor);
              }
              ancestor = ancestor.parent;
            }
          }
          if (isDef(parentElm)) {
            removeVnodes([oldVnode], 0, 0);
          } else if (isDef(oldVnode.tag)) {
            invokeDestroyHook(oldVnode);
          }
        }
      }
      invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
      return vnode.elm;
    };
  }
  var directives = {
    create: updateDirectives,
    update: updateDirectives,
    destroy: function unbindDirectives(vnode) {
      updateDirectives(vnode, emptyNode);
    }
  };
  function updateDirectives(oldVnode, vnode) {
    if (oldVnode.data.directives || vnode.data.directives) {
      _update(oldVnode, vnode);
    }
  }
  function _update(oldVnode, vnode) {
    var isCreate = oldVnode === emptyNode;
    var isDestroy = vnode === emptyNode;
    var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
    var dirsWithInsert = [];
    var dirsWithPostpatch = [];
    var key, oldDir, dir;
    for (key in newDirs) {
      oldDir = oldDirs[key];
      dir = newDirs[key];
      if (!oldDir) {
        callHook(dir, "bind", vnode, oldVnode);
        if (dir.def && dir.def.inserted) {
          dirsWithInsert.push(dir);
        }
      } else {
        dir.oldValue = oldDir.value;
        dir.oldArg = oldDir.arg;
        callHook(dir, "update", vnode, oldVnode);
        if (dir.def && dir.def.componentUpdated) {
          dirsWithPostpatch.push(dir);
        }
      }
    }
    if (dirsWithInsert.length) {
      var callInsert = function() {
        for (var i = 0; i < dirsWithInsert.length; i++) {
          callHook(dirsWithInsert[i], "inserted", vnode, oldVnode);
        }
      };
      if (isCreate) {
        mergeVNodeHook(vnode, "insert", callInsert);
      } else {
        callInsert();
      }
    }
    if (dirsWithPostpatch.length) {
      mergeVNodeHook(vnode, "postpatch", function() {
        for (var i = 0; i < dirsWithPostpatch.length; i++) {
          callHook(dirsWithPostpatch[i], "componentUpdated", vnode, oldVnode);
        }
      });
    }
    if (!isCreate) {
      for (key in oldDirs) {
        if (!newDirs[key]) {
          callHook(oldDirs[key], "unbind", oldVnode, oldVnode, isDestroy);
        }
      }
    }
  }
  var emptyModifiers = /* @__PURE__ */ Object.create(null);
  function normalizeDirectives(dirs, vm) {
    var res = /* @__PURE__ */ Object.create(null);
    if (!dirs) {
      return res;
    }
    var i, dir;
    for (i = 0; i < dirs.length; i++) {
      dir = dirs[i];
      if (!dir.modifiers) {
        dir.modifiers = emptyModifiers;
      }
      res[getRawDirName(dir)] = dir;
      if (vm._setupState && vm._setupState.__sfc) {
        var setupDef = dir.def || resolveAsset(vm, "_setupState", "v-" + dir.name);
        if (typeof setupDef === "function") {
          dir.def = {
            bind: setupDef,
            update: setupDef
          };
        } else {
          dir.def = setupDef;
        }
      }
      dir.def = dir.def || resolveAsset(vm.$options, "directives", dir.name, true);
    }
    return res;
  }
  function getRawDirName(dir) {
    return dir.rawName || "".concat(dir.name, ".").concat(Object.keys(dir.modifiers || {}).join("."));
  }
  function callHook(dir, hook, vnode, oldVnode, isDestroy) {
    var fn = dir.def && dir.def[hook];
    if (fn) {
      try {
        fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
      } catch (e) {
        handleError(e, vnode.context, "directive ".concat(dir.name, " ").concat(hook, " hook"));
      }
    }
  }
  var baseModules = [ref, directives];
  function updateAttrs(oldVnode, vnode) {
    var opts = vnode.componentOptions;
    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
      return;
    }
    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
      return;
    }
    var key, cur, old;
    var elm = vnode.elm;
    var oldAttrs = oldVnode.data.attrs || {};
    var attrs2 = vnode.data.attrs || {};
    if (isDef(attrs2.__ob__) || isTrue(attrs2._v_attr_proxy)) {
      attrs2 = vnode.data.attrs = extend({}, attrs2);
    }
    for (key in attrs2) {
      cur = attrs2[key];
      old = oldAttrs[key];
      if (old !== cur) {
        setAttr(elm, key, cur, vnode.data.pre);
      }
    }
    if ((isIE || isEdge) && attrs2.value !== oldAttrs.value) {
      setAttr(elm, "value", attrs2.value);
    }
    for (key in oldAttrs) {
      if (isUndef(attrs2[key])) {
        if (isXlink(key)) {
          elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
        } else if (!isEnumeratedAttr(key)) {
          elm.removeAttribute(key);
        }
      }
    }
  }
  function setAttr(el, key, value, isInPre) {
    if (isInPre || el.tagName.indexOf("-") > -1) {
      baseSetAttr(el, key, value);
    } else if (isBooleanAttr(key)) {
      if (isFalsyAttrValue(value)) {
        el.removeAttribute(key);
      } else {
        value = key === "allowfullscreen" && el.tagName === "EMBED" ? "true" : key;
        el.setAttribute(key, value);
      }
    } else if (isEnumeratedAttr(key)) {
      el.setAttribute(key, convertEnumeratedValue(key, value));
    } else if (isXlink(key)) {
      if (isFalsyAttrValue(value)) {
        el.removeAttributeNS(xlinkNS, getXlinkProp(key));
      } else {
        el.setAttributeNS(xlinkNS, key, value);
      }
    } else {
      baseSetAttr(el, key, value);
    }
  }
  function baseSetAttr(el, key, value) {
    if (isFalsyAttrValue(value)) {
      el.removeAttribute(key);
    } else {
      if (isIE && !isIE9 && el.tagName === "TEXTAREA" && key === "placeholder" && value !== "" && !el.__ieph) {
        var blocker_1 = function(e) {
          e.stopImmediatePropagation();
          el.removeEventListener("input", blocker_1);
        };
        el.addEventListener("input", blocker_1);
        el.__ieph = true;
      }
      el.setAttribute(key, value);
    }
  }
  var attrs = {
    create: updateAttrs,
    update: updateAttrs
  };
  function updateClass(oldVnode, vnode) {
    var el = vnode.elm;
    var data = vnode.data;
    var oldData = oldVnode.data;
    if (isUndef(data.staticClass) && isUndef(data.class) && (isUndef(oldData) || isUndef(oldData.staticClass) && isUndef(oldData.class))) {
      return;
    }
    var cls = genClassForVnode(vnode);
    var transitionClass = el._transitionClasses;
    if (isDef(transitionClass)) {
      cls = concat(cls, stringifyClass(transitionClass));
    }
    if (cls !== el._prevClass) {
      el.setAttribute("class", cls);
      el._prevClass = cls;
    }
  }
  var klass = {
    create: updateClass,
    update: updateClass
  };
  var RANGE_TOKEN = "__r";
  var CHECKBOX_RADIO_TOKEN = "__c";
  function normalizeEvents(on) {
    if (isDef(on[RANGE_TOKEN])) {
      var event_1 = isIE ? "change" : "input";
      on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
      delete on[RANGE_TOKEN];
    }
    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
      on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
      delete on[CHECKBOX_RADIO_TOKEN];
    }
  }
  var target;
  function createOnceHandler(event, handler, capture) {
    var _target = target;
    return function onceHandler() {
      var res = handler.apply(null, arguments);
      if (res !== null) {
        remove(event, onceHandler, capture, _target);
      }
    };
  }
  var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
  function add(name, handler, capture, passive) {
    if (useMicrotaskFix) {
      var attachedTimestamp_1 = currentFlushTimestamp;
      var original_1 = handler;
      handler = original_1._wrapper = function(e) {
        if (
          // no bubbling, should always fire.
          // this is just a safety net in case event.timeStamp is unreliable in
          // certain weird environments...
          e.target === e.currentTarget || // event is fired after handler attachment
          e.timeStamp >= attachedTimestamp_1 || // bail for environments that have buggy event.timeStamp implementations
          // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
          // #9681 QtWebEngine event.timeStamp is negative value
          e.timeStamp <= 0 || // #9448 bail if event is fired in another document in a multi-page
          // electron/nw.js app, since event.timeStamp will be using a different
          // starting reference
          e.target.ownerDocument !== document
        ) {
          return original_1.apply(this, arguments);
        }
      };
    }
    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
  }
  function remove(name, handler, capture, _target) {
    (_target || target).removeEventListener(
      name,
      //@ts-expect-error
      handler._wrapper || handler,
      capture
    );
  }
  function updateDOMListeners(oldVnode, vnode) {
    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
      return;
    }
    var on = vnode.data.on || {};
    var oldOn = oldVnode.data.on || {};
    target = vnode.elm || oldVnode.elm;
    normalizeEvents(on);
    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
    target = void 0;
  }
  var events = {
    create: updateDOMListeners,
    update: updateDOMListeners,
    // @ts-expect-error emptyNode has actually data
    destroy: function(vnode) {
      return updateDOMListeners(vnode, emptyNode);
    }
  };
  var svgContainer;
  function updateDOMProps(oldVnode, vnode) {
    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
      return;
    }
    var key, cur;
    var elm = vnode.elm;
    var oldProps = oldVnode.data.domProps || {};
    var props2 = vnode.data.domProps || {};
    if (isDef(props2.__ob__) || isTrue(props2._v_attr_proxy)) {
      props2 = vnode.data.domProps = extend({}, props2);
    }
    for (key in oldProps) {
      if (!(key in props2)) {
        elm[key] = "";
      }
    }
    for (key in props2) {
      cur = props2[key];
      if (key === "textContent" || key === "innerHTML") {
        if (vnode.children)
          vnode.children.length = 0;
        if (cur === oldProps[key])
          continue;
        if (elm.childNodes.length === 1) {
          elm.removeChild(elm.childNodes[0]);
        }
      }
      if (key === "value" && elm.tagName !== "PROGRESS") {
        elm._value = cur;
        var strCur = isUndef(cur) ? "" : String(cur);
        if (shouldUpdateValue(elm, strCur)) {
          elm.value = strCur;
        }
      } else if (key === "innerHTML" && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {
        svgContainer = svgContainer || document.createElement("div");
        svgContainer.innerHTML = "<svg>".concat(cur, "</svg>");
        var svg = svgContainer.firstChild;
        while (elm.firstChild) {
          elm.removeChild(elm.firstChild);
        }
        while (svg.firstChild) {
          elm.appendChild(svg.firstChild);
        }
      } else if (
        // skip the update if old and new VDOM state is the same.
        // `value` is handled separately because the DOM value may be temporarily
        // out of sync with VDOM state due to focus, composition and modifiers.
        // This  #4521 by skipping the unnecessary `checked` update.
        cur !== oldProps[key]
      ) {
        try {
          elm[key] = cur;
        } catch (e) {
        }
      }
    }
  }
  function shouldUpdateValue(elm, checkVal) {
    return (
      //@ts-expect-error
      !elm.composing && (elm.tagName === "OPTION" || isNotInFocusAndDirty(elm, checkVal) || isDirtyWithModifiers(elm, checkVal))
    );
  }
  function isNotInFocusAndDirty(elm, checkVal) {
    var notInFocus = true;
    try {
      notInFocus = document.activeElement !== elm;
    } catch (e) {
    }
    return notInFocus && elm.value !== checkVal;
  }
  function isDirtyWithModifiers(elm, newVal) {
    var value = elm.value;
    var modifiers = elm._vModifiers;
    if (isDef(modifiers)) {
      if (modifiers.number) {
        return toNumber(value) !== toNumber(newVal);
      }
      if (modifiers.trim) {
        return value.trim() !== newVal.trim();
      }
    }
    return value !== newVal;
  }
  var domProps = {
    create: updateDOMProps,
    update: updateDOMProps
  };
  var parseStyleText = cached(function(cssText) {
    var res = {};
    var listDelimiter = /;(?![^(]*\))/g;
    var propertyDelimiter = /:(.+)/;
    cssText.split(listDelimiter).forEach(function(item) {
      if (item) {
        var tmp = item.split(propertyDelimiter);
        tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
      }
    });
    return res;
  });
  function normalizeStyleData(data) {
    var style2 = normalizeStyleBinding(data.style);
    return data.staticStyle ? extend(data.staticStyle, style2) : style2;
  }
  function normalizeStyleBinding(bindingStyle) {
    if (Array.isArray(bindingStyle)) {
      return toObject(bindingStyle);
    }
    if (typeof bindingStyle === "string") {
      return parseStyleText(bindingStyle);
    }
    return bindingStyle;
  }
  function getStyle(vnode, checkChild) {
    var res = {};
    var styleData;
    if (checkChild) {
      var childNode = vnode;
      while (childNode.componentInstance) {
        childNode = childNode.componentInstance._vnode;
        if (childNode && childNode.data && (styleData = normalizeStyleData(childNode.data))) {
          extend(res, styleData);
        }
      }
    }
    if (styleData = normalizeStyleData(vnode.data)) {
      extend(res, styleData);
    }
    var parentNode2 = vnode;
    while (parentNode2 = parentNode2.parent) {
      if (parentNode2.data && (styleData = normalizeStyleData(parentNode2.data))) {
        extend(res, styleData);
      }
    }
    return res;
  }
  var cssVarRE = /^--/;
  var importantRE = /\s*!important$/;
  var setProp = function(el, name, val) {
    if (cssVarRE.test(name)) {
      el.style.setProperty(name, val);
    } else if (importantRE.test(val)) {
      el.style.setProperty(hyphenate(name), val.replace(importantRE, ""), "important");
    } else {
      var normalizedName = normalize(name);
      if (Array.isArray(val)) {
        for (var i = 0, len = val.length; i < len; i++) {
          el.style[normalizedName] = val[i];
        }
      } else {
        el.style[normalizedName] = val;
      }
    }
  };
  var vendorNames = ["Webkit", "Moz", "ms"];
  var emptyStyle;
  var normalize = cached(function(prop) {
    emptyStyle = emptyStyle || document.createElement("div").style;
    prop = camelize(prop);
    if (prop !== "filter" && prop in emptyStyle) {
      return prop;
    }
    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
    for (var i = 0; i < vendorNames.length; i++) {
      var name_1 = vendorNames[i] + capName;
      if (name_1 in emptyStyle) {
        return name_1;
      }
    }
  });
  function updateStyle(oldVnode, vnode) {
    var data = vnode.data;
    var oldData = oldVnode.data;
    if (isUndef(data.staticStyle) && isUndef(data.style) && isUndef(oldData.staticStyle) && isUndef(oldData.style)) {
      return;
    }
    var cur, name;
    var el = vnode.elm;
    var oldStaticStyle = oldData.staticStyle;
    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
    var oldStyle = oldStaticStyle || oldStyleBinding;
    var style2 = normalizeStyleBinding(vnode.data.style) || {};
    vnode.data.normalizedStyle = isDef(style2.__ob__) ? extend({}, style2) : style2;
    var newStyle = getStyle(vnode, true);
    for (name in oldStyle) {
      if (isUndef(newStyle[name])) {
        setProp(el, name, "");
      }
    }
    for (name in newStyle) {
      cur = newStyle[name];
      setProp(el, name, cur == null ? "" : cur);
    }
  }
  var style = {
    create: updateStyle,
    update: updateStyle
  };
  var whitespaceRE = /\s+/;
  function addClass(el, cls) {
    if (!cls || !(cls = cls.trim())) {
      return;
    }
    if (el.classList) {
      if (cls.indexOf(" ") > -1) {
        cls.split(whitespaceRE).forEach(function(c) {
          return el.classList.add(c);
        });
      } else {
        el.classList.add(cls);
      }
    } else {
      var cur = " ".concat(el.getAttribute("class") || "", " ");
      if (cur.indexOf(" " + cls + " ") < 0) {
        el.setAttribute("class", (cur + cls).trim());
      }
    }
  }
  function removeClass(el, cls) {
    if (!cls || !(cls = cls.trim())) {
      return;
    }
    if (el.classList) {
      if (cls.indexOf(" ") > -1) {
        cls.split(whitespaceRE).forEach(function(c) {
          return el.classList.remove(c);
        });
      } else {
        el.classList.remove(cls);
      }
      if (!el.classList.length) {
        el.removeAttribute("class");
      }
    } else {
      var cur = " ".concat(el.getAttribute("class") || "", " ");
      var tar = " " + cls + " ";
      while (cur.indexOf(tar) >= 0) {
        cur = cur.replace(tar, " ");
      }
      cur = cur.trim();
      if (cur) {
        el.setAttribute("class", cur);
      } else {
        el.removeAttribute("class");
      }
    }
  }
  function resolveTransition(def2) {
    if (!def2) {
      return;
    }
    if (typeof def2 === "object") {
      var res = {};
      if (def2.css !== false) {
        extend(res, autoCssTransition(def2.name || "v"));
      }
      extend(res, def2);
      return res;
    } else if (typeof def2 === "string") {
      return autoCssTransition(def2);
    }
  }
  var autoCssTransition = cached(function(name) {
    return {
      enterClass: "".concat(name, "-enter"),
      enterToClass: "".concat(name, "-enter-to"),
      enterActiveClass: "".concat(name, "-enter-active"),
      leaveClass: "".concat(name, "-leave"),
      leaveToClass: "".concat(name, "-leave-to"),
      leaveActiveClass: "".concat(name, "-leave-active")
    };
  });
  var hasTransition = inBrowser && !isIE9;
  var TRANSITION = "transition";
  var ANIMATION = "animation";
  var transitionProp = "transition";
  var transitionEndEvent = "transitionend";
  var animationProp = "animation";
  var animationEndEvent = "animationend";
  if (hasTransition) {
    if (window.ontransitionend === void 0 && window.onwebkittransitionend !== void 0) {
      transitionProp = "WebkitTransition";
      transitionEndEvent = "webkitTransitionEnd";
    }
    if (window.onanimationend === void 0 && window.onwebkitanimationend !== void 0) {
      animationProp = "WebkitAnimation";
      animationEndEvent = "webkitAnimationEnd";
    }
  }
  var raf = inBrowser ? window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : setTimeout : (
    /* istanbul ignore next */
    function(fn) {
      return fn();
    }
  );
  function nextFrame(fn) {
    raf(function() {
      raf(fn);
    });
  }
  function addTransitionClass(el, cls) {
    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
    if (transitionClasses.indexOf(cls) < 0) {
      transitionClasses.push(cls);
      addClass(el, cls);
    }
  }
  function removeTransitionClass(el, cls) {
    if (el._transitionClasses) {
      remove$2(el._transitionClasses, cls);
    }
    removeClass(el, cls);
  }
  function whenTransitionEnds(el, expectedType, cb) {
    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
    if (!type)
      return cb();
    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
    var ended = 0;
    var end = function() {
      el.removeEventListener(event, onEnd);
      cb();
    };
    var onEnd = function(e) {
      if (e.target === el) {
        if (++ended >= propCount) {
          end();
        }
      }
    };
    setTimeout(function() {
      if (ended < propCount) {
        end();
      }
    }, timeout + 1);
    el.addEventListener(event, onEnd);
  }
  var transformRE = /\b(transform|all)(,|$)/;
  function getTransitionInfo(el, expectedType) {
    var styles = window.getComputedStyle(el);
    var transitionDelays = (styles[transitionProp + "Delay"] || "").split(", ");
    var transitionDurations = (styles[transitionProp + "Duration"] || "").split(", ");
    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
    var animationDelays = (styles[animationProp + "Delay"] || "").split(", ");
    var animationDurations = (styles[animationProp + "Duration"] || "").split(", ");
    var animationTimeout = getTimeout(animationDelays, animationDurations);
    var type;
    var timeout = 0;
    var propCount = 0;
    if (expectedType === TRANSITION) {
      if (transitionTimeout > 0) {
        type = TRANSITION;
        timeout = transitionTimeout;
        propCount = transitionDurations.length;
      }
    } else if (expectedType === ANIMATION) {
      if (animationTimeout > 0) {
        type = ANIMATION;
        timeout = animationTimeout;
        propCount = animationDurations.length;
      }
    } else {
      timeout = Math.max(transitionTimeout, animationTimeout);
      type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;
      propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;
    }
    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + "Property"]);
    return {
      type,
      timeout,
      propCount,
      hasTransform
    };
  }
  function getTimeout(delays, durations) {
    while (delays.length < durations.length) {
      delays = delays.concat(delays);
    }
    return Math.max.apply(null, durations.map(function(d, i) {
      return toMs(d) + toMs(delays[i]);
    }));
  }
  function toMs(s) {
    return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
  }
  function enter(vnode, toggleDisplay) {
    var el = vnode.elm;
    if (isDef(el._leaveCb)) {
      el._leaveCb.cancelled = true;
      el._leaveCb();
    }
    var data = resolveTransition(vnode.data.transition);
    if (isUndef(data)) {
      return;
    }
    if (isDef(el._enterCb) || el.nodeType !== 1) {
      return;
    }
    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter2 = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
    var context = activeInstance;
    var transitionNode = activeInstance.$vnode;
    while (transitionNode && transitionNode.parent) {
      context = transitionNode.context;
      transitionNode = transitionNode.parent;
    }
    var isAppear = !context._isMounted || !vnode.isRootInsert;
    if (isAppear && !appear && appear !== "") {
      return;
    }
    var startClass = isAppear && appearClass ? appearClass : enterClass;
    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
    var enterHook = isAppear ? isFunction(appear) ? appear : enter2 : enter2;
    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
    var enterCancelledHook = isAppear ? appearCancelled || enterCancelled : enterCancelled;
    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
    if (false) {
      checkDuration(explicitEnterDuration, "enter", vnode);
    }
    var expectsCSS = css !== false && !isIE9;
    var userWantsControl = getHookArgumentsLength(enterHook);
    var cb = el._enterCb = once(function() {
      if (expectsCSS) {
        removeTransitionClass(el, toClass);
        removeTransitionClass(el, activeClass);
      }
      if (cb.cancelled) {
        if (expectsCSS) {
          removeTransitionClass(el, startClass);
        }
        enterCancelledHook && enterCancelledHook(el);
      } else {
        afterEnterHook && afterEnterHook(el);
      }
      el._enterCb = null;
    });
    if (!vnode.data.show) {
      mergeVNodeHook(vnode, "insert", function() {
        var parent = el.parentNode;
        var pendingNode = parent && parent._pending && parent._pending[vnode.key];
        if (pendingNode && pendingNode.tag === vnode.tag && pendingNode.elm._leaveCb) {
          pendingNode.elm._leaveCb();
        }
        enterHook && enterHook(el, cb);
      });
    }
    beforeEnterHook && beforeEnterHook(el);
    if (expectsCSS) {
      addTransitionClass(el, startClass);
      addTransitionClass(el, activeClass);
      nextFrame(function() {
        removeTransitionClass(el, startClass);
        if (!cb.cancelled) {
          addTransitionClass(el, toClass);
          if (!userWantsControl) {
            if (isValidDuration(explicitEnterDuration)) {
              setTimeout(cb, explicitEnterDuration);
            } else {
              whenTransitionEnds(el, type, cb);
            }
          }
        }
      });
    }
    if (vnode.data.show) {
      toggleDisplay && toggleDisplay();
      enterHook && enterHook(el, cb);
    }
    if (!expectsCSS && !userWantsControl) {
      cb();
    }
  }
  function leave(vnode, rm) {
    var el = vnode.elm;
    if (isDef(el._enterCb)) {
      el._enterCb.cancelled = true;
      el._enterCb();
    }
    var data = resolveTransition(vnode.data.transition);
    if (isUndef(data) || el.nodeType !== 1) {
      return rm();
    }
    if (isDef(el._leaveCb)) {
      return;
    }
    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave2 = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
    var expectsCSS = css !== false && !isIE9;
    var userWantsControl = getHookArgumentsLength(leave2);
    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
    if (false) {
      checkDuration(explicitLeaveDuration, "leave", vnode);
    }
    var cb = el._leaveCb = once(function() {
      if (el.parentNode && el.parentNode._pending) {
        el.parentNode._pending[vnode.key] = null;
      }
      if (expectsCSS) {
        removeTransitionClass(el, leaveToClass);
        removeTransitionClass(el, leaveActiveClass);
      }
      if (cb.cancelled) {
        if (expectsCSS) {
          removeTransitionClass(el, leaveClass);
        }
        leaveCancelled && leaveCancelled(el);
      } else {
        rm();
        afterLeave && afterLeave(el);
      }
      el._leaveCb = null;
    });
    if (delayLeave) {
      delayLeave(performLeave);
    } else {
      performLeave();
    }
    function performLeave() {
      if (cb.cancelled) {
        return;
      }
      if (!vnode.data.show && el.parentNode) {
        (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
      }
      beforeLeave && beforeLeave(el);
      if (expectsCSS) {
        addTransitionClass(el, leaveClass);
        addTransitionClass(el, leaveActiveClass);
        nextFrame(function() {
          removeTransitionClass(el, leaveClass);
          if (!cb.cancelled) {
            addTransitionClass(el, leaveToClass);
            if (!userWantsControl) {
              if (isValidDuration(explicitLeaveDuration)) {
                setTimeout(cb, explicitLeaveDuration);
              } else {
                whenTransitionEnds(el, type, cb);
              }
            }
          }
        });
      }
      leave2 && leave2(el, cb);
      if (!expectsCSS && !userWantsControl) {
        cb();
      }
    }
  }
  function isValidDuration(val) {
    return typeof val === "number" && !isNaN(val);
  }
  function getHookArgumentsLength(fn) {
    if (isUndef(fn)) {
      return false;
    }
    var invokerFns = fn.fns;
    if (isDef(invokerFns)) {
      return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
    } else {
      return (fn._length || fn.length) > 1;
    }
  }
  function _enter(_, vnode) {
    if (vnode.data.show !== true) {
      enter(vnode);
    }
  }
  var transition = inBrowser ? {
    create: _enter,
    activate: _enter,
    remove: function(vnode, rm) {
      if (vnode.data.show !== true) {
        leave(vnode, rm);
      } else {
        rm();
      }
    }
  } : {};
  var platformModules = [attrs, klass, events, domProps, style, transition];
  var modules = platformModules.concat(baseModules);
  var patch = createPatchFunction({ nodeOps, modules });
  if (isIE9) {
    document.addEventListener("selectionchange", function() {
      var el = document.activeElement;
      if (el && el.vmodel) {
        trigger(el, "input");
      }
    });
  }
  var directive = {
    inserted: function(el, binding, vnode, oldVnode) {
      if (vnode.tag === "select") {
        if (oldVnode.elm && !oldVnode.elm._vOptions) {
          mergeVNodeHook(vnode, "postpatch", function() {
            directive.componentUpdated(el, binding, vnode);
          });
        } else {
          setSelected(el, binding, vnode.context);
        }
        el._vOptions = [].map.call(el.options, getValue);
      } else if (vnode.tag === "textarea" || isTextInputType(el.type)) {
        el._vModifiers = binding.modifiers;
        if (!binding.modifiers.lazy) {
          el.addEventListener("compositionstart", onCompositionStart);
          el.addEventListener("compositionend", onCompositionEnd);
          el.addEventListener("change", onCompositionEnd);
          if (isIE9) {
            el.vmodel = true;
          }
        }
      }
    },
    componentUpdated: function(el, binding, vnode) {
      if (vnode.tag === "select") {
        setSelected(el, binding, vnode.context);
        var prevOptions_1 = el._vOptions;
        var curOptions_1 = el._vOptions = [].map.call(el.options, getValue);
        if (curOptions_1.some(function(o, i) {
          return !looseEqual(o, prevOptions_1[i]);
        })) {
          var needReset = el.multiple ? binding.value.some(function(v) {
            return hasNoMatchingOption(v, curOptions_1);
          }) : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions_1);
          if (needReset) {
            trigger(el, "change");
          }
        }
      }
    }
  };
  function setSelected(el, binding, vm) {
    actuallySetSelected(el, binding, vm);
    if (isIE || isEdge) {
      setTimeout(function() {
        actuallySetSelected(el, binding, vm);
      }, 0);
    }
  }
  function actuallySetSelected(el, binding, vm) {
    var value = binding.value;
    var isMultiple = el.multiple;
    if (isMultiple && !Array.isArray(value)) {
      return;
    }
    var selected, option;
    for (var i = 0, l = el.options.length; i < l; i++) {
      option = el.options[i];
      if (isMultiple) {
        selected = looseIndexOf(value, getValue(option)) > -1;
        if (option.selected !== selected) {
          option.selected = selected;
        }
      } else {
        if (looseEqual(getValue(option), value)) {
          if (el.selectedIndex !== i) {
            el.selectedIndex = i;
          }
          return;
        }
      }
    }
    if (!isMultiple) {
      el.selectedIndex = -1;
    }
  }
  function hasNoMatchingOption(value, options) {
    return options.every(function(o) {
      return !looseEqual(o, value);
    });
  }
  function getValue(option) {
    return "_value" in option ? option._value : option.value;
  }
  function onCompositionStart(e) {
    e.target.composing = true;
  }
  function onCompositionEnd(e) {
    if (!e.target.composing)
      return;
    e.target.composing = false;
    trigger(e.target, "input");
  }
  function trigger(el, type) {
    var e = document.createEvent("HTMLEvents");
    e.initEvent(type, true, true);
    el.dispatchEvent(e);
  }
  function locateNode(vnode) {
    return vnode.componentInstance && (!vnode.data || !vnode.data.transition) ? locateNode(vnode.componentInstance._vnode) : vnode;
  }
  var show = {
    bind: function(el, _a, vnode) {
      var value = _a.value;
      vnode = locateNode(vnode);
      var transition2 = vnode.data && vnode.data.transition;
      var originalDisplay = el.__vOriginalDisplay = el.style.display === "none" ? "" : el.style.display;
      if (value && transition2) {
        vnode.data.show = true;
        enter(vnode, function() {
          el.style.display = originalDisplay;
        });
      } else {
        el.style.display = value ? originalDisplay : "none";
      }
    },
    update: function(el, _a, vnode) {
      var value = _a.value, oldValue = _a.oldValue;
      if (!value === !oldValue)
        return;
      vnode = locateNode(vnode);
      var transition2 = vnode.data && vnode.data.transition;
      if (transition2) {
        vnode.data.show = true;
        if (value) {
          enter(vnode, function() {
            el.style.display = el.__vOriginalDisplay;
          });
        } else {
          leave(vnode, function() {
            el.style.display = "none";
          });
        }
      } else {
        el.style.display = value ? el.__vOriginalDisplay : "none";
      }
    },
    unbind: function(el, binding, vnode, oldVnode, isDestroy) {
      if (!isDestroy) {
        el.style.display = el.__vOriginalDisplay;
      }
    }
  };
  var platformDirectives = {
    model: directive,
    show
  };
  var transitionProps = {
    name: String,
    appear: Boolean,
    css: Boolean,
    mode: String,
    type: String,
    enterClass: String,
    leaveClass: String,
    enterToClass: String,
    leaveToClass: String,
    enterActiveClass: String,
    leaveActiveClass: String,
    appearClass: String,
    appearActiveClass: String,
    appearToClass: String,
    duration: [Number, String, Object]
  };
  function getRealChild(vnode) {
    var compOptions = vnode && vnode.componentOptions;
    if (compOptions && compOptions.Ctor.options.abstract) {
      return getRealChild(getFirstComponentChild(compOptions.children));
    } else {
      return vnode;
    }
  }
  function extractTransitionData(comp) {
    var data = {};
    var options = comp.$options;
    for (var key in options.propsData) {
      data[key] = comp[key];
    }
    var listeners = options._parentListeners;
    for (var key in listeners) {
      data[camelize(key)] = listeners[key];
    }
    return data;
  }
  function placeholder(h, rawChild) {
    if (/\d-keep-alive$/.test(rawChild.tag)) {
      return h("keep-alive", {
        props: rawChild.componentOptions.propsData
      });
    }
  }
  function hasParentTransition(vnode) {
    while (vnode = vnode.parent) {
      if (vnode.data.transition) {
        return true;
      }
    }
  }
  function isSameChild(child, oldChild) {
    return oldChild.key === child.key && oldChild.tag === child.tag;
  }
  var isNotTextNode = function(c) {
    return c.tag || isAsyncPlaceholder(c);
  };
  var isVShowDirective = function(d) {
    return d.name === "show";
  };
  var Transition = {
    name: "transition",
    props: transitionProps,
    abstract: true,
    render: function(h) {
      var _this = this;
      var children = this.$slots.default;
      if (!children) {
        return;
      }
      children = children.filter(isNotTextNode);
      if (!children.length) {
        return;
      }
      if (false) {
        warn("<transition> can only be used on a single element. Use <transition-group> for lists.", this.$parent);
      }
      var mode = this.mode;
      if (false) {
        warn("invalid <transition> mode: " + mode, this.$parent);
      }
      var rawChild = children[0];
      if (hasParentTransition(this.$vnode)) {
        return rawChild;
      }
      var child = getRealChild(rawChild);
      if (!child) {
        return rawChild;
      }
      if (this._leaving) {
        return placeholder(h, rawChild);
      }
      var id = "__transition-".concat(this._uid, "-");
      child.key = child.key == null ? child.isComment ? id + "comment" : id + child.tag : isPrimitive(child.key) ? String(child.key).indexOf(id) === 0 ? child.key : id + child.key : child.key;
      var data = (child.data || (child.data = {})).transition = extractTransitionData(this);
      var oldRawChild = this._vnode;
      var oldChild = getRealChild(oldRawChild);
      if (child.data.directives && child.data.directives.some(isVShowDirective)) {
        child.data.show = true;
      }
      if (oldChild && oldChild.data && !isSameChild(child, oldChild) && !isAsyncPlaceholder(oldChild) && // #6687 component root is a comment node
      !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)) {
        var oldData = oldChild.data.transition = extend({}, data);
        if (mode === "out-in") {
          this._leaving = true;
          mergeVNodeHook(oldData, "afterLeave", function() {
            _this._leaving = false;
            _this.$forceUpdate();
          });
          return placeholder(h, rawChild);
        } else if (mode === "in-out") {
          if (isAsyncPlaceholder(child)) {
            return oldRawChild;
          }
          var delayedLeave_1;
          var performLeave = function() {
            delayedLeave_1();
          };
          mergeVNodeHook(data, "afterEnter", performLeave);
          mergeVNodeHook(data, "enterCancelled", performLeave);
          mergeVNodeHook(oldData, "delayLeave", function(leave2) {
            delayedLeave_1 = leave2;
          });
        }
      }
      return rawChild;
    }
  };
  var props = extend({
    tag: String,
    moveClass: String
  }, transitionProps);
  delete props.mode;
  var TransitionGroup = {
    props,
    beforeMount: function() {
      var _this = this;
      var update3 = this._update;
      this._update = function(vnode, hydrating) {
        var restoreActiveInstance = setActiveInstance(_this);
        _this.__patch__(
          _this._vnode,
          _this.kept,
          false,
          // hydrating
          true
          // removeOnly (!important, avoids unnecessary moves)
        );
        _this._vnode = _this.kept;
        restoreActiveInstance();
        update3.call(_this, vnode, hydrating);
      };
    },
    render: function(h) {
      var tag = this.tag || this.$vnode.data.tag || "span";
      var map = /* @__PURE__ */ Object.create(null);
      var prevChildren = this.prevChildren = this.children;
      var rawChildren = this.$slots.default || [];
      var children = this.children = [];
      var transitionData = extractTransitionData(this);
      for (var i = 0; i < rawChildren.length; i++) {
        var c = rawChildren[i];
        if (c.tag) {
          if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
            children.push(c);
            map[c.key] = c;
            (c.data || (c.data = {})).transition = transitionData;
          } else if (false) {
            var opts = c.componentOptions;
            var name_1 = opts ? getComponentName(opts.Ctor.options) || opts.tag || "" : c.tag;
            warn("<transition-group> children must be keyed: <".concat(name_1, ">"));
          }
        }
      }
      if (prevChildren) {
        var kept = [];
        var removed = [];
        for (var i = 0; i < prevChildren.length; i++) {
          var c = prevChildren[i];
          c.data.transition = transitionData;
          c.data.pos = c.elm.getBoundingClientRect();
          if (map[c.key]) {
            kept.push(c);
          } else {
            removed.push(c);
          }
        }
        this.kept = h(tag, null, kept);
        this.removed = removed;
      }
      return h(tag, null, children);
    },
    updated: function() {
      var children = this.prevChildren;
      var moveClass = this.moveClass || (this.name || "v") + "-move";
      if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
        return;
      }
      children.forEach(callPendingCbs);
      children.forEach(recordPosition);
      children.forEach(applyTranslation);
      this._reflow = document.body.offsetHeight;
      children.forEach(function(c) {
        if (c.data.moved) {
          var el_1 = c.elm;
          var s = el_1.style;
          addTransitionClass(el_1, moveClass);
          s.transform = s.WebkitTransform = s.transitionDuration = "";
          el_1.addEventListener(transitionEndEvent, el_1._moveCb = function cb(e) {
            if (e && e.target !== el_1) {
              return;
            }
            if (!e || /transform$/.test(e.propertyName)) {
              el_1.removeEventListener(transitionEndEvent, cb);
              el_1._moveCb = null;
              removeTransitionClass(el_1, moveClass);
            }
          });
        }
      });
    },
    methods: {
      hasMove: function(el, moveClass) {
        if (!hasTransition) {
          return false;
        }
        if (this._hasMove) {
          return this._hasMove;
        }
        var clone = el.cloneNode();
        if (el._transitionClasses) {
          el._transitionClasses.forEach(function(cls) {
            removeClass(clone, cls);
          });
        }
        addClass(clone, moveClass);
        clone.style.display = "none";
        this.$el.appendChild(clone);
        var info = getTransitionInfo(clone);
        this.$el.removeChild(clone);
        return this._hasMove = info.hasTransform;
      }
    }
  };
  function callPendingCbs(c) {
    if (c.elm._moveCb) {
      c.elm._moveCb();
    }
    if (c.elm._enterCb) {
      c.elm._enterCb();
    }
  }
  function recordPosition(c) {
    c.data.newPos = c.elm.getBoundingClientRect();
  }
  function applyTranslation(c) {
    var oldPos = c.data.pos;
    var newPos = c.data.newPos;
    var dx = oldPos.left - newPos.left;
    var dy = oldPos.top - newPos.top;
    if (dx || dy) {
      c.data.moved = true;
      var s = c.elm.style;
      s.transform = s.WebkitTransform = "translate(".concat(dx, "px,").concat(dy, "px)");
      s.transitionDuration = "0s";
    }
  }
  var platformComponents = {
    Transition,
    TransitionGroup
  };
  Vue.config.mustUseProp = mustUseProp;
  Vue.config.isReservedTag = isReservedTag;
  Vue.config.isReservedAttr = isReservedAttr;
  Vue.config.getTagNamespace = getTagNamespace;
  Vue.config.isUnknownElement = isUnknownElement;
  extend(Vue.options.directives, platformDirectives);
  extend(Vue.options.components, platformComponents);
  Vue.prototype.__patch__ = inBrowser ? patch : noop;
  Vue.prototype.$mount = function(el, hydrating) {
    el = el && inBrowser ? query(el) : void 0;
    return mountComponent(this, el, hydrating);
  };
  if (inBrowser) {
    setTimeout(function() {
      if (config.devtools) {
        if (devtools) {
          devtools.emit("init", Vue);
        } else if (false) {
          console[console.info ? "info" : "log"]("Download the Vue Devtools extension for a better development experience:\nhttps://github.com/vuejs/vue-devtools");
        }
      }
      if (false) {
        console[console.info ? "info" : "log"]("You are running Vue in development mode.\nMake sure to turn on production mode when deploying for production.\nSee more tips at https://vuejs.org/guide/deployment.html");
      }
    }, 0);
  }

  // app.js
  var import_App = __toESM(require_App());

  // node_modules/vuex/dist/vuex.esm.js
  function applyMixin(Vue4) {
    var version2 = Number(Vue4.version.split(".")[0]);
    if (version2 >= 2) {
      Vue4.mixin({ beforeCreate: vuexInit });
    } else {
      var _init = Vue4.prototype._init;
      Vue4.prototype._init = function(options) {
        if (options === void 0) options = {};
        options.init = options.init ? [vuexInit].concat(options.init) : vuexInit;
        _init.call(this, options);
      };
    }
    function vuexInit() {
      var options = this.$options;
      if (options.store) {
        this.$store = typeof options.store === "function" ? options.store() : options.store;
      } else if (options.parent && options.parent.$store) {
        this.$store = options.parent.$store;
      }
    }
  }
  var target2 = typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
  var devtoolHook = target2.__VUE_DEVTOOLS_GLOBAL_HOOK__;
  function devtoolPlugin(store2) {
    if (!devtoolHook) {
      return;
    }
    store2._devtoolHook = devtoolHook;
    devtoolHook.emit("vuex:init", store2);
    devtoolHook.on("vuex:travel-to-state", function(targetState) {
      store2.replaceState(targetState);
    });
    store2.subscribe(function(mutation, state) {
      devtoolHook.emit("vuex:mutation", mutation, state);
    }, { prepend: true });
    store2.subscribeAction(function(action, state) {
      devtoolHook.emit("vuex:action", action, state);
    }, { prepend: true });
  }
  function find(list, f) {
    return list.filter(f)[0];
  }
  function deepCopy(obj, cache) {
    if (cache === void 0) cache = [];
    if (obj === null || typeof obj !== "object") {
      return obj;
    }
    var hit = find(cache, function(c) {
      return c.original === obj;
    });
    if (hit) {
      return hit.copy;
    }
    var copy = Array.isArray(obj) ? [] : {};
    cache.push({
      original: obj,
      copy
    });
    Object.keys(obj).forEach(function(key) {
      copy[key] = deepCopy(obj[key], cache);
    });
    return copy;
  }
  function forEachValue(obj, fn) {
    Object.keys(obj).forEach(function(key) {
      return fn(obj[key], key);
    });
  }
  function isObject2(obj) {
    return obj !== null && typeof obj === "object";
  }
  function isPromise2(val) {
    return val && typeof val.then === "function";
  }
  function partial(fn, arg) {
    return function() {
      return fn(arg);
    };
  }
  var Module = function Module2(rawModule, runtime) {
    this.runtime = runtime;
    this._children = /* @__PURE__ */ Object.create(null);
    this._rawModule = rawModule;
    var rawState = rawModule.state;
    this.state = (typeof rawState === "function" ? rawState() : rawState) || {};
  };
  var prototypeAccessors = { namespaced: { configurable: true } };
  prototypeAccessors.namespaced.get = function() {
    return !!this._rawModule.namespaced;
  };
  Module.prototype.addChild = function addChild(key, module) {
    this._children[key] = module;
  };
  Module.prototype.removeChild = function removeChild2(key) {
    delete this._children[key];
  };
  Module.prototype.getChild = function getChild(key) {
    return this._children[key];
  };
  Module.prototype.hasChild = function hasChild(key) {
    return key in this._children;
  };
  Module.prototype.update = function update(rawModule) {
    this._rawModule.namespaced = rawModule.namespaced;
    if (rawModule.actions) {
      this._rawModule.actions = rawModule.actions;
    }
    if (rawModule.mutations) {
      this._rawModule.mutations = rawModule.mutations;
    }
    if (rawModule.getters) {
      this._rawModule.getters = rawModule.getters;
    }
  };
  Module.prototype.forEachChild = function forEachChild(fn) {
    forEachValue(this._children, fn);
  };
  Module.prototype.forEachGetter = function forEachGetter(fn) {
    if (this._rawModule.getters) {
      forEachValue(this._rawModule.getters, fn);
    }
  };
  Module.prototype.forEachAction = function forEachAction(fn) {
    if (this._rawModule.actions) {
      forEachValue(this._rawModule.actions, fn);
    }
  };
  Module.prototype.forEachMutation = function forEachMutation(fn) {
    if (this._rawModule.mutations) {
      forEachValue(this._rawModule.mutations, fn);
    }
  };
  Object.defineProperties(Module.prototype, prototypeAccessors);
  var ModuleCollection = function ModuleCollection2(rawRootModule) {
    this.register([], rawRootModule, false);
  };
  ModuleCollection.prototype.get = function get(path) {
    return path.reduce(function(module, key) {
      return module.getChild(key);
    }, this.root);
  };
  ModuleCollection.prototype.getNamespace = function getNamespace(path) {
    var module = this.root;
    return path.reduce(function(namespace, key) {
      module = module.getChild(key);
      return namespace + (module.namespaced ? key + "/" : "");
    }, "");
  };
  ModuleCollection.prototype.update = function update$1(rawRootModule) {
    update2([], this.root, rawRootModule);
  };
  ModuleCollection.prototype.register = function register(path, rawModule, runtime) {
    var this$1 = this;
    if (runtime === void 0) runtime = true;
    if (false) {
      assertRawModule(path, rawModule);
    }
    var newModule = new Module(rawModule, runtime);
    if (path.length === 0) {
      this.root = newModule;
    } else {
      var parent = this.get(path.slice(0, -1));
      parent.addChild(path[path.length - 1], newModule);
    }
    if (rawModule.modules) {
      forEachValue(rawModule.modules, function(rawChildModule, key) {
        this$1.register(path.concat(key), rawChildModule, runtime);
      });
    }
  };
  ModuleCollection.prototype.unregister = function unregister(path) {
    var parent = this.get(path.slice(0, -1));
    var key = path[path.length - 1];
    var child = parent.getChild(key);
    if (!child) {
      if (false) {
        console.warn(
          "[vuex] trying to unregister module '" + key + "', which is not registered"
        );
      }
      return;
    }
    if (!child.runtime) {
      return;
    }
    parent.removeChild(key);
  };
  ModuleCollection.prototype.isRegistered = function isRegistered(path) {
    var parent = this.get(path.slice(0, -1));
    var key = path[path.length - 1];
    if (parent) {
      return parent.hasChild(key);
    }
    return false;
  };
  function update2(path, targetModule, newModule) {
    if (false) {
      assertRawModule(path, newModule);
    }
    targetModule.update(newModule);
    if (newModule.modules) {
      for (var key in newModule.modules) {
        if (!targetModule.getChild(key)) {
          if (false) {
            console.warn(
              "[vuex] trying to add a new module '" + key + "' on hot reloading, manual reload is needed"
            );
          }
          return;
        }
        update2(
          path.concat(key),
          targetModule.getChild(key),
          newModule.modules[key]
        );
      }
    }
  }
  var Vue2;
  var Store = function Store2(options) {
    var this$1 = this;
    if (options === void 0) options = {};
    if (!Vue2 && typeof window !== "undefined" && window.Vue) {
      install(window.Vue);
    }
    if (false) {
      assert(Vue2, "must call Vue.use(Vuex) before creating a store instance.");
      assert(typeof Promise !== "undefined", "vuex requires a Promise polyfill in this browser.");
      assert(this instanceof Store2, "store must be called with the new operator.");
    }
    var plugins = options.plugins;
    if (plugins === void 0) plugins = [];
    var strict = options.strict;
    if (strict === void 0) strict = false;
    this._committing = false;
    this._actions = /* @__PURE__ */ Object.create(null);
    this._actionSubscribers = [];
    this._mutations = /* @__PURE__ */ Object.create(null);
    this._wrappedGetters = /* @__PURE__ */ Object.create(null);
    this._modules = new ModuleCollection(options);
    this._modulesNamespaceMap = /* @__PURE__ */ Object.create(null);
    this._subscribers = [];
    this._watcherVM = new Vue2();
    this._makeLocalGettersCache = /* @__PURE__ */ Object.create(null);
    var store2 = this;
    var ref2 = this;
    var dispatch2 = ref2.dispatch;
    var commit2 = ref2.commit;
    this.dispatch = function boundDispatch(type, payload) {
      return dispatch2.call(store2, type, payload);
    };
    this.commit = function boundCommit(type, payload, options2) {
      return commit2.call(store2, type, payload, options2);
    };
    this.strict = strict;
    var state = this._modules.root.state;
    installModule(this, state, [], this._modules.root);
    resetStoreVM(this, state);
    plugins.forEach(function(plugin) {
      return plugin(this$1);
    });
    var useDevtools = options.devtools !== void 0 ? options.devtools : Vue2.config.devtools;
    if (useDevtools) {
      devtoolPlugin(this);
    }
  };
  var prototypeAccessors$1 = { state: { configurable: true } };
  prototypeAccessors$1.state.get = function() {
    return this._vm._data.$$state;
  };
  prototypeAccessors$1.state.set = function(v) {
    if (false) {
      assert(false, "use store.replaceState() to explicit replace store state.");
    }
  };
  Store.prototype.commit = function commit(_type, _payload, _options) {
    var this$1 = this;
    var ref2 = unifyObjectStyle(_type, _payload, _options);
    var type = ref2.type;
    var payload = ref2.payload;
    var options = ref2.options;
    var mutation = { type, payload };
    var entry = this._mutations[type];
    if (!entry) {
      if (false) {
        console.error("[vuex] unknown mutation type: " + type);
      }
      return;
    }
    this._withCommit(function() {
      entry.forEach(function commitIterator(handler) {
        handler(payload);
      });
    });
    this._subscribers.slice().forEach(function(sub) {
      return sub(mutation, this$1.state);
    });
    if (false) {
      console.warn(
        "[vuex] mutation type: " + type + ". Silent option has been removed. Use the filter functionality in the vue-devtools"
      );
    }
  };
  Store.prototype.dispatch = function dispatch(_type, _payload) {
    var this$1 = this;
    var ref2 = unifyObjectStyle(_type, _payload);
    var type = ref2.type;
    var payload = ref2.payload;
    var action = { type, payload };
    var entry = this._actions[type];
    if (!entry) {
      if (false) {
        console.error("[vuex] unknown action type: " + type);
      }
      return;
    }
    try {
      this._actionSubscribers.slice().filter(function(sub) {
        return sub.before;
      }).forEach(function(sub) {
        return sub.before(action, this$1.state);
      });
    } catch (e) {
      if (false) {
        console.warn("[vuex] error in before action subscribers: ");
        console.error(e);
      }
    }
    var result = entry.length > 1 ? Promise.all(entry.map(function(handler) {
      return handler(payload);
    })) : entry[0](payload);
    return new Promise(function(resolve, reject) {
      result.then(function(res) {
        try {
          this$1._actionSubscribers.filter(function(sub) {
            return sub.after;
          }).forEach(function(sub) {
            return sub.after(action, this$1.state);
          });
        } catch (e) {
          if (false) {
            console.warn("[vuex] error in after action subscribers: ");
            console.error(e);
          }
        }
        resolve(res);
      }, function(error) {
        try {
          this$1._actionSubscribers.filter(function(sub) {
            return sub.error;
          }).forEach(function(sub) {
            return sub.error(action, this$1.state, error);
          });
        } catch (e) {
          if (false) {
            console.warn("[vuex] error in error action subscribers: ");
            console.error(e);
          }
        }
        reject(error);
      });
    });
  };
  Store.prototype.subscribe = function subscribe(fn, options) {
    return genericSubscribe(fn, this._subscribers, options);
  };
  Store.prototype.subscribeAction = function subscribeAction(fn, options) {
    var subs = typeof fn === "function" ? { before: fn } : fn;
    return genericSubscribe(subs, this._actionSubscribers, options);
  };
  Store.prototype.watch = function watch(getter, cb, options) {
    var this$1 = this;
    if (false) {
      assert(typeof getter === "function", "store.watch only accepts a function.");
    }
    return this._watcherVM.$watch(function() {
      return getter(this$1.state, this$1.getters);
    }, cb, options);
  };
  Store.prototype.replaceState = function replaceState(state) {
    var this$1 = this;
    this._withCommit(function() {
      this$1._vm._data.$$state = state;
    });
  };
  Store.prototype.registerModule = function registerModule(path, rawModule, options) {
    if (options === void 0) options = {};
    if (typeof path === "string") {
      path = [path];
    }
    if (false) {
      assert(Array.isArray(path), "module path must be a string or an Array.");
      assert(path.length > 0, "cannot register the root module by using registerModule.");
    }
    this._modules.register(path, rawModule);
    installModule(this, this.state, path, this._modules.get(path), options.preserveState);
    resetStoreVM(this, this.state);
  };
  Store.prototype.unregisterModule = function unregisterModule(path) {
    var this$1 = this;
    if (typeof path === "string") {
      path = [path];
    }
    if (false) {
      assert(Array.isArray(path), "module path must be a string or an Array.");
    }
    this._modules.unregister(path);
    this._withCommit(function() {
      var parentState = getNestedState(this$1.state, path.slice(0, -1));
      Vue2.delete(parentState, path[path.length - 1]);
    });
    resetStore(this);
  };
  Store.prototype.hasModule = function hasModule(path) {
    if (typeof path === "string") {
      path = [path];
    }
    if (false) {
      assert(Array.isArray(path), "module path must be a string or an Array.");
    }
    return this._modules.isRegistered(path);
  };
  Store.prototype.hotUpdate = function hotUpdate(newOptions) {
    this._modules.update(newOptions);
    resetStore(this, true);
  };
  Store.prototype._withCommit = function _withCommit(fn) {
    var committing = this._committing;
    this._committing = true;
    fn();
    this._committing = committing;
  };
  Object.defineProperties(Store.prototype, prototypeAccessors$1);
  function genericSubscribe(fn, subs, options) {
    if (subs.indexOf(fn) < 0) {
      options && options.prepend ? subs.unshift(fn) : subs.push(fn);
    }
    return function() {
      var i = subs.indexOf(fn);
      if (i > -1) {
        subs.splice(i, 1);
      }
    };
  }
  function resetStore(store2, hot) {
    store2._actions = /* @__PURE__ */ Object.create(null);
    store2._mutations = /* @__PURE__ */ Object.create(null);
    store2._wrappedGetters = /* @__PURE__ */ Object.create(null);
    store2._modulesNamespaceMap = /* @__PURE__ */ Object.create(null);
    var state = store2.state;
    installModule(store2, state, [], store2._modules.root, true);
    resetStoreVM(store2, state, hot);
  }
  function resetStoreVM(store2, state, hot) {
    var oldVm = store2._vm;
    store2.getters = {};
    store2._makeLocalGettersCache = /* @__PURE__ */ Object.create(null);
    var wrappedGetters = store2._wrappedGetters;
    var computed = {};
    forEachValue(wrappedGetters, function(fn, key) {
      computed[key] = partial(fn, store2);
      Object.defineProperty(store2.getters, key, {
        get: function() {
          return store2._vm[key];
        },
        enumerable: true
        // for local getters
      });
    });
    var silent = Vue2.config.silent;
    Vue2.config.silent = true;
    store2._vm = new Vue2({
      data: {
        $$state: state
      },
      computed
    });
    Vue2.config.silent = silent;
    if (store2.strict) {
      enableStrictMode(store2);
    }
    if (oldVm) {
      if (hot) {
        store2._withCommit(function() {
          oldVm._data.$$state = null;
        });
      }
      Vue2.nextTick(function() {
        return oldVm.$destroy();
      });
    }
  }
  function installModule(store2, rootState, path, module, hot) {
    var isRoot = !path.length;
    var namespace = store2._modules.getNamespace(path);
    if (module.namespaced) {
      if (store2._modulesNamespaceMap[namespace] && false) {
        console.error("[vuex] duplicate namespace " + namespace + " for the namespaced module " + path.join("/"));
      }
      store2._modulesNamespaceMap[namespace] = module;
    }
    if (!isRoot && !hot) {
      var parentState = getNestedState(rootState, path.slice(0, -1));
      var moduleName = path[path.length - 1];
      store2._withCommit(function() {
        if (false) {
          if (moduleName in parentState) {
            console.warn(
              '[vuex] state field "' + moduleName + '" was overridden by a module with the same name at "' + path.join(".") + '"'
            );
          }
        }
        Vue2.set(parentState, moduleName, module.state);
      });
    }
    var local = module.context = makeLocalContext(store2, namespace, path);
    module.forEachMutation(function(mutation, key) {
      var namespacedType = namespace + key;
      registerMutation(store2, namespacedType, mutation, local);
    });
    module.forEachAction(function(action, key) {
      var type = action.root ? key : namespace + key;
      var handler = action.handler || action;
      registerAction(store2, type, handler, local);
    });
    module.forEachGetter(function(getter, key) {
      var namespacedType = namespace + key;
      registerGetter(store2, namespacedType, getter, local);
    });
    module.forEachChild(function(child, key) {
      installModule(store2, rootState, path.concat(key), child, hot);
    });
  }
  function makeLocalContext(store2, namespace, path) {
    var noNamespace = namespace === "";
    var local = {
      dispatch: noNamespace ? store2.dispatch : function(_type, _payload, _options) {
        var args = unifyObjectStyle(_type, _payload, _options);
        var payload = args.payload;
        var options = args.options;
        var type = args.type;
        if (!options || !options.root) {
          type = namespace + type;
          if (false) {
            console.error("[vuex] unknown local action type: " + args.type + ", global type: " + type);
            return;
          }
        }
        return store2.dispatch(type, payload);
      },
      commit: noNamespace ? store2.commit : function(_type, _payload, _options) {
        var args = unifyObjectStyle(_type, _payload, _options);
        var payload = args.payload;
        var options = args.options;
        var type = args.type;
        if (!options || !options.root) {
          type = namespace + type;
          if (false) {
            console.error("[vuex] unknown local mutation type: " + args.type + ", global type: " + type);
            return;
          }
        }
        store2.commit(type, payload, options);
      }
    };
    Object.defineProperties(local, {
      getters: {
        get: noNamespace ? function() {
          return store2.getters;
        } : function() {
          return makeLocalGetters(store2, namespace);
        }
      },
      state: {
        get: function() {
          return getNestedState(store2.state, path);
        }
      }
    });
    return local;
  }
  function makeLocalGetters(store2, namespace) {
    if (!store2._makeLocalGettersCache[namespace]) {
      var gettersProxy = {};
      var splitPos = namespace.length;
      Object.keys(store2.getters).forEach(function(type) {
        if (type.slice(0, splitPos) !== namespace) {
          return;
        }
        var localType = type.slice(splitPos);
        Object.defineProperty(gettersProxy, localType, {
          get: function() {
            return store2.getters[type];
          },
          enumerable: true
        });
      });
      store2._makeLocalGettersCache[namespace] = gettersProxy;
    }
    return store2._makeLocalGettersCache[namespace];
  }
  function registerMutation(store2, type, handler, local) {
    var entry = store2._mutations[type] || (store2._mutations[type] = []);
    entry.push(function wrappedMutationHandler(payload) {
      handler.call(store2, local.state, payload);
    });
  }
  function registerAction(store2, type, handler, local) {
    var entry = store2._actions[type] || (store2._actions[type] = []);
    entry.push(function wrappedActionHandler(payload) {
      var res = handler.call(store2, {
        dispatch: local.dispatch,
        commit: local.commit,
        getters: local.getters,
        state: local.state,
        rootGetters: store2.getters,
        rootState: store2.state
      }, payload);
      if (!isPromise2(res)) {
        res = Promise.resolve(res);
      }
      if (store2._devtoolHook) {
        return res.catch(function(err) {
          store2._devtoolHook.emit("vuex:error", err);
          throw err;
        });
      } else {
        return res;
      }
    });
  }
  function registerGetter(store2, type, rawGetter, local) {
    if (store2._wrappedGetters[type]) {
      if (false) {
        console.error("[vuex] duplicate getter key: " + type);
      }
      return;
    }
    store2._wrappedGetters[type] = function wrappedGetter(store3) {
      return rawGetter(
        local.state,
        // local state
        local.getters,
        // local getters
        store3.state,
        // root state
        store3.getters
        // root getters
      );
    };
  }
  function enableStrictMode(store2) {
    store2._vm.$watch(function() {
      return this._data.$$state;
    }, function() {
      if (false) {
        assert(store2._committing, "do not mutate vuex store state outside mutation handlers.");
      }
    }, { deep: true, sync: true });
  }
  function getNestedState(state, path) {
    return path.reduce(function(state2, key) {
      return state2[key];
    }, state);
  }
  function unifyObjectStyle(type, payload, options) {
    if (isObject2(type) && type.type) {
      options = payload;
      payload = type;
      type = type.type;
    }
    if (false) {
      assert(typeof type === "string", "expects string as the type, but found " + typeof type + ".");
    }
    return { type, payload, options };
  }
  function install(_Vue) {
    if (Vue2 && _Vue === Vue2) {
      if (false) {
        console.error(
          "[vuex] already installed. Vue.use(Vuex) should be called only once."
        );
      }
      return;
    }
    Vue2 = _Vue;
    applyMixin(Vue2);
  }
  var mapState = normalizeNamespace(function(namespace, states) {
    var res = {};
    if (false) {
      console.error("[vuex] mapState: mapper parameter must be either an Array or an Object");
    }
    normalizeMap(states).forEach(function(ref2) {
      var key = ref2.key;
      var val = ref2.val;
      res[key] = function mappedState() {
        var state = this.$store.state;
        var getters = this.$store.getters;
        if (namespace) {
          var module = getModuleByNamespace(this.$store, "mapState", namespace);
          if (!module) {
            return;
          }
          state = module.context.state;
          getters = module.context.getters;
        }
        return typeof val === "function" ? val.call(this, state, getters) : state[val];
      };
      res[key].vuex = true;
    });
    return res;
  });
  var mapMutations = normalizeNamespace(function(namespace, mutations) {
    var res = {};
    if (false) {
      console.error("[vuex] mapMutations: mapper parameter must be either an Array or an Object");
    }
    normalizeMap(mutations).forEach(function(ref2) {
      var key = ref2.key;
      var val = ref2.val;
      res[key] = function mappedMutation() {
        var args = [], len = arguments.length;
        while (len--) args[len] = arguments[len];
        var commit2 = this.$store.commit;
        if (namespace) {
          var module = getModuleByNamespace(this.$store, "mapMutations", namespace);
          if (!module) {
            return;
          }
          commit2 = module.context.commit;
        }
        return typeof val === "function" ? val.apply(this, [commit2].concat(args)) : commit2.apply(this.$store, [val].concat(args));
      };
    });
    return res;
  });
  var mapGetters = normalizeNamespace(function(namespace, getters) {
    var res = {};
    if (false) {
      console.error("[vuex] mapGetters: mapper parameter must be either an Array or an Object");
    }
    normalizeMap(getters).forEach(function(ref2) {
      var key = ref2.key;
      var val = ref2.val;
      val = namespace + val;
      res[key] = function mappedGetter() {
        if (namespace && !getModuleByNamespace(this.$store, "mapGetters", namespace)) {
          return;
        }
        if (false) {
          console.error("[vuex] unknown getter: " + val);
          return;
        }
        return this.$store.getters[val];
      };
      res[key].vuex = true;
    });
    return res;
  });
  var mapActions = normalizeNamespace(function(namespace, actions) {
    var res = {};
    if (false) {
      console.error("[vuex] mapActions: mapper parameter must be either an Array or an Object");
    }
    normalizeMap(actions).forEach(function(ref2) {
      var key = ref2.key;
      var val = ref2.val;
      res[key] = function mappedAction() {
        var args = [], len = arguments.length;
        while (len--) args[len] = arguments[len];
        var dispatch2 = this.$store.dispatch;
        if (namespace) {
          var module = getModuleByNamespace(this.$store, "mapActions", namespace);
          if (!module) {
            return;
          }
          dispatch2 = module.context.dispatch;
        }
        return typeof val === "function" ? val.apply(this, [dispatch2].concat(args)) : dispatch2.apply(this.$store, [val].concat(args));
      };
    });
    return res;
  });
  var createNamespacedHelpers = function(namespace) {
    return {
      mapState: mapState.bind(null, namespace),
      mapGetters: mapGetters.bind(null, namespace),
      mapMutations: mapMutations.bind(null, namespace),
      mapActions: mapActions.bind(null, namespace)
    };
  };
  function normalizeMap(map) {
    if (!isValidMap(map)) {
      return [];
    }
    return Array.isArray(map) ? map.map(function(key) {
      return { key, val: key };
    }) : Object.keys(map).map(function(key) {
      return { key, val: map[key] };
    });
  }
  function isValidMap(map) {
    return Array.isArray(map) || isObject2(map);
  }
  function normalizeNamespace(fn) {
    return function(namespace, map) {
      if (typeof namespace !== "string") {
        map = namespace;
        namespace = "";
      } else if (namespace.charAt(namespace.length - 1) !== "/") {
        namespace += "/";
      }
      return fn(namespace, map);
    };
  }
  function getModuleByNamespace(store2, helper, namespace) {
    var module = store2._modulesNamespaceMap[namespace];
    if (false) {
      console.error("[vuex] module namespace not found in " + helper + "(): " + namespace);
    }
    return module;
  }
  function createLogger(ref2) {
    if (ref2 === void 0) ref2 = {};
    var collapsed = ref2.collapsed;
    if (collapsed === void 0) collapsed = true;
    var filter = ref2.filter;
    if (filter === void 0) filter = function(mutation, stateBefore, stateAfter) {
      return true;
    };
    var transformer = ref2.transformer;
    if (transformer === void 0) transformer = function(state) {
      return state;
    };
    var mutationTransformer = ref2.mutationTransformer;
    if (mutationTransformer === void 0) mutationTransformer = function(mut) {
      return mut;
    };
    var actionFilter = ref2.actionFilter;
    if (actionFilter === void 0) actionFilter = function(action, state) {
      return true;
    };
    var actionTransformer = ref2.actionTransformer;
    if (actionTransformer === void 0) actionTransformer = function(act) {
      return act;
    };
    var logMutations = ref2.logMutations;
    if (logMutations === void 0) logMutations = true;
    var logActions = ref2.logActions;
    if (logActions === void 0) logActions = true;
    var logger = ref2.logger;
    if (logger === void 0) logger = console;
    return function(store2) {
      var prevState = deepCopy(store2.state);
      if (typeof logger === "undefined") {
        return;
      }
      if (logMutations) {
        store2.subscribe(function(mutation, state) {
          var nextState = deepCopy(state);
          if (filter(mutation, prevState, nextState)) {
            var formattedTime = getFormattedTime();
            var formattedMutation = mutationTransformer(mutation);
            var message = "mutation " + mutation.type + formattedTime;
            startMessage(logger, message, collapsed);
            logger.log("%c prev state", "color: #9E9E9E; font-weight: bold", transformer(prevState));
            logger.log("%c mutation", "color: #03A9F4; font-weight: bold", formattedMutation);
            logger.log("%c next state", "color: #4CAF50; font-weight: bold", transformer(nextState));
            endMessage(logger);
          }
          prevState = nextState;
        });
      }
      if (logActions) {
        store2.subscribeAction(function(action, state) {
          if (actionFilter(action, state)) {
            var formattedTime = getFormattedTime();
            var formattedAction = actionTransformer(action);
            var message = "action " + action.type + formattedTime;
            startMessage(logger, message, collapsed);
            logger.log("%c action", "color: #03A9F4; font-weight: bold", formattedAction);
            endMessage(logger);
          }
        });
      }
    };
  }
  function startMessage(logger, message, collapsed) {
    var startMessage2 = collapsed ? logger.groupCollapsed : logger.group;
    try {
      startMessage2.call(logger, message);
    } catch (e) {
      logger.log(message);
    }
  }
  function endMessage(logger) {
    try {
      logger.groupEnd();
    } catch (e) {
      logger.log("\u2014\u2014 log end \u2014\u2014");
    }
  }
  function getFormattedTime() {
    var time = /* @__PURE__ */ new Date();
    return " @ " + pad(time.getHours(), 2) + ":" + pad(time.getMinutes(), 2) + ":" + pad(time.getSeconds(), 2) + "." + pad(time.getMilliseconds(), 3);
  }
  function repeat(str, times) {
    return new Array(times + 1).join(str);
  }
  function pad(num, maxLength) {
    return repeat("0", maxLength - num.toString().length) + num;
  }
  var index2 = {
    Store,
    install,
    version: "3.6.2",
    mapState,
    mapMutations,
    mapGetters,
    mapActions,
    createNamespacedHelpers,
    createLogger
  };
  var vuex_esm_default = index2;

  // src/store/index.js
  var import_vue2 = __toESM(require_vue());

  // src/js/lang.js
  var LANGUAGES = Object.freeze({ EN: 0, JP: 1 });

  // src/js/mixins.js
  var provideModule = (path, module) => {
    let instanceCount = 0;
    return {
      beforeCreate() {
        if (VUE_ENV !== "server") {
          instanceCount++;
          if (instanceCount > 1) return;
        }
        const preserve_state = !!this.$store.state[path];
        this.$store.registerModule(path, module, { preserveState: preserve_state });
      },
      destroyed() {
        if (VUE_ENV !== "server") {
          instanceCount--;
          if (instanceCount > 0) return;
        }
        this.$store.unregisterModule(path);
      }
    };
  };

  // src/store/replicard.js
  var INITIAL_DATA = () => {
    return {
      progression: {
        "E": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        "F": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        "G": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        "H": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      },
      data_fetched: false
    };
  };
  var myStoreModule = {
    namespaced: true,
    state() {
      return INITIAL_DATA();
    },
    mutations: {
      setReplicardData(state, value) {
        Vue.set(state, "progression", value);
      },
      setReplicardFetched(state, value) {
        state.data_fetched = value;
      },
      resetReplicard(state) {
        Object.assign(state, INITIAL_DATA());
      }
    }
  };
  var provideMyStoreModule = provideModule("replicard", myStoreModule);
  var replicard_default = provideMyStoreModule;

  // src/store/index.js
  import_vue2.default.use(vuex_esm_default);
  var store = new vuex_esm_default.Store({
    modules: {
      replicard: replicard_default
    }
  });
  var store_default = store;

  // app.js
  Vue.use(vuex_esm_default);
  new Vue({
    el: "#app",
    store: store_default,
    render: (h) => h(import_App.default)
  });
})();
/*! Bundled license information:

vue/dist/vue.js:
vue/dist/vue.runtime.esm.js:
  (*!
   * Vue.js v2.7.16
   * (c) 2014-2023 Evan You
   * Released under the MIT License.
   *)

vuex/dist/vuex.esm.js:
  (*!
   * vuex v3.6.2
   * (c) 2021 Evan You
   * @license MIT
   *)
*/