https://casalolesa.cat/_nuxt/Di5hha55.js

54**/
55/*! #__NO_SIDE_EFFECTS__ */
56// @__NO_SIDE_EFFECTS__
57function makeMap(str) {
58  const map2 = /* @__PURE__ */ Object.create(null);
59  for (const key of str.split(",")) map2[key] = 1;
60  return (val) => val in map2;
61}
62const EMPTY_OBJ = {};
63const EMPTY_ARR = [];
64const NOOP = () => {
65};
66const NO = () => false;
67const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
68(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
69const isModelListener = (key) => key.startsWith("onUpdate:");
70const extend = Object.assign;
71const remove = (arr, el) => {
72  const i2 = arr.indexOf(el);
73  if (i2 > -1) {
74    arr.splice(i2, 1);
75  }
76};
77const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
78const hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
79const isArray$3 = Array.isArray;
80const isMap = (val) => toTypeString(val) === "[object Map]";
81const isSet = (val) => toTypeString(val) === "[object Set]";
82const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
83const isFunction$1 = (val) => typeof val === "function";
84const isString = (val) => typeof val === "string";
85const isSymbol = (val) => typeof val === "symbol";
86const isObject = (val) => val !== null && typeof val === "object";
87const isPromise$1 = (val) => {
88  return (isObject(val) || isFunction$1(val)) && isFunction$1(val.then) && isFunction$1(val.catch);
89};
90const objectToString = Object.prototype.toString;
91const toTypeString = (value) => objectToString.call(value);
92const toRawType = (value) => {
93  return toTypeString(value).slice(8, -1);
94};
95const isPlainObject$3 = (val) => toTypeString(val) === "[object Object]";
96const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
97const isReservedProp = /* @__PURE__ */ makeMap(
98  // the leading comma is intentional so empty string "" is also included
99  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
100);
101const cacheStringFunction = (fn) => {
102  const cache = /* @__PURE__ */ Object.create(null);
103  return (str) => {
104    const hit = cache[str];
105    return hit || (cache[str] = fn(str));
106  };
107};
108const camelizeRE = /-(\w)/g;
109const camelize = cacheStringFunction(
110  (str) => {
111    return str.replace(camelizeRE, (_2, c2) => c2 ? c2.toUpperCase() : "");
112  }
113);
114const hyphenateRE = /\B([A-Z])/g;
115const hyphenate = cacheStringFunction(
116  (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
117);
118const capitalize = cacheStringFunction((str) => {
119  return str.charAt(0).toUpperCase() + str.slice(1);
120});
121const toHandlerKey = cacheStringFunction(
122  (str) => {
123    const s2 = str ? `on${capitalize(str)}` : ``;
124    return s2;
125  }
126);
127const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
128const invokeArrayFns = (fns, ...arg) => {
129  for (let i2 = 0; i2 < fns.length; i2++) {
130    fns[i2](...arg);
131  }
132};
133const def = (obj, key, value, writable = false) => {
134  Object.defineProperty(obj, key, {
135    configurable: true,
136    enumerable: false,
137    writable,
138    value
139  });
140};
141const looseToNumber = (val) => {
142  const n2 = parseFloat(val);
143  return isNaN(n2) ? val : n2;
144};
145const toNumber = (val) => {
146  const n2 = isString(val) ? Number(val) : NaN;
147  return isNaN(n2) ? val : n2;
148};
149let _globalThis$2;
150const getGlobalThis = () => {
151  return _globalThis$2 || (_globalThis$2 = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
152};
153function normalizeStyle(value) {
154  if (isArray$3(value)) {
155    const res = {};
156    for (let i2 = 0; i2 < value.length; i2++) {
157      const item = value[i2];
158      const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
159      if (normalized) {
160        for (const key in normalized) {
161          res[key] = normalized[key];
162        }
163      }
164    }
165    return res;
166  } else if (isString(value) || isObject(value)) {
167    return value;
168  }
169}
170const listDelimiterRE = /;(?![^(]*\))/g;
171const propertyDelimiterRE = /:([^]+)/;
172const styleCommentRE = /\/\*[^]*?\*\//g;
173function parseStringStyle(cssText) {
174  const ret = {};
175  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEac

175h((item) => {
176    if (item) {
177      const tmp = item.split(propertyDelimiterRE);
178      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
179    }
180  });
181  return ret;
182}
183function normalizeClass(value) {
184  let res = "";
185  if (isString(value)) {
186    res = value;
187  } else if (isArray$3(value)) {
188    for (let i2 = 0; i2 < value.length; i2++) {
189      const normalized = normalizeClass(value[i2]);
190      if (normalized) {
191        res += normalized + " ";
192      }
193    }
194  } else if (isObject(value)) {
195    for (const name in value) {
196      if (value[name]) {
197        res += name + " ";
198      }
199    }
200  }
201  return res.trim();
202}
203const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
204const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
205function includeBooleanAttr(value) {
206  return !!value || value === "";
207}
208const isRef$1 = (val) => {
209  return !!(val && val["__v_isRef"] === true);
210};
211const toDisplayString = (val) => {
212  return isString(val) ? val : val == null ? "" : isArray$3(val) || isObject(val) && (val.toString === objectToString || !isFunction$1(val.toString)) ? isRef$1(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
213};
214const replacer = (_key, val) => {
215  if (isRef$1(val)) {
216    return replacer(_key, val.value);
217  } else if (isMap(val)) {
218    return {
219      [`Map(${val.size})`]: [...val.entries()].reduce(
220        (entries, [key, val2], i2) => {
221          entries[stringifySymbol(key, i2) + " =>"] = val2;
222          return entries;
223        },
224        {}
225      )
226    };
227  } else if (isSet(val)) {
228    return {
229      [`Set(${val.size})`]: [...val.values()].map((v2) => stringifySymbol(v2))
230    };
231  } else if (isSymbol(val)) {
232    return stringifySymbol(val);
233  } else if (isObject(val) && !isArray$3(val) && !isPlainObject$3(val)) {
234    return String(val);
235  }
236  return val;
237};
238const stringifySymbol = (v2, i2 = "") => {
239  var _a3;
240  return (
241    // Symbol.description in es2019+ so we need to cast here to pass
242    // the lib: es2016 check
243    isSymbol(v2) ? `Symbol(${(_a3 = v2.description) != null ? _a3 : i2})` : v2
244  );
245};
246/**
247* @vue/reactivity v3.5.14
248* (c) 2018-present Yuxi (Evan) You and Vue contributors
249* @license MIT
250**/
251let activeEffectScope;
252class EffectScope {
253  constructor(detached = false) {
254    this.detached = detached;
255    this._active = true;
256    this._on = 0;
257    this.effects = [];
258    this.cleanups = [];
259    this._isPaused = false;
260    this.parent = activeEffectScope;
261    if (!detached && activeEffectScope) {
262      this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
263        this
264      ) - 1;
265    }
266  }
267  get active() {
268    return this._active;
269  }
270  pause() {
271    if (this._active) {
272      this._isPaused = true;
273      let i2, l2;
274      if (this.scopes) {
275        for (i2 = 0, l2 = this.scopes.length; i2 < l2; i2++) {
276          this.scopes[i2].pause();
277        }
278      }
279      for (i2 = 0, l2 = this.effects.length; i2 < l2; i2++) {
280        this.effects[i2].pause();
281      }
282    }
283  }
284  /**
285   * Resumes the effect scope, including all child scopes and effects.
286   */
287  resume() {
288    if (this._active) {
289      if (this._isPaused) {
290        this._isPaused = false;
291        let i2, l2;
292        if (this.scopes) {
293          for (i2 = 0, l2 = this.scopes.length; i2 < l2; i2++) {
294            this.scopes[i2].resume();
295          }
296        }
297        for (i2 = 0, l2 = this.effects.length; i2 < l2; i2++) {
298          this.effects[i2].resume();
299        }
300      }
301    }
302  }
303  run(fn) {
304    if (this._active) {
305      const currentEffectScope = activeEffectScope;
306      try {
307        activeEffectScope = this;
308        return fn();
309      } finally {
310        activeEffectScope = currentEffectScope;
311      }
312    }
313  }
314  /**
315   * This should only be called on non-detached scopes
316   * @internal
317   */
318  on() {
319    if (++this._on === 1) {
320      this.prevScope = activeEffectScope;
321      activeEffectScope = this;
322    }
323  }
324  /**
325   * This should only be called on non-detached scopes
326   * @internal
327   */
328  off() {
329    if (this._on > 0 && --this._on === 0) {
330      activeEffectScope = this.prevScope;
331      this.prevScope = void 0;
332    }
333  }
334  stop(fromParent) {
335    if (this._active) {
336      this._active = false;
337      let i2, l2;
338      for (i2 = 0, l2 = this.effects.length; i2 < l2; i2++) {
339        this.effects[i2].stop();
340      }
341      this.effects.length = 0;
342      for (i2 = 0, l2 = this.cleanups.length; i2 < l2; i2++) {
343        this.cleanups[i2]();
344      }
345      this.cleanups.length = 0;
346      if (this.scopes) {
347        for (i2 = 0, l2 = this.scopes.length; i2 < l2; i2++) {
348          this.scopes[i2].stop(true);
349        }
350        this.scopes.length = 0;
351      }
352      if (!this.detached && this.parent && !fromParent) {
353        const last2 = this.parent.scopes.pop();
354        if (last2 && last2 !== this) {
355          this.parent.scopes[this.index] = last2;
356          last2.index = this.index;
357        }
358      }
359      this.parent = void 0;
360    }
361  }
362}
363function effectScope(detached) {
364  return new EffectScope(detached);
365}
366function getCurrentScope() {
367  return activeEffectScope;
368}
369function onScopeDispose(fn, failSilently = false) {
370  if (activeEffectScope) {
371    activeEffectScope.cleanups.push(fn);
372  }
373}
374let activeSub;
375const pausedQueueEffects = /* @__PURE__ */ new WeakSet();
376class ReactiveEffect {
377  constructor(fn) {
378    this.fn = fn;
379    this.deps = void 0;
380    this.depsTail = void 0;
381    this.flags = 1 | 4;
382    this.next = void 0;
383    this.cleanup = void 0;
384    this.scheduler = void 0;
385    if (activeEffectScope && activeEffectScope.active) {
386      activeEffectScope.effects.push(this);
387    }
388  }
389  pause() {
390    this.flags |= 64;
391  }
392  resume() {
393    if (this.flags & 64) {
394      this.flags &= -65;
395      if (pausedQueueEffects.has(this)) {
396        pausedQueueEffects.delete(this);
397        this.trigger();
398      }
399    }
400  }
401  /**
402   * @internal
403   */
404  notify() {
405    if (this.flags & 2 && !(this.flags & 32)) {
406      return;
407    }
408    if (!(this.flags & 8)) {
409      batch(this);
410    }
411  }
412  run() {
413    if (!(this.flags & 1)) {
414      return this.fn();
415    }
416    this.flags |= 2;
417    cleanupEffect(this);
418    prepareDeps(this);
419    const prevEffect = activeSub;
420    const prevShouldTrack = shouldTrack;
421    activeSub = this;
422    shouldTrack = true;
423    try {
424      return this.fn();
425    } finally {
426      cleanupDeps(this);
427      activeSub = prevEffect;
428      shouldTrack = prevShouldTrack;
429      this.flags &= -3;
430    }
431  }
432  stop() {
433    if (this.flags & 1) {
434      for (let link = this.deps; link; link = link.nextDep) {
435        removeSub(link);
436      }
437      this.deps = this.depsTail = void 0;
438      cleanupEffect(this);
439      this.onStop && this.onStop();
440      this.flags &= -2;
441    }
442  }
443  trigger() {
444    if (this.flags & 64) {
445      pausedQueueEffects.add(this);
446    } else if (this.scheduler) {
447      this.scheduler();
448    } else {
449      this.runIfDirty();
450    }
451  }
452  /**
453   * @internal
454   */
455  runIfDirty() {
456    if (isDirty(this)) {
457      this.run();
458    }
459  }
460  get dirty() {
461    return isDirty(this);
462  }
463}
464let batchDepth = 0;
465let batchedSub;
466let batchedComputed;
467function batch(sub2, isComputed2 = false) {
468  sub2.flags |= 8;
469  if (isComputed2) {
470    sub2.next = batchedComputed;
471    batchedComputed = sub2;
472    return;
473  }
474  sub2.next = batchedSub;
475  batchedSub = sub2;
476}
477function startBatch() {
478  batchDepth++;
479}
480function endBatch() {
481  if (--batchDepth > 0) {
482    return;
483  }
484  if (batchedComputed) {
485    let e2 = batchedComputed;
486    batchedComputed = void 0;
487    while (e2) {
488      const next = e2.next;
489      e2.next = void 0;
490      e2.flags &= -9;
491      e2 = next;
492    }
493  }
494  let error;
495  while (batchedSub) {
496    let e2 = batchedSub;
497    batchedSub = void 0;
498    while (e2) {
499      const next = e2.next;
500      e2.next = void 0;
501      e2.flags &= -9;
502      if (e2.flags & 1) {
503        try {
504          ;
505          e2.trigger();
506        } catch (err) {
507          if (!error) error = err;
508        }
509      }
510      e2 = next;
511    }
512  }
513  if (error) throw error;
514}
515function prepareDeps(sub2) {
516  for (let link = sub2.deps; link; link = link.nextDep) {
517    link.version = -1;
518    link.prevActiveLink = link.dep.activeLink;
519    link.dep.activeLink = link;
520  }
521}
522function cleanupDeps(sub2) {
523  let head;
524  let tail = sub2.depsTail;
525  let link = tail;
526  while (link) {
527    const prev = link.prevDep;
528    if (link.version === -1) {
529      if (link === tail) tail = prev;
530      removeSub(link);
531      removeDep(link);
532    } else {
533      head = link;
534    }
535    link.dep.activeLink = link.prevActiveLink;
536    link.prevActiveLink = void 0;
537    link = prev;
538  }
539  sub2.deps = head;
540  sub2.depsTail = tail;
541}
542function isDirty(sub2) {
543  for (let link = sub2.deps; link; link = link.nextDep) {
544    if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
545      return true;
546    }
547  }
548  if (sub2._dirty) {
549    return true;
550  }
551  return false;
552}
553function refreshComputed(computed2) {
554  if (computed2.flags & 4 && !(computed2.flags & 16)) {
555    return;
556  }
557  computed2.flags &= -17;
558  if (computed2.globalVersion === globalVersion) {
559    return;
560  }
561  computed2.globalVersion = globalVersion;
562  if (!computed2.isSSR && computed2.flags & 128 && (!computed2.deps && !computed2._dirty || !isDirty(computed2))) {
563    return;
564  }
565  computed2.flags |= 2;
566  const dep = computed2.dep;
567  const prevSub = activeSub;
568  const prevShouldTrack = shouldTrack;
569  activeSub = computed2;
570  shouldTrack = true;
571  try {
572    prepareDeps(computed2);
573    const value = computed2.fn(computed2._value);
574    if (dep.version === 0 || hasChanged(value, computed2._value)) {
575      computed2.flags |= 128;
576      computed2._value = value;
577      dep.version++;
578    }
579  } catch (err) {
580    dep.version++;
581    throw err;
582  } finally {
583    activeSub = prevSub;
584    shouldTrack = prevShouldTrack;
585    cleanupDeps(computed2);
586    computed2.flags &= -3;
587  }
588}
589function removeSub(link, soft = false) {
590  const { dep, prevSub, nextSub } = link;
591  if (prevSub) {
592    prevSub.nextSub = nextSub;
593    link.prevSub = void 0;
594  }
595  if (nextSub) {
596    nextSub.prevSub = prevSub;
597    link.nextSub = void 0;
598  }
599  if (dep.subs === link) {
600    dep.subs = prevSub;
601    if (!prevSub && dep.computed) {
602      dep.computed.flags &= -5;
603      for (let l2 = dep.computed.deps; l2; l2 = l2.nextDep) {
604        removeSub(l2, true);
605      }
606    }
607  }
608  if (!soft && !--dep.sc && dep.map) {
609    dep.map.delete(dep.key);
610  }
611}
612function removeDep(link) {
613  const { prevDep, nextDep } = link;
614  if (prevDep) {
615    prevDep.nextDep = nextDep;
616    link.prevDep = void 0;
617  }
618  if (nextDep) {
619    nextDep.prevDep = prevDep;
620    link.nextDep = void 0;
621  }
622}
623let shouldTrack = true;
624const trackStack = [];
625function pauseTracking() {
626  trackStack.push(shouldTrack);
627  shouldTrack = false;
628}
629function resetTracking() {
630  const last2 = trackStack.pop();
631  shouldTrack = last2 === void 0 ? true : last2;
632}
633function cleanupEffect(e2) {
634  const { cleanup } = e2;
635  e2.cleanup = void 0;
636  if (cleanup) {
637    const prevSub = activeSub;
638    activeSub = void 0;
639    try {
640      cleanup();
641    } finally {
642      activeSub = prevSub;
643    }
644  }
645}
646let globalVersion = 0;
647class Link {
648  constructor(sub2, dep) {
649    this.sub = sub2;
650    this.dep = dep;
651    this.version = dep.version;
652    this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
653  }
654}
655class Dep {
656  constructor(computed2) {
657    this.computed = computed2;
658    this.version = 0;
659    this.activeLink = void 0;
660    this.subs = void 0;
661    this.map = void 0;
662    this.key = void 0;
663    this.sc = 0;
664  }
665  track(debugInfo) {
666    if (!activeSub || !shouldTrack || activeSub === this.computed) {
667      return;
668    }
669    let link = this.activeLink;
670    if (link === void 0 || link.sub !== activeSub) {
671      link = this.activeLink = new Link(activeSub, this);
672      if (!activeSub.deps) {
673        activeSub.deps = activeSub.depsTail = link;
674      } else {
675        link.prevDep = activeSub.depsTail;
676        activeSub.depsTail.nextDep = link;
677        activeSub.depsTail = link;
678      }
679      addSub(link);
680    } else if (link.version === -1) {
681      link.version = this.version;
682      if (link.nextDep) {
683        const next = link.nextDep;
684        next.prevDep = link.prevDep;
685        if (link.prevDep) {
686          link.prevDep.nextDep = next;
687        }
688        link.prevDep = activeSub.depsTail;
689        link.nextDep = void 0;
690        activeSub.depsTail.nextDep = link;
691        activeSub.depsTail = link;
692        if (activeSub.deps === link) {
693          activeSub.deps = next;
694        }
695      }
696    }
697    return link;
698  }
699  trigger(debugInfo) {
700    this.version++;
701    globalVersion++;
702    this.notify(debugInfo);
703  }
704  notify(debugInfo) {
705    startBatch();
706    try {
707      if (false) ;
708      for (let link = this.subs; link; link = link.prevSub) {
709        if (link.sub.notify()) {
710          ;
711          link.sub.dep.notify();
712        }
713      }
714    } finally {
715      endBatch();
716    }
717  }
718}
719function addSub(link) {
720  link.dep.sc++;
721  if (link.sub.flags & 4) {
722    const computed2 = link.dep.computed;
723    if (computed2 && !link.dep.subs) {
724      computed2.flags |= 4 | 16;
725      for (let l2 = computed2.deps; l2; l2 = l2.nextDep) {
726        addSub(l2);
727      }
728    }
729    const currentTail = link.dep.subs;
730    if (currentTail !== link) {
731      link.prevSub = currentTail;
732      if (currentTail) currentTail.nextSub = link;
733    }
734    link.dep.subs = link;
735  }
736}
737const targetMap = /* @__PURE__ */ new WeakMap();
738const ITERATE_KEY = Symbol(
739  ""
740);
741const MAP_KEY_ITERATE_KEY = Symbol(
742  ""
743);
744const ARRAY_ITERATE_KEY = Symbol(
745  ""
746);
747function track(target, type, key) {
748  if (shouldTrack && activeSub) {
749    let depsMap = targetMap.get(target);
750    if (!depsMap) {
751      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
752    }
753    let dep = depsMap.get(key);
754    if (!dep) {
755      depsMap.set(key, dep = new Dep());
756      dep.map = depsMap;
757      dep.key = key;
758    }
759    {
760      dep.track();
761    }
762  }
763}
764function trigger(target, type, key, newValue, oldValue, oldTarget) {
765  const depsMap = targetMap.get(target);
766  if (!depsMap) {
767    globalVersion++;
768    return;
769  }
770  const run = (dep) => {
771    if (dep) {
772      {
773        dep.trigger();
774      }
775    }
776  };
777  startBatch();
778  if (type === "clear") {

779    depsMap.forEach(run);
780  } else {
781    const targetIsArray = isArray$3(target);
782    const isArrayIndex = targetIsArray && isIntegerKey(key);
783    if (targetIsArray && key === "length") {
784      const newLength = Number(newValue);
785      depsMap.forEach((dep, key2) => {
786        if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
787          run(dep);
788        }
789      });
790    } else {
791      if (key !== void 0 || depsMap.has(void 0)) {
792        run(depsMap.get(key));
793      }
794      if (isArrayIndex) {
795        run(depsMap.get(ARRAY_ITERATE_KEY));
796      }
797      switch (type) {
798        case "add":
799          if (!targetIsArray) {
800            run(depsMap.get(ITERATE_KEY));
801            if (isMap(target)) {
802              run(depsMap.get(MAP_KEY_ITERATE_KEY));
803            }
804          } else if (isArrayIndex) {
805            run(depsMap.get("length"));
806          }
807          break;
808        case "delete":
809          if (!targetIsArray) {
810            run(depsMap.get(ITERATE_KEY));
811            if (isMap(target)) {
812              run(depsMap.get(MAP_KEY_ITERATE_KEY));
813            }
814          }
815          break;
816        case "set":
817          if (isMap(target)) {
818            run(depsMap.get(ITERATE_KEY));
819          }
820          break;
821      }
822    }
823  }
824  endBatch();
825}
826function getDepFromReactive(object, key) {
827  const depMap = targetMap.get(object);
828  return depMap && depMap.get(key);
829}
830function reactiveReadArray(array) {
831  const raw = toRaw(array);
832  if (raw === array) return raw;
833  track(raw, "iterate", ARRAY_ITERATE_KEY);
834  return isShallow(array) ? raw : raw.map(toReactive);
835}
836function shallowReadArray(arr) {
837  track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
838  return arr;
839}
840const arrayInstrumentations = {
841  __proto__: null,
842  [Symbol.iterator]() {
843    return iterator$1(this, Symbol.iterator, toReactive);
844  },
845  concat(...args) {
846    return reactiveReadArray(this).concat(
847      ...args.map((x2) => isArray$3(x2) ? reactiveReadArray(x2) : x2)
848    );
849  },
850  entries() {
851    return iterator$1(this, "entries", (value) => {
852      value[1] = toReactive(value[1]);
853      return value;
854    });
855  },
856  every(fn, thisArg) {
857    return apply(this, "every", fn, thisArg, void 0, arguments);
858  },
859  filter(fn, thisArg) {
860    return apply(this, "filter", fn, thisArg, (v2) => v2.map(toReactive), arguments);
861  },
862  find(fn, thisArg) {
863    return apply(this, "find", fn, thisArg, toReactive, arguments);
864  },
865  findIndex(fn, thisArg) {
866    return apply(this, "findIndex", fn, thisArg, void 0, arguments);
867  },
868  findLast(fn, thisArg) {
869    return apply(this, "findLast", fn, thisArg, toReactive, arguments);
870  },
871  findLastIndex(fn, thisArg) {
872    return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
873  },
874  // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
875  forEach(fn, thisArg) {
876    return apply(this, "forEach", fn, thisArg, void 0, arguments);
877  },
878  includes(...args) {
879    return searchProxy(this, "includes", args);
880  },
881  indexOf(...args) {
882    return searchProxy(this, "indexOf", args);
883  },
884  join(separator) {
885    return reactiveReadArray(this).join(separator);
886  },
887  // keys() iterator only reads `length`, no optimisation required
888  lastIndexOf(...args) {
889    return searchProxy(this, "lastIndexOf", args);
890  },
891  map(fn, thisArg) {
892    return apply(this, "map", fn, thisArg, void 0, arguments);
893  },
894  pop() {
895    return noTracking(this, "pop");
896  },
897  push(...args) {
898    return noTracking(this, "push", args);
899  },
900  reduce(fn, ...args) {
901    return reduce(this, "reduce", fn, args);
902  },
903  reduceRight(fn, ...args) {
904    return reduce(this, "reduceRight", fn, args);
905  },
906  shift() {
907    return noTracking(this, "shift");
908  },
909  // slice could use ARRAY_ITERATE but also seems to beg for range tracking
910  some(fn, thisArg) {
911    return apply(this, "some", fn, thisArg, void 0, arguments);
912  },
913  splice(...args) {
914    return noTracking(this, "splice", args);
915  },
916  toReversed() {
917    return reactiveReadArray(this).toReversed();
918  },
919  toSorted(comparer) {
920    return reactiveReadArray(this).toSorted(comparer);
921  },
922  toSpliced(...args) {
923    return reactiveReadArray(this).toSpliced(...args);
924  },
925  unshift(...args) {
926    return noTracking(this, "unshift", args);
927  },
928  values() {
929    return iterator$1(this, "values", toReactive);
930  }
931};
932function iterator$1(self2, method, wrapValue) {
933  const arr = shallowReadArray(self2);
934  const iter = arr[method]();
935  if (arr !== self2 && !isShallow(self2)) {
936    iter._next = iter.next;
937    iter.next = () => {
938      const result = iter._next();
939      if (result.value) {
940        result.value = wrapValue(result.value);
941      }
942      return result;
943    };
944  }
945  return iter;
946}
947const arrayProto = Array.prototype;
948function apply(self2, method, fn, thisArg, wrappedRetFn, args) {
949  const arr = shallowReadArray(self2);
950  const needsWrap = arr !== self2 && !isShallow(self2);
951  const methodFn = arr[method];
952  if (methodFn !== arrayProto[method]) {
953    const result2 = methodFn.apply(self2, args);
954    return needsWrap ? toReactive(result2) : result2;
955  }
956  let wrappedFn = fn;
957  if (arr !== self2) {
958    if (needsWrap) {
959      wrappedFn = function(item, index) {

960        return fn.call(this, toReactive(item), index, self2);
961      };
962    } else if (fn.length > 2) {
963      wrappedFn = function(item, index) {
964        return fn.call(this, item, index, self2);
965      };
966    }
967  }
968  const result = methodFn.call(arr, wrappedFn, thisArg);
969  return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
970}
971function reduce(self2, method, fn, args) {
972  const arr = shallowReadArray(self2);
973  let wrappedFn = fn;
974  if (arr !== self2) {
975    if (!isShallow(self2)) {
976      wrappedFn = function(acc, item, index) {
977        return fn.call(this, acc, toReactive(item), index, self2);
978      };
979    } else if (fn.length > 3) {
980      wrappedFn = function(acc, item, index) {
981        return fn.call(this, acc, item, index, self2);
982      };
983    }
984  }
985  return arr[method](wrappedFn, ...args);
986}
987function searchProxy(self2, method, args) {
988  const arr = toRaw(self2);
989  track(arr, "iterate", ARRAY_ITERATE_KEY);
990  const res = arr[method](...args);
991  if ((res === -1 || res === false) && isProxy(args[0])) {
992    args[0] = toRaw(args[0]);
993    return arr[method](...args);
994  }
995  return res;
996}
997function noTracking(self2, method, args = []) {
998  pauseTracking();
999  startBatch();
1000  const res = toRaw(self2)[method].apply(self2, args);
1001  endBatch();
1002  resetTracking();
1003  return res;
1004}
1005const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
1006const builtInSymbols = new Set(
1007  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
1008);
1009function hasOwnProperty(key) {
1010  if (!isSymbol(key)) key = String(key);
1011  const obj = toRaw(this);
1012  track(obj, "has", key);
1013  return obj.hasOwnProperty(key);
1014}
1015class BaseReactiveHandler {
1016  constructor(_isReadonly = false, _isShallow = false) {
1017    this._isReadonly = _isReadonly;
1018    this._isShallow = _isShallow;
1019  }
1020  get(target, key, receiver) {
1021    if (key === "__v_skip") return target["__v_skip"];
1022    const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
1023    if (key === "__v_isReactive") {
1024      return !isReadonly2;
1025    } else if (key === "__v_isReadonly") {
1026      return isReadonly2;
1027    } else if (key === "__v_isShallow") {
1028      return isShallow2;
1029    } else if (key === "__v_raw") {
1030      if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
1031      // this means the receiver is a user proxy of the reactive proxy
1032      Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
1033        return target;
1034      }
1035      return;
1036    }
1037    const targetIsArray = isArray$3(target);
1038    if (!isReadonly2) {
1039      let fn;
1040      if (targetIsArray && (fn = arrayInstrumentations[key])) {
1041        return fn;
1042      }
1043      if (key === "hasOwnProperty") {
1044        return hasOwnProperty;
1045      }
1046    }
1047    const res = Reflect.get(
1048      target,
1049      key,
1050      // if this is a proxy wrapping a ref, return methods using the raw ref
1051      // as receiver so that we don't have to call `toRaw` on the ref in all
1052      // its class methods
1053      isRef(target) ? target : receiver
1054    );
1055    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
1056      return res;
1057    }
1058    if (!isReadonly2) {
1059      track(target, "get", key);
1060    }
1061    if (isShallow2) {
1062      return res;
1063    }
1064    if (isRef(res)) {
1065      return targetIsArray && isIntegerKey(key) ? res : res.value;
1066    }
1067    if (isObject(res)) {
1068      return isReadonly2 ? readonly(res) : reactive(res);
1069    }
1070    return res;
1071  }
1072}
1073class MutableReactiveHandler extends BaseReactiveHandler {
1074  constructor(isShallow2 = false) {
1075    super(false, isShallow2);
1076  }
1077  set(target, key, value, receiver) {
1078    let oldValue = target[key];
1079    if (!this._isShallow) {
1080      const isOldValueReadonly = isReadonly(oldValue);
1081      if (!isShallow(value) && !isReadonly(value)) {
1082        oldValue = toRaw(oldValue);
1083        value = toRaw(value);
1084      }
1085      if (!isArray$3(target) && isRef(oldValue) && !isRef(value)) {
1086        if (isOldValueReadonly) {
1087          return false;

1088        } else {
1089          oldValue.value = value;
1090          return true;
1091        }
1092      }
1093    }
1094    const hadKey = isArray$3(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
1095    const result = Reflect.set(
1096      target,
1097      key,
1098      value,
1099      isRef(target) ? target : receiver
1100    );
1101    if (target === toRaw(receiver)) {
1102      if (!hadKey) {
1103        trigger(target, "add", key, value);
1104      } else if (hasChanged(value, oldValue)) {
1105        trigger(target, "set", key, value);
1106      }
1107    }
1108    return result;
1109  }
1110  deleteProperty(target, key) {
1111    const hadKey = hasOwn(target, key);
1112    target[key];
1113    const result = Reflect.deleteProperty(target, key);
1114    if (result && hadKey) {
1115      trigger(target, "delete", key, void 0);
1116    }
1117    return result;
1118  }
1119  has(target, key) {
1120    const result = Reflect.has(target, key);
1121    if (!isSymbol(key) || !builtInSymbols.has(key)) {
1122      track(target, "has", key);
1123    }
1124    return result;
1125  }
1126  ownKeys(target) {
1127    track(
1128      target,
1129      "iterate",
1130      isArray$3(target) ? "length" : ITERATE_KEY
1131    );
1132    return Reflect.ownKeys(target);
1133  }
1134}
1135class ReadonlyReactiveHandler extends BaseReactiveHandler {
1136  constructor(isShallow2 = false) {
1137    super(true, isShallow2);
1138  }
1139  set(target, key) {
1140    return true;
1141  }
1142  deleteProperty(target, key) {
1143    return true;
1144  }
1145}
1146const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
1147const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
1148const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true);
1149const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
1150const toShallow = (value) => value;
1151const getProto = (v2) => Reflect.getPrototypeOf(v2);
1152function createIterableMethod(method, isReadonly2, isShallow2) {
1153  return function(...args) {
1154    const target = this["__v_raw"];
1155    const rawTarget = toRaw(target);
1156    const targetIsMap = isMap(rawTarget);
1157    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
1158    const isKeyOnly = method === "keys" && targetIsMap;
1159    const innerIterator = target[method](...args);
1160    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
1161    !isReadonly2 && track(
1162      rawTarget,
1163      "iterate",
1164      isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
1165    );
1166    return {
1167      // iterator protocol
1168      next() {
1169        const { value, done } = innerIterator.next();
1170        return done ? { value, done } : {
1171          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
1172          done
1173        };
1174      },
1175      // iterable protocol
1176      [Symbol.iterator]() {
1177        return this;
1178      }
1179    };
1180  };
1181}
1182function createReadonlyMethod(type) {
1183  return function(...args) {
1184    return type === "delete" ? false : type === "clear" ? void 0 : this;
1185  };
1186}
1187function createInstrumentations(readonly2, shallow) {
1188  const instrumentations = {
1189    get(key) {
1190      const target = this["__v_raw"];
1191      const rawTarget = toRaw(target);
1192      const rawKey = toRaw(key);
1193      if (!readonly2) {
1194        if (hasChanged(key, rawKey)) {
1195          track(rawTarget, "get", key);
1196        }
1197        track(rawTarget, "get", rawKey);
1198      }
1199      const { has } = getProto(rawTarget);
1200      const wrap = shallow ? toShallow : readonly2 ? toReadonly : toReactive;
1201      if (has.call(rawTarget, key)) {
1202        return wrap(target.get(key));
1203      } else if (has.call(rawTarget, rawKey)) {
1204        return wrap(target.get(rawKey));
1205      } else if (target !== rawTarget) {
1206        target.get(key);
1207      }
1208    },
1209    get size() {
1210      const target = this["__v_raw"];
1211      !readonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
1212      return Reflect.get(target, "size", target);
1213    },
1214    has(key) {
1215      const target = this["__v_raw"];
1216      const rawTarget = toRaw(target);
1217      const rawKey = toRaw(key);
1218      if (!readonly2) {
1219        if (hasChanged(key, rawKey)) {
1220          track(rawTarget, "has", key);
1221        }
1222        track(rawTarget, "has", rawKey);
1223      }
1224      return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
1225    },

1226    forEach(callback, thisArg) {
1227      const observed = this;
1228      const target = observed["__v_raw"];
1229      const rawTarget = toRaw(target);
1230      const wrap = shallow ? toShallow : readonly2 ? toReadonly : toReactive;
1231      !readonly2 && track(rawTarget, "iterate", ITERATE_KEY);
1232      return target.forEach((value, key) => {
1233        return callback.call(thisArg, wrap(value), wrap(key), observed);
1234      });
1235    }
1236  };
1237  extend(
1238    instrumentations,
1239    readonly2 ? {
1240      add: createReadonlyMethod("add"),
1241      set: createReadonlyMethod("set"),
1242      delete: createReadonlyMethod("delete"),
1243      clear: createReadonlyMethod("clear")
1244    } : {
1245      add(value) {
1246        if (!shallow && !isShallow(value) && !isReadonly(value)) {
1247          value = toRaw(value);
1248        }
1249        const target = toRaw(this);
1250        const proto = getProto(target);
1251        const hadKey = proto.has.call(target, value);
1252        if (!hadKey) {
1253          target.add(value);
1254          trigger(target, "add", value, value);
1255        }
1256        return this;
1257      },
1258      set(key, value) {
1259        if (!shallow && !isShallow(value) && !isReadonly(value)) {
1260          value = toRaw(value);
1261        }
1262        const target = toRaw(this);
1263        const { has, get } = getProto(target);
1264        let hadKey = has.call(target, key);
1265        if (!hadKey) {
1266          key = toRaw(key);
1267          hadKey = has.call(target, key);
1268        }
1269        const oldValue = get.call(target, key);
1270        target.set(key, value);
1271        if (!hadKey) {
1272          trigger(target, "add", key, value);
1273        } else if (hasChanged(value, oldValue)) {
1274          trigger(target, "set", key, value);
1275        }
1276        return this;
1277      },
1278      delete(key) {
1279        const target = toRaw(this);
1280        const { has, get } = getProto(target);
1281        let hadKey = has.call(target, key);
1282        if (!hadKey) {
1283          key = toRaw(key);
1284          hadKey = has.call(target, key);
1285        }
1286        get ? get.call(target, key) : void 0;
1287        const result = target.delete(key);
1288        if (hadKey) {
1289          trigger(target, "delete", key, void 0);
1290        }
1291        return result;
1292      },
1293      clear() {
1294        const target = toRaw(this);
1295        const hadItems = target.size !== 0;
1296        const result = target.clear();
1297        if (hadItems) {
1298          trigger(
1299            target,
1300            "clear",
1301            void 0,
1302            void 0
1303          );
1304        }
1305        return result;
1306      }
1307    }
1308  );
1309  const iteratorMethods = [
1310    "keys",
1311    "values",
1312    "entries",
1313    Symbol.iterator
1314  ];
1315  iteratorMethods.forEach((method) => {
1316    instrumentations[method] = createIterableMethod(method, readonly2, shallow);
1317  });
1318  return instrumentations;
1319}
1320function createInstrumentationGetter(isReadonly2, shallow) {
1321  const instrumentations = createInstrumentations(isReadonly2, shallow);
1322  return (target, key, receiver) => {
1323    if (key === "__v_isReactive") {
1324      return !isReadonly2;
1325    } else if (key === "__v_isReadonly") {
1326      return isReadonly2;
1327    } else if (key === "__v_raw") {
1328      return target;
1329    }
1330    return Reflect.get(
1331      hasOwn(instrumentations, key) && key in target ? instrumentations : target,
1332      key,
1333      receiver
1334    );
1335  };
1336}
1337const mutableCollectionHandlers = {
1338  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
1339};
1340const shallowCollectionHandlers = {
1341  get: /* @__PURE__ */ createInstrumentationGetter(false, true)
1342};
1343const readonlyCollectionHandlers = {
1344  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
1345};
1346const shallowReadonlyCollectionHandlers = {
1347  get: /* @__PURE__ */ createInstrumentationGetter(true, true)
1348};
1349const reactiveMap = /* @__PURE__ */ new WeakMap();
1350const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
1351const readonlyMap = /* @__PURE__ */ new WeakMap();
1352const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
1353function targetTypeMap(rawType) {
1354  switch (rawType) {
1355    case "Object":
1356    case "Array":
1357      return 1;
1358    case "Map":
1359    case "Set":
1360    case "WeakMap":
1361    case "WeakSet":
1362      return 2;
1363    default:
1364      return 0;
1365  }
1366}
1367function getTargetType(value) {
1368  return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
1369}
1370function reactive(target) {
1371  if (isReadonly(target)) {
1372    return target;
1373  }
1374  return createReactiveObject(
1375    target,
1376    false,
1377    mutableHandlers,
1378    mutableCollectionHandlers,
1379    reactiveMap
1380  );
1381}
1382function shallowReactive(target) {
1383  return createReactiveObject(
1384    target,
1385    false,
1386    shallowReactiveHandlers,
1387    shallowCollectionHandlers,
1388    shallowReactiveMap
1389  );
1390}
1391function readonly(target) {
1392  return createReactiveObject(
1393    target,
1394    true,
1395    readonlyHandlers,
1396    readonlyCollectionHandlers,
1397    readonlyMap
1398  );
1399}
1400function shallowReadonly(target) {
1401  return createReactiveObject(
1402    target,
1403    true,
1404    shallowReadonlyHandlers,
1405    shallowReadonlyCollectionHandlers,
1406    shallowReadonlyMap
1407  );
1408}
1409function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
1410  if (!isObject(target)) {
1411    return target;
1412  }
1413  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
1414    return target;
1415  }
1416  const targetType = getTargetType(target);
1417  if (targetType === 0) {
1418    return target;
1419  }
1420  const existingProxy = proxyMap.get(target);
1421  if (existingProxy) {
1422    return existingProxy;
1423  }
1424  const proxy = new Proxy(
1425    target,
1426    targetType === 2 ? collectionHandlers : baseHandlers
1427  );
1428  proxyMap.set(target, proxy);
1429  return proxy;
1430}
1431function isReactive(value) {
1432  if (isReadonly(value)) {
1433    return isReactive(value["__v_raw"]);
1434  }
1435  return !!(value && value["__v_isReactive"]);
1436}
1437function isReadonly(value) {
1438  return !!(value && value["__v_isReadonly"]);
1439}
1440function isShallow(value) {
1441  return !!(value && value["__v_isShallow"]);
1442}
1443function isProxy(value) {
1444  return value ? !!value["__v_raw"] : false;
1445}
1446function toRaw(observed) {
1447  const raw = observed && observed["__v_raw"];
1448  return raw ? toRaw(raw) : observed;
1449}
1450function markRaw(value) {
1451  if (!hasOwn(value, "__v_skip") && Object.isExtensible(value)) {
1452    def(value, "__v_skip", true);
1453  }
1454  return value;
1455}
1456const toReactive = (value) => isObject(value) ? reactive(value) : value;
1457const toReadonly = (value) => isObject(value) ? readonly(value) : value;
1458function isRef(r2) {
1459  return r2 ? r2["__v_isRef"] === true : false;
1460}
1461function ref(value) {
1462  return createRef(value, false);
1463}
1464function shallowRef(value) {
1465  return createRef(value, true);
1466}
1467function createRef(rawValue, shallow) {
1468  if (isRef(rawValue)) {
1469    return rawValue;
1470  }
1471  return new RefImpl(rawValue, shallow);
1472}
1473class RefImpl {
1474  constructor(value, isShallow2) {
1475    this.dep = new Dep();
1476    this["__v_isRef"] = true;
1477    this["__v_isShallow"] = false;
1478    this._rawValue = isShallow2 ? value : toRaw(value);
1479    this._value = isShallow2 ? value : toReactive(value);
1480    this["__v_isShallow"] = isShallow2;
1481  }
1482  get value() {
1483    {
1484      this.dep.track();
1485    }
1486    return this._value;
1487  }
1488  set value(newValue) {
1489    const oldValue = this._rawValue;
1490    const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
1491    newValue = useDirectValue ? newValue : toRaw(newValue);
1492    if (hasChanged(newValue, oldValue)) {
1493      this._rawValue = newValue;
1494      this._value = useDirectValue ? newValue : toReactive(newValue);
1495      {
1496        this.dep.trigger();
1497      }
1498    }
1499  }
1500}
1501function unref(ref2) {
1502  return isRef(ref2) ? ref2.value : ref2;
1503}
1504function toValue(source) {
1505  return isFunction$1(source) ? source() : unref(source);
1506}
1507const shallowUnwrapHandlers = {
1508  get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)),
1509  set: (target, key, value, receiver) => {
1510    const oldValue = target[key];
1511    if (isRef(oldValue) && !isRef(value)) {
1512      oldValue.value = value;
1513      return true;
1514    } else {
1515      return Reflect.set(target, key, value, receiver);
1516    }
1517  }
1518};
1519function proxyRefs(objectWithRefs) {
1520  return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
1521}
1522function toRefs(object) {
1523  const ret = isArray$3(object) ? new Array(object.length) : {};
1524  for (const key in object) {
1525    ret[key] = propertyToRef(object, key);
1526  }
1527  return ret;
1528}
1529class ObjectRefImpl {
1530  constructor(_object, _key, _defaultValue) {
1531    this._object = _object;
1532    this._key = _key;
1533    this._defaultValue = _defaultValue;
1534    this["__v_isRef"] = true;
1535    this._value = void 0;
1536  }
1537  get value() {
1538    const val = this._object[this._key];
1539    return this._value = val === void 0 ? this._defaultValue : val;
1540  }
1541  set value(newVal) {
1542    this._object[this._key] = newVal;
1543  }
1544  get dep() {
1545    return getDepFromReactive(toRaw(this._object), this._key);
1546  }
1547}
1548class GetterRefImpl {
1549  constructor(_getter) {
1550    this._getter = _getter;
1551    this["__v_isRef"] = true;
1552    this["__v_isReadonly"] = true;
1553    this._value = void 0;
1554  }
1555  get value() {
1556    return this._value = this._getter();
1557  }
1558}
1559function toRef(source, key, defaultValue) {
1560  if (isRef(source)) {
1561    return source;
1562  } else if (isFunction$1(source)) {
1563    return new GetterRefImpl(source);
1564  } else if (isObject(source) && arguments.length > 1) {
1565    return propertyToRef(source, key, defaultValue);
1566  } else {
1567    return ref(source);
1568  }
1569}
1570function propertyToRef(source, key, defaultValue) {
1571  const val = source[key];
1572  return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
1573}
1574class ComputedRefImpl {
1575  constructor(fn, setter, isSSR) {
1576    this.fn = fn;
1577    this.setter = setter;
1578    this._value = void 0;
1579    this.dep = new Dep(this);
1580    this.__v_isRef = true;
1581    this.deps = void 0;
1582    this.depsTail = void 0;
1583    this.flags = 16;
1584    this.globalVersion = globalVersion - 1;
1585    this.next = void 0;
1586    this.effect = this;
1587    this["__v_isReadonly"] = !setter;
1588    this.isSSR = isSSR;
1589  }
1590  /**
1591   * @internal
1592   */
1593  notify() {
1594    this.flags |= 16;
1595    if (!(this.flags & 8) && // avoid infinite self recursion
1596    activeSub !== this) {
1597      batch(this, true);
1598      return true;
1599    }
1600  }
1601  get value() {
1602    const link = this.dep.track();
1603    refreshComputed(this);
1604    if (link) {
1605      link.version = this.dep.version;
1606    }
1607    return this._value;
1608  }
1609  set value(newValue) {
1610    if (this.setter) {
1611      this.setter(newValue);
1612    }
1613  }
1614}
1615function computed$1(getterOrOptions, debugOptions, isSSR = false) {
1616  let getter;
1617  let setter;
1618  if (isFunction$1(getterOrOptions)) {
1619    getter = getterOrOptions;
1620  } else {
1621    getter = getterOrOptions.get;
1622    setter = getterOrOptions.set;
1623  }
1624  const cRef = new ComputedRefImpl(getter, setter, isSSR);
1625  return cRef;
1626}
1627const INITIAL_WATCHER_VALUE = {};
1628const cleanupMap = /* @__PURE__ */ new WeakMap();
1629let activeWatcher = void 0;
1630function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
1631  if (owner) {
1632    let cleanups = cleanupMap.get(owner);
1633    if (!cleanups) cleanupMap.set(owner, cleanups = []);
1634    cleanups.push(cleanupFn);
1635  }
1636}
1637function watch$1(source, cb, options = EMPTY_OBJ) {
1638  const { immediate, deep, once: once2, scheduler, augmentJob, call } = options;
1639  const reactiveGetter = (source2) => {
1640    if (deep) return source2;
1641    if (isShallow(source2) || deep === false || deep === 0)
1642      return traverse(source2, 1);
1643    return traverse(source2);
1644  };
1645  let effect2;
1646  let getter;
1647  let cleanup;
1648  let boundCleanup;
1649  let forceTrigger = false;
1650  let isMultiSource = false;
1651  if (isRef(source)) {
1652    getter = () => source.value;
1653    forceTrigger = isShallow(source);
1654  } else if (isReactive(source)) {
1655    getter = () => reactiveGetter(source);
1656    forceTrigger = true;
1657  } else if (isArray$3(source)) {
1658    isMultiSource = true;
1659    forceTrigger = source.some((s2) => isReactive(s2) || isShallow(s2));
1660    getter = () => source.map((s2) => {
1661      if (isRef(s2)) {
1662        return s2.value;
1663      } else if (isReactive(s2)) {
1664        return reactiveGetter(s2);
1665      } else if (isFunction$1(s2)) {
1666        return call ? call(s2, 2) : s2();
1667      } else ;
1668    });
1669  } else if (isFunction$1(source)) {
1670    if (cb) {
1671      getter = call ? () => call(source, 2) : source;
1672    } else {
1673      getter = () => {
1674        if (cleanup) {
1675          pauseTracking();
1676          try {
1677            cleanup();
1678          } finally {
1679            resetTracking();
1680          }
1681        }
1682        const currentEffect = activeWatcher;
1683        activeWatcher = effect2;
1684        try {
1685          return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
1686        } finally {
1687          activeWatcher = currentEffect;
1688        }
1689      };
1690    }
1691  } else {
1692    getter = NOOP;
1693  }
1694  if (cb && deep) {
1695    const baseGetter = getter;
1696    const depth = deep === true ? Infinity : deep;
1697    getter = () => traverse(baseGetter(), depth);
1698  }
1699  const scope = getCurrentScope();
1700  const watchHandle = () => {
1701    effect2.stop();
1702    if (scope && scope.active) {
1703      remove(scope.effects, effect2);
1704    }
1705  };
1706  if (once2 && cb) {
1707    const _cb = cb;
1708    cb = (...args) => {
1709      _cb(...args);
1710      watchHandle();
1711    };
1712  }
1713  let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
1714  const job = (immediateFirstRun) => {
1715    if (!(effect2.flags & 1) || !effect2.dirty && !immediateFirstRun) {
1716      return;
1717    }
1718    if (cb) {
1719      const newValue = effect2.run();
1720      if (deep || forceTrigger || (isMultiSource ? newValue.some((v2, i2) => hasChanged(v2, oldValue[i2])) : hasChanged(newValue, oldValue))) {
1721        if (cleanup) {
1722          cleanup();
1723        }
1724        const currentWatcher = activeWatcher;
1725        activeWatcher = effect2;
1726        try {
1727          const args = [
1728            newValue,
1729            // pass undefined as the old value when it's changed for the first time
1730            oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
1731            boundCleanup
1732          ];
1733          call ? call(cb, 3, args) : (
1734            // @ts-expect-error
1735            cb(...args)
1736          );
1737          oldValue = newValue;
1738        } finally {
1739          activeWatcher = currentWatcher;
1740        }
1741      }
1742    } else {
1743      effect2.run();
1744    }
1745  };
1746  if (augmentJob) {
1747    augmentJob(job);
1748  }
1749  effect2 = new ReactiveEffect(getter);
1750  effect2.scheduler = scheduler ? () => scheduler(job, false) : job;
1751  boundCleanup = (fn) => onWatcherCleanup(fn, false, effect2);
1752  cleanup = effect2.onStop = () => {
1753    const cleanups = cleanupMap.get(effect2);
1754    if (cleanups) {
1755      if (call) {
1756        call(cleanups, 4);
1757      } else {
1758        for (const cleanup2 of cleanups) cleanup2();
1759      }
1760      cleanupMap.delete(effect2);
1761    }
1762  };
1763  if (cb) {
1764    if (immediate) {
1765      job(true);
1766    } else {
1767      oldValue = effect2.run();
1768    }
1769  } else if (scheduler) {
1770    scheduler(job.bind(null, true), true);
1771  } else {
1772    effect2.run();
1773  }
1774  watchHandle.pause = effect2.pause.bind(effect2);
1775  watchHandle.resume = effect2.resume.bind(effect2);
1776  watchHandle.stop = watchHandle;
1777  return watchHandle;
1778}
1779function traverse(value, depth = Infinity, seen2) {
1780  if (depth <= 0 || !isObject(value) || value["__v_skip"]) {
1781    return value;
1782  }

1783  seen2 = seen2 || /* @__PURE__ */ new Set();
1784  if (seen2.has(value)) {
1785    return value;
1786  }
1787  seen2.add(value);
1788  depth--;
1789  if (isRef(value)) {
1790    traverse(value.value, depth, seen2);
1791  } else if (isArray$3(value)) {
1792    for (let i2 = 0; i2 < value.length; i2++) {
1793      traverse(value[i2], depth, seen2);
1794    }
1795  } else if (isSet(value) || isMap(value)) {
1796    value.forEach((v2) => {
1797      traverse(v2, depth, seen2);
1798    });
1799  } else if (isPlainObject$3(value)) {
1800    for (const key in value) {
1801      traverse(value[key], depth, seen2);
1802    }
1803    for (const key of Object.getOwnPropertySymbols(value)) {
1804      if (Object.prototype.propertyIsEnumerable.call(value, key)) {
1805        traverse(value[key], depth, seen2);
1806      }
1807    }
1808  }
1809  return value;
1810}
1811/**
1812* @vue/runtime-core v3.5.14
1813* (c) 2018-present Yuxi (Evan) You and Vue contributors
1814* @license MIT
1815**/
1816const stack = [];
1817let isWarning = false;
1818function warn$1(msg, ...args) {
1819  if (isWarning) return;
1820  isWarning = true;
1821  pauseTracking();
1822  const instance = stack.length ? stack[stack.length - 1].component : null;
1823  const appWarnHandler = instance && instance.appContext.config.warnHandler;
1824  const trace = getComponentTrace();
1825  if (appWarnHandler) {
1826    callWithErrorHandling(
1827      appWarnHandler,
1828      instance,
1829      11,
1830      [
1831        // eslint-disable-next-line no-restricted-syntax
1832        msg + args.map((a2) => {
1833          var _a3, _b;
1834          return (_b = (_a3 = a2.toString) == null ? void 0 : _a3.call(a2)) != null ? _b : JSON.stringify(a2);
1835        }).join(""),
1836        instance && instance.proxy,
1837        trace.map(
1838          ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
1839        ).join("\n"),
1840        trace
1841      ]
1842    );
1843  } else {
1844    const warnArgs = [`[Vue warn]: ${msg}`, ...args];
1845    if (trace.length && // avoid spamming console during tests
1846    true) {
1847      warnArgs.push(`
1848`, ...formatTrace(trace));
1849    }
1850    console.warn(...warnArgs);
1851  }
1852  resetTracking();
1853  isWarning = false;
1854}
1855function getComponentTrace() {
1856  let currentVNode = stack[stack.length - 1];
1857  if (!currentVNode) {
1858    return [];
1859  }
1860  const normalizedStack = [];
1861  while (currentVNode) {
1862    const last2 = normalizedStack[0];
1863    if (last2 && last2.vnode === currentVNode) {
1864      last2.recurseCount++;
1865    } else {
1866      normalizedStack.push({
1867        vnode: currentVNode,
1868        recurseCount: 0
1869      });
1870    }
1871    const parentInstance = currentVNode.component && currentVNode.component.parent;
1872    currentVNode = parentInstance && parentInstance.vnode;
1873  }
1874  return normalizedStack;
1875}
1876function formatTrace(trace) {
1877  const logs = [];
1878  trace.forEach((entry2, i2) => {
1879    logs.push(...i2 === 0 ? [] : [`
1880`], ...formatTraceEntry(entry2));
1881  });
1882  return logs;
1883}
1884function formatTraceEntry({ vnode, recurseCount }) {
1885  const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
1886  const isRoot = vnode.component ? vnode.component.parent == null : false;
1887  const open2 = ` at <${formatComponentName(
1888    vnode.component,
1889    vnode.type,
1890    isRoot
1891  )}`;
1892  const close = `>` + postfix;
1893  return vnode.props ? [open2, ...formatProps(vnode.props), close] : [open2 + close];
1894}
1895function formatProps(props) {
1896  const res = [];
1897  const keys = Object.keys(props);
1898  keys.slice(0, 3).forEach((key) => {
1899    res.push(...formatProp(key, props[key]));
1900  });
1901  if (keys.length > 3) {
1902    res.push(` ...`);
1903  }
1904  return res;
1905}
1906function formatProp(key, value, raw) {
1907  if (isString(value)) {
1908    value = JSON.stringify(value);
1909    return raw ? value : [`${key}=${value}`];
1910  } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
1911    return raw ? value : [`${key}=${value}`];
1912  } else if (isRef(value)) {
1913    value = formatProp(key, toRaw(value.value), true);
1914    return raw ? value : [`${key}=Ref<`, value, `>`];
1915  } else if (isFunction$1(value)) {
1916    return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
1917  } else {
1918    value = toRaw(value);
1919    return raw ? value : [`${key}=`, value];
1920  }
1921}
1922function callWithErrorHandling(fn, instance, type, args) {
1923  try {
1924    return args ? fn(...args) : fn();
1925  } catch (err) {
1926    handleError(err, instance, type);
1927  }
1928}
1929function callWithAsyncErrorHandling(fn, instance, type, args) {
1930  if (isFunction$1(fn)) {
1931    const res = callWithErrorHandling(fn, instance, type, args);
1932    if (res && isPromise$1(res)) {
1933      res.catch((err) => {
1934        handleError(err, instance, type);
1935      });
1936    }
1937    return res;
1938  }
1939  if (isArray$3(fn)) {
1940    const values = [];
1941    for (let i2 = 0; i2 < fn.length; i2++) {
1942      values.push(callWithAsyncErrorHandling(fn[i2], instance, type, args));
1943    }
1944    return values;
1945  }
1946}
1947function handleError(err, instance, type, throwInDev = true) {
1948  const contextVNode = instance ? instance.vnode : null;
1949  const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
1950  if (instance) {

1951    let cur = instance.parent;
1952    const exposedInstance = instance.proxy;
1953    const errorInfo = `https://vuejs.org/error-reference/#runtime-${type}`;
1954    while (cur) {
1955      const errorCapturedHooks = cur.ec;
1956      if (errorCapturedHooks) {
1957        for (let i2 = 0; i2 < errorCapturedHooks.length; i2++) {
1958          if (errorCapturedHooks[i2](err, exposedInstance, errorInfo) === false) {
1959            return;
1960          }
1961        }
1962      }
1963      cur = cur.parent;
1964    }
1965    if (errorHandler) {
1966      pauseTracking();
1967      callWithErrorHandling(errorHandler, null, 10, [
1968        err,
1969        exposedInstance,
1970        errorInfo
1971      ]);
1972      resetTracking();
1973      return;
1974    }
1975  }
1976  logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
1977}
1978function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
1979  if (throwInProd) {
1980    throw err;
1981  } else {
1982    console.error(err);
1983  }
1984}
1985const queue = [];
1986let flushIndex = -1;
1987const pendingPostFlushCbs = [];
1988let activePostFlushCbs = null;
1989let postFlushIndex = 0;
1990const resolvedPromise = /* @__PURE__ */ Promise.resolve();
1991let currentFlushPromise = null;
1992function nextTick(fn) {
1993  const p2 = currentFlushPromise || resolvedPromise;
1994  return fn ? p2.then(this ? fn.bind(this) : fn) : p2;
1995}
1996function findInsertionIndex$1(id) {
1997  let start = flushIndex + 1;
1998  let end = queue.length;
1999  while (start < end) {
2000    const middle = start + end >>> 1;
2001    const middleJob = queue[middle];
2002    const middleJobId = getId(middleJob);
2003    if (middleJobId < id || middleJobId === id && middleJob.flags & 2) {
2004      start = middle + 1;
2005    } else {
2006      end = middle;
2007    }
2008  }
2009  return start;
2010}
2011function queueJob(job) {
2012  if (!(job.flags & 1)) {
2013    const jobId = getId(job);
2014    const lastJob = queue[queue.length - 1];
2015    if (!lastJob || // fast path when the job id is larger than the tail
2016    !(job.flags & 2) && jobId >= getId(lastJob)) {
2017      queue.push(job);
2018    } else {
2019      queue.splice(findInsertionIndex$1(jobId), 0, job);
2020    }
2021    job.flags |= 1;
2022    queueFlush();
2023  }
2024}
2025function queueFlush() {
2026  if (!currentFlushPromise) {
2027    currentFlushPromise = resolvedPromise.then(flushJobs);
2028  }
2029}
2030function queuePostFlushCb(cb) {
2031  if (!isArray$3(cb)) {
2032    if (activePostFlushCbs && cb.id === -1) {
2033      activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
2034    } else if (!(cb.flags & 1)) {
2035      pendingPostFlushCbs.push(cb);
2036      cb.flags |= 1;
2037    }
2038  } else {
2039    pendingPostFlushCbs.push(...cb);
2040  }
2041  queueFlush();
2042}
2043function flushPreFlushCbs(instance, seen2, i2 = flushIndex + 1) {
2044  for (; i2 < queue.length; i2++) {
2045    const cb = queue[i2];
2046    if (cb && cb.flags & 2) {
2047      if (instance && cb.id !== instance.uid) {
2048        continue;
2049      }
2050      queue.splice(i2, 1);
2051      i2--;
2052      if (cb.flags & 4) {
2053        cb.flags &= -2;
2054      }
2055      cb();
2056      if (!(cb.flags & 4)) {
2057        cb.flags &= -2;
2058      }
2059    }
2060  }
2061}
2062function flushPostFlushCbs(seen2) {
2063  if (pendingPostFlushCbs.length) {
2064    const deduped = [...new Set(pendingPostFlushCbs)].sort(
2065      (a2, b) => getId(a2) - getId(b)
2066    );
2067    pendingPostFlushCbs.length = 0;
2068    if (activePostFlushCbs) {
2069      activePostFlushCbs.push(...deduped);
2070      return;
2071    }
2072    activePostFlushCbs = deduped;
2073    for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
2074      const cb = activePostFlushCbs[postFlushIndex];
2075      if (cb.flags & 4) {
2076        cb.flags &= -2;
2077      }
2078      if (!(cb.flags & 8)) cb();
2079      cb.flags &= -2;
2080    }
2081    activePostFlushCbs = null;
2082    postFlushIndex = 0;
2083  }
2084}
2085const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
2086function flushJobs(seen2) {
2087  try {
2088    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
2089      const job = queue[flushIndex];
2090      if (job && !(job.flags & 8)) {
2091        if (false) ;
2092        if (job.flags & 4) {
2093          job.flags &= ~1;
2094        }
2095        callWithErrorHandling(
2096          job,
2097          job.i,
2098          job.i ? 15 : 14
2099        );
2100        if (!(job.flags & 4)) {
2101          job.flags &= ~1;
2102        }
2103      }
2104    }
2105  } finally {
2106    for (; flushIndex < queue.length; flushIndex++) {
2107      const job = queue[flushIndex];
2108      if (job) {
2109        job.flags &= -2;
2110      }
2111    }
2112    flushIndex = -1;
2113    queue.length = 0;
2114    flushPostFlushCbs();
2115    currentFlushPromise = null;
2116    if (queue.length || pendingPostFlushCbs.length) {
2117      flushJobs();
2118    }
2119  }
2120}
2121let currentRenderingInstance = null;
2122let currentScopeId = null;
2123function setCurrentRenderingInstance(instance) {
2124  const prev = currentRenderingInstance;
2125  currentRenderingInstance = instance;
2126  currentScopeId = instance && instance.type.__scopeId || null;
2127  return prev;
2128}
2129function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
2130  if (!ctx) return fn;
2131  if (fn._n) {
2132    return fn;
2133  }
2134  const renderFnWithContext = (...args) => {
2135    if (renderFnWithContext._d) {
2136      setBlockTracking(-1);
2137    }
2138    const prevInstance = setCurrentRenderingInstance(ctx);
2139    let res;
2140    try {
2141      res = fn(...args);
2142    } finally {
2143      setCurrentRenderingInstance(prevInstance);
2144      if (renderFnWithContext._d) {
2145        setBlockTracking(1);
2146      }
2147    }
2148    return res;
2149  };
2150  renderFnWithContext._n = true;
2151  renderFnWithContext._c = true;
2152  renderFnWithContext._d = true;
2153  return renderFnWithContext;
2154}
2155function withDirectives(vnode, directives) {
2156  if (currentRenderingInstance === null) {
2157    return vnode;
2158  }
2159  const instance = getComponentPublicInstance(currentRenderingInstance);
2160  const bindings = vnode.dirs || (vnode.dirs = []);
2161  for (let i2 = 0; i2 < directives.length; i2++) {
2162    let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i2];
2163    if (dir) {
2164      if (isFunction$1(dir)) {
2165        dir = {
2166          mounted: dir,
2167          updated: dir
2168        };
2169      }
2170      if (dir.deep) {
2171        traverse(value);
2172      }
2173      bindings.push({
2174        dir,
2175        instance,
2176        value,
2177        oldValue: void 0,
2178        arg,
2179        modifiers
2180      });
2181    }
2182  }
2183  return vnode;
2184}
2185function invokeDirectiveHook(vnode, prevVNode, instance, name) {
2186  const bindings = vnode.dirs;
2187  const oldBindings = prevVNode && prevVNode.dirs;
2188  for (let i2 = 0; i2 < bindings.length; i2++) {
2189    const binding = bindings[i2];
2190    if (oldBindings) {
2191      binding.oldValue = oldBindings[i2].value;
2192    }
2193    let hook = binding.dir[name];
2194    if (hook) {
2195      pauseTracking();

2395      hostRemove(targetStart);
2396      hostRemove(targetAnchor);
2397    }
2398    doRemove && hostRemove(anchor);
2399    if (shapeFlag & 16) {
2400      const shouldRemove = doRemove || !isTeleportDisabled(props);
2401      for (let i2 = 0; i2 < children.length; i2++) {
2402        const child = children[i2];
2403        unmount(
2404          child,
2405          parentComponent,
2406          parentSuspense,
2407          shouldRemove,
2408          !!child.dynamicChildren
2409        );
2410      }
2411    }
2412  },
2413  move: moveTeleport,
2414  hydrate: hydrateTeleport
2415};
2416function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
2417  if (moveType === 0) {
2418    insert(vnode.targetAnchor, container, parentAnchor);
2419  }
2420  const { el, anchor, shapeFlag, children, props } = vnode;
2421  const isReorder = moveType === 2;
2422  if (isReorder) {
2423    insert(el, container, parentAnchor);
2424  }
2425  if (!isReorder || isTeleportDisabled(props)) {
2426    if (shapeFlag & 16) {
2427      for (let i2 = 0; i2 < children.length; i2++) {
2428        move(
2429          children[i2],
2430          container,
2431          parentAnchor,
2432          2
2433        );
2434      }
2435    }
2436  }
2437  if (isReorder) {
2438    insert(anchor, container, parentAnchor);
2439  }
2440}
2441function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, {
2442  o: { nextSibling, parentNode, querySelector, insert, createText }
2443}, hydrateChildren) {
2444  const target = vnode.target = resolveTarget(
2445    vnode.props,
2446    querySelector
2447  );
2448  if (target) {
2449    const disabled = isTeleportDisabled(vnode.props);
2450    const targetNode = target._lpa || target.firstChild;
2451    if (vnode.shapeFlag & 16) {
2452      if (disabled) {
2453        vnode.anchor = hydrateChildren(
2454          nextSibling(node),
2455          vnode,
2456          parentNode(node),
2457          parentComponent,
2458          parentSuspense,
2459          slotScopeIds,
2460          optimized
2461        );
2462        vnode.targetStart = targetNode;
2463        vnode.targetAnchor = targetNode && nextSibling(targetNode);
2464      } else {
2465        vnode.anchor = nextSibling(node);
2466        let targetAnchor = targetNode;
2467        while (targetAnchor) {
2468          if (targetAnchor && targetAnchor.nodeType === 8) {
2469            if (targetAnchor.data === "teleport start anchor") {
2470              vnode.targetStart = targetAnchor;
2471            } else if (targetAnchor.data === "teleport anchor") {
2472              vnode.targetAnchor = targetAnchor;
2473              target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
2474              break;
2475            }
2476          }
2477          targetAnchor = nextSibling(targetAnchor);
2478        }
2479        if (!vnode.targetAnchor) {
2480          prepareAnchor(target, vnode, createText, insert);
2481        }
2482        hydrateChildren(
2483          targetNode && nextSibling(targetNode),
2484          vnode,
2485          target,
2486          parentComponent,
2487          parentSuspense,
2488          slotScopeIds,
2489          optimized
2490        );
2491      }
2492    }
2493    updateCssVars(vnode, disabled);
2494  }
2495  return vnode.anchor && nextSibling(vnode.anchor);
2496}
2497const Teleport = TeleportImpl;
2498function updateCssVars(vnode, isDisabled) {
2499  const ctx = vnode.ctx;
2500  if (ctx && ctx.ut) {
2501    let node, anchor;
2502    if (isDisabled) {
2503      node = vnode.el;
2504      anchor = vnode.anchor;
2505    } else {
2506      node = vnode.targetStart;
2507      anchor = vnode.targetAnchor;
2508    }
2509    while (node && node !== anchor) {
2510      if (node.nodeType === 1) node.setAttribute("data-v-owner", ctx.uid);
2511      node = node.nextSibling;
2512    }
2513    ctx.ut();
2514  }
2515}
2516function prepareAnchor(target, vnode, createText, insert) {
2517  const targetStart = vnode.targetStart = createText("");
2518  const targetAnchor = vnode.targetAnchor = createText("");
2519  targetStart[TeleportEndKey] = targetAnchor;
2520  if (target) {
2521    insert(targetStart, target);
2522    insert(targetAnchor, target);
2523  }
2524  return targetAnchor;
2525}
2526const leaveCbKey = Symbol("_leaveCb");
2527const enterCbKey = Symbol("_enterCb");
2528function useTransitionState() {
2529  const state = {
2530    isMounted: false,
2531    isLeaving: false,
2532    isUnmounting: false,
2533    leavingVNodes: /* @__PURE__ */ new Map()
2534  };
2535  onMounted(() => {
2536    state.isMounted = true;
2537  });
2538  onBeforeUnmount(() => {
2539    state.isUnmounting = true;
2540  });
2541  return state;
2542}
2543const TransitionHookValidator = [Function, Array];
2544const BaseTransitionPropsValidators = {
2545  mode: String,
2546  appear: Boolean,
2547  persisted: Boolean,
2548  // enter
2549  onBeforeEnter: TransitionHookValidator,
2550  onEnter: TransitionHookValidator,
2551  onAfterEnter: TransitionHookValidator,
2552  onEnterCancelled: TransitionHookValidator,
2553  // leave
2554  onBeforeLeave: TransitionHookValidator,
2555  onLeave: TransitionHookValidator,
2556  onAfterLeave: TransitionHookValidator,
2557  onLeaveCancelled: TransitionHookValidator,
2558  // appear
2559  onBeforeAppear: TransitionHookValidator,
2560  onAppear: TransitionHookValidator,
2561  onAfterAppear: TransitionHookValidator,
2562  onAppearCancelled: TransitionHookValidator
2563};
2564const recursiveGetSubtree = (instance) => {
2565  const subTree = instance.subTree;
2566  return subTree.component ? recursiveGetSubtree(subTree.component) : subTree;
2567};
2568const BaseTransitionImpl = {
2569  name: `BaseTransition`,
2570  props: BaseTransitionPropsValidators,
2571  setup(props, { slots }) {
2572    const instance = getCurrentInstance();
2573    const state = useTransitionState();
2574    return () => {
2575      const children = slots.default && getTransitionRawChildren(slots.default(), true);
2576      if (!children || !children.length) {
2577        return;
2578      }
2579      const child = findNonCommentChild(children);
2580      const rawProps = toRaw(props);
2581      const { mode } = rawProps;
2582      if (state.isLeaving) {
2583        return emptyPlaceholder(child);
2584      }
2585      const innerChild = getInnerChild$1(child);
2586      if (!innerChild) {
2587        return emptyPlaceholder(child);
2588      }
2589      let enterHooks = resolveTransitionHooks(
2590        innerChild,
2591        rawProps,
2592        state,
2593        instance,
2594        // #11061, ensure enterHooks is fresh after clone
2595        (hooks) => enterHooks = hooks
2596      );
2597      if (innerChild.type !== Comment) {
2598        setTransitionHooks(innerChild, enterHooks);
2599      }
2600      let oldInnerChild = instance.subTree && getInnerChild$1(instance.subTree);
2601      if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(innerChild, oldInnerChild) && recursiveGetSubtree(instance).type !== Comment) {
2602        let leavingHooks = resolveTransitionHooks(
2603          oldInnerChild,
2604          rawProps,
2605          state,
2606          instance
2607        );
2608        setTransitionHooks(oldInnerChild, leavingHooks);
2609        if (mode === "out-in" && innerChild.type !== Comment) {
2610          state.isLeaving = true;
2611          leavingHooks.afterLeave = () => {
2612            state.isLeaving = false;
2613            if (!(instance.job.flags & 8)) {
2614              instance.update();
2615            }
2616            delete leavingHooks.afterLeave;
2617            oldInnerChild = void 0;
2618          };
2619          return emptyPlaceholder(child);
2620        } else if (mode === "in-out" && innerChild.type !== Comment) {
2621          leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
2622            const leavingVNodesCache = getLeavingNodesForType(
2623              state,
2624              oldInnerChild
2625            );
2626            leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
2627            el[leaveCbKey] = () => {
2628              earlyRemove();
2629              el[leaveCbKey] = void 0;
2630              delete enterHooks.delayedLeave;
2631              oldInnerChild = void 0;
2632            };
2633            enterHooks.delayedLeave = () => {
2634              delayedLeave();
2635              delete enterHooks.delayedLeave;
2636              oldInnerChild = void 0;
2637            };
2638          };
2639        } else {
2640          oldInnerChild = void 0;
2641        }
2642      } else if (oldInnerChild) {
2643        oldInnerChild = void 0;
2644      }
2645      return child;
2646    };
2647  }
2648};
2649function findNonCommentChild(children) {
2650  let child = children[0];
2651  if (children.length > 1) {
2652    for (const c2 of children) {
2653      if (c2.type !== Comment) {
2654        child = c2;
2655        break;
2656      }
2657    }
2658  }
2659  return child;
2660}
2661const BaseTransition = BaseTransitionImpl;
2662function getLeavingNodesForType(state, vnode) {
2663  const { leavingVNodes } = state;
2664  let leavingVNodesCache = leavingVNodes.get(vnode.type);
2665  if (!leavingVNodesCache) {
2666    leavingVNodesCache = /* @__PURE__ */ Object.create(null);
2667    leavingVNodes.set(vnode.type, leavingVNodesCache);
2668  }
2669  return leavingVNodesCache;
2670}
2671function resolveTransitionHooks(vnode, props, state, instance, postClone) {
2672  const {
2673    appear,
2674    mode,
2675    persisted = false,
2676    onBeforeEnter,
2677    onEnter,
2678    onAfterEnter,
2679    onEnterCancelled,
2680    onBeforeLeave,
2681    onLeave,
2682    onAfterLeave,
2683    onLeaveCancelled,
2684    onBeforeAppear,
2685    onAppear,
2686    onAfterAppear,
2687    onAppearCancelled
2688  } = props;
2689  const key = String(vnode.key);
2690  const leavingVNodesCache = getLeavingNodesForType(state, vnode);
2691  const callHook2 = (hook, args) => {
2692    hook && callWithAsyncErrorHandling(
2693      hook,
2694      instance,
2695      9,
2696      args
2697    );
2698  };
2699  const callAsyncHook = (hook, args) => {
2700    const done = args[1];
2701    callHook2(hook, args);
2702    if (isArray$3(hook)) {
2703      if (hook.every((hook2) => hook2.length <= 1)) done();
2704    } else if (hook.length <= 1) {
2705      done();
2706    }
2707  };
2708  const hooks = {
2709    mode,
2710    persisted,
2711    beforeEnter(el) {
2712      let hook = onBeforeEnter;
2713      if (!state.isMounted) {
2714        if (appear) {
2715          hook = onBeforeAppear || onBeforeEnter;
2716        } else {
2717          return;
2718        }
2719      }
2720      if (el[leaveCbKey]) {
2721        el[leaveCbKey](
2722          true
2723          /* cancelled */
2724        );
2725      }
2726      const leavingVNode = leavingVNodesCache[key];
2727      if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {
2728        leavingVNode.el[leaveCbKey]();
2729      }
2730      callHook2(hook, [el]);
2731    },
2732    enter(el) {
2733      let hook = onEnter;
2734      let afterHook = onAfterEnter;
2735      let cancelHook = onEnterCancelled;
2736      if (!state.isMounted) {
2737        if (appear) {
2738          hook = onAppear || onEnter;
2739          afterHook = onAfterAppear || onAfterEnter;
2740          cancelHook = onAppearCancelled || onEnterCancelled;
2741        } else {
2742          return;
2743        }
2744      }
2745      let called = false;
2746      const done = el[enterCbKey] = (cancelled) => {
2747        if (called) return;
2748        called = true;
2749        if (cancelled) {
2750          callHook2(cancelHook, [el]);
2751        } else {
2752          callHook2(afterHook, [el]);
2753        }
2754        if (hooks.delayedLeave) {
2755          hooks.delayedLeave();
2756        }
2757        el[enterCbKey] = void 0;
2758      };
2759      if (hook) {
2760        callAsyncHook(hook, [el, done]);
2761      } else {
2762        done();
2763      }
2764    },
2765    leave(el, remove2) {