{"version":3,"file":"store.c1e9c370.js","sources":["../../../node_modules/vue-advanced-chat/dist/vue-advanced-chat.es.js","../../../app/javascript/components/appraiser/Chatbot.vue?vue&type=template&lang.js","../../../app/javascript/components/appraiser/Chatbot.vue","../../../app/javascript/components/chatbot/store.js"],"sourcesContent":["function makeMap$2(str, expectsLowerCase) {\n const map = /* @__PURE__ */ Object.create(null);\n const list = str.split(\",\");\n for (let i = 0; i < list.length; i++) {\n map[list[i]] = true;\n }\n return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];\n}\nconst NOOP$1 = () => {\n};\nconst extend$2 = Object.assign;\nconst hasOwnProperty$1 = Object.prototype.hasOwnProperty;\nconst hasOwn$1 = (val, key) => hasOwnProperty$1.call(val, key);\nconst isArray$2 = Array.isArray;\nconst isMap$1 = (val) => toTypeString$1(val) === \"[object Map]\";\nconst isFunction$2 = (val) => typeof val === \"function\";\nconst isString$2 = (val) => typeof val === \"string\";\nconst isSymbol = (val) => typeof val === \"symbol\";\nconst isObject$2 = (val) => val !== null && typeof val === \"object\";\nconst objectToString$1 = Object.prototype.toString;\nconst toTypeString$1 = (value) => objectToString$1.call(value);\nconst toRawType = (value) => {\n return toTypeString$1(value).slice(8, -1);\n};\nconst isIntegerKey = (key) => isString$2(key) && key !== \"NaN\" && key[0] !== \"-\" && \"\" + parseInt(key, 10) === key;\nconst hasChanged$1 = (value, oldValue) => !Object.is(value, oldValue);\nconst def$1 = (obj, key, value) => {\n Object.defineProperty(obj, key, {\n configurable: true,\n enumerable: false,\n value\n });\n};\nlet activeEffectScope;\nclass EffectScope {\n constructor(detached = false) {\n this.active = true;\n this.effects = [];\n this.cleanups = [];\n if (!detached && activeEffectScope) {\n this.parent = activeEffectScope;\n this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;\n }\n }\n run(fn) {\n if (this.active) {\n const currentEffectScope = activeEffectScope;\n try {\n activeEffectScope = this;\n return fn();\n } finally {\n activeEffectScope = currentEffectScope;\n }\n }\n }\n on() {\n activeEffectScope = this;\n }\n off() {\n activeEffectScope = this.parent;\n }\n stop(fromParent) {\n if (this.active) {\n let i, l;\n for (i = 0, l = this.effects.length; i < l; i++) {\n this.effects[i].stop();\n }\n for (i = 0, l = this.cleanups.length; i < l; i++) {\n this.cleanups[i]();\n }\n if (this.scopes) {\n for (i = 0, l = this.scopes.length; i < l; i++) {\n this.scopes[i].stop(true);\n }\n }\n if (this.parent && !fromParent) {\n const last = this.parent.scopes.pop();\n if (last && last !== this) {\n this.parent.scopes[this.index] = last;\n last.index = this.index;\n }\n }\n this.active = false;\n }\n }\n}\nfunction recordEffectScope(effect, scope = activeEffectScope) {\n if (scope && scope.active) {\n scope.effects.push(effect);\n }\n}\nconst createDep = (effects) => {\n const dep = new Set(effects);\n dep.w = 0;\n dep.n = 0;\n return dep;\n};\nconst wasTracked = (dep) => (dep.w & trackOpBit) > 0;\nconst newTracked = (dep) => (dep.n & trackOpBit) > 0;\nconst initDepMarkers = ({ deps }) => {\n if (deps.length) {\n for (let i = 0; i < deps.length; i++) {\n deps[i].w |= trackOpBit;\n }\n }\n};\nconst finalizeDepMarkers = (effect) => {\n const { deps } = effect;\n if (deps.length) {\n let ptr = 0;\n for (let i = 0; i < deps.length; i++) {\n const dep = deps[i];\n if (wasTracked(dep) && !newTracked(dep)) {\n dep.delete(effect);\n } else {\n deps[ptr++] = dep;\n }\n dep.w &= ~trackOpBit;\n dep.n &= ~trackOpBit;\n }\n deps.length = ptr;\n }\n};\nconst targetMap = /* @__PURE__ */ new WeakMap();\nlet effectTrackDepth = 0;\nlet trackOpBit = 1;\nconst maxMarkerBits = 30;\nlet activeEffect;\nconst ITERATE_KEY = Symbol(\"\");\nconst MAP_KEY_ITERATE_KEY = Symbol(\"\");\nclass ReactiveEffect {\n constructor(fn, scheduler = null, scope) {\n this.fn = fn;\n this.scheduler = scheduler;\n this.active = true;\n this.deps = [];\n this.parent = void 0;\n recordEffectScope(this, scope);\n }\n run() {\n if (!this.active) {\n return this.fn();\n }\n let parent = activeEffect;\n let lastShouldTrack = shouldTrack;\n while (parent) {\n if (parent === this) {\n return;\n }\n parent = parent.parent;\n }\n try {\n this.parent = activeEffect;\n activeEffect = this;\n shouldTrack = true;\n trackOpBit = 1 << ++effectTrackDepth;\n if (effectTrackDepth <= maxMarkerBits) {\n initDepMarkers(this);\n } else {\n cleanupEffect(this);\n }\n return this.fn();\n } finally {\n if (effectTrackDepth <= maxMarkerBits) {\n finalizeDepMarkers(this);\n }\n trackOpBit = 1 << --effectTrackDepth;\n activeEffect = this.parent;\n shouldTrack = lastShouldTrack;\n this.parent = void 0;\n if (this.deferStop) {\n this.stop();\n }\n }\n }\n stop() {\n if (activeEffect === this) {\n this.deferStop = true;\n } else if (this.active) {\n cleanupEffect(this);\n if (this.onStop) {\n this.onStop();\n }\n this.active = false;\n }\n }\n}\nfunction cleanupEffect(effect) {\n const { deps } = effect;\n if (deps.length) {\n for (let i = 0; i < deps.length; i++) {\n deps[i].delete(effect);\n }\n deps.length = 0;\n }\n}\nlet shouldTrack = true;\nconst trackStack = [];\nfunction pauseTracking() {\n trackStack.push(shouldTrack);\n shouldTrack = false;\n}\nfunction resetTracking() {\n const last = trackStack.pop();\n shouldTrack = last === void 0 ? true : last;\n}\nfunction track(target, type, key) {\n if (shouldTrack && activeEffect) {\n let depsMap = targetMap.get(target);\n if (!depsMap) {\n targetMap.set(target, depsMap = /* @__PURE__ */ new Map());\n }\n let dep = depsMap.get(key);\n if (!dep) {\n depsMap.set(key, dep = createDep());\n }\n trackEffects(dep);\n }\n}\nfunction trackEffects(dep, debuggerEventExtraInfo) {\n let shouldTrack2 = false;\n if (effectTrackDepth <= maxMarkerBits) {\n if (!newTracked(dep)) {\n dep.n |= trackOpBit;\n shouldTrack2 = !wasTracked(dep);\n }\n } else {\n shouldTrack2 = !dep.has(activeEffect);\n }\n if (shouldTrack2) {\n dep.add(activeEffect);\n activeEffect.deps.push(dep);\n }\n}\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\n const depsMap = targetMap.get(target);\n if (!depsMap) {\n return;\n }\n let deps = [];\n if (type === \"clear\") {\n deps = [...depsMap.values()];\n } else if (key === \"length\" && isArray$2(target)) {\n depsMap.forEach((dep, key2) => {\n if (key2 === \"length\" || key2 >= newValue) {\n deps.push(dep);\n }\n });\n } else {\n if (key !== void 0) {\n deps.push(depsMap.get(key));\n }\n switch (type) {\n case \"add\":\n if (!isArray$2(target)) {\n deps.push(depsMap.get(ITERATE_KEY));\n if (isMap$1(target)) {\n deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));\n }\n } else if (isIntegerKey(key)) {\n deps.push(depsMap.get(\"length\"));\n }\n break;\n case \"delete\":\n if (!isArray$2(target)) {\n deps.push(depsMap.get(ITERATE_KEY));\n if (isMap$1(target)) {\n deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));\n }\n }\n break;\n case \"set\":\n if (isMap$1(target)) {\n deps.push(depsMap.get(ITERATE_KEY));\n }\n break;\n }\n }\n if (deps.length === 1) {\n if (deps[0]) {\n {\n triggerEffects(deps[0]);\n }\n }\n } else {\n const effects = [];\n for (const dep of deps) {\n if (dep) {\n effects.push(...dep);\n }\n }\n {\n triggerEffects(createDep(effects));\n }\n }\n}\nfunction triggerEffects(dep, debuggerEventExtraInfo) {\n const effects = isArray$2(dep) ? dep : [...dep];\n for (const effect of effects) {\n if (effect.computed) {\n triggerEffect(effect);\n }\n }\n for (const effect of effects) {\n if (!effect.computed) {\n triggerEffect(effect);\n }\n }\n}\nfunction triggerEffect(effect, debuggerEventExtraInfo) {\n if (effect !== activeEffect || effect.allowRecurse) {\n if (effect.scheduler) {\n effect.scheduler();\n } else {\n effect.run();\n }\n }\n}\nconst isNonTrackableKeys = /* @__PURE__ */ makeMap$2(`__proto__,__v_isRef,__isVue`);\nconst builtInSymbols = new Set(\n /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== \"arguments\" && key !== \"caller\").map((key) => Symbol[key]).filter(isSymbol)\n);\nconst get$1 = /* @__PURE__ */ createGetter();\nconst shallowGet = /* @__PURE__ */ createGetter(false, true);\nconst readonlyGet = /* @__PURE__ */ createGetter(true);\nconst arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();\nfunction createArrayInstrumentations() {\n const instrumentations = {};\n [\"includes\", \"indexOf\", \"lastIndexOf\"].forEach((key) => {\n instrumentations[key] = function(...args) {\n const arr = toRaw(this);\n for (let i = 0, l = this.length; i < l; i++) {\n track(arr, \"get\", i + \"\");\n }\n const res = arr[key](...args);\n if (res === -1 || res === false) {\n return arr[key](...args.map(toRaw));\n } else {\n return res;\n }\n };\n });\n [\"push\", \"pop\", \"shift\", \"unshift\", \"splice\"].forEach((key) => {\n instrumentations[key] = function(...args) {\n pauseTracking();\n const res = toRaw(this)[key].apply(this, args);\n resetTracking();\n return res;\n };\n });\n return instrumentations;\n}\nfunction createGetter(isReadonly2 = false, shallow = false) {\n return function get3(target, key, receiver) {\n if (key === \"__v_isReactive\") {\n return !isReadonly2;\n } else if (key === \"__v_isReadonly\") {\n return isReadonly2;\n } else if (key === \"__v_isShallow\") {\n return shallow;\n } else if (key === \"__v_raw\" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {\n return target;\n }\n const targetIsArray = isArray$2(target);\n if (!isReadonly2 && targetIsArray && hasOwn$1(arrayInstrumentations, key)) {\n return Reflect.get(arrayInstrumentations, key, receiver);\n }\n const res = Reflect.get(target, key, receiver);\n if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {\n return res;\n }\n if (!isReadonly2) {\n track(target, \"get\", key);\n }\n if (shallow) {\n return res;\n }\n if (isRef(res)) {\n return targetIsArray && isIntegerKey(key) ? res : res.value;\n }\n if (isObject$2(res)) {\n return isReadonly2 ? readonly(res) : reactive(res);\n }\n return res;\n };\n}\nconst set$1 = /* @__PURE__ */ createSetter();\nconst shallowSet = /* @__PURE__ */ createSetter(true);\nfunction createSetter(shallow = false) {\n return function set2(target, key, value, receiver) {\n let oldValue = target[key];\n if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {\n return false;\n }\n if (!shallow && !isReadonly(value)) {\n if (!isShallow(value)) {\n value = toRaw(value);\n oldValue = toRaw(oldValue);\n }\n if (!isArray$2(target) && isRef(oldValue) && !isRef(value)) {\n oldValue.value = value;\n return true;\n }\n }\n const hadKey = isArray$2(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn$1(target, key);\n const result = Reflect.set(target, key, value, receiver);\n if (target === toRaw(receiver)) {\n if (!hadKey) {\n trigger(target, \"add\", key, value);\n } else if (hasChanged$1(value, oldValue)) {\n trigger(target, \"set\", key, value);\n }\n }\n return result;\n };\n}\nfunction deleteProperty(target, key) {\n const hadKey = hasOwn$1(target, key);\n target[key];\n const result = Reflect.deleteProperty(target, key);\n if (result && hadKey) {\n trigger(target, \"delete\", key, void 0);\n }\n return result;\n}\nfunction has(target, key) {\n const result = Reflect.has(target, key);\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\n track(target, \"has\", key);\n }\n return result;\n}\nfunction ownKeys(target) {\n track(target, \"iterate\", isArray$2(target) ? \"length\" : ITERATE_KEY);\n return Reflect.ownKeys(target);\n}\nconst mutableHandlers = {\n get: get$1,\n set: set$1,\n deleteProperty,\n has,\n ownKeys\n};\nconst readonlyHandlers = {\n get: readonlyGet,\n set(target, key) {\n return true;\n },\n deleteProperty(target, key) {\n return true;\n }\n};\nconst shallowReactiveHandlers = /* @__PURE__ */ extend$2({}, mutableHandlers, {\n get: shallowGet,\n set: shallowSet\n});\nconst toShallow = (value) => value;\nconst getProto = (v) => Reflect.getPrototypeOf(v);\nfunction get$1$1(target, key, isReadonly2 = false, isShallow2 = false) {\n target = target[\"__v_raw\"];\n const rawTarget = toRaw(target);\n const rawKey = toRaw(key);\n if (!isReadonly2) {\n if (key !== rawKey) {\n track(rawTarget, \"get\", key);\n }\n track(rawTarget, \"get\", rawKey);\n }\n const { has: has2 } = getProto(rawTarget);\n const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;\n if (has2.call(rawTarget, key)) {\n return wrap(target.get(key));\n } else if (has2.call(rawTarget, rawKey)) {\n return wrap(target.get(rawKey));\n } else if (target !== rawTarget) {\n target.get(key);\n }\n}\nfunction has$1(key, isReadonly2 = false) {\n const target = this[\"__v_raw\"];\n const rawTarget = toRaw(target);\n const rawKey = toRaw(key);\n if (!isReadonly2) {\n if (key !== rawKey) {\n track(rawTarget, \"has\", key);\n }\n track(rawTarget, \"has\", rawKey);\n }\n return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);\n}\nfunction size(target, isReadonly2 = false) {\n target = target[\"__v_raw\"];\n !isReadonly2 && track(toRaw(target), \"iterate\", ITERATE_KEY);\n return Reflect.get(target, \"size\", target);\n}\nfunction add(value) {\n value = toRaw(value);\n const target = toRaw(this);\n const proto = getProto(target);\n const hadKey = proto.has.call(target, value);\n if (!hadKey) {\n target.add(value);\n trigger(target, \"add\", value, value);\n }\n return this;\n}\nfunction set$1$1(key, value) {\n value = toRaw(value);\n const target = toRaw(this);\n const { has: has2, get: get3 } = getProto(target);\n let hadKey = has2.call(target, key);\n if (!hadKey) {\n key = toRaw(key);\n hadKey = has2.call(target, key);\n }\n const oldValue = get3.call(target, key);\n target.set(key, value);\n if (!hadKey) {\n trigger(target, \"add\", key, value);\n } else if (hasChanged$1(value, oldValue)) {\n trigger(target, \"set\", key, value);\n }\n return this;\n}\nfunction deleteEntry(key) {\n const target = toRaw(this);\n const { has: has2, get: get3 } = getProto(target);\n let hadKey = has2.call(target, key);\n if (!hadKey) {\n key = toRaw(key);\n hadKey = has2.call(target, key);\n }\n get3 ? get3.call(target, key) : void 0;\n const result = target.delete(key);\n if (hadKey) {\n trigger(target, \"delete\", key, void 0);\n }\n return result;\n}\nfunction clear() {\n const target = toRaw(this);\n const hadItems = target.size !== 0;\n const result = target.clear();\n if (hadItems) {\n trigger(target, \"clear\", void 0, void 0);\n }\n return result;\n}\nfunction createForEach(isReadonly2, isShallow2) {\n return function forEach(callback, thisArg) {\n const observed = this;\n const target = observed[\"__v_raw\"];\n const rawTarget = toRaw(target);\n const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;\n !isReadonly2 && track(rawTarget, \"iterate\", ITERATE_KEY);\n return target.forEach((value, key) => {\n return callback.call(thisArg, wrap(value), wrap(key), observed);\n });\n };\n}\nfunction createIterableMethod(method, isReadonly2, isShallow2) {\n return function(...args) {\n const target = this[\"__v_raw\"];\n const rawTarget = toRaw(target);\n const targetIsMap = isMap$1(rawTarget);\n const isPair = method === \"entries\" || method === Symbol.iterator && targetIsMap;\n const isKeyOnly = method === \"keys\" && targetIsMap;\n const innerIterator = target[method](...args);\n const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;\n !isReadonly2 && track(rawTarget, \"iterate\", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\n return {\n next() {\n const { value, done } = innerIterator.next();\n return done ? { value, done } : {\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\n done\n };\n },\n [Symbol.iterator]() {\n return this;\n }\n };\n };\n}\nfunction createReadonlyMethod(type) {\n return function(...args) {\n return type === \"delete\" ? false : this;\n };\n}\nfunction createInstrumentations() {\n const mutableInstrumentations2 = {\n get(key) {\n return get$1$1(this, key);\n },\n get size() {\n return size(this);\n },\n has: has$1,\n add,\n set: set$1$1,\n delete: deleteEntry,\n clear,\n forEach: createForEach(false, false)\n };\n const shallowInstrumentations2 = {\n get(key) {\n return get$1$1(this, key, false, true);\n },\n get size() {\n return size(this);\n },\n has: has$1,\n add,\n set: set$1$1,\n delete: deleteEntry,\n clear,\n forEach: createForEach(false, true)\n };\n const readonlyInstrumentations2 = {\n get(key) {\n return get$1$1(this, key, true);\n },\n get size() {\n return size(this, true);\n },\n has(key) {\n return has$1.call(this, key, true);\n },\n add: createReadonlyMethod(\"add\"),\n set: createReadonlyMethod(\"set\"),\n delete: createReadonlyMethod(\"delete\"),\n clear: createReadonlyMethod(\"clear\"),\n forEach: createForEach(true, false)\n };\n const shallowReadonlyInstrumentations2 = {\n get(key) {\n return get$1$1(this, key, true, true);\n },\n get size() {\n return size(this, true);\n },\n has(key) {\n return has$1.call(this, key, true);\n },\n add: createReadonlyMethod(\"add\"),\n set: createReadonlyMethod(\"set\"),\n delete: createReadonlyMethod(\"delete\"),\n clear: createReadonlyMethod(\"clear\"),\n forEach: createForEach(true, true)\n };\n const iteratorMethods = [\"keys\", \"values\", \"entries\", Symbol.iterator];\n iteratorMethods.forEach((method) => {\n mutableInstrumentations2[method] = createIterableMethod(method, false, false);\n readonlyInstrumentations2[method] = createIterableMethod(method, true, false);\n shallowInstrumentations2[method] = createIterableMethod(method, false, true);\n shallowReadonlyInstrumentations2[method] = createIterableMethod(method, true, true);\n });\n return [\n mutableInstrumentations2,\n readonlyInstrumentations2,\n shallowInstrumentations2,\n shallowReadonlyInstrumentations2\n ];\n}\nconst [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* @__PURE__ */ createInstrumentations();\nfunction createInstrumentationGetter(isReadonly2, shallow) {\n const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;\n return (target, key, receiver) => {\n if (key === \"__v_isReactive\") {\n return !isReadonly2;\n } else if (key === \"__v_isReadonly\") {\n return isReadonly2;\n } else if (key === \"__v_raw\") {\n return target;\n }\n return Reflect.get(hasOwn$1(instrumentations, key) && key in target ? instrumentations : target, key, receiver);\n };\n}\nconst mutableCollectionHandlers = {\n get: /* @__PURE__ */ createInstrumentationGetter(false, false)\n};\nconst shallowCollectionHandlers = {\n get: /* @__PURE__ */ createInstrumentationGetter(false, true)\n};\nconst readonlyCollectionHandlers = {\n get: /* @__PURE__ */ createInstrumentationGetter(true, false)\n};\nconst reactiveMap = /* @__PURE__ */ new WeakMap();\nconst shallowReactiveMap = /* @__PURE__ */ new WeakMap();\nconst readonlyMap = /* @__PURE__ */ new WeakMap();\nconst shallowReadonlyMap = /* @__PURE__ */ new WeakMap();\nfunction targetTypeMap(rawType) {\n switch (rawType) {\n case \"Object\":\n case \"Array\":\n return 1;\n case \"Map\":\n case \"Set\":\n case \"WeakMap\":\n case \"WeakSet\":\n return 2;\n default:\n return 0;\n }\n}\nfunction getTargetType(value) {\n return value[\"__v_skip\"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));\n}\nfunction reactive(target) {\n if (isReadonly(target)) {\n return target;\n }\n return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);\n}\nfunction shallowReactive(target) {\n return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);\n}\nfunction readonly(target) {\n return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);\n}\nfunction createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {\n if (!isObject$2(target)) {\n return target;\n }\n if (target[\"__v_raw\"] && !(isReadonly2 && target[\"__v_isReactive\"])) {\n return target;\n }\n const existingProxy = proxyMap.get(target);\n if (existingProxy) {\n return existingProxy;\n }\n const targetType = getTargetType(target);\n if (targetType === 0) {\n return target;\n }\n const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);\n proxyMap.set(target, proxy);\n return proxy;\n}\nfunction isReactive(value) {\n if (isReadonly(value)) {\n return isReactive(value[\"__v_raw\"]);\n }\n return !!(value && value[\"__v_isReactive\"]);\n}\nfunction isReadonly(value) {\n return !!(value && value[\"__v_isReadonly\"]);\n}\nfunction isShallow(value) {\n return !!(value && value[\"__v_isShallow\"]);\n}\nfunction isProxy(value) {\n return isReactive(value) || isReadonly(value);\n}\nfunction toRaw(observed) {\n const raw = observed && observed[\"__v_raw\"];\n return raw ? toRaw(raw) : observed;\n}\nfunction markRaw(value) {\n def$1(value, \"__v_skip\", true);\n return value;\n}\nconst toReactive = (value) => isObject$2(value) ? reactive(value) : value;\nconst toReadonly = (value) => isObject$2(value) ? readonly(value) : value;\nfunction trackRefValue(ref) {\n if (shouldTrack && activeEffect) {\n ref = toRaw(ref);\n {\n trackEffects(ref.dep || (ref.dep = createDep()));\n }\n }\n}\nfunction triggerRefValue(ref, newVal) {\n ref = toRaw(ref);\n if (ref.dep) {\n {\n triggerEffects(ref.dep);\n }\n }\n}\nfunction isRef(r) {\n return !!(r && r.__v_isRef === true);\n}\nfunction unref(ref) {\n return isRef(ref) ? ref.value : ref;\n}\nconst shallowUnwrapHandlers = {\n get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),\n set: (target, key, value, receiver) => {\n const oldValue = target[key];\n if (isRef(oldValue) && !isRef(value)) {\n oldValue.value = value;\n return true;\n } else {\n return Reflect.set(target, key, value, receiver);\n }\n }\n};\nfunction proxyRefs(objectWithRefs) {\n return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);\n}\nclass ComputedRefImpl {\n constructor(getter, _setter, isReadonly2, isSSR) {\n this._setter = _setter;\n this.dep = void 0;\n this.__v_isRef = true;\n this._dirty = true;\n this.effect = new ReactiveEffect(getter, () => {\n if (!this._dirty) {\n this._dirty = true;\n triggerRefValue(this);\n }\n });\n this.effect.computed = this;\n this.effect.active = this._cacheable = !isSSR;\n this[\"__v_isReadonly\"] = isReadonly2;\n }\n get value() {\n const self2 = toRaw(this);\n trackRefValue(self2);\n if (self2._dirty || !self2._cacheable) {\n self2._dirty = false;\n self2._value = self2.effect.run();\n }\n return self2._value;\n }\n set value(newValue) {\n this._setter(newValue);\n }\n}\nfunction computed$1(getterOrOptions, debugOptions, isSSR = false) {\n let getter;\n let setter;\n const onlyGetter = isFunction$2(getterOrOptions);\n if (onlyGetter) {\n getter = getterOrOptions;\n setter = NOOP$1;\n } else {\n getter = getterOrOptions.get;\n setter = getterOrOptions.set;\n }\n const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);\n return cRef;\n}\nfunction makeMap$1(str, expectsLowerCase) {\n const map = /* @__PURE__ */ Object.create(null);\n const list = str.split(\",\");\n for (let i = 0; i < list.length; i++) {\n map[list[i]] = true;\n }\n return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];\n}\nfunction normalizeStyle(value) {\n if (isArray$1(value)) {\n const res = {};\n for (let i = 0; i < value.length; i++) {\n const item = value[i];\n const normalized = isString$1(item) ? parseStringStyle(item) : normalizeStyle(item);\n if (normalized) {\n for (const key in normalized) {\n res[key] = normalized[key];\n }\n }\n }\n return res;\n } else if (isString$1(value)) {\n return value;\n } else if (isObject$1(value)) {\n return value;\n }\n}\nconst listDelimiterRE = /;(?![^(]*\\))/g;\nconst propertyDelimiterRE = /:(.+)/;\nfunction parseStringStyle(cssText) {\n const ret = {};\n cssText.split(listDelimiterRE).forEach((item) => {\n if (item) {\n const tmp = item.split(propertyDelimiterRE);\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\n }\n });\n return ret;\n}\nfunction normalizeClass(value) {\n let res = \"\";\n if (isString$1(value)) {\n res = value;\n } else if (isArray$1(value)) {\n for (let i = 0; i < value.length; i++) {\n const normalized = normalizeClass(value[i]);\n if (normalized) {\n res += normalized + \" \";\n }\n }\n } else if (isObject$1(value)) {\n for (const name in value) {\n if (value[name]) {\n res += name + \" \";\n }\n }\n }\n return res.trim();\n}\nfunction normalizeProps(props) {\n if (!props)\n return null;\n let { class: klass, style } = props;\n if (klass && !isString$1(klass)) {\n props.class = normalizeClass(klass);\n }\n if (style) {\n props.style = normalizeStyle(style);\n }\n return props;\n}\nconst toDisplayString = (val) => {\n return isString$1(val) ? val : val == null ? \"\" : isArray$1(val) || isObject$1(val) && (val.toString === objectToString || !isFunction$1(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val);\n};\nconst replacer = (_key, val) => {\n if (val && val.__v_isRef) {\n return replacer(_key, val.value);\n } else if (isMap(val)) {\n return {\n [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2]) => {\n entries[`${key} =>`] = val2;\n return entries;\n }, {})\n };\n } else if (isSet(val)) {\n return {\n [`Set(${val.size})`]: [...val.values()]\n };\n } else if (isObject$1(val) && !isArray$1(val) && !isPlainObject(val)) {\n return String(val);\n }\n return val;\n};\nconst EMPTY_OBJ = {};\nconst EMPTY_ARR = [];\nconst NOOP = () => {\n};\nconst NO = () => false;\nconst onRE$1 = /^on[^a-z]/;\nconst isOn$1 = (key) => onRE$1.test(key);\nconst isModelListener$1 = (key) => key.startsWith(\"onUpdate:\");\nconst extend$1 = Object.assign;\nconst remove = (arr, el) => {\n const i = arr.indexOf(el);\n if (i > -1) {\n arr.splice(i, 1);\n }\n};\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\nconst isArray$1 = Array.isArray;\nconst isMap = (val) => toTypeString(val) === \"[object Map]\";\nconst isSet = (val) => toTypeString(val) === \"[object Set]\";\nconst isFunction$1 = (val) => typeof val === \"function\";\nconst isString$1 = (val) => typeof val === \"string\";\nconst isObject$1 = (val) => val !== null && typeof val === \"object\";\nconst isPromise = (val) => {\n return isObject$1(val) && isFunction$1(val.then) && isFunction$1(val.catch);\n};\nconst objectToString = Object.prototype.toString;\nconst toTypeString = (value) => objectToString.call(value);\nconst isPlainObject = (val) => toTypeString(val) === \"[object Object]\";\nconst isReservedProp = /* @__PURE__ */ makeMap$1(\n \",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted\"\n);\nconst cacheStringFunction$1 = (fn) => {\n const cache = /* @__PURE__ */ Object.create(null);\n return (str) => {\n const hit = cache[str];\n return hit || (cache[str] = fn(str));\n };\n};\nconst camelizeRE$1 = /-(\\w)/g;\nconst camelize$1 = cacheStringFunction$1((str) => {\n return str.replace(camelizeRE$1, (_, c) => c ? c.toUpperCase() : \"\");\n});\nconst hyphenateRE$1 = /\\B([A-Z])/g;\nconst hyphenate$1 = cacheStringFunction$1((str) => str.replace(hyphenateRE$1, \"-$1\").toLowerCase());\nconst capitalize$1 = cacheStringFunction$1((str) => str.charAt(0).toUpperCase() + str.slice(1));\nconst toHandlerKey = cacheStringFunction$1((str) => str ? `on${capitalize$1(str)}` : ``);\nconst hasChanged = (value, oldValue) => !Object.is(value, oldValue);\nconst invokeArrayFns = (fns, arg) => {\n for (let i = 0; i < fns.length; i++) {\n fns[i](arg);\n }\n};\nconst def = (obj, key, value) => {\n Object.defineProperty(obj, key, {\n configurable: true,\n enumerable: false,\n value\n });\n};\nconst toNumber$1 = (val) => {\n const n = parseFloat(val);\n return isNaN(n) ? val : n;\n};\nlet _globalThis;\nconst getGlobalThis = () => {\n return _globalThis || (_globalThis = typeof globalThis !== \"undefined\" ? globalThis : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : typeof global !== \"undefined\" ? global : {});\n};\nfunction callWithErrorHandling(fn, instance2, type, args) {\n let res;\n try {\n res = args ? fn(...args) : fn();\n } catch (err) {\n handleError(err, instance2, type);\n }\n return res;\n}\nfunction callWithAsyncErrorHandling(fn, instance2, type, args) {\n if (isFunction$1(fn)) {\n const res = callWithErrorHandling(fn, instance2, type, args);\n if (res && isPromise(res)) {\n res.catch((err) => {\n handleError(err, instance2, type);\n });\n }\n return res;\n }\n const values = [];\n for (let i = 0; i < fn.length; i++) {\n values.push(callWithAsyncErrorHandling(fn[i], instance2, type, args));\n }\n return values;\n}\nfunction handleError(err, instance2, type, throwInDev = true) {\n const contextVNode = instance2 ? instance2.vnode : null;\n if (instance2) {\n let cur = instance2.parent;\n const exposedInstance = instance2.proxy;\n const errorInfo = type;\n while (cur) {\n const errorCapturedHooks = cur.ec;\n if (errorCapturedHooks) {\n for (let i = 0; i < errorCapturedHooks.length; i++) {\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\n return;\n }\n }\n }\n cur = cur.parent;\n }\n const appErrorHandler = instance2.appContext.config.errorHandler;\n if (appErrorHandler) {\n callWithErrorHandling(appErrorHandler, null, 10, [err, exposedInstance, errorInfo]);\n return;\n }\n }\n logError(err, type, contextVNode, throwInDev);\n}\nfunction logError(err, type, contextVNode, throwInDev = true) {\n {\n console.error(err);\n }\n}\nlet isFlushing = false;\nlet isFlushPending = false;\nconst queue = [];\nlet flushIndex = 0;\nconst pendingPreFlushCbs = [];\nlet activePreFlushCbs = null;\nlet preFlushIndex = 0;\nconst pendingPostFlushCbs = [];\nlet activePostFlushCbs = null;\nlet postFlushIndex = 0;\nconst resolvedPromise = /* @__PURE__ */ Promise.resolve();\nlet currentFlushPromise = null;\nlet currentPreFlushParentJob = null;\nfunction nextTick(fn) {\n const p2 = currentFlushPromise || resolvedPromise;\n return fn ? p2.then(this ? fn.bind(this) : fn) : p2;\n}\nfunction findInsertionIndex(id) {\n let start2 = flushIndex + 1;\n let end = queue.length;\n while (start2 < end) {\n const middle = start2 + end >>> 1;\n const middleJobId = getId(queue[middle]);\n middleJobId < id ? start2 = middle + 1 : end = middle;\n }\n return start2;\n}\nfunction queueJob(job) {\n if ((!queue.length || !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) && job !== currentPreFlushParentJob) {\n if (job.id == null) {\n queue.push(job);\n } else {\n queue.splice(findInsertionIndex(job.id), 0, job);\n }\n queueFlush();\n }\n}\nfunction queueFlush() {\n if (!isFlushing && !isFlushPending) {\n isFlushPending = true;\n currentFlushPromise = resolvedPromise.then(flushJobs);\n }\n}\nfunction invalidateJob(job) {\n const i = queue.indexOf(job);\n if (i > flushIndex) {\n queue.splice(i, 1);\n }\n}\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\n if (!isArray$1(cb)) {\n if (!activeQueue || !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\n pendingQueue.push(cb);\n }\n } else {\n pendingQueue.push(...cb);\n }\n queueFlush();\n}\nfunction queuePreFlushCb(cb) {\n queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\n}\nfunction queuePostFlushCb(cb) {\n queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\n}\nfunction flushPreFlushCbs(seen, parentJob = null) {\n if (pendingPreFlushCbs.length) {\n currentPreFlushParentJob = parentJob;\n activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\n pendingPreFlushCbs.length = 0;\n for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\n activePreFlushCbs[preFlushIndex]();\n }\n activePreFlushCbs = null;\n preFlushIndex = 0;\n currentPreFlushParentJob = null;\n flushPreFlushCbs(seen, parentJob);\n }\n}\nfunction flushPostFlushCbs(seen) {\n flushPreFlushCbs();\n if (pendingPostFlushCbs.length) {\n const deduped = [...new Set(pendingPostFlushCbs)];\n pendingPostFlushCbs.length = 0;\n if (activePostFlushCbs) {\n activePostFlushCbs.push(...deduped);\n return;\n }\n activePostFlushCbs = deduped;\n activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\n activePostFlushCbs[postFlushIndex]();\n }\n activePostFlushCbs = null;\n postFlushIndex = 0;\n }\n}\nconst getId = (job) => job.id == null ? Infinity : job.id;\nfunction flushJobs(seen) {\n isFlushPending = false;\n isFlushing = true;\n flushPreFlushCbs(seen);\n queue.sort((a, b) => getId(a) - getId(b));\n const check2 = NOOP;\n try {\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\n const job = queue[flushIndex];\n if (job && job.active !== false) {\n if (false)\n ;\n callWithErrorHandling(job, null, 14);\n }\n }\n } finally {\n flushIndex = 0;\n queue.length = 0;\n flushPostFlushCbs();\n isFlushing = false;\n currentFlushPromise = null;\n if (queue.length || pendingPreFlushCbs.length || pendingPostFlushCbs.length) {\n flushJobs(seen);\n }\n }\n}\nfunction emit$1(instance2, event, ...rawArgs) {\n if (instance2.isUnmounted)\n return;\n const props = instance2.vnode.props || EMPTY_OBJ;\n let args = rawArgs;\n const isModelListener2 = event.startsWith(\"update:\");\n const modelArg = isModelListener2 && event.slice(7);\n if (modelArg && modelArg in props) {\n const modifiersKey = `${modelArg === \"modelValue\" ? \"model\" : modelArg}Modifiers`;\n const { number, trim } = props[modifiersKey] || EMPTY_OBJ;\n if (trim) {\n args = rawArgs.map((a) => a.trim());\n }\n if (number) {\n args = rawArgs.map(toNumber$1);\n }\n }\n let handlerName;\n let handler = props[handlerName = toHandlerKey(event)] || props[handlerName = toHandlerKey(camelize$1(event))];\n if (!handler && isModelListener2) {\n handler = props[handlerName = toHandlerKey(hyphenate$1(event))];\n }\n if (handler) {\n callWithAsyncErrorHandling(handler, instance2, 6, args);\n }\n const onceHandler = props[handlerName + `Once`];\n if (onceHandler) {\n if (!instance2.emitted) {\n instance2.emitted = {};\n } else if (instance2.emitted[handlerName]) {\n return;\n }\n instance2.emitted[handlerName] = true;\n callWithAsyncErrorHandling(onceHandler, instance2, 6, args);\n }\n}\nfunction normalizeEmitsOptions(comp, appContext, asMixin = false) {\n const cache = appContext.emitsCache;\n const cached = cache.get(comp);\n if (cached !== void 0) {\n return cached;\n }\n const raw = comp.emits;\n let normalized = {};\n let hasExtends = false;\n if (!isFunction$1(comp)) {\n const extendEmits = (raw2) => {\n const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);\n if (normalizedFromExtend) {\n hasExtends = true;\n extend$1(normalized, normalizedFromExtend);\n }\n };\n if (!asMixin && appContext.mixins.length) {\n appContext.mixins.forEach(extendEmits);\n }\n if (comp.extends) {\n extendEmits(comp.extends);\n }\n if (comp.mixins) {\n comp.mixins.forEach(extendEmits);\n }\n }\n if (!raw && !hasExtends) {\n cache.set(comp, null);\n return null;\n }\n if (isArray$1(raw)) {\n raw.forEach((key) => normalized[key] = null);\n } else {\n extend$1(normalized, raw);\n }\n cache.set(comp, normalized);\n return normalized;\n}\nfunction isEmitListener(options2, key) {\n if (!options2 || !isOn$1(key)) {\n return false;\n }\n key = key.slice(2).replace(/Once$/, \"\");\n return hasOwn(options2, key[0].toLowerCase() + key.slice(1)) || hasOwn(options2, hyphenate$1(key)) || hasOwn(options2, key);\n}\nlet currentRenderingInstance = null;\nlet currentScopeId = null;\nfunction setCurrentRenderingInstance(instance2) {\n const prev = currentRenderingInstance;\n currentRenderingInstance = instance2;\n currentScopeId = instance2 && instance2.type.__scopeId || null;\n return prev;\n}\nfunction withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {\n if (!ctx)\n return fn;\n if (fn._n) {\n return fn;\n }\n const renderFnWithContext = (...args) => {\n if (renderFnWithContext._d) {\n setBlockTracking(-1);\n }\n const prevInstance = setCurrentRenderingInstance(ctx);\n const res = fn(...args);\n setCurrentRenderingInstance(prevInstance);\n if (renderFnWithContext._d) {\n setBlockTracking(1);\n }\n return res;\n };\n renderFnWithContext._n = true;\n renderFnWithContext._c = true;\n renderFnWithContext._d = true;\n return renderFnWithContext;\n}\nfunction markAttrsAccessed() {\n}\nfunction renderComponentRoot(instance2) {\n const { type: Component, vnode, proxy, withProxy, props, propsOptions: [propsOptions], slots, attrs, emit: emit2, render: render2, renderCache, data, setupState, ctx, inheritAttrs } = instance2;\n let result;\n let fallthroughAttrs;\n const prev = setCurrentRenderingInstance(instance2);\n try {\n if (vnode.shapeFlag & 4) {\n const proxyToUse = withProxy || proxy;\n result = normalizeVNode(render2.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx));\n fallthroughAttrs = attrs;\n } else {\n const render3 = Component;\n if (false)\n ;\n result = normalizeVNode(render3.length > 1 ? render3(props, false ? {\n get attrs() {\n markAttrsAccessed();\n return attrs;\n },\n slots,\n emit: emit2\n } : { attrs, slots, emit: emit2 }) : render3(props, null));\n fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);\n }\n } catch (err) {\n blockStack.length = 0;\n handleError(err, instance2, 1);\n result = createVNode(Comment);\n }\n let root = result;\n if (fallthroughAttrs && inheritAttrs !== false) {\n const keys = Object.keys(fallthroughAttrs);\n const { shapeFlag } = root;\n if (keys.length) {\n if (shapeFlag & (1 | 6)) {\n if (propsOptions && keys.some(isModelListener$1)) {\n fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions);\n }\n root = cloneVNode(root, fallthroughAttrs);\n }\n }\n }\n if (vnode.dirs) {\n root = cloneVNode(root);\n root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;\n }\n if (vnode.transition) {\n root.transition = vnode.transition;\n }\n {\n result = root;\n }\n setCurrentRenderingInstance(prev);\n return result;\n}\nconst getFunctionalFallthrough = (attrs) => {\n let res;\n for (const key in attrs) {\n if (key === \"class\" || key === \"style\" || isOn$1(key)) {\n (res || (res = {}))[key] = attrs[key];\n }\n }\n return res;\n};\nconst filterModelListeners = (attrs, props) => {\n const res = {};\n for (const key in attrs) {\n if (!isModelListener$1(key) || !(key.slice(9) in props)) {\n res[key] = attrs[key];\n }\n }\n return res;\n};\nfunction shouldUpdateComponent(prevVNode, nextVNode, optimized) {\n const { props: prevProps, children: prevChildren, component } = prevVNode;\n const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;\n const emits = component.emitsOptions;\n if (nextVNode.dirs || nextVNode.transition) {\n return true;\n }\n if (optimized && patchFlag >= 0) {\n if (patchFlag & 1024) {\n return true;\n }\n if (patchFlag & 16) {\n if (!prevProps) {\n return !!nextProps;\n }\n return hasPropsChanged(prevProps, nextProps, emits);\n } else if (patchFlag & 8) {\n const dynamicProps = nextVNode.dynamicProps;\n for (let i = 0; i < dynamicProps.length; i++) {\n const key = dynamicProps[i];\n if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {\n return true;\n }\n }\n }\n } else {\n if (prevChildren || nextChildren) {\n if (!nextChildren || !nextChildren.$stable) {\n return true;\n }\n }\n if (prevProps === nextProps) {\n return false;\n }\n if (!prevProps) {\n return !!nextProps;\n }\n if (!nextProps) {\n return true;\n }\n return hasPropsChanged(prevProps, nextProps, emits);\n }\n return false;\n}\nfunction hasPropsChanged(prevProps, nextProps, emitsOptions) {\n const nextKeys = Object.keys(nextProps);\n if (nextKeys.length !== Object.keys(prevProps).length) {\n return true;\n }\n for (let i = 0; i < nextKeys.length; i++) {\n const key = nextKeys[i];\n if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {\n return true;\n }\n }\n return false;\n}\nfunction updateHOCHostEl({ vnode, parent }, el) {\n while (parent && parent.subTree === vnode) {\n (vnode = parent.vnode).el = el;\n parent = parent.parent;\n }\n}\nconst isSuspense = (type) => type.__isSuspense;\nfunction queueEffectWithSuspense(fn, suspense) {\n if (suspense && suspense.pendingBranch) {\n if (isArray$1(fn)) {\n suspense.effects.push(...fn);\n } else {\n suspense.effects.push(fn);\n }\n } else {\n queuePostFlushCb(fn);\n }\n}\nfunction provide(key, value) {\n if (!currentInstance)\n ;\n else {\n let provides = currentInstance.provides;\n const parentProvides = currentInstance.parent && currentInstance.parent.provides;\n if (parentProvides === provides) {\n provides = currentInstance.provides = Object.create(parentProvides);\n }\n provides[key] = value;\n }\n}\nfunction inject(key, defaultValue, treatDefaultAsFactory = false) {\n const instance2 = currentInstance || currentRenderingInstance;\n if (instance2) {\n const provides = instance2.parent == null ? instance2.vnode.appContext && instance2.vnode.appContext.provides : instance2.parent.provides;\n if (provides && key in provides) {\n return provides[key];\n } else if (arguments.length > 1) {\n return treatDefaultAsFactory && isFunction$1(defaultValue) ? defaultValue.call(instance2.proxy) : defaultValue;\n } else\n ;\n }\n}\nconst INITIAL_WATCHER_VALUE = {};\nfunction watch(source, cb, options2) {\n return doWatch(source, cb, options2);\n}\nfunction doWatch(source, cb, { immediate, deep, flush: flush2, onTrack, onTrigger } = EMPTY_OBJ) {\n const instance2 = currentInstance;\n let getter;\n let forceTrigger = false;\n let isMultiSource = false;\n if (isRef(source)) {\n getter = () => source.value;\n forceTrigger = isShallow(source);\n } else if (isReactive(source)) {\n getter = () => source;\n deep = true;\n } else if (isArray$1(source)) {\n isMultiSource = true;\n forceTrigger = source.some((s) => isReactive(s) || isShallow(s));\n getter = () => source.map((s) => {\n if (isRef(s)) {\n return s.value;\n } else if (isReactive(s)) {\n return traverse(s);\n } else if (isFunction$1(s)) {\n return callWithErrorHandling(s, instance2, 2);\n } else\n ;\n });\n } else if (isFunction$1(source)) {\n if (cb) {\n getter = () => callWithErrorHandling(source, instance2, 2);\n } else {\n getter = () => {\n if (instance2 && instance2.isUnmounted) {\n return;\n }\n if (cleanup) {\n cleanup();\n }\n return callWithAsyncErrorHandling(source, instance2, 3, [onCleanup]);\n };\n }\n } else {\n getter = NOOP;\n }\n if (cb && deep) {\n const baseGetter = getter;\n getter = () => traverse(baseGetter());\n }\n let cleanup;\n let onCleanup = (fn) => {\n cleanup = effect.onStop = () => {\n callWithErrorHandling(fn, instance2, 4);\n };\n };\n if (isInSSRComponentSetup) {\n onCleanup = NOOP;\n if (!cb) {\n getter();\n } else if (immediate) {\n callWithAsyncErrorHandling(cb, instance2, 3, [\n getter(),\n isMultiSource ? [] : void 0,\n onCleanup\n ]);\n }\n return NOOP;\n }\n let oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE;\n const job = () => {\n if (!effect.active) {\n return;\n }\n if (cb) {\n const newValue = effect.run();\n if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || false) {\n if (cleanup) {\n cleanup();\n }\n callWithAsyncErrorHandling(cb, instance2, 3, [\n newValue,\n oldValue === INITIAL_WATCHER_VALUE ? void 0 : oldValue,\n onCleanup\n ]);\n oldValue = newValue;\n }\n } else {\n effect.run();\n }\n };\n job.allowRecurse = !!cb;\n let scheduler;\n if (flush2 === \"sync\") {\n scheduler = job;\n } else if (flush2 === \"post\") {\n scheduler = () => queuePostRenderEffect(job, instance2 && instance2.suspense);\n } else {\n scheduler = () => queuePreFlushCb(job);\n }\n const effect = new ReactiveEffect(getter, scheduler);\n if (cb) {\n if (immediate) {\n job();\n } else {\n oldValue = effect.run();\n }\n } else if (flush2 === \"post\") {\n queuePostRenderEffect(effect.run.bind(effect), instance2 && instance2.suspense);\n } else {\n effect.run();\n }\n return () => {\n effect.stop();\n if (instance2 && instance2.scope) {\n remove(instance2.scope.effects, effect);\n }\n };\n}\nfunction instanceWatch(source, value, options2) {\n const publicThis = this.proxy;\n const getter = isString$1(source) ? source.includes(\".\") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);\n let cb;\n if (isFunction$1(value)) {\n cb = value;\n } else {\n cb = value.handler;\n options2 = value;\n }\n const cur = currentInstance;\n setCurrentInstance(this);\n const res = doWatch(getter, cb.bind(publicThis), options2);\n if (cur) {\n setCurrentInstance(cur);\n } else {\n unsetCurrentInstance();\n }\n return res;\n}\nfunction createPathGetter(ctx, path) {\n const segments = path.split(\".\");\n return () => {\n let cur = ctx;\n for (let i = 0; i < segments.length && cur; i++) {\n cur = cur[segments[i]];\n }\n return cur;\n };\n}\nfunction traverse(value, seen) {\n if (!isObject$1(value) || value[\"__v_skip\"]) {\n return value;\n }\n seen = seen || /* @__PURE__ */ new Set();\n if (seen.has(value)) {\n return value;\n }\n seen.add(value);\n if (isRef(value)) {\n traverse(value.value, seen);\n } else if (isArray$1(value)) {\n for (let i = 0; i < value.length; i++) {\n traverse(value[i], seen);\n }\n } else if (isSet(value) || isMap(value)) {\n value.forEach((v) => {\n traverse(v, seen);\n });\n } else if (isPlainObject(value)) {\n for (const key in value) {\n traverse(value[key], seen);\n }\n }\n return value;\n}\nfunction useTransitionState() {\n const state2 = {\n isMounted: false,\n isLeaving: false,\n isUnmounting: false,\n leavingVNodes: /* @__PURE__ */ new Map()\n };\n onMounted(() => {\n state2.isMounted = true;\n });\n onBeforeUnmount(() => {\n state2.isUnmounting = true;\n });\n return state2;\n}\nconst TransitionHookValidator = [Function, Array];\nconst BaseTransitionImpl = {\n name: `BaseTransition`,\n props: {\n mode: String,\n appear: Boolean,\n persisted: Boolean,\n onBeforeEnter: TransitionHookValidator,\n onEnter: TransitionHookValidator,\n onAfterEnter: TransitionHookValidator,\n onEnterCancelled: TransitionHookValidator,\n onBeforeLeave: TransitionHookValidator,\n onLeave: TransitionHookValidator,\n onAfterLeave: TransitionHookValidator,\n onLeaveCancelled: TransitionHookValidator,\n onBeforeAppear: TransitionHookValidator,\n onAppear: TransitionHookValidator,\n onAfterAppear: TransitionHookValidator,\n onAppearCancelled: TransitionHookValidator\n },\n setup(props, { slots }) {\n const instance2 = getCurrentInstance();\n const state2 = useTransitionState();\n let prevTransitionKey;\n return () => {\n const children = slots.default && getTransitionRawChildren(slots.default(), true);\n if (!children || !children.length) {\n return;\n }\n let child = children[0];\n if (children.length > 1) {\n for (const c of children) {\n if (c.type !== Comment) {\n child = c;\n break;\n }\n }\n }\n const rawProps = toRaw(props);\n const { mode } = rawProps;\n if (state2.isLeaving) {\n return emptyPlaceholder(child);\n }\n const innerChild = getKeepAliveChild(child);\n if (!innerChild) {\n return emptyPlaceholder(child);\n }\n const enterHooks = resolveTransitionHooks(innerChild, rawProps, state2, instance2);\n setTransitionHooks(innerChild, enterHooks);\n const oldChild = instance2.subTree;\n const oldInnerChild = oldChild && getKeepAliveChild(oldChild);\n let transitionKeyChanged = false;\n const { getTransitionKey } = innerChild.type;\n if (getTransitionKey) {\n const key = getTransitionKey();\n if (prevTransitionKey === void 0) {\n prevTransitionKey = key;\n } else if (key !== prevTransitionKey) {\n prevTransitionKey = key;\n transitionKeyChanged = true;\n }\n }\n if (oldInnerChild && oldInnerChild.type !== Comment && (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) {\n const leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state2, instance2);\n setTransitionHooks(oldInnerChild, leavingHooks);\n if (mode === \"out-in\") {\n state2.isLeaving = true;\n leavingHooks.afterLeave = () => {\n state2.isLeaving = false;\n instance2.update();\n };\n return emptyPlaceholder(child);\n } else if (mode === \"in-out\" && innerChild.type !== Comment) {\n leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {\n const leavingVNodesCache = getLeavingNodesForType(state2, oldInnerChild);\n leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;\n el._leaveCb = () => {\n earlyRemove();\n el._leaveCb = void 0;\n delete enterHooks.delayedLeave;\n };\n enterHooks.delayedLeave = delayedLeave;\n };\n }\n }\n return child;\n };\n }\n};\nconst BaseTransition = BaseTransitionImpl;\nfunction getLeavingNodesForType(state2, vnode) {\n const { leavingVNodes } = state2;\n let leavingVNodesCache = leavingVNodes.get(vnode.type);\n if (!leavingVNodesCache) {\n leavingVNodesCache = /* @__PURE__ */ Object.create(null);\n leavingVNodes.set(vnode.type, leavingVNodesCache);\n }\n return leavingVNodesCache;\n}\nfunction resolveTransitionHooks(vnode, props, state2, instance2) {\n const { appear, mode, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled } = props;\n const key = String(vnode.key);\n const leavingVNodesCache = getLeavingNodesForType(state2, vnode);\n const callHook2 = (hook, args) => {\n hook && callWithAsyncErrorHandling(hook, instance2, 9, args);\n };\n const callAsyncHook = (hook, args) => {\n const done = args[1];\n callHook2(hook, args);\n if (isArray$1(hook)) {\n if (hook.every((hook2) => hook2.length <= 1))\n done();\n } else if (hook.length <= 1) {\n done();\n }\n };\n const hooks = {\n mode,\n persisted,\n beforeEnter(el) {\n let hook = onBeforeEnter;\n if (!state2.isMounted) {\n if (appear) {\n hook = onBeforeAppear || onBeforeEnter;\n } else {\n return;\n }\n }\n if (el._leaveCb) {\n el._leaveCb(true);\n }\n const leavingVNode = leavingVNodesCache[key];\n if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el._leaveCb) {\n leavingVNode.el._leaveCb();\n }\n callHook2(hook, [el]);\n },\n enter(el) {\n let hook = onEnter;\n let afterHook = onAfterEnter;\n let cancelHook = onEnterCancelled;\n if (!state2.isMounted) {\n if (appear) {\n hook = onAppear || onEnter;\n afterHook = onAfterAppear || onAfterEnter;\n cancelHook = onAppearCancelled || onEnterCancelled;\n } else {\n return;\n }\n }\n let called = false;\n const done = el._enterCb = (cancelled) => {\n if (called)\n return;\n called = true;\n if (cancelled) {\n callHook2(cancelHook, [el]);\n } else {\n callHook2(afterHook, [el]);\n }\n if (hooks.delayedLeave) {\n hooks.delayedLeave();\n }\n el._enterCb = void 0;\n };\n if (hook) {\n callAsyncHook(hook, [el, done]);\n } else {\n done();\n }\n },\n leave(el, remove2) {\n const key2 = String(vnode.key);\n if (el._enterCb) {\n el._enterCb(true);\n }\n if (state2.isUnmounting) {\n return remove2();\n }\n callHook2(onBeforeLeave, [el]);\n let called = false;\n const done = el._leaveCb = (cancelled) => {\n if (called)\n return;\n called = true;\n remove2();\n if (cancelled) {\n callHook2(onLeaveCancelled, [el]);\n } else {\n callHook2(onAfterLeave, [el]);\n }\n el._leaveCb = void 0;\n if (leavingVNodesCache[key2] === vnode) {\n delete leavingVNodesCache[key2];\n }\n };\n leavingVNodesCache[key2] = vnode;\n if (onLeave) {\n callAsyncHook(onLeave, [el, done]);\n } else {\n done();\n }\n },\n clone(vnode2) {\n return resolveTransitionHooks(vnode2, props, state2, instance2);\n }\n };\n return hooks;\n}\nfunction emptyPlaceholder(vnode) {\n if (isKeepAlive(vnode)) {\n vnode = cloneVNode(vnode);\n vnode.children = null;\n return vnode;\n }\n}\nfunction getKeepAliveChild(vnode) {\n return isKeepAlive(vnode) ? vnode.children ? vnode.children[0] : void 0 : vnode;\n}\nfunction setTransitionHooks(vnode, hooks) {\n if (vnode.shapeFlag & 6 && vnode.component) {\n setTransitionHooks(vnode.component.subTree, hooks);\n } else if (vnode.shapeFlag & 128) {\n vnode.ssContent.transition = hooks.clone(vnode.ssContent);\n vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);\n } else {\n vnode.transition = hooks;\n }\n}\nfunction getTransitionRawChildren(children, keepComment = false, parentKey) {\n let ret = [];\n let keyedFragmentCount = 0;\n for (let i = 0; i < children.length; i++) {\n let child = children[i];\n const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);\n if (child.type === Fragment) {\n if (child.patchFlag & 128)\n keyedFragmentCount++;\n ret = ret.concat(getTransitionRawChildren(child.children, keepComment, key));\n } else if (keepComment || child.type !== Comment) {\n ret.push(key != null ? cloneVNode(child, { key }) : child);\n }\n }\n if (keyedFragmentCount > 1) {\n for (let i = 0; i < ret.length; i++) {\n ret[i].patchFlag = -2;\n }\n }\n return ret;\n}\nfunction defineComponent(options2) {\n return isFunction$1(options2) ? { setup: options2, name: options2.name } : options2;\n}\nconst isAsyncWrapper = (i) => !!i.type.__asyncLoader;\nconst isKeepAlive = (vnode) => vnode.type.__isKeepAlive;\nfunction onActivated(hook, target) {\n registerKeepAliveHook(hook, \"a\", target);\n}\nfunction onDeactivated(hook, target) {\n registerKeepAliveHook(hook, \"da\", target);\n}\nfunction registerKeepAliveHook(hook, type, target = currentInstance) {\n const wrappedHook = hook.__wdc || (hook.__wdc = () => {\n let current = target;\n while (current) {\n if (current.isDeactivated) {\n return;\n }\n current = current.parent;\n }\n return hook();\n });\n injectHook(type, wrappedHook, target);\n if (target) {\n let current = target.parent;\n while (current && current.parent) {\n if (isKeepAlive(current.parent.vnode)) {\n injectToKeepAliveRoot(wrappedHook, type, target, current);\n }\n current = current.parent;\n }\n }\n}\nfunction injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {\n const injected = injectHook(type, hook, keepAliveRoot, true);\n onUnmounted(() => {\n remove(keepAliveRoot[type], injected);\n }, target);\n}\nfunction injectHook(type, hook, target = currentInstance, prepend = false) {\n if (target) {\n const hooks = target[type] || (target[type] = []);\n const wrappedHook = hook.__weh || (hook.__weh = (...args) => {\n if (target.isUnmounted) {\n return;\n }\n pauseTracking();\n setCurrentInstance(target);\n const res = callWithAsyncErrorHandling(hook, target, type, args);\n unsetCurrentInstance();\n resetTracking();\n return res;\n });\n if (prepend) {\n hooks.unshift(wrappedHook);\n } else {\n hooks.push(wrappedHook);\n }\n return wrappedHook;\n }\n}\nconst createHook = (lifecycle) => (hook, target = currentInstance) => (!isInSSRComponentSetup || lifecycle === \"sp\") && injectHook(lifecycle, hook, target);\nconst onBeforeMount = createHook(\"bm\");\nconst onMounted = createHook(\"m\");\nconst onBeforeUpdate = createHook(\"bu\");\nconst onUpdated = createHook(\"u\");\nconst onBeforeUnmount = createHook(\"bum\");\nconst onUnmounted = createHook(\"um\");\nconst onServerPrefetch = createHook(\"sp\");\nconst onRenderTriggered = createHook(\"rtg\");\nconst onRenderTracked = createHook(\"rtc\");\nfunction onErrorCaptured(hook, target = currentInstance) {\n injectHook(\"ec\", hook, target);\n}\nfunction withDirectives(vnode, directives) {\n const internalInstance = currentRenderingInstance;\n if (internalInstance === null) {\n return vnode;\n }\n const instance2 = getExposeProxy(internalInstance) || internalInstance.proxy;\n const bindings = vnode.dirs || (vnode.dirs = []);\n for (let i = 0; i < directives.length; i++) {\n let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];\n if (isFunction$1(dir)) {\n dir = {\n mounted: dir,\n updated: dir\n };\n }\n if (dir.deep) {\n traverse(value);\n }\n bindings.push({\n dir,\n instance: instance2,\n value,\n oldValue: void 0,\n arg,\n modifiers\n });\n }\n return vnode;\n}\nfunction invokeDirectiveHook(vnode, prevVNode, instance2, name) {\n const bindings = vnode.dirs;\n const oldBindings = prevVNode && prevVNode.dirs;\n for (let i = 0; i < bindings.length; i++) {\n const binding = bindings[i];\n if (oldBindings) {\n binding.oldValue = oldBindings[i].value;\n }\n let hook = binding.dir[name];\n if (hook) {\n pauseTracking();\n callWithAsyncErrorHandling(hook, instance2, 8, [\n vnode.el,\n binding,\n vnode,\n prevVNode\n ]);\n resetTracking();\n }\n }\n}\nconst COMPONENTS = \"components\";\nconst DIRECTIVES = \"directives\";\nfunction resolveComponent(name, maybeSelfReference) {\n return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;\n}\nconst NULL_DYNAMIC_COMPONENT = Symbol();\nfunction resolveDynamicComponent(component) {\n if (isString$1(component)) {\n return resolveAsset(COMPONENTS, component, false) || component;\n } else {\n return component || NULL_DYNAMIC_COMPONENT;\n }\n}\nfunction resolveDirective(name) {\n return resolveAsset(DIRECTIVES, name);\n}\nfunction resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {\n const instance2 = currentRenderingInstance || currentInstance;\n if (instance2) {\n const Component = instance2.type;\n if (type === COMPONENTS) {\n const selfName = getComponentName(Component, false);\n if (selfName && (selfName === name || selfName === camelize$1(name) || selfName === capitalize$1(camelize$1(name)))) {\n return Component;\n }\n }\n const res = resolve(instance2[type] || Component[type], name) || resolve(instance2.appContext[type], name);\n if (!res && maybeSelfReference) {\n return Component;\n }\n return res;\n }\n}\nfunction resolve(registry, name) {\n return registry && (registry[name] || registry[camelize$1(name)] || registry[capitalize$1(camelize$1(name))]);\n}\nfunction renderList(source, renderItem, cache, index) {\n let ret;\n const cached = cache && cache[index];\n if (isArray$1(source) || isString$1(source)) {\n ret = new Array(source.length);\n for (let i = 0, l = source.length; i < l; i++) {\n ret[i] = renderItem(source[i], i, void 0, cached && cached[i]);\n }\n } else if (typeof source === \"number\") {\n ret = new Array(source);\n for (let i = 0; i < source; i++) {\n ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);\n }\n } else if (isObject$1(source)) {\n if (source[Symbol.iterator]) {\n ret = Array.from(source, (item, i) => renderItem(item, i, void 0, cached && cached[i]));\n } else {\n const keys = Object.keys(source);\n ret = new Array(keys.length);\n for (let i = 0, l = keys.length; i < l; i++) {\n const key = keys[i];\n ret[i] = renderItem(source[key], key, i, cached && cached[i]);\n }\n }\n } else {\n ret = [];\n }\n if (cache) {\n cache[index] = ret;\n }\n return ret;\n}\nfunction createSlots(slots, dynamicSlots) {\n for (let i = 0; i < dynamicSlots.length; i++) {\n const slot = dynamicSlots[i];\n if (isArray$1(slot)) {\n for (let j = 0; j < slot.length; j++) {\n slots[slot[j].name] = slot[j].fn;\n }\n } else if (slot) {\n slots[slot.name] = slot.fn;\n }\n }\n return slots;\n}\nfunction renderSlot(slots, name, props = {}, fallback, noSlotted) {\n if (currentRenderingInstance.isCE || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.isCE) {\n return createVNode(\"slot\", name === \"default\" ? null : { name }, fallback && fallback());\n }\n let slot = slots[name];\n if (slot && slot._c) {\n slot._d = false;\n }\n openBlock();\n const validSlotContent = slot && ensureValidVNode(slot(props));\n const rendered = createBlock(Fragment, { key: props.key || `_${name}` }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 ? 64 : -2);\n if (!noSlotted && rendered.scopeId) {\n rendered.slotScopeIds = [rendered.scopeId + \"-s\"];\n }\n if (slot && slot._c) {\n slot._d = true;\n }\n return rendered;\n}\nfunction ensureValidVNode(vnodes) {\n return vnodes.some((child) => {\n if (!isVNode(child))\n return true;\n if (child.type === Comment)\n return false;\n if (child.type === Fragment && !ensureValidVNode(child.children))\n return false;\n return true;\n }) ? vnodes : null;\n}\nconst getPublicInstance = (i) => {\n if (!i)\n return null;\n if (isStatefulComponent(i))\n return getExposeProxy(i) || i.proxy;\n return getPublicInstance(i.parent);\n};\nconst publicPropertiesMap = /* @__PURE__ */ extend$1(/* @__PURE__ */ Object.create(null), {\n $: (i) => i,\n $el: (i) => i.vnode.el,\n $data: (i) => i.data,\n $props: (i) => i.props,\n $attrs: (i) => i.attrs,\n $slots: (i) => i.slots,\n $refs: (i) => i.refs,\n $parent: (i) => getPublicInstance(i.parent),\n $root: (i) => getPublicInstance(i.root),\n $emit: (i) => i.emit,\n $options: (i) => resolveMergedOptions(i),\n $forceUpdate: (i) => i.f || (i.f = () => queueJob(i.update)),\n $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),\n $watch: (i) => instanceWatch.bind(i)\n});\nconst PublicInstanceProxyHandlers = {\n get({ _: instance2 }, key) {\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance2;\n let normalizedProps;\n if (key[0] !== \"$\") {\n const n = accessCache[key];\n if (n !== void 0) {\n switch (n) {\n case 1:\n return setupState[key];\n case 2:\n return data[key];\n case 4:\n return ctx[key];\n case 3:\n return props[key];\n }\n } else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\n accessCache[key] = 1;\n return setupState[key];\n } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\n accessCache[key] = 2;\n return data[key];\n } else if ((normalizedProps = instance2.propsOptions[0]) && hasOwn(normalizedProps, key)) {\n accessCache[key] = 3;\n return props[key];\n } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\n accessCache[key] = 4;\n return ctx[key];\n } else if (shouldCacheAccess) {\n accessCache[key] = 0;\n }\n }\n const publicGetter = publicPropertiesMap[key];\n let cssModule, globalProperties;\n if (publicGetter) {\n if (key === \"$attrs\") {\n track(instance2, \"get\", key);\n }\n return publicGetter(instance2);\n } else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) {\n return cssModule;\n } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\n accessCache[key] = 4;\n return ctx[key];\n } else if (globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)) {\n {\n return globalProperties[key];\n }\n } else\n ;\n },\n set({ _: instance2 }, key, value) {\n const { data, setupState, ctx } = instance2;\n if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\n setupState[key] = value;\n return true;\n } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\n data[key] = value;\n return true;\n } else if (hasOwn(instance2.props, key)) {\n return false;\n }\n if (key[0] === \"$\" && key.slice(1) in instance2) {\n return false;\n } else {\n {\n ctx[key] = value;\n }\n }\n return true;\n },\n has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {\n let normalizedProps;\n return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || setupState !== EMPTY_OBJ && hasOwn(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);\n },\n defineProperty(target, key, descriptor) {\n if (descriptor.get != null) {\n target._.accessCache[key] = 0;\n } else if (hasOwn(descriptor, \"value\")) {\n this.set(target, key, descriptor.value, null);\n }\n return Reflect.defineProperty(target, key, descriptor);\n }\n};\nlet shouldCacheAccess = true;\nfunction applyOptions(instance2) {\n const options2 = resolveMergedOptions(instance2);\n const publicThis = instance2.proxy;\n const ctx = instance2.ctx;\n shouldCacheAccess = false;\n if (options2.beforeCreate) {\n callHook$1(options2.beforeCreate, instance2, \"bc\");\n }\n const {\n data: dataOptions,\n computed: computedOptions,\n methods,\n watch: watchOptions,\n provide: provideOptions,\n inject: injectOptions,\n created,\n beforeMount: beforeMount2,\n mounted,\n beforeUpdate,\n updated: updated2,\n activated,\n deactivated,\n beforeDestroy,\n beforeUnmount,\n destroyed,\n unmounted: unmounted2,\n render: render2,\n renderTracked,\n renderTriggered,\n errorCaptured,\n serverPrefetch,\n expose,\n inheritAttrs,\n components,\n directives,\n filters\n } = options2;\n const checkDuplicateProperties = null;\n if (injectOptions) {\n resolveInjections(injectOptions, ctx, checkDuplicateProperties, instance2.appContext.config.unwrapInjectedRef);\n }\n if (methods) {\n for (const key in methods) {\n const methodHandler = methods[key];\n if (isFunction$1(methodHandler)) {\n {\n ctx[key] = methodHandler.bind(publicThis);\n }\n }\n }\n }\n if (dataOptions) {\n const data = dataOptions.call(publicThis, publicThis);\n if (!isObject$1(data))\n ;\n else {\n instance2.data = reactive(data);\n }\n }\n shouldCacheAccess = true;\n if (computedOptions) {\n for (const key in computedOptions) {\n const opt = computedOptions[key];\n const get3 = isFunction$1(opt) ? opt.bind(publicThis, publicThis) : isFunction$1(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;\n const set2 = !isFunction$1(opt) && isFunction$1(opt.set) ? opt.set.bind(publicThis) : NOOP;\n const c = computed({\n get: get3,\n set: set2\n });\n Object.defineProperty(ctx, key, {\n enumerable: true,\n configurable: true,\n get: () => c.value,\n set: (v) => c.value = v\n });\n }\n }\n if (watchOptions) {\n for (const key in watchOptions) {\n createWatcher(watchOptions[key], ctx, publicThis, key);\n }\n }\n if (provideOptions) {\n const provides = isFunction$1(provideOptions) ? provideOptions.call(publicThis) : provideOptions;\n Reflect.ownKeys(provides).forEach((key) => {\n provide(key, provides[key]);\n });\n }\n if (created) {\n callHook$1(created, instance2, \"c\");\n }\n function registerLifecycleHook(register2, hook) {\n if (isArray$1(hook)) {\n hook.forEach((_hook) => register2(_hook.bind(publicThis)));\n } else if (hook) {\n register2(hook.bind(publicThis));\n }\n }\n registerLifecycleHook(onBeforeMount, beforeMount2);\n registerLifecycleHook(onMounted, mounted);\n registerLifecycleHook(onBeforeUpdate, beforeUpdate);\n registerLifecycleHook(onUpdated, updated2);\n registerLifecycleHook(onActivated, activated);\n registerLifecycleHook(onDeactivated, deactivated);\n registerLifecycleHook(onErrorCaptured, errorCaptured);\n registerLifecycleHook(onRenderTracked, renderTracked);\n registerLifecycleHook(onRenderTriggered, renderTriggered);\n registerLifecycleHook(onBeforeUnmount, beforeUnmount);\n registerLifecycleHook(onUnmounted, unmounted2);\n registerLifecycleHook(onServerPrefetch, serverPrefetch);\n if (isArray$1(expose)) {\n if (expose.length) {\n const exposed = instance2.exposed || (instance2.exposed = {});\n expose.forEach((key) => {\n Object.defineProperty(exposed, key, {\n get: () => publicThis[key],\n set: (val) => publicThis[key] = val\n });\n });\n } else if (!instance2.exposed) {\n instance2.exposed = {};\n }\n }\n if (render2 && instance2.render === NOOP) {\n instance2.render = render2;\n }\n if (inheritAttrs != null) {\n instance2.inheritAttrs = inheritAttrs;\n }\n if (components)\n instance2.components = components;\n if (directives)\n instance2.directives = directives;\n}\nfunction resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP, unwrapRef = false) {\n if (isArray$1(injectOptions)) {\n injectOptions = normalizeInject(injectOptions);\n }\n for (const key in injectOptions) {\n const opt = injectOptions[key];\n let injected;\n if (isObject$1(opt)) {\n if (\"default\" in opt) {\n injected = inject(opt.from || key, opt.default, true);\n } else {\n injected = inject(opt.from || key);\n }\n } else {\n injected = inject(opt);\n }\n if (isRef(injected)) {\n if (unwrapRef) {\n Object.defineProperty(ctx, key, {\n enumerable: true,\n configurable: true,\n get: () => injected.value,\n set: (v) => injected.value = v\n });\n } else {\n ctx[key] = injected;\n }\n } else {\n ctx[key] = injected;\n }\n }\n}\nfunction callHook$1(hook, instance2, type) {\n callWithAsyncErrorHandling(isArray$1(hook) ? hook.map((h2) => h2.bind(instance2.proxy)) : hook.bind(instance2.proxy), instance2, type);\n}\nfunction createWatcher(raw, ctx, publicThis, key) {\n const getter = key.includes(\".\") ? createPathGetter(publicThis, key) : () => publicThis[key];\n if (isString$1(raw)) {\n const handler = ctx[raw];\n if (isFunction$1(handler)) {\n watch(getter, handler);\n }\n } else if (isFunction$1(raw)) {\n watch(getter, raw.bind(publicThis));\n } else if (isObject$1(raw)) {\n if (isArray$1(raw)) {\n raw.forEach((r) => createWatcher(r, ctx, publicThis, key));\n } else {\n const handler = isFunction$1(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];\n if (isFunction$1(handler)) {\n watch(getter, handler, raw);\n }\n }\n } else\n ;\n}\nfunction resolveMergedOptions(instance2) {\n const base = instance2.type;\n const { mixins, extends: extendsOptions } = base;\n const { mixins: globalMixins, optionsCache: cache, config: { optionMergeStrategies } } = instance2.appContext;\n const cached = cache.get(base);\n let resolved;\n if (cached) {\n resolved = cached;\n } else if (!globalMixins.length && !mixins && !extendsOptions) {\n {\n resolved = base;\n }\n } else {\n resolved = {};\n if (globalMixins.length) {\n globalMixins.forEach((m) => mergeOptions(resolved, m, optionMergeStrategies, true));\n }\n mergeOptions(resolved, base, optionMergeStrategies);\n }\n cache.set(base, resolved);\n return resolved;\n}\nfunction mergeOptions(to, from, strats, asMixin = false) {\n const { mixins, extends: extendsOptions } = from;\n if (extendsOptions) {\n mergeOptions(to, extendsOptions, strats, true);\n }\n if (mixins) {\n mixins.forEach((m) => mergeOptions(to, m, strats, true));\n }\n for (const key in from) {\n if (asMixin && key === \"expose\")\n ;\n else {\n const strat = internalOptionMergeStrats[key] || strats && strats[key];\n to[key] = strat ? strat(to[key], from[key]) : from[key];\n }\n }\n return to;\n}\nconst internalOptionMergeStrats = {\n data: mergeDataFn,\n props: mergeObjectOptions,\n emits: mergeObjectOptions,\n methods: mergeObjectOptions,\n computed: mergeObjectOptions,\n beforeCreate: mergeAsArray,\n created: mergeAsArray,\n beforeMount: mergeAsArray,\n mounted: mergeAsArray,\n beforeUpdate: mergeAsArray,\n updated: mergeAsArray,\n beforeDestroy: mergeAsArray,\n beforeUnmount: mergeAsArray,\n destroyed: mergeAsArray,\n unmounted: mergeAsArray,\n activated: mergeAsArray,\n deactivated: mergeAsArray,\n errorCaptured: mergeAsArray,\n serverPrefetch: mergeAsArray,\n components: mergeObjectOptions,\n directives: mergeObjectOptions,\n watch: mergeWatchOptions,\n provide: mergeDataFn,\n inject: mergeInject\n};\nfunction mergeDataFn(to, from) {\n if (!from) {\n return to;\n }\n if (!to) {\n return from;\n }\n return function mergedDataFn() {\n return extend$1(isFunction$1(to) ? to.call(this, this) : to, isFunction$1(from) ? from.call(this, this) : from);\n };\n}\nfunction mergeInject(to, from) {\n return mergeObjectOptions(normalizeInject(to), normalizeInject(from));\n}\nfunction normalizeInject(raw) {\n if (isArray$1(raw)) {\n const res = {};\n for (let i = 0; i < raw.length; i++) {\n res[raw[i]] = raw[i];\n }\n return res;\n }\n return raw;\n}\nfunction mergeAsArray(to, from) {\n return to ? [...new Set([].concat(to, from))] : from;\n}\nfunction mergeObjectOptions(to, from) {\n return to ? extend$1(extend$1(/* @__PURE__ */ Object.create(null), to), from) : from;\n}\nfunction mergeWatchOptions(to, from) {\n if (!to)\n return from;\n if (!from)\n return to;\n const merged = extend$1(/* @__PURE__ */ Object.create(null), to);\n for (const key in from) {\n merged[key] = mergeAsArray(to[key], from[key]);\n }\n return merged;\n}\nfunction initProps(instance2, rawProps, isStateful, isSSR = false) {\n const props = {};\n const attrs = {};\n def(attrs, InternalObjectKey, 1);\n instance2.propsDefaults = /* @__PURE__ */ Object.create(null);\n setFullProps(instance2, rawProps, props, attrs);\n for (const key in instance2.propsOptions[0]) {\n if (!(key in props)) {\n props[key] = void 0;\n }\n }\n if (isStateful) {\n instance2.props = isSSR ? props : shallowReactive(props);\n } else {\n if (!instance2.type.props) {\n instance2.props = attrs;\n } else {\n instance2.props = props;\n }\n }\n instance2.attrs = attrs;\n}\nfunction updateProps(instance2, rawProps, rawPrevProps, optimized) {\n const { props, attrs, vnode: { patchFlag } } = instance2;\n const rawCurrentProps = toRaw(props);\n const [options2] = instance2.propsOptions;\n let hasAttrsChanged = false;\n if ((optimized || patchFlag > 0) && !(patchFlag & 16)) {\n if (patchFlag & 8) {\n const propsToUpdate = instance2.vnode.dynamicProps;\n for (let i = 0; i < propsToUpdate.length; i++) {\n let key = propsToUpdate[i];\n if (isEmitListener(instance2.emitsOptions, key)) {\n continue;\n }\n const value = rawProps[key];\n if (options2) {\n if (hasOwn(attrs, key)) {\n if (value !== attrs[key]) {\n attrs[key] = value;\n hasAttrsChanged = true;\n }\n } else {\n const camelizedKey = camelize$1(key);\n props[camelizedKey] = resolvePropValue(options2, rawCurrentProps, camelizedKey, value, instance2, false);\n }\n } else {\n if (value !== attrs[key]) {\n attrs[key] = value;\n hasAttrsChanged = true;\n }\n }\n }\n }\n } else {\n if (setFullProps(instance2, rawProps, props, attrs)) {\n hasAttrsChanged = true;\n }\n let kebabKey;\n for (const key in rawCurrentProps) {\n if (!rawProps || !hasOwn(rawProps, key) && ((kebabKey = hyphenate$1(key)) === key || !hasOwn(rawProps, kebabKey))) {\n if (options2) {\n if (rawPrevProps && (rawPrevProps[key] !== void 0 || rawPrevProps[kebabKey] !== void 0)) {\n props[key] = resolvePropValue(options2, rawCurrentProps, key, void 0, instance2, true);\n }\n } else {\n delete props[key];\n }\n }\n }\n if (attrs !== rawCurrentProps) {\n for (const key in attrs) {\n if (!rawProps || !hasOwn(rawProps, key) && true) {\n delete attrs[key];\n hasAttrsChanged = true;\n }\n }\n }\n }\n if (hasAttrsChanged) {\n trigger(instance2, \"set\", \"$attrs\");\n }\n}\nfunction setFullProps(instance2, rawProps, props, attrs) {\n const [options2, needCastKeys] = instance2.propsOptions;\n let hasAttrsChanged = false;\n let rawCastValues;\n if (rawProps) {\n for (let key in rawProps) {\n if (isReservedProp(key)) {\n continue;\n }\n const value = rawProps[key];\n let camelKey;\n if (options2 && hasOwn(options2, camelKey = camelize$1(key))) {\n if (!needCastKeys || !needCastKeys.includes(camelKey)) {\n props[camelKey] = value;\n } else {\n (rawCastValues || (rawCastValues = {}))[camelKey] = value;\n }\n } else if (!isEmitListener(instance2.emitsOptions, key)) {\n if (!(key in attrs) || value !== attrs[key]) {\n attrs[key] = value;\n hasAttrsChanged = true;\n }\n }\n }\n }\n if (needCastKeys) {\n const rawCurrentProps = toRaw(props);\n const castValues = rawCastValues || EMPTY_OBJ;\n for (let i = 0; i < needCastKeys.length; i++) {\n const key = needCastKeys[i];\n props[key] = resolvePropValue(options2, rawCurrentProps, key, castValues[key], instance2, !hasOwn(castValues, key));\n }\n }\n return hasAttrsChanged;\n}\nfunction resolvePropValue(options2, props, key, value, instance2, isAbsent) {\n const opt = options2[key];\n if (opt != null) {\n const hasDefault = hasOwn(opt, \"default\");\n if (hasDefault && value === void 0) {\n const defaultValue = opt.default;\n if (opt.type !== Function && isFunction$1(defaultValue)) {\n const { propsDefaults } = instance2;\n if (key in propsDefaults) {\n value = propsDefaults[key];\n } else {\n setCurrentInstance(instance2);\n value = propsDefaults[key] = defaultValue.call(null, props);\n unsetCurrentInstance();\n }\n } else {\n value = defaultValue;\n }\n }\n if (opt[0]) {\n if (isAbsent && !hasDefault) {\n value = false;\n } else if (opt[1] && (value === \"\" || value === hyphenate$1(key))) {\n value = true;\n }\n }\n }\n return value;\n}\nfunction normalizePropsOptions(comp, appContext, asMixin = false) {\n const cache = appContext.propsCache;\n const cached = cache.get(comp);\n if (cached) {\n return cached;\n }\n const raw = comp.props;\n const normalized = {};\n const needCastKeys = [];\n let hasExtends = false;\n if (!isFunction$1(comp)) {\n const extendProps = (raw2) => {\n hasExtends = true;\n const [props, keys] = normalizePropsOptions(raw2, appContext, true);\n extend$1(normalized, props);\n if (keys)\n needCastKeys.push(...keys);\n };\n if (!asMixin && appContext.mixins.length) {\n appContext.mixins.forEach(extendProps);\n }\n if (comp.extends) {\n extendProps(comp.extends);\n }\n if (comp.mixins) {\n comp.mixins.forEach(extendProps);\n }\n }\n if (!raw && !hasExtends) {\n cache.set(comp, EMPTY_ARR);\n return EMPTY_ARR;\n }\n if (isArray$1(raw)) {\n for (let i = 0; i < raw.length; i++) {\n const normalizedKey = camelize$1(raw[i]);\n if (validatePropName(normalizedKey)) {\n normalized[normalizedKey] = EMPTY_OBJ;\n }\n }\n } else if (raw) {\n for (const key in raw) {\n const normalizedKey = camelize$1(key);\n if (validatePropName(normalizedKey)) {\n const opt = raw[key];\n const prop = normalized[normalizedKey] = isArray$1(opt) || isFunction$1(opt) ? { type: opt } : opt;\n if (prop) {\n const booleanIndex = getTypeIndex(Boolean, prop.type);\n const stringIndex = getTypeIndex(String, prop.type);\n prop[0] = booleanIndex > -1;\n prop[1] = stringIndex < 0 || booleanIndex < stringIndex;\n if (booleanIndex > -1 || hasOwn(prop, \"default\")) {\n needCastKeys.push(normalizedKey);\n }\n }\n }\n }\n }\n const res = [normalized, needCastKeys];\n cache.set(comp, res);\n return res;\n}\nfunction validatePropName(key) {\n if (key[0] !== \"$\") {\n return true;\n }\n return false;\n}\nfunction getType(ctor) {\n const match = ctor && ctor.toString().match(/^\\s*function (\\w+)/);\n return match ? match[1] : ctor === null ? \"null\" : \"\";\n}\nfunction isSameType(a, b) {\n return getType(a) === getType(b);\n}\nfunction getTypeIndex(type, expectedTypes) {\n if (isArray$1(expectedTypes)) {\n return expectedTypes.findIndex((t) => isSameType(t, type));\n } else if (isFunction$1(expectedTypes)) {\n return isSameType(expectedTypes, type) ? 0 : -1;\n }\n return -1;\n}\nconst isInternalKey = (key) => key[0] === \"_\" || key === \"$stable\";\nconst normalizeSlotValue = (value) => isArray$1(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];\nconst normalizeSlot = (key, rawSlot, ctx) => {\n if (rawSlot._n) {\n return rawSlot;\n }\n const normalized = withCtx((...args) => {\n return normalizeSlotValue(rawSlot(...args));\n }, ctx);\n normalized._c = false;\n return normalized;\n};\nconst normalizeObjectSlots = (rawSlots, slots, instance2) => {\n const ctx = rawSlots._ctx;\n for (const key in rawSlots) {\n if (isInternalKey(key))\n continue;\n const value = rawSlots[key];\n if (isFunction$1(value)) {\n slots[key] = normalizeSlot(key, value, ctx);\n } else if (value != null) {\n const normalized = normalizeSlotValue(value);\n slots[key] = () => normalized;\n }\n }\n};\nconst normalizeVNodeSlots = (instance2, children) => {\n const normalized = normalizeSlotValue(children);\n instance2.slots.default = () => normalized;\n};\nconst initSlots = (instance2, children) => {\n if (instance2.vnode.shapeFlag & 32) {\n const type = children._;\n if (type) {\n instance2.slots = toRaw(children);\n def(children, \"_\", type);\n } else {\n normalizeObjectSlots(children, instance2.slots = {});\n }\n } else {\n instance2.slots = {};\n if (children) {\n normalizeVNodeSlots(instance2, children);\n }\n }\n def(instance2.slots, InternalObjectKey, 1);\n};\nconst updateSlots = (instance2, children, optimized) => {\n const { vnode, slots } = instance2;\n let needDeletionCheck = true;\n let deletionComparisonTarget = EMPTY_OBJ;\n if (vnode.shapeFlag & 32) {\n const type = children._;\n if (type) {\n if (optimized && type === 1) {\n needDeletionCheck = false;\n } else {\n extend$1(slots, children);\n if (!optimized && type === 1) {\n delete slots._;\n }\n }\n } else {\n needDeletionCheck = !children.$stable;\n normalizeObjectSlots(children, slots);\n }\n deletionComparisonTarget = children;\n } else if (children) {\n normalizeVNodeSlots(instance2, children);\n deletionComparisonTarget = { default: 1 };\n }\n if (needDeletionCheck) {\n for (const key in slots) {\n if (!isInternalKey(key) && !(key in deletionComparisonTarget)) {\n delete slots[key];\n }\n }\n }\n};\nfunction createAppContext() {\n return {\n app: null,\n config: {\n isNativeTag: NO,\n performance: false,\n globalProperties: {},\n optionMergeStrategies: {},\n errorHandler: void 0,\n warnHandler: void 0,\n compilerOptions: {}\n },\n mixins: [],\n components: {},\n directives: {},\n provides: /* @__PURE__ */ Object.create(null),\n optionsCache: /* @__PURE__ */ new WeakMap(),\n propsCache: /* @__PURE__ */ new WeakMap(),\n emitsCache: /* @__PURE__ */ new WeakMap()\n };\n}\nlet uid = 0;\nfunction createAppAPI(render2, hydrate) {\n return function createApp(rootComponent, rootProps = null) {\n if (!isFunction$1(rootComponent)) {\n rootComponent = Object.assign({}, rootComponent);\n }\n if (rootProps != null && !isObject$1(rootProps)) {\n rootProps = null;\n }\n const context = createAppContext();\n const installedPlugins = /* @__PURE__ */ new Set();\n let isMounted = false;\n const app = context.app = {\n _uid: uid++,\n _component: rootComponent,\n _props: rootProps,\n _container: null,\n _context: context,\n _instance: null,\n version,\n get config() {\n return context.config;\n },\n set config(v) {\n },\n use(plugin, ...options2) {\n if (installedPlugins.has(plugin))\n ;\n else if (plugin && isFunction$1(plugin.install)) {\n installedPlugins.add(plugin);\n plugin.install(app, ...options2);\n } else if (isFunction$1(plugin)) {\n installedPlugins.add(plugin);\n plugin(app, ...options2);\n } else\n ;\n return app;\n },\n mixin(mixin) {\n {\n if (!context.mixins.includes(mixin)) {\n context.mixins.push(mixin);\n }\n }\n return app;\n },\n component(name, component) {\n if (!component) {\n return context.components[name];\n }\n context.components[name] = component;\n return app;\n },\n directive(name, directive2) {\n if (!directive2) {\n return context.directives[name];\n }\n context.directives[name] = directive2;\n return app;\n },\n mount(rootContainer, isHydrate, isSVG) {\n if (!isMounted) {\n const vnode = createVNode(rootComponent, rootProps);\n vnode.appContext = context;\n if (isHydrate && hydrate) {\n hydrate(vnode, rootContainer);\n } else {\n render2(vnode, rootContainer, isSVG);\n }\n isMounted = true;\n app._container = rootContainer;\n rootContainer.__vue_app__ = app;\n return getExposeProxy(vnode.component) || vnode.component.proxy;\n }\n },\n unmount() {\n if (isMounted) {\n render2(null, app._container);\n delete app._container.__vue_app__;\n }\n },\n provide(key, value) {\n context.provides[key] = value;\n return app;\n }\n };\n return app;\n };\n}\nfunction setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {\n if (isArray$1(rawRef)) {\n rawRef.forEach((r, i) => setRef(r, oldRawRef && (isArray$1(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode, isUnmount));\n return;\n }\n if (isAsyncWrapper(vnode) && !isUnmount) {\n return;\n }\n const refValue = vnode.shapeFlag & 4 ? getExposeProxy(vnode.component) || vnode.component.proxy : vnode.el;\n const value = isUnmount ? null : refValue;\n const { i: owner, r: ref } = rawRef;\n const oldRef = oldRawRef && oldRawRef.r;\n const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;\n const setupState = owner.setupState;\n if (oldRef != null && oldRef !== ref) {\n if (isString$1(oldRef)) {\n refs[oldRef] = null;\n if (hasOwn(setupState, oldRef)) {\n setupState[oldRef] = null;\n }\n } else if (isRef(oldRef)) {\n oldRef.value = null;\n }\n }\n if (isFunction$1(ref)) {\n callWithErrorHandling(ref, owner, 12, [value, refs]);\n } else {\n const _isString = isString$1(ref);\n const _isRef = isRef(ref);\n if (_isString || _isRef) {\n const doSet = () => {\n if (rawRef.f) {\n const existing = _isString ? refs[ref] : ref.value;\n if (isUnmount) {\n isArray$1(existing) && remove(existing, refValue);\n } else {\n if (!isArray$1(existing)) {\n if (_isString) {\n refs[ref] = [refValue];\n if (hasOwn(setupState, ref)) {\n setupState[ref] = refs[ref];\n }\n } else {\n ref.value = [refValue];\n if (rawRef.k)\n refs[rawRef.k] = ref.value;\n }\n } else if (!existing.includes(refValue)) {\n existing.push(refValue);\n }\n }\n } else if (_isString) {\n refs[ref] = value;\n if (hasOwn(setupState, ref)) {\n setupState[ref] = value;\n }\n } else if (_isRef) {\n ref.value = value;\n if (rawRef.k)\n refs[rawRef.k] = value;\n } else\n ;\n };\n if (value) {\n doSet.id = -1;\n queuePostRenderEffect(doSet, parentSuspense);\n } else {\n doSet();\n }\n }\n }\n}\nconst queuePostRenderEffect = queueEffectWithSuspense;\nfunction createRenderer(options2) {\n return baseCreateRenderer(options2);\n}\nfunction baseCreateRenderer(options2, createHydrationFns) {\n const target = getGlobalThis();\n target.__VUE__ = true;\n const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = NOOP, cloneNode: hostCloneNode, insertStaticContent: hostInsertStaticContent } = options2;\n const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, slotScopeIds = null, optimized = !!n2.dynamicChildren) => {\n if (n1 === n2) {\n return;\n }\n if (n1 && !isSameVNodeType(n1, n2)) {\n anchor = getNextHostNode(n1);\n unmount(n1, parentComponent, parentSuspense, true);\n n1 = null;\n }\n if (n2.patchFlag === -2) {\n optimized = false;\n n2.dynamicChildren = null;\n }\n const { type, ref, shapeFlag } = n2;\n switch (type) {\n case Text:\n processText(n1, n2, container, anchor);\n break;\n case Comment:\n processCommentNode(n1, n2, container, anchor);\n break;\n case Static:\n if (n1 == null) {\n mountStaticNode(n2, container, anchor, isSVG);\n }\n break;\n case Fragment:\n processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n break;\n default:\n if (shapeFlag & 1) {\n processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n } else if (shapeFlag & 6) {\n processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n } else if (shapeFlag & 64) {\n type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals);\n } else if (shapeFlag & 128) {\n type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals);\n } else\n ;\n }\n if (ref != null && parentComponent) {\n setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2);\n }\n };\n const processText = (n1, n2, container, anchor) => {\n if (n1 == null) {\n hostInsert(n2.el = hostCreateText(n2.children), container, anchor);\n } else {\n const el = n2.el = n1.el;\n if (n2.children !== n1.children) {\n hostSetText(el, n2.children);\n }\n }\n };\n const processCommentNode = (n1, n2, container, anchor) => {\n if (n1 == null) {\n hostInsert(n2.el = hostCreateComment(n2.children || \"\"), container, anchor);\n } else {\n n2.el = n1.el;\n }\n };\n const mountStaticNode = (n2, container, anchor, isSVG) => {\n [n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG, n2.el, n2.anchor);\n };\n const moveStaticNode = ({ el, anchor }, container, nextSibling) => {\n let next2;\n while (el && el !== anchor) {\n next2 = hostNextSibling(el);\n hostInsert(el, container, nextSibling);\n el = next2;\n }\n hostInsert(anchor, container, nextSibling);\n };\n const removeStaticNode = ({ el, anchor }) => {\n let next2;\n while (el && el !== anchor) {\n next2 = hostNextSibling(el);\n hostRemove(el);\n el = next2;\n }\n hostRemove(anchor);\n };\n const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {\n isSVG = isSVG || n2.type === \"svg\";\n if (n1 == null) {\n mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n } else {\n patchElement(n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n }\n };\n const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {\n let el;\n let vnodeHook;\n const { type, props, shapeFlag, transition, patchFlag, dirs } = vnode;\n if (vnode.el && hostCloneNode !== void 0 && patchFlag === -1) {\n el = vnode.el = hostCloneNode(vnode.el);\n } else {\n el = vnode.el = hostCreateElement(vnode.type, isSVG, props && props.is, props);\n if (shapeFlag & 8) {\n hostSetElementText(el, vnode.children);\n } else if (shapeFlag & 16) {\n mountChildren(vnode.children, el, null, parentComponent, parentSuspense, isSVG && type !== \"foreignObject\", slotScopeIds, optimized);\n }\n if (dirs) {\n invokeDirectiveHook(vnode, null, parentComponent, \"created\");\n }\n if (props) {\n for (const key in props) {\n if (key !== \"value\" && !isReservedProp(key)) {\n hostPatchProp(el, key, null, props[key], isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);\n }\n }\n if (\"value\" in props) {\n hostPatchProp(el, \"value\", null, props.value);\n }\n if (vnodeHook = props.onVnodeBeforeMount) {\n invokeVNodeHook(vnodeHook, parentComponent, vnode);\n }\n }\n setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);\n }\n if (dirs) {\n invokeDirectiveHook(vnode, null, parentComponent, \"beforeMount\");\n }\n const needCallTransitionHooks = (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;\n if (needCallTransitionHooks) {\n transition.beforeEnter(el);\n }\n hostInsert(el, container, anchor);\n if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {\n queuePostRenderEffect(() => {\n vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);\n needCallTransitionHooks && transition.enter(el);\n dirs && invokeDirectiveHook(vnode, null, parentComponent, \"mounted\");\n }, parentSuspense);\n }\n };\n const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {\n if (scopeId) {\n hostSetScopeId(el, scopeId);\n }\n if (slotScopeIds) {\n for (let i = 0; i < slotScopeIds.length; i++) {\n hostSetScopeId(el, slotScopeIds[i]);\n }\n }\n if (parentComponent) {\n let subTree = parentComponent.subTree;\n if (vnode === subTree) {\n const parentVNode = parentComponent.vnode;\n setScopeId(el, parentVNode, parentVNode.scopeId, parentVNode.slotScopeIds, parentComponent.parent);\n }\n }\n };\n const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, start2 = 0) => {\n for (let i = start2; i < children.length; i++) {\n const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);\n patch(null, child, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n }\n };\n const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {\n const el = n2.el = n1.el;\n let { patchFlag, dynamicChildren, dirs } = n2;\n patchFlag |= n1.patchFlag & 16;\n const oldProps = n1.props || EMPTY_OBJ;\n const newProps = n2.props || EMPTY_OBJ;\n let vnodeHook;\n parentComponent && toggleRecurse(parentComponent, false);\n if (vnodeHook = newProps.onVnodeBeforeUpdate) {\n invokeVNodeHook(vnodeHook, parentComponent, n2, n1);\n }\n if (dirs) {\n invokeDirectiveHook(n2, n1, parentComponent, \"beforeUpdate\");\n }\n parentComponent && toggleRecurse(parentComponent, true);\n const areChildrenSVG = isSVG && n2.type !== \"foreignObject\";\n if (dynamicChildren) {\n patchBlockChildren(n1.dynamicChildren, dynamicChildren, el, parentComponent, parentSuspense, areChildrenSVG, slotScopeIds);\n } else if (!optimized) {\n patchChildren(n1, n2, el, null, parentComponent, parentSuspense, areChildrenSVG, slotScopeIds, false);\n }\n if (patchFlag > 0) {\n if (patchFlag & 16) {\n patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);\n } else {\n if (patchFlag & 2) {\n if (oldProps.class !== newProps.class) {\n hostPatchProp(el, \"class\", null, newProps.class, isSVG);\n }\n }\n if (patchFlag & 4) {\n hostPatchProp(el, \"style\", oldProps.style, newProps.style, isSVG);\n }\n if (patchFlag & 8) {\n const propsToUpdate = n2.dynamicProps;\n for (let i = 0; i < propsToUpdate.length; i++) {\n const key = propsToUpdate[i];\n const prev = oldProps[key];\n const next2 = newProps[key];\n if (next2 !== prev || key === \"value\") {\n hostPatchProp(el, key, prev, next2, isSVG, n1.children, parentComponent, parentSuspense, unmountChildren);\n }\n }\n }\n }\n if (patchFlag & 1) {\n if (n1.children !== n2.children) {\n hostSetElementText(el, n2.children);\n }\n }\n } else if (!optimized && dynamicChildren == null) {\n patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);\n }\n if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {\n queuePostRenderEffect(() => {\n vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);\n dirs && invokeDirectiveHook(n2, n1, parentComponent, \"updated\");\n }, parentSuspense);\n }\n };\n const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG, slotScopeIds) => {\n for (let i = 0; i < newChildren.length; i++) {\n const oldVNode = oldChildren[i];\n const newVNode = newChildren[i];\n const container = oldVNode.el && (oldVNode.type === Fragment || !isSameVNodeType(oldVNode, newVNode) || oldVNode.shapeFlag & (6 | 64)) ? hostParentNode(oldVNode.el) : fallbackContainer;\n patch(oldVNode, newVNode, container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, true);\n }\n };\n const patchProps = (el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) => {\n if (oldProps !== newProps) {\n for (const key in newProps) {\n if (isReservedProp(key))\n continue;\n const next2 = newProps[key];\n const prev = oldProps[key];\n if (next2 !== prev && key !== \"value\") {\n hostPatchProp(el, key, prev, next2, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);\n }\n }\n if (oldProps !== EMPTY_OBJ) {\n for (const key in oldProps) {\n if (!isReservedProp(key) && !(key in newProps)) {\n hostPatchProp(el, key, oldProps[key], null, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);\n }\n }\n }\n if (\"value\" in newProps) {\n hostPatchProp(el, \"value\", oldProps.value, newProps.value);\n }\n }\n };\n const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {\n const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText(\"\");\n const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText(\"\");\n let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;\n if (fragmentSlotScopeIds) {\n slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;\n }\n if (n1 == null) {\n hostInsert(fragmentStartAnchor, container, anchor);\n hostInsert(fragmentEndAnchor, container, anchor);\n mountChildren(n2.children, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n } else {\n if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && n1.dynamicChildren) {\n patchBlockChildren(n1.dynamicChildren, dynamicChildren, container, parentComponent, parentSuspense, isSVG, slotScopeIds);\n if (n2.key != null || parentComponent && n2 === parentComponent.subTree) {\n traverseStaticChildren(n1, n2, true);\n }\n } else {\n patchChildren(n1, n2, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n }\n }\n };\n const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {\n n2.slotScopeIds = slotScopeIds;\n if (n1 == null) {\n if (n2.shapeFlag & 512) {\n parentComponent.ctx.activate(n2, container, anchor, isSVG, optimized);\n } else {\n mountComponent(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\n }\n } else {\n updateComponent(n1, n2, optimized);\n }\n };\n const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {\n const instance2 = initialVNode.component = createComponentInstance(initialVNode, parentComponent, parentSuspense);\n if (isKeepAlive(initialVNode)) {\n instance2.ctx.renderer = internals;\n }\n {\n setupComponent(instance2);\n }\n if (instance2.asyncDep) {\n parentSuspense && parentSuspense.registerDep(instance2, setupRenderEffect);\n if (!initialVNode.el) {\n const placeholder = instance2.subTree = createVNode(Comment);\n processCommentNode(null, placeholder, container, anchor);\n }\n return;\n }\n setupRenderEffect(instance2, initialVNode, container, anchor, parentSuspense, isSVG, optimized);\n };\n const updateComponent = (n1, n2, optimized) => {\n const instance2 = n2.component = n1.component;\n if (shouldUpdateComponent(n1, n2, optimized)) {\n if (instance2.asyncDep && !instance2.asyncResolved) {\n updateComponentPreRender(instance2, n2, optimized);\n return;\n } else {\n instance2.next = n2;\n invalidateJob(instance2.update);\n instance2.update();\n }\n } else {\n n2.el = n1.el;\n instance2.vnode = n2;\n }\n };\n const setupRenderEffect = (instance2, initialVNode, container, anchor, parentSuspense, isSVG, optimized) => {\n const componentUpdateFn = () => {\n if (!instance2.isMounted) {\n let vnodeHook;\n const { el, props } = initialVNode;\n const { bm, m, parent } = instance2;\n const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);\n toggleRecurse(instance2, false);\n if (bm) {\n invokeArrayFns(bm);\n }\n if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) {\n invokeVNodeHook(vnodeHook, parent, initialVNode);\n }\n toggleRecurse(instance2, true);\n if (el && hydrateNode) {\n const hydrateSubTree = () => {\n instance2.subTree = renderComponentRoot(instance2);\n hydrateNode(el, instance2.subTree, instance2, parentSuspense, null);\n };\n if (isAsyncWrapperVNode) {\n initialVNode.type.__asyncLoader().then(\n () => !instance2.isUnmounted && hydrateSubTree()\n );\n } else {\n hydrateSubTree();\n }\n } else {\n const subTree = instance2.subTree = renderComponentRoot(instance2);\n patch(null, subTree, container, anchor, instance2, parentSuspense, isSVG);\n initialVNode.el = subTree.el;\n }\n if (m) {\n queuePostRenderEffect(m, parentSuspense);\n }\n if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {\n const scopedInitialVNode = initialVNode;\n queuePostRenderEffect(() => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode), parentSuspense);\n }\n if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {\n instance2.a && queuePostRenderEffect(instance2.a, parentSuspense);\n }\n instance2.isMounted = true;\n initialVNode = container = anchor = null;\n } else {\n let { next: next2, bu, u, parent, vnode } = instance2;\n let originNext = next2;\n let vnodeHook;\n toggleRecurse(instance2, false);\n if (next2) {\n next2.el = vnode.el;\n updateComponentPreRender(instance2, next2, optimized);\n } else {\n next2 = vnode;\n }\n if (bu) {\n invokeArrayFns(bu);\n }\n if (vnodeHook = next2.props && next2.props.onVnodeBeforeUpdate) {\n invokeVNodeHook(vnodeHook, parent, next2, vnode);\n }\n toggleRecurse(instance2, true);\n const nextTree = renderComponentRoot(instance2);\n const prevTree = instance2.subTree;\n instance2.subTree = nextTree;\n patch(\n prevTree,\n nextTree,\n hostParentNode(prevTree.el),\n getNextHostNode(prevTree),\n instance2,\n parentSuspense,\n isSVG\n );\n next2.el = nextTree.el;\n if (originNext === null) {\n updateHOCHostEl(instance2, nextTree.el);\n }\n if (u) {\n queuePostRenderEffect(u, parentSuspense);\n }\n if (vnodeHook = next2.props && next2.props.onVnodeUpdated) {\n queuePostRenderEffect(() => invokeVNodeHook(vnodeHook, parent, next2, vnode), parentSuspense);\n }\n }\n };\n const effect = instance2.effect = new ReactiveEffect(\n componentUpdateFn,\n () => queueJob(update2),\n instance2.scope\n );\n const update2 = instance2.update = () => effect.run();\n update2.id = instance2.uid;\n toggleRecurse(instance2, true);\n update2();\n };\n const updateComponentPreRender = (instance2, nextVNode, optimized) => {\n nextVNode.component = instance2;\n const prevProps = instance2.vnode.props;\n instance2.vnode = nextVNode;\n instance2.next = null;\n updateProps(instance2, nextVNode.props, prevProps, optimized);\n updateSlots(instance2, nextVNode.children, optimized);\n pauseTracking();\n flushPreFlushCbs(void 0, instance2.update);\n resetTracking();\n };\n const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized = false) => {\n const c1 = n1 && n1.children;\n const prevShapeFlag = n1 ? n1.shapeFlag : 0;\n const c2 = n2.children;\n const { patchFlag, shapeFlag } = n2;\n if (patchFlag > 0) {\n if (patchFlag & 128) {\n patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n return;\n } else if (patchFlag & 256) {\n patchUnkeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n return;\n }\n }\n if (shapeFlag & 8) {\n if (prevShapeFlag & 16) {\n unmountChildren(c1, parentComponent, parentSuspense);\n }\n if (c2 !== c1) {\n hostSetElementText(container, c2);\n }\n } else {\n if (prevShapeFlag & 16) {\n if (shapeFlag & 16) {\n patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n } else {\n unmountChildren(c1, parentComponent, parentSuspense, true);\n }\n } else {\n if (prevShapeFlag & 8) {\n hostSetElementText(container, \"\");\n }\n if (shapeFlag & 16) {\n mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n }\n }\n }\n };\n const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {\n c1 = c1 || EMPTY_ARR;\n c2 = c2 || EMPTY_ARR;\n const oldLength = c1.length;\n const newLength = c2.length;\n const commonLength = Math.min(oldLength, newLength);\n let i;\n for (i = 0; i < commonLength; i++) {\n const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);\n patch(c1[i], nextChild, container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n }\n if (oldLength > newLength) {\n unmountChildren(c1, parentComponent, parentSuspense, true, false, commonLength);\n } else {\n mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, commonLength);\n }\n };\n const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {\n let i = 0;\n const l2 = c2.length;\n let e1 = c1.length - 1;\n let e2 = l2 - 1;\n while (i <= e1 && i <= e2) {\n const n1 = c1[i];\n const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);\n if (isSameVNodeType(n1, n2)) {\n patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n } else {\n break;\n }\n i++;\n }\n while (i <= e1 && i <= e2) {\n const n1 = c1[e1];\n const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);\n if (isSameVNodeType(n1, n2)) {\n patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n } else {\n break;\n }\n e1--;\n e2--;\n }\n if (i > e1) {\n if (i <= e2) {\n const nextPos = e2 + 1;\n const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;\n while (i <= e2) {\n patch(null, c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]), container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n i++;\n }\n }\n } else if (i > e2) {\n while (i <= e1) {\n unmount(c1[i], parentComponent, parentSuspense, true);\n i++;\n }\n } else {\n const s1 = i;\n const s2 = i;\n const keyToNewIndexMap = /* @__PURE__ */ new Map();\n for (i = s2; i <= e2; i++) {\n const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);\n if (nextChild.key != null) {\n keyToNewIndexMap.set(nextChild.key, i);\n }\n }\n let j;\n let patched = 0;\n const toBePatched = e2 - s2 + 1;\n let moved = false;\n let maxNewIndexSoFar = 0;\n const newIndexToOldIndexMap = new Array(toBePatched);\n for (i = 0; i < toBePatched; i++)\n newIndexToOldIndexMap[i] = 0;\n for (i = s1; i <= e1; i++) {\n const prevChild = c1[i];\n if (patched >= toBePatched) {\n unmount(prevChild, parentComponent, parentSuspense, true);\n continue;\n }\n let newIndex;\n if (prevChild.key != null) {\n newIndex = keyToNewIndexMap.get(prevChild.key);\n } else {\n for (j = s2; j <= e2; j++) {\n if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {\n newIndex = j;\n break;\n }\n }\n }\n if (newIndex === void 0) {\n unmount(prevChild, parentComponent, parentSuspense, true);\n } else {\n newIndexToOldIndexMap[newIndex - s2] = i + 1;\n if (newIndex >= maxNewIndexSoFar) {\n maxNewIndexSoFar = newIndex;\n } else {\n moved = true;\n }\n patch(prevChild, c2[newIndex], container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n patched++;\n }\n }\n const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : EMPTY_ARR;\n j = increasingNewIndexSequence.length - 1;\n for (i = toBePatched - 1; i >= 0; i--) {\n const nextIndex = s2 + i;\n const nextChild = c2[nextIndex];\n const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;\n if (newIndexToOldIndexMap[i] === 0) {\n patch(null, nextChild, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);\n } else if (moved) {\n if (j < 0 || i !== increasingNewIndexSequence[j]) {\n move(nextChild, container, anchor, 2);\n } else {\n j--;\n }\n }\n }\n }\n };\n const move = (vnode, container, anchor, moveType, parentSuspense = null) => {\n const { el, type, transition, children, shapeFlag } = vnode;\n if (shapeFlag & 6) {\n move(vnode.component.subTree, container, anchor, moveType);\n return;\n }\n if (shapeFlag & 128) {\n vnode.suspense.move(container, anchor, moveType);\n return;\n }\n if (shapeFlag & 64) {\n type.move(vnode, container, anchor, internals);\n return;\n }\n if (type === Fragment) {\n hostInsert(el, container, anchor);\n for (let i = 0; i < children.length; i++) {\n move(children[i], container, anchor, moveType);\n }\n hostInsert(vnode.anchor, container, anchor);\n return;\n }\n if (type === Static) {\n moveStaticNode(vnode, container, anchor);\n return;\n }\n const needTransition = moveType !== 2 && shapeFlag & 1 && transition;\n if (needTransition) {\n if (moveType === 0) {\n transition.beforeEnter(el);\n hostInsert(el, container, anchor);\n queuePostRenderEffect(() => transition.enter(el), parentSuspense);\n } else {\n const { leave, delayLeave, afterLeave } = transition;\n const remove3 = () => hostInsert(el, container, anchor);\n const performLeave = () => {\n leave(el, () => {\n remove3();\n afterLeave && afterLeave();\n });\n };\n if (delayLeave) {\n delayLeave(el, remove3, performLeave);\n } else {\n performLeave();\n }\n }\n } else {\n hostInsert(el, container, anchor);\n }\n };\n const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {\n const { type, props, ref, children, dynamicChildren, shapeFlag, patchFlag, dirs } = vnode;\n if (ref != null) {\n setRef(ref, null, parentSuspense, vnode, true);\n }\n if (shapeFlag & 256) {\n parentComponent.ctx.deactivate(vnode);\n return;\n }\n const shouldInvokeDirs = shapeFlag & 1 && dirs;\n const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);\n let vnodeHook;\n if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) {\n invokeVNodeHook(vnodeHook, parentComponent, vnode);\n }\n if (shapeFlag & 6) {\n unmountComponent(vnode.component, parentSuspense, doRemove);\n } else {\n if (shapeFlag & 128) {\n vnode.suspense.unmount(parentSuspense, doRemove);\n return;\n }\n if (shouldInvokeDirs) {\n invokeDirectiveHook(vnode, null, parentComponent, \"beforeUnmount\");\n }\n if (shapeFlag & 64) {\n vnode.type.remove(vnode, parentComponent, parentSuspense, optimized, internals, doRemove);\n } else if (dynamicChildren && (type !== Fragment || patchFlag > 0 && patchFlag & 64)) {\n unmountChildren(dynamicChildren, parentComponent, parentSuspense, false, true);\n } else if (type === Fragment && patchFlag & (128 | 256) || !optimized && shapeFlag & 16) {\n unmountChildren(children, parentComponent, parentSuspense);\n }\n if (doRemove) {\n remove2(vnode);\n }\n }\n if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {\n queuePostRenderEffect(() => {\n vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);\n shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, \"unmounted\");\n }, parentSuspense);\n }\n };\n const remove2 = (vnode) => {\n const { type, el, anchor, transition } = vnode;\n if (type === Fragment) {\n {\n removeFragment(el, anchor);\n }\n return;\n }\n if (type === Static) {\n removeStaticNode(vnode);\n return;\n }\n const performRemove = () => {\n hostRemove(el);\n if (transition && !transition.persisted && transition.afterLeave) {\n transition.afterLeave();\n }\n };\n if (vnode.shapeFlag & 1 && transition && !transition.persisted) {\n const { leave, delayLeave } = transition;\n const performLeave = () => leave(el, performRemove);\n if (delayLeave) {\n delayLeave(vnode.el, performRemove, performLeave);\n } else {\n performLeave();\n }\n } else {\n performRemove();\n }\n };\n const removeFragment = (cur, end) => {\n let next2;\n while (cur !== end) {\n next2 = hostNextSibling(cur);\n hostRemove(cur);\n cur = next2;\n }\n hostRemove(end);\n };\n const unmountComponent = (instance2, parentSuspense, doRemove) => {\n const { bum, scope, update: update2, subTree, um } = instance2;\n if (bum) {\n invokeArrayFns(bum);\n }\n scope.stop();\n if (update2) {\n update2.active = false;\n unmount(subTree, instance2, parentSuspense, doRemove);\n }\n if (um) {\n queuePostRenderEffect(um, parentSuspense);\n }\n queuePostRenderEffect(() => {\n instance2.isUnmounted = true;\n }, parentSuspense);\n if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance2.asyncDep && !instance2.asyncResolved && instance2.suspenseId === parentSuspense.pendingId) {\n parentSuspense.deps--;\n if (parentSuspense.deps === 0) {\n parentSuspense.resolve();\n }\n }\n };\n const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start2 = 0) => {\n for (let i = start2; i < children.length; i++) {\n unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);\n }\n };\n const getNextHostNode = (vnode) => {\n if (vnode.shapeFlag & 6) {\n return getNextHostNode(vnode.component.subTree);\n }\n if (vnode.shapeFlag & 128) {\n return vnode.suspense.next();\n }\n return hostNextSibling(vnode.anchor || vnode.el);\n };\n const render2 = (vnode, container, isSVG) => {\n if (vnode == null) {\n if (container._vnode) {\n unmount(container._vnode, null, null, true);\n }\n } else {\n patch(container._vnode || null, vnode, container, null, null, null, isSVG);\n }\n flushPostFlushCbs();\n container._vnode = vnode;\n };\n const internals = {\n p: patch,\n um: unmount,\n m: move,\n r: remove2,\n mt: mountComponent,\n mc: mountChildren,\n pc: patchChildren,\n pbc: patchBlockChildren,\n n: getNextHostNode,\n o: options2\n };\n let hydrate;\n let hydrateNode;\n if (createHydrationFns) {\n [hydrate, hydrateNode] = createHydrationFns(internals);\n }\n return {\n render: render2,\n hydrate,\n createApp: createAppAPI(render2, hydrate)\n };\n}\nfunction toggleRecurse({ effect, update: update2 }, allowed) {\n effect.allowRecurse = update2.allowRecurse = allowed;\n}\nfunction traverseStaticChildren(n1, n2, shallow = false) {\n const ch1 = n1.children;\n const ch2 = n2.children;\n if (isArray$1(ch1) && isArray$1(ch2)) {\n for (let i = 0; i < ch1.length; i++) {\n const c1 = ch1[i];\n let c2 = ch2[i];\n if (c2.shapeFlag & 1 && !c2.dynamicChildren) {\n if (c2.patchFlag <= 0 || c2.patchFlag === 32) {\n c2 = ch2[i] = cloneIfMounted(ch2[i]);\n c2.el = c1.el;\n }\n if (!shallow)\n traverseStaticChildren(c1, c2);\n }\n }\n }\n}\nfunction getSequence(arr) {\n const p2 = arr.slice();\n const result = [0];\n let i, j, u, v, c;\n const len = arr.length;\n for (i = 0; i < len; i++) {\n const arrI = arr[i];\n if (arrI !== 0) {\n j = result[result.length - 1];\n if (arr[j] < arrI) {\n p2[i] = j;\n result.push(i);\n continue;\n }\n u = 0;\n v = result.length - 1;\n while (u < v) {\n c = u + v >> 1;\n if (arr[result[c]] < arrI) {\n u = c + 1;\n } else {\n v = c;\n }\n }\n if (arrI < arr[result[u]]) {\n if (u > 0) {\n p2[i] = result[u - 1];\n }\n result[u] = i;\n }\n }\n }\n u = result.length;\n v = result[u - 1];\n while (u-- > 0) {\n result[u] = v;\n v = p2[v];\n }\n return result;\n}\nconst isTeleport = (type) => type.__isTeleport;\nconst Fragment = Symbol(void 0);\nconst Text = Symbol(void 0);\nconst Comment = Symbol(void 0);\nconst Static = Symbol(void 0);\nconst blockStack = [];\nlet currentBlock = null;\nfunction openBlock(disableTracking = false) {\n blockStack.push(currentBlock = disableTracking ? null : []);\n}\nfunction closeBlock() {\n blockStack.pop();\n currentBlock = blockStack[blockStack.length - 1] || null;\n}\nlet isBlockTreeEnabled = 1;\nfunction setBlockTracking(value) {\n isBlockTreeEnabled += value;\n}\nfunction setupBlock(vnode) {\n vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || EMPTY_ARR : null;\n closeBlock();\n if (isBlockTreeEnabled > 0 && currentBlock) {\n currentBlock.push(vnode);\n }\n return vnode;\n}\nfunction createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {\n return setupBlock(createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, true));\n}\nfunction createBlock(type, props, children, patchFlag, dynamicProps) {\n return setupBlock(createVNode(type, props, children, patchFlag, dynamicProps, true));\n}\nfunction isVNode(value) {\n return value ? value.__v_isVNode === true : false;\n}\nfunction isSameVNodeType(n1, n2) {\n return n1.type === n2.type && n1.key === n2.key;\n}\nconst InternalObjectKey = `__vInternal`;\nconst normalizeKey = ({ key }) => key != null ? key : null;\nconst normalizeRef = ({ ref, ref_key, ref_for }) => {\n return ref != null ? isString$1(ref) || isRef(ref) || isFunction$1(ref) ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } : ref : null;\n};\nfunction createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {\n const vnode = {\n __v_isVNode: true,\n __v_skip: true,\n type,\n props,\n key: props && normalizeKey(props),\n ref: props && normalizeRef(props),\n scopeId: currentScopeId,\n slotScopeIds: null,\n children,\n component: null,\n suspense: null,\n ssContent: null,\n ssFallback: null,\n dirs: null,\n transition: null,\n el: null,\n anchor: null,\n target: null,\n targetAnchor: null,\n staticCount: 0,\n shapeFlag,\n patchFlag,\n dynamicProps,\n dynamicChildren: null,\n appContext: null\n };\n if (needFullChildrenNormalization) {\n normalizeChildren(vnode, children);\n if (shapeFlag & 128) {\n type.normalize(vnode);\n }\n } else if (children) {\n vnode.shapeFlag |= isString$1(children) ? 8 : 16;\n }\n if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock && (vnode.patchFlag > 0 || shapeFlag & 6) && vnode.patchFlag !== 32) {\n currentBlock.push(vnode);\n }\n return vnode;\n}\nconst createVNode = _createVNode;\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\n if (!type || type === NULL_DYNAMIC_COMPONENT) {\n type = Comment;\n }\n if (isVNode(type)) {\n const cloned = cloneVNode(type, props, true);\n if (children) {\n normalizeChildren(cloned, children);\n }\n if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {\n if (cloned.shapeFlag & 6) {\n currentBlock[currentBlock.indexOf(type)] = cloned;\n } else {\n currentBlock.push(cloned);\n }\n }\n cloned.patchFlag |= -2;\n return cloned;\n }\n if (isClassComponent(type)) {\n type = type.__vccOpts;\n }\n if (props) {\n props = guardReactiveProps(props);\n let { class: klass, style } = props;\n if (klass && !isString$1(klass)) {\n props.class = normalizeClass(klass);\n }\n if (isObject$1(style)) {\n if (isProxy(style) && !isArray$1(style)) {\n style = extend$1({}, style);\n }\n props.style = normalizeStyle(style);\n }\n }\n const shapeFlag = isString$1(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject$1(type) ? 4 : isFunction$1(type) ? 2 : 0;\n return createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, isBlockNode, true);\n}\nfunction guardReactiveProps(props) {\n if (!props)\n return null;\n return isProxy(props) || InternalObjectKey in props ? extend$1({}, props) : props;\n}\nfunction cloneVNode(vnode, extraProps, mergeRef = false) {\n const { props, ref, patchFlag, children } = vnode;\n const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;\n const cloned = {\n __v_isVNode: true,\n __v_skip: true,\n type: vnode.type,\n props: mergedProps,\n key: mergedProps && normalizeKey(mergedProps),\n ref: extraProps && extraProps.ref ? mergeRef && ref ? isArray$1(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps) : ref,\n scopeId: vnode.scopeId,\n slotScopeIds: vnode.slotScopeIds,\n children,\n target: vnode.target,\n targetAnchor: vnode.targetAnchor,\n staticCount: vnode.staticCount,\n shapeFlag: vnode.shapeFlag,\n patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,\n dynamicProps: vnode.dynamicProps,\n dynamicChildren: vnode.dynamicChildren,\n appContext: vnode.appContext,\n dirs: vnode.dirs,\n transition: vnode.transition,\n component: vnode.component,\n suspense: vnode.suspense,\n ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),\n ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),\n el: vnode.el,\n anchor: vnode.anchor\n };\n return cloned;\n}\nfunction createTextVNode(text2 = \" \", flag = 0) {\n return createVNode(Text, null, text2, flag);\n}\nfunction createCommentVNode(text2 = \"\", asBlock = false) {\n return asBlock ? (openBlock(), createBlock(Comment, null, text2)) : createVNode(Comment, null, text2);\n}\nfunction normalizeVNode(child) {\n if (child == null || typeof child === \"boolean\") {\n return createVNode(Comment);\n } else if (isArray$1(child)) {\n return createVNode(\n Fragment,\n null,\n child.slice()\n );\n } else if (typeof child === \"object\") {\n return cloneIfMounted(child);\n } else {\n return createVNode(Text, null, String(child));\n }\n}\nfunction cloneIfMounted(child) {\n return child.el === null || child.memo ? child : cloneVNode(child);\n}\nfunction normalizeChildren(vnode, children) {\n let type = 0;\n const { shapeFlag } = vnode;\n if (children == null) {\n children = null;\n } else if (isArray$1(children)) {\n type = 16;\n } else if (typeof children === \"object\") {\n if (shapeFlag & (1 | 64)) {\n const slot = children.default;\n if (slot) {\n slot._c && (slot._d = false);\n normalizeChildren(vnode, slot());\n slot._c && (slot._d = true);\n }\n return;\n } else {\n type = 32;\n const slotFlag = children._;\n if (!slotFlag && !(InternalObjectKey in children)) {\n children._ctx = currentRenderingInstance;\n } else if (slotFlag === 3 && currentRenderingInstance) {\n if (currentRenderingInstance.slots._ === 1) {\n children._ = 1;\n } else {\n children._ = 2;\n vnode.patchFlag |= 1024;\n }\n }\n }\n } else if (isFunction$1(children)) {\n children = { default: children, _ctx: currentRenderingInstance };\n type = 32;\n } else {\n children = String(children);\n if (shapeFlag & 64) {\n type = 16;\n children = [createTextVNode(children)];\n } else {\n type = 8;\n }\n }\n vnode.children = children;\n vnode.shapeFlag |= type;\n}\nfunction mergeProps(...args) {\n const ret = {};\n for (let i = 0; i < args.length; i++) {\n const toMerge = args[i];\n for (const key in toMerge) {\n if (key === \"class\") {\n if (ret.class !== toMerge.class) {\n ret.class = normalizeClass([ret.class, toMerge.class]);\n }\n } else if (key === \"style\") {\n ret.style = normalizeStyle([ret.style, toMerge.style]);\n } else if (isOn$1(key)) {\n const existing = ret[key];\n const incoming = toMerge[key];\n if (incoming && existing !== incoming && !(isArray$1(existing) && existing.includes(incoming))) {\n ret[key] = existing ? [].concat(existing, incoming) : incoming;\n }\n } else if (key !== \"\") {\n ret[key] = toMerge[key];\n }\n }\n }\n return ret;\n}\nfunction invokeVNodeHook(hook, instance2, vnode, prevVNode = null) {\n callWithAsyncErrorHandling(hook, instance2, 7, [\n vnode,\n prevVNode\n ]);\n}\nconst emptyAppContext = createAppContext();\nlet uid$1 = 0;\nfunction createComponentInstance(vnode, parent, suspense) {\n const type = vnode.type;\n const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;\n const instance2 = {\n uid: uid$1++,\n vnode,\n type,\n parent,\n appContext,\n root: null,\n next: null,\n subTree: null,\n effect: null,\n update: null,\n scope: new EffectScope(true),\n render: null,\n proxy: null,\n exposed: null,\n exposeProxy: null,\n withProxy: null,\n provides: parent ? parent.provides : Object.create(appContext.provides),\n accessCache: null,\n renderCache: [],\n components: null,\n directives: null,\n propsOptions: normalizePropsOptions(type, appContext),\n emitsOptions: normalizeEmitsOptions(type, appContext),\n emit: null,\n emitted: null,\n propsDefaults: EMPTY_OBJ,\n inheritAttrs: type.inheritAttrs,\n ctx: EMPTY_OBJ,\n data: EMPTY_OBJ,\n props: EMPTY_OBJ,\n attrs: EMPTY_OBJ,\n slots: EMPTY_OBJ,\n refs: EMPTY_OBJ,\n setupState: EMPTY_OBJ,\n setupContext: null,\n suspense,\n suspenseId: suspense ? suspense.pendingId : 0,\n asyncDep: null,\n asyncResolved: false,\n isMounted: false,\n isUnmounted: false,\n isDeactivated: false,\n bc: null,\n c: null,\n bm: null,\n m: null,\n bu: null,\n u: null,\n um: null,\n bum: null,\n da: null,\n a: null,\n rtg: null,\n rtc: null,\n ec: null,\n sp: null\n };\n {\n instance2.ctx = { _: instance2 };\n }\n instance2.root = parent ? parent.root : instance2;\n instance2.emit = emit$1.bind(null, instance2);\n if (vnode.ce) {\n vnode.ce(instance2);\n }\n return instance2;\n}\nlet currentInstance = null;\nconst getCurrentInstance = () => currentInstance || currentRenderingInstance;\nconst setCurrentInstance = (instance2) => {\n currentInstance = instance2;\n instance2.scope.on();\n};\nconst unsetCurrentInstance = () => {\n currentInstance && currentInstance.scope.off();\n currentInstance = null;\n};\nfunction isStatefulComponent(instance2) {\n return instance2.vnode.shapeFlag & 4;\n}\nlet isInSSRComponentSetup = false;\nfunction setupComponent(instance2, isSSR = false) {\n isInSSRComponentSetup = isSSR;\n const { props, children } = instance2.vnode;\n const isStateful = isStatefulComponent(instance2);\n initProps(instance2, props, isStateful, isSSR);\n initSlots(instance2, children);\n const setupResult = isStateful ? setupStatefulComponent(instance2, isSSR) : void 0;\n isInSSRComponentSetup = false;\n return setupResult;\n}\nfunction setupStatefulComponent(instance2, isSSR) {\n const Component = instance2.type;\n instance2.accessCache = /* @__PURE__ */ Object.create(null);\n instance2.proxy = markRaw(new Proxy(instance2.ctx, PublicInstanceProxyHandlers));\n const { setup } = Component;\n if (setup) {\n const setupContext = instance2.setupContext = setup.length > 1 ? createSetupContext(instance2) : null;\n setCurrentInstance(instance2);\n pauseTracking();\n const setupResult = callWithErrorHandling(setup, instance2, 0, [instance2.props, setupContext]);\n resetTracking();\n unsetCurrentInstance();\n if (isPromise(setupResult)) {\n setupResult.then(unsetCurrentInstance, unsetCurrentInstance);\n if (isSSR) {\n return setupResult.then((resolvedResult) => {\n handleSetupResult(instance2, resolvedResult, isSSR);\n }).catch((e) => {\n handleError(e, instance2, 0);\n });\n } else {\n instance2.asyncDep = setupResult;\n }\n } else {\n handleSetupResult(instance2, setupResult, isSSR);\n }\n } else {\n finishComponentSetup(instance2, isSSR);\n }\n}\nfunction handleSetupResult(instance2, setupResult, isSSR) {\n if (isFunction$1(setupResult)) {\n if (instance2.type.__ssrInlineRender) {\n instance2.ssrRender = setupResult;\n } else {\n instance2.render = setupResult;\n }\n } else if (isObject$1(setupResult)) {\n instance2.setupState = proxyRefs(setupResult);\n } else\n ;\n finishComponentSetup(instance2, isSSR);\n}\nlet compile;\nfunction finishComponentSetup(instance2, isSSR, skipOptions) {\n const Component = instance2.type;\n if (!instance2.render) {\n if (!isSSR && compile && !Component.render) {\n const template = Component.template;\n if (template) {\n const { isCustomElement, compilerOptions } = instance2.appContext.config;\n const { delimiters, compilerOptions: componentCompilerOptions } = Component;\n const finalCompilerOptions = extend$1(extend$1({\n isCustomElement,\n delimiters\n }, compilerOptions), componentCompilerOptions);\n Component.render = compile(template, finalCompilerOptions);\n }\n }\n instance2.render = Component.render || NOOP;\n }\n {\n setCurrentInstance(instance2);\n pauseTracking();\n applyOptions(instance2);\n resetTracking();\n unsetCurrentInstance();\n }\n}\nfunction createAttrsProxy(instance2) {\n return new Proxy(instance2.attrs, {\n get(target, key) {\n track(instance2, \"get\", \"$attrs\");\n return target[key];\n }\n });\n}\nfunction createSetupContext(instance2) {\n const expose = (exposed) => {\n instance2.exposed = exposed || {};\n };\n let attrs;\n {\n return {\n get attrs() {\n return attrs || (attrs = createAttrsProxy(instance2));\n },\n slots: instance2.slots,\n emit: instance2.emit,\n expose\n };\n }\n}\nfunction getExposeProxy(instance2) {\n if (instance2.exposed) {\n return instance2.exposeProxy || (instance2.exposeProxy = new Proxy(proxyRefs(markRaw(instance2.exposed)), {\n get(target, key) {\n if (key in target) {\n return target[key];\n } else if (key in publicPropertiesMap) {\n return publicPropertiesMap[key](instance2);\n }\n }\n }));\n }\n}\nfunction getComponentName(Component, includeInferred = true) {\n return isFunction$1(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;\n}\nfunction isClassComponent(value) {\n return isFunction$1(value) && \"__vccOpts\" in value;\n}\nconst computed = (getterOrOptions, debugOptions) => {\n return computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);\n};\nfunction h(type, propsOrChildren, children) {\n const l = arguments.length;\n if (l === 2) {\n if (isObject$1(propsOrChildren) && !isArray$1(propsOrChildren)) {\n if (isVNode(propsOrChildren)) {\n return createVNode(type, null, [propsOrChildren]);\n }\n return createVNode(type, propsOrChildren);\n } else {\n return createVNode(type, null, propsOrChildren);\n }\n } else {\n if (l > 3) {\n children = Array.prototype.slice.call(arguments, 2);\n } else if (l === 3 && isVNode(children)) {\n children = [children];\n }\n return createVNode(type, propsOrChildren, children);\n }\n}\nconst version = \"3.2.37\";\nfunction makeMap(str, expectsLowerCase) {\n const map = /* @__PURE__ */ Object.create(null);\n const list = str.split(\",\");\n for (let i = 0; i < list.length; i++) {\n map[list[i]] = true;\n }\n return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];\n}\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\nconst isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);\nfunction includeBooleanAttr(value) {\n return !!value || value === \"\";\n}\nconst onRE = /^on[^a-z]/;\nconst isOn = (key) => onRE.test(key);\nconst isModelListener = (key) => key.startsWith(\"onUpdate:\");\nconst extend = Object.assign;\nconst isArray = Array.isArray;\nconst isFunction = (val) => typeof val === \"function\";\nconst isString = (val) => typeof val === \"string\";\nconst isObject = (val) => val !== null && typeof val === \"object\";\nconst cacheStringFunction = (fn) => {\n const cache = /* @__PURE__ */ Object.create(null);\n return (str) => {\n const hit = cache[str];\n return hit || (cache[str] = fn(str));\n };\n};\nconst camelizeRE = /-(\\w)/g;\nconst camelize = cacheStringFunction((str) => {\n return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : \"\");\n});\nconst hyphenateRE = /\\B([A-Z])/g;\nconst hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, \"-$1\").toLowerCase());\nconst capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));\nconst toNumber = (val) => {\n const n = parseFloat(val);\n return isNaN(n) ? val : n;\n};\nconst svgNS = \"http://www.w3.org/2000/svg\";\nconst doc = typeof document !== \"undefined\" ? document : null;\nconst templateContainer = doc && /* @__PURE__ */ doc.createElement(\"template\");\nconst nodeOps = {\n insert: (child, parent, anchor) => {\n parent.insertBefore(child, anchor || null);\n },\n remove: (child) => {\n const parent = child.parentNode;\n if (parent) {\n parent.removeChild(child);\n }\n },\n createElement: (tag, isSVG, is, props) => {\n const el = isSVG ? doc.createElementNS(svgNS, tag) : doc.createElement(tag, is ? { is } : void 0);\n if (tag === \"select\" && props && props.multiple != null) {\n el.setAttribute(\"multiple\", props.multiple);\n }\n return el;\n },\n createText: (text2) => doc.createTextNode(text2),\n createComment: (text2) => doc.createComment(text2),\n setText: (node, text2) => {\n node.nodeValue = text2;\n },\n setElementText: (el, text2) => {\n el.textContent = text2;\n },\n parentNode: (node) => node.parentNode,\n nextSibling: (node) => node.nextSibling,\n querySelector: (selector) => doc.querySelector(selector),\n setScopeId(el, id) {\n el.setAttribute(id, \"\");\n },\n cloneNode(el) {\n const cloned = el.cloneNode(true);\n if (`_value` in el) {\n cloned._value = el._value;\n }\n return cloned;\n },\n insertStaticContent(content, parent, anchor, isSVG, start2, end) {\n const before = anchor ? anchor.previousSibling : parent.lastChild;\n if (start2 && (start2 === end || start2.nextSibling)) {\n while (true) {\n parent.insertBefore(start2.cloneNode(true), anchor);\n if (start2 === end || !(start2 = start2.nextSibling))\n break;\n }\n } else {\n templateContainer.innerHTML = isSVG ? `` : content;\n const template = templateContainer.content;\n if (isSVG) {\n const wrapper = template.firstChild;\n while (wrapper.firstChild) {\n template.appendChild(wrapper.firstChild);\n }\n template.removeChild(wrapper);\n }\n parent.insertBefore(template, anchor);\n }\n return [\n before ? before.nextSibling : parent.firstChild,\n anchor ? anchor.previousSibling : parent.lastChild\n ];\n }\n};\nfunction patchClass(el, value, isSVG) {\n const transitionClasses = el._vtc;\n if (transitionClasses) {\n value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(\" \");\n }\n if (value == null) {\n el.removeAttribute(\"class\");\n } else if (isSVG) {\n el.setAttribute(\"class\", value);\n } else {\n el.className = value;\n }\n}\nfunction patchStyle(el, prev, next2) {\n const style = el.style;\n const isCssString = isString(next2);\n if (next2 && !isCssString) {\n for (const key in next2) {\n setStyle(style, key, next2[key]);\n }\n if (prev && !isString(prev)) {\n for (const key in prev) {\n if (next2[key] == null) {\n setStyle(style, key, \"\");\n }\n }\n }\n } else {\n const currentDisplay = style.display;\n if (isCssString) {\n if (prev !== next2) {\n style.cssText = next2;\n }\n } else if (prev) {\n el.removeAttribute(\"style\");\n }\n if (\"_vod\" in el) {\n style.display = currentDisplay;\n }\n }\n}\nconst importantRE = /\\s*!important$/;\nfunction setStyle(style, name, val) {\n if (isArray(val)) {\n val.forEach((v) => setStyle(style, name, v));\n } else {\n if (val == null)\n val = \"\";\n if (name.startsWith(\"--\")) {\n style.setProperty(name, val);\n } else {\n const prefixed = autoPrefix(style, name);\n if (importantRE.test(val)) {\n style.setProperty(hyphenate(prefixed), val.replace(importantRE, \"\"), \"important\");\n } else {\n style[prefixed] = val;\n }\n }\n }\n}\nconst prefixes = [\"Webkit\", \"Moz\", \"ms\"];\nconst prefixCache = {};\nfunction autoPrefix(style, rawName) {\n const cached = prefixCache[rawName];\n if (cached) {\n return cached;\n }\n let name = camelize$1(rawName);\n if (name !== \"filter\" && name in style) {\n return prefixCache[rawName] = name;\n }\n name = capitalize(name);\n for (let i = 0; i < prefixes.length; i++) {\n const prefixed = prefixes[i] + name;\n if (prefixed in style) {\n return prefixCache[rawName] = prefixed;\n }\n }\n return rawName;\n}\nconst xlinkNS = \"http://www.w3.org/1999/xlink\";\nfunction patchAttr(el, key, value, isSVG, instance2) {\n if (isSVG && key.startsWith(\"xlink:\")) {\n if (value == null) {\n el.removeAttributeNS(xlinkNS, key.slice(6, key.length));\n } else {\n el.setAttributeNS(xlinkNS, key, value);\n }\n } else {\n const isBoolean = isSpecialBooleanAttr(key);\n if (value == null || isBoolean && !includeBooleanAttr(value)) {\n el.removeAttribute(key);\n } else {\n el.setAttribute(key, isBoolean ? \"\" : value);\n }\n }\n}\nfunction patchDOMProp(el, key, value, prevChildren, parentComponent, parentSuspense, unmountChildren) {\n if (key === \"innerHTML\" || key === \"textContent\") {\n if (prevChildren) {\n unmountChildren(prevChildren, parentComponent, parentSuspense);\n }\n el[key] = value == null ? \"\" : value;\n return;\n }\n if (key === \"value\" && el.tagName !== \"PROGRESS\" && !el.tagName.includes(\"-\")) {\n el._value = value;\n const newValue = value == null ? \"\" : value;\n if (el.value !== newValue || el.tagName === \"OPTION\") {\n el.value = newValue;\n }\n if (value == null) {\n el.removeAttribute(key);\n }\n return;\n }\n let needRemove = false;\n if (value === \"\" || value == null) {\n const type = typeof el[key];\n if (type === \"boolean\") {\n value = includeBooleanAttr(value);\n } else if (value == null && type === \"string\") {\n value = \"\";\n needRemove = true;\n } else if (type === \"number\") {\n value = 0;\n needRemove = true;\n }\n }\n try {\n el[key] = value;\n } catch (e) {\n }\n needRemove && el.removeAttribute(key);\n}\nconst [_getNow, skipTimestampCheck] = /* @__PURE__ */ (() => {\n let _getNow2 = Date.now;\n let skipTimestampCheck2 = false;\n if (typeof window !== \"undefined\") {\n if (Date.now() > document.createEvent(\"Event\").timeStamp) {\n _getNow2 = performance.now.bind(performance);\n }\n const ffMatch = navigator.userAgent.match(/firefox\\/(\\d+)/i);\n skipTimestampCheck2 = !!(ffMatch && Number(ffMatch[1]) <= 53);\n }\n return [_getNow2, skipTimestampCheck2];\n})();\nlet cachedNow = 0;\nconst p = /* @__PURE__ */ Promise.resolve();\nconst reset = () => {\n cachedNow = 0;\n};\nconst getNow = () => cachedNow || (p.then(reset), cachedNow = _getNow());\nfunction addEventListener$1(el, event, handler, options2) {\n el.addEventListener(event, handler, options2);\n}\nfunction removeEventListener(el, event, handler, options2) {\n el.removeEventListener(event, handler, options2);\n}\nfunction patchEvent(el, rawName, prevValue, nextValue, instance2 = null) {\n const invokers = el._vei || (el._vei = {});\n const existingInvoker = invokers[rawName];\n if (nextValue && existingInvoker) {\n existingInvoker.value = nextValue;\n } else {\n const [name, options2] = parseName(rawName);\n if (nextValue) {\n const invoker = invokers[rawName] = createInvoker(nextValue, instance2);\n addEventListener$1(el, name, invoker, options2);\n } else if (existingInvoker) {\n removeEventListener(el, name, existingInvoker, options2);\n invokers[rawName] = void 0;\n }\n }\n}\nconst optionsModifierRE = /(?:Once|Passive|Capture)$/;\nfunction parseName(name) {\n let options2;\n if (optionsModifierRE.test(name)) {\n options2 = {};\n let m;\n while (m = name.match(optionsModifierRE)) {\n name = name.slice(0, name.length - m[0].length);\n options2[m[0].toLowerCase()] = true;\n }\n }\n return [hyphenate(name.slice(2)), options2];\n}\nfunction createInvoker(initialValue, instance2) {\n const invoker = (e) => {\n const timeStamp = e.timeStamp || _getNow();\n if (skipTimestampCheck || timeStamp >= invoker.attached - 1) {\n callWithAsyncErrorHandling(patchStopImmediatePropagation(e, invoker.value), instance2, 5, [e]);\n }\n };\n invoker.value = initialValue;\n invoker.attached = getNow();\n return invoker;\n}\nfunction patchStopImmediatePropagation(e, value) {\n if (isArray(value)) {\n const originalStop = e.stopImmediatePropagation;\n e.stopImmediatePropagation = () => {\n originalStop.call(e);\n e._stopped = true;\n };\n return value.map((fn) => (e2) => !e2._stopped && fn && fn(e2));\n } else {\n return value;\n }\n}\nconst nativeOnRE = /^on[a-z]/;\nconst patchProp = (el, key, prevValue, nextValue, isSVG = false, prevChildren, parentComponent, parentSuspense, unmountChildren) => {\n if (key === \"class\") {\n patchClass(el, nextValue, isSVG);\n } else if (key === \"style\") {\n patchStyle(el, prevValue, nextValue);\n } else if (isOn(key)) {\n if (!isModelListener(key)) {\n patchEvent(el, key, prevValue, nextValue, parentComponent);\n }\n } else if (key[0] === \".\" ? (key = key.slice(1), true) : key[0] === \"^\" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {\n patchDOMProp(el, key, nextValue, prevChildren, parentComponent, parentSuspense, unmountChildren);\n } else {\n if (key === \"true-value\") {\n el._trueValue = nextValue;\n } else if (key === \"false-value\") {\n el._falseValue = nextValue;\n }\n patchAttr(el, key, nextValue, isSVG);\n }\n};\nfunction shouldSetAsProp(el, key, value, isSVG) {\n if (isSVG) {\n if (key === \"innerHTML\" || key === \"textContent\") {\n return true;\n }\n if (key in el && nativeOnRE.test(key) && isFunction(value)) {\n return true;\n }\n return false;\n }\n if (key === \"spellcheck\" || key === \"draggable\" || key === \"translate\") {\n return false;\n }\n if (key === \"form\") {\n return false;\n }\n if (key === \"list\" && el.tagName === \"INPUT\") {\n return false;\n }\n if (key === \"type\" && el.tagName === \"TEXTAREA\") {\n return false;\n }\n if (nativeOnRE.test(key) && isString(value)) {\n return false;\n }\n return key in el;\n}\nfunction defineCustomElement(options2, hydrate) {\n const Comp = defineComponent(options2);\n class VueCustomElement extends VueElement {\n constructor(initialProps) {\n super(Comp, initialProps, hydrate);\n }\n }\n VueCustomElement.def = Comp;\n return VueCustomElement;\n}\nconst BaseClass = typeof HTMLElement !== \"undefined\" ? HTMLElement : class {\n};\nclass VueElement extends BaseClass {\n constructor(_def, _props = {}, hydrate) {\n super();\n this._def = _def;\n this._props = _props;\n this._instance = null;\n this._connected = false;\n this._resolved = false;\n this._numberProps = null;\n if (this.shadowRoot && hydrate) {\n hydrate(this._createVNode(), this.shadowRoot);\n } else {\n this.attachShadow({ mode: \"open\" });\n }\n }\n connectedCallback() {\n this._connected = true;\n if (!this._instance) {\n this._resolveDef();\n }\n }\n disconnectedCallback() {\n this._connected = false;\n nextTick(() => {\n if (!this._connected) {\n render(null, this.shadowRoot);\n this._instance = null;\n }\n });\n }\n _resolveDef() {\n if (this._resolved) {\n return;\n }\n this._resolved = true;\n for (let i = 0; i < this.attributes.length; i++) {\n this._setAttr(this.attributes[i].name);\n }\n new MutationObserver((mutations) => {\n for (const m of mutations) {\n this._setAttr(m.attributeName);\n }\n }).observe(this, { attributes: true });\n const resolve3 = (def2) => {\n const { props, styles } = def2;\n const hasOptions = !isArray(props);\n const rawKeys = props ? hasOptions ? Object.keys(props) : props : [];\n let numberProps;\n if (hasOptions) {\n for (const key in this._props) {\n const opt = props[key];\n if (opt === Number || opt && opt.type === Number) {\n this._props[key] = toNumber(this._props[key]);\n (numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[key] = true;\n }\n }\n }\n this._numberProps = numberProps;\n for (const key of Object.keys(this)) {\n if (key[0] !== \"_\") {\n this._setProp(key, this[key], true, false);\n }\n }\n for (const key of rawKeys.map(camelize)) {\n Object.defineProperty(this, key, {\n get() {\n return this._getProp(key);\n },\n set(val) {\n this._setProp(key, val);\n }\n });\n }\n this._applyStyles(styles);\n this._update();\n };\n const asyncDef = this._def.__asyncLoader;\n if (asyncDef) {\n asyncDef().then(resolve3);\n } else {\n resolve3(this._def);\n }\n }\n _setAttr(key) {\n let value = this.getAttribute(key);\n if (this._numberProps && this._numberProps[key]) {\n value = toNumber(value);\n }\n this._setProp(camelize(key), value, false);\n }\n _getProp(key) {\n return this._props[key];\n }\n _setProp(key, val, shouldReflect = true, shouldUpdate = true) {\n if (val !== this._props[key]) {\n this._props[key] = val;\n if (shouldUpdate && this._instance) {\n this._update();\n }\n if (shouldReflect) {\n if (val === true) {\n this.setAttribute(hyphenate(key), \"\");\n } else if (typeof val === \"string\" || typeof val === \"number\") {\n this.setAttribute(hyphenate(key), val + \"\");\n } else if (!val) {\n this.removeAttribute(hyphenate(key));\n }\n }\n }\n }\n _update() {\n render(this._createVNode(), this.shadowRoot);\n }\n _createVNode() {\n const vnode = createVNode(this._def, extend({}, this._props));\n if (!this._instance) {\n vnode.ce = (instance2) => {\n this._instance = instance2;\n instance2.isCE = true;\n instance2.emit = (event, ...args) => {\n this.dispatchEvent(new CustomEvent(event, {\n detail: args\n }));\n };\n let parent = this;\n while (parent = parent && (parent.parentNode || parent.host)) {\n if (parent instanceof VueElement) {\n instance2.parent = parent._instance;\n break;\n }\n }\n };\n }\n return vnode;\n }\n _applyStyles(styles) {\n if (styles) {\n styles.forEach((css) => {\n const s = document.createElement(\"style\");\n s.textContent = css;\n this.shadowRoot.appendChild(s);\n });\n }\n }\n}\nconst TRANSITION = \"transition\";\nconst ANIMATION = \"animation\";\nconst Transition = (props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots);\nTransition.displayName = \"Transition\";\nconst DOMTransitionPropsValidators = {\n name: String,\n type: String,\n css: {\n type: Boolean,\n default: true\n },\n duration: [String, Number, Object],\n enterFromClass: String,\n enterActiveClass: String,\n enterToClass: String,\n appearFromClass: String,\n appearActiveClass: String,\n appearToClass: String,\n leaveFromClass: String,\n leaveActiveClass: String,\n leaveToClass: String\n};\nconst TransitionPropsValidators = Transition.props = /* @__PURE__ */ extend({}, BaseTransition.props, DOMTransitionPropsValidators);\nconst callHook = (hook, args = []) => {\n if (isArray(hook)) {\n hook.forEach((h2) => h2(...args));\n } else if (hook) {\n hook(...args);\n }\n};\nconst hasExplicitCallback = (hook) => {\n return hook ? isArray(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;\n};\nfunction resolveTransitionProps(rawProps) {\n const baseProps = {};\n for (const key in rawProps) {\n if (!(key in DOMTransitionPropsValidators)) {\n baseProps[key] = rawProps[key];\n }\n }\n if (rawProps.css === false) {\n return baseProps;\n }\n const { name = \"v\", type, duration, enterFromClass = `${name}-enter-from`, enterActiveClass = `${name}-enter-active`, enterToClass = `${name}-enter-to`, appearFromClass = enterFromClass, appearActiveClass = enterActiveClass, appearToClass = enterToClass, leaveFromClass = `${name}-leave-from`, leaveActiveClass = `${name}-leave-active`, leaveToClass = `${name}-leave-to` } = rawProps;\n const durations = normalizeDuration(duration);\n const enterDuration = durations && durations[0];\n const leaveDuration = durations && durations[1];\n const { onBeforeEnter, onEnter, onEnterCancelled, onLeave, onLeaveCancelled, onBeforeAppear = onBeforeEnter, onAppear = onEnter, onAppearCancelled = onEnterCancelled } = baseProps;\n const finishEnter = (el, isAppear, done) => {\n removeTransitionClass(el, isAppear ? appearToClass : enterToClass);\n removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);\n done && done();\n };\n const finishLeave = (el, done) => {\n el._isLeaving = false;\n removeTransitionClass(el, leaveFromClass);\n removeTransitionClass(el, leaveToClass);\n removeTransitionClass(el, leaveActiveClass);\n done && done();\n };\n const makeEnterHook = (isAppear) => {\n return (el, done) => {\n const hook = isAppear ? onAppear : onEnter;\n const resolve3 = () => finishEnter(el, isAppear, done);\n callHook(hook, [el, resolve3]);\n nextFrame(() => {\n removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);\n addTransitionClass(el, isAppear ? appearToClass : enterToClass);\n if (!hasExplicitCallback(hook)) {\n whenTransitionEnds(el, type, enterDuration, resolve3);\n }\n });\n };\n };\n return extend(baseProps, {\n onBeforeEnter(el) {\n callHook(onBeforeEnter, [el]);\n addTransitionClass(el, enterFromClass);\n addTransitionClass(el, enterActiveClass);\n },\n onBeforeAppear(el) {\n callHook(onBeforeAppear, [el]);\n addTransitionClass(el, appearFromClass);\n addTransitionClass(el, appearActiveClass);\n },\n onEnter: makeEnterHook(false),\n onAppear: makeEnterHook(true),\n onLeave(el, done) {\n el._isLeaving = true;\n const resolve3 = () => finishLeave(el, done);\n addTransitionClass(el, leaveFromClass);\n forceReflow();\n addTransitionClass(el, leaveActiveClass);\n nextFrame(() => {\n if (!el._isLeaving) {\n return;\n }\n removeTransitionClass(el, leaveFromClass);\n addTransitionClass(el, leaveToClass);\n if (!hasExplicitCallback(onLeave)) {\n whenTransitionEnds(el, type, leaveDuration, resolve3);\n }\n });\n callHook(onLeave, [el, resolve3]);\n },\n onEnterCancelled(el) {\n finishEnter(el, false);\n callHook(onEnterCancelled, [el]);\n },\n onAppearCancelled(el) {\n finishEnter(el, true);\n callHook(onAppearCancelled, [el]);\n },\n onLeaveCancelled(el) {\n finishLeave(el);\n callHook(onLeaveCancelled, [el]);\n }\n });\n}\nfunction normalizeDuration(duration) {\n if (duration == null) {\n return null;\n } else if (isObject(duration)) {\n return [NumberOf(duration.enter), NumberOf(duration.leave)];\n } else {\n const n = NumberOf(duration);\n return [n, n];\n }\n}\nfunction NumberOf(val) {\n const res = toNumber(val);\n return res;\n}\nfunction addTransitionClass(el, cls) {\n cls.split(/\\s+/).forEach((c) => c && el.classList.add(c));\n (el._vtc || (el._vtc = /* @__PURE__ */ new Set())).add(cls);\n}\nfunction removeTransitionClass(el, cls) {\n cls.split(/\\s+/).forEach((c) => c && el.classList.remove(c));\n const { _vtc } = el;\n if (_vtc) {\n _vtc.delete(cls);\n if (!_vtc.size) {\n el._vtc = void 0;\n }\n }\n}\nfunction nextFrame(cb) {\n requestAnimationFrame(() => {\n requestAnimationFrame(cb);\n });\n}\nlet endId = 0;\nfunction whenTransitionEnds(el, expectedType, explicitTimeout, resolve3) {\n const id = el._endId = ++endId;\n const resolveIfNotStale = () => {\n if (id === el._endId) {\n resolve3();\n }\n };\n if (explicitTimeout) {\n return setTimeout(resolveIfNotStale, explicitTimeout);\n }\n const { type, timeout, propCount } = getTransitionInfo(el, expectedType);\n if (!type) {\n return resolve3();\n }\n const endEvent = type + \"end\";\n let ended = 0;\n const end = () => {\n el.removeEventListener(endEvent, onEnd);\n resolveIfNotStale();\n };\n const onEnd = (e) => {\n if (e.target === el && ++ended >= propCount) {\n end();\n }\n };\n setTimeout(() => {\n if (ended < propCount) {\n end();\n }\n }, timeout + 1);\n el.addEventListener(endEvent, onEnd);\n}\nfunction getTransitionInfo(el, expectedType) {\n const styles = window.getComputedStyle(el);\n const getStyleProperties = (key) => (styles[key] || \"\").split(\", \");\n const transitionDelays = getStyleProperties(TRANSITION + \"Delay\");\n const transitionDurations = getStyleProperties(TRANSITION + \"Duration\");\n const transitionTimeout = getTimeout(transitionDelays, transitionDurations);\n const animationDelays = getStyleProperties(ANIMATION + \"Delay\");\n const animationDurations = getStyleProperties(ANIMATION + \"Duration\");\n const animationTimeout = getTimeout(animationDelays, animationDurations);\n let type = null;\n let timeout = 0;\n let propCount = 0;\n if (expectedType === TRANSITION) {\n if (transitionTimeout > 0) {\n type = TRANSITION;\n timeout = transitionTimeout;\n propCount = transitionDurations.length;\n }\n } else if (expectedType === ANIMATION) {\n if (animationTimeout > 0) {\n type = ANIMATION;\n timeout = animationTimeout;\n propCount = animationDurations.length;\n }\n } else {\n timeout = Math.max(transitionTimeout, animationTimeout);\n type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;\n propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;\n }\n const hasTransform = type === TRANSITION && /\\b(transform|all)(,|$)/.test(styles[TRANSITION + \"Property\"]);\n return {\n type,\n timeout,\n propCount,\n hasTransform\n };\n}\nfunction getTimeout(delays, durations) {\n while (delays.length < durations.length) {\n delays = delays.concat(delays);\n }\n return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));\n}\nfunction toMs(s) {\n return Number(s.slice(0, -1).replace(\",\", \".\")) * 1e3;\n}\nfunction forceReflow() {\n return document.body.offsetHeight;\n}\nconst positionMap = /* @__PURE__ */ new WeakMap();\nconst newPositionMap = /* @__PURE__ */ new WeakMap();\nconst TransitionGroupImpl = {\n name: \"TransitionGroup\",\n props: /* @__PURE__ */ extend({}, TransitionPropsValidators, {\n tag: String,\n moveClass: String\n }),\n setup(props, { slots }) {\n const instance2 = getCurrentInstance();\n const state2 = useTransitionState();\n let prevChildren;\n let children;\n onUpdated(() => {\n if (!prevChildren.length) {\n return;\n }\n const moveClass = props.moveClass || `${props.name || \"v\"}-move`;\n if (!hasCSSTransform(prevChildren[0].el, instance2.vnode.el, moveClass)) {\n return;\n }\n prevChildren.forEach(callPendingCbs);\n prevChildren.forEach(recordPosition);\n const movedChildren = prevChildren.filter(applyTranslation);\n forceReflow();\n movedChildren.forEach((c) => {\n const el = c.el;\n const style = el.style;\n addTransitionClass(el, moveClass);\n style.transform = style.webkitTransform = style.transitionDuration = \"\";\n const cb = el._moveCb = (e) => {\n if (e && e.target !== el) {\n return;\n }\n if (!e || /transform$/.test(e.propertyName)) {\n el.removeEventListener(\"transitionend\", cb);\n el._moveCb = null;\n removeTransitionClass(el, moveClass);\n }\n };\n el.addEventListener(\"transitionend\", cb);\n });\n });\n return () => {\n const rawProps = toRaw(props);\n const cssTransitionProps = resolveTransitionProps(rawProps);\n let tag = rawProps.tag || Fragment;\n prevChildren = children;\n children = slots.default ? getTransitionRawChildren(slots.default()) : [];\n for (let i = 0; i < children.length; i++) {\n const child = children[i];\n if (child.key != null) {\n setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state2, instance2));\n }\n }\n if (prevChildren) {\n for (let i = 0; i < prevChildren.length; i++) {\n const child = prevChildren[i];\n setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state2, instance2));\n positionMap.set(child, child.el.getBoundingClientRect());\n }\n }\n return createVNode(tag, null, children);\n };\n }\n};\nconst TransitionGroup = TransitionGroupImpl;\nfunction callPendingCbs(c) {\n const el = c.el;\n if (el._moveCb) {\n el._moveCb();\n }\n if (el._enterCb) {\n el._enterCb();\n }\n}\nfunction recordPosition(c) {\n newPositionMap.set(c, c.el.getBoundingClientRect());\n}\nfunction applyTranslation(c) {\n const oldPos = positionMap.get(c);\n const newPos = newPositionMap.get(c);\n const dx = oldPos.left - newPos.left;\n const dy = oldPos.top - newPos.top;\n if (dx || dy) {\n const s = c.el.style;\n s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;\n s.transitionDuration = \"0s\";\n return c;\n }\n}\nfunction hasCSSTransform(el, root, moveClass) {\n const clone = el.cloneNode();\n if (el._vtc) {\n el._vtc.forEach((cls) => {\n cls.split(/\\s+/).forEach((c) => c && clone.classList.remove(c));\n });\n }\n moveClass.split(/\\s+/).forEach((c) => c && clone.classList.add(c));\n clone.style.display = \"none\";\n const container = root.nodeType === 1 ? root : root.parentNode;\n container.appendChild(clone);\n const { hasTransform } = getTransitionInfo(clone);\n container.removeChild(clone);\n return hasTransform;\n}\nconst systemModifiers = [\"ctrl\", \"shift\", \"alt\", \"meta\"];\nconst modifierGuards = {\n stop: (e) => e.stopPropagation(),\n prevent: (e) => e.preventDefault(),\n self: (e) => e.target !== e.currentTarget,\n ctrl: (e) => !e.ctrlKey,\n shift: (e) => !e.shiftKey,\n alt: (e) => !e.altKey,\n meta: (e) => !e.metaKey,\n left: (e) => \"button\" in e && e.button !== 0,\n middle: (e) => \"button\" in e && e.button !== 1,\n right: (e) => \"button\" in e && e.button !== 2,\n exact: (e, modifiers) => systemModifiers.some((m) => e[`${m}Key`] && !modifiers.includes(m))\n};\nconst withModifiers = (fn, modifiers) => {\n return (event, ...args) => {\n for (let i = 0; i < modifiers.length; i++) {\n const guard = modifierGuards[modifiers[i]];\n if (guard && guard(event, modifiers))\n return;\n }\n return fn(event, ...args);\n };\n};\nconst keyNames = {\n esc: \"escape\",\n space: \" \",\n up: \"arrow-up\",\n left: \"arrow-left\",\n right: \"arrow-right\",\n down: \"arrow-down\",\n delete: \"backspace\"\n};\nconst withKeys = (fn, modifiers) => {\n return (event) => {\n if (!(\"key\" in event)) {\n return;\n }\n const eventKey = hyphenate(event.key);\n if (modifiers.some((k) => k === eventKey || keyNames[k] === eventKey)) {\n return fn(event);\n }\n };\n};\nconst vShow = {\n beforeMount(el, { value }, { transition }) {\n el._vod = el.style.display === \"none\" ? \"\" : el.style.display;\n if (transition && value) {\n transition.beforeEnter(el);\n } else {\n setDisplay(el, value);\n }\n },\n mounted(el, { value }, { transition }) {\n if (transition && value) {\n transition.enter(el);\n }\n },\n updated(el, { value, oldValue }, { transition }) {\n if (!value === !oldValue)\n return;\n if (transition) {\n if (value) {\n transition.beforeEnter(el);\n setDisplay(el, true);\n transition.enter(el);\n } else {\n transition.leave(el, () => {\n setDisplay(el, false);\n });\n }\n } else {\n setDisplay(el, value);\n }\n },\n beforeUnmount(el, { value }) {\n setDisplay(el, value);\n }\n};\nfunction setDisplay(el, value) {\n el.style.display = value ? el._vod : \"none\";\n}\nconst rendererOptions = /* @__PURE__ */ extend({ patchProp }, nodeOps);\nlet renderer;\nfunction ensureRenderer() {\n return renderer || (renderer = createRenderer(rendererOptions));\n}\nconst render = (...args) => {\n ensureRenderer().render(...args);\n};\nvar _export_sfc = (sfc, props) => {\n const target = sfc.__vccOpts || sfc;\n for (const [key, val] of props) {\n target[key] = val;\n }\n return target;\n};\nconst _sfc_main$q = {\n name: \"AppLoader\",\n props: {\n show: { type: Boolean, default: false },\n infinite: { type: Boolean, default: false },\n type: { type: String, required: true },\n messageId: { type: String, default: \"\" }\n }\n};\nconst _hoisted_1$q = /* @__PURE__ */ createBaseVNode(\"div\", { id: \"vac-circle\" }, null, -1);\nconst _hoisted_2$n = /* @__PURE__ */ createBaseVNode(\"div\", { id: \"vac-circle\" }, null, -1);\nconst _hoisted_3$j = /* @__PURE__ */ createBaseVNode(\"div\", { id: \"vac-circle\" }, null, -1);\nconst _hoisted_4$h = /* @__PURE__ */ createBaseVNode(\"div\", { id: \"vac-circle\" }, null, -1);\nconst _hoisted_5$b = /* @__PURE__ */ createBaseVNode(\"div\", { id: \"vac-circle\" }, null, -1);\nconst _hoisted_6$7 = /* @__PURE__ */ createBaseVNode(\"div\", { id: \"vac-circle\" }, null, -1);\nfunction _sfc_render$q(_ctx, _cache, $props, $setup, $data, $options) {\n return openBlock(), createBlock(Transition, {\n name: \"vac-fade-spinner\",\n appear: \"\"\n }, {\n default: withCtx(() => [\n $props.show ? (openBlock(), createElementBlock(\"div\", {\n key: 0,\n class: normalizeClass([\"vac-loader-wrapper\", {\n \"vac-container-center\": !$props.infinite,\n \"vac-container-top\": $props.infinite\n }])\n }, [\n $props.type === \"rooms\" ? renderSlot(_ctx.$slots, \"spinner-icon-rooms\", { key: 0 }, () => [\n _hoisted_1$q\n ]) : createCommentVNode(\"\", true),\n $props.type === \"infinite-rooms\" ? renderSlot(_ctx.$slots, \"spinner-icon-infinite-rooms\", { key: 1 }, () => [\n _hoisted_2$n\n ]) : createCommentVNode(\"\", true),\n $props.type === \"message-file\" ? renderSlot(_ctx.$slots, \"spinner-icon-message-file_\" + $props.messageId, { key: 2 }, () => [\n _hoisted_3$j\n ]) : createCommentVNode(\"\", true),\n $props.type === \"room-file\" ? renderSlot(_ctx.$slots, \"spinner-icon-room-file\", { key: 3 }, () => [\n _hoisted_4$h\n ]) : createCommentVNode(\"\", true),\n $props.type === \"messages\" ? renderSlot(_ctx.$slots, \"spinner-icon-messages\", { key: 4 }, () => [\n _hoisted_5$b\n ]) : createCommentVNode(\"\", true),\n $props.type === \"infinite-messages\" ? renderSlot(_ctx.$slots, \"spinner-icon-infinite-messages\", { key: 5 }, () => [\n _hoisted_6$7\n ]) : createCommentVNode(\"\", true)\n ], 2)) : createCommentVNode(\"\", true)\n ]),\n _: 3\n });\n}\nvar Loader = /* @__PURE__ */ _export_sfc(_sfc_main$q, [[\"render\", _sfc_render$q]]);\nconst _sfc_main$p = {\n name: \"SvgIcon\",\n props: {\n name: { type: String, default: null },\n param: { type: String, default: null }\n },\n data() {\n return {\n svgItem: {\n search: {\n path: \"M9.5,3A6.5,6.5 0 0,1 16,9.5C16,11.11 15.41,12.59 14.44,13.73L14.71,14H15.5L20.5,19L19,20.5L14,15.5V14.71L13.73,14.44C12.59,15.41 11.11,16 9.5,16A6.5,6.5 0 0,1 3,9.5A6.5,6.5 0 0,1 9.5,3M9.5,5C7,5 5,7 5,9.5C5,12 7,14 9.5,14C12,14 14,12 14,9.5C14,7 12,5 9.5,5Z\"\n },\n add: {\n path: \"M17,13H13V17H11V13H7V11H11V7H13V11H17M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12A10,10 0 0,0 12,2Z\"\n },\n toggle: {\n path: \"M5,13L9,17L7.6,18.42L1.18,12L7.6,5.58L9,7L5,11H21V13H5M21,6V8H11V6H21M21,16V18H11V16H21Z\"\n },\n menu: {\n path: \"M12,16A2,2 0 0,1 14,18A2,2 0 0,1 12,20A2,2 0 0,1 10,18A2,2 0 0,1 12,16M12,10A2,2 0 0,1 14,12A2,2 0 0,1 12,14A2,2 0 0,1 10,12A2,2 0 0,1 12,10M12,4A2,2 0 0,1 14,6A2,2 0 0,1 12,8A2,2 0 0,1 10,6A2,2 0 0,1 12,4Z\"\n },\n close: {\n path: \"M12,2C17.53,2 22,6.47 22,12C22,17.53 17.53,22 12,22C6.47,22 2,17.53 2,12C2,6.47 6.47,2 12,2M15.59,7L12,10.59L8.41,7L7,8.41L10.59,12L7,15.59L8.41,17L12,13.41L15.59,17L17,15.59L13.41,12L17,8.41L15.59,7Z\"\n },\n file: {\n path: \"M14,17H7V15H14M17,13H7V11H17M17,9H7V7H17M19,3H5C3.89,3 3,3.89 3,5V19A2,2 0 0,0 5,21H19A2,2 0 0,0 21,19V5C21,3.89 20.1,3 19,3Z\"\n },\n paperclip: {\n path: \"M16.5,6V17.5A4,4 0 0,1 12.5,21.5A4,4 0 0,1 8.5,17.5V5A2.5,2.5 0 0,1 11,2.5A2.5,2.5 0 0,1 13.5,5V15.5A1,1 0 0,1 12.5,16.5A1,1 0 0,1 11.5,15.5V6H10V15.5A2.5,2.5 0 0,0 12.5,18A2.5,2.5 0 0,0 15,15.5V5A4,4 0 0,0 11,1A4,4 0 0,0 7,5V17.5A5.5,5.5 0 0,0 12.5,23A5.5,5.5 0 0,0 18,17.5V6H16.5Z\"\n },\n \"close-outline\": {\n path: \"M19,6.41L17.59,5L12,10.59L6.41,5L5,6.41L10.59,12L5,17.59L6.41,19L12,13.41L17.59,19L19,17.59L13.41,12L19,6.41Z\"\n },\n send: {\n path: \"M2,21L23,12L2,3V10L17,12L2,14V21Z\"\n },\n emoji: {\n path: \"M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm3.5-9c.83 0 1.5-.67 1.5-1.5S16.33 8 15.5 8 14 8.67 14 9.5s.67 1.5 1.5 1.5zm-7 0c.83 0 1.5-.67 1.5-1.5S9.33 8 8.5 8 7 8.67 7 9.5 7.67 11 8.5 11zm3.5 6.5c2.33 0 4.31-1.46 5.11-3.5H6.89c.8 2.04 2.78 3.5 5.11 3.5z\"\n },\n document: {\n path: \"M5,20H19V18H5M19,9H15V3H9V9H5L12,16L19,9Z\"\n },\n pencil: {\n path: \"M20.71,7.04C21.1,6.65 21.1,6 20.71,5.63L18.37,3.29C18,2.9 17.35,2.9 16.96,3.29L15.12,5.12L18.87,8.87M3,17.25V21H6.75L17.81,9.93L14.06,6.18L3,17.25Z\"\n },\n checkmark: {\n path: \"M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z\"\n },\n \"double-checkmark\": {\n path: \"M18 7l-1.41-1.41-6.34 6.34 1.41 1.41L18 7zm4.24-1.41L11.66 16.17 7.48 12l-1.41 1.41L11.66 19l12-12-1.42-1.41zM.41 13.41L6 19l1.41-1.41L1.83 12 .41 13.41z\"\n },\n eye: {\n path: \"M12,9A3,3 0 0,0 9,12A3,3 0 0,0 12,15A3,3 0 0,0 15,12A3,3 0 0,0 12,9M12,17A5,5 0 0,1 7,12A5,5 0 0,1 12,7A5,5 0 0,1 17,12A5,5 0 0,1 12,17M12,4.5C7,4.5 2.73,7.61 1,12C2.73,16.39 7,19.5 12,19.5C17,19.5 21.27,16.39 23,12C21.27,7.61 17,4.5 12,4.5Z\"\n },\n dropdown: {\n path: \"M7.41,8.58L12,13.17L16.59,8.58L18,10L12,16L6,10L7.41,8.58Z\"\n },\n deleted: {\n path: \"M12,2A10,10 0 0,1 22,12A10,10 0 0,1 12,22A10,10 0 0,1 2,12A10,10 0 0,1 12,2M12,4A8,8 0 0,0 4,12C4,13.85 4.63,15.55 5.68,16.91L16.91,5.68C15.55,4.63 13.85,4 12,4M12,20A8,8 0 0,0 20,12C20,10.15 19.37,8.45 18.32,7.09L7.09,18.32C8.45,19.37 10.15,20 12,20Z\"\n },\n microphone: {\n size: \"large\",\n path: \"M432.8,216.4v39.2c0,45.2-15.3,84.3-45.2,118.4c-29.8,33.2-67.3,52.8-111.6,57.9v40.9h78.4c5.1,0,10.2,1.7,13.6,6c4.3,4.3,6,8.5,6,13.6c0,5.1-1.7,10.2-6,13.6c-4.3,4.3-8.5,6-13.6,6H157.6c-5.1,0-10.2-1.7-13.6-6c-4.3-4.3-6-8.5-6-13.6c0-5.1,1.7-10.2,6-13.6c4.3-4.3,8.5-6,13.6-6H236v-40.9c-44.3-5.1-81.8-23.9-111.6-57.9s-45.2-73.3-45.2-118.4v-39.2c0-5.1,1.7-10.2,6-13.6c4.3-4.3,8.5-6,13.6-6s10.2,1.7,13.6,6c4.3,4.3,6,8.5,6,13.6v39.2c0,37.5,13.6,70.7,40,97.1s59.6,40,97.1,40s70.7-13.6,97.1-40c26.4-26.4,40-59.6,40-97.1v-39.2c0-5.1,1.7-10.2,6-13.6c4.3-4.3,8.5-6,13.6-6c5.1,0,10.2,1.7,13.6,6C430.2,206.2,432.8,211.3,432.8,216.4z M353.5,98v157.6c0,27.3-9.4,50.3-29,69c-19.6,19.6-42.6,29-69,29s-50.3-9.4-69-29c-19.6-19.6-29-42.6-29-69V98c0-27.3,9.4-50.3,29-69c19.6-19.6,42.6-29,69-29s50.3,9.4,69,29C344.2,47.7,353.5,71.6,353.5,98z\"\n },\n \"audio-play\": {\n size: \"medium\",\n path: \"M43.331,21.237L7.233,0.397c-0.917-0.529-2.044-0.529-2.96,0c-0.916,0.528-1.48,1.505-1.48,2.563v41.684 c0,1.058,0.564,2.035,1.48,2.563c0.458,0.268,0.969,0.397,1.48,0.397c0.511,0,1.022-0.133,1.48-0.397l36.098-20.84 c0.918-0.529,1.479-1.506,1.479-2.564S44.247,21.767,43.331,21.237z\"\n },\n \"audio-pause\": {\n size: \"medium\",\n path: \"M17.991,40.976c0,3.662-2.969,6.631-6.631,6.631l0,0c-3.662,0-6.631-2.969-6.631-6.631V6.631C4.729,2.969,7.698,0,11.36,0l0,0c3.662,0,6.631,2.969,6.631,6.631V40.976z\",\n path2: \"M42.877,40.976c0,3.662-2.969,6.631-6.631,6.631l0,0c-3.662,0-6.631-2.969-6.631-6.631V6.631C29.616,2.969,32.585,0,36.246,0l0,0c3.662,0,6.631,2.969,6.631,6.631V40.976z\"\n }\n }\n };\n },\n computed: {\n svgId() {\n const param = this.param ? \"-\" + this.param : \"\";\n return `vac-icon-${this.name}${param}`;\n },\n size() {\n const item = this.svgItem[this.name];\n if (item.size === \"large\")\n return 512;\n else if (item.size === \"medium\")\n return 48;\n else\n return 24;\n }\n }\n};\nconst _hoisted_1$p = [\"viewBox\"];\nconst _hoisted_2$m = [\"id\", \"d\"];\nconst _hoisted_3$i = [\"id\", \"d\"];\nfunction _sfc_render$p(_ctx, _cache, $props, $setup, $data, $options) {\n return openBlock(), createElementBlock(\"svg\", {\n xmlns: \"http://www.w3.org/2000/svg\",\n \"xmlns:xlink\": \"http://www.w3.org/1999/xlink\",\n version: \"1.1\",\n width: \"24\",\n height: \"24\",\n viewBox: `0 0 ${$options.size} ${$options.size}`\n }, [\n createBaseVNode(\"path\", {\n id: $options.svgId,\n d: $data.svgItem[$props.name].path\n }, null, 8, _hoisted_2$m),\n $data.svgItem[$props.name].path2 ? (openBlock(), createElementBlock(\"path\", {\n key: 0,\n id: $options.svgId,\n d: $data.svgItem[$props.name].path2\n }, null, 8, _hoisted_3$i)) : createCommentVNode(\"\", true)\n ], 8, _hoisted_1$p);\n}\nvar SvgIcon = /* @__PURE__ */ _export_sfc(_sfc_main$p, [[\"render\", _sfc_render$p]]);\nconst _sfc_main$o = {\n name: \"RoomsSearch\",\n components: { SvgIcon },\n props: {\n textMessages: { type: Object, required: true },\n showSearch: { type: Boolean, required: true },\n showAddRoom: { type: Boolean, required: true },\n rooms: { type: Array, required: true },\n loadingRooms: { type: Boolean, required: true }\n },\n emits: [\"search-room\", \"add-room\"],\n computed: {\n showSearchBar() {\n return this.showSearch || this.showAddRoom;\n }\n }\n};\nconst _hoisted_1$o = {\n key: 0,\n class: \"vac-icon-search\"\n};\nconst _hoisted_2$l = [\"placeholder\"];\nfunction _sfc_render$o(_ctx, _cache, $props, $setup, $data, $options) {\n const _component_svg_icon = resolveComponent(\"svg-icon\");\n return openBlock(), createElementBlock(\"div\", {\n class: normalizeClass({\n \"vac-box-search\": $options.showSearchBar,\n \"vac-box-empty\": !$options.showSearchBar\n })\n }, [\n $props.showSearch ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [\n !$props.loadingRooms && $props.rooms.length ? (openBlock(), createElementBlock(\"div\", _hoisted_1$o, [\n renderSlot(_ctx.$slots, \"search-icon\", {}, () => [\n createVNode(_component_svg_icon, { name: \"search\" })\n ])\n ])) : createCommentVNode(\"\", true),\n !$props.loadingRooms && $props.rooms.length ? (openBlock(), createElementBlock(\"input\", {\n key: 1,\n type: \"search\",\n placeholder: $props.textMessages.SEARCH,\n autocomplete: \"off\",\n class: \"vac-input\",\n onInput: _cache[0] || (_cache[0] = ($event) => _ctx.$emit(\"search-room\", $event))\n }, null, 40, _hoisted_2$l)) : createCommentVNode(\"\", true)\n ], 64)) : createCommentVNode(\"\", true),\n $props.showAddRoom ? (openBlock(), createElementBlock(\"div\", {\n key: 1,\n class: \"vac-svg-button vac-add-icon\",\n onClick: _cache[1] || (_cache[1] = ($event) => _ctx.$emit(\"add-room\"))\n }, [\n renderSlot(_ctx.$slots, \"add-icon\", {}, () => [\n createVNode(_component_svg_icon, { name: \"add\" })\n ])\n ])) : createCommentVNode(\"\", true)\n ], 2);\n}\nvar RoomsSearch = /* @__PURE__ */ _export_sfc(_sfc_main$o, [[\"render\", _sfc_render$o]]);\nvar linkify = {};\nvar _class$4 = {};\n_class$4.__esModule = true;\n_class$4.inherits = inherits;\nfunction inherits(parent, child) {\n var props = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};\n var extended = Object.create(parent.prototype);\n for (var p2 in props) {\n extended[p2] = props[p2];\n }\n extended.constructor = child;\n child.prototype = extended;\n return child;\n}\nvar options$1 = {};\noptions$1.__esModule = true;\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function(obj) {\n return typeof obj;\n} : function(obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\nvar defaults = {\n defaultProtocol: \"http\",\n events: null,\n format: noop$1,\n formatHref: noop$1,\n nl2br: false,\n tagName: \"a\",\n target: typeToTarget,\n validate: true,\n ignoreTags: [],\n attributes: null,\n className: \"linkified\"\n};\noptions$1.defaults = defaults;\noptions$1.Options = Options;\noptions$1.contains = contains;\nfunction Options(opts) {\n opts = opts || {};\n this.defaultProtocol = opts.hasOwnProperty(\"defaultProtocol\") ? opts.defaultProtocol : defaults.defaultProtocol;\n this.events = opts.hasOwnProperty(\"events\") ? opts.events : defaults.events;\n this.format = opts.hasOwnProperty(\"format\") ? opts.format : defaults.format;\n this.formatHref = opts.hasOwnProperty(\"formatHref\") ? opts.formatHref : defaults.formatHref;\n this.nl2br = opts.hasOwnProperty(\"nl2br\") ? opts.nl2br : defaults.nl2br;\n this.tagName = opts.hasOwnProperty(\"tagName\") ? opts.tagName : defaults.tagName;\n this.target = opts.hasOwnProperty(\"target\") ? opts.target : defaults.target;\n this.validate = opts.hasOwnProperty(\"validate\") ? opts.validate : defaults.validate;\n this.ignoreTags = [];\n this.attributes = opts.attributes || opts.linkAttributes || defaults.attributes;\n this.className = opts.hasOwnProperty(\"className\") ? opts.className : opts.linkClass || defaults.className;\n var ignoredTags = opts.hasOwnProperty(\"ignoreTags\") ? opts.ignoreTags : defaults.ignoreTags;\n for (var i = 0; i < ignoredTags.length; i++) {\n this.ignoreTags.push(ignoredTags[i].toUpperCase());\n }\n}\nOptions.prototype = {\n resolve: function resolve2(token) {\n var href = token.toHref(this.defaultProtocol);\n return {\n formatted: this.get(\"format\", token.toString(), token),\n formattedHref: this.get(\"formatHref\", href, token),\n tagName: this.get(\"tagName\", href, token),\n className: this.get(\"className\", href, token),\n target: this.get(\"target\", href, token),\n events: this.getObject(\"events\", href, token),\n attributes: this.getObject(\"attributes\", href, token)\n };\n },\n check: function check(token) {\n return this.get(\"validate\", token.toString(), token);\n },\n get: function get(key, operator, token) {\n var optionValue = void 0, option = this[key];\n if (!option) {\n return option;\n }\n switch (typeof option === \"undefined\" ? \"undefined\" : _typeof(option)) {\n case \"function\":\n return option(operator, token.type);\n case \"object\":\n optionValue = option.hasOwnProperty(token.type) ? option[token.type] : defaults[key];\n return typeof optionValue === \"function\" ? optionValue(operator, token.type) : optionValue;\n }\n return option;\n },\n getObject: function getObject(key, operator, token) {\n var option = this[key];\n return typeof option === \"function\" ? option(operator, token.type) : option;\n }\n};\nfunction contains(arr, value) {\n for (var i = 0; i < arr.length; i++) {\n if (arr[i] === value) {\n return true;\n }\n }\n return false;\n}\nfunction noop$1(val) {\n return val;\n}\nfunction typeToTarget(href, type) {\n return type === \"url\" ? \"_blank\" : null;\n}\nvar scanner$1 = {};\nvar state = {};\nstate.__esModule = true;\nstate.stateify = state.TokenState = state.CharacterState = void 0;\nvar _class$3 = _class$4;\nfunction createStateClass() {\n return function(tClass) {\n this.j = [];\n this.T = tClass || null;\n };\n}\nvar BaseState = createStateClass();\nBaseState.prototype = {\n defaultTransition: false,\n on: function on(symbol, state2) {\n if (symbol instanceof Array) {\n for (var i = 0; i < symbol.length; i++) {\n this.j.push([symbol[i], state2]);\n }\n return this;\n }\n this.j.push([symbol, state2]);\n return this;\n },\n next: function next(item) {\n for (var i = 0; i < this.j.length; i++) {\n var jump2 = this.j[i];\n var symbol = jump2[0];\n var state2 = jump2[1];\n if (this.test(item, symbol)) {\n return state2;\n }\n }\n return this.defaultTransition;\n },\n accepts: function accepts() {\n return !!this.T;\n },\n test: function test(item, symbol) {\n return item === symbol;\n },\n emit: function emit() {\n return this.T;\n }\n};\nvar CharacterState = (0, _class$3.inherits)(BaseState, createStateClass(), {\n test: function test2(character, charOrRegExp) {\n return character === charOrRegExp || charOrRegExp instanceof RegExp && charOrRegExp.test(character);\n }\n});\nvar TokenState = (0, _class$3.inherits)(BaseState, createStateClass(), {\n jump: function jump(token) {\n var tClass = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;\n var state2 = this.next(new token(\"\"));\n if (state2 === this.defaultTransition) {\n state2 = new this.constructor(tClass);\n this.on(token, state2);\n } else if (tClass) {\n state2.T = tClass;\n }\n return state2;\n },\n test: function test3(token, tokenClass) {\n return token instanceof tokenClass;\n }\n});\nfunction stateify(str, start2, endToken, defaultToken) {\n var i = 0, len = str.length, state2 = start2, newStates = [], nextState = void 0;\n while (i < len && (nextState = state2.next(str[i]))) {\n state2 = nextState;\n i++;\n }\n if (i >= len) {\n return [];\n }\n while (i < len - 1) {\n nextState = new CharacterState(defaultToken);\n newStates.push(nextState);\n state2.on(str[i], nextState);\n state2 = nextState;\n i++;\n }\n nextState = new CharacterState(endToken);\n newStates.push(nextState);\n state2.on(str[len - 1], nextState);\n return newStates;\n}\nstate.CharacterState = CharacterState;\nstate.TokenState = TokenState;\nstate.stateify = stateify;\nvar text$1 = {};\nvar createTokenClass$1 = {};\ncreateTokenClass$1.__esModule = true;\nfunction createTokenClass() {\n return function(value) {\n if (value) {\n this.v = value;\n }\n };\n}\ncreateTokenClass$1.createTokenClass = createTokenClass;\ntext$1.__esModule = true;\ntext$1.AMPERSAND = text$1.CLOSEPAREN = text$1.CLOSEANGLEBRACKET = text$1.CLOSEBRACKET = text$1.CLOSEBRACE = text$1.OPENPAREN = text$1.OPENANGLEBRACKET = text$1.OPENBRACKET = text$1.OPENBRACE = text$1.WS = text$1.TLD = text$1.SYM = text$1.UNDERSCORE = text$1.SLASH = text$1.MAILTO = text$1.PROTOCOL = text$1.QUERY = text$1.POUND = text$1.PLUS = text$1.NUM = text$1.NL = text$1.LOCALHOST = text$1.PUNCTUATION = text$1.DOT = text$1.COLON = text$1.AT = text$1.DOMAIN = text$1.Base = void 0;\nvar _createTokenClass$1 = createTokenClass$1;\nvar _class$2 = _class$4;\nvar TextToken = (0, _createTokenClass$1.createTokenClass)();\nTextToken.prototype = {\n toString: function toString() {\n return this.v + \"\";\n }\n};\nfunction inheritsToken(value) {\n var props = value ? { v: value } : {};\n return (0, _class$2.inherits)(TextToken, (0, _createTokenClass$1.createTokenClass)(), props);\n}\nvar DOMAIN = inheritsToken();\nvar AT = inheritsToken(\"@\");\nvar COLON = inheritsToken(\":\");\nvar DOT = inheritsToken(\".\");\nvar PUNCTUATION = inheritsToken();\nvar LOCALHOST = inheritsToken();\nvar NL$1 = inheritsToken(\"\\n\");\nvar NUM = inheritsToken();\nvar PLUS = inheritsToken(\"+\");\nvar POUND = inheritsToken(\"#\");\nvar PROTOCOL = inheritsToken();\nvar MAILTO = inheritsToken(\"mailto:\");\nvar QUERY = inheritsToken(\"?\");\nvar SLASH = inheritsToken(\"/\");\nvar UNDERSCORE = inheritsToken(\"_\");\nvar SYM = inheritsToken();\nvar TLD = inheritsToken();\nvar WS = inheritsToken();\nvar OPENBRACE = inheritsToken(\"{\");\nvar OPENBRACKET = inheritsToken(\"[\");\nvar OPENANGLEBRACKET = inheritsToken(\"<\");\nvar OPENPAREN = inheritsToken(\"(\");\nvar CLOSEBRACE = inheritsToken(\"}\");\nvar CLOSEBRACKET = inheritsToken(\"]\");\nvar CLOSEANGLEBRACKET = inheritsToken(\">\");\nvar CLOSEPAREN = inheritsToken(\")\");\nvar AMPERSAND = inheritsToken(\"&\");\ntext$1.Base = TextToken;\ntext$1.DOMAIN = DOMAIN;\ntext$1.AT = AT;\ntext$1.COLON = COLON;\ntext$1.DOT = DOT;\ntext$1.PUNCTUATION = PUNCTUATION;\ntext$1.LOCALHOST = LOCALHOST;\ntext$1.NL = NL$1;\ntext$1.NUM = NUM;\ntext$1.PLUS = PLUS;\ntext$1.POUND = POUND;\ntext$1.QUERY = QUERY;\ntext$1.PROTOCOL = PROTOCOL;\ntext$1.MAILTO = MAILTO;\ntext$1.SLASH = SLASH;\ntext$1.UNDERSCORE = UNDERSCORE;\ntext$1.SYM = SYM;\ntext$1.TLD = TLD;\ntext$1.WS = WS;\ntext$1.OPENBRACE = OPENBRACE;\ntext$1.OPENBRACKET = OPENBRACKET;\ntext$1.OPENANGLEBRACKET = OPENANGLEBRACKET;\ntext$1.OPENPAREN = OPENPAREN;\ntext$1.CLOSEBRACE = CLOSEBRACE;\ntext$1.CLOSEBRACKET = CLOSEBRACKET;\ntext$1.CLOSEANGLEBRACKET = CLOSEANGLEBRACKET;\ntext$1.CLOSEPAREN = CLOSEPAREN;\ntext$1.AMPERSAND = AMPERSAND;\nscanner$1.__esModule = true;\nscanner$1.start = scanner$1.run = scanner$1.TOKENS = scanner$1.State = void 0;\nvar _state$1 = state;\nvar _text$2 = text$1;\nvar TOKENS = _interopRequireWildcard$2(_text$2);\nfunction _interopRequireWildcard$2(obj) {\n if (obj && obj.__esModule) {\n return obj;\n } else {\n var newObj = {};\n if (obj != null) {\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key))\n newObj[key] = obj[key];\n }\n }\n newObj.default = obj;\n return newObj;\n }\n}\nvar tlds = \"aaa|aarp|abarth|abb|abbott|abbvie|abc|able|abogado|abudhabi|ac|academy|accenture|accountant|accountants|aco|active|actor|ad|adac|ads|adult|ae|aeg|aero|aetna|af|afamilycompany|afl|africa|ag|agakhan|agency|ai|aig|aigo|airbus|airforce|airtel|akdn|al|alfaromeo|alibaba|alipay|allfinanz|allstate|ally|alsace|alstom|am|americanexpress|americanfamily|amex|amfam|amica|amsterdam|analytics|android|anquan|anz|ao|aol|apartments|app|apple|aq|aquarelle|ar|arab|aramco|archi|army|arpa|art|arte|as|asda|asia|associates|at|athleta|attorney|au|auction|audi|audible|audio|auspost|author|auto|autos|avianca|aw|aws|ax|axa|az|azure|ba|baby|baidu|banamex|bananarepublic|band|bank|bar|barcelona|barclaycard|barclays|barefoot|bargains|baseball|basketball|bauhaus|bayern|bb|bbc|bbt|bbva|bcg|bcn|bd|be|beats|beauty|beer|bentley|berlin|best|bestbuy|bet|bf|bg|bh|bharti|bi|bible|bid|bike|bing|bingo|bio|biz|bj|black|blackfriday|blanco|blockbuster|blog|bloomberg|blue|bm|bms|bmw|bn|bnl|bnpparibas|bo|boats|boehringer|bofa|bom|bond|boo|book|booking|boots|bosch|bostik|boston|bot|boutique|box|br|bradesco|bridgestone|broadway|broker|brother|brussels|bs|bt|budapest|bugatti|build|builders|business|buy|buzz|bv|bw|by|bz|bzh|ca|cab|cafe|cal|call|calvinklein|cam|camera|camp|cancerresearch|canon|capetown|capital|capitalone|car|caravan|cards|care|career|careers|cars|cartier|casa|case|caseih|cash|casino|cat|catering|catholic|cba|cbn|cbre|cbs|cc|cd|ceb|center|ceo|cern|cf|cfa|cfd|cg|ch|chanel|channel|chase|chat|cheap|chintai|chloe|christmas|chrome|chrysler|church|ci|cipriani|circle|cisco|citadel|citi|citic|city|cityeats|ck|cl|claims|cleaning|click|clinic|clinique|clothing|cloud|club|clubmed|cm|cn|co|coach|codes|coffee|college|cologne|com|comcast|commbank|community|company|compare|computer|comsec|condos|construction|consulting|contact|contractors|cooking|cookingchannel|cool|coop|corsica|country|coupon|coupons|courses|cr|credit|creditcard|creditunion|cricket|crown|crs|cruise|cruises|csc|cu|cuisinella|cv|cw|cx|cy|cymru|cyou|cz|dabur|dad|dance|data|date|dating|datsun|day|dclk|dds|de|deal|dealer|deals|degree|delivery|dell|deloitte|delta|democrat|dental|dentist|desi|design|dev|dhl|diamonds|diet|digital|direct|directory|discount|discover|dish|diy|dj|dk|dm|dnp|do|docs|doctor|dodge|dog|doha|domains|dot|download|drive|dtv|dubai|duck|dunlop|duns|dupont|durban|dvag|dvr|dz|earth|eat|ec|eco|edeka|edu|education|ee|eg|email|emerck|energy|engineer|engineering|enterprises|epost|epson|equipment|er|ericsson|erni|es|esq|estate|esurance|et|etisalat|eu|eurovision|eus|events|everbank|exchange|expert|exposed|express|extraspace|fage|fail|fairwinds|faith|family|fan|fans|farm|farmers|fashion|fast|fedex|feedback|ferrari|ferrero|fi|fiat|fidelity|fido|film|final|finance|financial|fire|firestone|firmdale|fish|fishing|fit|fitness|fj|fk|flickr|flights|flir|florist|flowers|fly|fm|fo|foo|food|foodnetwork|football|ford|forex|forsale|forum|foundation|fox|fr|free|fresenius|frl|frogans|frontdoor|frontier|ftr|fujitsu|fujixerox|fun|fund|furniture|futbol|fyi|ga|gal|gallery|gallo|gallup|game|games|gap|garden|gb|gbiz|gd|gdn|ge|gea|gent|genting|george|gf|gg|ggee|gh|gi|gift|gifts|gives|giving|gl|glade|glass|gle|global|globo|gm|gmail|gmbh|gmo|gmx|gn|godaddy|gold|goldpoint|golf|goo|goodhands|goodyear|goog|google|gop|got|gov|gp|gq|gr|grainger|graphics|gratis|green|gripe|grocery|group|gs|gt|gu|guardian|gucci|guge|guide|guitars|guru|gw|gy|hair|hamburg|hangout|haus|hbo|hdfc|hdfcbank|health|healthcare|help|helsinki|here|hermes|hgtv|hiphop|hisamitsu|hitachi|hiv|hk|hkt|hm|hn|hockey|holdings|holiday|homedepot|homegoods|homes|homesense|honda|honeywell|horse|hospital|host|hosting|hot|hoteles|hotels|hotmail|house|how|hr|hsbc|ht|htc|hu|hughes|hyatt|hyundai|ibm|icbc|ice|icu|id|ie|ieee|ifm|ikano|il|im|imamat|imdb|immo|immobilien|in|industries|infiniti|info|ing|ink|institute|insurance|insure|int|intel|international|intuit|investments|io|ipiranga|iq|ir|irish|is|iselect|ismaili|ist|istanbul|it|itau|itv|iveco|iwc|jaguar|java|jcb|jcp|je|jeep|jetzt|jewelry|jio|jlc|jll|jm|jmp|jnj|jo|jobs|joburg|jot|joy|jp|jpmorgan|jprs|juegos|juniper|kaufen|kddi|ke|kerryhotels|kerrylogistics|kerryproperties|kfh|kg|kh|ki|kia|kim|kinder|kindle|kitchen|kiwi|km|kn|koeln|komatsu|kosher|kp|kpmg|kpn|kr|krd|kred|kuokgroup|kw|ky|kyoto|kz|la|lacaixa|ladbrokes|lamborghini|lamer|lancaster|lancia|lancome|land|landrover|lanxess|lasalle|lat|latino|latrobe|law|lawyer|lb|lc|lds|lease|leclerc|lefrak|legal|lego|lexus|lgbt|li|liaison|lidl|life|lifeinsurance|lifestyle|lighting|like|lilly|limited|limo|lincoln|linde|link|lipsy|live|living|lixil|lk|loan|loans|locker|locus|loft|lol|london|lotte|lotto|love|lpl|lplfinancial|lr|ls|lt|ltd|ltda|lu|lundbeck|lupin|luxe|luxury|lv|ly|ma|macys|madrid|maif|maison|makeup|man|management|mango|map|market|marketing|markets|marriott|marshalls|maserati|mattel|mba|mc|mckinsey|md|me|med|media|meet|melbourne|meme|memorial|men|menu|meo|merckmsd|metlife|mg|mh|miami|microsoft|mil|mini|mint|mit|mitsubishi|mk|ml|mlb|mls|mm|mma|mn|mo|mobi|mobile|mobily|moda|moe|moi|mom|monash|money|monster|mopar|mormon|mortgage|moscow|moto|motorcycles|mov|movie|movistar|mp|mq|mr|ms|msd|mt|mtn|mtr|mu|museum|mutual|mv|mw|mx|my|mz|na|nab|nadex|nagoya|name|nationwide|natura|navy|nba|nc|ne|nec|net|netbank|netflix|network|neustar|new|newholland|news|next|nextdirect|nexus|nf|nfl|ng|ngo|nhk|ni|nico|nike|nikon|ninja|nissan|nissay|nl|no|nokia|northwesternmutual|norton|now|nowruz|nowtv|np|nr|nra|nrw|ntt|nu|nyc|nz|obi|observer|off|office|okinawa|olayan|olayangroup|oldnavy|ollo|om|omega|one|ong|onl|online|onyourside|ooo|open|oracle|orange|org|organic|origins|osaka|otsuka|ott|ovh|pa|page|panasonic|panerai|paris|pars|partners|parts|party|passagens|pay|pccw|pe|pet|pf|pfizer|pg|ph|pharmacy|phd|philips|phone|photo|photography|photos|physio|piaget|pics|pictet|pictures|pid|pin|ping|pink|pioneer|pizza|pk|pl|place|play|playstation|plumbing|plus|pm|pn|pnc|pohl|poker|politie|porn|post|pr|pramerica|praxi|press|prime|pro|prod|productions|prof|progressive|promo|properties|property|protection|pru|prudential|ps|pt|pub|pw|pwc|py|qa|qpon|quebec|quest|qvc|racing|radio|raid|re|read|realestate|realtor|realty|recipes|red|redstone|redumbrella|rehab|reise|reisen|reit|reliance|ren|rent|rentals|repair|report|republican|rest|restaurant|review|reviews|rexroth|rich|richardli|ricoh|rightathome|ril|rio|rip|rmit|ro|rocher|rocks|rodeo|rogers|room|rs|rsvp|ru|rugby|ruhr|run|rw|rwe|ryukyu|sa|saarland|safe|safety|sakura|sale|salon|samsclub|samsung|sandvik|sandvikcoromant|sanofi|sap|sapo|sarl|sas|save|saxo|sb|sbi|sbs|sc|sca|scb|schaeffler|schmidt|scholarships|school|schule|schwarz|science|scjohnson|scor|scot|sd|se|search|seat|secure|security|seek|select|sener|services|ses|seven|sew|sex|sexy|sfr|sg|sh|shangrila|sharp|shaw|shell|shia|shiksha|shoes|shop|shopping|shouji|show|showtime|shriram|si|silk|sina|singles|site|sj|sk|ski|skin|sky|skype|sl|sling|sm|smart|smile|sn|sncf|so|soccer|social|softbank|software|sohu|solar|solutions|song|sony|soy|space|spiegel|spot|spreadbetting|sr|srl|srt|st|stada|staples|star|starhub|statebank|statefarm|statoil|stc|stcgroup|stockholm|storage|store|stream|studio|study|style|su|sucks|supplies|supply|support|surf|surgery|suzuki|sv|swatch|swiftcover|swiss|sx|sy|sydney|symantec|systems|sz|tab|taipei|talk|taobao|target|tatamotors|tatar|tattoo|tax|taxi|tc|tci|td|tdk|team|tech|technology|tel|telecity|telefonica|temasek|tennis|teva|tf|tg|th|thd|theater|theatre|tiaa|tickets|tienda|tiffany|tips|tires|tirol|tj|tjmaxx|tjx|tk|tkmaxx|tl|tm|tmall|tn|to|today|tokyo|tools|top|toray|toshiba|total|tours|town|toyota|toys|tr|trade|trading|training|travel|travelchannel|travelers|travelersinsurance|trust|trv|tt|tube|tui|tunes|tushu|tv|tvs|tw|tz|ua|ubank|ubs|uconnect|ug|uk|unicom|university|uno|uol|ups|us|uy|uz|va|vacations|vana|vanguard|vc|ve|vegas|ventures|verisign|versicherung|vet|vg|vi|viajes|video|vig|viking|villas|vin|vip|virgin|visa|vision|vista|vistaprint|viva|vivo|vlaanderen|vn|vodka|volkswagen|volvo|vote|voting|voto|voyage|vu|vuelos|wales|walmart|walter|wang|wanggou|warman|watch|watches|weather|weatherchannel|webcam|weber|website|wed|wedding|weibo|weir|wf|whoswho|wien|wiki|williamhill|win|windows|wine|winners|wme|wolterskluwer|woodside|work|works|world|wow|ws|wtc|wtf|xbox|xerox|xfinity|xihuan|xin|xn--11b4c3d|xn--1ck2e1b|xn--1qqw23a|xn--2scrj9c|xn--30rr7y|xn--3bst00m|xn--3ds443g|xn--3e0b707e|xn--3hcrj9c|xn--3oq18vl8pn36a|xn--3pxu8k|xn--42c2d9a|xn--45br5cyl|xn--45brj9c|xn--45q11c|xn--4gbrim|xn--54b7fta0cc|xn--55qw42g|xn--55qx5d|xn--5su34j936bgsg|xn--5tzm5g|xn--6frz82g|xn--6qq986b3xl|xn--80adxhks|xn--80ao21a|xn--80aqecdr1a|xn--80asehdb|xn--80aswg|xn--8y0a063a|xn--90a3ac|xn--90ae|xn--90ais|xn--9dbq2a|xn--9et52u|xn--9krt00a|xn--b4w605ferd|xn--bck1b9a5dre4c|xn--c1avg|xn--c2br7g|xn--cck2b3b|xn--cg4bki|xn--clchc0ea0b2g2a9gcd|xn--czr694b|xn--czrs0t|xn--czru2d|xn--d1acj3b|xn--d1alf|xn--e1a4c|xn--eckvdtc9d|xn--efvy88h|xn--estv75g|xn--fct429k|xn--fhbei|xn--fiq228c5hs|xn--fiq64b|xn--fiqs8s|xn--fiqz9s|xn--fjq720a|xn--flw351e|xn--fpcrj9c3d|xn--fzc2c9e2c|xn--fzys8d69uvgm|xn--g2xx48c|xn--gckr3f0f|xn--gecrj9c|xn--gk3at1e|xn--h2breg3eve|xn--h2brj9c|xn--h2brj9c8c|xn--hxt814e|xn--i1b6b1a6a2e|xn--imr513n|xn--io0a7i|xn--j1aef|xn--j1amh|xn--j6w193g|xn--jlq61u9w7b|xn--jvr189m|xn--kcrx77d1x4a|xn--kprw13d|xn--kpry57d|xn--kpu716f|xn--kput3i|xn--l1acc|xn--lgbbat1ad8j|xn--mgb9awbf|xn--mgba3a3ejt|xn--mgba3a4f16a|xn--mgba7c0bbn0a|xn--mgbaakc7dvf|xn--mgbaam7a8h|xn--mgbab2bd|xn--mgbai9azgqp6j|xn--mgbayh7gpa|xn--mgbb9fbpob|xn--mgbbh1a|xn--mgbbh1a71e|xn--mgbc0a9azcg|xn--mgbca7dzdo|xn--mgberp4a5d4ar|xn--mgbgu82a|xn--mgbi4ecexp|xn--mgbpl2fh|xn--mgbt3dhd|xn--mgbtx2b|xn--mgbx4cd0ab|xn--mix891f|xn--mk1bu44c|xn--mxtq1m|xn--ngbc5azd|xn--ngbe9e0a|xn--ngbrx|xn--node|xn--nqv7f|xn--nqv7fs00ema|xn--nyqy26a|xn--o3cw4h|xn--ogbpf8fl|xn--p1acf|xn--p1ai|xn--pbt977c|xn--pgbs0dh|xn--pssy2u|xn--q9jyb4c|xn--qcka1pmc|xn--qxam|xn--rhqv96g|xn--rovu88b|xn--rvc1e0am3e|xn--s9brj9c|xn--ses554g|xn--t60b56a|xn--tckwe|xn--tiq49xqyj|xn--unup4y|xn--vermgensberater-ctb|xn--vermgensberatung-pwb|xn--vhquv|xn--vuq861b|xn--w4r85el8fhu5dnra|xn--w4rs40l|xn--wgbh1c|xn--wgbl6a|xn--xhq521b|xn--xkc2al3hye2a|xn--xkc2dl3a5ee0h|xn--y9a3aq|xn--yfro4i67o|xn--ygbi2ammx|xn--zfr164b|xperia|xxx|xyz|yachts|yahoo|yamaxun|yandex|ye|yodobashi|yoga|yokohama|you|youtube|yt|yun|za|zappos|zara|zero|zip|zippo|zm|zone|zuerich|zw\".split(\"|\");\nvar NUMBERS = \"0123456789\".split(\"\");\nvar ALPHANUM = \"0123456789abcdefghijklmnopqrstuvwxyz\".split(\"\");\nvar WHITESPACE = [\" \", \"\\f\", \"\\r\", \"\t\", \"\\v\", \"\\xA0\", \"\\u1680\", \"\\u180E\"];\nvar domainStates = [];\nvar makeState$1 = function makeState(tokenClass) {\n return new _state$1.CharacterState(tokenClass);\n};\nvar S_START$1 = makeState$1();\nvar S_NUM = makeState$1(_text$2.NUM);\nvar S_DOMAIN$1 = makeState$1(_text$2.DOMAIN);\nvar S_DOMAIN_HYPHEN = makeState$1();\nvar S_WS = makeState$1(_text$2.WS);\nS_START$1.on(\"@\", makeState$1(_text$2.AT)).on(\".\", makeState$1(_text$2.DOT)).on(\"+\", makeState$1(_text$2.PLUS)).on(\"#\", makeState$1(_text$2.POUND)).on(\"?\", makeState$1(_text$2.QUERY)).on(\"/\", makeState$1(_text$2.SLASH)).on(\"_\", makeState$1(_text$2.UNDERSCORE)).on(\":\", makeState$1(_text$2.COLON)).on(\"{\", makeState$1(_text$2.OPENBRACE)).on(\"[\", makeState$1(_text$2.OPENBRACKET)).on(\"<\", makeState$1(_text$2.OPENANGLEBRACKET)).on(\"(\", makeState$1(_text$2.OPENPAREN)).on(\"}\", makeState$1(_text$2.CLOSEBRACE)).on(\"]\", makeState$1(_text$2.CLOSEBRACKET)).on(\">\", makeState$1(_text$2.CLOSEANGLEBRACKET)).on(\")\", makeState$1(_text$2.CLOSEPAREN)).on(\"&\", makeState$1(_text$2.AMPERSAND)).on([\",\", \";\", \"!\", '\"', \"'\"], makeState$1(_text$2.PUNCTUATION));\nS_START$1.on(\"\\n\", makeState$1(_text$2.NL)).on(WHITESPACE, S_WS);\nS_WS.on(WHITESPACE, S_WS);\nfor (var i = 0; i < tlds.length; i++) {\n var newStates = (0, _state$1.stateify)(tlds[i], S_START$1, _text$2.TLD, _text$2.DOMAIN);\n domainStates.push.apply(domainStates, newStates);\n}\nvar partialProtocolFileStates = (0, _state$1.stateify)(\"file\", S_START$1, _text$2.DOMAIN, _text$2.DOMAIN);\nvar partialProtocolFtpStates = (0, _state$1.stateify)(\"ftp\", S_START$1, _text$2.DOMAIN, _text$2.DOMAIN);\nvar partialProtocolHttpStates = (0, _state$1.stateify)(\"http\", S_START$1, _text$2.DOMAIN, _text$2.DOMAIN);\nvar partialProtocolMailtoStates = (0, _state$1.stateify)(\"mailto\", S_START$1, _text$2.DOMAIN, _text$2.DOMAIN);\ndomainStates.push.apply(domainStates, partialProtocolFileStates);\ndomainStates.push.apply(domainStates, partialProtocolFtpStates);\ndomainStates.push.apply(domainStates, partialProtocolHttpStates);\ndomainStates.push.apply(domainStates, partialProtocolMailtoStates);\nvar S_PROTOCOL_FILE = partialProtocolFileStates.pop();\nvar S_PROTOCOL_FTP = partialProtocolFtpStates.pop();\nvar S_PROTOCOL_HTTP = partialProtocolHttpStates.pop();\nvar S_MAILTO$1 = partialProtocolMailtoStates.pop();\nvar S_PROTOCOL_SECURE = makeState$1(_text$2.DOMAIN);\nvar S_FULL_PROTOCOL = makeState$1(_text$2.PROTOCOL);\nvar S_FULL_MAILTO = makeState$1(_text$2.MAILTO);\nS_PROTOCOL_FTP.on(\"s\", S_PROTOCOL_SECURE).on(\":\", S_FULL_PROTOCOL);\nS_PROTOCOL_HTTP.on(\"s\", S_PROTOCOL_SECURE).on(\":\", S_FULL_PROTOCOL);\ndomainStates.push(S_PROTOCOL_SECURE);\nS_PROTOCOL_FILE.on(\":\", S_FULL_PROTOCOL);\nS_PROTOCOL_SECURE.on(\":\", S_FULL_PROTOCOL);\nS_MAILTO$1.on(\":\", S_FULL_MAILTO);\nvar partialLocalhostStates = (0, _state$1.stateify)(\"localhost\", S_START$1, _text$2.LOCALHOST, _text$2.DOMAIN);\ndomainStates.push.apply(domainStates, partialLocalhostStates);\nS_START$1.on(NUMBERS, S_NUM);\nS_NUM.on(\"-\", S_DOMAIN_HYPHEN).on(NUMBERS, S_NUM).on(ALPHANUM, S_DOMAIN$1);\nS_DOMAIN$1.on(\"-\", S_DOMAIN_HYPHEN).on(ALPHANUM, S_DOMAIN$1);\nfor (var _i = 0; _i < domainStates.length; _i++) {\n domainStates[_i].on(\"-\", S_DOMAIN_HYPHEN).on(ALPHANUM, S_DOMAIN$1);\n}\nS_DOMAIN_HYPHEN.on(\"-\", S_DOMAIN_HYPHEN).on(NUMBERS, S_DOMAIN$1).on(ALPHANUM, S_DOMAIN$1);\nS_START$1.defaultTransition = makeState$1(_text$2.SYM);\nvar run$2 = function run(str) {\n var lowerStr = str.replace(/[A-Z]/g, function(c) {\n return c.toLowerCase();\n });\n var len = str.length;\n var tokens = [];\n var cursor = 0;\n while (cursor < len) {\n var state2 = S_START$1;\n var nextState = null;\n var tokenLength = 0;\n var latestAccepting = null;\n var sinceAccepts = -1;\n while (cursor < len && (nextState = state2.next(lowerStr[cursor]))) {\n state2 = nextState;\n if (state2.accepts()) {\n sinceAccepts = 0;\n latestAccepting = state2;\n } else if (sinceAccepts >= 0) {\n sinceAccepts++;\n }\n tokenLength++;\n cursor++;\n }\n if (sinceAccepts < 0) {\n continue;\n }\n cursor -= sinceAccepts;\n tokenLength -= sinceAccepts;\n var TOKEN = latestAccepting.emit();\n tokens.push(new TOKEN(str.substr(cursor - tokenLength, tokenLength)));\n }\n return tokens;\n};\nvar start = S_START$1;\nscanner$1.State = _state$1.CharacterState;\nscanner$1.TOKENS = TOKENS;\nscanner$1.run = run$2;\nscanner$1.start = start;\nvar parser$1 = {};\nvar multi = {};\nmulti.__esModule = true;\nmulti.URL = multi.TEXT = multi.NL = multi.EMAIL = multi.MAILTOEMAIL = multi.Base = void 0;\nvar _createTokenClass = createTokenClass$1;\nvar _class$1 = _class$4;\nvar _text$1 = text$1;\nfunction isDomainToken(token) {\n return token instanceof _text$1.DOMAIN || token instanceof _text$1.TLD;\n}\nvar MultiToken = (0, _createTokenClass.createTokenClass)();\nMultiToken.prototype = {\n type: \"token\",\n isLink: false,\n toString: function toString2() {\n var result = [];\n for (var i = 0; i < this.v.length; i++) {\n result.push(this.v[i].toString());\n }\n return result.join(\"\");\n },\n toHref: function toHref() {\n return this.toString();\n },\n toObject: function toObject() {\n var protocol = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : \"http\";\n return {\n type: this.type,\n value: this.toString(),\n href: this.toHref(protocol)\n };\n }\n};\nvar MAILTOEMAIL = (0, _class$1.inherits)(MultiToken, (0, _createTokenClass.createTokenClass)(), {\n type: \"email\",\n isLink: true\n});\nvar EMAIL = (0, _class$1.inherits)(MultiToken, (0, _createTokenClass.createTokenClass)(), {\n type: \"email\",\n isLink: true,\n toHref: function toHref2() {\n return \"mailto:\" + this.toString();\n }\n});\nvar TEXT = (0, _class$1.inherits)(MultiToken, (0, _createTokenClass.createTokenClass)(), { type: \"text\" });\nvar NL = (0, _class$1.inherits)(MultiToken, (0, _createTokenClass.createTokenClass)(), { type: \"nl\" });\nvar URL$1 = (0, _class$1.inherits)(MultiToken, (0, _createTokenClass.createTokenClass)(), {\n type: \"url\",\n isLink: true,\n toHref: function toHref3() {\n var protocol = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : \"http\";\n var hasProtocol2 = false;\n var hasSlashSlash = false;\n var tokens = this.v;\n var result = [];\n var i = 0;\n while (tokens[i] instanceof _text$1.PROTOCOL) {\n hasProtocol2 = true;\n result.push(tokens[i].toString().toLowerCase());\n i++;\n }\n while (tokens[i] instanceof _text$1.SLASH) {\n hasSlashSlash = true;\n result.push(tokens[i].toString());\n i++;\n }\n while (isDomainToken(tokens[i])) {\n result.push(tokens[i].toString().toLowerCase());\n i++;\n }\n for (; i < tokens.length; i++) {\n result.push(tokens[i].toString());\n }\n result = result.join(\"\");\n if (!(hasProtocol2 || hasSlashSlash)) {\n result = protocol + \"://\" + result;\n }\n return result;\n },\n hasProtocol: function hasProtocol() {\n return this.v[0] instanceof _text$1.PROTOCOL;\n }\n});\nmulti.Base = MultiToken;\nmulti.MAILTOEMAIL = MAILTOEMAIL;\nmulti.EMAIL = EMAIL;\nmulti.NL = NL;\nmulti.TEXT = TEXT;\nmulti.URL = URL$1;\nparser$1.__esModule = true;\nparser$1.start = parser$1.run = parser$1.TOKENS = parser$1.State = void 0;\nvar _state = state;\nvar _multi = multi;\nvar MULTI_TOKENS = _interopRequireWildcard$1(_multi);\nvar _text = text$1;\nfunction _interopRequireWildcard$1(obj) {\n if (obj && obj.__esModule) {\n return obj;\n } else {\n var newObj = {};\n if (obj != null) {\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key))\n newObj[key] = obj[key];\n }\n }\n newObj.default = obj;\n return newObj;\n }\n}\nvar makeState2 = function makeState3(tokenClass) {\n return new _state.TokenState(tokenClass);\n};\nvar S_START = makeState2();\nvar S_PROTOCOL = makeState2();\nvar S_MAILTO = makeState2();\nvar S_PROTOCOL_SLASH = makeState2();\nvar S_PROTOCOL_SLASH_SLASH = makeState2();\nvar S_DOMAIN = makeState2();\nvar S_DOMAIN_DOT = makeState2();\nvar S_TLD = makeState2(_multi.URL);\nvar S_TLD_COLON = makeState2();\nvar S_TLD_PORT = makeState2(_multi.URL);\nvar S_URL = makeState2(_multi.URL);\nvar S_URL_NON_ACCEPTING = makeState2();\nvar S_URL_OPENBRACE = makeState2();\nvar S_URL_OPENBRACKET = makeState2();\nvar S_URL_OPENANGLEBRACKET = makeState2();\nvar S_URL_OPENPAREN = makeState2();\nvar S_URL_OPENBRACE_Q = makeState2(_multi.URL);\nvar S_URL_OPENBRACKET_Q = makeState2(_multi.URL);\nvar S_URL_OPENANGLEBRACKET_Q = makeState2(_multi.URL);\nvar S_URL_OPENPAREN_Q = makeState2(_multi.URL);\nvar S_URL_OPENBRACE_SYMS = makeState2();\nvar S_URL_OPENBRACKET_SYMS = makeState2();\nvar S_URL_OPENANGLEBRACKET_SYMS = makeState2();\nvar S_URL_OPENPAREN_SYMS = makeState2();\nvar S_EMAIL_DOMAIN = makeState2();\nvar S_EMAIL_DOMAIN_DOT = makeState2();\nvar S_EMAIL = makeState2(_multi.EMAIL);\nvar S_EMAIL_COLON = makeState2();\nvar S_EMAIL_PORT = makeState2(_multi.EMAIL);\nvar S_MAILTO_EMAIL = makeState2(_multi.MAILTOEMAIL);\nvar S_MAILTO_EMAIL_NON_ACCEPTING = makeState2();\nvar S_LOCALPART = makeState2();\nvar S_LOCALPART_AT = makeState2();\nvar S_LOCALPART_DOT = makeState2();\nvar S_NL = makeState2(_multi.NL);\nS_START.on(_text.NL, S_NL).on(_text.PROTOCOL, S_PROTOCOL).on(_text.MAILTO, S_MAILTO).on(_text.SLASH, S_PROTOCOL_SLASH);\nS_PROTOCOL.on(_text.SLASH, S_PROTOCOL_SLASH);\nS_PROTOCOL_SLASH.on(_text.SLASH, S_PROTOCOL_SLASH_SLASH);\nS_START.on(_text.TLD, S_DOMAIN).on(_text.DOMAIN, S_DOMAIN).on(_text.LOCALHOST, S_TLD).on(_text.NUM, S_DOMAIN);\nS_PROTOCOL_SLASH_SLASH.on(_text.TLD, S_URL).on(_text.DOMAIN, S_URL).on(_text.NUM, S_URL).on(_text.LOCALHOST, S_URL);\nS_DOMAIN.on(_text.DOT, S_DOMAIN_DOT);\nS_EMAIL_DOMAIN.on(_text.DOT, S_EMAIL_DOMAIN_DOT);\nS_DOMAIN_DOT.on(_text.TLD, S_TLD).on(_text.DOMAIN, S_DOMAIN).on(_text.NUM, S_DOMAIN).on(_text.LOCALHOST, S_DOMAIN);\nS_EMAIL_DOMAIN_DOT.on(_text.TLD, S_EMAIL).on(_text.DOMAIN, S_EMAIL_DOMAIN).on(_text.NUM, S_EMAIL_DOMAIN).on(_text.LOCALHOST, S_EMAIL_DOMAIN);\nS_TLD.on(_text.DOT, S_DOMAIN_DOT);\nS_EMAIL.on(_text.DOT, S_EMAIL_DOMAIN_DOT);\nS_TLD.on(_text.COLON, S_TLD_COLON).on(_text.SLASH, S_URL);\nS_TLD_COLON.on(_text.NUM, S_TLD_PORT);\nS_TLD_PORT.on(_text.SLASH, S_URL);\nS_EMAIL.on(_text.COLON, S_EMAIL_COLON);\nS_EMAIL_COLON.on(_text.NUM, S_EMAIL_PORT);\nvar qsAccepting = [_text.DOMAIN, _text.AT, _text.LOCALHOST, _text.NUM, _text.PLUS, _text.POUND, _text.PROTOCOL, _text.SLASH, _text.TLD, _text.UNDERSCORE, _text.SYM, _text.AMPERSAND];\nvar qsNonAccepting = [_text.COLON, _text.DOT, _text.QUERY, _text.PUNCTUATION, _text.CLOSEBRACE, _text.CLOSEBRACKET, _text.CLOSEANGLEBRACKET, _text.CLOSEPAREN, _text.OPENBRACE, _text.OPENBRACKET, _text.OPENANGLEBRACKET, _text.OPENPAREN];\nS_URL.on(_text.OPENBRACE, S_URL_OPENBRACE).on(_text.OPENBRACKET, S_URL_OPENBRACKET).on(_text.OPENANGLEBRACKET, S_URL_OPENANGLEBRACKET).on(_text.OPENPAREN, S_URL_OPENPAREN);\nS_URL_NON_ACCEPTING.on(_text.OPENBRACE, S_URL_OPENBRACE).on(_text.OPENBRACKET, S_URL_OPENBRACKET).on(_text.OPENANGLEBRACKET, S_URL_OPENANGLEBRACKET).on(_text.OPENPAREN, S_URL_OPENPAREN);\nS_URL_OPENBRACE.on(_text.CLOSEBRACE, S_URL);\nS_URL_OPENBRACKET.on(_text.CLOSEBRACKET, S_URL);\nS_URL_OPENANGLEBRACKET.on(_text.CLOSEANGLEBRACKET, S_URL);\nS_URL_OPENPAREN.on(_text.CLOSEPAREN, S_URL);\nS_URL_OPENBRACE_Q.on(_text.CLOSEBRACE, S_URL);\nS_URL_OPENBRACKET_Q.on(_text.CLOSEBRACKET, S_URL);\nS_URL_OPENANGLEBRACKET_Q.on(_text.CLOSEANGLEBRACKET, S_URL);\nS_URL_OPENPAREN_Q.on(_text.CLOSEPAREN, S_URL);\nS_URL_OPENBRACE_SYMS.on(_text.CLOSEBRACE, S_URL);\nS_URL_OPENBRACKET_SYMS.on(_text.CLOSEBRACKET, S_URL);\nS_URL_OPENANGLEBRACKET_SYMS.on(_text.CLOSEANGLEBRACKET, S_URL);\nS_URL_OPENPAREN_SYMS.on(_text.CLOSEPAREN, S_URL);\nS_URL_OPENBRACE.on(qsAccepting, S_URL_OPENBRACE_Q);\nS_URL_OPENBRACKET.on(qsAccepting, S_URL_OPENBRACKET_Q);\nS_URL_OPENANGLEBRACKET.on(qsAccepting, S_URL_OPENANGLEBRACKET_Q);\nS_URL_OPENPAREN.on(qsAccepting, S_URL_OPENPAREN_Q);\nS_URL_OPENBRACE.on(qsNonAccepting, S_URL_OPENBRACE_SYMS);\nS_URL_OPENBRACKET.on(qsNonAccepting, S_URL_OPENBRACKET_SYMS);\nS_URL_OPENANGLEBRACKET.on(qsNonAccepting, S_URL_OPENANGLEBRACKET_SYMS);\nS_URL_OPENPAREN.on(qsNonAccepting, S_URL_OPENPAREN_SYMS);\nS_URL_OPENBRACE_Q.on(qsAccepting, S_URL_OPENBRACE_Q);\nS_URL_OPENBRACKET_Q.on(qsAccepting, S_URL_OPENBRACKET_Q);\nS_URL_OPENANGLEBRACKET_Q.on(qsAccepting, S_URL_OPENANGLEBRACKET_Q);\nS_URL_OPENPAREN_Q.on(qsAccepting, S_URL_OPENPAREN_Q);\nS_URL_OPENBRACE_Q.on(qsNonAccepting, S_URL_OPENBRACE_Q);\nS_URL_OPENBRACKET_Q.on(qsNonAccepting, S_URL_OPENBRACKET_Q);\nS_URL_OPENANGLEBRACKET_Q.on(qsNonAccepting, S_URL_OPENANGLEBRACKET_Q);\nS_URL_OPENPAREN_Q.on(qsNonAccepting, S_URL_OPENPAREN_Q);\nS_URL_OPENBRACE_SYMS.on(qsAccepting, S_URL_OPENBRACE_Q);\nS_URL_OPENBRACKET_SYMS.on(qsAccepting, S_URL_OPENBRACKET_Q);\nS_URL_OPENANGLEBRACKET_SYMS.on(qsAccepting, S_URL_OPENANGLEBRACKET_Q);\nS_URL_OPENPAREN_SYMS.on(qsAccepting, S_URL_OPENPAREN_Q);\nS_URL_OPENBRACE_SYMS.on(qsNonAccepting, S_URL_OPENBRACE_SYMS);\nS_URL_OPENBRACKET_SYMS.on(qsNonAccepting, S_URL_OPENBRACKET_SYMS);\nS_URL_OPENANGLEBRACKET_SYMS.on(qsNonAccepting, S_URL_OPENANGLEBRACKET_SYMS);\nS_URL_OPENPAREN_SYMS.on(qsNonAccepting, S_URL_OPENPAREN_SYMS);\nS_URL.on(qsAccepting, S_URL);\nS_URL_NON_ACCEPTING.on(qsAccepting, S_URL);\nS_URL.on(qsNonAccepting, S_URL_NON_ACCEPTING);\nS_URL_NON_ACCEPTING.on(qsNonAccepting, S_URL_NON_ACCEPTING);\nS_MAILTO.on(_text.TLD, S_MAILTO_EMAIL).on(_text.DOMAIN, S_MAILTO_EMAIL).on(_text.NUM, S_MAILTO_EMAIL).on(_text.LOCALHOST, S_MAILTO_EMAIL);\nS_MAILTO_EMAIL.on(qsAccepting, S_MAILTO_EMAIL).on(qsNonAccepting, S_MAILTO_EMAIL_NON_ACCEPTING);\nS_MAILTO_EMAIL_NON_ACCEPTING.on(qsAccepting, S_MAILTO_EMAIL).on(qsNonAccepting, S_MAILTO_EMAIL_NON_ACCEPTING);\nvar localpartAccepting = [_text.DOMAIN, _text.NUM, _text.PLUS, _text.POUND, _text.QUERY, _text.UNDERSCORE, _text.SYM, _text.AMPERSAND, _text.TLD];\nS_DOMAIN.on(localpartAccepting, S_LOCALPART).on(_text.AT, S_LOCALPART_AT);\nS_TLD.on(localpartAccepting, S_LOCALPART).on(_text.AT, S_LOCALPART_AT);\nS_DOMAIN_DOT.on(localpartAccepting, S_LOCALPART);\nS_LOCALPART.on(localpartAccepting, S_LOCALPART).on(_text.AT, S_LOCALPART_AT).on(_text.DOT, S_LOCALPART_DOT);\nS_LOCALPART_DOT.on(localpartAccepting, S_LOCALPART);\nS_LOCALPART_AT.on(_text.TLD, S_EMAIL_DOMAIN).on(_text.DOMAIN, S_EMAIL_DOMAIN).on(_text.LOCALHOST, S_EMAIL);\nvar run$1 = function run2(tokens) {\n var len = tokens.length;\n var cursor = 0;\n var multis = [];\n var textTokens = [];\n while (cursor < len) {\n var state2 = S_START;\n var secondState = null;\n var nextState = null;\n var multiLength = 0;\n var latestAccepting = null;\n var sinceAccepts = -1;\n while (cursor < len && !(secondState = state2.next(tokens[cursor]))) {\n textTokens.push(tokens[cursor++]);\n }\n while (cursor < len && (nextState = secondState || state2.next(tokens[cursor]))) {\n secondState = null;\n state2 = nextState;\n if (state2.accepts()) {\n sinceAccepts = 0;\n latestAccepting = state2;\n } else if (sinceAccepts >= 0) {\n sinceAccepts++;\n }\n cursor++;\n multiLength++;\n }\n if (sinceAccepts < 0) {\n for (var i = cursor - multiLength; i < cursor; i++) {\n textTokens.push(tokens[i]);\n }\n } else {\n if (textTokens.length > 0) {\n multis.push(new _multi.TEXT(textTokens));\n textTokens = [];\n }\n cursor -= sinceAccepts;\n multiLength -= sinceAccepts;\n var MULTI = latestAccepting.emit();\n multis.push(new MULTI(tokens.slice(cursor - multiLength, cursor)));\n }\n }\n if (textTokens.length > 0) {\n multis.push(new _multi.TEXT(textTokens));\n }\n return multis;\n};\nparser$1.State = _state.TokenState;\nparser$1.TOKENS = MULTI_TOKENS;\nparser$1.run = run$1;\nparser$1.start = S_START;\nlinkify.__esModule = true;\nlinkify.tokenize = linkify.test = linkify.scanner = linkify.parser = linkify.options = linkify.inherits = linkify.find = void 0;\nvar _class = _class$4;\nvar _options = options$1;\nvar options = _interopRequireWildcard(_options);\nvar _scanner = scanner$1;\nvar scanner = _interopRequireWildcard(_scanner);\nvar _parser = parser$1;\nvar parser = _interopRequireWildcard(_parser);\nfunction _interopRequireWildcard(obj) {\n if (obj && obj.__esModule) {\n return obj;\n } else {\n var newObj = {};\n if (obj != null) {\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key))\n newObj[key] = obj[key];\n }\n }\n newObj.default = obj;\n return newObj;\n }\n}\nif (!Array.isArray) {\n Array.isArray = function(arg) {\n return Object.prototype.toString.call(arg) === \"[object Array]\";\n };\n}\nvar tokenize = function tokenize2(str) {\n return parser.run(scanner.run(str));\n};\nvar find = function find2(str) {\n var type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;\n var tokens = tokenize(str);\n var filtered = [];\n for (var i = 0; i < tokens.length; i++) {\n var token = tokens[i];\n if (token.isLink && (!type || token.type === type)) {\n filtered.push(token.toObject());\n }\n }\n return filtered;\n};\nvar test4 = function test5(str) {\n var type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;\n var tokens = tokenize(str);\n return tokens.length === 1 && tokens[0].isLink && (!type || tokens[0].type === type);\n};\nlinkify.find = find;\nlinkify.inherits = _class.inherits;\nlinkify.options = options;\nlinkify.parser = parser;\nlinkify.scanner = scanner;\nlinkify.test = test4;\nlinkify.tokenize = tokenize;\nvar linkifyjs = linkify;\nvar formatString$1 = (text2, doLinkify, textFormatting) => {\n const typeMarkdown = {\n bold: textFormatting.bold,\n italic: textFormatting.italic,\n strike: textFormatting.strike,\n underline: textFormatting.underline,\n multilineCode: textFormatting.multilineCode,\n inlineCode: textFormatting.inlineCode\n };\n const pseudoMarkdown = {\n [typeMarkdown.bold]: {\n end: \"\\\\\" + typeMarkdown.bold,\n allowed_chars: \".\",\n type: \"bold\"\n },\n [typeMarkdown.italic]: {\n end: typeMarkdown.italic,\n allowed_chars: \".\",\n type: \"italic\"\n },\n [typeMarkdown.strike]: {\n end: typeMarkdown.strike,\n allowed_chars: \".\",\n type: \"strike\"\n },\n [typeMarkdown.underline]: {\n end: typeMarkdown.underline,\n allowed_chars: \".\",\n type: \"underline\"\n },\n [typeMarkdown.multilineCode]: {\n end: typeMarkdown.multilineCode,\n allowed_chars: \"(.|\\n)\",\n type: \"multiline-code\"\n },\n [typeMarkdown.inlineCode]: {\n end: typeMarkdown.inlineCode,\n allowed_chars: \".\",\n type: \"inline-code\"\n },\n \"
{{ notificationCount }}
\n{{ notificationCount }}
\n