https://event.kgi.com.tw/news/event/commonResources/js/vue-v3.js

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

128URI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error";
129  const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
130
131  const range = 2;
132  function generateCodeFrame(source, start = 0, end = source.length) {
133    let lines = source.split(/(\r?\n)/);
134    const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
135    lines = lines.filter((_, idx) => idx % 2 === 0);
136    let count = 0;
137    const res = [];
138    for (let i = 0; i < lines.length; i++) {
139      count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
140      if (count >= start) {
141        for (let j = i - range; j <= i + range || end > count; j++) {
142          if (j < 0 || j >= lines.length)
143            continue;
144          const line = j + 1;
145          res.push(
146            `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`
147          );
148          const lineLength = lines[j].length;
149          const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
150          if (j === i) {
151            const pad = start - (count - (lineLength + newLineSeqLength));
152            const length = Math.max(
153              1,
154              end > count ? lineLength - pad : end - start
155            );
156            res.push(`   |  ` + " ".repeat(pad) + "^".repeat(length));
157          } else if (j > i) {
158            if (end > count) {
159              const length = Math.max(Math.min(end - count, lineLength), 1);
160              res.push(`   |  ` + "^".repeat(length));
161            }
162            count += lineLength + newLineSeqLength;
163          }
164        }
165        break;
166      }
167    }
168    return res.join("\n");
169  }
170
171  function normalizeStyle(value) {
172    if (isArray(value)) {
173      const res = {};
174      for (let i = 0; i < value.length; i++) {
175        const item = value[i];
176        const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
177        if (normalized) {
178          for (const key in normalized) {
179            res[key] = normalized[key];
180          }
181        }
182      }
183      return res;
184    } else if (isString(value) || isObject(value)) {
185      return value;
186    }
187  }
188  const listDelimiterRE = /;(?![^(]*\))/g;
189  const propertyDelimiterRE = /:([^]+)/;
190  const styleCommentRE = /\/\*[^]*?\*\//g;
191  function parseStringStyle(cssText) {
192    const ret = {};
193    cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
194      if (item) {
195        const tmp = item.split(propertyDelimiterRE);
196        tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
197      }
198    });
199    return ret;
200  }
201  function stringifyStyle(styles) {
202    let ret = "";
203    if (!styles || isString(styles)) {
204      return ret;
205    }
206    for (const key in styles) {
207      const value = styles[key];
208      const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
209      if (isString(value) || typeof value === "number") {
210        ret += `${normalizedKey}:${value};`;
211      }
212    }
213    return ret;
214  }
215  function normalizeClass(value) {
216    let res = "";
217    if (isString(value)) {
218      res = value;
219    } else if (isArray(value)) {
220      for (let i = 0; i < value.length; i++) {
221        const normalized = normalizeClass(value[i]);
222        if (normalized) {
223          res += normalized + " ";
224        }
225      }
226    } else if (isObject(value)) {
227      for (const name in value) {
228        if (value[name]) {
229          res += name + " ";
230        }
231      }
232    }
233    return res.trim();
234  }
235  function normalizeProps(props) {
236    if (!props)
237      return null;
238    let { class: klass, style } = props;
239    if (klass && !isString(klass)) {
240      props.class = normalizeClass(klass);
241    }
242    if (style) {
243      props.style = normalizeStyle(style);
244    }
245    return props;
246  }
247
248  const 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";
249  const 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";
250  const 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";
251  const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";

443      }
444    }
445  }
446  function effectScope(detached) {
447    return new EffectScope(detached);
448  }
449  function recordEffectScope(effect, scope = activeEffectScope) {
450    if (scope && scope.active) {
451      scope.effects.push(effect);
452    }
453  }
454  function getCurrentScope() {
455    return activeEffectScope;
456  }
457  function onScopeDispose(fn) {
458    if (activeEffectScope) {
459      activeEffectScope.cleanups.push(fn);
460    } else {
461      warn$2(
462        `onScopeDispose() is called when there is no active effect scope to be associated with.`
463      );
464    }
465  }
466
467  let activeEffect;
468  class ReactiveEffect {
469    constructor(fn, trigger, scheduler, scope) {
470      this.fn = fn;
471      this.trigger = trigger;
472      this.scheduler = scheduler;
473      this.active = true;
474      this.deps = [];
475      /**
476       * @internal
477       */
478      this._dirtyLevel = 4;
479      /**
480       * @internal
481       */
482      this._trackId = 0;
483      /**
484       * @internal
485       */
486      this._runnings = 0;
487      /**
488       * @internal
489       */
490      this._shouldSchedule = false;
491      /**
492       * @internal
493       */
494      this._depsLength = 0;
495      recordEffectScope(this, scope);
496    }
497    get dirty() {
498      if (this._dirtyLevel === 2 || this._dirtyLevel === 3) {
499        this._dirtyLevel = 1;
500        pauseTracking();
501        for (let i = 0; i < this._depsLength; i++) {
502          const dep = this.deps[i];
503          if (dep.computed) {
504            triggerComputed(dep.computed);
505            if (this._dirtyLevel >= 4) {
506              break;
507            }
508          }
509        }
510        if (this._dirtyLevel === 1) {
511          this._dirtyLevel = 0;
512        }
513        resetTracking();
514      }
515      return this._dirtyLevel >= 4;
516    }
517    set dirty(v) {
518      this._dirtyLevel = v ? 4 : 0;
519    }
520    run() {
521      this._dirtyLevel = 0;
522      if (!this.active) {
523        return this.fn();
524      }
525      let lastShouldTrack = shouldTrack;
526      let lastEffect = activeEffect;
527      try {
528        shouldTrack = true;
529        activeEffect = this;
530        this._runnings++;
531        preCleanupEffect(this);
532        return this.fn();
533      } finally {
534        postCleanupEffect(this);
535        this._runnings--;
536        activeEffect = lastEffect;
537        shouldTrack = lastShouldTrack;
538      }
539    }
540    stop() {
541      var _a;
542      if (this.active) {
543        preCleanupEffect(this);
544        postCleanupEffect(this);
545        (_a = this.onStop) == null ? void 0 : _a.call(this);
546        this.active = false;
547      }
548    }
549  }
550  function triggerComputed(computed) {
551    return computed.value;
552  }
553  function preCleanupEffect(effect2) {
554    effect2._trackId++;
555    effect2._depsLength = 0;
556  }
557  function postCleanupEffect(effect2) {
558    if (effect2.deps.length > effect2._depsLength) {
559      for (let i = effect2._depsLength; i < effect2.deps.length; i++) {
560        cleanupDepEffect(effect2.deps[i], effect2);
561      }
562      effect2.deps.length = effect2._depsLength;
563    }
564  }
565  function cleanupDepEffect(dep, effect2) {
566    const trackId = dep.get(effect2);
567    if (trackId !== void 0 && effect2._trackId !== trackId) {
568      dep.delete(effect2);
569      if (dep.size === 0) {
570        dep.cleanup();
571      }
572    }
573  }
574  function effect(fn, options) {
575    if (fn.effect instanceof ReactiveEffect) {
576      fn = fn.effect.fn;
577    }
578    const _effect = new ReactiveEffect(fn, NOOP, () => {
579      if (_effect.dirty) {
580        _effect.run();
581      }
582    });
583    if (options) {
584      extend(_effect, options);
585      if (options.scope)
586        recordEffectScope(_effect, options.scope);
587    }
588    if (!options || !options.lazy) {
589      _effect.run();
590    }
591    const runner = _effect.run.bind(_effect);
592    runner.effect = _effect;
593    return runner;
594  }
595  function stop(runner) {
596    runner.effect.stop();
597  }
598  let shouldTrack = true;
599  let pauseScheduleStack = 0;
600  const trackStack = [];
601  function pauseTracking() {
602    trackStack.push(shouldTrack);
603    shouldTrack = false;
604  }
605  function resetTracking() {
606    const last = trackStack.pop();
607    shouldTrack = last === void 0 ? true : last;
608  }
609  function pauseScheduling() {
610    pauseScheduleStack++;
611  }
612  function resetScheduling() {
613    pauseScheduleStack--;
614    while (!pauseScheduleStack && queueEffectSchedulers.length) {
615      queueEffectSchedulers.shift()();
616    }
617  }
618  function trackEffect(effect2, dep, debuggerEventExtraInfo) {
619    var _a;
620    if (dep.get(effect2) !== effect2._trackId) {
621      dep.set(effect2, effect2._trackId);
622      const oldDep = effect2.deps[effect2._depsLength];
623      if (oldDep !== dep) {
624        if (oldDep) {
625          cleanupDepEffect(oldDep, effect2);
626        }
627        effect2.deps[effect2._depsLength++] = dep;
628      } else {
629        effect2._depsLength++;
630      }
631      {
632        (_a = effect2.onTrack) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));
633      }
634    }
635  }
636  const queueEffectSchedulers = [];
637  function triggerEffects(dep, dirtyLevel, debuggerEventExtraInfo) {
638    var _a;
639    pauseScheduling();
640    for (const effect2 of dep.keys()) {
641      let tracking;
642      if (effect2._dirtyLevel < dirtyLevel && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {
643        effect2._shouldSchedule || (effect2._shouldSchedule = effect2._dirtyLevel === 0);
644        effect2._dirtyLevel = dirtyLevel;
645      }
646      if (effect2._shouldSchedule && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {
647        {
648          (_a = effect2.onTrigger) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));
649        }
650        effect2.trigger();
651        if ((!effect2._runnings || effect2.allowRecurse) && effect2._dirtyLevel !== 2) {
652          effect2._shouldSchedule = false;
653          if (effect2.scheduler) {
654            queueEffectSchedulers.push(effect2.scheduler);
655          }
656        }
657      }
658    }
659    resetScheduling();
660  }
661
662  const createDep = (cleanup, computed) => {
663    const dep = /* @__PURE__ */ new Map();
664    dep.cleanup = cleanup;
665    dep.computed = computed;
666    return dep;
667  };
668
669  const targetMap = /* @__PURE__ */ new WeakMap();
670  const ITERATE_KEY = Symbol("iterate" );
671  const MAP_KEY_ITERATE_KEY = Symbol("Map key iterate" );
672  function track(target, type, key) {
673    if (shouldTrack && activeEffect) {
674      let depsMap = targetMap.get(target);
675      if (!depsMap) {
676        targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
677      }
678      let dep = depsMap.get(key);
679      if (!dep) {
680        depsMap.set(key, dep = createDep(() => depsMap.delete(key)));
681      }
682      trackEffect(
683        activeEffect,
684        dep,
685        {
686          target,
687          type,
688          key
689        } 
690      );
691    }
692  }
693  function trigger(target, type, key, newValue, oldValue, oldTarget) {
694    const depsMap = targetMap.get(target);
695    if (!depsMap) {
696      return;
697    }
698    let deps = [];
699    if (type === "clear") {
700      deps = [...depsMap.values()];
701    } else if (key === "length" && isArray(target)) {
702      const newLength = Number(newValue);
703      depsMap.forEach((dep, key2) => {
704        if (key2 === "length" || !isSymbol(key2) && key2 >= newLength) {
705          deps.push(dep);
706        }
707      });
708    } else {
709      if (key !== void 0) {
710        deps.push(depsMap.get(key));
711      }
712      switch (type) {
713        case "add":
714          if (!isArray(target)) {
715            deps.push(depsMap.get(ITERATE_KEY));
716            if (isMap(target)) {
717              deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
718            }
719          } else if (isIntegerKey(key)) {
720            deps.push(depsMap.get("length"));
721          }
722          break;
723        case "delete":
724          if (!isArray(target)) {
725            deps.push(depsMap.get(ITERATE_KEY));
726            if (isMap(target)) {
727              deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
728            }
729          }
730          break;
731        case "set":
732          if (isMap(target)) {
733            deps.push(depsMap.get(ITERATE_KEY));
734          }
735          break;
736      }
737    }
738    pauseScheduling();
739    for (const dep of deps) {
740      if (dep) {
741        triggerEffects(
742          dep,
743          4,
744          {
745            target,
746            type,
747            key,
748            newValue,
749            oldValue,
750            oldTarget
751          } 
752        );
753      }
754    }
755    resetScheduling();
756  }
757  function getDepFromReactive(object, key) {
758    var _a;
759    return (_a = targetMap.get(object)) == null ? void 0 : _a.get(key);
760  }
761
762  const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
763  const builtInSymbols = new Set(
764    /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
765  );
766  const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
767  function createArrayInstrumentations() {
768    const instrumentations = {};
769    ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
770      instrumentations[key] = function(...args) {
771        const arr = toRaw(this);
772        for (let i = 0, l = this.length; i < l; i++) {
773          track(arr, "get", i + "");
774        }
775        const res = arr[key](...args);
776        if (res === -1 || res === false) {
777          return arr[key](...args.map(toRaw));
778        } else {
779          return res;
780        }
781      };
782    });
783    ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
784      instrumentations[key] = function(...args) {
785        pauseTracking();
786        pauseScheduling();
787        const res = toRaw(this)[key].apply(this, args);
788        resetScheduling();
789        resetTracking();
790        return res;
791      };
792    });
793    return instrumentations;
794  }
795  function hasOwnProperty(key) {
796    const obj = toRaw(this);
797    track(obj, "has", key);
798    return obj.hasOwnProperty(key);
799  }
800  class BaseReactiveHandler {
801    constructor(_isReadonly = false, _isShallow = false) {
802      this._isReadonly = _isReadonly;
803      this._isShallow = _isShallow;
804    }
805    get(target, key, receiver) {
806      const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
807      if (key === "__v_isReactive") {
808        return !isReadonly2;
809      } else if (key === "__v_isReadonly") {
810        return isReadonly2;
811      } else if (key === "__v_isShallow") {
812        return isShallow2;
813      } else if (key === "__v_raw") {
814        if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
815        // this means the reciever is a user proxy of the reactive proxy
816        Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
817          return target;
818        }
819        return;
820      }
821      const targetIsArray = isArray(target);
822      if (!isReadonly2) {
823        if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
824          return Reflect.get(arrayInstrumentations, key, receiver);
825        }
826        if (key === "hasOwnProperty") {
827          return hasOwnProperty;
828        }
829      }
830      const res = Reflect.get(target, key, receiver);
831      if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
832        return res;
833      }
834      if (!isReadonly2) {
835        track(target, "get", key);
836      }
837      if (isShallow2) {
838        return res;
839      }
840      if (isRef(res)) {
841        return targetIsArray && isIntegerKey(key) ? res : res.value;
842      }
843      if (isObject(res)) {
844        return isReadonly2 ? readonly(res) : reactive(res);
845      }
846      return res;
847    }
848  }
849  class MutableReactiveHandler extends BaseReactiveHandler {
850    constructor(isShallow2 = false) {
851      super(false, isShallow2);
852    }
853    set(target, key, value, receiver) {
854      let oldValue = target[key];
855      if (!this._isShallow) {
856        const isOldValueReadonly = isReadonly(oldValue);
857        if (!isShallow(value) && !isReadonly(value)) {
858          oldValue = toRaw(oldValue);
859          value = toRaw(value);
860        }
861        if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
862          if (isOldValueReadonly) {
863            return false;
864          } else {
865            oldValue.value = value;
866            return true;
867          }
868        }
869      }
870      const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
871      const result = Reflect.set(target, key, value, receiver);
872      if (target === toRaw(receiver)) {
873        if (!hadKey) {
874          trigger(target, "add", key, value);
875        } else if (hasChanged(value, oldValue)) {
876          trigger(target, "set", key, value, oldValue);
877        }
878      }
879      return result;
880    }
881    deleteProperty(target, key) {
882      const hadKey = hasOwn(target, key);
883      const oldValue = target[key];
884      const result = Reflect.deleteProperty(target, key);
885      if (result && hadKey) {
886        trigger(target, "delete", key, void 0, oldValue);
887      }
888      return result;
889    }
890    has(target, key) {
891      const result = Reflect.has(target, key);
892      if (!isSymbol(key) || !builtInSymbols.has(key)) {
893        track(target, "has", key);
894      }
895      return result;
896    }
897    ownKeys(target) {
898      track(
899        target,
900        "iterate",
901        isArray(target) ? "length" : ITERATE_KEY
902      );
903      return Reflect.ownKeys(target);
904    }
905  }
906  class ReadonlyReactiveHandler extends BaseReactiveHandler {
907    constructor(isShallow2 = false) {
908      super(true, isShallow2);
909    }
910    set(target, key) {
911      {
912        warn$2(
913          `Set operation on key "${String(key)}" failed: target is readonly.`,
914          target
915        );
916      }
917      return true;
918    }
919    deleteProperty(target, key) {
920      {
921        warn$2(
922          `Delete operation on key "${String(key)}" failed: target is readonly.`,
923          target
924        );
925      }
926      return true;
927    }
928  }
929  const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
930  const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
931  const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(
932    true
933  );
934  const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
935
936  const toShallow = (value) => value;
937  const getProto = (v) => Reflect.getPrototypeOf(v);
938  function get(target, key, isReadonly = false, isShallow = false) {
939    target = target["__v_raw"];
940    const rawTarget = toRaw(target);
941    const rawKey = toRaw(key);
942    if (!isReadonly) {
943      if (hasChanged(key, rawKey)) {
944        track(rawTarget, "get", key);
945      }
946      track(rawTarget, "get", rawKey);
947    }
948    const { has: has2 } = getProto(rawTarget);
949    const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
950    if (has2.call(rawTarget, key)) {
951      return wrap(target.get(key));
952    } else if (has2.call(rawTarget, rawKey)) {
953      return wrap(target.get(rawKey));
954    } else if (target !== rawTarget) {
955      target.get(key);
956    }
957  }
958  function has(key, isReadonly = false) {
959    const target = this["__v_raw"];
960    const rawTarget = toRaw(target);
961    const rawKey = toRaw(key);
962    if (!isReadonly) {
963      if (hasChanged(key, rawKey)) {
964        track(rawTarget, "has", key);
965      }
966      track(rawTarget, "has", rawKey);
967    }
968    return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
969  }
970  function size(target, isReadonly = false) {
971    target = target["__v_raw"];
972    !isReadonly && track(toRaw(target), "iterate", ITERATE_KEY);
973    return Reflect.get(target, "size", target);
974  }
975  function add(value) {
976    value = toRaw(value);
977    const target = toRaw(this);
978    const proto = getProto(target);
979    const hadKey = proto.has.call(target, value);
980    if (!hadKey) {
981      target.add(value);
982      trigger(target, "add", value, value);
983    }
984    return this;
985  }
986  function set(key, value) {
987    value = toRaw(value);
988    const target = toRaw(this);
989    const { has: has2, get: get2 } = getProto(target);
990    let hadKey = has2.call(target, key);
991    if (!hadKey) {
992      key = toRaw(key);
993      hadKey = has2.call(target, key);
994    } else {
995      checkIdentityKeys(target, has2, key);
996    }
997    const oldValue = get2.call(target, key);
998    target.set(key, value);
999    if (!hadKey) {
1000      trigger(target, "add", key, value);
1001    } else if (hasChanged(value, oldValue)) {
1002      trigger(target, "set", key, value, oldValue);
1003    }
1004    return this;
1005  }
1006  function deleteEntry(key) {
1007    const target = toRaw(this);
1008    const { has: has2, get: get2 } = getProto(target);
1009    let hadKey = has2.call(target, key);
1010    if (!hadKey) {
1011      key = toRaw(key);
1012      hadKey = has2.call(target, key);
1013    } else {
1014      checkIdentityKeys(target, has2, key);
1015    }
1016    const oldValue = get2 ? get2.call(target, key) : void 0;
1017    const result = target.delete(key);
1018    if (hadKey) {
1019      trigger(target, "delete", key, void 0, oldValue);
1020    }
1021    return result;
1022  }
1023  function clear() {
1024    const target = toRaw(this);
1025    const hadItems = target.size !== 0;
1026    const oldTarget = isMap(target) ? new Map(target) : new Set(target) ;
1027    const result = target.clear();
1028    if (hadItems) {
1029      trigger(target, "clear", void 0, void 0, oldTarget);
1030    }
1031    return result;
1032  }
1033  function createForEach(isReadonly, isShallow) {
1034    return function forEach(callback, thisArg) {
1035      const observed = this;
1036      const target = observed["__v_raw"];
1037      const rawTarget = toRaw(target);
1038      const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
1039      !isReadonly && track(rawTarget, "iterate", ITERATE_KEY);
1040      return target.forEach((value, key) => {
1041        return callback.call(thisArg, wrap(value), wrap(key), observed);
1042      });
1043    };
1044  }
1045  function createIterableMethod(method, isReadonly, isShallow) {
1046    return function(...args) {
1047      const target = this["__v_raw"];
1048      const rawTarget = toRaw(target);
1049      const targetIsMap = isMap(rawTarget);
1050      const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
1051      const isKeyOnly = method === "keys" && targetIsMap;
1052      const innerIterator = target[method](...args);
1053      const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
1054      !isReadonly && track(
1055        rawTarget,
1056        "iterate",
1057        isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
1058      );
1059      return {
1060        // iterator protocol
1061        next() {
1062          const { value, done } = innerIterator.next();
1063          return done ? { value, done } : {
1064            value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
1065            done
1066          };
1067        },
1068        // iterable protocol
1069        [Symbol.iterator]() {
1070          return this;
1071        }
1072      };
1073    };
1074  }
1075  function createReadonlyMethod(type) {
1076    return function(...args) {
1077      {
1078        const key = args[0] ? `on key "${args[0]}" ` : ``;
1079        warn$2(
1080          `${capitalize(type)} operation ${key}failed: target is readonly.`,
1081          toRaw(this)
1082        );
1083      }
1084      return type === "delete" ? false : type === "clear" ? void 0 : this;
1085    };
1086  }
1087  function createInstrumentations() {
1088    const mutableInstrumentations2 = {
1089      get(key) {
1090        return get(this, key);
1091      },
1092      get size() {
1093        return size(this);
1094      },
1095      has,
1096      add,
1097      set,
1098      delete: deleteEntry,
1099      clear,
1100      forEach: createForEach(false, false)
1101    };
1102    const shallowInstrumentations2 = {
1103      get(key) {
1104        return get(this, key, false, true);
1105      },
1106      get size() {
1107        return size(this);
1108      },
1109      has,
1110      add,
1111      set,
1112      delete: deleteEntry,
1113      clear,
1114      forEach: createForEach(false, true)
1115    };
1116    const readonlyInstrumentations2 = {
1117      get(key) {
1118        return get(this, key, true);
1119      },
1120      get size() {
1121        return size(this, true);
1122      },
1123      has(key) {
1124        return has.call(this, key, true);
1125      },
1126      add: createReadonlyMethod("add"),
1127      set: createReadonlyMethod("set"),
1128      delete: createReadonlyMethod("delete"),
1129      clear: createReadonlyMethod("clear"),
1130      forEach: createForEach(true, false)
1131    };
1132    const shallowReadonlyInstrumentations2 = {
1133      get(key) {
1134        return get(this, key, true, true);
1135      },
1136      get size() {
1137        return size(this, true);
1138      },
1139      has(key) {
1140        return has.call(this, key, true);
1141      },
1142      add: createReadonlyMethod("add"),
1143      set: createReadonlyMethod("set"),
1144      delete: createReadonlyMethod("delete"),
1145      clear: createReadonlyMethod("clear"),
1146      forEach: createForEach(true, true)
1147    };
1148    const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
1149    iteratorMethods.forEach((method) => {
1150      mutableInstrumentations2[method] = createIterableMethod(
1151        method,
1152        false,
1153        false
1154      );
1155      readonlyInstrumentations2[method] = createIterableMethod(
1156        method,
1157        true,
1158        false
1159      );
1160      shallowInstrumentations2[method] = createIterableMethod(
1161        method,
1162        false,
1163        true
1164      );
1165      shallowReadonlyInstrumentations2[method] = createIterableMethod(
1166        method,
1167        true,
1168        true
1169      );
1170    });
1171    return [
1172      mutableInstrumentations2,
1173      readonlyInstrumentations2,
1174      shallowInstrumentations2,
1175      shallowReadonlyInstrumentations2
1176    ];
1177  }
1178  const [
1179    mutableInstrumentations,
1180    readonlyInstrumentations,
1181    shallowInstrumentations,
1182    shallowReadonlyInstrumentations
1183  ] = /* @__PURE__ */ createInstrumentations();
1184  function createInstrumentationGetter(isReadonly, shallow) {
1185    const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
1186    return (target, key, receiver) => {
1187      if (key === "__v_isReactive") {
1188        return !isReadonly;
1189      } else if (key === "__v_isReadonly") {
1190        return isReadonly;
1191      } else if (key === "__v_raw") {
1192        return target;
1193      }
1194      return Reflect.get(
1195        hasOwn(instrumentations, key) && key in target ? instrumentations : target,
1196        key,
1197        receiver
1198      );
1199    };
1200  }
1201  const mutableCollectionHandlers = {
1202    get: /* @__PURE__ */ createInstrumentationGetter(false, false)
1203  };
1204  const shallowCollectionHandlers = {
1205    get: /* @__PURE__ */ createInstrumentationGetter(false, true)
1206  };
1207  const readonlyCollectionHandlers = {
1208    get: /* @__PURE__ */ createInstrumentationGetter(true, false)
1209  };
1210  const shallowReadonlyCollectionHandlers = {
1211    get: /* @__PURE__ */ createInstrumentationGetter(true, true)
1212  };
1213  function checkIdentityKeys(target, has2, key) {
1214    const rawKey = toRaw(key);
1215    if (rawKey !== key && has2.call(target, rawKey)) {
1216      const type = toRawType(target);
1217      warn$2(
1218        `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.`
1219      );
1220    }
1221  }
1222
1223  const reactiveMap = /* @__PURE__ */ new WeakMap();
1224  const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
1225  const readonlyMap = /* @__PURE__ */ new WeakMap();
1226  const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
1227  function targetTypeMap(rawType) {
1228    switch (rawType) {
1229      case "Object":
1230      case "Array":
1231        return 1 /* COMMON */;
1232      case "Map":
1233      case "Set":
1234      case "WeakMap":
1235      case "WeakSet":
1236        return 2 /* COLLECTION */;
1237      default:
1238        return 0 /* INVALID */;
1239    }
1240  }
1241  function getTargetType(value) {
1242    return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap(toRawType(value));
1243  }
1244  function reactive(target) {
1245    if (isReadonly(target)) {
1246      return target;
1247    }
1248    return createReactiveObject(
1249      target,
1250      false,
1251      mutableHandlers,
1252      mutableCollectionHandlers,
1253      reactiveMap
1254    );
1255  }
1256  function shallowReactive(target) {
1257    return createReactiveObject(
1258      target,
1259      false,
1260      shallowReactiveHandlers,
1261      shallowCollectionHandlers,
1262      shallowReactiveMap
1263    );
1264  }
1265  function readonly(target) {
1266    return createReactiveObject(
1267      target,
1268      true,
1269      readonlyHandlers,
1270      readonlyCollectionHandlers,
1271      readonlyMap
1272    );
1273  }
1274  function shallowReadonly(target) {
1275    return createReactiveObject(
1276      target,
1277      true,
1278      shallowReadonlyHandlers,
1279      shallowReadonlyCollectionHandlers,
1280      shallowReadonlyMap
1281    );
1282  }
1283  function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
1284    if (!isObject(target)) {
1285      {
1286        warn$2(`value cannot be made reactive: ${String(target)}`);
1287      }
1288      return target;
1289    }
1290    if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
1291      return target;
1292    }
1293    const existingProxy = proxyMap.get(target);
1294    if (existingProxy) {
1295      return existingProxy;
1296    }
1297    const targetType = getTargetType(target);
1298    if (targetType === 0 /* INVALID */) {
1299      return target;
1300    }
1301    const proxy = new Proxy(
1302      target,
1303      targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers
1304    );
1305    proxyMap.set(target, proxy);
1306    return proxy;
1307  }
1308  function isReactive(value) {
1309    if (isReadonly(value)) {
1310      return isReactive(value["__v_raw"]);
1311    }
1312    return !!(value && value["__v_isReactive"]);
1313  }
1314  function isReadonly(value) {
1315    return !!(value && value["__v_isReadonly"]);
1316  }
1317  function isShallow(value) {
1318    return !!(value && value["__v_isShallow"]);
1319  }
1320  function isProxy(value) {
1321    return isReactive(value) || isReadonly(value);
1322  }
1323  function toRaw(observed) {
1324    const raw = observed && observed["__v_raw"];
1325    return raw ? toRaw(raw) : observed;
1326  }
1327  function markRaw(value) {
1328    if (Object.isExtensible(value)) {
1329      def(value, "__v_skip", true);
1330    }
1331    return value;
1332  }
1333  const toReactive = (value) => isObject(value) ? reactive(value) : value;
1334  const toReadonly = (value) => isObject(value) ? readonly(value) : value;
1335
1336  const COMPUTED_SIDE_EFFECT_WARN = `Computed is still dirty after getter evaluation, likely because a computed is mutating its own dependency in its getter. State mutations in computed getters should be avoided.  Check the docs for more details: https://vuejs.org/guide/essentials/computed.html#getters-should-be-side-effect-free`;
1337  class ComputedRefImpl {
1338    constructor(getter, _setter, isReadonly, isSSR) {
1339      this.getter = getter;
1340      this._setter = _setter;
1341      this.dep = void 0;
1342      this.__v_isRef = true;
1343      this["__v_isReadonly"] = false;
1344      this.effect = new ReactiveEffect(
1345        () => getter(this._value),
1346        () => triggerRefValue(
1347          this,
1348          this.effect._dirtyLevel === 2 ? 2 : 3
1349        )
1350      );
1351      this.effect.computed = this;
1352      this.effect.active = this._cacheable = !isSSR;
1353      this["__v_isReadonly"] = isReadonly;
1354    }
1355    get value() {
1356      const self = toRaw(this);
1357      if ((!self._cacheable || self.effect.dirty) && hasChanged(self._value, self._value = self.effect.run())) {
1358        triggerRefValue(self, 4);
1359      }
1360      trackRefValue(self);
1361      if (self.effect._dirtyLevel >= 2) {
1362        if (this._warnRecursive) {
1363          warn$2(COMPUTED_SIDE_EFFECT_WARN, `
1364
1365getter: `, this.getter);
1366        }
1367        triggerRefValue(self, 2);
1368      }
1369      return self._value;
1370    }
1371    set value(newValue) {
1372      this._setter(newValue);
1373    }
1374    // #region polyfill _dirty for backward compatibility third party code for Vue <= 3.3.x
1375    get _dirty() {
1376      return this.effect.dirty;
1377    }
1378    set _dirty(v) {
1379      this.effect.dirty = v;
1380    }
1381    // #endregion
1382  }
1383  function computed$1(getterOrOptions, debugOptions, isSSR = false) {
1384    let getter;
1385    let setter;
1386    const onlyGetter = isFunction(getterOrOptions);
1387    if (onlyGetter) {
1388      getter = getterOrOptions;
1389      setter = () => {
1390        warn$2("Write operation failed: computed value is readonly");
1391      } ;
1392    } else {
1393      getter = getterOrOptions.get;
1394      setter = getterOrOptions.set;
1395    }
1396    const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
1397    if (debugOptions && !isSSR) {
1398      cRef.effect.onTrack = debugOptions.onTrack;
1399      cRef.effect.onTrigger = debugOptions.onTrigger;
1400    }
1401    return cRef;
1402  }
1403
1404  function trackRefValue(ref2) {
1405    var _a;
1406    if (shouldTrack && activeEffect) {
1407      ref2 = toRaw(ref2);
1408      trackEffect(
1409        activeEffect,
1410        (_a = ref2.dep) != null ? _a : ref2.dep = createDep(
1411          () => ref2.dep = void 0,
1412          ref2 instanceof ComputedRefImpl ? ref2 : void 0
1413        ),
1414        {
1415          target: ref2,
1416          type: "get",
1417          key: "value"
1418        } 
1419      );
1420    }
1421  }
1422  function triggerRefValue(ref2, dirtyLevel = 4, newVal) {
1423    ref2 = toRaw(ref2);
1424    const dep = ref2.dep;
1425    if (dep) {
1426      triggerEffects(
1427        dep,
1428        dirtyLevel,
1429        {
1430          target: ref2,
1431          type: "set",
1432          key: "value",
1433          newValue: newVal
1434        } 
1435      );
1436    }
1437  }
1438  function isRef(r) {
1439    return !!(r && r.__v_isRef === true);
1440  }
1441  function ref(value) {
1442    return createRef(value, false);
1443  }
1444  function shallowRef(value) {
1445    return createRef(value, true);
1446  }
1447  function createRef(rawValue, shallow) {
1448    if (isRef(rawValue)) {
1449      return rawValue;
1450    }
1451    return new RefImpl(rawValue, shallow);
1452  }
1453  class RefImpl {
1454    constructor(value, __v_isShallow) {
1455      this.__v_isShallow = __v_isShallow;
1456      this.dep = void 0;
1457      this.__v_isRef = true;
1458      this._rawValue = __v_isShallow ? value : toRaw(value);
1459      this._value = __v_isShallow ? value : toReactive(value);
1460    }
1461    get value() {
1462      trackRefValue(this);
1463      return this._value;
1464    }
1465    set value(newVal) {
1466      const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
1467      newVal = useDirectValue ? newVal : toRaw(newVal);
1468      if (hasChanged(newVal, this._rawValue)) {
1469        this._rawValue = newVal;
1470        this._value = useDirectValue ? newVal : toReactive(newVal);
1471        triggerRefValue(this, 4, newVal);
1472      }
1473    }
1474  }
1475  function triggerRef(ref2) {
1476    triggerRefValue(ref2, 4, ref2.value );
1477  }
1478  function unref(ref2) {
1479    return isRef(ref2) ? ref2.value : ref2;
1480  }
1481  function toValue(source) {
1482    return isFunction(source) ? source() : unref(source);
1483  }
1484  const shallowUnwrapHandlers = {
1485    get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
1486    set: (target, key, value, receiver) => {
1487      const oldValue = target[key];
1488      if (isRef(oldValue) && !isRef(value)) {
1489        oldValue.value = value;
1490        return true;
1491      } else {
1492        return Reflect.set(target, key, value, receiver);
1493      }
1494    }
1495  };
1496  function proxyRefs(objectWithRefs) {
1497    return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
1498  }
1499  class CustomRefImpl {
1500    constructor(factory) {
1501      this.dep = void 0;
1502      this.__v_isRef = true;
1503      const { get, set } = factory(
1504        () => trackRefValue(this),
1505        () => triggerRefValue(this)
1506      );
1507      this._get = get;
1508      this._set = set;
1509    }
1510    get value() {
1511      return this._get();
1512    }
1513    set value(newVal) {
1514      this._set(newVal);
1515    }
1516  }
1517  function customRef(factory) {
1518    return new CustomRefImpl(factory);
1519  }
1520  function toRefs(object) {
1521    if (!isProxy(object)) {
1522      warn$2(`toRefs() expects a reactive object but received a plain one.`);
1523    }
1524    const ret = isArray(object) ? new Array(object.length) : {};
1525    for (const key in object) {
1526      ret[key] = propertyToRef(object, key);
1527    }
1528    return ret;
1529  }
1530  class ObjectRefImpl {
1531    constructor(_object, _key, _defaultValue) {
1532      this._object = _object;
1533      this._key = _key;
1534      this._defaultValue = _defaultValue;
1535      this.__v_isRef = true;
1536    }
1537    get value() {
1538      const val = this._object[this._key];
1539      return val === void 0 ? this._defaultValue : val;
1540    }
1541    set value(newVal) {
1542      this._object[this._key] = newVal;
1543    }
1544    get dep() {
1545      return getDepFromReactive(toRaw(this._object), this._key);
1546    }
1547  }
1548  class GetterRefImpl {
1549    constructor(_getter) {
1550      this._getter = _getter;
1551      this.__v_isRef = true;
1552      this.__v_isReadonly = true;
1553    }
1554    get value() {
1555      return this._getter();
1556    }
1557  }
1558  function toRef(source, key, defaultValue) {
1559    if (isRef(source)) {
1560      return source;
1561    } else if (isFunction(source)) {
1562      return new GetterRefImpl(source);
1563    } else if (isObject(source) && arguments.length > 1) {
1564      return propertyToRef(source, key, defaultValue);
1565    } else {
1566      return ref(source);
1567    }
1568  }
1569  function propertyToRef(source, key, defaultValue) {
1570    const val = source[key];
1571    return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
1572  }
1573
1574  const TrackOpTypes = {
1575    "GET": "get",
1576    "HAS": "has",
1577    "ITERATE": "iterate"
1578  };
1579  const TriggerOpTypes = {
1580    "SET": "set",
1581    "ADD": "add",

1582    "DELETE": "delete",
1583    "CLEAR": "clear"
1584  };
1585
1586  const stack$1 = [];
1587  function pushWarningContext(vnode) {
1588    stack$1.push(vnode);
1589  }
1590  function popWarningContext() {
1591    stack$1.pop();
1592  }
1593  function warn$1(msg, ...args) {
1594    pauseTracking();
1595    const instance = stack$1.length ? stack$1[stack$1.length - 1].component : null;
1596    const appWarnHandler = instance && instance.appContext.config.warnHandler;
1597    const trace = getComponentTrace();
1598    if (appWarnHandler) {
1599      callWithErrorHandling(
1600        appWarnHandler,
1601        instance,
1602        11,
1603        [
1604          msg + args.map((a) => {
1605            var _a, _b;
1606            return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
1607          }).join(""),
1608          instance && instance.proxy,
1609          trace.map(
1610            ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
1611          ).join("\n"),
1612          trace
1613        ]
1614      );
1615    } else {
1616      const warnArgs = [`[Vue warn]: ${msg}`, ...args];
1617      if (trace.length && // avoid spamming console during tests
1618      true) {
1619        warnArgs.push(`
1620`, ...formatTrace(trace));
1621      }
1622      console.warn(...warnArgs);
1623    }
1624    resetTracking();
1625  }
1626  function getComponentTrace() {
1627    let currentVNode = stack$1[stack$1.length - 1];
1628    if (!currentVNode) {
1629      return [];
1630    }
1631    const normalizedStack = [];
1632    while (currentVNode) {
1633      const last = normalizedStack[0];
1634      if (last && last.vnode === currentVNode) {
1635        last.recurseCount++;
1636      } else {
1637        normalizedStack.push({
1638          vnode: currentVNode,
1639          recurseCount: 0
1640        });
1641      }
1642      const parentInstance = currentVNode.component && currentVNode.component.parent;
1643      currentVNode = parentInstance && parentInstance.vnode;
1644    }
1645    return normalizedStack;
1646  }
1647  function formatTrace(trace) {
1648    const logs = [];
1649    trace.forEach((entry, i) => {
1650      logs.push(...i === 0 ? [] : [`
1651`], ...formatTraceEntry(entry));
1652    });
1653    return logs;
1654  }
1655  function formatTraceEntry({ vnode, recurseCount }) {
1656    const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
1657    const isRoot = vnode.component ? vnode.component.parent == null : false;
1658    const open = ` at <${formatComponentName(
1659    vnode.component,
1660    vnode.type,
1661    isRoot
1662  )}`;
1663    const close = `>` + postfix;
1664    return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
1665  }
1666  function formatProps(props) {
1667    const res = [];
1668    const keys = Object.keys(props);
1669    keys.slice(0, 3).forEach((key) => {
1670      res.push(...formatProp(key, props[key]));
1671    });
1672    if (keys.length > 3) {
1673      res.push(` ...`);
1674    }
1675    return res;
1676  }
1677  function formatProp(key, value, raw) {
1678    if (isString(value)) {
1679      value = JSON.stringify(value);
1680      return raw ? value : [`${key}=${value}`];
1681    } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
1682      return raw ? value : [`${key}=${value}`];
1683    } else if (isRef(value)) {
1684      value = formatProp(key, toRaw(value.value), true);
1685      return raw ? value : [`${key}=Ref<`, value, `>`];
1686    } else if (isFunction(value)) {
1687      return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
1688    } else {
1689      value = toRaw(value);
1690      return raw ? value : [`${key}=`, value];
1691    }
1692  }
1693  function assertNumber(val, type) {
1694    if (val === void 0) {
1695      return;
1696    } else if (typeof val !== "number") {
1697      warn$1(`${type} is not a valid number - got ${JSON.stringify(val)}.`);
1698    } else if (isNaN(val)) {
1699      warn$1(`${type} is NaN - the duration expression might be incorrect.`);
1700    }
1701  }
1702
1703  const ErrorCodes = {
1704    "SETUP_FUNCTION": 0,
1705    "0": "SETUP_FUNCTION",
1706    "RENDER_FUNCTION": 1,
1707    "1": "RENDER_FUNCTION",
1708    "WATCH_GETTER": 2,
1709    "2": "WATCH_GETTER",
1710    "WATCH_CALLBACK": 3,
1711    "3": "WATCH_CALLBACK",
1712    "WATCH_CLEANUP": 4,
1713    "4": "WATCH_CLEANUP",
1714    "NATIVE_EVENT_HANDLER": 5,
1715    "5": "NATIVE_EVENT_HANDLER",
1716    "COMPONENT_EVENT_HANDLER": 6,
1717    "6": "COMPONENT_EVENT_HANDLER",
1718    "VNODE_HOOK": 7,
1719    "7": "VNODE_HOOK",
1720    "DIRECTIVE_HOOK": 8,
1721    "8": "DIRECTIVE_HOOK",
1722    "TRANSITION_HOOK": 9,
1723    "9": "TRANSITION_HOOK",
1724    "APP_ERROR_HANDLER": 10,
1725    "10": "APP_ERROR_HANDLER",
1726    "APP_WARN_HANDLER": 11,
1727    "11": "APP_WARN_HANDLER",
1728    "FUNCTION_REF": 12,
1729    "12": "FUNCTION_REF",
1730    "ASYNC_COMPONENT_LOADER": 13,
1731    "13": "ASYNC_COMPONENT_LOADER",
1732    "SCHEDULER": 14,
1733    "14": "SCHEDULER"
1734  };
1735  const ErrorTypeStrings$1 = {
1736    ["sp"]: "serverPrefetch hook",
1737    ["bc"]: "beforeCreate hook",
1738    ["c"]: "created hook",
1739    ["bm"]: "beforeMount hook",
1740    ["m"]: "mounted hook",
1741    ["bu"]: "beforeUpdate hook",
1742    ["u"]: "updated",
1743    ["bum"]: "beforeUnmount hook",
1744    ["um"]: "unmounted hook",
1745    ["a"]: "activated hook",
1746    ["da"]: "deactivated hook",
1747    ["ec"]: "errorCaptured hook",
1748    ["rtc"]: "renderTracked hook",
1749    ["rtg"]: "renderTriggered hook",
1750    [0]: "setup function",
1751    [1]: "render function",
1752    [2]: "watcher getter",
1753    [3]: "watcher callback",
1754    [4]: "watcher cleanup function",
1755    [5]: "native event handler",
1756    [6]: "component event handler",
1757    [7]: "vnode hook",
1758    [8]: "directive hook",
1759    [9]: "transition hook",
1760    [10]: "app errorHandler",
1761    [11]: "app warnHandler",
1762    [12]: "ref function",
1763    [13]: "async component loader",
1764    [14]: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://github.com/vuejs/core ."
1765  };
1766  function callWithErrorHandling(fn, instance, type, args) {
1767    try {
1768      return args ? fn(...args) : fn();
1769    } catch (err) {
1770      handleError(err, instance, type);
1771    }
1772  }
1773  function callWithAsyncErrorHandling(fn, instance, type, args) {
1774    if (isFunction(fn)) {
1775      const res = callWithErrorHandling(fn, instance, type, args);
1776      if (res && isPromise(res)) {
1777        res.catch((err) => {
1778          handleError(err, instance, type);
1779        });
1780      }
1781      return res;
1782    }
1783    const values = [];
1784    for (let i = 0; i < fn.length; i++) {
1785      values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
1786    }
1787    return values;
1788  }
1789  function handleError(err, instance, type, throwInDev = true) {
1790    const contextVNode = instance ? instance.vnode : null;
1791    if (instance) {
1792      let cur = instance.parent;
1793      const exposedInstance = instance.proxy;
1794      const errorInfo = ErrorTypeStrings$1[type] ;
1795      while (cur) {

2032    }
2033    map.set(id, {
2034      initialDef: normalizeClassComponent(initialDef),
2035      instances: /* @__PURE__ */ new Set()
2036    });
2037    return true;
2038  }
2039  function normalizeClassComponent(component) {
2040    return isClassComponent(component) ? component.__vccOpts : component;
2041  }
2042  function rerender(id, newRender) {
2043    const record = map.get(id);
2044    if (!record) {
2045      return;
2046    }
2047    record.initialDef.render = newRender;
2048    [...record.instances].forEach((instance) => {
2049      if (newRender) {
2050        instance.render = newRender;
2051        normalizeClassComponent(instance.type).render = newRender;
2052      }
2053      instance.renderCache = [];
2054      isHmrUpdating = true;
2055      instance.effect.dirty = true;
2056      instance.update();
2057      isHmrUpdating = false;
2058    });
2059  }
2060  function reload(id, newComp) {
2061    const record = map.get(id);
2062    if (!record)
2063      return;
2064    newComp = normalizeClassComponent(newComp);
2065    updateComponentDef(record.initialDef, newComp);
2066    const instances = [...record.instances];
2067    for (const instance of instances) {
2068      const oldComp = normalizeClassComponent(instance.type);
2069      if (!hmrDirtyComponents.has(oldComp)) {
2070        if (oldComp !== record.initialDef) {
2071          updateComponentDef(oldComp, newComp);
2072        }
2073        hmrDirtyComponents.add(oldComp);
2074      }
2075      instance.appContext.propsCache.delete(instance.type);
2076      instance.appContext.emitsCache.delete(instance.type);
2077      instance.appContext.optionsCache.delete(instance.type);
2078      if (instance.ceReload) {
2079        hmrDirtyComponents.add(oldComp);
2080        instance.ceReload(newComp.styles);
2081        hmrDirtyComponents.delete(oldComp);
2082      } else if (instance.parent) {
2083        instance.parent.effect.dirty = true;
2084        queueJob(instance.parent.update);
2085      } else if (instance.appContext.reload) {
2086        instance.appContext.reload();
2087      } else if (typeof window !== "undefined") {
2088        window.location.reload();
2089      } else {
2090        console.warn(
2091          "[HMR] Root or manually mounted instance modified. Full reload required."
2092        );
2093      }
2094    }
2095    queuePostFlushCb(() => {
2096      for (const instance of instances) {
2097        hmrDirtyComponents.delete(
2098          normalizeClassComponent(instance.type)
2099        );
2100      }
2101    });
2102  }
2103  function updateComponentDef(oldComp, newComp) {
2104    extend(oldComp, newComp);
2105    for (const key in oldComp) {
2106      if (key !== "__file" && !(key in newComp)) {
2107        delete oldComp[key];
2108      }
2109    }
2110  }
2111  function tryWrap(fn) {
2112    return (id, arg) => {
2113      try {
2114        return fn(id, arg);
2115      } catch (e) {
2116        console.error(e);
2117        console.warn(
2118          `[HMR] Something went wrong during Vue component hot-reload. Full reload required.`
2119        );
2120      }
2121    };
2122  }
2123
2124  let devtools$1;
2125  let buffer = [];
2126  let devtoolsNotInstalled = false;
2127  function emit$1(event, ...args) {
2128    if (devtools$1) {
2129      devtools$1.emit(event, ...args);
2130    } else if (!devtoolsNotInstalled) {
2131      buffer.push({ event, args });
2132    }
2133  }
2134  function setDevtoolsHook$1(hook, target) {
2135    var _a, _b;
2136    devtools$1 = hook;
2137    if (devtools$1) {
2138      devtools$1.enabled = true;
2139      buffer.forEach(({ event, args }) => devtools$1.emit(event, ...args));
2140      buffer = [];
2141    } else if (
2142      // handle late devtools injection - only do this if we are in an actual
2143      // browser environment to avoid the timer handle stalling test runner exit
2144      // (#4815)
2145      typeof window !== "undefined" && // some envs mock window but not fully
2146      window.HTMLElement && // also exclude jsdom
2147      !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
2148    ) {
2149      const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
2150      replay.push((newHook) => {
2151        setDevtoolsHook$1(newHook, target);
2152      });
2153      setTimeout(() => {
2154        if (!devtools$1) {
2155          target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
2156          devtoolsNotInstalled = true;
2157          buffer = [];
2158        }
2159      }, 3e3);
2160    } else {
2161      devtoolsNotInstalled = true;
2162      buffer = [];
2163    }
2164  }
2165  function devtoolsInitApp(app, version) {
2166    emit$1("app:init" /* APP_INIT */, app, version, {
2167      Fragment,
2168      Text,
2169      Comment,
2170      Static
2171    });
2172  }
2173  function devtoolsUnmountApp(app) {
2174    emit$1("app:unmount" /* APP_UNMOUNT */, app);
2175  }
2176  const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook(
2177    "component:added" /* COMPONENT_ADDED */
2178  );
2179  const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */);
2180  const _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook(
2181    "component:removed" /* COMPONENT_REMOVED */
2182  );
2183  const devtoolsComponentRemoved = (component) => {
2184    if (devtools$1 && typeof devtools$1.cleanupBuffer === "function" && // remove the component if it wasn't buffered
2185    !devtools$1.cleanupBuffer(component)) {
2186      _devtoolsComponentRemoved(component);
2187    }
2188  };
2189  function createDevtoolsComponentHook(hook) {
2190    return (component) => {
2191      emit$1(
2192        hook,
2193        component.appContext.app,
2194        component.uid,
2195        component.parent ? component.parent.uid : void 0,
2196        component
2197      );
2198    };
2199  }
2200  const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook(
2201    "perf:start" /* PERFORMANCE_START */
2202  );
2203  const devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook(
2204    "perf:end" /* PERFORMANCE_END */
2205  );
2206  function createDevtoolsPerformanceHook(hook) {
2207    return (component, type, time) => {
2208      emit$1(hook, component.appContext.app, component.uid, component, type, time);
2209    };
2210  }
2211  function devtoolsComponentEmit(component, event, params) {
2212    emit$1(
2213      "component:emit" /* COMPONENT_EMIT */,
2214      component.appContext.app,
2215      component,
2216      event,
2217      params
2218    );
2219  }
2220
2221  function emit(instance, event, ...rawArgs) {
2222    if (instance.isUnmounted)
2223      return;
2224    const props = instance.vnode.props || EMPTY_OBJ;
2225    {
2226      const {
2227        emitsOptions,
2228        propsOptions: [propsOptions]
2229      } = instance;
2230      if (emitsOptions) {
2231        if (!(event in emitsOptions) && true) {
2232          if (!propsOptions || !(toHandlerKey(event) in propsOptions)) {
2233            warn$1(
2234              `Component emitted event "${event}" but it is neither declared in the emits option nor as an "${toHandlerKey(event)}" prop.`
2235            );
2236          }
2237        } else {
2238          const validator = emitsOptions[event];
2239          if (isFunction(validator)) {
2240            const isValid = validator(...rawArgs);
2241            if (!isValid) {
2242              warn$1(
2243                `Invalid event arguments: event validation failed for event "${event}".`
2244              );
2245            }
2246          }
2247        }
2248      }
2249    }
2250    let args = rawArgs;
2251    const isModelListener = event.startsWith("update:");
2252    const modelArg = isModelListener && event.slice(7);
2253    if (modelArg && modelArg in props) {
2254      const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`;
2255      const { number, trim } = props[modifiersKey] || EMPTY_OBJ;
2256      if (trim) {
2257        args = rawArgs.map((a) => isString(a) ? a.trim() : a);
2258      }
2259      if (number) {
2260        args = rawArgs.map(looseToNumber);
2261      }
2262    }
2263    {
2264      devtoolsComponentEmit(instance, event, args);
2265    }
2266    {
2267      const lowerCaseEvent = event.toLowerCase();
2268      if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) {
2269        warn$1(
2270          `Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(
2271          instance,
2272          instance.type
2273        )} but the handler is registered for "${event}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${hyphenate(
2274          event
2275        )}" instead of "${event}".`
2276        );
2277      }
2278    }
2279    let handlerName;
2280    let handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249)
2281    props[handlerName = toHandlerKey(camelize(event))];
2282    if (!handler && isModelListener) {
2283      handler = props[handlerName = toHandlerKey(hyphenate(event))];
2284    }
2285    if (handler) {
2286      callWithAsyncErrorHandling(
2287        handler,
2288        instance,
2289        6,
2290        args
2291      );
2292    }
2293    const onceHandler = props[handlerName + `Once`];
2294    if (onceHandler) {
2295      if (!instance.emitted) {
2296        instance.emitted = {};
2297      } else if (instance.emitted[handlerName]) {
2298        return;
2299      }
2300      instance.emitted[handlerName] = true;
2301      callWithAsyncErrorHandling(
2302        onceHandler,
2303        instance,
2304        6,
2305        args
2306      );
2307    }
2308  }
2309  function normalizeEmitsOptions(comp, appContext, asMixin = false) {
2310    const cache = appContext.emitsCache;
2311    const cached = cache.get(comp);
2312    if (cached !== void 0) {
2313      return cached;
2314    }
2315    const raw = comp.emits;
2316    let normalized = {};
2317    let hasExtends = false;
2318    if (!isFunction(comp)) {
2319      const extendEmits = (raw2) => {
2320        const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
2321        if (normalizedFromExtend) {
2322          hasExtends = true;
2323          extend(normalized, normalizedFromExtend);
2324        }
2325      };
2326      if (!asMixin && appContext.mixins.length) {
2327        appContext.mixins.forEach(extendEmits);
2328      }
2329      if (comp.extends) {
2330        extendEmits(comp.extends);
2331      }
2332      if (comp.mixins) {
2333        comp.mixins.forEach(extendEmits);
2334      }
2335    }
2336    if (!raw && !hasExtends) {
2337      if (isObject(comp)) {
2338        cache.set(comp, null);
2339      }
2340      return null;
2341    }
2342    if (isArray(raw)) {
2343      raw.forEach((key) => normalized[key] = null);
2344    } else {
2345      extend(normalized, raw);
2346    }
2347    if (isObject(comp)) {
2348      cache.set(comp, normalized);
2349    }
2350    return normalized;
2351  }
2352  function isEmitListener(options, key) {
2353    if (!options || !isOn(key)) {
2354      return false;
2355    }
2356    key = key.slice(2).replace(/Once$/, "");
2357    return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
2358  }
2359
2360  let currentRenderingInstance = null;
2361  let currentScopeId = null;
2362  function setCurrentRenderingInstance(instance) {
2363    const prev = currentRenderingInstance;
2364    currentRenderingInstance = instance;
2365    currentScopeId = instance && instance.type.__scopeId || null;
2366    return prev;
2367  }
2368  function pushScopeId(id) {
2369    currentScopeId = id;
2370  }
2371  function popScopeId() {
2372    currentScopeId = null;
2373  }
2374  const withScopeId = (_id) => withCtx;
2375  function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
2376    if (!ctx)
2377      return fn;
2378    if (fn._n) {
2379      return fn;
2380    }
2381    const renderFnWithContext = (...args) => {
2382      if (renderFnWithContext._d) {
2383        setBlockTracking(-1);
2384      }
2385      const prevInstance = setCurrentRenderingInstance(ctx);
2386      let res;
2387      try {
2388        res = fn(...args);
2389      } finally {
2390        setCurrentRenderingInstance(prevInstance);
2391        if (renderFnWithContext._d) {
2392          setBlockTracking(1);
2393        }
2394      }
2395      {
2396        devtoolsComponentUpdated(ctx);
2397      }
2398      return res;
2399    };
2400    renderFnWithContext._n = true;
2401    renderFnWithContext._c = true;
2402    renderFnWithContext._d = true;
2403    return renderFnWithContext;
2404  }
2405
2406  let accessedAttrs = false;
2407  function markAttrsAccessed() {
2408    accessedAttrs = true;
2409  }
2410  function renderComponentRoot(instance) {
2411    const {
2412      type: Component,
2413      vnode,
2414      proxy,
2415      withProxy,
2416      props,
2417      propsOptions: [propsOptions],
2418      slots,
2419      attrs,
2420      emit,
2421      render,
2422      renderCache,
2423      data,
2424      setupState,
2425      ctx,
2426      inheritAttrs
2427    } = instance;
2428    let result;
2429    let fallthroughAttrs;
2430    const prev = setCurrentRenderingInstance(instance);
2431    {
2432      accessedAttrs = false;
2433    }
2434    try {
2435      if (vnode.shapeFlag & 4) {
2436        const proxyToUse = withProxy || proxy;
2437        const thisProxy = setupState.__isScriptSetup ? new Proxy(proxyToUse, {
2438          get(target, key, receiver) {
2439            warn$1(
2440              `Property '${String(
2441              key
2442            )}' was accessed via 'this'. Avoid using 'this' in templates.`
2443            );
2444            return Reflect.get(target, key, receiver);
2445          }
2446        }) : proxyToUse;
2447        result = normalizeVNode(
2448          render.call(
2449            thisProxy,
2450            proxyToUse,
2451            renderCache,
2452            props,
2453            setupState,
2454            data,
2455            ctx
2456          )
2457        );
2458        fallthroughAttrs = attrs;
2459      } else {
2460        const render2 = Component;
2461        if (attrs === props) {
2462          markAttrsAccessed();
2463        }
2464        result = normalizeVNode(
2465          render2.length > 1 ? render2(
2466            props,
2467            true ? {
2468              get attrs() {
2469                markAttrsAccessed();
2470                return attrs;
2471              },
2472              slots,
2473              emit
2474            } : { attrs, slots, emit }
2475          ) : render2(
2476            props,
2477            null
2478            /* we know it doesn't need it */
2479          )
2480        );
2481        fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
2482      }
2483    } catch (err) {
2484      blockStack.length = 0;
2485      handleError(err, instance, 1);
2486      result = createVNode(Comment);
2487    }
2488    let root = result;
2489    let setRoot = void 0;
2490    if (result.patchFlag > 0 && result.patchFlag & 2048) {
2491      [root, setRoot] = getChildRoot(result);
2492    }
2493    if (fallthroughAttrs && inheritAttrs !== false) {
2494      const keys = Object.keys(fallthroughAttrs);
2495      const { shapeFlag } = root;
2496      if (keys.length) {
2497        if (shapeFlag & (1 | 6)) {
2498          if (propsOptions && keys.some(isModelListener)) {
2499            fallthroughAttrs = filterModelListeners(
2500              fallthroughAttrs,
2501              propsOptions
2502            );
2503          }
2504          root = cloneVNode(root, fallthroughAttrs);
2505        } else if (!accessedAttrs && root.type !== Comment) {
2506          const allAttrs = Object.keys(attrs);
2507          const eventAttrs = [];
2508          const extraAttrs = [];
2509          for (let i = 0, l = allAttrs.length; i < l; i++) {
2510            const key = allAttrs[i];
2511            if (isOn(key)) {
2512              if (!isModelListener(key)) {
2513                eventAttrs.push(key[2].toLowerCase() + key.slice(3));
2514              }
2515            } else {
2516              extraAttrs.push(key);
2517            }
2518          }
2519          if (extraAttrs.length) {
2520            warn$1(
2521              `Extraneous non-props attributes (${extraAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes.`
2522            );
2523          }
2524          if (eventAttrs.length) {
2525            warn$1(
2526              `Extraneous non-emits event listeners (${eventAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes. If the listener is intended to be a component custom event listener only, declare it using the "emits" option.`
2527            );
2528          }
2529        }
2530      }
2531    }
2532    if (vnode.dirs) {
2533      if (!isElementRoot(root)) {
2534        warn$1(
2535          `Runtime directive used on component with non-element root node. The directives will not function as intended.`
2536        );
2537      }
2538      root = cloneVNode(root);
2539      root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
2540    }
2541    if (vnode.transition) {
2542      if (!isElementRoot(root)) {
2543        warn$1(
2544          `Component inside <Transition> renders non-element root node that cannot be animated.`
2545        );
2546      }
2547      root.transition = vnode.transition;
2548    }
2549    if (setRoot) {
2550      setRoot(root);
2551    } else {
2552      result = root;
2553    }
2554    setCurrentRenderingInstance(prev);
2555    return result;
2556  }
2557  const getChildRoot = (vnode) => {
2558    const rawChildren = vnode.children;
2559    const dynamicChildren = vnode.dynamicChildren;
2560    const childRoot = filterSingleRoot(rawChildren, false);
2561    if (!childRoot) {
2562      return [vnode, void 0];
2563    } else if (childRoot.patchFlag > 0 && childRoot.patchFlag & 2048) {
2564      return getChildRoot(childRoot);
2565    }
2566    const index = rawChildren.indexOf(childRoot);
2567    const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;
2568    const setRoot = (updatedRoot) => {
2569      rawChildren[index] = updatedRoot;
2570      if (dynamicChildren) {
2571        if (dynamicIndex > -1) {
2572          dynamicChildren[dynamicIndex] = updatedRoot;
2573        } else if (updatedRoot.patchFlag > 0) {
2574          vnode.dynamicChildren = [...dynamicChildren, updatedRoot];
2575        }
2576      }
2577    };
2578    return [normalizeVNode(childRoot), setRoot];
2579  };
2580  function filterSingleRoot(children, recurse = true) {
2581    let singleRoot;
2582    for (let i = 0; i < children.length; i++) {
2583      const child = children[i];
2584      if (isVNode(child)) {
2585        if (child.type !== Comment || child.children === "v-if") {
2586          if (singleRoot) {
2587            return;
2588          } else {
2589            singleRoot = child;
2590            if (recurse && singleRoot.patchFlag > 0 && singleRoot.patchFlag & 2048) {
2591              return filterSingleRoot(singleRoot.children);
2592            }
2593          }
2594        }
2595      } else {
2596        return;
2597      }
2598    }
2599    return singleRoot;
2600  }
2601  const getFunctionalFallthrough = (attrs) => {
2602    let res;
2603    for (const key in attrs) {
2604      if (key === "class" || key === "style" || isOn(key)) {
2605        (res || (res = {}))[key] = attrs[key];
2606      }
2607    }
2608    return res;
2609  };
2610  const filterModelListeners = (attrs, props) => {
2611    const res = {};
2612    for (const key in attrs) {
2613      if (!isModelListener(key) || !(key.slice(9) in props)) {
2614        res[key] = attrs[key];
2615      }
2616    }
2617    return res;
2618  };
2619  const isElementRoot = (vnode) => {
2620    return vnode.shapeFlag & (6 | 1) || vnode.type === Comment;
2621  };
2622  function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
2623    const { props: prevProps, children: prevChildren, component } = prevVNode;
2624    const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
2625    const emits = component.emitsOptions;
2626    if ((prevChildren || nextChildren) && isHmrUpdating) {
2627      return true;
2628    }
2629    if (nextVNode.dirs || nextVNode.transition) {
2630      return true;
2631    }
2632    if (optimized && patchFlag >= 0) {
2633      if (patchFlag & 1024) {
2634        return true;
2635      }
2636      if (patchFlag & 16) {
2637        if (!prevProps) {
2638          return !!nextProps;
2639        }
2640        return hasPropsChanged(prevProps, nextProps, emits);
2641      } else if (patchFlag & 8) {
2642        const dynamicProps = nextVNode.dynamicProps;
2643        for (let i = 0; i < dynamicProps.length; i++) {
2644          const key = dynamicProps[i];
2645          if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
2646            return true;
2647          }
2648        }
2649      }
2650    } else {
2651      if (prevChildren || nextChildren) {
2652        if (!nextChildren || !nextChildren.$stable) {
2653          return true;
2654        }
2655      }
2656      if (prevProps === nextProps) {
2657        return false;
2658      }
2659      if (!prevProps) {
2660        return !!nextProps;
2661      }
2662      if (!nextProps) {
2663        return true;
2664      }
2665      return hasPropsChanged(prevProps, nextProps, emits);
2666    }
2667    return false;
2668  }
2669  function hasPropsChanged(prevProps, nextProps, emitsOptions) {
2670    const nextKeys = Object.keys(nextProps);
2671    if (nextKeys.length !== Object.keys(prevProps).length) {
2672      return true;
2673    }
2674    for (let i = 0; i < nextKeys.length; i++) {
2675      const key = nextKeys[i];
2676      if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
2677        return true;
2678      }
2679    }
2680    return false;
2681  }
2682  function updateHOCHostEl({ vnode, parent }, el) {
2683    while (parent) {
2684      const root = parent.subTree;
2685      if (root.suspense && root.suspense.activeBranch === vnode) {
2686        root.el = vnode.el;
2687      }
2688      if (root === vnode) {
2689        (vnode = parent.vnode).el = el;
2690        parent = parent.parent;
2691      } else {
2692        break;
2693      }
2694    }
2695  }
2696
2697  const COMPONENTS = "components";
2698  const DIRECTIVES = "directives";
2699  function resolveComponent(name, maybeSelfReference) {
2700    return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
2701  }
2702  const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
2703  function resolveDynamicComponent(component) {
2704    if (isString(component)) {
2705      return resolveAsset(COMPONENTS, component, false) || component;
2706    } else {
2707      return component || NULL_DYNAMIC_COMPONENT;
2708    }
2709  }
2710  function resolveDirective(name) {
2711    return resolveAsset(DIRECTIVES, name);
2712  }
2713  function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
2714    const instance = currentRenderingInstance || currentInstance;
2715    if (instance) {
2716      const Component = instance.type;
2717      if (type === COMPONENTS) {
2718        const selfName = getComponentName(
2719          Component,
2720          false
2721        );
2722        if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) {
2723          return Component;
2724        }
2725      }
2726      const res = (
2727        // local registration
2728        // check instance[type] first which is resolved for options API
2729        resolve(instance[type] || Component[type], name) || // global registration
2730        resolve(instance.appContext[type], name)
2731      );
2732      if (!res && maybeSelfReference) {
2733        return Component;
2734      }
2735      if (warnMissing && !res) {
2736        const extra = type === COMPONENTS ? `
2737If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ``;
2738        warn$1(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`);
2739      }
2740      return res;
2741    } else {
2742      warn$1(
2743        `resolve${capitalize(type.slice(0, -1))} can only be used in render() or setup().`
2744      );
2745    }
2746  }
2747  function resolve(registry, name) {
2748    return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);
2749  }
2750
2751  const isSuspense = (type) => type.__isSuspense;
2752  let suspenseId = 0;
2753  const SuspenseImpl = {
2754    name: "Suspense",
2755    // In order to make Suspense tree-shakable, we need to avoid importing it
2756    // directly in the renderer. The renderer checks for the __isSuspense flag
2757    // on a vnode's type and calls the `process` method, passing in renderer
2758    // internals.
2759    __isSuspense: true,
2760    process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
2761      if (n1 == null) {
2762        mountSuspense(
2763          n2,
2764          container,
2765          anchor,
2766          parentComponent,
2767          parentSuspense,
2768          namespace,
2769          slotScopeIds,
2770          optimized,
2771          rendererInternals
2772        );
2773      } else {
2774        if (parentSuspense && parentSuspense.deps > 0 && !n1.suspense.isInFallback) {
2775          n2.suspense = n1.suspense;
2776          n2.suspense.vnode = n2;
2777          n2.el = n1.el;
2778          return;
2779        }
2780        patchSuspense(
2781          n1,
2782          n2,
2783          container,
2784          anchor,
2785          parentComponent,
2786          namespace,
2787          slotScopeIds,
2788          optimized,
2789          rendererInternals
2790        );
2791      }
2792    },
2793    hydrate: hydrateSuspense,
2794    create: createSuspenseBoundary,
2795    normalize: normalizeSuspenseChildren
2796  };
2797  const Suspense = SuspenseImpl ;
2798  function triggerEvent(vnode, name) {
2799    const eventListener = vnode.props && vnode.props[name];
2800    if (isFunction(eventListener)) {
2801      eventListener();
2802    }
2803  }
2804  function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
2805    const {
2806      p: patch,
2807      o: { createElement }
2808    } = rendererInternals;
2809    const hiddenContainer = createElement("div");
2810    const suspense = vnode.suspense = createSuspenseBoundary(
2811      vnode,
2812      parentSuspense,
2813      parentComponent,
2814      container,
2815      hiddenContainer,
2816      anchor,
2817      namespace,
2818      slotScopeIds,
2819      optimized,
2820      rendererInternals
2821    );
2822    patch(
2823      null,
2824      suspense.pendingBranch = vnode.ssContent,
2825      hiddenContainer,
2826      null,
2827      parentComponent,
2828      suspense,
2829      namespace,
2830      slotScopeIds
2831    );
2832    if (suspense.deps > 0) {
2833      triggerEvent(vnode, "onPending");
2834      triggerEvent(vnode, "onFallback");
2835      patch(
2836        null,
2837        vnode.ssFallback,
2838        container,
2839        anchor,
2840        parentComponent,
2841        null,
2842        // fallback tree will not have suspense context
2843        namespace,
2844        slotScopeIds
2845      );