https://chatbot.cocosolution.com/dist/widget.js?key=6cf4dfd02a1ceb…85498ca4ff9db5fd8614410c6ae9c945773a9fa7674

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

124const listDelimiterRE = /;(?![^(]*\))/g;
125const propertyDelimiterRE = /:([^]+)/;
126const styleCommentRE = /\/\*[^]*?\*\//g;
127function parseStringStyle(cssText) {
128  const ret = {};
129  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
130    if (item) {
131      const tmp = item.split(propertyDelimiterRE);
132      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
133    }
134  });
135  return ret;
136}
137function normalizeClass(value) {
138  let res = "";
139  if (isString$2(value)) {
140    res = value;
141  } else if (isArray$1(value)) {
142    for (let i = 0; i < value.length; i++) {
143      const normalized = normalizeClass(value[i]);
144      if (normalized) {
145        res += normalized + " ";
146      }
147    }
148  } else if (isObject$3(value)) {
149    for (const name in value) {
150      if (value[name]) {
151        res += name + " ";
152      }
153    }
154  }
155  return res.trim();
156}
157const 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";
158const 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";
159const 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";
160const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
161const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
162const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
163const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
164const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
165function includeBooleanAttr(value) {
166  return !!value || value === "";
167}
168function looseCompareArrays(a, b) {
169  if (a.length !== b.length) return false;
170  let equal = true;
171  for (let i = 0; equal && i < a.length; i++) {
172    equal = looseEqual(a[i], b[i]);
173  }
174  return equal;
175}
176function looseEqual(a, b) {
177  if (a === b) return true;
178  let aValidType = isDate$1(a);
179  let bValidType = isDate$1(b);
180  if (aValidType || bValidType) {
181    return aValidType && bValidType ? a.getTime() === b.getTime() : false;
182  }
183  aValidType = isSymbol(a);
184  bValidType = isSymbol(b);
185  if (aValidType || bValidType) {
186    return a === b;
187  }
188  aValidType = isArray$1(a);
189  bValidType = isArray$1(b);
190  if (aValidType || bValidType) {
191    return aValidType && bValidType ? looseCompareArrays(a, b) : false;
192  }
193  aValidType = isObject$3(a);
194  bValidType = isObject$3(b);
195  if (aValidType || bValidType) {
196    if (!aValidType || !bValidType) {
197      return false;
198    }
199    const aKeysCount = Object.keys(a).length;
200    const bKeysCount = Object.keys(b).length;
201    if (aKeysCount !== bKeysCount) {
202      return false;
203    }
204    for (const key in a) {
205      const aHasKey = a.hasOwnProperty(key);
206      const bHasKey = b.hasOwnProperty(key);
207      if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
208        return false;

209      }
210    }
211  }
212  return String(a) === String(b);
213}
214function looseIndexOf(arr, val) {
215  return arr.findIndex((item) => looseEqual(item, val));
216}
217const isRef$1 = (val) => {
218  return !!(val && val["__v_isRef"] === true);
219};
220const toDisplayString$1 = (val) => {
221  return isString$2(val) ? val : val == null ? "" : isArray$1(val) || isObject$3(val) && (val.toString === objectToString$1 || !isFunction$1(val.toString)) ? isRef$1(val) ? toDisplayString$1(val.value) : JSON.stringify(val, replacer, 2) : String(val);
222};
223const replacer = (_key, val) => {
224  if (isRef$1(val)) {
225    return replacer(_key, val.value);
226  } else if (isMap(val)) {
227    return {
228      [`Map(${val.size})`]: [...val.entries()].reduce(
229        (entries, [key, val2], i) => {
230          entries[stringifySymbol(key, i) + " =>"] = val2;
231          return entries;
232        },
233        {}
234      )
235    };
236  } else if (isSet(val)) {
237    return {
238      [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
239    };
240  } else if (isSymbol(val)) {
241    return stringifySymbol(val);
242  } else if (isObject$3(val) && !isArray$1(val) && !isPlainObject$2(val)) {
243    return String(val);
244  }
245  return val;
246};
247const stringifySymbol = (v, i = "") => {
248  var _a2;
249  return (
250    // Symbol.description in es2019+ so we need to cast here to pass
251    // the lib: es2016 check
252    isSymbol(v) ? `Symbol(${(_a2 = v.description) != null ? _a2 : i})` : v
253  );
254};
255var define_process_env_default$8 = {};
256function warn$3(msg, ...args) {
257  console.warn(`[Vue warn] ${msg}`, ...args);
258}
259let activeEffectScope;
260class EffectScope {
261  constructor(detached = false) {
262    this.detached = detached;
263    this._active = true;
264    this._on = 0;
265    this.effects = [];
266    this.cleanups = [];
267    this._isPaused = false;
268    this.parent = activeEffectScope;
269    if (!detached && activeEffectScope) {
270      this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
271        this
272      ) - 1;
273    }
274  }
275  get active() {
276    return this._active;
277  }
278  pause() {
279    if (this._active) {
280      this._isPaused = true;
281      let i, l;
282      if (this.scopes) {
283        for (i = 0, l = this.scopes.length; i < l; i++) {
284          this.scopes[i].pause();
285        }
286      }
287      for (i = 0, l = this.effects.length; i < l; i++) {
288        this.effects[i].pause();
289      }
290    }
291  }
292  /**
293   * Resumes the effect scope, including all child scopes and effects.
294   */
295  resume() {
296    if (this._active) {
297      if (this._isPaused) {
298        this._isPaused = false;
299        let i, l;
300        if (this.scopes) {
301          for (i = 0, l = this.scopes.length; i < l; i++) {
302            this.scopes[i].resume();
303          }
304        }
305        for (i = 0, l = this.effects.length; i < l; i++) {
306          this.effects[i].resume();
307        }
308      }
309    }
310  }
311  run(fn) {
312    if (this._active) {
313      const currentEffectScope = activeEffectScope;
314      try {
315        activeEffectScope = this;
316        return fn();
317      } finally {
318        activeEffectScope = currentEffectScope;
319      }
320    } else if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
321      warn$3(`cannot run an inactive effect scope.`);
322    }
323  }
324  /**
325   * This should only be called on non-detached scopes
326   * @internal
327   */
328  on() {
329    if (++this._on === 1) {
330      this.prevScope = activeEffectScope;
331      activeEffectScope = this;
332    }
333  }
334  /**
335   * This should only be called on non-detached scopes
336   * @internal
337   */
338  off() {
339    if (this._on > 0 && --this._on === 0) {
340      activeEffectScope = this.prevScope;
341      this.prevScope = void 0;
342    }
343  }
344  stop(fromParent) {
345    if (this._active) {
346      this._active = false;
347      let i, l;
348      for (i = 0, l = this.effects.length; i < l; i++) {
349        this.effects[i].stop();
350      }
351      this.effects.length = 0;
352      for (i = 0, l = this.cleanups.length; i < l; i++) {
353        this.cleanups[i]();
354      }
355      this.cleanups.length = 0;
356      if (this.scopes) {
357        for (i = 0, l = this.scopes.length; i < l; i++) {
358          this.scopes[i].stop(true);
359        }
360        this.scopes.length = 0;
361      }
362      if (!this.detached && this.parent && !fromParent) {
363        const last = this.parent.scopes.pop();
364        if (last && last !== this) {
365          this.parent.scopes[this.index] = last;
366          last.index = this.index;
367        }
368      }
369      this.parent = void 0;
370    }
371  }
372}
373function effectScope(detached) {
374  return new EffectScope(detached);
375}
376function getCurrentScope() {
377  return activeEffectScope;
378}
379function onScopeDispose(fn, failSilently = false) {
380  if (activeEffectScope) {
381    activeEffectScope.cleanups.push(fn);
382  } else if (!!(define_process_env_default$8.NODE_ENV !== "production") && !failSilently) {
383    warn$3(
384      `onScopeDispose() is called when there is no active effect scope to be associated with.`
385    );
386  }
387}
388let activeSub;

389const pausedQueueEffects = /* @__PURE__ */ new WeakSet();
390class ReactiveEffect {
391  constructor(fn) {
392    this.fn = fn;
393    this.deps = void 0;
394    this.depsTail = void 0;
395    this.flags = 1 | 4;
396    this.next = void 0;
397    this.cleanup = void 0;
398    this.scheduler = void 0;
399    if (activeEffectScope && activeEffectScope.active) {
400      activeEffectScope.effects.push(this);
401    }
402  }
403  pause() {
404    this.flags |= 64;
405  }
406  resume() {
407    if (this.flags & 64) {
408      this.flags &= -65;
409      if (pausedQueueEffects.has(this)) {
410        pausedQueueEffects.delete(this);
411        this.trigger();
412      }
413    }
414  }
415  /**
416   * @internal
417   */
418  notify() {
419    if (this.flags & 2 && !(this.flags & 32)) {
420      return;
421    }
422    if (!(this.flags & 8)) {
423      batch(this);
424    }
425  }
426  run() {
427    if (!(this.flags & 1)) {
428      return this.fn();
429    }
430    this.flags |= 2;
431    cleanupEffect(this);
432    prepareDeps(this);
433    const prevEffect = activeSub;
434    const prevShouldTrack = shouldTrack;
435    activeSub = this;
436    shouldTrack = true;
437    try {
438      return this.fn();
439    } finally {
440      if (!!(define_process_env_default$8.NODE_ENV !== "production") && activeSub !== this) {
441        warn$3(
442          "Active effect was not restored correctly - this is likely a Vue internal bug."
443        );
444      }
445      cleanupDeps(this);
446      activeSub = prevEffect;
447      shouldTrack = prevShouldTrack;
448      this.flags &= -3;
449    }
450  }
451  stop() {
452    if (this.flags & 1) {
453      for (let link2 = this.deps; link2; link2 = link2.nextDep) {
454        removeSub(link2);
455      }
456      this.deps = this.depsTail = void 0;
457      cleanupEffect(this);
458      this.onStop && this.onStop();
459      this.flags &= -2;
460    }
461  }
462  trigger() {
463    if (this.flags & 64) {
464      pausedQueueEffects.add(this);
465    } else if (this.scheduler) {
466      this.scheduler();
467    } else {
468      this.runIfDirty();
469    }
470  }
471  /**
472   * @internal
473   */
474  runIfDirty() {
475    if (isDirty(this)) {
476      this.run();
477    }
478  }
479  get dirty() {
480    return isDirty(this);
481  }
482}
483let batchDepth = 0;
484let batchedSub;
485let batchedComputed;
486function batch(sub, isComputed2 = false) {
487  sub.flags |= 8;
488  if (isComputed2) {
489    sub.next = batchedComputed;
490    batchedComputed = sub;
491    return;
492  }
493  sub.next = batchedSub;
494  batchedSub = sub;
495}
496function startBatch() {
497  batchDepth++;
498}
499function endBatch() {
500  if (--batchDepth > 0) {
501    return;
502  }
503  if (batchedComputed) {
504    let e = batchedComputed;
505    batchedComputed = void 0;
506    while (e) {
507      const next = e.next;
508      e.next = void 0;
509      e.flags &= -9;
510      e = next;
511    }
512  }
513  let error2;
514  while (batchedSub) {
515    let e = batchedSub;
516    batchedSub = void 0;
517    while (e) {
518      const next = e.next;
519      e.next = void 0;
520      e.flags &= -9;
521      if (e.flags & 1) {
522        try {
523          ;
524          e.trigger();
525        } catch (err) {
526          if (!error2) error2 = err;
527        }
528      }
529      e = next;
530    }
531  }
532  if (error2) throw error2;
533}
534function prepareDeps(sub) {
535  for (let link2 = sub.deps; link2; link2 = link2.nextDep) {
536    link2.version = -1;
537    link2.prevActiveLink = link2.dep.activeLink;
538    link2.dep.activeLink = link2;
539  }
540}
541function cleanupDeps(sub) {
542  let head;
543  let tail = sub.depsTail;
544  let link2 = tail;
545  while (link2) {
546    const prev = link2.prevDep;
547    if (link2.version === -1) {
548      if (link2 === tail) tail = prev;
549      removeSub(link2);
550      removeDep(link2);
551    } else {
552      head = link2;
553    }
554    link2.dep.activeLink = link2.prevActiveLink;
555    link2.prevActiveLink = void 0;
556    link2 = prev;
557  }
558  sub.deps = head;
559  sub.depsTail = tail;
560}
561function isDirty(sub) {
562  for (let link2 = sub.deps; link2; link2 = link2.nextDep) {
563    if (link2.dep.version !== link2.version || link2.dep.computed && (refreshComputed(link2.dep.computed) || link2.dep.version !== link2.version)) {
564      return true;
565    }
566  }
567  if (sub._dirty) {
568    return true;
569  }
570  return false;
571}
572function refreshComputed(computed2) {
573  if (computed2.flags & 4 && !(computed2.flags & 16)) {
574    return;
575  }
576  computed2.flags &= -17;
577  if (computed2.globalVersion === globalVersion) {
578    return;
579  }
580  computed2.globalVersion = globalVersion;
581  if (!computed2.isSSR && computed2.flags & 128 && (!computed2.deps && !computed2._dirty || !isDirty(computed2))) {
582    return;
583  }
584  computed2.flags |= 2;

585  const dep = computed2.dep;
586  const prevSub = activeSub;
587  const prevShouldTrack = shouldTrack;
588  activeSub = computed2;
589  shouldTrack = true;
590  try {
591    prepareDeps(computed2);
592    const value = computed2.fn(computed2._value);
593    if (dep.version === 0 || hasChanged(value, computed2._value)) {
594      computed2.flags |= 128;
595      computed2._value = value;
596      dep.version++;
597    }
598  } catch (err) {
599    dep.version++;
600    throw err;
601  } finally {
602    activeSub = prevSub;
603    shouldTrack = prevShouldTrack;
604    cleanupDeps(computed2);
605    computed2.flags &= -3;
606  }
607}
608function removeSub(link2, soft = false) {
609  const { dep, prevSub, nextSub } = link2;
610  if (prevSub) {
611    prevSub.nextSub = nextSub;
612    link2.prevSub = void 0;
613  }
614  if (nextSub) {
615    nextSub.prevSub = prevSub;
616    link2.nextSub = void 0;
617  }
618  if (!!(define_process_env_default$8.NODE_ENV !== "production") && dep.subsHead === link2) {
619    dep.subsHead = nextSub;
620  }
621  if (dep.subs === link2) {
622    dep.subs = prevSub;
623    if (!prevSub && dep.computed) {
624      dep.computed.flags &= -5;
625      for (let l = dep.computed.deps; l; l = l.nextDep) {
626        removeSub(l, true);
627      }
628    }
629  }
630  if (!soft && !--dep.sc && dep.map) {
631    dep.map.delete(dep.key);
632  }
633}
634function removeDep(link2) {
635  const { prevDep, nextDep } = link2;
636  if (prevDep) {
637    prevDep.nextDep = nextDep;
638    link2.prevDep = void 0;
639  }
640  if (nextDep) {
641    nextDep.prevDep = prevDep;
642    link2.nextDep = void 0;
643  }
644}
645let shouldTrack = true;
646const trackStack = [];
647function pauseTracking() {
648  trackStack.push(shouldTrack);
649  shouldTrack = false;
650}
651function resetTracking() {
652  const last = trackStack.pop();
653  shouldTrack = last === void 0 ? true : last;
654}
655function cleanupEffect(e) {
656  const { cleanup } = e;
657  e.cleanup = void 0;
658  if (cleanup) {
659    const prevSub = activeSub;
660    activeSub = void 0;
661    try {
662      cleanup();
663    } finally {
664      activeSub = prevSub;
665    }
666  }
667}
668let globalVersion = 0;
669class Link {
670  constructor(sub, dep) {
671    this.sub = sub;
672    this.dep = dep;
673    this.version = dep.version;
674    this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
675  }
676}
677class Dep {
678  // TODO isolatedDeclarations "__v_skip"
679  constructor(computed2) {
680    this.computed = computed2;
681    this.version = 0;
682    this.activeLink = void 0;
683    this.subs = void 0;
684    this.map = void 0;
685    this.key = void 0;
686    this.sc = 0;
687    this.__v_skip = true;
688    if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
689      this.subsHead = void 0;
690    }
691  }
692  track(debugInfo) {
693    if (!activeSub || !shouldTrack || activeSub === this.computed) {
694      return;
695    }
696    let link2 = this.activeLink;
697    if (link2 === void 0 || link2.sub !== activeSub) {
698      link2 = this.activeLink = new Link(activeSub, this);
699      if (!activeSub.deps) {
700        activeSub.deps = activeSub.depsTail = link2;
701      } else {
702        link2.prevDep = activeSub.depsTail;
703        activeSub.depsTail.nextDep = link2;
704        activeSub.depsTail = link2;
705      }
706      addSub(link2);
707    } else if (link2.version === -1) {
708      link2.version = this.version;
709      if (link2.nextDep) {
710        const next = link2.nextDep;
711        next.prevDep = link2.prevDep;
712        if (link2.prevDep) {
713          link2.prevDep.nextDep = next;
714        }
715        link2.prevDep = activeSub.depsTail;
716        link2.nextDep = void 0;
717        activeSub.depsTail.nextDep = link2;
718        activeSub.depsTail = link2;
719        if (activeSub.deps === link2) {
720          activeSub.deps = next;
721        }
722      }
723    }
724    if (!!(define_process_env_default$8.NODE_ENV !== "production") && activeSub.onTrack) {
725      activeSub.onTrack(
726        extend(
727          {
728            effect: activeSub
729          },
730          debugInfo
731        )
732      );
733    }
734    return link2;
735  }
736  trigger(debugInfo) {
737    this.version++;
738    globalVersion++;
739    this.notify(debugInfo);
740  }
741  notify(debugInfo) {
742    startBatch();
743    try {
744      if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
745        for (let head = this.subsHead; head; head = head.nextSub) {
746          if (head.sub.onTrigger && !(head.sub.flags & 8)) {
747            head.sub.onTrigger(
748              extend(
749                {
750                  effect: head.sub
751                },
752                debugInfo
753              )
754            );
755          }
756        }
757      }
758      for (let link2 = this.subs; link2; link2 = link2.prevSub) {
759        if (link2.sub.notify()) {
760          ;
761          link2.sub.dep.notify();
762        }
763      }
764    } finally {
765      endBatch();
766    }
767  }
768}
769function addSub(link2) {
770  link2.dep.sc++;
771  if (link2.sub.flags & 4) {
772    const computed2 = link2.dep.computed;
773    if (computed2 && !link2.dep.subs) {
774      computed2.flags |= 4 | 16;
775      for (let l = computed2.deps; l; l = l.nextDep) {
776        addSub(l);
777      }
778    }
779    const currentTail = link2.dep.subs;
780    if (currentTail !== link2) {
781      link2.prevSub = currentTail;
782      if (currentTail) currentTail.nextSub = link2;
783    }
784    if (!!(define_process_env_default$8.NODE_ENV !== "production") && link2.dep.subsHead === void 0) {
785      link2.dep.subsHead = link2;
786    }
787    link2.dep.subs = link2;
788  }
789}
790const targetMap = /* @__PURE__ */ new WeakMap();
791const ITERATE_KEY = Symbol(
792  !!(define_process_env_default$8.NODE_ENV !== "production") ? "Object iterate" : ""
793);
794const MAP_KEY_ITERATE_KEY = Symbol(
795  !!(define_process_env_default$8.NODE_ENV !== "production") ? "Map keys iterate" : ""
796);
797const ARRAY_ITERATE_KEY = Symbol(
798  !!(define_process_env_default$8.NODE_ENV !== "production") ? "Array iterate" : ""
799);
800function track(target, type, key) {
801  if (shouldTrack && activeSub) {
802    let depsMap = targetMap.get(target);
803    if (!depsMap) {
804      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
805    }
806    let dep = depsMap.get(key);
807    if (!dep) {
808      depsMap.set(key, dep = new Dep());
809      dep.map = depsMap;
810      dep.key = key;
811    }
812    if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
813      dep.track({
814        target,
815        type,
816        key
817      });
818    } else {
819      dep.track();
820    }
821  }
822}
823function trigger(target, type, key, newValue, oldValue, oldTarget) {
824  const depsMap = targetMap.get(target);
825  if (!depsMap) {
826    globalVersion++;
827    return;
828  }
829  const run = (dep) => {
830    if (dep) {
831      if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
832        dep.trigger({
833          target,
834          type,
835          key,
836          newValue,
837          oldValue,
838          oldTarget
839        });
840      } else {
841        dep.trigger();
842      }
843    }
844  };
845  startBatch();
846  if (type === "clear") {

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

1028        return fn.call(this, toReactive(item), index, self2);
1029      };
1030    } else if (fn.length > 2) {
1031      wrappedFn = function(item, index) {
1032        return fn.call(this, item, index, self2);
1033      };
1034    }
1035  }
1036  const result = methodFn.call(arr, wrappedFn, thisArg);
1037  return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
1038}
1039function reduce(self2, method, fn, args) {
1040  const arr = shallowReadArray(self2);
1041  let wrappedFn = fn;
1042  if (arr !== self2) {
1043    if (!isShallow(self2)) {
1044      wrappedFn = function(acc, item, index) {
1045        return fn.call(this, acc, toReactive(item), index, self2);
1046      };
1047    } else if (fn.length > 3) {
1048      wrappedFn = function(acc, item, index) {
1049        return fn.call(this, acc, item, index, self2);
1050      };
1051    }
1052  }
1053  return arr[method](wrappedFn, ...args);
1054}
1055function searchProxy(self2, method, args) {
1056  const arr = toRaw(self2);
1057  track(arr, "iterate", ARRAY_ITERATE_KEY);
1058  const res = arr[method](...args);
1059  if ((res === -1 || res === false) && isProxy(args[0])) {
1060    args[0] = toRaw(args[0]);
1061    return arr[method](...args);
1062  }
1063  return res;
1064}
1065function noTracking(self2, method, args = []) {
1066  pauseTracking();
1067  startBatch();
1068  const res = toRaw(self2)[method].apply(self2, args);
1069  endBatch();
1070  resetTracking();
1071  return res;
1072}
1073const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
1074const builtInSymbols = new Set(
1075  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
1076);
1077function hasOwnProperty$1(key) {
1078  if (!isSymbol(key)) key = String(key);
1079  const obj = toRaw(this);
1080  track(obj, "has", key);
1081  return obj.hasOwnProperty(key);
1082}
1083class BaseReactiveHandler {
1084  constructor(_isReadonly = false, _isShallow = false) {
1085    this._isReadonly = _isReadonly;
1086    this._isShallow = _isShallow;
1087  }
1088  get(target, key, receiver) {
1089    if (key === "__v_skip") return target["__v_skip"];
1090    const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
1091    if (key === "__v_isReactive") {
1092      return !isReadonly2;
1093    } else if (key === "__v_isReadonly") {
1094      return isReadonly2;
1095    } else if (key === "__v_isShallow") {
1096      return isShallow2;
1097    } else if (key === "__v_raw") {
1098      if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
1099      // this means the receiver is a user proxy of the reactive proxy
1100      Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
1101        return target;
1102      }
1103      return;
1104    }
1105    const targetIsArray = isArray$1(target);
1106    if (!isReadonly2) {
1107      let fn;
1108      if (targetIsArray && (fn = arrayInstrumentations[key])) {
1109        return fn;
1110      }
1111      if (key === "hasOwnProperty") {
1112        return hasOwnProperty$1;
1113      }
1114    }
1115    const res = Reflect.get(
1116      target,
1117      key,
1118      // if this is a proxy wrapping a ref, return methods using the raw ref
1119      // as receiver so that we don't have to call `toRaw` on the ref in all
1120      // its class methods
1121      isRef(target) ? target : receiver
1122    );
1123    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
1124      return res;
1125    }
1126    if (!isReadonly2) {
1127      track(target, "get", key);
1128    }
1129    if (isShallow2) {
1130      return res;
1131    }
1132    if (isRef(res)) {
1133      const value = targetIsArray && isIntegerKey(key) ? res : res.value;
1134      return isReadonly2 && isObject$3(value) ? readonly(value) : value;
1135    }
1136    if (isObject$3(res)) {
1137      return isReadonly2 ? readonly(res) : reactive(res);
1138    }
1139    return res;
1140  }
1141}
1142class MutableReactiveHandler extends BaseReactiveHandler {
1143  constructor(isShallow2 = false) {
1144    super(false, isShallow2);
1145  }
1146  set(target, key, value, receiver) {
1147    let oldValue = target[key];
1148    if (!this._isShallow) {
1149      const isOldValueReadonly = isReadonly(oldValue);
1150      if (!isShallow(value) && !isReadonly(value)) {
1151        oldValue = toRaw(oldValue);
1152        value = toRaw(value);
1153      }
1154      if (!isArray$1(target) && isRef(oldValue) && !isRef(value)) {
1155        if (isOldValueReadonly) {
1156          if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
1157            warn$3(
1158              `Set operation on key "${String(key)}" failed: target is readonly.`,
1159              target[key]
1160            );
1161          }
1162          return true;
1163        } else {
1164          oldValue.value = value;
1165          return true;
1166        }
1167      }
1168    }
1169    const hadKey = isArray$1(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn$1(target, key);
1170    const result = Reflect.set(
1171      target,
1172      key,
1173      value,
1174      isRef(target) ? target : receiver
1175    );
1176    if (target === toRaw(receiver)) {
1177      if (!hadKey) {
1178        trigger(target, "add", key, value);
1179      } else if (hasChanged(value, oldValue)) {
1180        trigger(target, "set", key, value, oldValue);
1181      }
1182    }
1183    return result;
1184  }
1185  deleteProperty(target, key) {
1186    const hadKey = hasOwn$1(target, key);
1187    const oldValue = target[key];
1188    const result = Reflect.deleteProperty(target, key);
1189    if (result && hadKey) {
1190      trigger(target, "delete", key, void 0, oldValue);
1191    }
1192    return result;
1193  }
1194  has(target, key) {
1195    const result = Reflect.has(target, key);
1196    if (!isSymbol(key) || !builtInSymbols.has(key)) {
1197      track(target, "has", key);
1198    }
1199    return result;
1200  }
1201  ownKeys(target) {
1202    track(
1203      target,
1204      "iterate",
1205      isArray$1(target) ? "length" : ITERATE_KEY
1206    );
1207    return Reflect.ownKeys(target);
1208  }
1209}
1210class ReadonlyReactiveHandler extends BaseReactiveHandler {
1211  constructor(isShallow2 = false) {
1212    super(true, isShallow2);
1213  }
1214  set(target, key) {
1215    if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
1216      warn$3(
1217        `Set operation on key "${String(key)}" failed: target is readonly.`,
1218        target
1219      );
1220    }
1221    return true;
1222  }
1223  deleteProperty(target, key) {
1224    if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
1225      warn$3(
1226        `Delete operation on key "${String(key)}" failed: target is readonly.`,
1227        target
1228      );
1229    }
1230    return true;
1231  }
1232}
1233const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
1234const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
1235const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true);
1236const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
1237const toShallow = (value) => value;
1238const getProto = (v) => Reflect.getPrototypeOf(v);
1239function createIterableMethod(method, isReadonly2, isShallow2) {
1240  return function(...args) {
1241    const target = this["__v_raw"];
1242    const rawTarget = toRaw(target);
1243    const targetIsMap = isMap(rawTarget);
1244    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
1245    const isKeyOnly = method === "keys" && targetIsMap;
1246    const innerIterator = target[method](...args);
1247    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
1248    !isReadonly2 && track(
1249      rawTarget,
1250      "iterate",
1251      isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
1252    );
1253    return {
1254      // iterator protocol
1255      next() {
1256        const { value, done } = innerIterator.next();
1257        return done ? { value, done } : {
1258          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
1259          done
1260        };
1261      },
1262      // iterable protocol
1263      [Symbol.iterator]() {
1264        return this;
1265      }
1266    };
1267  };
1268}
1269function createReadonlyMethod(type) {
1270  return function(...args) {
1271    if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
1272      const key = args[0] ? `on key "${args[0]}" ` : ``;
1273      warn$3(
1274        `${capitalize$1(type)} operation ${key}failed: target is readonly.`,
1275        toRaw(this)
1276      );
1277    }
1278    return type === "delete" ? false : type === "clear" ? void 0 : this;
1279  };
1280}
1281function createInstrumentations(readonly2, shallow) {
1282  const instrumentations = {
1283    get(key) {
1284      const target = this["__v_raw"];
1285      const rawTarget = toRaw(target);
1286      const rawKey = toRaw(key);
1287      if (!readonly2) {
1288        if (hasChanged(key, rawKey)) {
1289          track(rawTarget, "get", key);
1290        }
1291        track(rawTarget, "get", rawKey);
1292      }
1293      const { has } = getProto(rawTarget);
1294      const wrap = shallow ? toShallow : readonly2 ? toReadonly : toReactive;
1295      if (has.call(rawTarget, key)) {
1296        return wrap(target.get(key));
1297      } else if (has.call(rawTarget, rawKey)) {
1298        return wrap(target.get(rawKey));
1299      } else if (target !== rawTarget) {
1300        target.get(key);
1301      }
1302    },
1303    get size() {
1304      const target = this["__v_raw"];
1305      !readonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
1306      return target.size;
1307    },
1308    has(key) {
1309      const target = this["__v_raw"];
1310      const rawTarget = toRaw(target);
1311      const rawKey = toRaw(key);
1312      if (!readonly2) {
1313        if (hasChanged(key, rawKey)) {
1314          track(rawTarget, "has", key);
1315        }
1316        track(rawTarget, "has", rawKey);
1317      }
1318      return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
1319    },
1320    forEach(callback, thisArg) {
1321      const observed = this;
1322      const target = observed["__v_raw"];
1323      const rawTarget = toRaw(target);
1324      const wrap = shallow ? toShallow : readonly2 ? toReadonly : toReactive;
1325      !readonly2 && track(rawTarget, "iterate", ITERATE_KEY);
1326      return target.forEach((value, key) => {
1327        return callback.call(thisArg, wrap(value), wrap(key), observed);
1328      });
1329    }
1330  };
1331  extend(
1332    instrumentations,
1333    readonly2 ? {
1334      add: createReadonlyMethod("add"),
1335      set: createReadonlyMethod("set"),
1336      delete: createReadonlyMethod("delete"),
1337      clear: createReadonlyMethod("clear")
1338    } : {
1339      add(value) {
1340        if (!shallow && !isShallow(value) && !isReadonly(value)) {
1341          value = toRaw(value);
1342        }
1343        const target = toRaw(this);
1344        const proto = getProto(target);
1345        const hadKey = proto.has.call(target, value);
1346        if (!hadKey) {
1347          target.add(value);
1348          trigger(target, "add", value, value);
1349        }
1350        return this;
1351      },
1352      set(key, value) {
1353        if (!shallow && !isShallow(value) && !isReadonly(value)) {
1354          value = toRaw(value);
1355        }
1356        const target = toRaw(this);
1357        const { has, get } = getProto(target);
1358        let hadKey = has.call(target, key);
1359        if (!hadKey) {
1360          key = toRaw(key);
1361          hadKey = has.call(target, key);
1362        } else if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
1363          checkIdentityKeys(target, has, key);
1364        }
1365        const oldValue = get.call(target, key);
1366        target.set(key, value);
1367        if (!hadKey) {
1368          trigger(target, "add", key, value);
1369        } else if (hasChanged(value, oldValue)) {
1370          trigger(target, "set", key, value, oldValue);
1371        }
1372        return this;
1373      },
1374      delete(key) {
1375        const target = toRaw(this);
1376        const { has, get } = getProto(target);
1377        let hadKey = has.call(target, key);
1378        if (!hadKey) {
1379          key = toRaw(key);
1380          hadKey = has.call(target, key);
1381        } else if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
1382          checkIdentityKeys(target, has, key);
1383        }
1384        const oldValue = get ? get.call(target, key) : void 0;
1385        const result = target.delete(key);
1386        if (hadKey) {
1387          trigger(target, "delete", key, void 0, oldValue);
1388        }
1389        return result;
1390      },
1391      clear() {
1392        const target = toRaw(this);
1393        const hadItems = target.size !== 0;
1394        const oldTarget = !!(define_process_env_default$8.NODE_ENV !== "production") ? isMap(target) ? new Map(target) : new Set(target) : void 0;
1395        const result = target.clear();
1396        if (hadItems) {
1397          trigger(
1398            target,
1399            "clear",
1400            void 0,
1401            void 0,
1402            oldTarget
1403          );
1404        }
1405        return result;
1406      }
1407    }
1408  );
1409  const iteratorMethods = [
1410    "keys",
1411    "values",
1412    "entries",
1413    Symbol.iterator
1414  ];
1415  iteratorMethods.forEach((method) => {
1416    instrumentations[method] = createIterableMethod(method, readonly2, shallow);
1417  });
1418  return instrumentations;
1419}
1420function createInstrumentationGetter(isReadonly2, shallow) {
1421  const instrumentations = createInstrumentations(isReadonly2, shallow);
1422  return (target, key, receiver) => {
1423    if (key === "__v_isReactive") {
1424      return !isReadonly2;
1425    } else if (key === "__v_isReadonly") {
1426      return isReadonly2;
1427    } else if (key === "__v_raw") {
1428      return target;
1429    }
1430    return Reflect.get(
1431      hasOwn$1(instrumentations, key) && key in target ? instrumentations : target,
1432      key,
1433      receiver
1434    );
1435  };
1436}
1437const mutableCollectionHandlers = {
1438  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
1439};
1440const shallowCollectionHandlers = {
1441  get: /* @__PURE__ */ createInstrumentationGetter(false, true)
1442};
1443const readonlyCollectionHandlers = {
1444  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
1445};
1446const shallowReadonlyCollectionHandlers = {
1447  get: /* @__PURE__ */ createInstrumentationGetter(true, true)
1448};
1449function checkIdentityKeys(target, has, key) {
1450  const rawKey = toRaw(key);
1451  if (rawKey !== key && has.call(target, rawKey)) {
1452    const type = toRawType(target);
1453    warn$3(
1454      `Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`
1455    );
1456  }
1457}
1458const reactiveMap = /* @__PURE__ */ new WeakMap();
1459const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
1460const readonlyMap = /* @__PURE__ */ new WeakMap();
1461const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
1462function targetTypeMap(rawType) {
1463  switch (rawType) {
1464    case "Object":
1465    case "Array":
1466      return 1;
1467    case "Map":
1468    case "Set":
1469    case "WeakMap":
1470    case "WeakSet":
1471      return 2;
1472    default:
1473      return 0;
1474  }
1475}
1476function getTargetType(value) {
1477  return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
1478}
1479function reactive(target) {
1480  if (isReadonly(target)) {
1481    return target;
1482  }
1483  return createReactiveObject(
1484    target,
1485    false,
1486    mutableHandlers,
1487    mutableCollectionHandlers,
1488    reactiveMap
1489  );
1490}
1491function shallowReactive(target) {
1492  return createReactiveObject(
1493    target,
1494    false,
1495    shallowReactiveHandlers,
1496    shallowCollectionHandlers,
1497    shallowReactiveMap
1498  );
1499}
1500function readonly(target) {
1501  return createReactiveObject(
1502    target,
1503    true,
1504    readonlyHandlers,
1505    readonlyCollectionHandlers,
1506    readonlyMap
1507  );
1508}
1509function shallowReadonly(target) {
1510  return createReactiveObject(
1511    target,
1512    true,
1513    shallowReadonlyHandlers,
1514    shallowReadonlyCollectionHandlers,
1515    shallowReadonlyMap
1516  );
1517}
1518function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
1519  if (!isObject$3(target)) {
1520    if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
1521      warn$3(
1522        `value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(
1523          target
1524        )}`
1525      );
1526    }
1527    return target;
1528  }
1529  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
1530    return target;
1531  }
1532  const targetType = getTargetType(target);
1533  if (targetType === 0) {
1534    return target;
1535  }
1536  const existingProxy = proxyMap.get(target);
1537  if (existingProxy) {
1538    return existingProxy;
1539  }
1540  const proxy = new Proxy(
1541    target,
1542    targetType === 2 ? collectionHandlers : baseHandlers
1543  );
1544  proxyMap.set(target, proxy);
1545  return proxy;
1546}
1547function isReactive(value) {
1548  if (isReadonly(value)) {
1549    return isReactive(value["__v_raw"]);
1550  }
1551  return !!(value && value["__v_isReactive"]);
1552}
1553function isReadonly(value) {
1554  return !!(value && value["__v_isReadonly"]);
1555}
1556function isShallow(value) {
1557  return !!(value && value["__v_isShallow"]);
1558}
1559function isProxy(value) {
1560  return value ? !!value["__v_raw"] : false;
1561}
1562function toRaw(observed) {
1563  const raw = observed && observed["__v_raw"];
1564  return raw ? toRaw(raw) : observed;
1565}
1566function markRaw(value) {
1567  if (!hasOwn$1(value, "__v_skip") && Object.isExtensible(value)) {
1568    def$1(value, "__v_skip", true);
1569  }
1570  return value;
1571}
1572const toReactive = (value) => isObject$3(value) ? reactive(value) : value;
1573const toReadonly = (value) => isObject$3(value) ? readonly(value) : value;
1574function isRef(r) {
1575  return r ? r["__v_isRef"] === true : false;
1576}
1577function ref(value) {
1578  return createRef(value, false);
1579}
1580function shallowRef(value) {
1581  return createRef(value, true);
1582}
1583function createRef(rawValue, shallow) {
1584  if (isRef(rawValue)) {
1585    return rawValue;
1586  }
1587  return new RefImpl(rawValue, shallow);
1588}
1589class RefImpl {
1590  constructor(value, isShallow2) {
1591    this.dep = new Dep();
1592    this["__v_isRef"] = true;
1593    this["__v_isShallow"] = false;
1594    this._rawValue = isShallow2 ? value : toRaw(value);
1595    this._value = isShallow2 ? value : toReactive(value);
1596    this["__v_isShallow"] = isShallow2;
1597  }
1598  get value() {
1599    if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
1600      this.dep.track({
1601        target: this,
1602        type: "get",
1603        key: "value"
1604      });
1605    } else {
1606      this.dep.track();
1607    }
1608    return this._value;
1609  }
1610  set value(newValue) {
1611    const oldValue = this._rawValue;
1612    const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
1613    newValue = useDirectValue ? newValue : toRaw(newValue);
1614    if (hasChanged(newValue, oldValue)) {
1615      this._rawValue = newValue;
1616      this._value = useDirectValue ? newValue : toReactive(newValue);
1617      if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
1618        this.dep.trigger({
1619          target: this,
1620          type: "set",
1621          key: "value",
1622          newValue,
1623          oldValue
1624        });
1625      } else {
1626        this.dep.trigger();
1627      }
1628    }
1629  }
1630}
1631function unref(ref2) {
1632  return isRef(ref2) ? ref2.value : ref2;
1633}
1634const shallowUnwrapHandlers = {
1635  get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)),
1636  set: (target, key, value, receiver) => {
1637    const oldValue = target[key];
1638    if (isRef(oldValue) && !isRef(value)) {
1639      oldValue.value = value;
1640      return true;
1641    } else {
1642      return Reflect.set(target, key, value, receiver);
1643    }
1644  }
1645};
1646function proxyRefs(objectWithRefs) {
1647  return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
1648}
1649function toRefs(object) {
1650  if (!!(define_process_env_default$8.NODE_ENV !== "production") && !isProxy(object)) {
1651    warn$3(`toRefs() expects a reactive object but received a plain one.`);
1652  }
1653  const ret = isArray$1(object) ? new Array(object.length) : {};
1654  for (const key in object) {
1655    ret[key] = propertyToRef(object, key);
1656  }
1657  return ret;
1658}
1659class ObjectRefImpl {
1660  constructor(_object, _key, _defaultValue) {
1661    this._object = _object;
1662    this._key = _key;
1663    this._defaultValue = _defaultValue;
1664    this["__v_isRef"] = true;
1665    this._value = void 0;
1666  }
1667  get value() {
1668    const val = this._object[this._key];
1669    return this._value = val === void 0 ? this._defaultValue : val;
1670  }
1671  set value(newVal) {
1672    this._object[this._key] = newVal;
1673  }
1674  get dep() {
1675    return getDepFromReactive(toRaw(this._object), this._key);
1676  }
1677}
1678class GetterRefImpl {
1679  constructor(_getter) {
1680    this._getter = _getter;
1681    this["__v_isRef"] = true;
1682    this["__v_isReadonly"] = true;
1683    this._value = void 0;
1684  }
1685  get value() {
1686    return this._value = this._getter();
1687  }
1688}
1689function toRef(source, key, defaultValue) {
1690  if (isRef(source)) {
1691    return source;
1692  } else if (isFunction$1(source)) {
1693    return new GetterRefImpl(source);
1694  } else if (isObject$3(source) && arguments.length > 1) {
1695    return propertyToRef(source, key, defaultValue);
1696  } else {
1697    return ref(source);
1698  }
1699}
1700function propertyToRef(source, key, defaultValue) {
1701  const val = source[key];
1702  return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
1703}
1704class ComputedRefImpl {

1798  if (isRef(source)) {
1799    getter = () => source.value;
1800    forceTrigger = isShallow(source);
1801  } else if (isReactive(source)) {
1802    getter = () => reactiveGetter(source);
1803    forceTrigger = true;
1804  } else if (isArray$1(source)) {
1805    isMultiSource = true;
1806    forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
1807    getter = () => source.map((s) => {
1808      if (isRef(s)) {
1809        return s.value;
1810      } else if (isReactive(s)) {
1811        return reactiveGetter(s);
1812      } else if (isFunction$1(s)) {
1813        return call ? call(s, 2) : s();
1814      } else {
1815        !!(define_process_env_default$8.NODE_ENV !== "production") && warnInvalidSource(s);
1816      }
1817    });
1818  } else if (isFunction$1(source)) {
1819    if (cb) {
1820      getter = call ? () => call(source, 2) : source;
1821    } else {
1822      getter = () => {
1823        if (cleanup) {
1824          pauseTracking();
1825          try {
1826            cleanup();
1827          } finally {
1828            resetTracking();
1829          }
1830        }
1831        const currentEffect = activeWatcher;
1832        activeWatcher = effect2;
1833        try {
1834          return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
1835        } finally {
1836          activeWatcher = currentEffect;
1837        }
1838      };
1839    }
1840  } else {
1841    getter = NOOP;
1842    !!(define_process_env_default$8.NODE_ENV !== "production") && warnInvalidSource(source);
1843  }
1844  if (cb && deep) {
1845    const baseGetter = getter;
1846    const depth = deep === true ? Infinity : deep;
1847    getter = () => traverse(baseGetter(), depth);
1848  }
1849  const scope = getCurrentScope();
1850  const watchHandle = () => {
1851    effect2.stop();
1852    if (scope && scope.active) {
1853      remove(scope.effects, effect2);
1854    }
1855  };
1856  if (once2 && cb) {
1857    const _cb = cb;
1858    cb = (...args) => {
1859      _cb(...args);
1860      watchHandle();
1861    };
1862  }
1863  let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
1864  const job = (immediateFirstRun) => {
1865    if (!(effect2.flags & 1) || !effect2.dirty && !immediateFirstRun) {
1866      return;
1867    }
1868    if (cb) {
1869      const newValue = effect2.run();
1870      if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
1871        if (cleanup) {
1872          cleanup();
1873        }
1874        const currentWatcher = activeWatcher;
1875        activeWatcher = effect2;
1876        try {
1877          const args = [
1878            newValue,
1879            // pass undefined as the old value when it's changed for the first time
1880            oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
1881            boundCleanup
1882          ];
1883          oldValue = newValue;
1884          call ? call(cb, 3, args) : (
1885            // @ts-expect-error
1886            cb(...args)
1887          );
1888        } finally {
1889          activeWatcher = currentWatcher;
1890        }
1891      }
1892    } else {
1893      effect2.run();
1894    }
1895  };
1896  if (augmentJob) {
1897    augmentJob(job);
1898  }
1899  effect2 = new ReactiveEffect(getter);
1900  effect2.scheduler = scheduler ? () => scheduler(job, false) : job;
1901  boundCleanup = (fn) => onWatcherCleanup(fn, false, effect2);
1902  cleanup = effect2.onStop = () => {
1903    const cleanups = cleanupMap.get(effect2);
1904    if (cleanups) {
1905      if (call) {
1906        call(cleanups, 4);
1907      } else {
1908        for (const cleanup2 of cleanups) cleanup2();
1909      }
1910      cleanupMap.delete(effect2);
1911    }
1912  };
1913  if (!!(define_process_env_default$8.NODE_ENV !== "production")) {
1914    effect2.onTrack = options.onTrack;
1915    effect2.onTrigger = options.onTrigger;
1916  }
1917  if (cb) {
1918    if (immediate) {
1919      job(true);
1920    } else {
1921      oldValue = effect2.run();
1922    }
1923  } else if (scheduler) {
1924    scheduler(job.bind(null, true), true);
1925  } else {
1926    effect2.run();
1927  }
1928  watchHandle.pause = effect2.pause.bind(effect2);
1929  watchHandle.resume = effect2.resume.bind(effect2);
1930  watchHandle.stop = watchHandle;
1931  return watchHandle;
1932}
1933function traverse(value, depth = Infinity, seen) {
1934  if (depth <= 0 || !isObject$3(value) || value["__v_skip"]) {
1935    return value;
1936  }

1937  seen = seen || /* @__PURE__ */ new Map();
1938  if ((seen.get(value) || 0) >= depth) {
1939    return value;
1940  }
1941  seen.set(value, depth);
1942  depth--;
1943  if (isRef(value)) {
1944    traverse(value.value, depth, seen);
1945  } else if (isArray$1(value)) {
1946    for (let i = 0; i < value.length; i++) {
1947      traverse(value[i], depth, seen);
1948    }
1949  } else if (isSet(value) || isMap(value)) {
1950    value.forEach((v) => {
1951      traverse(v, depth, seen);
1952    });
1953  } else if (isPlainObject$2(value)) {
1954    for (const key in value) {
1955      traverse(value[key], depth, seen);
1956    }
1957    for (const key of Object.getOwnPropertySymbols(value)) {
1958      if (Object.prototype.propertyIsEnumerable.call(value, key)) {
1959        traverse(value[key], depth, seen);
1960      }
1961    }
1962  }
1963  return value;
1964}
1965var define_process_env_default$7 = {};
1966const stack = [];
1967function pushWarningContext(vnode) {
1968  stack.push(vnode);
1969}
1970function popWarningContext() {
1971  stack.pop();
1972}
1973let isWarning = false;
1974function warn$1$1(msg, ...args) {
1975  if (isWarning) return;
1976  isWarning = true;
1977  pauseTracking();
1978  const instance = stack.length ? stack[stack.length - 1].component : null;
1979  const appWarnHandler = instance && instance.appContext.config.warnHandler;
1980  const trace = getComponentTrace();
1981  if (appWarnHandler) {
1982    callWithErrorHandling(
1983      appWarnHandler,
1984      instance,
1985      11,
1986      [
1987        // eslint-disable-next-line no-restricted-syntax
1988        msg + args.map((a) => {
1989          var _a2, _b;
1990          return (_b = (_a2 = a.toString) == null ? void 0 : _a2.call(a)) != null ? _b : JSON.stringify(a);
1991        }).join(""),
1992        instance && instance.proxy,
1993        trace.map(
1994          ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
1995        ).join("\n"),
1996        trace
1997      ]
1998    );
1999  } else {
2000    const warnArgs = [`[Vue warn]: ${msg}`, ...args];
2001    if (trace.length && // avoid spamming console during tests
2002    true) {
2003      warnArgs.push(`
2004`, ...formatTrace(trace));
2005    }
2006    console.warn(...warnArgs);
2007  }
2008  resetTracking();
2009  isWarning = false;
2010}
2011function getComponentTrace() {
2012  let currentVNode = stack[stack.length - 1];
2013  if (!currentVNode) {
2014    return [];
2015  }
2016  const normalizedStack = [];
2017  while (currentVNode) {
2018    const last = normalizedStack[0];
2019    if (last && last.vnode === currentVNode) {
2020      last.recurseCount++;
2021    } else {
2022      normalizedStack.push({
2023        vnode: currentVNode,
2024        recurseCount: 0
2025      });
2026    }
2027    const parentInstance = currentVNode.component && currentVNode.component.parent;
2028    currentVNode = parentInstance && parentInstance.vnode;
2029  }
2030  return normalizedStack;
2031}
2032function formatTrace(trace) {
2033  const logs = [];
2034  trace.forEach((entry, i) => {
2035    logs.push(...i === 0 ? [] : [`
2036`], ...formatTraceEntry(entry));
2037  });
2038  return logs;
2039}
2040function formatTraceEntry({ vnode, recurseCount }) {
2041  const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
2042  const isRoot = vnode.component ? vnode.component.parent == null : false;
2043  const open = ` at <${formatComponentName(
2044    vnode.component,
2045    vnode.type,
2046    isRoot
2047  )}`;
2048  const close2 = `>` + postfix;
2049  return vnode.props ? [open, ...formatProps(vnode.props), close2] : [open + close2];
2050}
2051function formatProps(props) {
2052  const res = [];
2053  const keys = Object.keys(props);
2054  keys.slice(0, 3).forEach((key) => {
2055    res.push(...formatProp(key, props[key]));
2056  });
2057  if (keys.length > 3) {
2058    res.push(` ...`);
2059  }
2060  return res;
2061}
2062function formatProp(key, value, raw) {
2063  if (isString$2(value)) {
2064    value = JSON.stringify(value);
2065    return raw ? value : [`${key}=${value}`];
2066  } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
2067    return raw ? value : [`${key}=${value}`];
2068  } else if (isRef(value)) {
2069    value = formatProp(key, toRaw(value.value), true);
2070    return raw ? value : [`${key}=Ref<`, value, `>`];
2071  } else if (isFunction$1(value)) {
2072    return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
2073  } else {
2074    value = toRaw(value);
2075    return raw ? value : [`${key}=`, value];
2076  }
2077}
2078const ErrorTypeStrings$1 = {
2079  ["sp"]: "serverPrefetch hook",
2080  ["bc"]: "beforeCreate hook",
2081  ["c"]: "created hook",
2082  ["bm"]: "beforeMount hook",
2083  ["m"]: "mounted hook",
2084  ["bu"]: "beforeUpdate hook",
2085  ["u"]: "updated",
2086  ["bum"]: "beforeUnmount hook",
2087  ["um"]: "unmounted hook",
2088  ["a"]: "activated hook",
2089  ["da"]: "deactivated hook",
2090  ["ec"]: "errorCaptured hook",
2091  ["rtc"]: "renderTracked hook",
2092  ["rtg"]: "renderTriggered hook",
2093  [0]: "setup function",
2094  [1]: "render function",
2095  [2]: "watcher getter",

2096  [3]: "watcher callback",
2097  [4]: "watcher cleanup function",
2098  [5]: "native event handler",
2099  [6]: "component event handler",
2100  [7]: "vnode hook",
2101  [8]: "directive hook",
2102  [9]: "transition hook",
2103  [10]: "app errorHandler",
2104  [11]: "app warnHandler",
2105  [12]: "ref function",
2106  [13]: "async component loader",
2107  [14]: "scheduler flush",
2108  [15]: "component update",
2109  [16]: "app unmount cleanup function"
2110};
2111function callWithErrorHandling(fn, instance, type, args) {
2112  try {
2113    return args ? fn(...args) : fn();
2114  } catch (err) {
2115    handleError(err, instance, type);
2116  }
2117}
2118function callWithAsyncErrorHandling(fn, instance, type, args) {
2119  if (isFunction$1(fn)) {
2120    const res = callWithErrorHandling(fn, instance, type, args);
2121    if (res && isPromise$2(res)) {
2122      res.catch((err) => {
2123        handleError(err, instance, type);
2124      });
2125    }
2126    return res;
2127  }
2128  if (isArray$1(fn)) {
2129    const values = [];
2130    for (let i = 0; i < fn.length; i++) {
2131      values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
2132    }
2133    return values;
2134  } else if (!!(define_process_env_default$7.NODE_ENV !== "production")) {
2135    warn$1$1(
2136      `Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`
2137    );
2138  }
2139}
2140function handleError(err, instance, type, throwInDev = true) {
2141  const contextVNode = instance ? instance.vnode : null;
2142  const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
2143  if (instance) {
2144    let cur = instance.parent;
2145    const exposedInstance = instance.proxy;
2146    const errorInfo = !!(define_process_env_default$7.NODE_ENV !== "production") ? ErrorTypeStrings$1[type] : `https://vuejs.org/error-reference/#runtime-${type}`;
2147    while (cur) {

2148      const errorCapturedHooks = cur.ec;
2149      if (errorCapturedHooks) {
2150        for (let i = 0; i < errorCapturedHooks.length; i++) {
2151          if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
2152            return;
2153          }
2154        }
2155      }
2156      cur = cur.parent;
2157    }
2158    if (errorHandler) {
2159      pauseTracking();
2160      callWithErrorHandling(errorHandler, null, 10, [
2161        err,
2162        exposedInstance,
2163        errorInfo
2164      ]);
2165      resetTracking();
2166      return;
2167    }
2168  }
2169  logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
2170}
2171function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
2172  if (!!(define_process_env_default$7.NODE_ENV !== "production")) {
2173    const info = ErrorTypeStrings$1[type];
2174    if (contextVNode) {
2175      pushWarningContext(contextVNode);
2176    }
2177    warn$1$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
2178    if (contextVNode) {
2179      popWarningContext();
2180    }
2181    if (throwInDev) {
2182      throw err;
2183    } else {
2184      console.error(err);
2185    }
2186  } else if (throwInProd) {
2187    throw err;
2188  } else {
2189    console.error(err);
2190  }
2191}
2192const queue = [];
2193let flushIndex = -1;
2194const pendingPostFlushCbs = [];
2195let activePostFlushCbs = null;
2196let postFlushIndex = 0;
2197const resolvedPromise = /* @__PURE__ */ Promise.resolve();
2198let currentFlushPromise = null;
2199const RECURSION_LIMIT = 100;
2200function nextTick(fn) {
2201  const p2 = currentFlushPromise || resolvedPromise;
2202  return fn ? p2.then(this ? fn.bind(this) : fn) : p2;
2203}
2204function findInsertionIndex(id) {
2205  let start = flushIndex + 1;
2206  let end = queue.length;
2207  while (start < end) {
2208    const middle = start + end >>> 1;
2209    const middleJob = queue[middle];
2210    const middleJobId = getId(middleJob);
2211    if (middleJobId < id || middleJobId === id && middleJob.flags & 2) {
2212      start = middle + 1;
2213    } else {
2214      end = middle;
2215    }
2216  }
2217  return start;
2218}
2219function queueJob(job) {
2220  if (!(job.flags & 1)) {
2221    const jobId = getId(job);
2222    const lastJob = queue[queue.length - 1];
2223    if (!lastJob || // fast path when the job id is larger than the tail
2224    !(job.flags & 2) && jobId >= getId(lastJob)) {
2225      queue.push(job);
2226    } else {
2227      queue.splice(findInsertionIndex(jobId), 0, job);
2228    }
2229    job.flags |= 1;
2230    queueFlush();
2231  }
2232}
2233function queueFlush() {
2234  if (!currentFlushPromise) {
2235    currentFlushPromise = resolvedPromise.then(flushJobs);
2236  }
2237}
2238function queuePostFlushCb(cb) {
2239  if (!isArray$1(cb)) {
2240    if (activePostFlushCbs && cb.id === -1) {
2241      activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
2242    } else if (!(cb.flags & 1)) {
2243      pendingPostFlushCbs.push(cb);
2244      cb.flags |= 1;
2245    }
2246  } else {
2247    pendingPostFlushCbs.push(...cb);
2248  }
2249  queueFlush();
2250}
2251function flushPreFlushCbs(instance, seen, i = flushIndex + 1) {
2252  if (!!(define_process_env_default$7.NODE_ENV !== "production")) {
2253    seen = seen || /* @__PURE__ */ new Map();
2254  }
2255  for (; i < queue.length; i++) {
2256    const cb = queue[i];
2257    if (cb && cb.flags & 2) {
2258      if (instance && cb.id !== instance.uid) {
2259        continue;
2260      }
2261      if (!!(define_process_env_default$7.NODE_ENV !== "production") && checkRecursiveUpdates(seen, cb)) {
2262        continue;
2263      }
2264      queue.splice(i, 1);
2265      i--;
2266      if (cb.flags & 4) {
2267        cb.flags &= -2;
2268      }
2269      cb();
2270      if (!(cb.flags & 4)) {
2271        cb.flags &= -2;
2272      }
2273    }
2274  }
2275}
2276function flushPostFlushCbs(seen) {
2277  if (pendingPostFlushCbs.length) {
2278    const deduped = [...new Set(pendingPostFlushCbs)].sort(
2279      (a, b) => getId(a) - getId(b)
2280    );
2281    pendingPostFlushCbs.length = 0;
2282    if (activePostFlushCbs) {
2283      activePostFlushCbs.push(...deduped);
2284      return;
2285    }
2286    activePostFlushCbs = deduped;
2287    if (!!(define_process_env_default$7.NODE_ENV !== "production")) {
2288      seen = seen || /* @__PURE__ */ new Map();
2289    }
2290    for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
2291      const cb = activePostFlushCbs[postFlushIndex];
2292      if (!!(define_process_env_default$7.NODE_ENV !== "production") && checkRecursiveUpdates(seen, cb)) {
2293        continue;
2294      }
2295      if (cb.flags & 4) {
2296        cb.flags &= -2;
2297      }
2298      if (!(cb.flags & 8)) cb();
2299      cb.flags &= -2;
2300    }
2301    activePostFlushCbs = null;
2302    postFlushIndex = 0;
2303  }
2304}
2305const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
2306function flushJobs(seen) {
2307  if (!!(define_process_env_default$7.NODE_ENV !== "production")) {

2308    seen = seen || /* @__PURE__ */ new Map();
2309  }
2310  const check = !!(define_process_env_default$7.NODE_ENV !== "production") ? (job) => checkRecursiveUpdates(seen, job) : NOOP;
2311  try {
2312    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
2313      const job = queue[flushIndex];
2314      if (job && !(job.flags & 8)) {
2315        if (!!(define_process_env_default$7.NODE_ENV !== "production") && check(job)) {
2316          continue;
2317        }
2318        if (job.flags & 4) {
2319          job.flags &= ~1;
2320        }
2321        callWithErrorHandling(
2322          job,
2323          job.i,
2324          job.i ? 15 : 14
2325        );
2326        if (!(job.flags & 4)) {
2327          job.flags &= ~1;
2328        }
2329      }
2330    }
2331  } finally {
2332    for (; flushIndex < queue.length; flushIndex++) {
2333      const job = queue[flushIndex];
2334      if (job) {
2335        job.flags &= -2;
2336      }
2337    }
2338    flushIndex = -1;
2339    queue.length = 0;
2340    flushPostFlushCbs(seen);
2341    currentFlushPromise = null;
2342    if (queue.length || pendingPostFlushCbs.length) {
2343      flushJobs(seen);
2344    }
2345  }
2346}
2347function checkRecursiveUpdates(seen, fn) {
2348  const count = seen.get(fn) || 0;
2349  if (count > RECURSION_LIMIT) {
2350    const instance = fn.i;
2351    const componentName = instance && getComponentName(instance.type);
2352    handleError(
2353      `Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`,
2354      null,
2355      10
2356    );
2357    return true;
2358  }
2359  seen.set(fn, count + 1);
2360  return false;
2361}
2362let isHmrUpdating = false;
2363const hmrDirtyComponents = /* @__PURE__ */ new Map();
2364if (!!(define_process_env_default$7.NODE_ENV !== "production")) {
2365  getGlobalThis$1().__VUE_HMR_RUNTIME__ = {
2366    createRecord: tryWrap(createRecord),
2367    rerender: tryWrap(rerender),
2368    reload: tryWrap(reload)
2369  };
2370}
2371const map = /* @__PURE__ */ new Map();
2372function registerHMR(instance) {
2373  const id = instance.type.__hmrId;
2374  let record = map.get(id);
2375  if (!record) {
2376    createRecord(id, instance.type);
2377    record = map.get(id);
2378  }
2379  record.instances.add(instance);
2380}
2381function unregisterHMR(instance) {
2382  map.get(instance.type.__hmrId).instances.delete(instance);
2383}
2384function createRecord(id, initialDef) {
2385  if (map.has(id)) {
2386    return false;
2387  }
2388  map.set(id, {
2389    initialDef: normalizeClassComponent(initialDef),
2390    instances: /* @__PURE__ */ new Set()
2391  });
2392  return true;
2393}
2394function normalizeClassComponent(component) {
2395  return isClassComponent(component) ? component.__vccOpts : component;
2396}
2397function rerender(id, newRender) {
2398  const record = map.get(id);
2399  if (!record) {
2400    return;
2401  }
2402  record.initialDef.render = newRender;
2403  [...record.instances].forEach((instance) => {
2404    if (newRender) {
2405      instance.render = newRender;
2406      normalizeClassComponent(instance.type).render = newRender;
2407    }
2408    instance.renderCache = [];
2409    isHmrUpdating = true;
2410    if (!(instance.job.flags & 8)) {
2411      instance.update();
2412    }
2413    isHmrUpdating = false;
2414  });
2415}
2416function reload(id, newComp) {
2417  const record = map.get(id);
2418  if (!record) return;
2419  newComp = normalizeClassComponent(newComp);
2420  updateComponentDef(record.initialDef, newComp);
2421  const instances = [...record.instances];
2422  for (let i = 0; i < instances.length; i++) {
2423    const instance = instances[i];
2424    const oldComp = normalizeClassComponent(instance.type);
2425    let dirtyInstances = hmrDirtyComponents.get(oldComp);
2426    if (!dirtyInstances) {
2427      if (oldComp !== record.initialDef) {
2428        updateComponentDef(oldComp, newComp);
2429      }
2430      hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
2431    }
2432    dirtyInstances.add(instance);
2433    instance.appContext.propsCache.delete(instance.type);
2434    instance.appContext.emitsCache.delete(instance.type);
2435    instance.appContext.optionsCache.delete(instance.type);
2436    if (instance.ceReload) {
2437      dirtyInstances.add(instance);
2438      instance.ceReload(newComp.styles);
2439      dirtyInstances.delete(instance);
2440    } else if (instance.parent) {
2441      queueJob(() => {
2442        if (!(instance.job.flags & 8)) {
2443          isHmrUpdating = true;
2444          instance.parent.update();
2445          isHmrUpdating = false;
2446          dirtyInstances.delete(instance);
2447        }
2448      });
2449    } else if (instance.appContext.reload) {
2450      instance.appContext.reload();
2451    } else if (typeof window !== "undefined") {
2452      window.location.reload();
2453    } else {
2454      console.warn(
2455        "[HMR] Root or manually mounted instance modified. Full reload required."
2456      );
2457    }
2458    if (instance.root.ce && instance !== instance.root) {
2459      instance.root.ce._removeChildStyle(oldComp);
2460    }
2461  }
2462  queuePostFlushCb(() => {
2463    hmrDirtyComponents.clear();
2464  });
2465}
2466function updateComponentDef(oldComp, newComp) {
2467  extend(oldComp, newComp);
2468  for (const key in oldComp) {
2469    if (key !== "__file" && !(key in newComp)) {
2470      delete oldComp[key];
2471    }
2472  }
2473}
2474function tryWrap(fn) {
2475  return (id, arg) => {
2476    try {
2477      return fn(id, arg);
2478    } catch (e) {
2479      console.error(e);
2480      console.warn(
2481        `[HMR] Something went wrong during Vue component hot-reload. Full reload required.`
2482      );
2483    }
2484  };
2485}
2486let devtools$1;
2487let buffer = [];
2488let devtoolsNotInstalled = false;
2489function emit$1(event, ...args) {
2490  if (devtools$1) {
2491    devtools$1.emit(event, ...args);
2492  } else if (!devtoolsNotInstalled) {
2493    buffer.push({ event, args });
2494  }
2495}
2496function setDevtoolsHook$1(hook, target) {
2497  var _a2, _b;
2498  devtools$1 = hook;
2499  if (devtools$1) {
2500    devtools$1.enabled = true;
2501    buffer.forEach(({ event, args }) => devtools$1.emit(event, ...args));
2502    buffer = [];
2503  } else if (
2504    // handle late devtools injection - only do this if we are in an actual
2505    // browser environment to avoid the timer handle stalling test runner exit
2506    // (#4815)
2507    typeof window !== "undefined" && // some envs mock window but not fully
2508    window.HTMLElement && // also exclude jsdom
2509    // eslint-disable-next-line no-restricted-syntax
2510    !((_b = (_a2 = window.navigator) == null ? void 0 : _a2.userAgent) == null ? void 0 : _b.includes("jsdom"))
2511  ) {
2512    const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
2513    replay.push((newHook) => {
2514      setDevtoolsHook$1(newHook, target);
2515    });
2516    setTimeout(() => {
2517      if (!devtools$1) {
2518        target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
2519        devtoolsNotInstalled = true;
2520        buffer = [];
2521      }
2522    }, 3e3);
2523  } else {
2524    devtoolsNotInstalled = true;
2525    buffer = [];
2526  }
2527}
2528function devtoolsInitApp(app, version2) {
2529  emit$1("app:init", app, version2, {
2530    Fragment,
2531    Text,
2532    Comment,
2533    Static
2534  });
2535}
2536function devtoolsUnmountApp(app) {
2537  emit$1("app:unmount", app);
2538}
2539const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook(
2540  "component:added"
2541  /* COMPONENT_ADDED */
2542);
2543const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook(
2544  "component:updated"
2545  /* COMPONENT_UPDATED */
2546);
2547const _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook(
2548  "component:removed"
2549  /* COMPONENT_REMOVED */
2550);
2551const devtoolsComponentRemoved = (component) => {
2552  if (devtools$1 && typeof devtools$1.cleanupBuffer === "function" && // remove the component if it wasn't buffered
2553  !devtools$1.cleanupBuffer(component)) {
2554    _devtoolsComponentRemoved(component);
2555  }
2556};
2557// @__NO_SIDE_EFFECTS__
2558function createDevtoolsComponentHook(hook) {
2559  return (component) => {
2560    emit$1(
2561      hook,
2562      component.appContext.app,
2563      component.uid,
2564      component.parent ? component.parent.uid : void 0,
2565      component
2566    );
2567  };
2568}
2569const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook(
2570  "perf:start"
2571  /* PERFORMANCE_START */
2572);
2573const devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook(
2574  "perf:end"
2575  /* PERFORMANCE_END */
2576);
2577function createDevtoolsPerformanceHook(hook) {
2578  return (component, type, time) => {
2579    emit$1(hook, component.appContext.app, component.uid, component, type, time);
2580  };
2581}
2582function devtoolsComponentEmit(component, event, params) {
2583  emit$1(
2584    "component:emit",
2585    component.appContext.app,
2586    component,
2587    event,
2588    params
2589  );
2590}
2591let currentRenderingInstance = null;
2592let currentScopeId = null;
2593function setCurrentRenderingInstance(instance) {
2594  const prev = currentRenderingInstance;
2595  currentRenderingInstance = instance;
2596  currentScopeId = instance && instance.type.__scopeId || null;
2597  return prev;
2598}
2599function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
2600  if (!ctx) return fn;
2601  if (fn._n) {
2602    return fn;
2603  }
2604  const renderFnWithContext = (...args) => {
2605    if (renderFnWithContext._d) {
2606      setBlockTracking(-1);
2607    }
2608    const prevInstance = setCurrentRenderingInstance(ctx);
2609    let res;
2610    try {
2611      res = fn(...args);
2612    } finally {
2613      setCurrentRenderingInstance(prevInstance);
2614      if (renderFnWithContext._d) {
2615        setBlockTracking(1);
2616      }
2617    }
2618    if (!!(define_process_env_default$7.NODE_ENV !== "production") || false) {
2619      devtoolsComponentUpdated(ctx);
2620    }
2621    return res;
2622  };
2623  renderFnWithContext._n = true;
2624  renderFnWithContext._c = true;
2625  renderFnWithContext._d = true;
2626  return renderFnWithContext;
2627}
2628function validateDirectiveName(name) {
2629  if (isBuiltInDirective(name)) {
2630    warn$1$1("Do not use built-in directive ids as custom directive id: " + name);
2631  }
2632}
2633function withDirectives(vnode, directives) {
2634  if (currentRenderingInstance === null) {
2635    !!(define_process_env_default$7.NODE_ENV !== "production") && warn$1$1(`withDirectives can only be used inside render functions.`);
2636    return vnode;
2637  }
2638  const instance = getComponentPublicInstance(currentRenderingInstance);
2639  const bindings = vnode.dirs || (vnode.dirs = []);
2640  for (let i = 0; i < directives.length; i++) {
2641    let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
2642    if (dir) {
2643      if (isFunction$1(dir)) {
2644        dir = {
2645          mounted: dir,
2646          updated: dir
2647        };
2648      }
2649      if (dir.deep) {
2650        traverse(value);
2651      }
2652      bindings.push({
2653        dir,
2654        instance,
2655        value,
2656        oldValue: void 0,
2657        arg,
2658        modifiers
2659      });
2660    }
2661  }
2662  return vnode;
2663}
2664function invokeDirectiveHook(vnode, prevVNode, instance, name) {
2665  const bindings = vnode.dirs;
2666  const oldBindings = prevVNode && prevVNode.dirs;
2667  for (let i = 0; i < bindings.length; i++) {
2668    const binding = bindings[i];
2669    if (oldBindings) {
2670      binding.oldValue = oldBindings[i].value;
2671    }
2672    let hook = binding.dir[name];
2673    if (hook) {
2674      pauseTracking();