https://www.asiago.it/assets/base64-db31b48c.js

1function makeMap(str, expectsLowerCase) {
2  const map2 = /* @__PURE__ */ Object.create(null);
3  const list = str.split(",");
4  for (let i = 0; i < list.length; i++) {
5    map2[list[i]] = true;
6  }
7  return expectsLowerCase ? (val) => !!map2[val.toLowerCase()] : (val) => !!map2[val];
8}
9const EMPTY_OBJ = {};
10const EMPTY_ARR = [];
11const NOOP = () => {
12};
13const NO = () => false;
14const onRE = /^on[^a-z]/;
15const isOn = (key) => onRE.test(key);
16const isModelListener = (key) => key.startsWith("onUpdate:");
17const extend$1 = Object.assign;
18const remove = (arr, el) => {
19  const i = arr.indexOf(el);
20  if (i > -1) {
21    arr.splice(i, 1);
22  }
23};
24const hasOwnProperty$o = Object.prototype.hasOwnProperty;
25const hasOwn = (val, key) => hasOwnProperty$o.call(val, key);
26const isArray$5 = Array.isArray;
27const isMap$2 = (val) => toTypeString(val) === "[object Map]";
28const isSet$2 = (val) => toTypeString(val) === "[object Set]";
29const isDate$2 = (val) => toTypeString(val) === "[object Date]";
30const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
31const isFunction$4 = (val) => typeof val === "function";
32const isString$3 = (val) => typeof val === "string";
33const isSymbol$1 = (val) => typeof val === "symbol";
34const isObject$3 = (val) => val !== null && typeof val === "object";
35const isPromise = (val) => {
36  return isObject$3(val) && isFunction$4(val.then) && isFunction$4(val.catch);
37};
38const objectToString$2 = Object.prototype.toString;
39const toTypeString = (value) => objectToString$2.call(value);
40const toRawType = (value) => {
41  return toTypeString(value).slice(8, -1);
42};
43const isPlainObject$3 = (val) => toTypeString(val) === "[object Object]";
44const isIntegerKey = (key) => isString$3(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
45const isReservedProp = /* @__PURE__ */ makeMap(
46  // the leading comma is intentional so empty string "" is also included
47  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
48);
49const cacheStringFunction = (fn) => {
50  const cache2 = /* @__PURE__ */ Object.create(null);
51  return (str) => {
52    const hit = cache2[str];
53    return hit || (cache2[str] = fn(str));
54  };
55};
56const camelizeRE = /-(\w)/g;
57const camelize = cacheStringFunction((str) => {
58  return str.replace(camelizeRE, (_, c2) => c2 ? c2.toUpperCase() : "");
59});
60const hyphenateRE = /\B([A-Z])/g;
61const hyphenate = cacheStringFunction(
62  (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
63);
64const capitalize = cacheStringFunction(
65  (str) => str.charAt(0).toUpperCase() + str.slice(1)
66);
67const toHandlerKey = cacheStringFunction(
68  (str) => str ? `on${capitalize(str)}` : ``
69);
70const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
71const invokeArrayFns = (fns, arg) => {
72  for (let i = 0; i < fns.length; i++) {
73    fns[i](arg);
74  }
75};
76const def = (obj, key, value) => {
77  Object.defineProperty(obj, key, {
78    configurable: true,
79    enumerable: false,
80    value
81  });
82};
83const looseToNumber = (val) => {
84  const n2 = parseFloat(val);
85  return isNaN(n2) ? val : n2;
86};
87const toNumber = (val) => {
88  const n2 = isString$3(val) ? Number(val) : NaN;
89  return isNaN(n2) ? val : n2;
90};
91let _globalThis;
92const getGlobalThis = () => {
93  return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
94};
95const GLOBALS_WHITE_LISTED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console";
96const isGloballyWhitelisted = /* @__PURE__ */ makeMap(GLOBALS_WHITE_LISTED);
97function normalizeStyle(value) {
98  if (isArray$5(value)) {
99    const res = {};
100    for (let i = 0; i < value.length; i++) {
101      const item = value[i];
102      const normalized = isString$3(item) ? parseStringStyle(item) : normalizeStyle(item);
103      if (normalized) {
104        for (const key in normalized) {
105          res[key] = normalized[key];
106        }
107      }
108    }
109    return res;
110  } else if (isString$3(value)) {
111    return value;
112  } else if (isObject$3(value)) {
113    return value;
114  }
115}

116const listDelimiterRE = /;(?![^(]*\))/g;
117const propertyDelimiterRE = /:([^]+)/;
118const styleCommentRE = /\/\*[^]*?\*\//g;
119function parseStringStyle(cssText) {
120  const ret = {};
121  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
122    if (item) {
123      const tmp = item.split(propertyDelimiterRE);
124      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
125    }
126  });
127  return ret;
128}
129function normalizeClass(value) {
130  let res = "";
131  if (isString$3(value)) {
132    res = value;
133  } else if (isArray$5(value)) {
134    for (let i = 0; i < value.length; i++) {
135      const normalized = normalizeClass(value[i]);
136      if (normalized) {
137        res += normalized + " ";
138      }
139    }
140  } else if (isObject$3(value)) {
141    for (const name in value) {
142      if (value[name]) {
143        res += name + " ";
144      }
145    }
146  }
147  return res.trim();
148}
149function normalizeProps(props) {
150  if (!props)
151    return null;
152  let { class: klass, style: style2 } = props;
153  if (klass && !isString$3(klass)) {
154    props.class = normalizeClass(klass);
155  }
156  if (style2) {
157    props.style = normalizeStyle(style2);
158  }
159  return props;
160}
161const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
162const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
163function includeBooleanAttr(value) {
164  return !!value || value === "";
165}
166function looseCompareArrays(a, b) {
167  if (a.length !== b.length)
168    return false;
169  let equal = true;
170  for (let i = 0; equal && i < a.length; i++) {
171    equal = looseEqual(a[i], b[i]);
172  }
173  return equal;
174}
175function looseEqual(a, b) {
176  if (a === b)
177    return true;
178  let aValidType = isDate$2(a);
179  let bValidType = isDate$2(b);
180  if (aValidType || bValidType) {
181    return aValidType && bValidType ? a.getTime() === b.getTime() : false;
182  }
183  aValidType = isSymbol$1(a);
184  bValidType = isSymbol$1(b);
185  if (aValidType || bValidType) {
186    return a === b;
187  }
188  aValidType = isArray$5(a);
189  bValidType = isArray$5(b);
190  if (aValidType || bValidType) {
191    return aValidType && bValidType ? looseCompareArrays(a, b) : false;
192  }
193  aValidType = isObject$3(a);
194  bValidType = isObject$3(b);
195  if (aValidType || bValidType) {
196    if (!aValidType || !bValidType) {
197      return false;
198    }
199    const aKeysCount = Object.keys(a).length;
200    const bKeysCount = Object.keys(b).length;
201    if (aKeysCount !== bKeysCount) {
202      return false;
203    }
204    for (const key in a) {
205      const aHasKey = a.hasOwnProperty(key);
206      const bHasKey = b.hasOwnProperty(key);
207      if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
208        return false;
209      }
210    }
211  }
212  return String(a) === String(b);
213}
214function looseIndexOf(arr, val) {
215  return arr.findIndex((item) => looseEqual(item, val));
216}
217const toDisplayString = (val) => {
218  return isString$3(val) ? val : val == null ? "" : isArray$5(val) || isObject$3(val) && (val.toString === objectToString$2 || !isFunction$4(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val);
219};
220const replacer = (_key, val) => {
221  if (val && val.__v_isRef) {
222    return replacer(_key, val.value);
223  } else if (isMap$2(val)) {
224    return {
225      [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2]) => {
226        entries[`${key} =>`] = val2;
227        return entries;
228      }, {})
229    };
230  } else if (isSet$2(val)) {
231    return {
232      [`Set(${val.size})`]: [...val.values()]
233    };
234  } else if (isObject$3(val) && !isArray$5(val) && !isPlainObject$3(val)) {
235    return String(val);
236  }
237  return val;
238};
239let activeEffectScope;
240class EffectScope {
241  constructor(detached = false) {
242    this.detached = detached;
243    this._active = true;
244    this.effects = [];
245    this.cleanups = [];
246    this.parent = activeEffectScope;
247    if (!detached && activeEffectScope) {
248      this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
249        this
250      ) - 1;
251    }
252  }
253  get active() {
254    return this._active;
255  }
256  run(fn) {
257    if (this._active) {
258      const currentEffectScope = activeEffectScope;

259      try {
260        activeEffectScope = this;
261        return fn();
262      } finally {
263        activeEffectScope = currentEffectScope;
264      }
265    }
266  }
267  /**
268   * This should only be called on non-detached scopes
269   * @internal
270   */
271  on() {
272    activeEffectScope = this;
273  }
274  /**
275   * This should only be called on non-detached scopes
276   * @internal
277   */
278  off() {
279    activeEffectScope = this.parent;
280  }
281  stop(fromParent) {
282    if (this._active) {
283      let i, l2;
284      for (i = 0, l2 = this.effects.length; i < l2; i++) {
285        this.effects[i].stop();
286      }
287      for (i = 0, l2 = this.cleanups.length; i < l2; i++) {
288        this.cleanups[i]();
289      }
290      if (this.scopes) {
291        for (i = 0, l2 = this.scopes.length; i < l2; i++) {
292          this.scopes[i].stop(true);
293        }
294      }
295      if (!this.detached && this.parent && !fromParent) {
296        const last = this.parent.scopes.pop();
297        if (last && last !== this) {
298          this.parent.scopes[this.index] = last;
299          last.index = this.index;
300        }
301      }
302      this.parent = void 0;
303      this._active = false;
304    }
305  }
306}
307function effectScope(detached) {
308  return new EffectScope(detached);
309}
310function recordEffectScope(effect2, scope = activeEffectScope) {
311  if (scope && scope.active) {
312    scope.effects.push(effect2);
313  }
314}
315function getCurrentScope() {
316  return activeEffectScope;
317}
318function onScopeDispose(fn) {
319  if (activeEffectScope) {
320    activeEffectScope.cleanups.push(fn);
321  }
322}
323const createDep = (effects) => {
324  const dep = new Set(effects);
325  dep.w = 0;
326  dep.n = 0;
327  return dep;
328};
329const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
330const newTracked = (dep) => (dep.n & trackOpBit) > 0;
331const initDepMarkers = ({ deps }) => {
332  if (deps.length) {
333    for (let i = 0; i < deps.length; i++) {
334      deps[i].w |= trackOpBit;
335    }
336  }
337};
338const finalizeDepMarkers = (effect2) => {
339  const { deps } = effect2;
340  if (deps.length) {
341    let ptr = 0;
342    for (let i = 0; i < deps.length; i++) {
343      const dep = deps[i];
344      if (wasTracked(dep) && !newTracked(dep)) {
345        dep.delete(effect2);
346      } else {
347        deps[ptr++] = dep;
348      }
349      dep.w &= ~trackOpBit;
350      dep.n &= ~trackOpBit;
351    }
352    deps.length = ptr;
353  }
354};
355const targetMap = /* @__PURE__ */ new WeakMap();
356let effectTrackDepth = 0;
357let trackOpBit = 1;
358const maxMarkerBits = 30;
359let activeEffect;
360const ITERATE_KEY = Symbol("");
361const MAP_KEY_ITERATE_KEY = Symbol("");
362class ReactiveEffect {
363  constructor(fn, scheduler2 = null, scope) {
364    this.fn = fn;
365    this.scheduler = scheduler2;
366    this.active = true;
367    this.deps = [];
368    this.parent = void 0;
369    recordEffectScope(this, scope);
370  }
371  run() {
372    if (!this.active) {
373      return this.fn();
374    }
375    let parent = activeEffect;
376    let lastShouldTrack = shouldTrack;
377    while (parent) {
378      if (parent === this) {
379        return;
380      }
381      parent = parent.parent;
382    }
383    try {
384      this.parent = activeEffect;
385      activeEffect = this;
386      shouldTrack = true;
387      trackOpBit = 1 << ++effectTrackDepth;
388      if (effectTrackDepth <= maxMarkerBits) {
389        initDepMarkers(this);
390      } else {
391        cleanupEffect(this);
392      }
393      return this.fn();
394    } finally {
395      if (effectTrackDepth <= maxMarkerBits) {
396        finalizeDepMarkers(this);
397      }
398      trackOpBit = 1 << --effectTrackDepth;
399      activeEffect = this.parent;
400      shouldTrack = lastShouldTrack;
401      this.parent = void 0;
402      if (this.deferStop) {
403        this.stop();
404      }
405    }
406  }
407  stop() {
408    if (activeEffect === this) {
409      this.deferStop = true;
410    } else if (this.active) {
411      cleanupEffect(this);
412      if (this.onStop) {
413        this.onStop();
414      }
415      this.active = false;
416    }
417  }
418}
419function cleanupEffect(effect2) {
420  const { deps } = effect2;
421  if (deps.length) {
422    for (let i = 0; i < deps.length; i++) {
423      deps[i].delete(effect2);
424    }
425    deps.length = 0;
426  }
427}
428function effect(fn, options) {
429  if (fn.effect) {
430    fn = fn.effect.fn;
431  }
432  const _effect = new ReactiveEffect(fn);
433  if (options) {
434    extend$1(_effect, options);
435    if (options.scope)
436      recordEffectScope(_effect, options.scope);
437  }
438  if (!options || !options.lazy) {
439    _effect.run();
440  }
441  const runner = _effect.run.bind(_effect);
442  runner.effect = _effect;
443  return runner;
444}
445function stop(runner) {
446  runner.effect.stop();
447}
448let shouldTrack = true;
449const trackStack = [];
450function pauseTracking() {
451  trackStack.push(shouldTrack);
452  shouldTrack = false;

453}
454function resetTracking() {
455  const last = trackStack.pop();
456  shouldTrack = last === void 0 ? true : last;
457}
458function track(target, type4, key) {
459  if (shouldTrack && activeEffect) {
460    let depsMap = targetMap.get(target);
461    if (!depsMap) {
462      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
463    }
464    let dep = depsMap.get(key);
465    if (!dep) {
466      depsMap.set(key, dep = createDep());
467    }
468    trackEffects(dep);
469  }
470}
471function trackEffects(dep, debuggerEventExtraInfo) {
472  let shouldTrack2 = false;
473  if (effectTrackDepth <= maxMarkerBits) {
474    if (!newTracked(dep)) {
475      dep.n |= trackOpBit;
476      shouldTrack2 = !wasTracked(dep);
477    }
478  } else {
479    shouldTrack2 = !dep.has(activeEffect);
480  }
481  if (shouldTrack2) {
482    dep.add(activeEffect);
483    activeEffect.deps.push(dep);
484  }
485}
486function trigger$1(target, type4, key, newValue, oldValue, oldTarget) {
487  const depsMap = targetMap.get(target);
488  if (!depsMap) {
489    return;
490  }
491  let deps = [];
492  if (type4 === "clear") {
493    deps = [...depsMap.values()];
494  } else if (key === "length" && isArray$5(target)) {
495    const newLength = Number(newValue);
496    depsMap.forEach((dep, key2) => {

497      if (key2 === "length" || key2 >= newLength) {
498        deps.push(dep);
499      }
500    });
501  } else {
502    if (key !== void 0) {
503      deps.push(depsMap.get(key));
504    }
505    switch (type4) {
506      case "add":
507        if (!isArray$5(target)) {
508          deps.push(depsMap.get(ITERATE_KEY));
509          if (isMap$2(target)) {
510            deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
511          }
512        } else if (isIntegerKey(key)) {
513          deps.push(depsMap.get("length"));
514        }
515        break;
516      case "delete":
517        if (!isArray$5(target)) {
518          deps.push(depsMap.get(ITERATE_KEY));
519          if (isMap$2(target)) {
520            deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
521          }
522        }
523        break;
524      case "set":
525        if (isMap$2(target)) {
526          deps.push(depsMap.get(ITERATE_KEY));
527        }
528        break;
529    }
530  }
531  if (deps.length === 1) {
532    if (deps[0]) {
533      {
534        triggerEffects(deps[0]);
535      }
536    }
537  } else {
538    const effects = [];
539    for (const dep of deps) {
540      if (dep) {
541        effects.push(...dep);
542      }
543    }
544    {
545      triggerEffects(createDep(effects));
546    }
547  }
548}
549function triggerEffects(dep, debuggerEventExtraInfo) {
550  const effects = isArray$5(dep) ? dep : [...dep];
551  for (const effect2 of effects) {
552    if (effect2.computed) {
553      triggerEffect(effect2);
554    }
555  }
556  for (const effect2 of effects) {
557    if (!effect2.computed) {
558      triggerEffect(effect2);
559    }
560  }
561}
562function triggerEffect(effect2, debuggerEventExtraInfo) {
563  if (effect2 !== activeEffect || effect2.allowRecurse) {
564    if (effect2.scheduler) {
565      effect2.scheduler();
566    } else {
567      effect2.run();
568    }
569  }
570}
571function getDepFromReactive(object4, key) {
572  var _a2;
573  return (_a2 = targetMap.get(object4)) == null ? void 0 : _a2.get(key);
574}
575const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
576const builtInSymbols = new Set(
577  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol$1)
578);
579const get$1 = /* @__PURE__ */ createGetter();
580const shallowGet = /* @__PURE__ */ createGetter(false, true);
581const readonlyGet = /* @__PURE__ */ createGetter(true);
582const shallowReadonlyGet = /* @__PURE__ */ createGetter(true, true);
583const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
584function createArrayInstrumentations() {
585  const instrumentations = {};
586  ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
587    instrumentations[key] = function(...args) {
588      const arr = toRaw(this);
589      for (let i = 0, l2 = this.length; i < l2; i++) {
590        track(arr, "get", i + "");
591      }
592      const res = arr[key](...args);
593      if (res === -1 || res === false) {
594        return arr[key](...args.map(toRaw));
595      } else {
596        return res;
597      }
598    };
599  });
600  ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
601    instrumentations[key] = function(...args) {
602      pauseTracking();
603      const res = toRaw(this)[key].apply(this, args);
604      resetTracking();
605      return res;
606    };
607  });
608  return instrumentations;
609}
610function hasOwnProperty$n(key) {
611  const obj = toRaw(this);
612  track(obj, "has", key);
613  return obj.hasOwnProperty(key);
614}
615function createGetter(isReadonly2 = false, shallow = false) {
616  return function get2(target, key, receiver) {
617    if (key === "__v_isReactive") {
618      return !isReadonly2;
619    } else if (key === "__v_isReadonly") {
620      return isReadonly2;
621    } else if (key === "__v_isShallow") {
622      return shallow;
623    } else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
624      return target;
625    }
626    const targetIsArray = isArray$5(target);
627    if (!isReadonly2) {
628      if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
629        return Reflect.get(arrayInstrumentations, key, receiver);
630      }
631      if (key === "hasOwnProperty") {
632        return hasOwnProperty$n;
633      }
634    }
635    const res = Reflect.get(target, key, receiver);

636    if (isSymbol$1(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
637      return res;
638    }
639    if (!isReadonly2) {
640      track(target, "get", key);
641    }
642    if (shallow) {
643      return res;
644    }
645    if (isRef(res)) {
646      return targetIsArray && isIntegerKey(key) ? res : res.value;
647    }
648    if (isObject$3(res)) {
649      return isReadonly2 ? readonly(res) : reactive(res);
650    }
651    return res;
652  };
653}
654const set$1 = /* @__PURE__ */ createSetter();
655const shallowSet = /* @__PURE__ */ createSetter(true);
656function createSetter(shallow = false) {
657  return function set2(target, key, value, receiver) {
658    let oldValue = target[key];
659    if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
660      return false;
661    }
662    if (!shallow) {
663      if (!isShallow(value) && !isReadonly(value)) {
664        oldValue = toRaw(oldValue);
665        value = toRaw(value);
666      }
667      if (!isArray$5(target) && isRef(oldValue) && !isRef(value)) {
668        oldValue.value = value;
669        return true;
670      }
671    }
672    const hadKey = isArray$5(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
673    const result = Reflect.set(target, key, value, receiver);
674    if (target === toRaw(receiver)) {
675      if (!hadKey) {
676        trigger$1(target, "add", key, value);
677      } else if (hasChanged(value, oldValue)) {
678        trigger$1(target, "set", key, value);
679      }
680    }
681    return result;
682  };
683}
684function deleteProperty(target, key) {
685  const hadKey = hasOwn(target, key);
686  target[key];
687  const result = Reflect.deleteProperty(target, key);
688  if (result && hadKey) {
689    trigger$1(target, "delete", key, void 0);
690  }
691  return result;
692}
693function has$1(target, key) {
694  const result = Reflect.has(target, key);
695  if (!isSymbol$1(key) || !builtInSymbols.has(key)) {
696    track(target, "has", key);
697  }
698  return result;
699}
700function ownKeys(target) {
701  track(target, "iterate", isArray$5(target) ? "length" : ITERATE_KEY);
702  return Reflect.ownKeys(target);
703}
704const mutableHandlers = {
705  get: get$1,
706  set: set$1,
707  deleteProperty,
708  has: has$1,
709  ownKeys
710};
711const readonlyHandlers = {
712  get: readonlyGet,
713  set(target, key) {
714    return true;
715  },
716  deleteProperty(target, key) {
717    return true;
718  }
719};
720const shallowReactiveHandlers = /* @__PURE__ */ extend$1(
721  {},
722  mutableHandlers,
723  {
724    get: shallowGet,
725    set: shallowSet
726  }
727);
728const shallowReadonlyHandlers = /* @__PURE__ */ extend$1(
729  {},
730  readonlyHandlers,
731  {
732    get: shallowReadonlyGet
733  }
734);
735const toShallow = (value) => value;
736const getProto = (v) => Reflect.getPrototypeOf(v);
737function get$2(target, key, isReadonly2 = false, isShallow2 = false) {
738  target = target["__v_raw"];
739  const rawTarget = toRaw(target);
740  const rawKey = toRaw(key);
741  if (!isReadonly2) {
742    if (key !== rawKey) {
743      track(rawTarget, "get", key);
744    }
745    track(rawTarget, "get", rawKey);
746  }
747  const { has: has2 } = getProto(rawTarget);
748  const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
749  if (has2.call(rawTarget, key)) {
750    return wrap(target.get(key));
751  } else if (has2.call(rawTarget, rawKey)) {
752    return wrap(target.get(rawKey));
753  } else if (target !== rawTarget) {
754    target.get(key);
755  }
756}
757function has(key, isReadonly2 = false) {
758  const target = this["__v_raw"];
759  const rawTarget = toRaw(target);
760  const rawKey = toRaw(key);
761  if (!isReadonly2) {
762    if (key !== rawKey) {
763      track(rawTarget, "has", key);
764    }
765    track(rawTarget, "has", rawKey);
766  }
767  return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
768}
769function size$1(target, isReadonly2 = false) {
770  target = target["__v_raw"];
771  !isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
772  return Reflect.get(target, "size", target);
773}
774function add(value) {
775  value = toRaw(value);
776  const target = toRaw(this);
777  const proto = getProto(target);
778  const hadKey = proto.has.call(target, value);
779  if (!hadKey) {
780    target.add(value);
781    trigger$1(target, "add", value, value);
782  }
783  return this;
784}
785function set(key, value) {
786  value = toRaw(value);
787  const target = toRaw(this);
788  const { has: has2, get: get2 } = getProto(target);
789  let hadKey = has2.call(target, key);
790  if (!hadKey) {
791    key = toRaw(key);
792    hadKey = has2.call(target, key);
793  }
794  const oldValue = get2.call(target, key);
795  target.set(key, value);
796  if (!hadKey) {
797    trigger$1(target, "add", key, value);
798  } else if (hasChanged(value, oldValue)) {
799    trigger$1(target, "set", key, value);
800  }
801  return this;
802}
803function deleteEntry(key) {
804  const target = toRaw(this);
805  const { has: has2, get: get2 } = getProto(target);
806  let hadKey = has2.call(target, key);
807  if (!hadKey) {
808    key = toRaw(key);
809    hadKey = has2.call(target, key);
810  }
811  get2 ? get2.call(target, key) : void 0;
812  const result = target.delete(key);
813  if (hadKey) {
814    trigger$1(target, "delete", key, void 0);
815  }
816  return result;
817}
818function clear() {
819  const target = toRaw(this);
820  const hadItems = target.size !== 0;
821  const result = target.clear();
822  if (hadItems) {
823    trigger$1(target, "clear", void 0, void 0);
824  }
825  return result;
826}
827function createForEach(isReadonly2, isShallow2) {
828  return function forEach3(callback, thisArg) {
829    const observed = this;
830    const target = observed["__v_raw"];
831    const rawTarget = toRaw(target);
832    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
833    !isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY);
834    return target.forEach((value, key) => {
835      return callback.call(thisArg, wrap(value), wrap(key), observed);
836    });
837  };
838}
839function createIterableMethod(method4, isReadonly2, isShallow2) {
840  return function(...args) {
841    const target = this["__v_raw"];
842    const rawTarget = toRaw(target);
843    const targetIsMap = isMap$2(rawTarget);
844    const isPair = method4 === "entries" || method4 === Symbol.iterator && targetIsMap;
845    const isKeyOnly = method4 === "keys" && targetIsMap;
846    const innerIterator = target[method4](...args);
847    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
848    !isReadonly2 && track(
849      rawTarget,
850      "iterate",
851      isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
852    );
853    return {
854      // iterator protocol
855      next() {
856        const { value, done } = innerIterator.next();
857        return done ? { value, done } : {
858          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),

859          done
860        };
861      },
862      // iterable protocol
863      [Symbol.iterator]() {
864        return this;
865      }
866    };
867  };
868}
869function createReadonlyMethod(type4) {
870  return function(...args) {
871    return type4 === "delete" ? false : this;
872  };
873}
874function createInstrumentations() {
875  const mutableInstrumentations2 = {
876    get(key) {
877      return get$2(this, key);
878    },
879    get size() {
880      return size$1(this);
881    },
882    has,
883    add,
884    set,
885    delete: deleteEntry,
886    clear,
887    forEach: createForEach(false, false)
888  };
889  const shallowInstrumentations2 = {
890    get(key) {
891      return get$2(this, key, false, true);
892    },
893    get size() {
894      return size$1(this);
895    },
896    has,
897    add,
898    set,
899    delete: deleteEntry,
900    clear,
901    forEach: createForEach(false, true)
902  };
903  const readonlyInstrumentations2 = {
904    get(key) {
905      return get$2(this, key, true);
906    },
907    get size() {
908      return size$1(this, true);
909    },
910    has(key) {
911      return has.call(this, key, true);
912    },
913    add: createReadonlyMethod("add"),
914    set: createReadonlyMethod("set"),
915    delete: createReadonlyMethod("delete"),
916    clear: createReadonlyMethod("clear"),
917    forEach: createForEach(true, false)
918  };
919  const shallowReadonlyInstrumentations2 = {
920    get(key) {
921      return get$2(this, key, true, true);
922    },
923    get size() {
924      return size$1(this, true);
925    },
926    has(key) {
927      return has.call(this, key, true);
928    },
929    add: createReadonlyMethod("add"),
930    set: createReadonlyMethod("set"),
931    delete: createReadonlyMethod("delete"),
932    clear: createReadonlyMethod("clear"),
933    forEach: createForEach(true, true)
934  };
935  const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
936  iteratorMethods.forEach((method4) => {
937    mutableInstrumentations2[method4] = createIterableMethod(
938      method4,
939      false,
940      false
941    );
942    readonlyInstrumentations2[method4] = createIterableMethod(
943      method4,
944      true,
945      false
946    );
947    shallowInstrumentations2[method4] = createIterableMethod(
948      method4,
949      false,
950      true
951    );
952    shallowReadonlyInstrumentations2[method4] = createIterableMethod(
953      method4,
954      true,
955      true
956    );
957  });
958  return [
959    mutableInstrumentations2,
960    readonlyInstrumentations2,
961    shallowInstrumentations2,
962    shallowReadonlyInstrumentations2
963  ];
964}
965const [
966  mutableInstrumentations,
967  readonlyInstrumentations,
968  shallowInstrumentations,
969  shallowReadonlyInstrumentations
970] = /* @__PURE__ */ createInstrumentations();
971function createInstrumentationGetter(isReadonly2, shallow) {
972  const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;
973  return (target, key, receiver) => {
974    if (key === "__v_isReactive") {
975      return !isReadonly2;
976    } else if (key === "__v_isReadonly") {
977      return isReadonly2;
978    } else if (key === "__v_raw") {
979      return target;
980    }
981    return Reflect.get(
982      hasOwn(instrumentations, key) && key in target ? instrumentations : target,
983      key,
984      receiver
985    );
986  };
987}
988const mutableCollectionHandlers = {
989  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
990};
991const shallowCollectionHandlers = {
992  get: /* @__PURE__ */ createInstrumentationGetter(false, true)
993};
994const readonlyCollectionHandlers = {
995  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
996};
997const shallowReadonlyCollectionHandlers = {
998  get: /* @__PURE__ */ createInstrumentationGetter(true, true)
999};
1000const reactiveMap = /* @__PURE__ */ new WeakMap();
1001const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
1002const readonlyMap = /* @__PURE__ */ new WeakMap();
1003const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
1004function targetTypeMap(rawType) {
1005  switch (rawType) {
1006    case "Object":
1007    case "Array":
1008      return 1;
1009    case "Map":
1010    case "Set":
1011    case "WeakMap":
1012    case "WeakSet":
1013      return 2;
1014    default:
1015      return 0;
1016  }
1017}
1018function getTargetType(value) {
1019  return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
1020}
1021function reactive(target) {
1022  if (isReadonly(target)) {
1023    return target;
1024  }
1025  return createReactiveObject(
1026    target,
1027    false,
1028    mutableHandlers,
1029    mutableCollectionHandlers,
1030    reactiveMap
1031  );
1032}
1033function shallowReactive(target) {
1034  return createReactiveObject(
1035    target,
1036    false,
1037    shallowReactiveHandlers,
1038    shallowCollectionHandlers,
1039    shallowReactiveMap
1040  );
1041}
1042function readonly(target) {
1043  return createReactiveObject(
1044    target,
1045    true,
1046    readonlyHandlers,
1047    readonlyCollectionHandlers,
1048    readonlyMap
1049  );
1050}
1051function shallowReadonly(target) {
1052  return createReactiveObject(
1053    target,
1054    true,
1055    shallowReadonlyHandlers,
1056    shallowReadonlyCollectionHandlers,
1057    shallowReadonlyMap
1058  );
1059}
1060function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
1061  if (!isObject$3(target)) {
1062    return target;
1063  }
1064  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
1065    return target;
1066  }
1067  const existingProxy = proxyMap.get(target);
1068  if (existingProxy) {
1069    return existingProxy;
1070  }
1071  const targetType = getTargetType(target);
1072  if (targetType === 0) {
1073    return target;
1074  }
1075  const proxy = new Proxy(
1076    target,
1077    targetType === 2 ? collectionHandlers : baseHandlers
1078  );
1079  proxyMap.set(target, proxy);
1080  return proxy;
1081}
1082function isReactive(value) {
1083  if (isReadonly(value)) {
1084    return isReactive(value["__v_raw"]);
1085  }
1086  return !!(value && value["__v_isReactive"]);
1087}
1088function isReadonly(value) {
1089  return !!(value && value["__v_isReadonly"]);
1090}
1091function isShallow(value) {
1092  return !!(value && value["__v_isShallow"]);
1093}
1094function isProxy(value) {
1095  return isReactive(value) || isReadonly(value);
1096}
1097function toRaw(observed) {
1098  const raw = observed && observed["__v_raw"];
1099  return raw ? toRaw(raw) : observed;
1100}
1101function markRaw(value) {
1102  def(value, "__v_skip", true);
1103  return value;
1104}
1105const toReactive = (value) => isObject$3(value) ? reactive(value) : value;
1106const toReadonly = (value) => isObject$3(value) ? readonly(value) : value;
1107function trackRefValue(ref2) {
1108  if (shouldTrack && activeEffect) {
1109    ref2 = toRaw(ref2);
1110    {
1111      trackEffects(ref2.dep || (ref2.dep = createDep()));
1112    }
1113  }
1114}
1115function triggerRefValue(ref2, newVal) {
1116  ref2 = toRaw(ref2);
1117  const dep = ref2.dep;
1118  if (dep) {
1119    {
1120      triggerEffects(dep);
1121    }
1122  }
1123}
1124function isRef(r) {
1125  return !!(r && r.__v_isRef === true);
1126}
1127function ref(value) {
1128  return createRef(value, false);
1129}
1130function shallowRef(value) {
1131  return createRef(value, true);
1132}
1133function createRef(rawValue, shallow) {
1134  if (isRef(rawValue)) {
1135    return rawValue;
1136  }
1137  return new RefImpl(rawValue, shallow);
1138}
1139class RefImpl {

1140  constructor(value, __v_isShallow) {
1141    this.__v_isShallow = __v_isShallow;
1142    this.dep = void 0;
1143    this.__v_isRef = true;
1144    this._rawValue = __v_isShallow ? value : toRaw(value);
1145    this._value = __v_isShallow ? value : toReactive(value);
1146  }
1147  get value() {
1148    trackRefValue(this);
1149    return this._value;
1150  }
1151  set value(newVal) {
1152    const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
1153    newVal = useDirectValue ? newVal : toRaw(newVal);
1154    if (hasChanged(newVal, this._rawValue)) {
1155      this._rawValue = newVal;
1156      this._value = useDirectValue ? newVal : toReactive(newVal);
1157      triggerRefValue(this);
1158    }
1159  }
1160}
1161function triggerRef(ref2) {
1162  triggerRefValue(ref2);
1163}
1164function unref(ref2) {
1165  return isRef(ref2) ? ref2.value : ref2;
1166}
1167function toValue(source) {
1168  return isFunction$4(source) ? source() : unref(source);
1169}
1170const shallowUnwrapHandlers = {
1171  get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
1172  set: (target, key, value, receiver) => {
1173    const oldValue = target[key];
1174    if (isRef(oldValue) && !isRef(value)) {
1175      oldValue.value = value;
1176      return true;
1177    } else {
1178      return Reflect.set(target, key, value, receiver);
1179    }
1180  }
1181};
1182function proxyRefs(objectWithRefs) {
1183  return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
1184}
1185class CustomRefImpl {
1186  constructor(factory) {
1187    this.dep = void 0;
1188    this.__v_isRef = true;
1189    const { get: get2, set: set2 } = factory(
1190      () => trackRefValue(this),
1191      () => triggerRefValue(this)
1192    );
1193    this._get = get2;
1194    this._set = set2;
1195  }
1196  get value() {
1197    return this._get();
1198  }
1199  set value(newVal) {
1200    this._set(newVal);
1201  }
1202}
1203function customRef(factory) {
1204  return new CustomRefImpl(factory);
1205}
1206function toRefs(object4) {
1207  const ret = isArray$5(object4) ? new Array(object4.length) : {};
1208  for (const key in object4) {
1209    ret[key] = propertyToRef(object4, key);
1210  }
1211  return ret;
1212}
1213class ObjectRefImpl {
1214  constructor(_object, _key, _defaultValue) {
1215    this._object = _object;
1216    this._key = _key;
1217    this._defaultValue = _defaultValue;
1218    this.__v_isRef = true;
1219  }
1220  get value() {
1221    const val = this._object[this._key];
1222    return val === void 0 ? this._defaultValue : val;
1223  }
1224  set value(newVal) {
1225    this._object[this._key] = newVal;
1226  }
1227  get dep() {
1228    return getDepFromReactive(toRaw(this._object), this._key);
1229  }
1230}
1231class GetterRefImpl {
1232  constructor(_getter) {
1233    this._getter = _getter;
1234    this.__v_isRef = true;
1235    this.__v_isReadonly = true;
1236  }
1237  get value() {
1238    return this._getter();
1239  }
1240}
1241function toRef(source, key, defaultValue) {
1242  if (isRef(source)) {
1243    return source;
1244  } else if (isFunction$4(source)) {
1245    return new GetterRefImpl(source);
1246  } else if (isObject$3(source) && arguments.length > 1) {
1247    return propertyToRef(source, key, defaultValue);
1248  } else {
1249    return ref(source);
1250  }
1251}
1252function propertyToRef(source, key, defaultValue) {
1253  const val = source[key];
1254  return isRef(val) ? val : new ObjectRefImpl(
1255    source,
1256    key,
1257    defaultValue
1258  );
1259}
1260class ComputedRefImpl {
1261  constructor(getter, _setter, isReadonly2, isSSR) {
1262    this._setter = _setter;
1263    this.dep = void 0;
1264    this.__v_isRef = true;
1265    this["__v_isReadonly"] = false;
1266    this._dirty = true;
1267    this.effect = new ReactiveEffect(getter, () => {
1268      if (!this._dirty) {
1269        this._dirty = true;
1270        triggerRefValue(this);
1271      }
1272    });
1273    this.effect.computed = this;
1274    this.effect.active = this._cacheable = !isSSR;
1275    this["__v_isReadonly"] = isReadonly2;
1276  }
1277  get value() {
1278    const self2 = toRaw(this);
1279    trackRefValue(self2);
1280    if (self2._dirty || !self2._cacheable) {
1281      self2._dirty = false;
1282      self2._value = self2.effect.run();
1283    }
1284    return self2._value;
1285  }
1286  set value(newValue) {
1287    this._setter(newValue);
1288  }
1289}
1290function computed$1(getterOrOptions, debugOptions, isSSR = false) {
1291  let getter;
1292  let setter;
1293  const onlyGetter = isFunction$4(getterOrOptions);
1294  if (onlyGetter) {
1295    getter = getterOrOptions;
1296    setter = NOOP;
1297  } else {
1298    getter = getterOrOptions.get;
1299    setter = getterOrOptions.set;
1300  }
1301  const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
1302  return cRef;
1303}
1304function warn$4(msg2, ...args) {
1305  return;
1306}
1307function assertNumber(val, type4) {
1308  return;
1309}
1310function callWithErrorHandling(fn, instance, type4, args) {
1311  let res;
1312  try {
1313    res = args ? fn(...args) : fn();
1314  } catch (err) {
1315    handleError(err, instance, type4);
1316  }
1317  return res;
1318}
1319function callWithAsyncErrorHandling(fn, instance, type4, args) {
1320  if (isFunction$4(fn)) {
1321    const res = callWithErrorHandling(fn, instance, type4, args);
1322    if (res && isPromise(res)) {
1323      res.catch((err) => {
1324        handleError(err, instance, type4);
1325      });
1326    }
1327    return res;
1328  }
1329  const values = [];
1330  for (let i = 0; i < fn.length; i++) {
1331    values.push(callWithAsyncErrorHandling(fn[i], instance, type4, args));
1332  }
1333  return values;
1334}
1335function handleError(err, instance, type4, throwInDev = true) {
1336  const contextVNode = instance ? instance.vnode : null;
1337  if (instance) {

1338    let cur = instance.parent;
1339    const exposedInstance = instance.proxy;
1340    const errorInfo = type4;
1341    while (cur) {
1342      const errorCapturedHooks = cur.ec;
1343      if (errorCapturedHooks) {
1344        for (let i = 0; i < errorCapturedHooks.length; i++) {
1345          if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
1346            return;
1347          }
1348        }
1349      }
1350      cur = cur.parent;
1351    }
1352    const appErrorHandler = instance.appContext.config.errorHandler;
1353    if (appErrorHandler) {
1354      callWithErrorHandling(
1355        appErrorHandler,
1356        null,
1357        10,
1358        [err, exposedInstance, errorInfo]
1359      );
1360      return;
1361    }
1362  }
1363  logError(err, type4, contextVNode, throwInDev);
1364}
1365function logError(err, type4, contextVNode, throwInDev = true) {
1366  {
1367    console.error(err);
1368  }
1369}
1370let isFlushing = false;
1371let isFlushPending = false;
1372const queue = [];
1373let flushIndex = 0;
1374const pendingPostFlushCbs = [];
1375let activePostFlushCbs = null;
1376let postFlushIndex = 0;
1377const resolvedPromise = /* @__PURE__ */ Promise.resolve();
1378let currentFlushPromise = null;
1379function nextTick(fn) {
1380  const p2 = currentFlushPromise || resolvedPromise;
1381  return fn ? p2.then(this ? fn.bind(this) : fn) : p2;
1382}
1383function findInsertionIndex(id) {
1384  let start = flushIndex + 1;
1385  let end = queue.length;
1386  while (start < end) {
1387    const middle = start + end >>> 1;
1388    const middleJobId = getId(queue[middle]);
1389    middleJobId < id ? start = middle + 1 : end = middle;
1390  }
1391  return start;
1392}
1393function queueJob(job) {
1394  if (!queue.length || !queue.includes(
1395    job,
1396    isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex
1397  )) {
1398    if (job.id == null) {
1399      queue.push(job);
1400    } else {
1401      queue.splice(findInsertionIndex(job.id), 0, job);
1402    }
1403    queueFlush();
1404  }
1405}
1406function queueFlush() {
1407  if (!isFlushing && !isFlushPending) {
1408    isFlushPending = true;
1409    currentFlushPromise = resolvedPromise.then(flushJobs);
1410  }
1411}

1412function invalidateJob(job) {
1413  const i = queue.indexOf(job);
1414  if (i > flushIndex) {
1415    queue.splice(i, 1);
1416  }
1417}
1418function queuePostFlushCb(cb) {
1419  if (!isArray$5(cb)) {
1420    if (!activePostFlushCbs || !activePostFlushCbs.includes(
1421      cb,
1422      cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex
1423    )) {
1424      pendingPostFlushCbs.push(cb);
1425    }
1426  } else {
1427    pendingPostFlushCbs.push(...cb);
1428  }
1429  queueFlush();
1430}
1431function flushPreFlushCbs(seen, i = isFlushing ? flushIndex + 1 : 0) {
1432  for (; i < queue.length; i++) {
1433    const cb = queue[i];
1434    if (cb && cb.pre) {
1435      queue.splice(i, 1);
1436      i--;
1437      cb();
1438    }
1439  }
1440}
1441function flushPostFlushCbs(seen) {
1442  if (pendingPostFlushCbs.length) {
1443    const deduped = [...new Set(pendingPostFlushCbs)];
1444    pendingPostFlushCbs.length = 0;
1445    if (activePostFlushCbs) {
1446      activePostFlushCbs.push(...deduped);
1447      return;
1448    }
1449    activePostFlushCbs = deduped;
1450    activePostFlushCbs.sort((a, b) => getId(a) - getId(b));
1451    for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
1452      activePostFlushCbs[postFlushIndex]();
1453    }
1454    activePostFlushCbs = null;
1455    postFlushIndex = 0;
1456  }
1457}
1458const getId = (job) => job.id == null ? Infinity : job.id;
1459const comparator = (a, b) => {
1460  const diff2 = getId(a) - getId(b);
1461  if (diff2 === 0) {
1462    if (a.pre && !b.pre)
1463      return -1;
1464    if (b.pre && !a.pre)
1465      return 1;
1466  }
1467  return diff2;
1468};
1469function flushJobs(seen) {
1470  isFlushPending = false;
1471  isFlushing = true;
1472  queue.sort(comparator);
1473  const check = NOOP;
1474  try {
1475    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
1476      const job = queue[flushIndex];
1477      if (job && job.active !== false) {
1478        if (false)
1479          ;
1480        callWithErrorHandling(job, null, 14);
1481      }
1482    }
1483  } finally {
1484    flushIndex = 0;
1485    queue.length = 0;
1486    flushPostFlushCbs();
1487    isFlushing = false;
1488    currentFlushPromise = null;
1489    if (queue.length || pendingPostFlushCbs.length) {
1490      flushJobs();
1491    }
1492  }
1493}
1494let devtools;
1495let buffer = [];
1496function setDevtoolsHook(hook, target) {
1497  var _a2, _b;
1498  devtools = hook;
1499  if (devtools) {
1500    devtools.enabled = true;
1501    buffer.forEach(({ event, args }) => devtools.emit(event, ...args));
1502    buffer = [];
1503  } else if (
1504    // handle late devtools injection - only do this if we are in an actual
1505    // browser environment to avoid the timer handle stalling test runner exit
1506    // (#4815)
1507    typeof window !== "undefined" && // some envs mock window but not fully
1508    window.HTMLElement && // also exclude jsdom
1509    !((_b = (_a2 = window.navigator) == null ? void 0 : _a2.userAgent) == null ? void 0 : _b.includes("jsdom"))
1510  ) {
1511    const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
1512    replay.push((newHook) => {
1513      setDevtoolsHook(newHook, target);
1514    });
1515    setTimeout(() => {
1516      if (!devtools) {
1517        target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
1518        buffer = [];
1519      }
1520    }, 3e3);
1521  } else {
1522    buffer = [];
1523  }
1524}
1525function emit(instance, event, ...rawArgs) {
1526  if (instance.isUnmounted)
1527    return;
1528  const props = instance.vnode.props || EMPTY_OBJ;
1529  let args = rawArgs;
1530  const isModelListener2 = event.startsWith("update:");
1531  const modelArg = isModelListener2 && event.slice(7);
1532  if (modelArg && modelArg in props) {
1533    const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`;
1534    const { number: number4, trim: trim2 } = props[modifiersKey] || EMPTY_OBJ;
1535    if (trim2) {
1536      args = rawArgs.map((a) => isString$3(a) ? a.trim() : a);
1537    }
1538    if (number4) {
1539      args = rawArgs.map(looseToNumber);
1540    }
1541  }
1542  let handlerName;
1543  let handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249)
1544  props[handlerName = toHandlerKey(camelize(event))];
1545  if (!handler && isModelListener2) {
1546    handler = props[handlerName = toHandlerKey(hyphenate(event))];
1547  }
1548  if (handler) {
1549    callWithAsyncErrorHandling(
1550      handler,
1551      instance,
1552      6,
1553      args
1554    );
1555  }
1556  const onceHandler = props[handlerName + `Once`];
1557  if (onceHandler) {
1558    if (!instance.emitted) {
1559      instance.emitted = {};
1560    } else if (instance.emitted[handlerName]) {
1561      return;
1562    }
1563    instance.emitted[handlerName] = true;
1564    callWithAsyncErrorHandling(
1565      onceHandler,
1566      instance,
1567      6,
1568      args
1569    );
1570  }
1571}
1572function normalizeEmitsOptions(comp, appContext, asMixin = false) {
1573  const cache2 = appContext.emitsCache;

1574  const cached = cache2.get(comp);
1575  if (cached !== void 0) {
1576    return cached;
1577  }
1578  const raw = comp.emits;
1579  let normalized = {};
1580  let hasExtends = false;
1581  if (!isFunction$4(comp)) {
1582    const extendEmits = (raw2) => {
1583      const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
1584      if (normalizedFromExtend) {
1585        hasExtends = true;
1586        extend$1(normalized, normalizedFromExtend);
1587      }
1588    };
1589    if (!asMixin && appContext.mixins.length) {
1590      appContext.mixins.forEach(extendEmits);
1591    }
1592    if (comp.extends) {
1593      extendEmits(comp.extends);
1594    }
1595    if (comp.mixins) {
1596      comp.mixins.forEach(extendEmits);
1597    }
1598  }
1599  if (!raw && !hasExtends) {
1600    if (isObject$3(comp)) {
1601      cache2.set(comp, null);
1602    }
1603    return null;
1604  }
1605  if (isArray$5(raw)) {
1606    raw.forEach((key) => normalized[key] = null);
1607  } else {
1608    extend$1(normalized, raw);
1609  }
1610  if (isObject$3(comp)) {
1611    cache2.set(comp, normalized);
1612  }
1613  return normalized;
1614}
1615function isEmitListener(options, key) {
1616  if (!options || !isOn(key)) {
1617    return false;
1618  }
1619  key = key.slice(2).replace(/Once$/, "");
1620  return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
1621}
1622let currentRenderingInstance = null;
1623let currentScopeId = null;
1624function setCurrentRenderingInstance(instance) {
1625  const prev = currentRenderingInstance;
1626  currentRenderingInstance = instance;
1627  currentScopeId = instance && instance.type.__scopeId || null;
1628  return prev;
1629}
1630function pushScopeId(id) {
1631  currentScopeId = id;
1632}
1633function popScopeId() {
1634  currentScopeId = null;
1635}
1636const withScopeId = (_id) => withCtx;
1637function withCtx(fn, ctx2 = currentRenderingInstance, isNonScopedSlot) {
1638  if (!ctx2)
1639    return fn;
1640  if (fn._n) {
1641    return fn;
1642  }
1643  const renderFnWithContext = (...args) => {
1644    if (renderFnWithContext._d) {
1645      setBlockTracking(-1);
1646    }
1647    const prevInstance = setCurrentRenderingInstance(ctx2);
1648    let res;
1649    try {
1650      res = fn(...args);
1651    } finally {
1652      setCurrentRenderingInstance(prevInstance);
1653      if (renderFnWithContext._d) {
1654        setBlockTracking(1);
1655      }
1656    }
1657    return res;
1658  };
1659  renderFnWithContext._n = true;
1660  renderFnWithContext._c = true;
1661  renderFnWithContext._d = true;
1662  return renderFnWithContext;
1663}
1664function markAttrsAccessed() {
1665}
1666function renderComponentRoot(instance) {
1667  const {
1668    type: Component,
1669    vnode,
1670    proxy,
1671    withProxy,
1672    props,
1673    propsOptions: [propsOptions],
1674    slots,
1675    attrs,
1676    emit: emit2,
1677    render: render2,
1678    renderCache,
1679    data: data2,
1680    setupState,
1681    ctx: ctx2,
1682    inheritAttrs
1683  } = instance;
1684  let result;
1685  let fallthroughAttrs;
1686  const prev = setCurrentRenderingInstance(instance);
1687  try {
1688    if (vnode.shapeFlag & 4) {
1689      const proxyToUse = withProxy || proxy;
1690      result = normalizeVNode(
1691        render2.call(
1692          proxyToUse,
1693          proxyToUse,
1694          renderCache,
1695          props,
1696          setupState,
1697          data2,
1698          ctx2
1699        )
1700      );
1701      fallthroughAttrs = attrs;
1702    } else {
1703      const render22 = Component;
1704      if (false)
1705        ;
1706      result = normalizeVNode(
1707        render22.length > 1 ? render22(
1708          props,
1709          false ? {
1710            get attrs() {
1711              markAttrsAccessed();
1712              return attrs;
1713            },
1714            slots,
1715            emit: emit2
1716          } : { attrs, slots, emit: emit2 }
1717        ) : render22(
1718          props,
1719          null
1720          /* we know it doesn't need it */
1721        )
1722      );
1723      fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
1724    }
1725  } catch (err) {
1726    blockStack.length = 0;
1727    handleError(err, instance, 1);
1728    result = createVNode(Comment);
1729  }
1730  let root2 = result;
1731  if (fallthroughAttrs && inheritAttrs !== false) {
1732    const keys2 = Object.keys(fallthroughAttrs);
1733    const { shapeFlag } = root2;
1734    if (keys2.length) {
1735      if (shapeFlag & (1 | 6)) {
1736        if (propsOptions && keys2.some(isModelListener)) {
1737          fallthroughAttrs = filterModelListeners(
1738            fallthroughAttrs,
1739            propsOptions
1740          );
1741        }
1742        root2 = cloneVNode(root2, fallthroughAttrs);
1743      }
1744    }
1745  }
1746  if (vnode.dirs) {
1747    root2 = cloneVNode(root2);
1748    root2.dirs = root2.dirs ? root2.dirs.concat(vnode.dirs) : vnode.dirs;
1749  }
1750  if (vnode.transition) {
1751    root2.transition = vnode.transition;
1752  }
1753  {
1754    result = root2;
1755  }
1756  setCurrentRenderingInstance(prev);
1757  return result;
1758}
1759function filterSingleRoot(children) {
1760  let singleRoot;
1761  for (let i = 0; i < children.length; i++) {
1762    const child = children[i];
1763    if (isVNode(child)) {
1764      if (child.type !== Comment || child.children === "v-if") {
1765        if (singleRoot) {
1766          return;
1767        } else {
1768          singleRoot = child;
1769        }
1770      }
1771    } else {
1772      return;
1773    }
1774  }
1775  return singleRoot;
1776}
1777const getFunctionalFallthrough = (attrs) => {
1778  let res;
1779  for (const key in attrs) {
1780    if (key === "class" || key === "style" || isOn(key)) {
1781      (res || (res = {}))[key] = attrs[key];
1782    }
1783  }
1784  return res;
1785};
1786const filterModelListeners = (attrs, props) => {
1787  const res = {};
1788  for (const key in attrs) {
1789    if (!isModelListener(key) || !(key.slice(9) in props)) {
1790      res[key] = attrs[key];
1791    }
1792  }
1793  return res;
1794};
1795function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
1796  const { props: prevProps, children: prevChildren, component } = prevVNode;
1797  const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
1798  const emits = component.emitsOptions;
1799  if (nextVNode.dirs || nextVNode.transition) {
1800    return true;
1801  }
1802  if (optimized && patchFlag >= 0) {
1803    if (patchFlag & 1024) {
1804      return true;
1805    }
1806    if (patchFlag & 16) {
1807      if (!prevProps) {
1808        return !!nextProps;
1809      }
1810      return hasPropsChanged(prevProps, nextProps, emits);
1811    } else if (patchFlag & 8) {
1812      const dynamicProps = nextVNode.dynamicProps;
1813      for (let i = 0; i < dynamicProps.length; i++) {

1814        const key = dynamicProps[i];
1815        if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
1816          return true;
1817        }
1818      }
1819    }
1820  } else {
1821    if (prevChildren || nextChildren) {
1822      if (!nextChildren || !nextChildren.$stable) {
1823        return true;
1824      }
1825    }
1826    if (prevProps === nextProps) {
1827      return false;
1828    }
1829    if (!prevProps) {
1830      return !!nextProps;
1831    }
1832    if (!nextProps) {
1833      return true;
1834    }
1835    return hasPropsChanged(prevProps, nextProps, emits);
1836  }
1837  return false;
1838}
1839function hasPropsChanged(prevProps, nextProps, emitsOptions) {
1840  const nextKeys = Object.keys(nextProps);
1841  if (nextKeys.length !== Object.keys(prevProps).length) {
1842    return true;
1843  }
1844  for (let i = 0; i < nextKeys.length; i++) {
1845    const key = nextKeys[i];
1846    if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
1847      return true;
1848    }
1849  }
1850  return false;
1851}
1852function updateHOCHostEl({ vnode, parent }, el) {
1853  while (parent && parent.subTree === vnode) {
1854    (vnode = parent.vnode).el = el;
1855    parent = parent.parent;
1856  }
1857}
1858const isSuspense = (type4) => type4.__isSuspense;
1859const SuspenseImpl = {
1860  name: "Suspense",
1861  // In order to make Suspense tree-shakable, we need to avoid importing it
1862  // directly in the renderer. The renderer checks for the __isSuspense flag
1863  // on a vnode's type and calls the `process` method, passing in renderer
1864  // internals.
1865  __isSuspense: true,
1866  process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG2, slotScopeIds, optimized, rendererInternals) {
1867    if (n1 == null) {
1868      mountSuspense(
1869        n2,
1870        container,
1871        anchor,
1872        parentComponent,
1873        parentSuspense,
1874        isSVG2,
1875        slotScopeIds,
1876        optimized,
1877        rendererInternals
1878      );
1879    } else {
1880      patchSuspense(
1881        n1,
1882        n2,
1883        container,
1884        anchor,
1885        parentComponent,
1886        isSVG2,
1887        slotScopeIds,
1888        optimized,
1889        rendererInternals
1890      );
1891    }
1892  },
1893  hydrate: hydrateSuspense,
1894  create: createSuspenseBoundary,
1895  normalize: normalizeSuspenseChildren
1896};
1897const Suspense = SuspenseImpl;
1898function triggerEvent(vnode, name) {
1899  const eventListener = vnode.props && vnode.props[name];
1900  if (isFunction$4(eventListener)) {
1901    eventListener();
1902  }
1903}
1904function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG2, slotScopeIds, optimized, rendererInternals) {
1905  const {
1906    p: patch,
1907    o: { createElement: createElement2 }
1908  } = rendererInternals;
1909  const hiddenContainer = createElement2("div");
1910  const suspense = vnode.suspense = createSuspenseBoundary(
1911    vnode,
1912    parentSuspense,
1913    parentComponent,
1914    container,
1915    hiddenContainer,
1916    anchor,
1917    isSVG2,
1918    slotScopeIds,
1919    optimized,
1920    rendererInternals
1921  );
1922  patch(
1923    null,
1924    suspense.pendingBranch = vnode.ssContent,
1925    hiddenContainer,
1926    null,
1927    parentComponent,
1928    suspense,
1929    isSVG2,
1930    slotScopeIds
1931  );
1932  if (suspense.deps > 0) {
1933    triggerEvent(vnode, "onPending");
1934    triggerEvent(vnode, "onFallback");
1935    patch(
1936      null,
1937      vnode.ssFallback,
1938      container,
1939      anchor,
1940      parentComponent,
1941      null,
1942      // fallback tree will not have suspense context
1943      isSVG2,
1944      slotScopeIds
1945    );
1946    setActiveBranch(suspense, vnode.ssFallback);
1947  } else {
1948    suspense.resolve(false, true);
1949  }
1950}
1951function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG2, slotScopeIds, optimized, { p: patch, um: unmount2, o: { createElement: createElement2 } }) {
1952  const suspense = n2.suspense = n1.suspense;
1953  suspense.vnode = n2;
1954  n2.el = n1.el;
1955  const newBranch = n2.ssContent;
1956  const newFallback = n2.ssFallback;
1957  const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
1958  if (pendingBranch) {
1959    suspense.pendingBranch = newBranch;
1960    if (isSameVNodeType(newBranch, pendingBranch)) {
1961      patch(
1962        pendingBranch,
1963        newBranch,
1964        suspense.hiddenContainer,
1965        null,
1966        parentComponent,
1967        suspense,
1968        isSVG2,
1969        slotScopeIds,
1970        optimized
1971      );
1972      if (suspense.deps <= 0) {
1973        suspense.resolve();
1974      } else if (isInFallback) {
1975        patch(
1976          activeBranch,
1977          newFallback,
1978          container,
1979          anchor,
1980          parentComponent,
1981          null,
1982          // fallback tree will not have suspense context
1983          isSVG2,
1984          slotScopeIds,
1985          optimized
1986        );

1987        setActiveBranch(suspense, newFallback);
1988      }
1989    } else {
1990      suspense.pendingId++;
1991      if (isHydrating) {
1992        suspense.isHydrating = false;
1993        suspense.activeBranch = pendingBranch;
1994      } else {
1995        unmount2(pendingBranch, parentComponent, suspense);
1996      }
1997      suspense.deps = 0;
1998      suspense.effects.length = 0;
1999      suspense.hiddenContainer = createElement2("div");
2000      if (isInFallback) {
2001        patch(
2002          null,
2003          newBranch,
2004          suspense.hiddenContainer,
2005          null,
2006          parentComponent,
2007          suspense,
2008          isSVG2,
2009          slotScopeIds,
2010          optimized
2011        );
2012        if (suspense.deps <= 0) {
2013          suspense.resolve();
2014        } else {
2015          patch(
2016            activeBranch,
2017            newFallback,
2018            container,
2019            anchor,
2020            parentComponent,
2021            null,
2022            // fallback tree will not have suspense context
2023            isSVG2,
2024            slotScopeIds,
2025            optimized
2026          );

2027          setActiveBranch(suspense, newFallback);
2028        }
2029      } else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
2030        patch(
2031          activeBranch,
2032          newBranch,
2033          container,
2034          anchor,
2035          parentComponent,
2036          suspense,
2037          isSVG2,
2038          slotScopeIds,
2039          optimized
2040        );
2041        suspense.resolve(true);
2042      } else {
2043        patch(
2044          null,
2045          newBranch,
2046          suspense.hiddenContainer,
2047          null,
2048          parentComponent,
2049          suspense,
2050          isSVG2,
2051          slotScopeIds,
2052          optimized
2053        );
2054        if (suspense.deps <= 0) {
2055          suspense.resolve();
2056        }
2057      }
2058    }
2059  } else {
2060    if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
2061      patch(
2062        activeBranch,
2063        newBranch,
2064        container,
2065        anchor,
2066        parentComponent,
2067        suspense,
2068        isSVG2,
2069        slotScopeIds,
2070        optimized
2071      );
2072      setActiveBranch(suspense, newBranch);
2073    } else {
2074      triggerEvent(n2, "onPending");
2075      suspense.pendingBranch = newBranch;
2076      suspense.pendingId++;
2077      patch(
2078        null,
2079        newBranch,
2080        suspense.hiddenContainer,
2081        null,
2082        parentComponent,
2083        suspense,
2084        isSVG2,
2085        slotScopeIds,
2086        optimized
2087      );
2088      if (suspense.deps <= 0) {
2089        suspense.resolve();
2090      } else {
2091        const { timeout, pendingId } = suspense;
2092        if (timeout > 0) {
2093          setTimeout(() => {
2094            if (suspense.pendingId === pendingId) {
2095              suspense.fallback(newFallback);
2096            }
2097          }, timeout);
2098        } else if (timeout === 0) {
2099          suspense.fallback(newFallback);
2100        }
2101      }
2102    }
2103  }
2104}
2105function createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG2, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
2106  const {
2107    p: patch,
2108    m: move2,
2109    um: unmount2,
2110    n: next,
2111    o: { parentNode, remove: remove2 }
2112  } = rendererInternals;
2113  let parentSuspenseId;
2114  const isSuspensible = isVNodeSuspensible(vnode);
2115  if (isSuspensible) {
2116    if (parentSuspense == null ? void 0 : parentSuspense.pendingBranch) {
2117      parentSuspenseId = parentSuspense.pendingId;
2118      parentSuspense.deps++;
2119    }
2120  }
2121  const timeout = vnode.props ? toNumber(vnode.props.timeout) : void 0;
2122  const suspense = {
2123    vnode,
2124    parent: parentSuspense,
2125    parentComponent,
2126    isSVG: isSVG2,
2127    container,
2128    hiddenContainer,
2129    anchor,
2130    deps: 0,
2131    pendingId: 0,
2132    timeout: typeof timeout === "number" ? timeout : -1,
2133    activeBranch: null,
2134    pendingBranch: null,
2135    isInFallback: true,
2136    isHydrating,
2137    isUnmounted: false,
2138    effects: [],
2139    resolve(resume = false, sync = false) {
2140      const {
2141        vnode: vnode2,
2142        activeBranch,
2143        pendingBranch,
2144        pendingId,
2145        effects,
2146        parentComponent: parentComponent2,
2147        container: container2
2148      } = suspense;
2149      if (suspense.isHydrating) {
2150        suspense.isHydrating = false;
2151      } else if (!resume) {
2152        const delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
2153        if (delayEnter) {
2154          activeBranch.transition.afterLeave = () => {
2155            if (pendingId === suspense.pendingId) {
2156              move2(pendingBranch, container2, anchor2, 0);
2157            }
2158          };
2159        }
2160        let { anchor: anchor2 } = suspense;
2161        if (activeBranch) {
2162          anchor2 = next(activeBranch);
2163          unmount2(activeBranch, parentComponent2, suspense, true);
2164        }
2165        if (!delayEnter) {
2166          move2(pendingBranch, container2, anchor2, 0);
2167        }
2168      }
2169      setActiveBranch(suspense, pendingBranch);
2170      suspense.pendingBranch = null;
2171      suspense.isInFallback = false;
2172      let parent = suspense.parent;
2173      let hasUnresolvedAncestor = false;
2174      while (parent) {
2175        if (parent.pendingBranch) {
2176          parent.effects.push(...effects);
2177          hasUnresolvedAncestor = true;
2178          break;
2179        }
2180        parent = parent.parent;
2181      }
2182      if (!hasUnresolvedAncestor) {
2183        queuePostFlushCb(effects);
2184      }
2185      suspense.effects = [];
2186      if (isSuspensible) {
2187        if (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) {
2188          parentSuspense.deps--;
2189          if (parentSuspense.deps === 0 && !sync) {
2190            parentSuspense.resolve();
2191          }
2192        }
2193      }
2194      triggerEvent(vnode2, "onResolve");
2195    },
2196    fallback(fallbackVNode) {
2197      if (!suspense.pendingBranch) {
2198        return;
2199      }
2200      const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, isSVG: isSVG22 } = suspense;
2201      triggerEvent(vnode2, "onFallback");
2202      const anchor2 = next(activeBranch);
2203      const mountFallback = () => {
2204        if (!suspense.isInFallback) {
2205          return;
2206        }
2207        patch(
2208          null,
2209          fallbackVNode,
2210          container2,
2211          anchor2,
2212          parentComponent2,
2213          null,
2214          // fallback tree will not have suspense context
2215          isSVG22,
2216          slotScopeIds,
2217          optimized
2218        );

2219        setActiveBranch(suspense, fallbackVNode);
2220      };
2221      const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in";
2222      if (delayEnter) {
2223        activeBranch.transition.afterLeave = mountFallback;
2224      }
2225      suspense.isInFallback = true;
2226      unmount2(
2227        activeBranch,
2228        parentComponent2,
2229        null,
2230        // no suspense so unmount hooks fire now
2231        true
2232        // shouldRemove
2233      );
2234      if (!delayEnter) {
2235        mountFallback();
2236      }
2237    },
2238    move(container2, anchor2, type4) {
2239      suspense.activeBranch && move2(suspense.activeBranch, container2, anchor2, type4);
2240      suspense.container = container2;
2241    },
2242    next() {
2243      return suspense.activeBranch && next(suspense.activeBranch);
2244    },
2245    registerDep(instance, setupRenderEffect) {
2246      const isInPendingSuspense = !!suspense.pendingBranch;
2247      if (isInPendingSuspense) {
2248        suspense.deps++;
2249      }
2250      const hydratedEl = instance.vnode.el;
2251      instance.asyncDep.catch((err) => {
2252        handleError(err, instance, 0);
2253      }).then((asyncSetupResult) => {
2254        if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) {
2255          return;
2256        }
2257        instance.asyncResolved = true;
2258        const { vnode: vnode2 } = instance;
2259        handleSetupResult(instance, asyncSetupResult, false);
2260        if (hydratedEl) {
2261          vnode2.el = hydratedEl;
2262        }
2263        const placeholder = !hydratedEl && instance.subTree.el;
2264        setupRenderEffect(
2265          instance,
2266          vnode2,
2267          // component may have been moved before resolve.
2268          // if this is not a hydration, instance.subTree will be the comment
2269          // placeholder.
2270          parentNode(hydratedEl || instance.subTree.el),
2271          // anchor will not be used if this is hydration, so only need to
2272          // consider the comment placeholder case.
2273          hydratedEl ? null : next(instance.subTree),
2274          suspense,
2275          isSVG2,
2276          optimized
2277        );
2278        if (placeholder) {
2279          remove2(placeholder);
2280        }
2281        updateHOCHostEl(instance, vnode2.el);
2282        if (isInPendingSuspense && --suspense.deps === 0) {
2283          suspense.resolve();
2284        }
2285      });
2286    },
2287    unmount(parentSuspense2, doRemove) {
2288      suspense.isUnmounted = true;
2289      if (suspense.activeBranch) {
2290        unmount2(
2291          suspense.activeBranch,
2292          parentComponent,
2293          parentSuspense2,
2294          doRemove
2295        );
2296      }
2297      if (suspense.pendingBranch) {
2298        unmount2(
2299          suspense.pendingBranch,
2300          parentComponent,
2301          parentSuspense2,
2302          doRemove
2303        );
2304      }
2305    }
2306  };
2307  return suspense;
2308}
2309function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG2, slotScopeIds, optimized, rendererInternals, hydrateNode) {
2310  const suspense = vnode.suspense = createSuspenseBoundary(
2311    vnode,
2312    parentSuspense,
2313    parentComponent,
2314    node.parentNode,
2315    document.createElement("div"),
2316    null,
2317    isSVG2,
2318    slotScopeIds,
2319    optimized,
2320    rendererInternals,
2321    true
2322    /* hydrating */
2323  );
2324  const result = hydrateNode(
2325    node,
2326    suspense.pendingBranch = vnode.ssContent,
2327    parentComponent,
2328    suspense,
2329    slotScopeIds,
2330    optimized
2331  );
2332  if (suspense.deps === 0) {
2333    suspense.resolve(false, true);
2334  }
2335  return result;
2336}
2337function normalizeSuspenseChildren(vnode) {
2338  const { shapeFlag, children } = vnode;
2339  const isSlotChildren = shapeFlag & 32;
2340  vnode.ssContent = normalizeSuspenseSlot(
2341    isSlotChildren ? children.default : children
2342  );
2343  vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment);
2344}
2345function normalizeSuspenseSlot(s2) {
2346  let block;
2347  if (isFunction$4(s2)) {
2348    const trackBlock = isBlockTreeEnabled && s2._c;
2349    if (trackBlock) {
2350      s2._d = false;
2351      openBlock();
2352    }
2353    s2 = s2();
2354    if (trackBlock) {
2355      s2._d = true;
2356      block = currentBlock;
2357      closeBlock();
2358    }
2359  }
2360  if (isArray$5(s2)) {
2361    const singleChild = filterSingleRoot(s2);
2362    s2 = singleChild;
2363  }
2364  s2 = normalizeVNode(s2);
2365  if (block && !s2.dynamicChildren) {
2366    s2.dynamicChildren = block.filter((c2) => c2 !== s2);
2367  }
2368  return s2;
2369}
2370function queueEffectWithSuspense(fn, suspense) {
2371  if (suspense && suspense.pendingBranch) {
2372    if (isArray$5(fn)) {
2373      suspense.effects.push(...fn);
2374    } else {
2375      suspense.effects.push(fn);
2376    }
2377  } else {
2378    queuePostFlushCb(fn);
2379  }
2380}
2381function setActiveBranch(suspense, branch) {
2382  suspense.activeBranch = branch;
2383  const { vnode, parentComponent } = suspense;
2384  const el = vnode.el = branch.el;
2385  if (parentComponent && parentComponent.subTree === vnode) {
2386    parentComponent.vnode.el = el;
2387    updateHOCHostEl(parentComponent, el);
2388  }
2389}
2390function isVNodeSuspensible(vnode) {
2391  var _a2;
2392  return ((_a2 = vnode.props) == null ? void 0 : _a2.suspensible) != null && vnode.props.suspensible !== false;
2393}
2394function watchEffect(effect2, options) {
2395  return doWatch(effect2, null, options);
2396}
2397function watchPostEffect(effect2, options) {
2398  return doWatch(
2399    effect2,
2400    null,
2401    { flush: "post" }
2402  );
2403}
2404function watchSyncEffect(effect2, options) {
2405  return doWatch(
2406    effect2,
2407    null,
2408    { flush: "sync" }
2409  );
2410}
2411const INITIAL_WATCHER_VALUE = {};
2412function watch(source, cb, options) {
2413  return doWatch(source, cb, options);
2414}
2415function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ) {
2416  var _a2;
2417  const instance = getCurrentScope() === ((_a2 = currentInstance) == null ? void 0 : _a2.scope) ? currentInstance : null;
2418  let getter;
2419  let forceTrigger = false;

2420  let isMultiSource = false;
2421  if (isRef(source)) {
2422    getter = () => source.value;
2423    forceTrigger = isShallow(source);
2424  } else if (isReactive(source)) {
2425    getter = () => source;
2426    deep = true;
2427  } else if (isArray$5(source)) {
2428    isMultiSource = true;
2429    forceTrigger = source.some((s2) => isReactive(s2) || isShallow(s2));
2430    getter = () => source.map((s2) => {
2431      if (isRef(s2)) {
2432        return s2.value;
2433      } else if (isReactive(s2)) {
2434        return traverse(s2);
2435      } else if (isFunction$4(s2)) {
2436        return callWithErrorHandling(s2, instance, 2);
2437      } else
2438        ;
2439    });
2440  } else if (isFunction$4(source)) {
2441    if (cb) {
2442      getter = () => callWithErrorHandling(source, instance, 2);
2443    } else {
2444      getter = () => {
2445        if (instance && instance.isUnmounted) {
2446          return;
2447        }
2448        if (cleanup) {
2449          cleanup();
2450        }
2451        return callWithAsyncErrorHandling(
2452          source,
2453          instance,
2454          3,
2455          [onCleanup]
2456        );
2457      };
2458    }
2459  } else {
2460    getter = NOOP;
2461  }
2462  if (cb && deep) {
2463    const baseGetter = getter;
2464    getter = () => traverse(baseGetter());
2465  }
2466  let cleanup;
2467  let onCleanup = (fn) => {
2468    cleanup = effect2.onStop = () => {
2469      callWithErrorHandling(fn, instance, 4);
2470    };
2471  };
2472  let ssrCleanup;
2473  if (isInSSRComponentSetup) {
2474    onCleanup = NOOP;
2475    if (!cb) {
2476      getter();
2477    } else if (immediate) {
2478      callWithAsyncErrorHandling(cb, instance, 3, [
2479        getter(),
2480        isMultiSource ? [] : void 0,
2481        onCleanup
2482      ]);
2483    }
2484    if (flush === "sync") {
2485      const ctx2 = useSSRContext();
2486      ssrCleanup = ctx2.__watcherHandles || (ctx2.__watcherHandles = []);
2487    } else {
2488      return NOOP;
2489    }
2490  }
2491  let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
2492  const job = () => {
2493    if (!effect2.active) {
2494      return;
2495    }
2496    if (cb) {
2497      const newValue = effect2.run();
2498      if (deep || forceTrigger || (isMultiSource ? newValue.some(
2499        (v, i) => hasChanged(v, oldValue[i])
2500      ) : hasChanged(newValue, oldValue)) || false) {
2501        if (cleanup) {
2502          cleanup();
2503        }
2504        callWithAsyncErrorHandling(cb, instance, 3, [
2505          newValue,
2506          // pass undefined as the old value when it's changed for the first time
2507          oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
2508          onCleanup
2509        ]);
2510        oldValue = newValue;
2511      }
2512    } else {
2513      effect2.run();
2514    }
2515  };
2516  job.allowRecurse = !!cb;
2517  let scheduler2;
2518  if (flush === "sync") {
2519    scheduler2 = job;
2520  } else if (flush === "post") {
2521    scheduler2 = () => queuePostRenderEffect(job, instance && instance.suspense);
2522  } else {
2523    job.pre = true;
2524    if (instance)
2525      job.id = instance.uid;
2526    scheduler2 = () => queueJob(job);
2527  }
2528  const effect2 = new ReactiveEffect(getter, scheduler2);
2529  if (cb) {
2530    if (immediate) {
2531      job();
2532    } else {
2533      oldValue = effect2.run();
2534    }
2535  } else if (flush === "post") {
2536    queuePostRenderEffect(
2537      effect2.run.bind(effect2),
2538      instance && instance.suspense
2539    );
2540  } else {
2541    effect2.run();
2542  }
2543  const unwatch = () => {
2544    effect2.stop();
2545    if (instance && instance.scope) {
2546      remove(instance.scope.effects, effect2);
2547    }
2548  };
2549  if (ssrCleanup)
2550    ssrCleanup.push(unwatch);
2551  return unwatch;
2552}
2553function instanceWatch(source, value, options) {
2554  const publicThis = this.proxy;
2555  const getter = isString$3(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
2556  let cb;
2557  if (isFunction$4(value)) {
2558    cb = value;
2559  } else {
2560    cb = value.handler;
2561    options = value;
2562  }
2563  const cur = currentInstance;
2564  setCurrentInstance(this);
2565  const res = doWatch(getter, cb.bind(publicThis), options);
2566  if (cur) {
2567    setCurrentInstance(cur);
2568  } else {
2569    unsetCurrentInstance();
2570  }
2571  return res;
2572}
2573function createPathGetter(ctx2, path) {
2574  const segments = path.split(".");
2575  return () => {

2576    let cur = ctx2;
2577    for (let i = 0; i < segments.length && cur; i++) {
2578      cur = cur[segments[i]];
2579    }
2580    return cur;
2581  };
2582}
2583function traverse(value, seen) {
2584  if (!isObject$3(value) || value["__v_skip"]) {
2585    return value;
2586  }
2587  seen = seen || /* @__PURE__ */ new Set();
2588  if (seen.has(value)) {
2589    return value;
2590  }
2591  seen.add(value);
2592  if (isRef(value)) {
2593    traverse(value.value, seen);
2594  } else if (isArray$5(value)) {
2595    for (let i = 0; i < value.length; i++) {
2596      traverse(value[i], seen);
2597    }
2598  } else if (isSet$2(value) || isMap$2(value)) {
2599    value.forEach((v) => {
2600      traverse(v, seen);
2601    });
2602  } else if (isPlainObject$3(value)) {
2603    for (const key in value) {
2604      traverse(value[key], seen);
2605    }
2606  }
2607  return value;
2608}
2609function withDirectives(vnode, directives) {
2610  const internalInstance = currentRenderingInstance;
2611  if (internalInstance === null) {
2612    return vnode;
2613  }
2614  const instance = getExposeProxy(internalInstance) || internalInstance.proxy;
2615  const bindings = vnode.dirs || (vnode.dirs = []);
2616  for (let i = 0; i < directives.length; i++) {
2617    let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
2618    if (dir) {
2619      if (isFunction$4(dir)) {
2620        dir = {
2621          mounted: dir,
2622          updated: dir
2623        };
2624      }
2625      if (dir.deep) {
2626        traverse(value);
2627      }
2628      bindings.push({
2629        dir,
2630        instance,
2631        value,
2632        oldValue: void 0,
2633        arg,
2634        modifiers
2635      });
2636    }
2637  }
2638  return vnode;
2639}
2640function invokeDirectiveHook(vnode, prevVNode, instance, name) {
2641  const bindings = vnode.dirs;
2642  const oldBindings = prevVNode && prevVNode.dirs;
2643  for (let i = 0; i < bindings.length; i++) {
2644    const binding = bindings[i];
2645    if (oldBindings) {
2646      binding.oldValue = oldBindings[i].value;
2647    }
2648    let hook = binding.dir[name];
2649    if (hook) {
2650      pauseTracking();
2651      callWithAsyncErrorHandling(hook, instance, 8, [
2652        vnode.el,
2653        binding,
2654        vnode,
2655        prevVNode
2656      ]);
2657      resetTracking();
2658    }
2659  }
2660}
2661function useTransitionState() {
2662  const state = {
2663    isMounted: false,
2664    isLeaving: false,
2665    isUnmounting: false,
2666    leavingVNodes: /* @__PURE__ */ new Map()
2667  };
2668  onMounted(() => {
2669    state.isMounted = true;
2670  });
2671  onBeforeUnmount(() => {
2672    state.isUnmounting = true;
2673  });
2674  return state;
2675}
2676const TransitionHookValidator = [Function, Array];
2677const BaseTransitionPropsValidators = {
2678  mode: String,
2679  appear: Boolean,
2680  persisted: Boolean,
2681  // enter
2682  onBeforeEnter: TransitionHookValidator,
2683  onEnter: TransitionHookValidator,
2684  onAfterEnter: TransitionHookValidator,
2685  onEnterCancelled: TransitionHookValidator,
2686  // leave
2687  onBeforeLeave: TransitionHookValidator,
2688  onLeave: TransitionHookValidator,
2689  onAfterLeave: TransitionHookValidator,
2690  onLeaveCancelled: TransitionHookValidator,
2691  // appear
2692  onBeforeAppear: TransitionHookValidator,
2693  onAppear: TransitionHookValidator,
2694  onAfterAppear: TransitionHookValidator,
2695  onAppearCancelled: TransitionHookValidator
2696};
2697const BaseTransitionImpl = {
2698  name: `BaseTransition`,
2699  props: BaseTransitionPropsValidators,
2700  setup(props, { slots }) {
2701    const instance = getCurrentInstance();
2702    const state = useTransitionState();
2703    let prevTransitionKey;
2704    return () => {
2705      const children = slots.default && getTransitionRawChildren(slots.default(), true);
2706      if (!children || !children.length) {
2707        return;
2708      }
2709      let child = children[0];
2710      if (children.length > 1) {
2711        for (const c2 of children) {
2712          if (c2.type !== Comment) {
2713            child = c2;
2714            break;
2715          }
2716        }
2717      }
2718      const rawProps = toRaw(props);
2719      const { mode } = rawProps;
2720      if (state.isLeaving) {
2721        return emptyPlaceholder(child);
2722      }
2723      const innerChild = getKeepAliveChild(child);
2724      if (!innerChild) {
2725        return emptyPlaceholder(child);
2726      }
2727      const enterHooks = resolveTransitionHooks(
2728        innerChild,
2729        rawProps,
2730        state,
2731        instance
2732      );
2733      setTransitionHooks(innerChild, enterHooks);