https://www.stiftung-gedenkstaetten.de/.resources/buchenwald-base-…/js/main~2026-07-22-08-03-18-000~cache.js

1/**
2* @vue/shared v3.5.16
3* (c) 2018-present Yuxi (Evan) You and Vue contributors
4* @license MIT
5**/
6/*! #__NO_SIDE_EFFECTS__ */
7// @__NO_SIDE_EFFECTS__
8function makeMap(str) {
9  const map = /* @__PURE__ */ Object.create(null);
10  for (const key of str.split(",")) map[key] = 1;
11  return (val) => val in map;
12}
13const EMPTY_OBJ = {};
14const EMPTY_ARR = [];
15const NOOP = () => {
16};
17const NO = () => false;
18const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
19(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
20const isModelListener = (key) => key.startsWith("onUpdate:");
21const extend$5 = Object.assign;
22const remove = (arr, el) => {
23  const i = arr.indexOf(el);
24  if (i > -1) {
25    arr.splice(i, 1);
26  }
27};
28const hasOwnProperty$4 = Object.prototype.hasOwnProperty;
29const hasOwn$2 = (val, key) => hasOwnProperty$4.call(val, key);
30const isArray$3 = Array.isArray;
31const isMap = (val) => toTypeString$2(val) === "[object Map]";
32const isSet = (val) => toTypeString$2(val) === "[object Set]";
33const isDate$2 = (val) => toTypeString$2(val) === "[object Date]";
34const isRegExp$3 = (val) => toTypeString$2(val) === "[object RegExp]";
35const isFunction$3 = (val) => typeof val === "function";
36const isString$3 = (val) => typeof val === "string";
37const isSymbol$2 = (val) => typeof val === "symbol";
38const isObject$9 = (val) => val !== null && typeof val === "object";
39const isPromise$2 = (val) => {
40  return (isObject$9(val) || isFunction$3(val)) && isFunction$3(val.then) && isFunction$3(val.catch);
41};
42const objectToString$4 = Object.prototype.toString;
43const toTypeString$2 = (value) => objectToString$4.call(value);
44const toRawType = (value) => {
45  return toTypeString$2(value).slice(8, -1);
46};
47const isPlainObject$3 = (val) => toTypeString$2(val) === "[object Object]";
48const isIntegerKey = (key) => isString$3(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
49const isReservedProp = /* @__PURE__ */ makeMap(
50  // the leading comma is intentional so empty string "" is also included
51  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
52);
53const isBuiltInDirective = /* @__PURE__ */ makeMap(
54  "bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
55);
56const cacheStringFunction = (fn) => {
57  const cache2 = /* @__PURE__ */ Object.create(null);
58  return (str) => {
59    const hit = cache2[str];
60    return hit || (cache2[str] = fn(str));
61  };
62};
63const camelizeRE = /-(\w)/g;
64const camelize = cacheStringFunction(
65  (str) => {
66    return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
67  }
68);
69const hyphenateRE = /\B([A-Z])/g;
70const hyphenate = cacheStringFunction(
71  (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
72);
73const capitalize$1 = cacheStringFunction((str) => {
74  return str.charAt(0).toUpperCase() + str.slice(1);
75});
76const toHandlerKey = cacheStringFunction(
77  (str) => {
78    const s = str ? `on${capitalize$1(str)}` : ``;
79    return s;
80  }
81);
82const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
83const invokeArrayFns = (fns, ...arg) => {
84  for (let i = 0; i < fns.length; i++) {
85    fns[i](...arg);
86  }
87};
88const def = (obj, key, value, writable = false) => {
89  Object.defineProperty(obj, key, {
90    configurable: true,
91    enumerable: false,
92    writable,
93    value
94  });
95};
96const looseToNumber = (val) => {
97  const n = parseFloat(val);
98  return isNaN(n) ? val : n;
99};
100const toNumber$2 = (val) => {
101  const n = isString$3(val) ? Number(val) : NaN;
102  return isNaN(n) ? val : n;
103};
104let _globalThis$2;
105const getGlobalThis$2 = () => {
106  return _globalThis$2 || (_globalThis$2 = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
107};
108function genCacheKey(source, options2) {
109  return source + JSON.stringify(
110    options2,
111    (_, val) => typeof val === "function" ? val.toString() : val
112  );
113}
114const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decode

114URI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol";
115const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
116function normalizeStyle(value) {
117  if (isArray$3(value)) {
118    const res = {};
119    for (let i = 0; i < value.length; i++) {
120      const item = value[i];
121      const normalized = isString$3(item) ? parseStringStyle(item) : normalizeStyle(item);
122      if (normalized) {
123        for (const key in normalized) {
124          res[key] = normalized[key];
125        }
126      }
127    }
128    return res;
129  } else if (isString$3(value) || isObject$9(value)) {
130    return value;
131  }
132}
133const listDelimiterRE = /;(?![^(]*\))/g;
134const propertyDelimiterRE = /:([^]+)/;
135const styleCommentRE = /\/\*[^]*?\*\//g;
136function parseStringStyle(cssText) {
137  const ret = {};
138  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
139    if (item) {
140      const tmp = item.split(propertyDelimiterRE);
141      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
142    }
143  });
144  return ret;
145}
146function normalizeClass(value) {
147  let res = "";
148  if (isString$3(value)) {
149    res = value;
150  } else if (isArray$3(value)) {
151    for (let i = 0; i < value.length; i++) {
152      const normalized = normalizeClass(value[i]);
153      if (normalized) {
154        res += normalized + " ";
155      }
156    }
157  } else if (isObject$9(value)) {
158    for (const name in value) {
159      if (value[name]) {
160        res += name + " ";
161      }
162    }
163  }
164  return res.trim();
165}
166function normalizeProps(props2) {
167  if (!props2) return null;
168  let { class: klass, style } = props2;
169  if (klass && !isString$3(klass)) {
170    props2.class = normalizeClass(klass);
171  }
172  if (style) {
173    props2.style = normalizeStyle(style);
174  }
175  return props2;
176}
177const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
178const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
179const MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics";
180const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
181const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
182const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
183const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
184const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
185const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
186const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
187function includeBooleanAttr(value) {
188  return !!value || value === "";
189}
190function looseCompareArrays(a, b) {
191  if (a.length !== b.length) return false;

192  let equal2 = true;
193  for (let i = 0; equal2 && i < a.length; i++) {
194    equal2 = looseEqual(a[i], b[i]);
195  }
196  return equal2;
197}
198function looseEqual(a, b) {
199  if (a === b) return true;
200  let aValidType = isDate$2(a);
201  let bValidType = isDate$2(b);
202  if (aValidType || bValidType) {
203    return aValidType && bValidType ? a.getTime() === b.getTime() : false;
204  }
205  aValidType = isSymbol$2(a);
206  bValidType = isSymbol$2(b);
207  if (aValidType || bValidType) {
208    return a === b;
209  }
210  aValidType = isArray$3(a);
211  bValidType = isArray$3(b);
212  if (aValidType || bValidType) {
213    return aValidType && bValidType ? looseCompareArrays(a, b) : false;
214  }
215  aValidType = isObject$9(a);
216  bValidType = isObject$9(b);
217  if (aValidType || bValidType) {
218    if (!aValidType || !bValidType) {
219      return false;
220    }
221    const aKeysCount = Object.keys(a).length;
222    const bKeysCount = Object.keys(b).length;
223    if (aKeysCount !== bKeysCount) {
224      return false;
225    }
226    for (const key in a) {
227      const aHasKey = a.hasOwnProperty(key);
228      const bHasKey = b.hasOwnProperty(key);
229      if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
230        return false;
231      }
232    }
233  }
234  return String(a) === String(b);
235}
236function looseIndexOf(arr, val) {
237  return arr.findIndex((item) => looseEqual(item, val));
238}
239const isRef$1 = (val) => {
240  return !!(val && val["__v_isRef"] === true);
241};
242const toDisplayString$1 = (val) => {
243  return isString$3(val) ? val : val == null ? "" : isArray$3(val) || isObject$9(val) && (val.toString === objectToString$4 || !isFunction$3(val.toString)) ? isRef$1(val) ? toDisplayString$1(val.value) : JSON.stringify(val, replacer, 2) : String(val);
244};
245const replacer = (_key, val) => {
246  if (isRef$1(val)) {
247    return replacer(_key, val.value);
248  } else if (isMap(val)) {
249    return {
250      [`Map(${val.size})`]: [...val.entries()].reduce(
251        (entries, [key, val2], i) => {
252          entries[stringifySymbol(key, i) + " =>"] = val2;
253          return entries;
254        },
255        {}
256      )
257    };
258  } else if (isSet(val)) {
259    return {
260      [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
261    };
262  } else if (isSymbol$2(val)) {
263    return stringifySymbol(val);
264  } else if (isObject$9(val) && !isArray$3(val) && !isPlainObject$3(val)) {
265    return String(val);
266  }
267  return val;
268};
269const stringifySymbol = (v, i = "") => {
270  var _a;
271  return (
272    // Symbol.description in es2019+ so we need to cast here to pass
273    // the lib: es2016 check
274    isSymbol$2(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v
275  );
276};
277/**
278* @vue/reactivity v3.5.16
279* (c) 2018-present Yuxi (Evan) You and Vue contributors
280* @license MIT

476      pausedQueueEffects.add(this);
477    } else if (this.scheduler) {
478      this.scheduler();
479    } else {
480      this.runIfDirty();
481    }
482  }
483  /**
484   * @internal
485   */
486  runIfDirty() {
487    if (isDirty(this)) {
488      this.run();
489    }
490  }
491  get dirty() {
492    return isDirty(this);
493  }
494}
495let batchDepth = 0;
496let batchedSub;
497let batchedComputed;
498function batch(sub, isComputed = false) {
499  sub.flags |= 8;
500  if (isComputed) {
501    sub.next = batchedComputed;
502    batchedComputed = sub;
503    return;
504  }
505  sub.next = batchedSub;
506  batchedSub = sub;
507}
508function startBatch() {
509  batchDepth++;
510}
511function endBatch() {
512  if (--batchDepth > 0) {
513    return;
514  }
515  if (batchedComputed) {
516    let e = batchedComputed;
517    batchedComputed = void 0;
518    while (e) {
519      const next = e.next;
520      e.next = void 0;
521      e.flags &= -9;
522      e = next;
523    }
524  }
525  let error;
526  while (batchedSub) {
527    let e = batchedSub;
528    batchedSub = void 0;
529    while (e) {
530      const next = e.next;
531      e.next = void 0;
532      e.flags &= -9;
533      if (e.flags & 1) {
534        try {
535          ;
536          e.trigger();
537        } catch (err) {
538          if (!error) error = err;
539        }
540      }
541      e = next;
542    }
543  }
544  if (error) throw error;
545}
546function prepareDeps(sub) {
547  for (let link = sub.deps; link; link = link.nextDep) {
548    link.version = -1;
549    link.prevActiveLink = link.dep.activeLink;
550    link.dep.activeLink = link;
551  }
552}
553function cleanupDeps(sub) {
554  let head;
555  let tail = sub.depsTail;
556  let link = tail;
557  while (link) {
558    const prev = link.prevDep;
559    if (link.version === -1) {
560      if (link === tail) tail = prev;
561      removeSub(link);
562      removeDep(link);
563    } else {
564      head = link;
565    }
566    link.dep.activeLink = link.prevActiveLink;
567    link.prevActiveLink = void 0;
568    link = prev;
569  }
570  sub.deps = head;
571  sub.depsTail = tail;
572}
573function isDirty(sub) {
574  for (let link = sub.deps; link; link = link.nextDep) {
575    if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
576      return true;
577    }
578  }
579  if (sub._dirty) {
580    return true;
581  }
582  return false;
583}
584function refreshComputed(computed2) {
585  if (computed2.flags & 4 && !(computed2.flags & 16)) {
586    return;
587  }
588  computed2.flags &= -17;
589  if (computed2.globalVersion === globalVersion) {
590    return;
591  }
592  computed2.globalVersion = globalVersion;
593  if (!computed2.isSSR && computed2.flags & 128 && (!computed2.deps && !computed2._dirty || !isDirty(computed2))) {
594    return;
595  }
596  computed2.flags |= 2;
597  const dep = computed2.dep;
598  const prevSub = activeSub;
599  const prevShouldTrack = shouldTrack;
600  activeSub = computed2;
601  shouldTrack = true;
602  try {
603    prepareDeps(computed2);
604    const value = computed2.fn(computed2._value);
605    if (dep.version === 0 || hasChanged(value, computed2._value)) {
606      computed2.flags |= 128;
607      computed2._value = value;
608      dep.version++;
609    }
610  } catch (err) {
611    dep.version++;
612    throw err;
613  } finally {
614    activeSub = prevSub;
615    shouldTrack = prevShouldTrack;
616    cleanupDeps(computed2);
617    computed2.flags &= -3;
618  }
619}
620function removeSub(link, soft = false) {
621  const { dep, prevSub, nextSub } = link;
622  if (prevSub) {
623    prevSub.nextSub = nextSub;
624    link.prevSub = void 0;
625  }
626  if (nextSub) {
627    nextSub.prevSub = prevSub;
628    link.nextSub = void 0;
629  }
630  if (dep.subs === link) {
631    dep.subs = prevSub;
632    if (!prevSub && dep.computed) {
633      dep.computed.flags &= -5;
634      for (let l = dep.computed.deps; l; l = l.nextDep) {
635        removeSub(l, true);
636      }
637    }
638  }
639  if (!soft && !--dep.sc && dep.map) {
640    dep.map.delete(dep.key);
641  }
642}
643function removeDep(link) {
644  const { prevDep, nextDep } = link;
645  if (prevDep) {
646    prevDep.nextDep = nextDep;
647    link.prevDep = void 0;
648  }
649  if (nextDep) {
650    nextDep.prevDep = prevDep;
651    link.nextDep = void 0;
652  }
653}
654function effect(fn, options2) {
655  if (fn.effect instanceof ReactiveEffect) {
656    fn = fn.effect.fn;
657  }
658  const e = new ReactiveEffect(fn);
659  if (options2) {
660    extend$5(e, options2);
661  }
662  try {
663    e.run();
664  } catch (err) {
665    e.stop();
666    throw err;
667  }
668  const runner = e.run.bind(e);
669  runner.effect = e;
670  return runner;
671}
672function stop(runner) {
673  runner.effect.stop();
674}
675let shouldTrack = true;
676const trackStack = [];
677function pauseTracking() {
678  trackStack.push(shouldTrack);
679  shouldTrack = false;

680}
681function resetTracking() {
682  const last = trackStack.pop();
683  shouldTrack = last === void 0 ? true : last;
684}
685function cleanupEffect(e) {
686  const { cleanup } = e;
687  e.cleanup = void 0;
688  if (cleanup) {
689    const prevSub = activeSub;
690    activeSub = void 0;
691    try {
692      cleanup();
693    } finally {
694      activeSub = prevSub;
695    }
696  }
697}
698let globalVersion = 0;
699class Link {
700  constructor(sub, dep) {
701    this.sub = sub;
702    this.dep = dep;
703    this.version = dep.version;
704    this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
705  }
706}
707class Dep {
708  constructor(computed2) {
709    this.computed = computed2;
710    this.version = 0;
711    this.activeLink = void 0;
712    this.subs = void 0;
713    this.map = void 0;
714    this.key = void 0;
715    this.sc = 0;
716  }
717  track(debugInfo) {
718    if (!activeSub || !shouldTrack || activeSub === this.computed) {
719      return;
720    }
721    let link = this.activeLink;
722    if (link === void 0 || link.sub !== activeSub) {
723      link = this.activeLink = new Link(activeSub, this);
724      if (!activeSub.deps) {
725        activeSub.deps = activeSub.depsTail = link;
726      } else {
727        link.prevDep = activeSub.depsTail;
728        activeSub.depsTail.nextDep = link;
729        activeSub.depsTail = link;
730      }
731      addSub(link);
732    } else if (link.version === -1) {
733      link.version = this.version;
734      if (link.nextDep) {
735        const next = link.nextDep;
736        next.prevDep = link.prevDep;
737        if (link.prevDep) {
738          link.prevDep.nextDep = next;
739        }
740        link.prevDep = activeSub.depsTail;
741        link.nextDep = void 0;
742        activeSub.depsTail.nextDep = link;
743        activeSub.depsTail = link;
744        if (activeSub.deps === link) {
745          activeSub.deps = next;
746        }
747      }
748    }
749    return link;
750  }
751  trigger(debugInfo) {
752    this.version++;
753    globalVersion++;
754    this.notify(debugInfo);
755  }
756  notify(debugInfo) {
757    startBatch();
758    try {
759      if (false) ;
760      for (let link = this.subs; link; link = link.prevSub) {
761        if (link.sub.notify()) {
762          ;
763          link.sub.dep.notify();
764        }
765      }
766    } finally {
767      endBatch();
768    }
769  }
770}
771function addSub(link) {
772  link.dep.sc++;
773  if (link.sub.flags & 4) {
774    const computed2 = link.dep.computed;
775    if (computed2 && !link.dep.subs) {
776      computed2.flags |= 4 | 16;
777      for (let l = computed2.deps; l; l = l.nextDep) {
778        addSub(l);
779      }
780    }
781    const currentTail = link.dep.subs;
782    if (currentTail !== link) {
783      link.prevSub = currentTail;
784      if (currentTail) currentTail.nextSub = link;
785    }
786    link.dep.subs = link;
787  }
788}
789const targetMap = /* @__PURE__ */ new WeakMap();
790const ITERATE_KEY = Symbol(
791  ""
792);
793const MAP_KEY_ITERATE_KEY = Symbol(
794  ""
795);
796const ARRAY_ITERATE_KEY = Symbol(
797  ""
798);
799function track(target, type, key) {
800  if (shouldTrack && activeSub) {
801    let depsMap = targetMap.get(target);
802    if (!depsMap) {
803      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
804    }
805    let dep = depsMap.get(key);
806    if (!dep) {
807      depsMap.set(key, dep = new Dep());
808      dep.map = depsMap;
809      dep.key = key;
810    }
811    {
812      dep.track();
813    }
814  }
815}
816function trigger(target, type, key, newValue, oldValue, oldTarget) {
817  const depsMap = targetMap.get(target);
818  if (!depsMap) {
819    globalVersion++;
820    return;
821  }
822  const run = (dep) => {
823    if (dep) {
824      {
825        dep.trigger();
826      }
827    }
828  };
829  startBatch();
830  if (type === "clear") {
831    depsMap.forEach(run);
832  } else {
833    const targetIsArray = isArray$3(target);
834    const isArrayIndex = targetIsArray && isIntegerKey(key);
835    if (targetIsArray && key === "length") {
836      const newLength = Number(newValue);
837      depsMap.forEach((dep, key2) => {

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

1907**/
1908const stack$1 = [];
1909function pushWarningContext(vnode) {
1910  stack$1.push(vnode);
1911}
1912function popWarningContext() {
1913  stack$1.pop();
1914}
1915let isWarning = false;
1916function warn$1(msg, ...args) {
1917  if (isWarning) return;
1918  isWarning = true;
1919  pauseTracking();
1920  const instance = stack$1.length ? stack$1[stack$1.length - 1].component : null;
1921  const appWarnHandler = instance && instance.appContext.config.warnHandler;
1922  const trace = getComponentTrace();
1923  if (appWarnHandler) {
1924    callWithErrorHandling(
1925      appWarnHandler,
1926      instance,
1927      11,
1928      [
1929        // eslint-disable-next-line no-restricted-syntax
1930        msg + args.map((a) => {
1931          var _a, _b;
1932          return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
1933        }).join(""),
1934        instance && instance.proxy,
1935        trace.map(
1936          ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
1937        ).join("\n"),
1938        trace
1939      ]
1940    );
1941  } else {
1942    const warnArgs = [`[Vue warn]: ${msg}`, ...args];
1943    if (trace.length && // avoid spamming console during tests
1944    true) {
1945      warnArgs.push(`
1946`, ...formatTrace(trace));
1947    }
1948    console.warn(...warnArgs);
1949  }
1950  resetTracking();
1951  isWarning = false;
1952}
1953function getComponentTrace() {
1954  let currentVNode = stack$1[stack$1.length - 1];
1955  if (!currentVNode) {
1956    return [];
1957  }
1958  const normalizedStack = [];
1959  while (currentVNode) {
1960    const last = normalizedStack[0];
1961    if (last && last.vnode === currentVNode) {
1962      last.recurseCount++;
1963    } else {
1964      normalizedStack.push({
1965        vnode: currentVNode,
1966        recurseCount: 0
1967      });
1968    }
1969    const parentInstance = currentVNode.component && currentVNode.component.parent;
1970    currentVNode = parentInstance && parentInstance.vnode;
1971  }
1972  return normalizedStack;
1973}
1974function formatTrace(trace) {
1975  const logs = [];
1976  trace.forEach((entry, i) => {
1977    logs.push(...i === 0 ? [] : [`
1978`], ...formatTraceEntry(entry));
1979  });
1980  return logs;
1981}
1982function formatTraceEntry({ vnode, recurseCount }) {
1983  const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
1984  const isRoot = vnode.component ? vnode.component.parent == null : false;
1985  const open = ` at <${formatComponentName(
1986    vnode.component,
1987    vnode.type,
1988    isRoot
1989  )}`;
1990  const close = `>` + postfix;
1991  return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
1992}
1993function formatProps(props2) {
1994  const res = [];
1995  const keys = Object.keys(props2);
1996  keys.slice(0, 3).forEach((key) => {
1997    res.push(...formatProp(key, props2[key]));
1998  });
1999  if (keys.length > 3) {
2000    res.push(` ...`);
2001  }
2002  return res;
2003}
2004function formatProp(key, value, raw) {
2005  if (isString$3(value)) {
2006    value = JSON.stringify(value);
2007    return raw ? value : [`${key}=${value}`];
2008  } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
2009    return raw ? value : [`${key}=${value}`];
2010  } else if (isRef(value)) {
2011    value = formatProp(key, toRaw(value.value), true);
2012    return raw ? value : [`${key}=Ref<`, value, `>`];
2013  } else if (isFunction$3(value)) {
2014    return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
2015  } else {
2016    value = toRaw(value);
2017    return raw ? value : [`${key}=`, value];
2018  }
2019}
2020function assertNumber(val, type) {
2021  return;
2022}
2023const ErrorCodes = {
2024  "SETUP_FUNCTION": 0,
2025  "0": "SETUP_FUNCTION",
2026  "RENDER_FUNCTION": 1,
2027  "1": "RENDER_FUNCTION",
2028  "NATIVE_EVENT_HANDLER": 5,
2029  "5": "NATIVE_EVENT_HANDLER",
2030  "COMPONENT_EVENT_HANDLER": 6,
2031  "6": "COMPONENT_EVENT_HANDLER",
2032  "VNODE_HOOK": 7,
2033  "7": "VNODE_HOOK",
2034  "DIRECTIVE_HOOK": 8,
2035  "8": "DIRECTIVE_HOOK",
2036  "TRANSITION_HOOK": 9,
2037  "9": "TRANSITION_HOOK",
2038  "APP_ERROR_HANDLER": 10,
2039  "10": "APP_ERROR_HANDLER",
2040  "APP_WARN_HANDLER": 11,
2041  "11": "APP_WARN_HANDLER",
2042  "FUNCTION_REF": 12,
2043  "12": "FUNCTION_REF",
2044  "ASYNC_COMPONENT_LOADER": 13,
2045  "13": "ASYNC_COMPONENT_LOADER",
2046  "SCHEDULER": 14,
2047  "14": "SCHEDULER",
2048  "COMPONENT_UPDATE": 15,
2049  "15": "COMPONENT_UPDATE",
2050  "APP_UNMOUNT_CLEANUP": 16,
2051  "16": "APP_UNMOUNT_CLEANUP"
2052};
2053const ErrorTypeStrings$1 = {
2054  ["sp"]: "serverPrefetch hook",
2055  ["bc"]: "beforeCreate hook",
2056  ["c"]: "created hook",
2057  ["bm"]: "beforeMount hook",
2058  ["m"]: "mounted hook",
2059  ["bu"]: "beforeUpdate hook",
2060  ["u"]: "updated",
2061  ["bum"]: "beforeUnmount hook",
2062  ["um"]: "unmounted hook",
2063  ["a"]: "activated hook",
2064  ["da"]: "deactivated hook",
2065  ["ec"]: "errorCaptured hook",
2066  ["rtc"]: "renderTracked hook",
2067  ["rtg"]: "renderTriggered hook",
2068  [0]: "setup function",
2069  [1]: "render function",
2070  [2]: "watcher getter",

2071  [3]: "watcher callback",
2072  [4]: "watcher cleanup function",
2073  [5]: "native event handler",
2074  [6]: "component event handler",
2075  [7]: "vnode hook",
2076  [8]: "directive hook",
2077  [9]: "transition hook",
2078  [10]: "app errorHandler",
2079  [11]: "app warnHandler",
2080  [12]: "ref function",
2081  [13]: "async component loader",
2082  [14]: "scheduler flush",
2083  [15]: "component update",
2084  [16]: "app unmount cleanup function"
2085};
2086function callWithErrorHandling(fn, instance, type, args) {
2087  try {
2088    return args ? fn(...args) : fn();
2089  } catch (err) {
2090    handleError(err, instance, type);
2091  }
2092}
2093function callWithAsyncErrorHandling(fn, instance, type, args) {
2094  if (isFunction$3(fn)) {
2095    const res = callWithErrorHandling(fn, instance, type, args);
2096    if (res && isPromise$2(res)) {
2097      res.catch((err) => {
2098        handleError(err, instance, type);
2099      });
2100    }
2101    return res;
2102  }
2103  if (isArray$3(fn)) {
2104    const values = [];
2105    for (let i = 0; i < fn.length; i++) {
2106      values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
2107    }
2108    return values;
2109  }
2110}
2111function handleError(err, instance, type, throwInDev = true) {
2112  const contextVNode = instance ? instance.vnode : null;
2113  const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
2114  if (instance) {
2115    let cur = instance.parent;
2116    const exposedInstance = instance.proxy;
2117    const errorInfo = `https://vuejs.org/error-reference/#runtime-${type}`;
2118    while (cur) {