https://www.kaktusreality.cz/poskireal/poskireal-v26.9/0/frontend/…/frontend-filter-4f081102.js?v=1791445361

53**/
54/*! #__NO_SIDE_EFFECTS__ */
55// @__NO_SIDE_EFFECTS__
56function makeMap(str) {
57  const map = /* @__PURE__ */ Object.create(null);
58  for (const key of str.split(","))
59    map[key] = 1;
60  return (val) => val in map;
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 i = arr.indexOf(el);
73  if (i > -1) {
74    arr.splice(i, 1);
75  }
76};
77const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
78const hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
79const isArray = Array.isArray;
80const isMap = (val) => toTypeString(val) === "[object Map]";
81const isSet = (val) => toTypeString(val) === "[object Set]";
82const isDate = (val) => toTypeString(val) === "[object Date]";
83const isFunction = (val) => typeof val === "function";
84const isString = (val) => typeof val === "string";
85const isSymbol = (val) => typeof val === "symbol";
86const isObject$1 = (val) => val !== null && typeof val === "object";
87const isPromise = (val) => {
88  return (isObject$1(val) || isFunction(val)) && isFunction(val.then) && isFunction(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$1 = (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, (_, c) => c ? c.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 s = str ? `on${capitalize(str)}` : ``;
124    return s;
125  }
126);
127const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
128const invokeArrayFns = (fns, ...arg) => {
129  for (let i = 0; i < fns.length; i++) {
130    fns[i](...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 n = parseFloat(val);
143  return isNaN(n) ? val : n;
144};
145let _globalThis;
146const getGlobalThis = () => {
147  return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
148};
149function normalizeStyle(value) {
150  if (isArray(value)) {
151    const res = {};
152    for (let i = 0; i < value.length; i++) {
153      const item = value[i];
154      const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
155      if (normalized) {
156        for (const key in normalized) {
157          res[key] = normalized[key];
158        }
159      }
160    }
161    return res;
162  } else if (isString(value) || isObject$1(value)) {
163    return value;
164  }
165}
166const listDelimiterRE = /;(?![^(]*\))/g;
167const propertyDelimiterRE = /:([^]+)/;
168const styleCommentRE = /\/\*[^]*?\*\//g;
169function parseStringStyle(cssText) {
170  const ret = {};
171  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEac

171h((item) => {
172    if (item) {
173      const tmp = item.split(propertyDelimiterRE);
174      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
175    }
176  });
177  return ret;
178}
179function normalizeClass(value) {
180  let res = "";
181  if (isString(value)) {
182    res = value;
183  } else if (isArray(value)) {
184    for (let i = 0; i < value.length; i++) {
185      const normalized = normalizeClass(value[i]);
186      if (normalized) {
187        res += normalized + " ";
188      }
189    }
190  } else if (isObject$1(value)) {
191    for (const name in value) {
192      if (value[name]) {
193        res += name + " ";
194      }
195    }
196  }
197  return res.trim();
198}
199const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
200const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
201function includeBooleanAttr(value) {
202  return !!value || value === "";
203}
204function looseCompareArrays(a, b) {
205  if (a.length !== b.length)
206    return false;
207  let equal = true;
208  for (let i = 0; equal && i < a.length; i++) {
209    equal = looseEqual(a[i], b[i]);
210  }
211  return equal;
212}
213function looseEqual(a, b) {
214  if (a === b)
215    return true;
216  let aValidType = isDate(a);
217  let bValidType = isDate(b);
218  if (aValidType || bValidType) {
219    return aValidType && bValidType ? a.getTime() === b.getTime() : false;
220  }
221  aValidType = isSymbol(a);
222  bValidType = isSymbol(b);
223  if (aValidType || bValidType) {
224    return a === b;
225  }
226  aValidType = isArray(a);
227  bValidType = isArray(b);
228  if (aValidType || bValidType) {
229    return aValidType && bValidType ? looseCompareArrays(a, b) : false;
230  }
231  aValidType = isObject$1(a);
232  bValidType = isObject$1(b);
233  if (aValidType || bValidType) {
234    if (!aValidType || !bValidType) {
235      return false;
236    }
237    const aKeysCount = Object.keys(a).length;
238    const bKeysCount = Object.keys(b).length;
239    if (aKeysCount !== bKeysCount) {
240      return false;
241    }
242    for (const key in a) {
243      const aHasKey = a.hasOwnProperty(key);
244      const bHasKey = b.hasOwnProperty(key);
245      if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
246        return false;
247      }
248    }
249  }
250  return String(a) === String(b);
251}
252function looseIndexOf(arr, val) {
253  return arr.findIndex((item) => looseEqual(item, val));
254}
255const isRef$1 = (val) => {
256  return !!(val && val["__v_isRef"] === true);
257};
258const toDisplayString = (val) => {
259  return isString(val) ? val : val == null ? "" : isArray(val) || isObject$1(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef$1(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
260};
261const replacer = (_key, val) => {
262  if (isRef$1(val)) {
263    return replacer(_key, val.value);
264  } else if (isMap(val)) {
265    return {
266      [`Map(${val.size})`]: [...val.entries()].reduce(
267        (entries, [key, val2], i) => {
268          entries[stringifySymbol(key, i) + " =>"] = val2;
269          return entries;
270        },
271        {}
272      )
273    };
274  } else if (isSet(val)) {
275    return {
276      [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
277    };
278  } else if (isSymbol(val)) {
279    return stringifySymbol(val);
280  } else if (isObject$1(val) && !isArray(val) && !isPlainObject$1(val)) {
281    return String(val);
282  }
283  return val;
284};
285const stringifySymbol = (v, i = "") => {
286  var _a2;
287  return (
288    // Symbol.description in es2019+ so we need to cast here to pass
289    // the lib: es2016 check
290    isSymbol(v) ? `Symbol(${(_a2 = v.description) != null ? _a2 : i})` : v
291  );
292};
293/**
294* @vue/reactivity v3.5.13
295* (c) 2018-present Yuxi (Evan) You and Vue contributors
296* @license MIT

485      pausedQueueEffects.add(this);
486    } else if (this.scheduler) {
487      this.scheduler();
488    } else {
489      this.runIfDirty();
490    }
491  }
492  /**
493   * @internal
494   */
495  runIfDirty() {
496    if (isDirty(this)) {
497      this.run();
498    }
499  }
500  get dirty() {
501    return isDirty(this);
502  }
503}
504let batchDepth = 0;
505let batchedSub;
506let batchedComputed;
507function batch(sub, isComputed2 = false) {
508  sub.flags |= 8;
509  if (isComputed2) {
510    sub.next = batchedComputed;
511    batchedComputed = sub;
512    return;
513  }
514  sub.next = batchedSub;
515  batchedSub = sub;
516}
517function startBatch() {
518  batchDepth++;
519}
520function endBatch() {
521  if (--batchDepth > 0) {
522    return;
523  }
524  if (batchedComputed) {
525    let e = batchedComputed;
526    batchedComputed = void 0;
527    while (e) {
528      const next = e.next;
529      e.next = void 0;
530      e.flags &= ~8;
531      e = next;
532    }
533  }
534  let error;
535  while (batchedSub) {
536    let e = batchedSub;
537    batchedSub = void 0;
538    while (e) {
539      const next = e.next;
540      e.next = void 0;
541      e.flags &= ~8;
542      if (e.flags & 1) {
543        try {
544          ;
545          e.trigger();
546        } catch (err) {
547          if (!error)
548            error = err;
549        }
550      }
551      e = next;
552    }
553  }
554  if (error)
555    throw error;
556}
557function prepareDeps(sub) {
558  for (let link = sub.deps; link; link = link.nextDep) {
559    link.version = -1;
560    link.prevActiveLink = link.dep.activeLink;
561    link.dep.activeLink = link;
562  }
563}
564function cleanupDeps(sub) {
565  let head;
566  let tail = sub.depsTail;
567  let link = tail;
568  while (link) {
569    const prev = link.prevDep;
570    if (link.version === -1) {
571      if (link === tail)
572        tail = prev;
573      removeSub(link);
574      removeDep(link);
575    } else {
576      head = link;
577    }
578    link.dep.activeLink = link.prevActiveLink;
579    link.prevActiveLink = void 0;
580    link = prev;
581  }
582  sub.deps = head;
583  sub.depsTail = tail;
584}
585function isDirty(sub) {
586  for (let link = sub.deps; link; link = link.nextDep) {
587    if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
588      return true;
589    }
590  }
591  if (sub._dirty) {
592    return true;
593  }
594  return false;
595}
596function refreshComputed(computed2) {
597  if (computed2.flags & 4 && !(computed2.flags & 16)) {
598    return;
599  }
600  computed2.flags &= ~16;
601  if (computed2.globalVersion === globalVersion) {
602    return;
603  }
604  computed2.globalVersion = globalVersion;
605  const dep = computed2.dep;
606  computed2.flags |= 2;
607  if (dep.version > 0 && !computed2.isSSR && computed2.deps && !isDirty(computed2)) {
608    computed2.flags &= ~2;
609    return;
610  }
611  const prevSub = activeSub;
612  const prevShouldTrack = shouldTrack;
613  activeSub = computed2;
614  shouldTrack = true;
615  try {
616    prepareDeps(computed2);
617    const value = computed2.fn(computed2._value);
618    if (dep.version === 0 || hasChanged(value, computed2._value)) {
619      computed2._value = value;
620      dep.version++;
621    }
622  } catch (err) {
623    dep.version++;
624    throw err;
625  } finally {
626    activeSub = prevSub;
627    shouldTrack = prevShouldTrack;
628    cleanupDeps(computed2);
629    computed2.flags &= ~2;
630  }
631}
632function removeSub(link, soft = false) {
633  const { dep, prevSub, nextSub } = link;
634  if (prevSub) {
635    prevSub.nextSub = nextSub;
636    link.prevSub = void 0;
637  }
638  if (nextSub) {
639    nextSub.prevSub = prevSub;
640    link.nextSub = void 0;
641  }
642  if (dep.subs === link) {
643    dep.subs = prevSub;
644    if (!prevSub && dep.computed) {
645      dep.computed.flags &= ~4;
646      for (let l = dep.computed.deps; l; l = l.nextDep) {
647        removeSub(l, true);
648      }
649    }
650  }
651  if (!soft && !--dep.sc && dep.map) {
652    dep.map.delete(dep.key);
653  }
654}
655function removeDep(link) {
656  const { prevDep, nextDep } = link;
657  if (prevDep) {
658    prevDep.nextDep = nextDep;
659    link.prevDep = void 0;
660  }
661  if (nextDep) {
662    nextDep.prevDep = prevDep;
663    link.nextDep = void 0;
664  }
665}
666let shouldTrack = true;
667const trackStack = [];
668function pauseTracking() {
669  trackStack.push(shouldTrack);
670  shouldTrack = false;
671}
672function resetTracking() {
673  const last = trackStack.pop();
674  shouldTrack = last === void 0 ? true : last;
675}
676function cleanupEffect(e) {
677  const { cleanup } = e;
678  e.cleanup = void 0;
679  if (cleanup) {
680    const prevSub = activeSub;
681    activeSub = void 0;
682    try {
683      cleanup();
684    } finally {
685      activeSub = prevSub;
686    }
687  }
688}
689let globalVersion = 0;
690class Link {
691  constructor(sub, dep) {
692    this.sub = sub;
693    this.dep = dep;
694    this.version = dep.version;
695    this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
696  }
697}
698class Dep {
699  constructor(computed2) {
700    this.computed = computed2;
701    this.version = 0;
702    this.activeLink = void 0;
703    this.subs = void 0;
704    this.map = void 0;
705    this.key = void 0;
706    this.sc = 0;
707  }
708  track(debugInfo) {
709    if (!activeSub || !shouldTrack || activeSub === this.computed) {
710      return;
711    }
712    let link = this.activeLink;
713    if (link === void 0 || link.sub !== activeSub) {
714      link = this.activeLink = new Link(activeSub, this);
715      if (!activeSub.deps) {
716        activeSub.deps = activeSub.depsTail = link;
717      } else {
718        link.prevDep = activeSub.depsTail;
719        activeSub.depsTail.nextDep = link;
720        activeSub.depsTail = link;
721      }
722      addSub(link);
723    } else if (link.version === -1) {
724      link.version = this.version;
725      if (link.nextDep) {
726        const next = link.nextDep;
727        next.prevDep = link.prevDep;
728        if (link.prevDep) {
729          link.prevDep.nextDep = next;
730        }
731        link.prevDep = activeSub.depsTail;
732        link.nextDep = void 0;
733        activeSub.depsTail.nextDep = link;
734        activeSub.depsTail = link;
735        if (activeSub.deps === link) {
736          activeSub.deps = next;
737        }
738      }
739    }
740    return link;
741  }
742  trigger(debugInfo) {
743    this.version++;
744    globalVersion++;
745    this.notify(debugInfo);
746  }
747  notify(debugInfo) {
748    startBatch();
749    try {
750      if (false)
751        ;
752      for (let link = this.subs; link; link = link.prevSub) {
753        if (link.sub.notify()) {
754          ;
755          link.sub.dep.notify();
756        }
757      }
758    } finally {
759      endBatch();
760    }
761  }
762}
763function addSub(link) {
764  link.dep.sc++;
765  if (link.sub.flags & 4) {
766    const computed2 = link.dep.computed;
767    if (computed2 && !link.dep.subs) {
768      computed2.flags |= 4 | 16;
769      for (let l = computed2.deps; l; l = l.nextDep) {
770        addSub(l);
771      }
772    }
773    const currentTail = link.dep.subs;
774    if (currentTail !== link) {
775      link.prevSub = currentTail;
776      if (currentTail)
777        currentTail.nextSub = link;
778    }
779    link.dep.subs = link;
780  }
781}
782const targetMap = /* @__PURE__ */ new WeakMap();
783const ITERATE_KEY = Symbol(
784  ""
785);
786const MAP_KEY_ITERATE_KEY = Symbol(
787  ""
788);
789const ARRAY_ITERATE_KEY = Symbol(
790  ""
791);
792function track(target, type, key) {
793  if (shouldTrack && activeSub) {
794    let depsMap = targetMap.get(target);
795    if (!depsMap) {
796      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
797    }
798    let dep = depsMap.get(key);
799    if (!dep) {
800      depsMap.set(key, dep = new Dep());
801      dep.map = depsMap;
802      dep.key = key;
803    }
804    {
805      dep.track();
806    }
807  }
808}
809function trigger(target, type, key, newValue, oldValue, oldTarget) {
810  const depsMap = targetMap.get(target);
811  if (!depsMap) {
812    globalVersion++;
813    return;
814  }
815  const run = (dep) => {
816    if (dep) {
817      {
818        dep.trigger();
819      }
820    }
821  };
822  startBatch();
823  if (type === "clear") {

824    depsMap.forEach(run);
825  } else {
826    const targetIsArray = isArray(target);
827    const isArrayIndex = targetIsArray && isIntegerKey(key);
828    if (targetIsArray && key === "length") {
829      const newLength = Number(newValue);
830      depsMap.forEach((dep, key2) => {
831        if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
832          run(dep);
833        }
834      });
835    } else {
836      if (key !== void 0 || depsMap.has(void 0)) {
837        run(depsMap.get(key));
838      }
839      if (isArrayIndex) {
840        run(depsMap.get(ARRAY_ITERATE_KEY));
841      }
842      switch (type) {
843        case "add":
844          if (!targetIsArray) {
845            run(depsMap.get(ITERATE_KEY));
846            if (isMap(target)) {
847              run(depsMap.get(MAP_KEY_ITERATE_KEY));
848            }
849          } else if (isArrayIndex) {
850            run(depsMap.get("length"));
851          }
852          break;
853        case "delete":
854          if (!targetIsArray) {
855            run(depsMap.get(ITERATE_KEY));
856            if (isMap(target)) {
857              run(depsMap.get(MAP_KEY_ITERATE_KEY));
858            }
859          }
860          break;
861        case "set":
862          if (isMap(target)) {
863            run(depsMap.get(ITERATE_KEY));
864          }
865          break;
866      }
867    }
868  }
869  endBatch();
870}
871function getDepFromReactive(object, key) {
872  const depMap = targetMap.get(object);
873  return depMap && depMap.get(key);
874}
875function reactiveReadArray(array) {
876  const raw = toRaw(array);
877  if (raw === array)
878    return raw;
879  track(raw, "iterate", ARRAY_ITERATE_KEY);
880  return isShallow(array) ? raw : raw.map(toReactive);
881}
882function shallowReadArray(arr) {
883  track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
884  return arr;
885}
886const arrayInstrumentations = {
887  __proto__: null,
888  [Symbol.iterator]() {
889    return iterator(this, Symbol.iterator, toReactive);
890  },
891  concat(...args) {
892    return reactiveReadArray(this).concat(
893      ...args.map((x) => isArray(x) ? reactiveReadArray(x) : x)
894    );
895  },
896  entries() {
897    return iterator(this, "entries", (value) => {
898      value[1] = toReactive(value[1]);
899      return value;
900    });
901  },
902  every(fn, thisArg) {
903    return apply(this, "every", fn, thisArg, void 0, arguments);
904  },
905  filter(fn, thisArg) {
906    return apply(this, "filter", fn, thisArg, (v) => v.map(toReactive), arguments);
907  },
908  find(fn, thisArg) {
909    return apply(this, "find", fn, thisArg, toReactive, arguments);
910  },
911  findIndex(fn, thisArg) {
912    return apply(this, "findIndex", fn, thisArg, void 0, arguments);
913  },
914  findLast(fn, thisArg) {
915    return apply(this, "findLast", fn, thisArg, toReactive, arguments);
916  },
917  findLastIndex(fn, thisArg) {
918    return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
919  },
920  // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
921  forEach(fn, thisArg) {
922    return apply(this, "forEach", fn, thisArg, void 0, arguments);
923  },
924  includes(...args) {
925    return searchProxy(this, "includes", args);
926  },
927  indexOf(...args) {
928    return searchProxy(this, "indexOf", args);
929  },
930  join(separator) {
931    return reactiveReadArray(this).join(separator);
932  },
933  // keys() iterator only reads `length`, no optimisation required
934  lastIndexOf(...args) {
935    return searchProxy(this, "lastIndexOf", args);
936  },
937  map(fn, thisArg) {
938    return apply(this, "map", fn, thisArg, void 0, arguments);
939  },
940  pop() {
941    return noTracking(this, "pop");
942  },
943  push(...args) {
944    return noTracking(this, "push", args);
945  },
946  reduce(fn, ...args) {
947    return reduce(this, "reduce", fn, args);
948  },
949  reduceRight(fn, ...args) {
950    return reduce(this, "reduceRight", fn, args);
951  },
952  shift() {
953    return noTracking(this, "shift");
954  },
955  // slice could use ARRAY_ITERATE but also seems to beg for range tracking
956  some(fn, thisArg) {
957    return apply(this, "some", fn, thisArg, void 0, arguments);
958  },
959  splice(...args) {
960    return noTracking(this, "splice", args);
961  },
962  toReversed() {
963    return reactiveReadArray(this).toReversed();
964  },
965  toSorted(comparer) {
966    return reactiveReadArray(this).toSorted(comparer);
967  },
968  toSpliced(...args) {
969    return reactiveReadArray(this).toSpliced(...args);
970  },
971  unshift(...args) {
972    return noTracking(this, "unshift", args);
973  },
974  values() {
975    return iterator(this, "values", toReactive);
976  }
977};
978function iterator(self2, method, wrapValue) {
979  const arr = shallowReadArray(self2);
980  const iter = arr[method]();
981  if (arr !== self2 && !isShallow(self2)) {
982    iter._next = iter.next;
983    iter.next = () => {
984      const result = iter._next();
985      if (result.value) {
986        result.value = wrapValue(result.value);
987      }
988      return result;
989    };
990  }
991  return iter;
992}
993const arrayProto = Array.prototype;
994function apply(self2, method, fn, thisArg, wrappedRetFn, args) {
995  const arr = shallowReadArray(self2);
996  const needsWrap = arr !== self2 && !isShallow(self2);
997  const methodFn = arr[method];
998  if (methodFn !== arrayProto[method]) {
999    const result2 = methodFn.apply(self2, args);
1000    return needsWrap ? toReactive(result2) : result2;
1001  }
1002  let wrappedFn = fn;
1003  if (arr !== self2) {
1004    if (needsWrap) {
1005      wrappedFn = function(item, index) {

1006        return fn.call(this, toReactive(item), index, self2);
1007      };
1008    } else if (fn.length > 2) {
1009      wrappedFn = function(item, index) {
1010        return fn.call(this, item, index, self2);
1011      };
1012    }
1013  }
1014  const result = methodFn.call(arr, wrappedFn, thisArg);
1015  return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
1016}
1017function reduce(self2, method, fn, args) {
1018  const arr = shallowReadArray(self2);
1019  let wrappedFn = fn;
1020  if (arr !== self2) {
1021    if (!isShallow(self2)) {
1022      wrappedFn = function(acc, item, index) {
1023        return fn.call(this, acc, toReactive(item), index, self2);
1024      };
1025    } else if (fn.length > 3) {
1026      wrappedFn = function(acc, item, index) {
1027        return fn.call(this, acc, item, index, self2);
1028      };
1029    }
1030  }
1031  return arr[method](wrappedFn, ...args);
1032}
1033function searchProxy(self2, method, args) {
1034  const arr = toRaw(self2);
1035  track(arr, "iterate", ARRAY_ITERATE_KEY);
1036  const res = arr[method](...args);
1037  if ((res === -1 || res === false) && isProxy(args[0])) {
1038    args[0] = toRaw(args[0]);
1039    return arr[method](...args);
1040  }
1041  return res;
1042}
1043function noTracking(self2, method, args = []) {
1044  pauseTracking();
1045  startBatch();
1046  const res = toRaw(self2)[method].apply(self2, args);
1047  endBatch();
1048  resetTracking();
1049  return res;
1050}
1051const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
1052const builtInSymbols = new Set(
1053  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
1054);
1055function hasOwnProperty(key) {
1056  if (!isSymbol(key))
1057    key = String(key);
1058  const obj = toRaw(this);
1059  track(obj, "has", key);
1060  return obj.hasOwnProperty(key);
1061}
1062class BaseReactiveHandler {
1063  constructor(_isReadonly = false, _isShallow = false) {
1064    this._isReadonly = _isReadonly;
1065    this._isShallow = _isShallow;
1066  }
1067  get(target, key, receiver) {
1068    if (key === "__v_skip")
1069      return target["__v_skip"];
1070    const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
1071    if (key === "__v_isReactive") {
1072      return !isReadonly2;
1073    } else if (key === "__v_isReadonly") {
1074      return isReadonly2;
1075    } else if (key === "__v_isShallow") {
1076      return isShallow2;
1077    } else if (key === "__v_raw") {
1078      if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
1079      // this means the receiver is a user proxy of the reactive proxy
1080      Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
1081        return target;
1082      }
1083      return;
1084    }
1085    const targetIsArray = isArray(target);
1086    if (!isReadonly2) {
1087      let fn;
1088      if (targetIsArray && (fn = arrayInstrumentations[key])) {
1089        return fn;
1090      }
1091      if (key === "hasOwnProperty") {
1092        return hasOwnProperty;
1093      }
1094    }
1095    const res = Reflect.get(
1096      target,
1097      key,
1098      // if this is a proxy wrapping a ref, return methods using the raw ref
1099      // as receiver so that we don't have to call `toRaw` on the ref in all
1100      // its class methods
1101      isRef(target) ? target : receiver
1102    );
1103    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
1104      return res;
1105    }
1106    if (!isReadonly2) {
1107      track(target, "get", key);
1108    }
1109    if (isShallow2) {
1110      return res;
1111    }
1112    if (isRef(res)) {
1113      return targetIsArray && isIntegerKey(key) ? res : res.value;
1114    }
1115    if (isObject$1(res)) {
1116      return isReadonly2 ? readonly(res) : reactive(res);
1117    }
1118    return res;
1119  }
1120}
1121class MutableReactiveHandler extends BaseReactiveHandler {
1122  constructor(isShallow2 = false) {
1123    super(false, isShallow2);
1124  }
1125  set(target, key, value, receiver) {
1126    let oldValue = target[key];
1127    if (!this._isShallow) {
1128      const isOldValueReadonly = isReadonly(oldValue);
1129      if (!isShallow(value) && !isReadonly(value)) {
1130        oldValue = toRaw(oldValue);
1131        value = toRaw(value);
1132      }
1133      if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
1134        if (isOldValueReadonly) {
1135          return false;

1136        } else {
1137          oldValue.value = value;
1138          return true;
1139        }
1140      }
1141    }
1142    const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
1143    const result = Reflect.set(
1144      target,
1145      key,
1146      value,
1147      isRef(target) ? target : receiver
1148    );
1149    if (target === toRaw(receiver)) {
1150      if (!hadKey) {
1151        trigger(target, "add", key, value);
1152      } else if (hasChanged(value, oldValue)) {
1153        trigger(target, "set", key, value);
1154      }
1155    }
1156    return result;
1157  }
1158  deleteProperty(target, key) {
1159    const hadKey = hasOwn(target, key);
1160    target[key];
1161    const result = Reflect.deleteProperty(target, key);
1162    if (result && hadKey) {
1163      trigger(target, "delete", key, void 0);
1164    }
1165    return result;
1166  }
1167  has(target, key) {
1168    const result = Reflect.has(target, key);
1169    if (!isSymbol(key) || !builtInSymbols.has(key)) {
1170      track(target, "has", key);
1171    }
1172    return result;
1173  }
1174  ownKeys(target) {
1175    track(
1176      target,
1177      "iterate",
1178      isArray(target) ? "length" : ITERATE_KEY
1179    );
1180    return Reflect.ownKeys(target);
1181  }
1182}
1183class ReadonlyReactiveHandler extends BaseReactiveHandler {
1184  constructor(isShallow2 = false) {
1185    super(true, isShallow2);
1186  }
1187  set(target, key) {
1188    return true;
1189  }
1190  deleteProperty(target, key) {
1191    return true;
1192  }
1193}
1194const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
1195const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
1196const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true);
1197const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
1198const toShallow = (value) => value;
1199const getProto = (v) => Reflect.getPrototypeOf(v);
1200function createIterableMethod(method, isReadonly2, isShallow2) {
1201  return function(...args) {
1202    const target = this["__v_raw"];
1203    const rawTarget = toRaw(target);
1204    const targetIsMap = isMap(rawTarget);
1205    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
1206    const isKeyOnly = method === "keys" && targetIsMap;
1207    const innerIterator = target[method](...args);
1208    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
1209    !isReadonly2 && track(
1210      rawTarget,
1211      "iterate",
1212      isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
1213    );
1214    return {
1215      // iterator protocol
1216      next() {
1217        const { value, done } = innerIterator.next();
1218        return done ? { value, done } : {
1219          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
1220          done
1221        };
1222      },
1223      // iterable protocol
1224      [Symbol.iterator]() {
1225        return this;
1226      }
1227    };
1228  };
1229}
1230function createReadonlyMethod(type) {
1231  return function(...args) {
1232    return type === "delete" ? false : type === "clear" ? void 0 : this;
1233  };
1234}
1235function createInstrumentations(readonly2, shallow) {
1236  const instrumentations = {
1237    get(key) {
1238      const target = this["__v_raw"];
1239      const rawTarget = toRaw(target);
1240      const rawKey = toRaw(key);
1241      if (!readonly2) {
1242        if (hasChanged(key, rawKey)) {
1243          track(rawTarget, "get", key);
1244        }
1245        track(rawTarget, "get", rawKey);
1246      }
1247      const { has } = getProto(rawTarget);
1248      const wrap = shallow ? toShallow : readonly2 ? toReadonly : toReactive;
1249      if (has.call(rawTarget, key)) {
1250        return wrap(target.get(key));
1251      } else if (has.call(rawTarget, rawKey)) {
1252        return wrap(target.get(rawKey));
1253      } else if (target !== rawTarget) {
1254        target.get(key);
1255      }
1256    },
1257    get size() {
1258      const target = this["__v_raw"];
1259      !readonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
1260      return Reflect.get(target, "size", target);
1261    },
1262    has(key) {
1263      const target = this["__v_raw"];
1264      const rawTarget = toRaw(target);
1265      const rawKey = toRaw(key);
1266      if (!readonly2) {
1267        if (hasChanged(key, rawKey)) {
1268          track(rawTarget, "has", key);
1269        }
1270        track(rawTarget, "has", rawKey);
1271      }
1272      return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
1273    },

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

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

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

2362    let current = target;
2363    while (current) {
2364      if (current.isDeactivated) {
2365        return;
2366      }
2367      current = current.parent;
2368    }
2369    return hook();
2370  });
2371  injectHook(type, wrappedHook, target);
2372  if (target) {
2373    let current = target.parent;
2374    while (current && current.parent) {
2375      if (isKeepAlive(current.parent.vnode)) {
2376        injectToKeepAliveRoot(wrappedHook, type, target, current);
2377      }
2378      current = current.parent;
2379    }
2380  }
2381}
2382function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
2383  const injected = injectHook(
2384    type,
2385    hook,
2386    keepAliveRoot,
2387    true
2388    /* prepend */
2389  );
2390  onUnmounted(() => {
2391    remove(keepAliveRoot[type], injected);
2392  }, target);
2393}
2394function injectHook(type, hook, target = currentInstance, prepend = false) {
2395  if (target) {
2396    const hooks = target[type] || (target[type] = []);
2397    const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
2398      pauseTracking();
2399      const reset = setCurrentInstance(target);
2400      const res = callWithAsyncErrorHandling(hook, target, type, args);
2401      reset();
2402      resetTracking();
2403      return res;
2404    });
2405    if (prepend) {
2406      hooks.unshift(wrappedHook);
2407    } else {
2408      hooks.push(wrappedHook);
2409    }
2410    return wrappedHook;
2411  }
2412}
2413const createHook = (lifecycle) => (hook, target = currentInstance) => {
2414  if (!isInSSRComponentSetup || lifecycle === "sp") {
2415    injectHook(lifecycle, (...args) => hook(...args), target);
2416  }
2417};
2418const onBeforeMount = createHook("bm");
2419const onMounted = createHook("m");
2420const onBeforeUpdate = createHook(
2421  "bu"
2422);
2423const onUpdated = createHook("u");
2424const onBeforeUnmount = createHook(
2425  "bum"
2426);
2427const onUnmounted = createHook("um");
2428const onServerPrefetch = createHook(
2429  "sp"
2430);
2431const onRenderTriggered = createHook("rtg");
2432const onRenderTracked = createHook("rtc");
2433function onErrorCaptured(hook, target = currentInstance) {
2434  injectHook("ec", hook, target);
2435}
2436const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
2437function renderList(source, renderItem, cache, index) {
2438  let ret;
2439  const cached = cache && cache[index];
2440  const sourceIsArray = isArray(source);
2441  if (sourceIsArray || isString(source)) {
2442    const sourceIsReactiveArray = sourceIsArray && isReactive(source);
2443    let needsWrap = false;
2444    if (sourceIsReactiveArray) {
2445      needsWrap = !isShallow(source);
2446      source = shallowReadArray(source);
2447    }
2448    ret = new Array(source.length);
2449    for (let i = 0, l = source.length; i < l; i++) {
2450      ret[i] = renderItem(
2451        needsWrap ? toReactive(source[i]) : source[i],
2452        i,
2453        void 0,
2454        cached && cached[i]
2455      );
2456    }
2457  } else if (typeof source === "number") {
2458    ret = new Array(source);
2459    for (let i = 0; i < source; i++) {
2460      ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
2461    }
2462  } else if (isObject$1(source)) {
2463    if (source[Symbol.iterator]) {
2464      ret = Array.from(
2465        source,
2466        (item, i) => renderItem(item, i, void 0, cached && cached[i])
2467      );
2468    } else {
2469      const keys = Object.keys(source);
2470      ret = new Array(keys.length);
2471      for (let i = 0, l = keys.length; i < l; i++) {
2472        const key = keys[i];
2473        ret[i] = renderItem(source[key], key, i, cached && cached[i]);
2474      }
2475    }
2476  } else {
2477    ret = [];
2478  }
2479  if (cache) {
2480    cache[index] = ret;
2481  }
2482  return ret;
2483}
2484const getPublicInstance = (i) => {
2485  if (!i)
2486    return null;
2487  if (isStatefulComponent(i))
2488    return getComponentPublicInstance(i);
2489  return getPublicInstance(i.parent);
2490};
2491const publicPropertiesMap = (
2492  // Move PURE marker to new line to workaround compiler discarding it
2493  // due to type annotation
2494  /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {
2495    $: (i) => i,
2496    $el: (i) => i.vnode.el,
2497    $data: (i) => i.data,
2498    $props: (i) => i.props,
2499    $attrs: (i) => i.attrs,
2500    $slots: (i) => i.slots,
2501    $refs: (i) => i.refs,
2502    $parent: (i) => getPublicInstance(i.parent),
2503    $root: (i) => getPublicInstance(i.root),
2504    $host: (i) => i.ce,
2505    $emit: (i) => i.emit,
2506    $options: (i) => resolveMergedOptions(i),
2507    $forceUpdate: (i) => i.f || (i.f = () => {
2508      queueJob(i.update);
2509    }),
2510    $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
2511    $watch: (i) => instanceWatch.bind(i)
2512  })
2513);
2514const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
2515const PublicInstanceProxyHandlers = {
2516  get({ _: instance }, key) {
2517    if (key === "__v_skip") {
2518      return true;
2519    }
2520    const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
2521    let normalizedProps;
2522    if (key[0] !== "$") {
2523      const n = accessCache[key];
2524      if (n !== void 0) {
2525        switch (n) {
2526          case 1:
2527            return setupState[key];
2528          case 2:
2529            return data[key];
2530          case 4:
2531            return ctx[key];
2532          case 3:
2533            return props[key];
2534        }
2535      } else if (hasSetupBinding(setupState, key)) {
2536        accessCache[key] = 1;
2537        return setupState[key];
2538      } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
2539        accessCache[key] = 2;
2540        return data[key];
2541      } else if (
2542        // only cache other properties when instance has declared (thus stable)
2543        // props
2544        (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)
2545      ) {
2546        accessCache[key] = 3;
2547        return props[key];
2548      } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
2549        accessCache[key] = 4;
2550        return ctx[key];
2551      } else if (shouldCacheAccess) {
2552        accessCache[key] = 0;
2553      }
2554    }
2555    const publicGetter = publicPropertiesMap[key];

2556    let cssModule, globalProperties;
2557    if (publicGetter) {
2558      if (key === "$attrs") {
2559        track(instance.attrs, "get", "");
2560      }
2561      return publicGetter(instance);
2562    } else if (
2563      // css module (injected by vue-loader)
2564      (cssModule = type.__cssModules) && (cssModule = cssModule[key])
2565    ) {
2566      return cssModule;
2567    } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
2568      accessCache[key] = 4;
2569      return ctx[key];
2570    } else if (
2571      // global properties
2572      globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)
2573    ) {
2574      {
2575        return globalProperties[key];
2576      }
2577    } else
2578      ;
2579  },
2580  set({ _: instance }, key, value) {
2581    const { data, setupState, ctx } = instance;
2582    if (hasSetupBinding(setupState, key)) {
2583      setupState[key] = value;
2584      return true;
2585    } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
2586      data[key] = value;
2587      return true;
2588    } else if (hasOwn(instance.props, key)) {
2589      return false;
2590    }
2591    if (key[0] === "$" && key.slice(1) in instance) {
2592      return false;
2593    } else {
2594      {
2595        ctx[key] = value;
2596      }
2597    }
2598    return true;
2599  },
2600  has({
2601    _: { data, setupState, accessCache, ctx, appContext, propsOptions }
2602  }, key) {
2603    let normalizedProps;
2604    return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
2605  },
2606  defineProperty(target, key, descriptor) {
2607    if (descriptor.get != null) {
2608      target._.accessCache[key] = 0;
2609    } else if (hasOwn(descriptor, "value")) {
2610      this.set(target, key, descriptor.value, null);
2611    }
2612    return Reflect.defineProperty(target, key, descriptor);
2613  }
2614};
2615function normalizePropsOrEmits(props) {
2616  return isArray(props) ? props.reduce(
2617    (normalized, p2) => (normalized[p2] = null, normalized),
2618    {}
2619  ) : props;
2620}
2621let shouldCacheAccess = true;
2622function applyOptions(instance) {
2623  const options = resolveMergedOptions(instance);
2624  const publicThis = instance.proxy;
2625  const ctx = instance.ctx;
2626  shouldCacheAccess = false;
2627  if (options.beforeCreate) {
2628    callHook(options.beforeCreate, instance, "bc");
2629  }
2630  const {
2631    // state
2632    data: dataOptions,
2633    computed: computedOptions,
2634    methods,
2635    watch: watchOptions,
2636    provide: provideOptions,
2637    inject: injectOptions,
2638    // lifecycle
2639    created,
2640    beforeMount,
2641    mounted,
2642    beforeUpdate,
2643    updated,
2644    activated,
2645    deactivated,
2646    beforeDestroy,
2647    beforeUnmount,
2648    destroyed,
2649    unmounted,
2650    render,
2651    renderTracked,
2652    renderTriggered,
2653    errorCaptured,
2654    serverPrefetch,
2655    // public API
2656    expose,
2657    inheritAttrs,
2658    // assets
2659    components,
2660    directives,
2661    filters
2662  } = options;
2663  const checkDuplicateProperties = null;
2664  if (injectOptions) {
2665    resolveInjections(injectOptions, ctx, checkDuplicateProperties);
2666  }
2667  if (methods) {
2668    for (const key in methods) {
2669      const methodHandler = methods[key];
2670      if (isFunction(methodHandler)) {
2671        {
2672          ctx[key] = methodHandler.bind(publicThis);
2673        }
2674      }
2675    }
2676  }
2677  if (dataOptions) {
2678    const data = dataOptions.call(publicThis, publicThis);
2679    if (!isObject$1(data))
2680      ;
2681    else {
2682      instance.data = reactive(data);
2683    }
2684  }
2685  shouldCacheAccess = true;
2686  if (computedOptions) {
2687    for (const key in computedOptions) {
2688      const opt = computedOptions[key];
2689      const get = isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;
2690      const set = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : NOOP;
2691      const c = computed({
2692        get,
2693        set
2694      });
2695      Object.defineProperty(ctx, key, {
2696        enumerable: true,
2697        configurable: true,
2698        get: () => c.value,
2699        set: (v) => c.value = v
2700      });
2701    }
2702  }
2703  if (watchOptions) {
2704    for (const key in watchOptions) {
2705      createWatcher(watchOptions[key], ctx, publicThis, key);
2706    }
2707  }
2708  if (provideOptions) {
2709    const provides = isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
2710    Reflect.ownKeys(provides).forEach((key) => {
2711      provide(key, provides[key]);
2712    });
2713  }
2714  if (created) {
2715    callHook(created, instance, "c");
2716  }
2717  function registerLifecycleHook(register, hook) {
2718    if (isArray(hook)) {
2719      hook.forEach((_hook) => register(_hook.bind(publicThis)));
2720    } else if (hook) {
2721      register(hook.bind(publicThis));
2722    }
2723  }
2724  registerLifecycleHook(onBeforeMount, beforeMount);
2725  registerLifecycleHook(onMounted, mounted);
2726  registerLifecycleHook(onBeforeUpdate, beforeUpdate);
2727  registerLifecycleHook(onUpdated, updated);
2728  registerLifecycleHook(onActivated, activated);
2729  registerLifecycleHook(onDeactivated, deactivated);
2730  registerLifecycleHook(onErrorCaptured, errorCaptured);
2731  registerLifecycleHook(onRenderTracked, renderTracked);
2732  registerLifecycleHook(onRenderTriggered, renderTriggered);
2733  registerLifecycleHook(onBeforeUnmount, beforeUnmount);
2734  registerLifecycleHook(onUnmounted, unmounted);
2735  registerLifecycleHook(onServerPrefetch, serverPrefetch);
2736  if (isArray(expose)) {
2737    if (expose.length) {
2738      const exposed = instance.exposed || (instance.exposed = {});
2739      expose.forEach((key) => {
2740        Object.defineProperty(exposed, key, {
2741          get: () => publicThis[key],
2742          set: (val) => publicThis[key] = val
2743        });
2744      });
2745    } else if (!instance.exposed) {
2746      instance.exposed = {};
2747    }
2748  }
2749  if (render && instance.render === NOOP) {
2750    instance.render = render;
2751  }
2752  if (inheritAttrs != null) {
2753    instance.inheritAttrs = inheritAttrs;
2754  }
2755  if (components)
2756    instance.components = components;
2757  if (directives)
2758    instance.directives = directives;
2759  if (serverPrefetch) {
2760    markAsyncBoundary(instance);
2761  }
2762}
2763function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {
2764  if (isArray(injectOptions)) {
2765    injectOptions = normalizeInject(injectOptions);
2766  }
2767  for (const key in injectOptions) {
2768    const opt = injectOptions[key];
2769    let injected;
2770    if (isObject$1(opt)) {
2771      if ("default" in opt) {
2772        injected = inject(
2773          opt.from || key,
2774          opt.default,
2775          true
2776        );
2777      } else {
2778        injected = inject(opt.from || key);
2779      }
2780    } else {
2781      injected = inject(opt);
2782    }
2783    if (isRef(injected)) {
2784      Object.defineProperty(ctx, key, {
2785        enumerable: true,
2786        configurable: true,
2787        get: () => injected.value,
2788        set: (v) => injected.value = v
2789      });
2790    } else {
2791      ctx[key] = injected;
2792    }
2793  }
2794}
2795function callHook(hook, instance, type) {
2796  callWithAsyncErrorHandling(
2797    isArray(hook) ? hook.map((h) => h.bind(instance.proxy)) : hook.bind(instance.proxy),
2798    instance,
2799    type
2800  );
2801}
2802function createWatcher(raw, ctx, publicThis, key) {
2803  let getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
2804  if (isString(raw)) {
2805    const handler = ctx[raw];
2806    if (isFunction(handler)) {
2807      {
2808        watch(getter, handler);
2809      }
2810    }
2811  } else if (isFunction(raw)) {
2812    {
2813      watch(getter, raw.bind(publicThis));
2814    }
2815  } else if (isObject$1(raw)) {
2816    if (isArray(raw)) {
2817      raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
2818    } else {
2819      const handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
2820      if (isFunction(handler)) {
2821        watch(getter, handler, raw);
2822      }
2823    }
2824  } else
2825    ;
2826}
2827function resolveMergedOptions(instance) {
2828  const base = instance.type;
2829  const { mixins, extends: extendsOptions } = base;
2830  const {
2831    mixins: globalMixins,
2832    optionsCache: cache,
2833    config: { optionMergeStrategies }
2834  } = instance.appContext;
2835  const cached = cache.get(base);
2836  let resolved;
2837  if (cached) {
2838    resolved = cached;
2839  } else if (!globalMixins.length && !mixins && !extendsOptions) {
2840    {
2841      resolved = base;
2842    }
2843  } else {
2844    resolved = {};
2845    if (globalMixins.length) {
2846      globalMixins.forEach(
2847        (m) => mergeOptions(resolved, m, optionMergeStrategies, true)
2848      );
2849    }
2850    mergeOptions(resolved, base, optionMergeStrategies);
2851  }
2852  if (isObject$1(base)) {
2853    cache.set(base, resolved);
2854  }
2855  return resolved;
2856}
2857function mergeOptions(to, from, strats, asMixin = false) {
2858  const { mixins, extends: extendsOptions } = from;
2859  if (extendsOptions) {
2860    mergeOptions(to, extendsOptions, strats, true);
2861  }
2862  if (mixins) {
2863    mixins.forEach(
2864      (m) => mergeOptions(to, m, strats, true)
2865    );
2866  }
2867  for (const key in from) {
2868    if (asMixin && key === "expose")
2869      ;
2870    else {
2871      const strat = internalOptionMergeStrats[key] || strats && strats[key];
2872      to[key] = strat ? strat(to[key], from[key]) : from[key];
2873    }
2874  }
2875  return to;
2876}
2877const internalOptionMergeStrats = {
2878  data: mergeDataFn,
2879  props: mergeEmitsOrPropsOptions,
2880  emits: mergeEmitsOrPropsOptions,
2881  // objects
2882  methods: mergeObjectOptions,
2883  computed: mergeObjectOptions,
2884  // lifecycle
2885  beforeCreate: mergeAsArray,
2886  created: mergeAsArray,
2887  beforeMount: mergeAsArray,
2888  mounted: mergeAsArray,
2889  beforeUpdate: mergeAsArray,
2890  updated: mergeAsArray,
2891  beforeDestroy: mergeAsArray,
2892  beforeUnmount: mergeAsArray,
2893  destroyed: mergeAsArray,
2894  unmounted: mergeAsArray,
2895  activated: mergeAsArray,
2896  deactivated: mergeAsArray,
2897  errorCaptured: mergeAsArray,
2898  serverPrefetch: mergeAsArray,
2899  // assets
2900  components: mergeObjectOptions,
2901  directives: mergeObjectOptions,
2902  // watch
2903  watch: mergeWatchOptions,
2904  // provide / inject
2905  provide: mergeDataFn,
2906  inject: mergeInject
2907};
2908function mergeDataFn(to, from) {
2909  if (!from) {
2910    return to;
2911  }
2912  if (!to) {
2913    return from;
2914  }
2915  return function mergedDataFn() {
2916    return extend(
2917      isFunction(to) ? to.call(this, this) : to,
2918      isFunction(from) ? from.call(this, this) : from
2919    );
2920  };
2921}
2922function mergeInject(to, from) {
2923  return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
2924}
2925function normalizeInject(raw) {
2926  if (isArray(raw)) {
2927    const res = {};
2928    for (let i = 0; i < raw.length; i++) {
2929      res[raw[i]] = raw[i];
2930    }
2931    return res;
2932  }
2933  return raw;
2934}
2935function mergeAsArray(to, from) {
2936  return to ? [...new Set([].concat(to, from))] : from;
2937}
2938function mergeObjectOptions(to, from) {
2939  return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
2940}
2941function mergeEmitsOrPropsOptions(to, from) {
2942  if (to) {
2943    if (isArray(to) && isArray(from)) {
2944      return [.../* @__PURE__ */ new Set([...to, ...from])];
2945    }
2946    return extend(