billit-client-production.js

js billit.eu collected 2026-09-28 07:29:41 UTC 359,456 bytes, 11,671 lines download raw bytes

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

110URI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol";
111  const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
112  function normalizeStyle(value) {
113    if (isArray(value)) {
114      const res = {};
115      for (let i = 0; i < value.length; i++) {
116        const item = value[i];
117        const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
118        if (normalized) {
119          for (const key in normalized) {
120            res[key] = normalized[key];
121          }
122        }
123      }
124      return res;
125    } else if (isString(value) || isObject(value)) {
126      return value;
127    }
128  }
129  const listDelimiterRE = /;(?![^(]*\))/g;
130  const propertyDelimiterRE = /:([^]+)/;
131  const styleCommentRE = /\/\*[^]*?\*\//g;
132  function parseStringStyle(cssText) {
133    const ret = {};
134    cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
135      if (item) {
136        const tmp = item.split(propertyDelimiterRE);
137        tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
138      }
139    });
140    return ret;
141  }
142  function stringifyStyle(styles) {
143    let ret = "";
144    if (!styles || isString(styles)) {
145      return ret;
146    }
147    for (const key in styles) {
148      const value = styles[key];
149      if (isString(value) || typeof value === "number") {
150        const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
151        ret += `${normalizedKey}:${value};`;
152      }
153    }
154    return ret;
155  }
156  function normalizeClass(value) {
157    let res = "";
158    if (isString(value)) {
159      res = value;
160    } else if (isArray(value)) {
161      for (let i = 0; i < value.length; i++) {
162        const normalized = normalizeClass(value[i]);
163        if (normalized) {
164          res += normalized + " ";
165        }
166      }
167    } else if (isObject(value)) {
168      for (const name in value) {
169        if (value[name]) {
170          res += name + " ";
171        }
172      }
173    }
174    return res.trim();
175  }
176  function normalizeProps(props) {
177    if (!props)
178      return null;
179    let { class: klass, style } = props;
180    if (klass && !isString(klass)) {
181      props.class = normalizeClass(klass);
182    }
183    if (style) {
184      props.style = normalizeStyle(style);
185    }
186    return props;
187  }
188  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";
189  const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
190  const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
191  const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
192  const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
193  const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
194  const isBooleanAttr = /* @__PURE__ */ makeMap(
195    specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
196  );
197  function includeBooleanAttr(value) {
198    return !!value || value === "";
199  }
200  const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
201  const attrValidationCache = {};
202  function isSSRSafeAttrName(name) {
203    if (attrValidationCache.hasOwnProperty(name)) {
204      return attrValidationCache[name];
205    }
206    const isUnsafe = unsafeAttrCharRE.test(name);
207    if (isUnsafe) {
208      console.error(`unsafe attribute name: ${name}`);
209    }
210    return attrValidationCache[name] = !isUnsafe;
211  }
212  const propsToAttrMap = {
213    acceptCharset: "accept-charset",
214    className: "class",
215    htmlFor: "for",
216    httpEquiv: "http-equiv"
217  };
218  function isRenderableAttrValue(value) {
219    if (value == null) {
220      return false;

vendor: 4,355 bytes, lines 221-369

221    }
222    const type = typeof value;
223    return type === "string" || type === "number" || type === "boolean";
224  }
225  const escapeRE = /["'&<>]/;
226  function escapeHtml(string) {
227    const str = "" + string;
228    const match = escapeRE.exec(str);
229    if (!match) {
230      return str;
231    }
232    let html = "";
233    let escaped;
234    let index2;
235    let lastIndex = 0;
236    for (index2 = match.index; index2 < str.length; index2++) {
237      switch (str.charCodeAt(index2)) {
238        case 34:
239          escaped = "&quot;";
240          break;
241        case 38:
242          escaped = "&amp;";
243          break;
244        case 39:
245          escaped = "&#39;";
246          break;
247        case 60:
248          escaped = "&lt;";
249          break;
250        case 62:
251          escaped = "&gt;";
252          break;
253        default:
254          continue;
255      }
256      if (lastIndex !== index2) {
257        html += str.slice(lastIndex, index2);
258      }
259      lastIndex = index2 + 1;
260      html += escaped;
261    }
262    return lastIndex !== index2 ? html + str.slice(lastIndex, index2) : html;
263  }
264  const commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;
265  function escapeHtmlComment(src) {
266    return src.replace(commentStripRE, "");
267  }
268  function looseCompareArrays(a, b) {
269    if (a.length !== b.length)
270      return false;
271    let equal = true;
272    for (let i = 0; equal && i < a.length; i++) {
273      equal = looseEqual(a[i], b[i]);
274    }
275    return equal;
276  }
277  function looseEqual(a, b) {
278    if (a === b)
279      return true;
280    let aValidType = isDate(a);
281    let bValidType = isDate(b);
282    if (aValidType || bValidType) {
283      return aValidType && bValidType ? a.getTime() === b.getTime() : false;
284    }
285    aValidType = isSymbol(a);
286    bValidType = isSymbol(b);
287    if (aValidType || bValidType) {
288      return a === b;
289    }
290    aValidType = isArray(a);
291    bValidType = isArray(b);
292    if (aValidType || bValidType) {
293      return aValidType && bValidType ? looseCompareArrays(a, b) : false;
294    }
295    aValidType = isObject(a);
296    bValidType = isObject(b);
297    if (aValidType || bValidType) {
298      if (!aValidType || !bValidType) {
299        return false;
300      }
301      const aKeysCount = Object.keys(a).length;
302      const bKeysCount = Object.keys(b).length;
303      if (aKeysCount !== bKeysCount) {
304        return false;
305      }
306      for (const key in a) {
307        const aHasKey = a.hasOwnProperty(key);
308        const bHasKey = b.hasOwnProperty(key);
309        if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
310          return false;
311        }
312      }
313    }
314    return String(a) === String(b);
315  }
316  function looseIndexOf(arr, val) {
317    return arr.findIndex((item) => looseEqual(item, val));
318  }
319  const isRef$1 = (val) => {
320    return !!(val && val["__v_isRef"] === true);
321  };
322  const toDisplayString = (val) => {
323    return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef$1(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
324  };
325  const replacer = (_key, val) => {
326    if (isRef$1(val)) {
327      return replacer(_key, val.value);
328    } else if (isMap(val)) {
329      return {
330        [`Map(${val.size})`]: [...val.entries()].reduce(
331          (entries, [key, val2], i) => {
332            entries[stringifySymbol(key, i) + " =>"] = val2;
333            return entries;
334          },
335          {}
336        )
337      };
338    } else if (isSet(val)) {
339      return {
340        [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
341      };
342    } else if (isSymbol(val)) {
343      return stringifySymbol(val);
344    } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
345      return String(val);
346    }
347    return val;
348  };
349  const stringifySymbol = (v, i = "") => {
350    var _a;
351    return (
352      // Symbol.description in es2019+ so we need to cast here to pass
353      // the lib: es2016 check
354      isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v
355    );
356  };
357  /**
358  * @vue/reactivity v3.5.12
359  * (c) 2018-present Yuxi (Evan) You and Vue contributors
360  * @license MIT
361  **/
362  let activeEffectScope;
363  class EffectScope {
364    constructor(detached = false) {
365      this.detached = detached;
366      this._active = true;
367      this.effects = [];
368      this.cleanups = [];
369      this._isPaused = false;

370      this.parent = activeEffectScope;
371      if (!detached && activeEffectScope) {
372        this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
373          this
374        ) - 1;
375      }
376    }
377    get active() {
378      return this._active;
379    }
380    pause() {
381      if (this._active) {
382        this._isPaused = true;
383        let i, l;
384        if (this.scopes) {
385          for (i = 0, l = this.scopes.length; i < l; i++) {
386            this.scopes[i].pause();
387          }
388        }
389        for (i = 0, l = this.effects.length; i < l; i++) {
390          this.effects[i].pause();
391        }
392      }
393    }
394    /**
395     * Resumes the effect scope, including all child scopes and effects.
396     */
397    resume() {
398      if (this._active) {
399        if (this._isPaused) {
400          this._isPaused = false;
401          let i, l;
402          if (this.scopes) {
403            for (i = 0, l = this.scopes.length; i < l; i++) {
404              this.scopes[i].resume();
405            }
406          }
407          for (i = 0, l = this.effects.length; i < l; i++) {
408            this.effects[i].resume();
409          }
410        }
411      }
412    }
413    run(fn) {
414      if (this._active) {
415        const currentEffectScope = activeEffectScope;
416        try {
417          activeEffectScope = this;
418          return fn();
419        } finally {
420          activeEffectScope = currentEffectScope;
421        }
422      }
423    }
424    /**
425     * This should only be called on non-detached scopes
426     * @internal
427     */
428    on() {
429      activeEffectScope = this;
430    }
431    /**
432     * This should only be called on non-detached scopes
433     * @internal
434     */
435    off() {
436      activeEffectScope = this.parent;
437    }
438    stop(fromParent) {
439      if (this._active) {
440        let i, l;
441        for (i = 0, l = this.effects.length; i < l; i++) {
442          this.effects[i].stop();
443        }
444        for (i = 0, l = this.cleanups.length; i < l; i++) {
445          this.cleanups[i]();
446        }
447        if (this.scopes) {
448          for (i = 0, l = this.scopes.length; i < l; i++) {
449            this.scopes[i].stop(true);
450          }
451        }
452        if (!this.detached && this.parent && !fromParent) {
453          const last = this.parent.scopes.pop();
454          if (last && last !== this) {
455            this.parent.scopes[this.index] = last;
456            last.index = this.index;
457          }
458        }
459        this.parent = void 0;
460        this._active = false;
461      }
462    }
463  }
464  function effectScope(detached) {
465    return new EffectScope(detached);
466  }
467  function getCurrentScope() {
468    return activeEffectScope;
469  }
470  function onScopeDispose(fn, failSilently = false) {
471    if (activeEffectScope) {
472      activeEffectScope.cleanups.push(fn);
473    }
474  }
475  let activeSub;
476  const pausedQueueEffects = /* @__PURE__ */ new WeakSet();
477  class ReactiveEffect {
478    constructor(fn) {
479      this.fn = fn;
480      this.deps = void 0;
481      this.depsTail = void 0;
482      this.flags = 1 | 4;
483      this.next = void 0;
484      this.cleanup = void 0;
485      this.scheduler = void 0;
486      if (activeEffectScope && activeEffectScope.active) {
487        activeEffectScope.effects.push(this);
488      }
489    }
490    pause() {
491      this.flags |= 64;
492    }
493    resume() {
494      if (this.flags & 64) {
495        this.flags &= ~64;
496        if (pausedQueueEffects.has(this)) {
497          pausedQueueEffects.delete(this);
498          this.trigger();
499        }
500      }
501    }
502    /**
503     * @internal
504     */
505    notify() {
506      if (this.flags & 2 && !(this.flags & 32)) {
507        return;
508      }
509      if (!(this.flags & 8)) {
510        batch(this);
511      }
512    }
513    run() {
514      if (!(this.flags & 1)) {
515        return this.fn();
516      }
517      this.flags |= 2;
518      cleanupEffect(this);
519      prepareDeps(this);
520      const prevEffect = activeSub;
521      const prevShouldTrack = shouldTrack;
522      activeSub = this;
523      shouldTrack = true;
524      try {
525        return this.fn();
526      } finally {
527        cleanupDeps(this);
528        activeSub = prevEffect;
529        shouldTrack = prevShouldTrack;
530        this.flags &= ~2;
531      }
532    }
533    stop() {
534      if (this.flags & 1) {
535        for (let link = this.deps; link; link = link.nextDep) {
536          removeSub(link);
537        }
538        this.deps = this.depsTail = void 0;
539        cleanupEffect(this);
540        this.onStop && this.onStop();
541        this.flags &= ~1;
542      }
543    }
544    trigger() {
545      if (this.flags & 64) {

546        pausedQueueEffects.add(this);
547      } else if (this.scheduler) {
548        this.scheduler();
549      } else {
550        this.runIfDirty();
551      }
552    }
553    /**
554     * @internal
555     */
556    runIfDirty() {
557      if (isDirty(this)) {
558        this.run();
559      }
560    }
561    get dirty() {
562      return isDirty(this);
563    }
564  }
565  let batchDepth = 0;
566  let batchedSub;
567  let batchedComputed;
568  function batch(sub, isComputed = false) {
569    sub.flags |= 8;
570    if (isComputed) {
571      sub.next = batchedComputed;
572      batchedComputed = sub;
573      return;
574    }
575    sub.next = batchedSub;
576    batchedSub = sub;
577  }
578  function startBatch() {
579    batchDepth++;
580  }
581  function endBatch() {
582    if (--batchDepth > 0) {
583      return;
584    }
585    if (batchedComputed) {
586      let e = batchedComputed;
587      batchedComputed = void 0;
588      while (e) {
589        const next = e.next;
590        e.next = void 0;
591        e.flags &= ~8;
592        e = next;
593      }
594    }
595    let error;
596    while (batchedSub) {
597      let e = batchedSub;
598      batchedSub = void 0;
599      while (e) {
600        const next = e.next;
601        e.next = void 0;
602        e.flags &= ~8;
603        if (e.flags & 1) {
604          try {
605            ;
606            e.trigger();
607          } catch (err) {
608            if (!error)
609              error = err;
610          }
611        }
612        e = next;
613      }
614    }
615    if (error)
616      throw error;
617  }
618  function prepareDeps(sub) {
619    for (let link = sub.deps; link; link = link.nextDep) {
620      link.version = -1;
621      link.prevActiveLink = link.dep.activeLink;
622      link.dep.activeLink = link;
623    }
624  }
625  function cleanupDeps(sub) {
626    let head;
627    let tail = sub.depsTail;
628    let link = tail;
629    while (link) {
630      const prev = link.prevDep;
631      if (link.version === -1) {
632        if (link === tail)
633          tail = prev;
634        removeSub(link);
635        removeDep(link);
636      } else {
637        head = link;
638      }
639      link.dep.activeLink = link.prevActiveLink;
640      link.prevActiveLink = void 0;
641      link = prev;
642    }
643    sub.deps = head;
644    sub.depsTail = tail;
645  }
646  function isDirty(sub) {
647    for (let link = sub.deps; link; link = link.nextDep) {
648      if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
649        return true;
650      }
651    }
652    if (sub._dirty) {
653      return true;
654    }
655    return false;
656  }
657  function refreshComputed(computed2) {
658    if (computed2.flags & 4 && !(computed2.flags & 16)) {
659      return;
660    }
661    computed2.flags &= ~16;
662    if (computed2.globalVersion === globalVersion) {
663      return;
664    }
665    computed2.globalVersion = globalVersion;
666    const dep = computed2.dep;
667    computed2.flags |= 2;
668    if (dep.version > 0 && !computed2.isSSR && computed2.deps && !isDirty(computed2)) {
669      computed2.flags &= ~2;
670      return;
671    }
672    const prevSub = activeSub;
673    const prevShouldTrack = shouldTrack;
674    activeSub = computed2;
675    shouldTrack = true;
676    try {
677      prepareDeps(computed2);
678      const value = computed2.fn(computed2._value);
679      if (dep.version === 0 || hasChanged(value, computed2._value)) {
680        computed2._value = value;
681        dep.version++;
682      }
683    } catch (err) {
684      dep.version++;
685      throw err;
686    } finally {
687      activeSub = prevSub;
688      shouldTrack = prevShouldTrack;
689      cleanupDeps(computed2);
690      computed2.flags &= ~2;
691    }
692  }
693  function removeSub(link, soft = false) {
694    const { dep, prevSub, nextSub } = link;
695    if (prevSub) {
696      prevSub.nextSub = nextSub;
697      link.prevSub = void 0;
698    }
699    if (nextSub) {
700      nextSub.prevSub = prevSub;
701      link.nextSub = void 0;
702    }
703    if (dep.subs === link) {
704      dep.subs = prevSub;
705      if (!prevSub && dep.computed) {
706        dep.computed.flags &= ~4;
707        for (let l = dep.computed.deps; l; l = l.nextDep) {
708          removeSub(l, true);
709        }
710      }
711    }
712    if (!soft && !--dep.sc && dep.map) {
713      dep.map.delete(dep.key);
714    }
715  }
716  function removeDep(link) {
717    const { prevDep, nextDep } = link;
718    if (prevDep) {
719      prevDep.nextDep = nextDep;
720      link.prevDep = void 0;
721    }
722    if (nextDep) {
723      nextDep.prevDep = prevDep;
724      link.nextDep = void 0;
725    }
726  }
727  function effect(fn, options) {
728    if (fn.effect instanceof ReactiveEffect) {
729      fn = fn.effect.fn;
730    }
731    const e = new ReactiveEffect(fn);
732    if (options) {
733      extend(e, options);
734    }
735    try {
736      e.run();
737    } catch (err) {
738      e.stop();
739      throw err;
740    }
741    const runner = e.run.bind(e);
742    runner.effect = e;
743    return runner;
744  }
745  function stop(runner) {
746    runner.effect.stop();
747  }
748  let shouldTrack = true;
749  const trackStack = [];
750  function pauseTracking() {
751    trackStack.push(shouldTrack);
752    shouldTrack = false;

vendor: 4,087 bytes, lines 753-912

753  }
754  function resetTracking() {
755    const last = trackStack.pop();
756    shouldTrack = last === void 0 ? true : last;
757  }
758  function cleanupEffect(e) {
759    const { cleanup } = e;
760    e.cleanup = void 0;
761    if (cleanup) {
762      const prevSub = activeSub;
763      activeSub = void 0;
764      try {
765        cleanup();
766      } finally {
767        activeSub = prevSub;
768      }
769    }
770  }
771  let globalVersion = 0;
772  class Link {
773    constructor(sub, dep) {
774      this.sub = sub;
775      this.dep = dep;
776      this.version = dep.version;
777      this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
778    }
779  }
780  class Dep {
781    constructor(computed2) {
782      this.computed = computed2;
783      this.version = 0;
784      this.activeLink = void 0;
785      this.subs = void 0;
786      this.map = void 0;
787      this.key = void 0;
788      this.sc = 0;
789    }
790    track(debugInfo) {
791      if (!activeSub || !shouldTrack || activeSub === this.computed) {
792        return;
793      }
794      let link = this.activeLink;
795      if (link === void 0 || link.sub !== activeSub) {
796        link = this.activeLink = new Link(activeSub, this);
797        if (!activeSub.deps) {
798          activeSub.deps = activeSub.depsTail = link;
799        } else {
800          link.prevDep = activeSub.depsTail;
801          activeSub.depsTail.nextDep = link;
802          activeSub.depsTail = link;
803        }
804        addSub(link);
805      } else if (link.version === -1) {
806        link.version = this.version;
807        if (link.nextDep) {
808          const next = link.nextDep;
809          next.prevDep = link.prevDep;
810          if (link.prevDep) {
811            link.prevDep.nextDep = next;
812          }
813          link.prevDep = activeSub.depsTail;
814          link.nextDep = void 0;
815          activeSub.depsTail.nextDep = link;
816          activeSub.depsTail = link;
817          if (activeSub.deps === link) {
818            activeSub.deps = next;
819          }
820        }
821      }
822      return link;
823    }
824    trigger(debugInfo) {
825      this.version++;
826      globalVersion++;
827      this.notify(debugInfo);
828    }
829    notify(debugInfo) {
830      startBatch();
831      try {
832        if (false)
833          ;
834        for (let link = this.subs; link; link = link.prevSub) {
835          if (link.sub.notify()) {
836            ;
837            link.sub.dep.notify();
838          }
839        }
840      } finally {
841        endBatch();
842      }
843    }
844  }
845  function addSub(link) {
846    link.dep.sc++;
847    if (link.sub.flags & 4) {
848      const computed2 = link.dep.computed;
849      if (computed2 && !link.dep.subs) {
850        computed2.flags |= 4 | 16;
851        for (let l = computed2.deps; l; l = l.nextDep) {
852          addSub(l);
853        }
854      }
855      const currentTail = link.dep.subs;
856      if (currentTail !== link) {
857        link.prevSub = currentTail;
858        if (currentTail)
859          currentTail.nextSub = link;
860      }
861      link.dep.subs = link;
862    }
863  }
864  const targetMap = /* @__PURE__ */ new WeakMap();
865  const ITERATE_KEY = Symbol(
866    ""
867  );
868  const MAP_KEY_ITERATE_KEY = Symbol(
869    ""
870  );
871  const ARRAY_ITERATE_KEY = Symbol(
872    ""
873  );
874  function track(target, type, key) {
875    if (shouldTrack && activeSub) {
876      let depsMap = targetMap.get(target);
877      if (!depsMap) {
878        targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
879      }
880      let dep = depsMap.get(key);
881      if (!dep) {
882        depsMap.set(key, dep = new Dep());
883        dep.map = depsMap;
884        dep.key = key;
885      }
886      {
887        dep.track();
888      }
889    }
890  }
891  function trigger(target, type, key, newValue, oldValue, oldTarget) {
892    const depsMap = targetMap.get(target);
893    if (!depsMap) {
894      globalVersion++;
895      return;
896    }
897    const run = (dep) => {
898      if (dep) {
899        {
900          dep.trigger();
901        }
902      }
903    };
904    startBatch();
905    if (type === "clear") {
906      depsMap.forEach(run);
907    } else {
908      const targetIsArray = isArray(target);
909      const isArrayIndex = targetIsArray && isIntegerKey(key);
910      if (targetIsArray && key === "length") {
911        const newLength = Number(newValue);
912        depsMap.forEach((dep, key2) => {

913          if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
914            run(dep);
915          }
916        });
917      } else {
918        if (key !== void 0 || depsMap.has(void 0)) {
919          run(depsMap.get(key));
920        }
921        if (isArrayIndex) {
922          run(depsMap.get(ARRAY_ITERATE_KEY));
923        }
924        switch (type) {
925          case "add":
926            if (!targetIsArray) {
927              run(depsMap.get(ITERATE_KEY));
928              if (isMap(target)) {
929                run(depsMap.get(MAP_KEY_ITERATE_KEY));
930              }
931            } else if (isArrayIndex) {
932              run(depsMap.get("length"));
933            }
934            break;
935          case "delete":
936            if (!targetIsArray) {
937              run(depsMap.get(ITERATE_KEY));
938              if (isMap(target)) {
939                run(depsMap.get(MAP_KEY_ITERATE_KEY));
940              }
941            }
942            break;
943          case "set":
944            if (isMap(target)) {
945              run(depsMap.get(ITERATE_KEY));
946            }
947            break;
948        }
949      }
950    }
951    endBatch();
952  }
953  function getDepFromReactive(object, key) {
954    const depMap = targetMap.get(object);
955    return depMap && depMap.get(key);
956  }
957  function reactiveReadArray(array) {
958    const raw = toRaw(array);
959    if (raw === array)
960      return raw;
961    track(raw, "iterate", ARRAY_ITERATE_KEY);
962    return isShallow(array) ? raw : raw.map(toReactive);
963  }
964  function shallowReadArray(arr) {
965    track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
966    return arr;
967  }
968  const arrayInstrumentations = {
969    __proto__: null,
970    [Symbol.iterator]() {
971      return iterator(this, Symbol.iterator, toReactive);
972    },
973    concat(...args) {
974      return reactiveReadArray(this).concat(
975        ...args.map((x) => isArray(x) ? reactiveReadArray(x) : x)
976      );
977    },
978    entries() {
979      return iterator(this, "entries", (value) => {
980        value[1] = toReactive(value[1]);
981        return value;
982      });
983    },
984    every(fn, thisArg) {
985      return apply(this, "every", fn, thisArg, void 0, arguments);
986    },
987    filter(fn, thisArg) {
988      return apply(this, "filter", fn, thisArg, (v) => v.map(toReactive), arguments);
989    },
990    find(fn, thisArg) {
991      return apply(this, "find", fn, thisArg, toReactive, arguments);
992    },
993    findIndex(fn, thisArg) {
994      return apply(this, "findIndex", fn, thisArg, void 0, arguments);
995    },
996    findLast(fn, thisArg) {
997      return apply(this, "findLast", fn, thisArg, toReactive, arguments);
998    },
999    findLastIndex(fn, thisArg) {
1000      return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
1001    },
1002    // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
1003    forEach(fn, thisArg) {
1004      return apply(this, "forEach", fn, thisArg, void 0, arguments);
1005    },
1006    includes(...args) {
1007      return searchProxy(this, "includes", args);
1008    },
1009    indexOf(...args) {
1010      return searchProxy(this, "indexOf", args);
1011    },
1012    join(separator) {
1013      return reactiveReadArray(this).join(separator);
1014    },
1015    // keys() iterator only reads `length`, no optimisation required
1016    lastIndexOf(...args) {
1017      return searchProxy(this, "lastIndexOf", args);
1018    },
1019    map(fn, thisArg) {
1020      return apply(this, "map", fn, thisArg, void 0, arguments);
1021    },
1022    pop() {
1023      return noTracking(this, "pop");
1024    },
1025    push(...args) {
1026      return noTracking(this, "push", args);
1027    },
1028    reduce(fn, ...args) {
1029      return reduce(this, "reduce", fn, args);
1030    },
1031    reduceRight(fn, ...args) {
1032      return reduce(this, "reduceRight", fn, args);
1033    },
1034    shift() {
1035      return noTracking(this, "shift");
1036    },
1037    // slice could use ARRAY_ITERATE but also seems to beg for range tracking
1038    some(fn, thisArg) {
1039      return apply(this, "some", fn, thisArg, void 0, arguments);
1040    },
1041    splice(...args) {
1042      return noTracking(this, "splice", args);
1043    },
1044    toReversed() {
1045      return reactiveReadArray(this).toReversed();
1046    },
1047    toSorted(comparer) {
1048      return reactiveReadArray(this).toSorted(comparer);
1049    },
1050    toSpliced(...args) {
1051      return reactiveReadArray(this).toSpliced(...args);
1052    },
1053    unshift(...args) {
1054      return noTracking(this, "unshift", args);
1055    },
1056    values() {
1057      return iterator(this, "values", toReactive);
1058    }
1059  };
1060  function iterator(self2, method, wrapValue) {
1061    const arr = shallowReadArray(self2);
1062    const iter = arr[method]();
1063    if (arr !== self2 && !isShallow(self2)) {
1064      iter._next = iter.next;
1065      iter.next = () => {
1066        const result = iter._next();
1067        if (result.value) {
1068          result.value = wrapValue(result.value);
1069        }
1070        return result;
1071      };
1072    }
1073    return iter;
1074  }
1075  const arrayProto = Array.prototype;
1076  function apply(self2, method, fn, thisArg, wrappedRetFn, args) {
1077    const arr = shallowReadArray(self2);
1078    const needsWrap = arr !== self2 && !isShallow(self2);
1079    const methodFn = arr[method];
1080    if (methodFn !== arrayProto[method]) {
1081      const result2 = methodFn.apply(self2, args);
1082      return needsWrap ? toReactive(result2) : result2;
1083    }
1084    let wrappedFn = fn;
1085    if (arr !== self2) {
1086      if (needsWrap) {
1087        wrappedFn = function(item, index2) {

1088          return fn.call(this, toReactive(item), index2, self2);
1089        };
1090      } else if (fn.length > 2) {
1091        wrappedFn = function(item, index2) {
1092          return fn.call(this, item, index2, self2);
1093        };
1094      }
1095    }
1096    const result = methodFn.call(arr, wrappedFn, thisArg);
1097    return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
1098  }
1099  function reduce(self2, method, fn, args) {
1100    const arr = shallowReadArray(self2);
1101    let wrappedFn = fn;
1102    if (arr !== self2) {
1103      if (!isShallow(self2)) {
1104        wrappedFn = function(acc, item, index2) {
1105          return fn.call(this, acc, toReactive(item), index2, self2);
1106        };
1107      } else if (fn.length > 3) {
1108        wrappedFn = function(acc, item, index2) {
1109          return fn.call(this, acc, item, index2, self2);
1110        };
1111      }
1112    }
1113    return arr[method](wrappedFn, ...args);
1114  }
1115  function searchProxy(self2, method, args) {
1116    const arr = toRaw(self2);
1117    track(arr, "iterate", ARRAY_ITERATE_KEY);
1118    const res = arr[method](...args);
1119    if ((res === -1 || res === false) && isProxy(args[0])) {
1120      args[0] = toRaw(args[0]);
1121      return arr[method](...args);
1122    }
1123    return res;
1124  }
1125  function noTracking(self2, method, args = []) {
1126    pauseTracking();
1127    startBatch();
1128    const res = toRaw(self2)[method].apply(self2, args);
1129    endBatch();
1130    resetTracking();
1131    return res;
1132  }
1133  const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
1134  const builtInSymbols = new Set(
1135    /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
1136  );
1137  function hasOwnProperty(key) {
1138    if (!isSymbol(key))
1139      key = String(key);
1140    const obj = toRaw(this);
1141    track(obj, "has", key);
1142    return obj.hasOwnProperty(key);
1143  }
1144  class BaseReactiveHandler {
1145    constructor(_isReadonly = false, _isShallow = false) {
1146      this._isReadonly = _isReadonly;
1147      this._isShallow = _isShallow;
1148    }
1149    get(target, key, receiver) {
1150      const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
1151      if (key === "__v_isReactive") {
1152        return !isReadonly2;
1153      } else if (key === "__v_isReadonly") {
1154        return isReadonly2;
1155      } else if (key === "__v_isShallow") {
1156        return isShallow2;
1157      } else if (key === "__v_raw") {
1158        if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
1159        // this means the receiver is a user proxy of the reactive proxy
1160        Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
1161          return target;
1162        }
1163        return;
1164      }
1165      const targetIsArray = isArray(target);
1166      if (!isReadonly2) {
1167        let fn;
1168        if (targetIsArray && (fn = arrayInstrumentations[key])) {
1169          return fn;
1170        }
1171        if (key === "hasOwnProperty") {
1172          return hasOwnProperty;
1173        }
1174      }
1175      const res = Reflect.get(
1176        target,
1177        key,
1178        // if this is a proxy wrapping a ref, return methods using the raw ref
1179        // as receiver so that we don't have to call `toRaw` on the ref in all
1180        // its class methods
1181        isRef(target) ? target : receiver
1182      );
1183      if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
1184        return res;
1185      }
1186      if (!isReadonly2) {
1187        track(target, "get", key);
1188      }
1189      if (isShallow2) {
1190        return res;
1191      }
1192      if (isRef(res)) {
1193        return targetIsArray && isIntegerKey(key) ? res : res.value;
1194      }
1195      if (isObject(res)) {
1196        return isReadonly2 ? readonly(res) : reactive(res);
1197      }
1198      return res;
1199    }
1200  }
1201  class MutableReactiveHandler extends BaseReactiveHandler {
1202    constructor(isShallow2 = false) {
1203      super(false, isShallow2);
1204    }
1205    set(target, key, value, receiver) {
1206      let oldValue = target[key];
1207      if (!this._isShallow) {
1208        const isOldValueReadonly = isReadonly(oldValue);
1209        if (!isShallow(value) && !isReadonly(value)) {
1210          oldValue = toRaw(oldValue);
1211          value = toRaw(value);
1212        }
1213        if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
1214          if (isOldValueReadonly) {
1215            return false;

1216          } else {
1217            oldValue.value = value;
1218            return true;
1219          }
1220        }
1221      }
1222      const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
1223      const result = Reflect.set(
1224        target,
1225        key,
1226        value,
1227        isRef(target) ? target : receiver
1228      );
1229      if (target === toRaw(receiver)) {
1230        if (!hadKey) {
1231          trigger(target, "add", key, value);
1232        } else if (hasChanged(value, oldValue)) {
1233          trigger(target, "set", key, value);
1234        }
1235      }
1236      return result;
1237    }
1238    deleteProperty(target, key) {
1239      const hadKey = hasOwn(target, key);
1240      target[key];
1241      const result = Reflect.deleteProperty(target, key);
1242      if (result && hadKey) {
1243        trigger(target, "delete", key, void 0);
1244      }
1245      return result;
1246    }
1247    has(target, key) {
1248      const result = Reflect.has(target, key);
1249      if (!isSymbol(key) || !builtInSymbols.has(key)) {
1250        track(target, "has", key);
1251      }
1252      return result;
1253    }
1254    ownKeys(target) {
1255      track(
1256        target,
1257        "iterate",
1258        isArray(target) ? "length" : ITERATE_KEY
1259      );
1260      return Reflect.ownKeys(target);
1261    }
1262  }
1263  class ReadonlyReactiveHandler extends BaseReactiveHandler {
1264    constructor(isShallow2 = false) {
1265      super(true, isShallow2);
1266    }
1267    set(target, key) {
1268      return true;
1269    }
1270    deleteProperty(target, key) {
1271      return true;
1272    }
1273  }
1274  const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
1275  const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
1276  const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true);
1277  const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
1278  const toShallow = (value) => value;
1279  const getProto = (v) => Reflect.getPrototypeOf(v);
1280  function createIterableMethod(method, isReadonly2, isShallow2) {
1281    return function(...args) {
1282      const target = this["__v_raw"];
1283      const rawTarget = toRaw(target);
1284      const targetIsMap = isMap(rawTarget);
1285      const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
1286      const isKeyOnly = method === "keys" && targetIsMap;
1287      const innerIterator = target[method](...args);
1288      const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
1289      !isReadonly2 && track(
1290        rawTarget,
1291        "iterate",
1292        isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
1293      );
1294      return {
1295        // iterator protocol
1296        next() {
1297          const { value, done } = innerIterator.next();
1298          return done ? { value, done } : {
1299            value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
1300            done
1301          };
1302        },
1303        // iterable protocol
1304        [Symbol.iterator]() {
1305          return this;
1306        }
1307      };
1308    };
1309  }
1310  function createReadonlyMethod(type) {
1311    return function(...args) {
1312      return type === "delete" ? false : type === "clear" ? void 0 : this;
1313    };
1314  }
1315  function createInstrumentations(readonly2, shallow) {
1316    const instrumentations = {
1317      get(key) {
1318        const target = this["__v_raw"];
1319        const rawTarget = toRaw(target);
1320        const rawKey = toRaw(key);
1321        if (!readonly2) {
1322          if (hasChanged(key, rawKey)) {
1323            track(rawTarget, "get", key);
1324          }
1325          track(rawTarget, "get", rawKey);
1326        }
1327        const { has } = getProto(rawTarget);
1328        const wrap = shallow ? toShallow : readonly2 ? toReadonly : toReactive;
1329        if (has.call(rawTarget, key)) {
1330          return wrap(target.get(key));
1331        } else if (has.call(rawTarget, rawKey)) {
1332          return wrap(target.get(rawKey));
1333        } else if (target !== rawTarget) {
1334          target.get(key);
1335        }
1336      },
1337      get size() {
1338        const target = this["__v_raw"];
1339        !readonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
1340        return Reflect.get(target, "size", target);
1341      },
1342      has(key) {
1343        const target = this["__v_raw"];
1344        const rawTarget = toRaw(target);
1345        const rawKey = toRaw(key);
1346        if (!readonly2) {
1347          if (hasChanged(key, rawKey)) {
1348            track(rawTarget, "has", key);
1349          }
1350          track(rawTarget, "has", rawKey);
1351        }
1352        return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
1353      },

vendor: 17,237 bytes, lines 1354-1954

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

vendor: 7,395 bytes, lines 1955-2199

1955    seen = seen || /* @__PURE__ */ new Set();
1956    if (seen.has(value)) {
1957      return value;
1958    }
1959    seen.add(value);
1960    depth--;
1961    if (isRef(value)) {
1962      traverse(value.value, depth, seen);
1963    } else if (isArray(value)) {
1964      for (let i = 0; i < value.length; i++) {
1965        traverse(value[i], depth, seen);
1966      }
1967    } else if (isSet(value) || isMap(value)) {
1968      value.forEach((v) => {
1969        traverse(v, depth, seen);
1970      });
1971    } else if (isPlainObject(value)) {
1972      for (const key in value) {
1973        traverse(value[key], depth, seen);
1974      }
1975      for (const key of Object.getOwnPropertySymbols(value)) {
1976        if (Object.prototype.propertyIsEnumerable.call(value, key)) {
1977          traverse(value[key], depth, seen);
1978        }
1979      }
1980    }
1981    return value;
1982  }
1983  /**
1984  * @vue/runtime-core v3.5.12
1985  * (c) 2018-present Yuxi (Evan) You and Vue contributors
1986  * @license MIT
1987  **/
1988  const stack = [];
1989  function pushWarningContext$1(vnode) {
1990    stack.push(vnode);
1991  }
1992  function popWarningContext$1() {
1993    stack.pop();
1994  }
1995  let isWarning = false;
1996  function warn$1(msg, ...args) {
1997    if (isWarning)
1998      return;
1999    isWarning = true;
2000    pauseTracking();
2001    const instance = stack.length ? stack[stack.length - 1].component : null;
2002    const appWarnHandler = instance && instance.appContext.config.warnHandler;
2003    const trace = getComponentTrace();
2004    if (appWarnHandler) {
2005      callWithErrorHandling(
2006        appWarnHandler,
2007        instance,
2008        11,
2009        [
2010          // eslint-disable-next-line no-restricted-syntax
2011          msg + args.map((a) => {
2012            var _a, _b;
2013            return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
2014          }).join(""),
2015          instance && instance.proxy,
2016          trace.map(
2017            ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
2018          ).join("\n"),
2019          trace
2020        ]
2021      );
2022    } else {
2023      const warnArgs = [`[Vue warn]: ${msg}`, ...args];
2024      if (trace.length && // avoid spamming console during tests
2025      true) {
2026        warnArgs.push(`
2027`, ...formatTrace(trace));
2028      }
2029      console.warn(...warnArgs);
2030    }
2031    resetTracking();
2032    isWarning = false;
2033  }
2034  function getComponentTrace() {
2035    let currentVNode = stack[stack.length - 1];
2036    if (!currentVNode) {
2037      return [];
2038    }
2039    const normalizedStack = [];
2040    while (currentVNode) {
2041      const last = normalizedStack[0];
2042      if (last && last.vnode === currentVNode) {
2043        last.recurseCount++;
2044      } else {
2045        normalizedStack.push({
2046          vnode: currentVNode,
2047          recurseCount: 0
2048        });
2049      }
2050      const parentInstance = currentVNode.component && currentVNode.component.parent;
2051      currentVNode = parentInstance && parentInstance.vnode;
2052    }
2053    return normalizedStack;
2054  }
2055  function formatTrace(trace) {
2056    const logs = [];
2057    trace.forEach((entry, i) => {
2058      logs.push(...i === 0 ? [] : [`
2059`], ...formatTraceEntry(entry));
2060    });
2061    return logs;
2062  }
2063  function formatTraceEntry({ vnode, recurseCount }) {
2064    const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
2065    const isRoot = vnode.component ? vnode.component.parent == null : false;
2066    const open = ` at <${formatComponentName(
2067      vnode.component,
2068      vnode.type,
2069      isRoot
2070    )}`;
2071    const close = `>` + postfix;
2072    return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
2073  }
2074  function formatProps(props) {
2075    const res = [];
2076    const keys = Object.keys(props);
2077    keys.slice(0, 3).forEach((key) => {
2078      res.push(...formatProp(key, props[key]));
2079    });
2080    if (keys.length > 3) {
2081      res.push(` ...`);
2082    }
2083    return res;
2084  }
2085  function formatProp(key, value, raw) {
2086    if (isString(value)) {
2087      value = JSON.stringify(value);
2088      return raw ? value : [`${key}=${value}`];
2089    } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
2090      return raw ? value : [`${key}=${value}`];
2091    } else if (isRef(value)) {
2092      value = formatProp(key, toRaw(value.value), true);
2093      return raw ? value : [`${key}=Ref<`, value, `>`];
2094    } else if (isFunction(value)) {
2095      return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
2096    } else {
2097      value = toRaw(value);
2098      return raw ? value : [`${key}=`, value];
2099    }
2100  }
2101  function assertNumber(val, type) {
2102    return;
2103  }
2104  const ErrorCodes = {
2105    "SETUP_FUNCTION": 0,
2106    "0": "SETUP_FUNCTION",
2107    "RENDER_FUNCTION": 1,
2108    "1": "RENDER_FUNCTION",
2109    "NATIVE_EVENT_HANDLER": 5,
2110    "5": "NATIVE_EVENT_HANDLER",
2111    "COMPONENT_EVENT_HANDLER": 6,
2112    "6": "COMPONENT_EVENT_HANDLER",
2113    "VNODE_HOOK": 7,
2114    "7": "VNODE_HOOK",
2115    "DIRECTIVE_HOOK": 8,
2116    "8": "DIRECTIVE_HOOK",
2117    "TRANSITION_HOOK": 9,
2118    "9": "TRANSITION_HOOK",
2119    "APP_ERROR_HANDLER": 10,
2120    "10": "APP_ERROR_HANDLER",
2121    "APP_WARN_HANDLER": 11,
2122    "11": "APP_WARN_HANDLER",
2123    "FUNCTION_REF": 12,
2124    "12": "FUNCTION_REF",
2125    "ASYNC_COMPONENT_LOADER": 13,
2126    "13": "ASYNC_COMPONENT_LOADER",
2127    "SCHEDULER": 14,
2128    "14": "SCHEDULER",
2129    "COMPONENT_UPDATE": 15,
2130    "15": "COMPONENT_UPDATE",
2131    "APP_UNMOUNT_CLEANUP": 16,
2132    "16": "APP_UNMOUNT_CLEANUP"
2133  };
2134  const ErrorTypeStrings$1 = {
2135    ["sp"]: "serverPrefetch hook",
2136    ["bc"]: "beforeCreate hook",
2137    ["c"]: "created hook",
2138    ["bm"]: "beforeMount hook",
2139    ["m"]: "mounted hook",
2140    ["bu"]: "beforeUpdate hook",
2141    ["u"]: "updated",
2142    ["bum"]: "beforeUnmount hook",
2143    ["um"]: "unmounted hook",
2144    ["a"]: "activated hook",
2145    ["da"]: "deactivated hook",
2146    ["ec"]: "errorCaptured hook",
2147    ["rtc"]: "renderTracked hook",
2148    ["rtg"]: "renderTriggered hook",
2149    [0]: "setup function",
2150    [1]: "render function",
2151    [2]: "watcher getter",
2152    [3]: "watcher callback",
2153    [4]: "watcher cleanup function",
2154    [5]: "native event handler",
2155    [6]: "component event handler",
2156    [7]: "vnode hook",
2157    [8]: "directive hook",
2158    [9]: "transition hook",
2159    [10]: "app errorHandler",
2160    [11]: "app warnHandler",
2161    [12]: "ref function",
2162    [13]: "async component loader",
2163    [14]: "scheduler flush",
2164    [15]: "component update",
2165    [16]: "app unmount cleanup function"
2166  };
2167  function callWithErrorHandling(fn, instance, type, args) {
2168    try {
2169      return args ? fn(...args) : fn();
2170    } catch (err) {
2171      handleError(err, instance, type);
2172    }
2173  }
2174  function callWithAsyncErrorHandling(fn, instance, type, args) {
2175    if (isFunction(fn)) {
2176      const res = callWithErrorHandling(fn, instance, type, args);
2177      if (res && isPromise(res)) {
2178        res.catch((err) => {
2179          handleError(err, instance, type);
2180        });
2181      }
2182      return res;
2183    }
2184    if (isArray(fn)) {
2185      const values = [];
2186      for (let i = 0; i < fn.length; i++) {
2187        values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
2188      }
2189      return values;
2190    }
2191  }
2192  function handleError(err, instance, type, throwInDev = true) {
2193    const contextVNode = instance ? instance.vnode : null;
2194    const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
2195    if (instance) {
2196      let cur = instance.parent;
2197      const exposedInstance = instance.proxy;
2198      const errorInfo = `https://vuejs.org/error-reference/#runtime-${type}`;
2199      while (cur) {

2200        const errorCapturedHooks = cur.ec;
2201        if (errorCapturedHooks) {
2202          for (let i = 0; i < errorCapturedHooks.length; i++) {
2203            if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
2204              return;
2205            }
2206          }
2207        }
2208        cur = cur.parent;
2209      }
2210      if (errorHandler) {
2211        pauseTracking();
2212        callWithErrorHandling(errorHandler, null, 10, [
2213          err,
2214          exposedInstance,
2215          errorInfo
2216        ]);
2217        resetTracking();
2218        return;
2219      }
2220    }
2221    logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
2222  }
2223  function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
2224    if (throwInProd) {
2225      throw err;
2226    } else {
2227      console.error(err);
2228    }
2229  }
2230  const queue = [];
2231  let flushIndex = -1;
2232  const pendingPostFlushCbs = [];
2233  let activePostFlushCbs = null;
2234  let postFlushIndex = 0;
2235  const resolvedPromise = /* @__PURE__ */ Promise.resolve();
2236  let currentFlushPromise = null;
2237  function nextTick(fn) {
2238    const p2 = currentFlushPromise || resolvedPromise;
2239    return fn ? p2.then(this ? fn.bind(this) : fn) : p2;
2240  }
2241  function findInsertionIndex(id) {
2242    let start = flushIndex + 1;
2243    let end = queue.length;
2244    while (start < end) {
2245      const middle = start + end >>> 1;
2246      const middleJob = queue[middle];
2247      const middleJobId = getId(middleJob);
2248      if (middleJobId < id || middleJobId === id && middleJob.flags & 2) {
2249        start = middle + 1;
2250      } else {
2251        end = middle;
2252      }
2253    }
2254    return start;
2255  }
2256  function queueJob(job) {
2257    if (!(job.flags & 1)) {
2258      const jobId = getId(job);
2259      const lastJob = queue[queue.length - 1];
2260      if (!lastJob || // fast path when the job id is larger than the tail
2261      !(job.flags & 2) && jobId >= getId(lastJob)) {
2262        queue.push(job);
2263      } else {
2264        queue.splice(findInsertionIndex(jobId), 0, job);
2265      }
2266      job.flags |= 1;
2267      queueFlush();
2268    }
2269  }
2270  function queueFlush() {
2271    if (!currentFlushPromise) {
2272      currentFlushPromise = resolvedPromise.then(flushJobs);
2273    }
2274  }
2275  function queuePostFlushCb(cb) {
2276    if (!isArray(cb)) {
2277      if (activePostFlushCbs && cb.id === -1) {
2278        activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
2279      } else if (!(cb.flags & 1)) {
2280        pendingPostFlushCbs.push(cb);
2281        cb.flags |= 1;
2282      }
2283    } else {
2284      pendingPostFlushCbs.push(...cb);
2285    }
2286    queueFlush();
2287  }
2288  function flushPreFlushCbs(instance, seen, i = flushIndex + 1) {
2289    for (; i < queue.length; i++) {
2290      const cb = queue[i];
2291      if (cb && cb.flags & 2) {
2292        if (instance && cb.id !== instance.uid) {
2293          continue;
2294        }
2295        queue.splice(i, 1);
2296        i--;
2297        if (cb.flags & 4) {
2298          cb.flags &= ~1;
2299        }
2300        cb();
2301        if (!(cb.flags & 4)) {
2302          cb.flags &= ~1;
2303        }
2304      }
2305    }
2306  }
2307  function flushPostFlushCbs(seen) {
2308    if (pendingPostFlushCbs.length) {
2309      const deduped = [...new Set(pendingPostFlushCbs)].sort(
2310        (a, b) => getId(a) - getId(b)
2311      );
2312      pendingPostFlushCbs.length = 0;
2313      if (activePostFlushCbs) {
2314        activePostFlushCbs.push(...deduped);
2315        return;
2316      }
2317      activePostFlushCbs = deduped;
2318      for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
2319        const cb = activePostFlushCbs[postFlushIndex];
2320        if (cb.flags & 4) {
2321          cb.flags &= ~1;
2322        }
2323        if (!(cb.flags & 8))
2324          cb();
2325        cb.flags &= ~1;
2326      }
2327      activePostFlushCbs = null;
2328      postFlushIndex = 0;
2329    }
2330  }
2331  const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
2332  function flushJobs(seen) {
2333    const check = NOOP;
2334    try {
2335      for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
2336        const job = queue[flushIndex];
2337        if (job && !(job.flags & 8)) {
2338          if (false)
2339            ;
2340          if (job.flags & 4) {
2341            job.flags &= ~1;
2342          }
2343          callWithErrorHandling(
2344            job,
2345            job.i,
2346            job.i ? 15 : 14
2347          );
2348          if (!(job.flags & 4)) {
2349            job.flags &= ~1;
2350          }
2351        }
2352      }
2353    } finally {
2354      for (; flushIndex < queue.length; flushIndex++) {
2355        const job = queue[flushIndex];
2356        if (job) {
2357          job.flags &= ~1;
2358        }
2359      }
2360      flushIndex = -1;
2361      queue.length = 0;
2362      flushPostFlushCbs();
2363      currentFlushPromise = null;
2364      if (queue.length || pendingPostFlushCbs.length) {
2365        flushJobs();
2366      }
2367    }
2368  }
2369  let devtools$1;
2370  let buffer = [];
2371  function setDevtoolsHook$1(hook, target) {
2372    var _a, _b;
2373    devtools$1 = hook;
2374    if (devtools$1) {
2375      devtools$1.enabled = true;
2376      buffer.forEach(({ event, args }) => devtools$1.emit(event, ...args));
2377      buffer = [];
2378    } else if (
2379      // handle late devtools injection - only do this if we are in an actual
2380      // browser environment to avoid the timer handle stalling test runner exit
2381      // (#4815)
2382      typeof window !== "undefined" && // some envs mock window but not fully
2383      window.HTMLElement && // also exclude jsdom
2384      // eslint-disable-next-line no-restricted-syntax
2385      !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
2386    ) {
2387      const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
2388      replay.push((newHook) => {

2389        setDevtoolsHook$1(newHook, target);
2390      });
2391      setTimeout(() => {
2392        if (!devtools$1) {
2393          target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
2394          buffer = [];
2395        }
2396      }, 3e3);
2397    } else {
2398      buffer = [];
2399    }
2400  }
2401  let currentRenderingInstance = null;
2402  let currentScopeId = null;
2403  function setCurrentRenderingInstance$1(instance) {
2404    const prev = currentRenderingInstance;
2405    currentRenderingInstance = instance;
2406    currentScopeId = instance && instance.type.__scopeId || null;
2407    return prev;
2408  }
2409  function pushScopeId(id) {
2410    currentScopeId = id;
2411  }
2412  function popScopeId() {
2413    currentScopeId = null;
2414  }
2415  const withScopeId = (_id) => withCtx;
2416  function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
2417    if (!ctx)
2418      return fn;
2419    if (fn._n) {
2420      return fn;
2421    }
2422    const renderFnWithContext = (...args) => {
2423      if (renderFnWithContext._d) {
2424        setBlockTracking(-1);
2425      }
2426      const prevInstance = setCurrentRenderingInstance$1(ctx);
2427      let res;
2428      try {
2429        res = fn(...args);
2430      } finally {
2431        setCurrentRenderingInstance$1(prevInstance);
2432        if (renderFnWithContext._d) {
2433          setBlockTracking(1);
2434        }
2435      }
2436      return res;
2437    };
2438    renderFnWithContext._n = true;
2439    renderFnWithContext._c = true;
2440    renderFnWithContext._d = true;
2441    return renderFnWithContext;
2442  }
2443  function withDirectives(vnode, directives) {
2444    if (currentRenderingInstance === null) {
2445      return vnode;
2446    }
2447    const instance = getComponentPublicInstance(currentRenderingInstance);
2448    const bindings = vnode.dirs || (vnode.dirs = []);
2449    for (let i = 0; i < directives.length; i++) {
2450      let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
2451      if (dir) {
2452        if (isFunction(dir)) {
2453          dir = {
2454            mounted: dir,
2455            updated: dir
2456          };
2457        }
2458        if (dir.deep) {
2459          traverse(value);
2460        }
2461        bindings.push({
2462          dir,
2463          instance,
2464          value,
2465          oldValue: void 0,
2466          arg,
2467          modifiers
2468        });
2469      }
2470    }
2471    return vnode;
2472  }
2473  function invokeDirectiveHook(vnode, prevVNode, instance, name) {
2474    const bindings = vnode.dirs;
2475    const oldBindings = prevVNode && prevVNode.dirs;
2476    for (let i = 0; i < bindings.length; i++) {
2477      const binding = bindings[i];
2478      if (oldBindings) {
2479        binding.oldValue = oldBindings[i].value;
2480      }
2481      let hook = binding.dir[name];
2482      if (hook) {
2483        pauseTracking();
2484        callWithAsyncErrorHandling(hook, instance, 8, [
2485          vnode.el,
2486          binding,
2487          vnode,
2488          prevVNode
2489        ]);
2490        resetTracking();
2491      }
2492    }
2493  }
2494  const TeleportEndKey = Symbol("_vte");
2495  const isTeleport = (type) => type.__isTeleport;
2496  const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");
2497  const isTeleportDeferred = (props) => props && (props.defer || props.defer === "");
2498  const isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement;
2499  const isTargetMathML = (target) => typeof MathMLElement === "function" && target instanceof MathMLElement;
2500  const resolveTarget = (props, select) => {
2501    const targetSelector = props && props.to;
2502    if (isString(targetSelector)) {
2503      if (!select) {
2504        return null;
2505      } else {
2506        const target = select(targetSelector);
2507        return target;
2508      }
2509    } else {
2510      return targetSelector;
2511    }
2512  };
2513  const TeleportImpl = {
2514    name: "Teleport",
2515    __isTeleport: true,
2516    process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals) {
2517      const {
2518        mc: mountChildren,
2519        pc: patchChildren,
2520        pbc: patchBlockChildren,
2521        o: { insert, querySelector, createText, createComment }
2522      } = internals;
2523      const disabled = isTeleportDisabled(n2.props);
2524      let { shapeFlag, children, dynamicChildren } = n2;
2525      if (n1 == null) {
2526        const placeholder = n2.el = createText("");
2527        const mainAnchor = n2.anchor = createText("");
2528        insert(placeholder, container, anchor);
2529        insert(mainAnchor, container, anchor);
2530        const mount = (container2, anchor2) => {
2531          if (shapeFlag & 16) {
2532            if (parentComponent && parentComponent.isCE) {
2533              parentComponent.ce._teleportTarget = container2;
2534            }
2535            mountChildren(
2536              children,
2537              container2,
2538              anchor2,
2539              parentComponent,
2540              parentSuspense,
2541              namespace,
2542              slotScopeIds,
2543              optimized
2544            );
2545          }
2546        };
2547        const mountToTarget = () => {
2548          const target = n2.target = resolveTarget(n2.props, querySelector);
2549          const targetAnchor = prepareAnchor(target, n2, createText, insert);
2550          if (target) {
2551            if (namespace !== "svg" && isTargetSVG(target)) {
2552              namespace = "svg";
2553            } else if (namespace !== "mathml" && isTargetMathML(target)) {
2554              namespace = "mathml";
2555            }
2556            if (!disabled) {
2557              mount(target, targetAnchor);
2558              updateCssVars(n2, false);
2559            }
2560          }
2561        };
2562        if (disabled) {
2563          mount(container, mainAnchor);
2564          updateCssVars(n2, true);
2565        }
2566        if (isTeleportDeferred(n2.props)) {
2567          queuePostRenderEffect(mountToTarget, parentSuspense);
2568        } else {
2569          mountToTarget();
2570        }
2571      } else {
2572        n2.el = n1.el;
2573        n2.targetStart = n1.targetStart;
2574        const mainAnchor = n2.anchor = n1.anchor;
2575        const target = n2.target = n1.target;
2576        const targetAnchor = n2.targetAnchor = n1.targetAnchor;
2577        const wasDisabled = isTeleportDisabled(n1.props);
2578        const currentContainer = wasDisabled ? container : target;
2579        const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
2580        if (namespace === "svg" || isTargetSVG(target)) {
2581          namespace = "svg";
2582        } else if (namespace === "mathml" || isTargetMathML(target)) {
2583          namespace = "mathml";
2584        }
2585        if (dynamicChildren) {
2586          patchBlockChildren(
2587            n1.dynamicChildren,
2588            dynamicChildren,
2589            currentContainer,
2590            parentComponent,
2591            parentSuspense,
2592            namespace,
2593            slotScopeIds
2594          );
2595          traverseStaticChildren(n1, n2, true);
2596        } else if (!optimized) {
2597          patchChildren(
2598            n1,
2599            n2,
2600            currentContainer,
2601            currentAnchor,
2602            parentComponent,
2603            parentSuspense,
2604            namespace,
2605            slotScopeIds,
2606            false
2607          );
2608        }
2609        if (disabled) {
2610          if (!wasDisabled) {
2611            moveTeleport(
2612              n2,
2613              container,
2614              mainAnchor,
2615              internals,
2616              1
2617            );
2618          } else {
2619            if (n2.props && n1.props && n2.props.to !== n1.props.to) {
2620              n2.props.to = n1.props.to;
2621            }
2622          }
2623        } else {
2624          if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
2625            const nextTarget = n2.target = resolveTarget(
2626              n2.props,
2627              querySelector
2628            );
2629            if (nextTarget) {
2630              moveTeleport(
2631                n2,
2632                nextTarget,
2633                null,
2634                internals,
2635                0
2636              );
2637            }
2638          } else if (wasDisabled) {
2639            moveTeleport(
2640              n2,
2641              target,
2642              targetAnchor,
2643              internals,
2644              1
2645            );
2646          }
2647        }
2648        updateCssVars(n2, disabled);
2649      }
2650    },
2651    remove(vnode, parentComponent, parentSuspense, { um: unmount, o: { remove: hostRemove } }, doRemove) {
2652      const {
2653        shapeFlag,
2654        children,
2655        anchor,
2656        targetStart,
2657        targetAnchor,
2658        target,
2659        props
2660      } = vnode;
2661      if (target) {

2662        hostRemove(targetStart);
2663        hostRemove(targetAnchor);
2664      }
2665      doRemove && hostRemove(anchor);
2666      if (shapeFlag & 16) {
2667        const shouldRemove = doRemove || !isTeleportDisabled(props);
2668        for (let i = 0; i < children.length; i++) {
2669          const child = children[i];
2670          unmount(
2671            child,
2672            parentComponent,
2673            parentSuspense,
2674            shouldRemove,
2675            !!child.dynamicChildren
2676          );
2677        }
2678      }
2679    },
2680    move: moveTeleport,
2681    hydrate: hydrateTeleport
2682  };
2683  function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
2684    if (moveType === 0) {
2685      insert(vnode.targetAnchor, container, parentAnchor);
2686    }
2687    const { el, anchor, shapeFlag, children, props } = vnode;
2688    const isReorder = moveType === 2;
2689    if (isReorder) {
2690      insert(el, container, parentAnchor);
2691    }
2692    if (!isReorder || isTeleportDisabled(props)) {
2693      if (shapeFlag & 16) {
2694        for (let i = 0; i < children.length; i++) {
2695          move(
2696            children[i],
2697            container,
2698            parentAnchor,
2699            2
2700          );
2701        }
2702      }
2703    }
2704    if (isReorder) {
2705      insert(anchor, container, parentAnchor);
2706    }
2707  }
2708  function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, {
2709    o: { nextSibling, parentNode, querySelector, insert, createText }
2710  }, hydrateChildren) {
2711    const target = vnode.target = resolveTarget(
2712      vnode.props,
2713      querySelector
2714    );
2715    if (target) {
2716      const disabled = isTeleportDisabled(vnode.props);
2717      const targetNode = target._lpa || target.firstChild;
2718      if (vnode.shapeFlag & 16) {
2719        if (disabled) {
2720          vnode.anchor = hydrateChildren(
2721            nextSibling(node),
2722            vnode,
2723            parentNode(node),
2724            parentComponent,
2725            parentSuspense,
2726            slotScopeIds,
2727            optimized
2728          );
2729          vnode.targetStart = targetNode;
2730          vnode.targetAnchor = targetNode && nextSibling(targetNode);
2731        } else {
2732          vnode.anchor = nextSibling(node);
2733          let targetAnchor = targetNode;
2734          while (targetAnchor) {
2735            if (targetAnchor && targetAnchor.nodeType === 8) {
2736              if (targetAnchor.data === "teleport start anchor") {
2737                vnode.targetStart = targetAnchor;
2738              } else if (targetAnchor.data === "teleport anchor") {
2739                vnode.targetAnchor = targetAnchor;
2740                target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
2741                break;
2742              }
2743            }
2744            targetAnchor = nextSibling(targetAnchor);
2745          }
2746          if (!vnode.targetAnchor) {
2747            prepareAnchor(target, vnode, createText, insert);
2748          }
2749          hydrateChildren(
2750            targetNode && nextSibling(targetNode),
2751            vnode,
2752            target,
2753            parentComponent,
2754            parentSuspense,
2755            slotScopeIds,
2756            optimized
2757          );
2758        }
2759      }
2760      updateCssVars(vnode, disabled);
2761    }
2762    return vnode.anchor && nextSibling(vnode.anchor);
2763  }
2764  const Teleport = TeleportImpl;
2765  function updateCssVars(vnode, isDisabled) {
2766    const ctx = vnode.ctx;
2767    if (ctx && ctx.ut) {
2768      let node, anchor;
2769      if (isDisabled) {
2770        node = vnode.el;
2771        anchor = vnode.anchor;
2772      } else {
2773        node = vnode.targetStart;
2774        anchor = vnode.targetAnchor;
2775      }
2776      while (node && node !== anchor) {
2777        if (node.nodeType === 1)
2778          node.setAttribute("data-v-owner", ctx.uid);
2779        node = node.nextSibling;
2780      }
2781      ctx.ut();
2782    }
2783  }
2784  function prepareAnchor(target, vnode, createText, insert) {
2785    const targetStart = vnode.targetStart = createText("");
2786    const targetAnchor = vnode.targetAnchor = createText("");
2787    targetStart[TeleportEndKey] = targetAnchor;
2788    if (target) {
2789      insert(targetStart, target);
2790      insert(targetAnchor, target);
2791    }
2792    return targetAnchor;
2793  }
2794  const leaveCbKey = Symbol("_leaveCb");
2795  const enterCbKey$1 = Symbol("_enterCb");
2796  function useTransitionState() {
2797    const state = {
2798      isMounted: false,
2799      isLeaving: false,
2800      isUnmounting: false,
2801      leavingVNodes: /* @__PURE__ */ new Map()
2802    };
2803    onMounted(() => {
2804      state.isMounted = true;
2805    });
2806    onBeforeUnmount(() => {
2807      state.isUnmounting = true;
2808    });
2809    return state;
2810  }
2811  const TransitionHookValidator = [Function, Array];
2812  const BaseTransitionPropsValidators = {
2813    mode: String,
2814    appear: Boolean,
2815    persisted: Boolean,
2816    // enter
2817    onBeforeEnter: TransitionHookValidator,
2818    onEnter: TransitionHookValidator,
2819    onAfterEnter: TransitionHookValidator,
2820    onEnterCancelled: TransitionHookValidator,
2821    // leave
2822    onBeforeLeave: TransitionHookValidator,
2823    onLeave: TransitionHookValidator,
2824    onAfterLeave: TransitionHookValidator,
2825    onLeaveCancelled: TransitionHookValidator,
2826    // appear
2827    onBeforeAppear: TransitionHookValidator,
2828    onAppear: TransitionHookValidator,
2829    onAfterAppear: TransitionHookValidator,
2830    onAppearCancelled: TransitionHookValidator
2831  };
2832  const recursiveGetSubtree = (instance) => {
2833    const subTree = instance.subTree;
2834    return subTree.component ? recursiveGetSubtree(subTree.component) : subTree;
2835  };
2836  const BaseTransitionImpl = {
2837    name: `BaseTransition`,
2838    props: BaseTransitionPropsValidators,
2839    setup(props, { slots }) {
2840      const instance = getCurrentInstance();
2841      const state = useTransitionState();
2842      return () => {
2843        const children = slots.default && getTransitionRawChildren(slots.default(), true);
2844        if (!children || !children.length) {
2845          return;
2846        }
2847        const child = findNonCommentChild(children);
2848        const rawProps = toRaw(props);
2849        const { mode } = rawProps;
2850        if (state.isLeaving) {
2851          return emptyPlaceholder(child);
2852        }
2853        const innerChild = getInnerChild$1(child);
2854        if (!innerChild) {
2855          return emptyPlaceholder(child);
2856        }
2857        let enterHooks = resolveTransitionHooks(
2858          innerChild,
2859          rawProps,
2860          state,
2861          instance,
2862          // #11061, ensure enterHooks is fresh after clone
2863          (hooks) => enterHooks = hooks
2864        );
2865        if (innerChild.type !== Comment) {
2866          setTransitionHooks(innerChild, enterHooks);
2867        }

2868        const oldChild = instance.subTree;
2869        const oldInnerChild = oldChild && getInnerChild$1(oldChild);
2870        if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(innerChild, oldInnerChild) && recursiveGetSubtree(instance).type !== Comment) {
2871          const leavingHooks = resolveTransitionHooks(
2872            oldInnerChild,
2873            rawProps,
2874            state,
2875            instance
2876          );
2877          setTransitionHooks(oldInnerChild, leavingHooks);
2878          if (mode === "out-in" && innerChild.type !== Comment) {
2879            state.isLeaving = true;
2880            leavingHooks.afterLeave = () => {
2881              state.isLeaving = false;
2882              if (!(instance.job.flags & 8)) {
2883                instance.update();
2884              }
2885              delete leavingHooks.afterLeave;
2886            };
2887            return emptyPlaceholder(child);
2888          } else if (mode === "in-out" && innerChild.type !== Comment) {
2889            leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
2890              const leavingVNodesCache = getLeavingNodesForType(
2891                state,
2892                oldInnerChild
2893              );
2894              leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
2895              el[leaveCbKey] = () => {
2896                earlyRemove();
2897                el[leaveCbKey] = void 0;
2898                delete enterHooks.delayedLeave;
2899              };
2900              enterHooks.delayedLeave = delayedLeave;
2901            };
2902          }
2903        }
2904        return child;
2905      };
2906    }
2907  };
2908  function findNonCommentChild(children) {

vendor: 5,565 bytes, lines 2909-3115

2909    let child = children[0];
2910    if (children.length > 1) {
2911      for (const c of children) {
2912        if (c.type !== Comment) {
2913          child = c;
2914          break;
2915        }
2916      }
2917    }
2918    return child;
2919  }
2920  const BaseTransition = BaseTransitionImpl;
2921  function getLeavingNodesForType(state, vnode) {
2922    const { leavingVNodes } = state;
2923    let leavingVNodesCache = leavingVNodes.get(vnode.type);
2924    if (!leavingVNodesCache) {
2925      leavingVNodesCache = /* @__PURE__ */ Object.create(null);
2926      leavingVNodes.set(vnode.type, leavingVNodesCache);
2927    }
2928    return leavingVNodesCache;
2929  }
2930  function resolveTransitionHooks(vnode, props, state, instance, postClone) {
2931    const {
2932      appear,
2933      mode,
2934      persisted = false,
2935      onBeforeEnter,
2936      onEnter,
2937      onAfterEnter,
2938      onEnterCancelled,
2939      onBeforeLeave,
2940      onLeave,
2941      onAfterLeave,
2942      onLeaveCancelled,
2943      onBeforeAppear,
2944      onAppear,
2945      onAfterAppear,
2946      onAppearCancelled
2947    } = props;
2948    const key = String(vnode.key);
2949    const leavingVNodesCache = getLeavingNodesForType(state, vnode);
2950    const callHook2 = (hook, args) => {
2951      hook && callWithAsyncErrorHandling(
2952        hook,
2953        instance,
2954        9,
2955        args
2956      );
2957    };
2958    const callAsyncHook = (hook, args) => {
2959      const done = args[1];
2960      callHook2(hook, args);
2961      if (isArray(hook)) {
2962        if (hook.every((hook2) => hook2.length <= 1))
2963          done();
2964      } else if (hook.length <= 1) {
2965        done();
2966      }
2967    };
2968    const hooks = {
2969      mode,
2970      persisted,
2971      beforeEnter(el) {
2972        let hook = onBeforeEnter;
2973        if (!state.isMounted) {
2974          if (appear) {
2975            hook = onBeforeAppear || onBeforeEnter;
2976          } else {
2977            return;
2978          }
2979        }
2980        if (el[leaveCbKey]) {
2981          el[leaveCbKey](
2982            true
2983            /* cancelled */
2984          );
2985        }
2986        const leavingVNode = leavingVNodesCache[key];
2987        if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {
2988          leavingVNode.el[leaveCbKey]();
2989        }
2990        callHook2(hook, [el]);
2991      },
2992      enter(el) {
2993        let hook = onEnter;
2994        let afterHook = onAfterEnter;
2995        let cancelHook = onEnterCancelled;
2996        if (!state.isMounted) {
2997          if (appear) {
2998            hook = onAppear || onEnter;
2999            afterHook = onAfterAppear || onAfterEnter;
3000            cancelHook = onAppearCancelled || onEnterCancelled;
3001          } else {
3002            return;
3003          }
3004        }
3005        let called = false;
3006        const done = el[enterCbKey$1] = (cancelled) => {
3007          if (called)
3008            return;
3009          called = true;
3010          if (cancelled) {
3011            callHook2(cancelHook, [el]);
3012          } else {
3013            callHook2(afterHook, [el]);
3014          }
3015          if (hooks.delayedLeave) {
3016            hooks.delayedLeave();
3017          }
3018          el[enterCbKey$1] = void 0;
3019        };
3020        if (hook) {
3021          callAsyncHook(hook, [el, done]);
3022        } else {
3023          done();
3024        }
3025      },
3026      leave(el, remove2) {
3027        const key2 = String(vnode.key);
3028        if (el[enterCbKey$1]) {
3029          el[enterCbKey$1](
3030            true
3031            /* cancelled */
3032          );
3033        }
3034        if (state.isUnmounting) {
3035          return remove2();
3036        }
3037        callHook2(onBeforeLeave, [el]);
3038        let called = false;
3039        const done = el[leaveCbKey] = (cancelled) => {
3040          if (called)
3041            return;
3042          called = true;
3043          remove2();
3044          if (cancelled) {
3045            callHook2(onLeaveCancelled, [el]);
3046          } else {
3047            callHook2(onAfterLeave, [el]);
3048          }
3049          el[leaveCbKey] = void 0;
3050          if (leavingVNodesCache[key2] === vnode) {
3051            delete leavingVNodesCache[key2];
3052          }
3053        };
3054        leavingVNodesCache[key2] = vnode;
3055        if (onLeave) {
3056          callAsyncHook(onLeave, [el, done]);
3057        } else {
3058          done();
3059        }
3060      },
3061      clone(vnode2) {
3062        const hooks2 = resolveTransitionHooks(
3063          vnode2,
3064          props,
3065          state,
3066          instance,
3067          postClone
3068        );
3069        if (postClone)
3070          postClone(hooks2);
3071        return hooks2;
3072      }
3073    };
3074    return hooks;
3075  }
3076  function emptyPlaceholder(vnode) {
3077    if (isKeepAlive(vnode)) {
3078      vnode = cloneVNode(vnode);
3079      vnode.children = null;
3080      return vnode;
3081    }
3082  }
3083  function getInnerChild$1(vnode) {
3084    if (!isKeepAlive(vnode)) {
3085      if (isTeleport(vnode.type) && vnode.children) {
3086        return findNonCommentChild(vnode.children);
3087      }
3088      return vnode;
3089    }
3090    const { shapeFlag, children } = vnode;
3091    if (children) {
3092      if (shapeFlag & 16) {
3093        return children[0];
3094      }
3095      if (shapeFlag & 32 && isFunction(children.default)) {
3096        return children.default();
3097      }
3098    }
3099  }
3100  function setTransitionHooks(vnode, hooks) {
3101    if (vnode.shapeFlag & 6 && vnode.component) {
3102      vnode.transition = hooks;
3103      setTransitionHooks(vnode.component.subTree, hooks);
3104    } else if (vnode.shapeFlag & 128) {
3105      vnode.ssContent.transition = hooks.clone(vnode.ssContent);
3106      vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
3107    } else {
3108      vnode.transition = hooks;
3109    }
3110  }
3111  function getTransitionRawChildren(children, keepComment = false, parentKey) {
3112    let ret = [];
3113    let keyedFragmentCount = 0;
3114    for (let i = 0; i < children.length; i++) {
3115      let child = children[i];

3116      const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
3117      if (child.type === Fragment) {
3118        if (child.patchFlag & 128)
3119          keyedFragmentCount++;
3120        ret = ret.concat(
3121          getTransitionRawChildren(child.children, keepComment, key)
3122        );
3123      } else if (keepComment || child.type !== Comment) {
3124        ret.push(key != null ? cloneVNode(child, { key }) : child);
3125      }
3126    }
3127    if (keyedFragmentCount > 1) {
3128      for (let i = 0; i < ret.length; i++) {
3129        ret[i].patchFlag = -2;
3130      }
3131    }
3132    return ret;
3133  }
3134  /*! #__NO_SIDE_EFFECTS__ */
3135  // @__NO_SIDE_EFFECTS__
3136  function defineComponent(options, extraOptions) {
3137    return isFunction(options) ? (
3138      // #8236: extend call and options.name access are considered side-effects
3139      // by Rollup, so we have to wrap it in a pure-annotated IIFE.
3140      /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))()
3141    ) : options;
3142  }
3143  function useId() {
3144    const i = getCurrentInstance();
3145    if (i) {
3146      return (i.appContext.config.idPrefix || "v") + "-" + i.ids[0] + i.ids[1]++;
3147    }
3148    return "";
3149  }
3150  function markAsyncBoundary(instance) {
3151    instance.ids = [instance.ids[0] + instance.ids[2]++ + "-", 0, 0];
3152  }
3153  function useTemplateRef(key) {
3154    const i = getCurrentInstance();
3155    const r = shallowRef(null);
3156    if (i) {
3157      const refs = i.refs === EMPTY_OBJ ? i.refs = {} : i.refs;
3158      {
3159        Object.defineProperty(refs, key, {
3160          enumerable: true,
3161          get: () => r.value,
3162          set: (val) => r.value = val
3163        });
3164      }
3165    }
3166    const ret = r;
3167    return ret;
3168  }
3169  function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
3170    if (isArray(rawRef)) {
3171      rawRef.forEach(
3172        (r, i) => setRef(
3173          r,
3174          oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef),
3175          parentSuspense,
3176          vnode,
3177          isUnmount
3178        )
3179      );
3180      return;
3181    }
3182    if (isAsyncWrapper(vnode) && !isUnmount) {
3183      return;
3184    }
3185    const refValue = vnode.shapeFlag & 4 ? getComponentPublicInstance(vnode.component) : vnode.el;
3186    const value = isUnmount ? null : refValue;
3187    const { i: owner, r: ref2 } = rawRef;
3188    const oldRef = oldRawRef && oldRawRef.r;
3189    const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
3190    const setupState = owner.setupState;
3191    const rawSetupState = toRaw(setupState);
3192    const canSetSetupRef = setupState === EMPTY_OBJ ? () => false : (key) => {
3193      return hasOwn(rawSetupState, key);
3194    };
3195    if (oldRef != null && oldRef !== ref2) {
3196      if (isString(oldRef)) {
3197        refs[oldRef] = null;
3198        if (canSetSetupRef(oldRef)) {
3199          setupState[oldRef] = null;
3200        }
3201      } else if (isRef(oldRef)) {
3202        oldRef.value = null;
3203      }
3204    }
3205    if (isFunction(ref2)) {
3206      callWithErrorHandling(ref2, owner, 12, [value, refs]);
3207    } else {
3208      const _isString = isString(ref2);
3209      const _isRef = isRef(ref2);
3210      if (_isString || _isRef) {
3211        const doSet = () => {
3212          if (rawRef.f) {
3213            const existing = _isString ? canSetSetupRef(ref2) ? setupState[ref2] : refs[ref2] : ref2.value;
3214            if (isUnmount) {
3215              isArray(existing) && remove(existing, refValue);
3216            } else {
3217              if (!isArray(existing)) {
3218                if (_isString) {
3219                  refs[ref2] = [refValue];
3220                  if (canSetSetupRef(ref2)) {
3221                    setupState[ref2] = refs[ref2];
3222                  }
3223                } else {
3224                  ref2.value = [refValue];
3225                  if (rawRef.k)
3226                    refs[rawRef.k] = ref2.value;
3227                }
3228              } else if (!existing.includes(refValue)) {
3229                existing.push(refValue);
3230              }
3231            }
3232          } else if (_isString) {
3233            refs[ref2] = value;
3234            if (canSetSetupRef(ref2)) {
3235              setupState[ref2] = value;
3236            }
3237          } else if (_isRef) {
3238            ref2.value = value;
3239            if (rawRef.k)
3240              refs[rawRef.k] = value;
3241          } else
3242            ;
3243        };
3244        if (value) {
3245          doSet.id = -1;
3246          queuePostRenderEffect(doSet, parentSuspense);
3247        } else {
3248          doSet();
3249        }
3250      }
3251    }
3252  }
3253  let hasLoggedMismatchError = false;

vendor: 7,169 bytes, lines 3254-3470

3254  const logMismatchError = () => {
3255    if (hasLoggedMismatchError) {
3256      return;
3257    }
3258    console.error("Hydration completed but contains mismatches.");
3259    hasLoggedMismatchError = true;
3260  };
3261  const isSVGContainer = (container) => container.namespaceURI.includes("svg") && container.tagName !== "foreignObject";
3262  const isMathMLContainer = (container) => container.namespaceURI.includes("MathML");
3263  const getContainerType = (container) => {
3264    if (container.nodeType !== 1)
3265      return void 0;
3266    if (isSVGContainer(container))
3267      return "svg";
3268    if (isMathMLContainer(container))
3269      return "mathml";
3270    return void 0;
3271  };
3272  const isComment = (node) => node.nodeType === 8;
3273  function createHydrationFunctions(rendererInternals) {
3274    const {
3275      mt: mountComponent,
3276      p: patch,
3277      o: {
3278        patchProp: patchProp2,
3279        createText,
3280        nextSibling,
3281        parentNode,
3282        remove: remove2,
3283        insert,
3284        createComment
3285      }
3286    } = rendererInternals;
3287    const hydrate2 = (vnode, container) => {
3288      if (!container.hasChildNodes()) {
3289        patch(null, vnode, container);
3290        flushPostFlushCbs();
3291        container._vnode = vnode;
3292        return;
3293      }
3294      hydrateNode(container.firstChild, vnode, null, null, null);
3295      flushPostFlushCbs();
3296      container._vnode = vnode;
3297    };
3298    const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
3299      optimized = optimized || !!vnode.dynamicChildren;
3300      const isFragmentStart = isComment(node) && node.data === "[";
3301      const onMismatch = () => handleMismatch(
3302        node,
3303        vnode,
3304        parentComponent,
3305        parentSuspense,
3306        slotScopeIds,
3307        isFragmentStart
3308      );
3309      const { type, ref: ref2, shapeFlag, patchFlag } = vnode;
3310      let domType = node.nodeType;
3311      vnode.el = node;
3312      if (patchFlag === -2) {
3313        optimized = false;
3314        vnode.dynamicChildren = null;
3315      }
3316      let nextNode = null;
3317      switch (type) {
3318        case Text:
3319          if (domType !== 3) {
3320            if (vnode.children === "") {
3321              insert(vnode.el = createText(""), parentNode(node), node);
3322              nextNode = node;
3323            } else {
3324              nextNode = onMismatch();
3325            }
3326          } else {
3327            if (node.data !== vnode.children) {
3328              logMismatchError();
3329              node.data = vnode.children;
3330            }
3331            nextNode = nextSibling(node);
3332          }
3333          break;
3334        case Comment:
3335          if (isTemplateNode(node)) {
3336            nextNode = nextSibling(node);
3337            replaceNode(
3338              vnode.el = node.content.firstChild,
3339              node,
3340              parentComponent
3341            );
3342          } else if (domType !== 8 || isFragmentStart) {
3343            nextNode = onMismatch();
3344          } else {
3345            nextNode = nextSibling(node);
3346          }
3347          break;
3348        case Static:
3349          if (isFragmentStart) {
3350            node = nextSibling(node);
3351            domType = node.nodeType;
3352          }
3353          if (domType === 1 || domType === 3) {
3354            nextNode = node;
3355            const needToAdoptContent = !vnode.children.length;
3356            for (let i = 0; i < vnode.staticCount; i++) {
3357              if (needToAdoptContent)
3358                vnode.children += nextNode.nodeType === 1 ? nextNode.outerHTML : nextNode.data;
3359              if (i === vnode.staticCount - 1) {
3360                vnode.anchor = nextNode;
3361              }
3362              nextNode = nextSibling(nextNode);
3363            }
3364            return isFragmentStart ? nextSibling(nextNode) : nextNode;
3365          } else {
3366            onMismatch();
3367          }
3368          break;
3369        case Fragment:
3370          if (!isFragmentStart) {
3371            nextNode = onMismatch();
3372          } else {
3373            nextNode = hydrateFragment(
3374              node,
3375              vnode,
3376              parentComponent,
3377              parentSuspense,
3378              slotScopeIds,
3379              optimized
3380            );
3381          }
3382          break;
3383        default:
3384          if (shapeFlag & 1) {
3385            if ((domType !== 1 || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) {
3386              nextNode = onMismatch();
3387            } else {
3388              nextNode = hydrateElement(
3389                node,
3390                vnode,
3391                parentComponent,
3392                parentSuspense,
3393                slotScopeIds,
3394                optimized
3395              );
3396            }
3397          } else if (shapeFlag & 6) {
3398            vnode.slotScopeIds = slotScopeIds;
3399            const container = parentNode(node);
3400            if (isFragmentStart) {
3401              nextNode = locateClosingAnchor(node);
3402            } else if (isComment(node) && node.data === "teleport start") {
3403              nextNode = locateClosingAnchor(node, node.data, "teleport end");
3404            } else {
3405              nextNode = nextSibling(node);
3406            }
3407            mountComponent(
3408              vnode,
3409              container,
3410              null,
3411              parentComponent,
3412              parentSuspense,
3413              getContainerType(container),
3414              optimized
3415            );
3416            if (isAsyncWrapper(vnode)) {
3417              let subTree;
3418              if (isFragmentStart) {
3419                subTree = createVNode(Fragment);
3420                subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild;
3421              } else {
3422                subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div");
3423              }
3424              subTree.el = node;
3425              vnode.component.subTree = subTree;
3426            }
3427          } else if (shapeFlag & 64) {
3428            if (domType !== 8) {
3429              nextNode = onMismatch();
3430            } else {
3431              nextNode = vnode.type.hydrate(
3432                node,
3433                vnode,
3434                parentComponent,
3435                parentSuspense,
3436                slotScopeIds,
3437                optimized,
3438                rendererInternals,
3439                hydrateChildren
3440              );
3441            }
3442          } else if (shapeFlag & 128) {
3443            nextNode = vnode.type.hydrate(
3444              node,
3445              vnode,
3446              parentComponent,
3447              parentSuspense,
3448              getContainerType(parentNode(node)),
3449              slotScopeIds,
3450              optimized,
3451              rendererInternals,
3452              hydrateNode
3453            );
3454          } else
3455            ;
3456      }
3457      if (ref2 != null) {
3458        setRef(ref2, null, parentSuspense, vnode);
3459      }
3460      return nextNode;
3461    };
3462    const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
3463      optimized = optimized || !!vnode.dynamicChildren;
3464      const { type, props, patchFlag, shapeFlag, dirs, transition } = vnode;
3465      const forcePatch = type === "input" || type === "option";
3466      if (forcePatch || patchFlag !== -1) {
3467        if (dirs) {
3468          invokeDirectiveHook(vnode, null, parentComponent, "created");
3469        }
3470        let needCallTransitionHooks = false;

3471        if (isTemplateNode(el)) {
3472          needCallTransitionHooks = needTransition(
3473            null,
3474            // no need check parentSuspense in hydration
3475            transition
3476          ) && parentComponent && parentComponent.vnode.props && parentComponent.vnode.props.appear;
3477          const content = el.content.firstChild;
3478          if (needCallTransitionHooks) {
3479            transition.beforeEnter(content);
3480          }
3481          replaceNode(content, el, parentComponent);
3482          vnode.el = el = content;
3483        }
3484        if (shapeFlag & 16 && // skip if element has innerHTML / textContent
3485        !(props && (props.innerHTML || props.textContent))) {
3486          let next = hydrateChildren(
3487            el.firstChild,
3488            vnode,
3489            el,
3490            parentComponent,
3491            parentSuspense,
3492            slotScopeIds,
3493            optimized
3494          );
3495          while (next) {
3496            if (!isMismatchAllowed(
3497              el,
3498              1
3499              /* CHILDREN */
3500            )) {
3501              logMismatchError();
3502            }
3503            const cur = next;
3504            next = next.nextSibling;
3505            remove2(cur);
3506          }
3507        } else if (shapeFlag & 8) {
3508          let clientText = vnode.children;
3509          if (clientText[0] === "\n" && (el.tagName === "PRE" || el.tagName === "TEXTAREA")) {
3510            clientText = clientText.slice(1);
3511          }
3512          if (el.textContent !== clientText) {
3513            if (!isMismatchAllowed(
3514              el,
3515              0
3516              /* TEXT */
3517            )) {
3518              logMismatchError();
3519            }
3520            el.textContent = vnode.children;
3521          }
3522        }
3523        if (props) {
3524          if (forcePatch || !optimized || patchFlag & (16 | 32)) {
3525            const isCustomElement = el.tagName.includes("-");
3526            for (const key in props) {
3527              if (forcePatch && (key.endsWith("value") || key === "indeterminate") || isOn(key) && !isReservedProp(key) || // force hydrate v-bind with .prop modifiers
3528              key[0] === "." || isCustomElement) {
3529                patchProp2(el, key, null, props[key], void 0, parentComponent);
3530              }
3531            }
3532          } else if (props.onClick) {
3533            patchProp2(
3534              el,
3535              "onClick",
3536              null,
3537              props.onClick,
3538              void 0,
3539              parentComponent
3540            );
3541          } else if (patchFlag & 4 && isReactive(props.style)) {
3542            for (const key in props.style)
3543              props.style[key];
3544          }
3545        }
3546        let vnodeHooks;
3547        if (vnodeHooks = props && props.onVnodeBeforeMount) {
3548          invokeVNodeHook(vnodeHooks, parentComponent, vnode);
3549        }
3550        if (dirs) {
3551          invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
3552        }
3553        if ((vnodeHooks = props && props.onVnodeMounted) || dirs || needCallTransitionHooks) {
3554          queueEffectWithSuspense(() => {
3555            vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
3556            needCallTransitionHooks && transition.enter(el);
3557            dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
3558          }, parentSuspense);
3559        }
3560      }
3561      return el.nextSibling;
3562    };
3563    const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => {
3564      optimized = optimized || !!parentVNode.dynamicChildren;
3565      const children = parentVNode.children;
3566      const l = children.length;
3567      for (let i = 0; i < l; i++) {
3568        const vnode = optimized ? children[i] : children[i] = normalizeVNode$1(children[i]);
3569        const isText = vnode.type === Text;
3570        if (node) {
3571          if (isText && !optimized) {
3572            if (i + 1 < l && normalizeVNode$1(children[i + 1]).type === Text) {
3573              insert(
3574                createText(
3575                  node.data.slice(vnode.children.length)
3576                ),
3577                container,
3578                nextSibling(node)
3579              );
3580              node.data = vnode.children;
3581            }
3582          }
3583          node = hydrateNode(
3584            node,
3585            vnode,
3586            parentComponent,
3587            parentSuspense,
3588            slotScopeIds,
3589            optimized
3590          );
3591        } else if (isText && !vnode.children) {
3592          insert(vnode.el = createText(""), container);
3593        } else {
3594          if (!isMismatchAllowed(
3595            container,
3596            1
3597            /* CHILDREN */
3598          )) {
3599            logMismatchError();
3600          }
3601          patch(
3602            null,
3603            vnode,
3604            container,
3605            null,
3606            parentComponent,
3607            parentSuspense,
3608            getContainerType(container),
3609            slotScopeIds
3610          );
3611        }
3612      }
3613      return node;
3614    };
3615    const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
3616      const { slotScopeIds: fragmentSlotScopeIds } = vnode;
3617      if (fragmentSlotScopeIds) {
3618        slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
3619      }
3620      const container = parentNode(node);
3621      const next = hydrateChildren(
3622        nextSibling(node),
3623        vnode,
3624        container,
3625        parentComponent,
3626        parentSuspense,
3627        slotScopeIds,
3628        optimized
3629      );
3630      if (next && isComment(next) && next.data === "]") {
3631        return nextSibling(vnode.anchor = next);
3632      } else {
3633        logMismatchError();
3634        insert(vnode.anchor = createComment(`]`), container, next);
3635        return next;
3636      }
3637    };
3638    const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
3639      if (!isMismatchAllowed(
3640        node.parentElement,
3641        1
3642        /* CHILDREN */
3643      )) {
3644        logMismatchError();
3645      }
3646      vnode.el = null;
3647      if (isFragment) {
3648        const end = locateClosingAnchor(node);
3649        while (true) {
3650          const next2 = nextSibling(node);
3651          if (next2 && next2 !== end) {
3652            remove2(next2);
3653          } else {
3654            break;
3655          }
3656        }
3657      }
3658      const next = nextSibling(node);
3659      const container = parentNode(node);
3660      remove2(node);
3661      patch(
3662        null,
3663        vnode,
3664        container,
3665        next,
3666        parentComponent,
3667        parentSuspense,
3668        getContainerType(container),
3669        slotScopeIds
3670      );
3671      return next;
3672    };
3673    const locateClosingAnchor = (node, open = "[", close = "]") => {
3674      let match = 0;
3675      while (node) {
3676        node = nextSibling(node);
3677        if (node && isComment(node)) {
3678          if (node.data === open)
3679            match++;
3680          if (node.data === close) {
3681            if (match === 0) {
3682              return nextSibling(node);
3683            } else {
3684              match--;
3685            }
3686          }
3687        }
3688      }
3689      return node;
3690    };
3691    const replaceNode = (newNode, oldNode, parentComponent) => {
3692      const parentNode2 = oldNode.parentNode;
3693      if (parentNode2) {
3694        parentNode2.replaceChild(newNode, oldNode);
3695      }
3696      let parent = parentComponent;
3697      while (parent) {
3698        if (parent.vnode.el === oldNode) {
3699          parent.vnode.el = parent.subTree.el = newNode;
3700        }
3701        parent = parent.parent;
3702      }
3703    };
3704    const isTemplateNode = (node) => {
3705      return node.nodeType === 1 && node.tagName === "TEMPLATE";
3706    };
3707    return [hydrate2, hydrateNode];
3708  }
3709  const allowMismatchAttr = "data-allow-mismatch";
3710  const MismatchTypeString = {
3711    [
3712      0
3713      /* TEXT */
3714    ]: "text",
3715    [
3716      1
3717      /* CHILDREN */
3718    ]: "children",
3719    [
3720      2
3721      /* CLASS */
3722    ]: "class",
3723    [
3724      3
3725      /* STYLE */
3726    ]: "style",
3727    [
3728      4
3729      /* ATTRIBUTE */
3730    ]: "attribute"
3731  };
3732  function isMismatchAllowed(el, allowedType) {
3733    if (allowedType === 0 || allowedType === 1) {
3734      while (el && !el.hasAttribute(allowMismatchAttr)) {
3735        el = el.parentElement;
3736      }
3737    }
3738    const allowedAttr = el && el.getAttribute(allowMismatchAttr);
3739    if (allowedAttr == null) {
3740      return false;

vendor: 20,558 bytes, lines 3741-4393

3741    } else if (allowedAttr === "") {
3742      return true;
3743    } else {
3744      const list = allowedAttr.split(",");
3745      if (allowedType === 0 && list.includes("children")) {
3746        return true;
3747      }
3748      return allowedAttr.split(",").includes(MismatchTypeString[allowedType]);
3749    }
3750  }
3751  const requestIdleCallback = getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb, 1));
3752  const cancelIdleCallback = getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id));
3753  const hydrateOnIdle = (timeout = 1e4) => (hydrate2) => {
3754    const id = requestIdleCallback(hydrate2, { timeout });
3755    return () => cancelIdleCallback(id);
3756  };
3757  function elementIsVisibleInViewport(el) {
3758    const { top, left, bottom, right } = el.getBoundingClientRect();
3759    const { innerHeight, innerWidth } = window;
3760    return (top > 0 && top < innerHeight || bottom > 0 && bottom < innerHeight) && (left > 0 && left < innerWidth || right > 0 && right < innerWidth);
3761  }
3762  const hydrateOnVisible = (opts) => (hydrate2, forEach) => {
3763    const ob = new IntersectionObserver((entries) => {
3764      for (const e of entries) {
3765        if (!e.isIntersecting)
3766          continue;
3767        ob.disconnect();
3768        hydrate2();
3769        break;
3770      }
3771    }, opts);
3772    forEach((el) => {
3773      if (!(el instanceof Element))
3774        return;
3775      if (elementIsVisibleInViewport(el)) {
3776        hydrate2();
3777        ob.disconnect();
3778        return false;
3779      }
3780      ob.observe(el);
3781    });
3782    return () => ob.disconnect();
3783  };
3784  const hydrateOnMediaQuery = (query) => (hydrate2) => {
3785    if (query) {
3786      const mql = matchMedia(query);
3787      if (mql.matches) {
3788        hydrate2();
3789      } else {
3790        mql.addEventListener("change", hydrate2, { once: true });
3791        return () => mql.removeEventListener("change", hydrate2);
3792      }
3793    }
3794  };
3795  const hydrateOnInteraction = (interactions = []) => (hydrate2, forEach) => {
3796    if (isString(interactions))
3797      interactions = [interactions];
3798    let hasHydrated = false;
3799    const doHydrate = (e) => {
3800      if (!hasHydrated) {
3801        hasHydrated = true;
3802        teardown();
3803        hydrate2();
3804        e.target.dispatchEvent(new e.constructor(e.type, e));
3805      }
3806    };
3807    const teardown = () => {
3808      forEach((el) => {
3809        for (const i of interactions) {
3810          el.removeEventListener(i, doHydrate);
3811        }
3812      });
3813    };
3814    forEach((el) => {
3815      for (const i of interactions) {
3816        el.addEventListener(i, doHydrate, { once: true });
3817      }
3818    });
3819    return teardown;
3820  };
3821  function forEachElement(node, cb) {
3822    if (isComment(node) && node.data === "[") {
3823      let depth = 1;
3824      let next = node.nextSibling;
3825      while (next) {
3826        if (next.nodeType === 1) {
3827          const result = cb(next);
3828          if (result === false) {
3829            break;
3830          }
3831        } else if (isComment(next)) {
3832          if (next.data === "]") {
3833            if (--depth === 0)
3834              break;
3835          } else if (next.data === "[") {
3836            depth++;
3837          }
3838        }
3839        next = next.nextSibling;
3840      }
3841    } else {
3842      cb(node);
3843    }
3844  }
3845  const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
3846  /*! #__NO_SIDE_EFFECTS__ */
3847  // @__NO_SIDE_EFFECTS__
3848  function defineAsyncComponent(source) {
3849    if (isFunction(source)) {
3850      source = { loader: source };
3851    }
3852    const {
3853      loader,
3854      loadingComponent,
3855      errorComponent,
3856      delay = 200,
3857      hydrate: hydrateStrategy,
3858      timeout,
3859      // undefined = never times out
3860      suspensible = true,
3861      onError: userOnError
3862    } = source;
3863    let pendingRequest = null;
3864    let resolvedComp;
3865    let retries = 0;
3866    const retry = () => {
3867      retries++;
3868      pendingRequest = null;
3869      return load();
3870    };
3871    const load = () => {
3872      let thisRequest;
3873      return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
3874        err = err instanceof Error ? err : new Error(String(err));
3875        if (userOnError) {
3876          return new Promise((resolve2, reject) => {
3877            const userRetry = () => resolve2(retry());
3878            const userFail = () => reject(err);
3879            userOnError(err, userRetry, userFail, retries + 1);
3880          });
3881        } else {
3882          throw err;
3883        }
3884      }).then((comp) => {
3885        if (thisRequest !== pendingRequest && pendingRequest) {
3886          return pendingRequest;
3887        }
3888        if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
3889          comp = comp.default;
3890        }
3891        resolvedComp = comp;
3892        return comp;
3893      }));
3894    };
3895    return /* @__PURE__ */ defineComponent({
3896      name: "AsyncComponentWrapper",
3897      __asyncLoader: load,
3898      __asyncHydrate(el, instance, hydrate2) {
3899        const doHydrate = hydrateStrategy ? () => {
3900          const teardown = hydrateStrategy(
3901            hydrate2,
3902            (cb) => forEachElement(el, cb)
3903          );
3904          if (teardown) {
3905            (instance.bum || (instance.bum = [])).push(teardown);
3906          }
3907        } : hydrate2;
3908        if (resolvedComp) {
3909          doHydrate();
3910        } else {
3911          load().then(() => !instance.isUnmounted && doHydrate());
3912        }
3913      },
3914      get __asyncResolved() {
3915        return resolvedComp;
3916      },
3917      setup() {
3918        const instance = currentInstance;
3919        markAsyncBoundary(instance);
3920        if (resolvedComp) {
3921          return () => createInnerComp(resolvedComp, instance);
3922        }
3923        const onError = (err) => {
3924          pendingRequest = null;
3925          handleError(
3926            err,
3927            instance,
3928            13,
3929            !errorComponent
3930          );
3931        };
3932        if (suspensible && instance.suspense || isInSSRComponentSetup) {
3933          return load().then((comp) => {
3934            return () => createInnerComp(comp, instance);
3935          }).catch((err) => {
3936            onError(err);
3937            return () => errorComponent ? createVNode(errorComponent, {
3938              error: err
3939            }) : null;
3940          });
3941        }
3942        const loaded = ref(false);
3943        const error = ref();
3944        const delayed = ref(!!delay);
3945        if (delay) {
3946          setTimeout(() => {
3947            delayed.value = false;
3948          }, delay);
3949        }
3950        if (timeout != null) {
3951          setTimeout(() => {
3952            if (!loaded.value && !error.value) {
3953              const err = new Error(
3954                `Async component timed out after ${timeout}ms.`
3955              );
3956              onError(err);
3957              error.value = err;
3958            }
3959          }, timeout);
3960        }
3961        load().then(() => {
3962          loaded.value = true;
3963          if (instance.parent && isKeepAlive(instance.parent.vnode)) {
3964            instance.parent.update();
3965          }
3966        }).catch((err) => {
3967          onError(err);
3968          error.value = err;
3969        });
3970        return () => {
3971          if (loaded.value && resolvedComp) {
3972            return createInnerComp(resolvedComp, instance);
3973          } else if (error.value && errorComponent) {
3974            return createVNode(errorComponent, {
3975              error: error.value
3976            });
3977          } else if (loadingComponent && !delayed.value) {
3978            return createVNode(loadingComponent);
3979          }
3980        };
3981      }
3982    });
3983  }
3984  function createInnerComp(comp, parent) {
3985    const { ref: ref2, props, children, ce } = parent.vnode;
3986    const vnode = createVNode(comp, props, children);
3987    vnode.ref = ref2;
3988    vnode.ce = ce;
3989    delete parent.vnode.ce;
3990    return vnode;
3991  }
3992  const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
3993  const KeepAliveImpl = {
3994    name: `KeepAlive`,
3995    // Marker for special handling inside the renderer. We are not using a ===
3996    // check directly on KeepAlive in the renderer, because importing it directly
3997    // would prevent it from being tree-shaken.
3998    __isKeepAlive: true,
3999    props: {
4000      include: [String, RegExp, Array],
4001      exclude: [String, RegExp, Array],
4002      max: [String, Number]
4003    },
4004    setup(props, { slots }) {
4005      const instance = getCurrentInstance();
4006      const sharedContext = instance.ctx;
4007      if (!sharedContext.renderer) {
4008        return () => {
4009          const children = slots.default && slots.default();
4010          return children && children.length === 1 ? children[0] : children;
4011        };
4012      }
4013      const cache = /* @__PURE__ */ new Map();
4014      const keys = /* @__PURE__ */ new Set();
4015      let current = null;
4016      const parentSuspense = instance.suspense;
4017      const {
4018        renderer: {
4019          p: patch,
4020          m: move,
4021          um: _unmount,
4022          o: { createElement }
4023        }
4024      } = sharedContext;
4025      const storageContainer = createElement("div");
4026      sharedContext.activate = (vnode, container, anchor, namespace, optimized) => {
4027        const instance2 = vnode.component;
4028        move(vnode, container, anchor, 0, parentSuspense);
4029        patch(
4030          instance2.vnode,
4031          vnode,
4032          container,
4033          anchor,
4034          instance2,
4035          parentSuspense,
4036          namespace,
4037          vnode.slotScopeIds,
4038          optimized
4039        );
4040        queuePostRenderEffect(() => {
4041          instance2.isDeactivated = false;
4042          if (instance2.a) {
4043            invokeArrayFns(instance2.a);
4044          }
4045          const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
4046          if (vnodeHook) {
4047            invokeVNodeHook(vnodeHook, instance2.parent, vnode);
4048          }
4049        }, parentSuspense);
4050      };
4051      sharedContext.deactivate = (vnode) => {
4052        const instance2 = vnode.component;
4053        invalidateMount(instance2.m);
4054        invalidateMount(instance2.a);
4055        move(vnode, storageContainer, null, 1, parentSuspense);
4056        queuePostRenderEffect(() => {
4057          if (instance2.da) {
4058            invokeArrayFns(instance2.da);
4059          }
4060          const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
4061          if (vnodeHook) {
4062            invokeVNodeHook(vnodeHook, instance2.parent, vnode);
4063          }
4064          instance2.isDeactivated = true;
4065        }, parentSuspense);
4066      };
4067      function unmount(vnode) {
4068        resetShapeFlag(vnode);
4069        _unmount(vnode, instance, parentSuspense, true);
4070      }
4071      function pruneCache(filter) {
4072        cache.forEach((vnode, key) => {
4073          const name = getComponentName(vnode.type);
4074          if (name && !filter(name)) {
4075            pruneCacheEntry(key);
4076          }
4077        });
4078      }
4079      function pruneCacheEntry(key) {
4080        const cached = cache.get(key);
4081        if (cached && (!current || !isSameVNodeType(cached, current))) {
4082          unmount(cached);
4083        } else if (current) {
4084          resetShapeFlag(current);
4085        }
4086        cache.delete(key);
4087        keys.delete(key);
4088      }
4089      watch(
4090        () => [props.include, props.exclude],
4091        ([include, exclude]) => {
4092          include && pruneCache((name) => matches(include, name));
4093          exclude && pruneCache((name) => !matches(exclude, name));
4094        },
4095        // prune post-render after `current` has been updated
4096        { flush: "post", deep: true }
4097      );
4098      let pendingCacheKey = null;
4099      const cacheSubtree = () => {
4100        if (pendingCacheKey != null) {
4101          if (isSuspense(instance.subTree.type)) {
4102            queuePostRenderEffect(() => {
4103              cache.set(pendingCacheKey, getInnerChild(instance.subTree));
4104            }, instance.subTree.suspense);
4105          } else {
4106            cache.set(pendingCacheKey, getInnerChild(instance.subTree));
4107          }
4108        }
4109      };
4110      onMounted(cacheSubtree);
4111      onUpdated(cacheSubtree);
4112      onBeforeUnmount(() => {
4113        cache.forEach((cached) => {
4114          const { subTree, suspense } = instance;
4115          const vnode = getInnerChild(subTree);
4116          if (cached.type === vnode.type && cached.key === vnode.key) {
4117            resetShapeFlag(vnode);
4118            const da = vnode.component.da;
4119            da && queuePostRenderEffect(da, suspense);
4120            return;
4121          }
4122          unmount(cached);
4123        });
4124      });
4125      return () => {
4126        pendingCacheKey = null;
4127        if (!slots.default) {
4128          return current = null;
4129        }
4130        const children = slots.default();
4131        const rawVNode = children[0];
4132        if (children.length > 1) {
4133          current = null;
4134          return children;
4135        } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) {
4136          current = null;
4137          return rawVNode;
4138        }
4139        let vnode = getInnerChild(rawVNode);
4140        if (vnode.type === Comment) {
4141          current = null;
4142          return vnode;
4143        }
4144        const comp = vnode.type;
4145        const name = getComponentName(
4146          isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp
4147        );
4148        const { include, exclude, max } = props;
4149        if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {
4150          vnode.shapeFlag &= ~256;
4151          current = vnode;
4152          return rawVNode;
4153        }
4154        const key = vnode.key == null ? comp : vnode.key;
4155        const cachedVNode = cache.get(key);
4156        if (vnode.el) {
4157          vnode = cloneVNode(vnode);
4158          if (rawVNode.shapeFlag & 128) {
4159            rawVNode.ssContent = vnode;
4160          }
4161        }
4162        pendingCacheKey = key;
4163        if (cachedVNode) {
4164          vnode.el = cachedVNode.el;
4165          vnode.component = cachedVNode.component;
4166          if (vnode.transition) {
4167            setTransitionHooks(vnode, vnode.transition);
4168          }
4169          vnode.shapeFlag |= 512;
4170          keys.delete(key);
4171          keys.add(key);
4172        } else {
4173          keys.add(key);
4174          if (max && keys.size > parseInt(max, 10)) {
4175            pruneCacheEntry(keys.values().next().value);
4176          }
4177        }
4178        vnode.shapeFlag |= 256;
4179        current = vnode;
4180        return isSuspense(rawVNode.type) ? rawVNode : vnode;
4181      };
4182    }
4183  };
4184  const KeepAlive = KeepAliveImpl;
4185  function matches(pattern, name) {
4186    if (isArray(pattern)) {
4187      return pattern.some((p2) => matches(p2, name));
4188    } else if (isString(pattern)) {
4189      return pattern.split(",").includes(name);
4190    } else if (isRegExp(pattern)) {
4191      pattern.lastIndex = 0;
4192      return pattern.test(name);
4193    }
4194    return false;
4195  }
4196  function onActivated(hook, target) {
4197    registerKeepAliveHook(hook, "a", target);
4198  }
4199  function onDeactivated(hook, target) {
4200    registerKeepAliveHook(hook, "da", target);
4201  }
4202  function registerKeepAliveHook(hook, type, target = currentInstance) {
4203    const wrappedHook = hook.__wdc || (hook.__wdc = () => {
4204      let current = target;
4205      while (current) {
4206        if (current.isDeactivated) {
4207          return;
4208        }
4209        current = current.parent;
4210      }
4211      return hook();
4212    });
4213    injectHook(type, wrappedHook, target);
4214    if (target) {
4215      let current = target.parent;
4216      while (current && current.parent) {
4217        if (isKeepAlive(current.parent.vnode)) {
4218          injectToKeepAliveRoot(wrappedHook, type, target, current);
4219        }
4220        current = current.parent;
4221      }
4222    }
4223  }
4224  function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
4225    const injected = injectHook(
4226      type,
4227      hook,
4228      keepAliveRoot,
4229      true
4230      /* prepend */
4231    );
4232    onUnmounted(() => {
4233      remove(keepAliveRoot[type], injected);
4234    }, target);
4235  }
4236  function resetShapeFlag(vnode) {
4237    vnode.shapeFlag &= ~256;
4238    vnode.shapeFlag &= ~512;
4239  }
4240  function getInnerChild(vnode) {
4241    return vnode.shapeFlag & 128 ? vnode.ssContent : vnode;
4242  }
4243  function injectHook(type, hook, target = currentInstance, prepend = false) {
4244    if (target) {
4245      const hooks = target[type] || (target[type] = []);
4246      const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
4247        pauseTracking();
4248        const reset = setCurrentInstance(target);
4249        const res = callWithAsyncErrorHandling(hook, target, type, args);
4250        reset();
4251        resetTracking();
4252        return res;
4253      });
4254      if (prepend) {
4255        hooks.unshift(wrappedHook);
4256      } else {
4257        hooks.push(wrappedHook);
4258      }
4259      return wrappedHook;
4260    }
4261  }
4262  const createHook = (lifecycle) => (hook, target = currentInstance) => {
4263    if (!isInSSRComponentSetup || lifecycle === "sp") {
4264      injectHook(lifecycle, (...args) => hook(...args), target);
4265    }
4266  };
4267  const onBeforeMount = createHook("bm");
4268  const onMounted = createHook("m");
4269  const onBeforeUpdate = createHook(
4270    "bu"
4271  );
4272  const onUpdated = createHook("u");
4273  const onBeforeUnmount = createHook(
4274    "bum"
4275  );
4276  const onUnmounted = createHook("um");
4277  const onServerPrefetch = createHook(
4278    "sp"
4279  );
4280  const onRenderTriggered = createHook("rtg");
4281  const onRenderTracked = createHook("rtc");
4282  function onErrorCaptured(hook, target = currentInstance) {
4283    injectHook("ec", hook, target);
4284  }
4285  const COMPONENTS = "components";
4286  const DIRECTIVES = "directives";
4287  function resolveComponent(name, maybeSelfReference) {
4288    return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
4289  }
4290  const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
4291  function resolveDynamicComponent(component) {
4292    if (isString(component)) {
4293      return resolveAsset(COMPONENTS, component, false) || component;
4294    } else {
4295      return component || NULL_DYNAMIC_COMPONENT;
4296    }
4297  }
4298  function resolveDirective(name) {
4299    return resolveAsset(DIRECTIVES, name);
4300  }
4301  function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
4302    const instance = currentRenderingInstance || currentInstance;
4303    if (instance) {
4304      const Component = instance.type;
4305      if (type === COMPONENTS) {
4306        const selfName = getComponentName(
4307          Component,
4308          false
4309        );
4310        if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) {
4311          return Component;
4312        }
4313      }
4314      const res = (
4315        // local registration
4316        // check instance[type] first which is resolved for options API
4317        resolve(instance[type] || Component[type], name) || // global registration
4318        resolve(instance.appContext[type], name)
4319      );
4320      if (!res && maybeSelfReference) {
4321        return Component;
4322      }
4323      return res;
4324    }
4325  }
4326  function resolve(registry, name) {
4327    return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);
4328  }
4329  function renderList(source, renderItem, cache, index2) {
4330    let ret;
4331    const cached = cache && cache[index2];
4332    const sourceIsArray = isArray(source);
4333    if (sourceIsArray || isString(source)) {
4334      const sourceIsReactiveArray = sourceIsArray && isReactive(source);
4335      let needsWrap = false;
4336      if (sourceIsReactiveArray) {
4337        needsWrap = !isShallow(source);
4338        source = shallowReadArray(source);
4339      }
4340      ret = new Array(source.length);
4341      for (let i = 0, l = source.length; i < l; i++) {
4342        ret[i] = renderItem(
4343          needsWrap ? toReactive(source[i]) : source[i],
4344          i,
4345          void 0,
4346          cached && cached[i]
4347        );
4348      }
4349    } else if (typeof source === "number") {
4350      ret = new Array(source);
4351      for (let i = 0; i < source; i++) {
4352        ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
4353      }
4354    } else if (isObject(source)) {
4355      if (source[Symbol.iterator]) {
4356        ret = Array.from(
4357          source,
4358          (item, i) => renderItem(item, i, void 0, cached && cached[i])
4359        );
4360      } else {
4361        const keys = Object.keys(source);
4362        ret = new Array(keys.length);
4363        for (let i = 0, l = keys.length; i < l; i++) {
4364          const key = keys[i];
4365          ret[i] = renderItem(source[key], key, i, cached && cached[i]);
4366        }
4367      }
4368    } else {
4369      ret = [];
4370    }
4371    if (cache) {
4372      cache[index2] = ret;
4373    }
4374    return ret;
4375  }
4376  function createSlots(slots, dynamicSlots) {
4377    for (let i = 0; i < dynamicSlots.length; i++) {
4378      const slot = dynamicSlots[i];
4379      if (isArray(slot)) {
4380        for (let j = 0; j < slot.length; j++) {
4381          slots[slot[j].name] = slot[j].fn;
4382        }
4383      } else if (slot) {
4384        slots[slot.name] = slot.key ? (...args) => {
4385          const res = slot.fn(...args);
4386          if (res)
4387            res.key = slot.key;
4388          return res;
4389        } : slot.fn;
4390      }
4391    }
4392    return slots;
4393  }

4394  function renderSlot(slots, name, props = {}, fallback, noSlotted) {
4395    if (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce) {
4396      if (name !== "default")
4397        props.name = name;
4398      return openBlock(), createBlock(
4399        Fragment,
4400        null,
4401        [createVNode("slot", props, fallback && fallback())],
4402        64
4403      );
4404    }
4405    let slot = slots[name];
4406    if (slot && slot._c) {
4407      slot._d = false;
4408    }
4409    openBlock();
4410    const validSlotContent = slot && ensureValidVNode(slot(props));
4411    const slotKey = props.key || // slot content array of a dynamic conditional slot may have a branch
4412    // key attached in the `createSlots` helper, respect that
4413    validSlotContent && validSlotContent.key;
4414    const rendered = createBlock(
4415      Fragment,
4416      {
4417        key: (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) + // #7256 force differentiate fallback content from actual content
4418        (!validSlotContent && fallback ? "_fb" : "")
4419      },
4420      validSlotContent || (fallback ? fallback() : []),
4421      validSlotContent && slots._ === 1 ? 64 : -2
4422    );
4423    if (!noSlotted && rendered.scopeId) {
4424      rendered.slotScopeIds = [rendered.scopeId + "-s"];
4425    }
4426    if (slot && slot._c) {
4427      slot._d = true;
4428    }
4429    return rendered;
4430  }
4431  function ensureValidVNode(vnodes) {
4432    return vnodes.some((child) => {
4433      if (!isVNode(child))
4434        return true;
4435      if (child.type === Comment)
4436        return false;
4437      if (child.type === Fragment && !ensureValidVNode(child.children))
4438        return false;
4439      return true;
4440    }) ? vnodes : null;
4441  }
4442  function toHandlers(obj, preserveCaseIfNecessary) {
4443    const ret = {};
4444    for (const key in obj) {
4445      ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : toHandlerKey(key)] = obj[key];
4446    }
4447    return ret;
4448  }
4449  const getPublicInstance = (i) => {
4450    if (!i)
4451      return null;
4452    if (isStatefulComponent(i))
4453      return getComponentPublicInstance(i);
4454    return getPublicInstance(i.parent);
4455  };
4456  const publicPropertiesMap = (
4457    // Move PURE marker to new line to workaround compiler discarding it
4458    // due to type annotation
4459    /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {
4460      $: (i) => i,
4461      $el: (i) => i.vnode.el,
4462      $data: (i) => i.data,
4463      $props: (i) => i.props,
4464      $attrs: (i) => i.attrs,
4465      $slots: (i) => i.slots,
4466      $refs: (i) => i.refs,
4467      $parent: (i) => getPublicInstance(i.parent),
4468      $root: (i) => getPublicInstance(i.root),
4469      $host: (i) => i.ce,
4470      $emit: (i) => i.emit,
4471      $options: (i) => resolveMergedOptions(i),
4472      $forceUpdate: (i) => i.f || (i.f = () => {
4473        queueJob(i.update);
4474      }),
4475      $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
4476      $watch: (i) => instanceWatch.bind(i)
4477    })
4478  );
4479  const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
4480  const PublicInstanceProxyHandlers = {
4481    get({ _: instance }, key) {
4482      if (key === "__v_skip") {
4483        return true;
4484      }
4485      const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
4486      let normalizedProps;
4487      if (key[0] !== "$") {
4488        const n = accessCache[key];
4489        if (n !== void 0) {
4490          switch (n) {
4491            case 1:
4492              return setupState[key];
4493            case 2:
4494              return data[key];
4495            case 4:
4496              return ctx[key];
4497            case 3:
4498              return props[key];
4499          }
4500        } else if (hasSetupBinding(setupState, key)) {
4501          accessCache[key] = 1;
4502          return setupState[key];
4503        } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
4504          accessCache[key] = 2;
4505          return data[key];
4506        } else if (
4507          // only cache other properties when instance has declared (thus stable)
4508          // props
4509          (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)
4510        ) {
4511          accessCache[key] = 3;
4512          return props[key];
4513        } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
4514          accessCache[key] = 4;
4515          return ctx[key];
4516        } else if (shouldCacheAccess) {
4517          accessCache[key] = 0;
4518        }
4519      }
4520      const publicGetter = publicPropertiesMap[key];
4521      let cssModule, globalProperties;
4522      if (publicGetter) {
4523        if (key === "$attrs") {
4524          track(instance.attrs, "get", "");
4525        }
4526        return publicGetter(instance);
4527      } else if (
4528        // css module (injected by vue-loader)
4529        (cssModule = type.__cssModules) && (cssModule = cssModule[key])
4530      ) {
4531        return cssModule;
4532      } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
4533        accessCache[key] = 4;
4534        return ctx[key];
4535      } else if (
4536        // global properties
4537        globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)
4538      ) {
4539        {
4540          return globalProperties[key];
4541        }
4542      } else
4543        ;
4544    },
4545    set({ _: instance }, key, value) {
4546      const { data, setupState, ctx } = instance;
4547      if (hasSetupBinding(setupState, key)) {
4548        setupState[key] = value;
4549        return true;
4550      } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
4551        data[key] = value;
4552        return true;
4553      } else if (hasOwn(instance.props, key)) {
4554        return false;

vendor: 5,961 bytes, lines 4555-4767

4555      }
4556      if (key[0] === "$" && key.slice(1) in instance) {
4557        return false;
4558      } else {
4559        {
4560          ctx[key] = value;
4561        }
4562      }
4563      return true;
4564    },
4565    has({
4566      _: { data, setupState, accessCache, ctx, appContext, propsOptions }
4567    }, key) {
4568      let normalizedProps;
4569      return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
4570    },
4571    defineProperty(target, key, descriptor) {
4572      if (descriptor.get != null) {
4573        target._.accessCache[key] = 0;
4574      } else if (hasOwn(descriptor, "value")) {
4575        this.set(target, key, descriptor.value, null);
4576      }
4577      return Reflect.defineProperty(target, key, descriptor);
4578    }
4579  };
4580  const RuntimeCompiledPublicInstanceProxyHandlers = /* @__PURE__ */ extend({}, PublicInstanceProxyHandlers, {
4581    get(target, key) {
4582      if (key === Symbol.unscopables) {
4583        return;
4584      }
4585      return PublicInstanceProxyHandlers.get(target, key, target);
4586    },
4587    has(_, key) {
4588      const has = key[0] !== "_" && !isGloballyAllowed(key);
4589      return has;
4590    }
4591  });
4592  function defineProps() {
4593    return null;
4594  }
4595  function defineEmits() {
4596    return null;
4597  }
4598  function defineExpose(exposed) {
4599  }
4600  function defineOptions(options) {
4601  }
4602  function defineSlots() {
4603    return null;
4604  }
4605  function defineModel() {
4606  }
4607  function withDefaults(props, defaults) {
4608    return null;
4609  }
4610  function useSlots() {
4611    return getContext().slots;
4612  }
4613  function useAttrs() {
4614    return getContext().attrs;
4615  }
4616  function getContext() {
4617    const i = getCurrentInstance();
4618    return i.setupContext || (i.setupContext = createSetupContext(i));
4619  }
4620  function normalizePropsOrEmits(props) {
4621    return isArray(props) ? props.reduce(
4622      (normalized, p2) => (normalized[p2] = null, normalized),
4623      {}
4624    ) : props;
4625  }
4626  function mergeDefaults(raw, defaults) {
4627    const props = normalizePropsOrEmits(raw);
4628    for (const key in defaults) {
4629      if (key.startsWith("__skip"))
4630        continue;
4631      let opt = props[key];
4632      if (opt) {
4633        if (isArray(opt) || isFunction(opt)) {
4634          opt = props[key] = { type: opt, default: defaults[key] };
4635        } else {
4636          opt.default = defaults[key];
4637        }
4638      } else if (opt === null) {
4639        opt = props[key] = { default: defaults[key] };
4640      } else
4641        ;
4642      if (opt && defaults[`__skip_${key}`]) {
4643        opt.skipFactory = true;
4644      }
4645    }
4646    return props;
4647  }
4648  function mergeModels(a, b) {
4649    if (!a || !b)
4650      return a || b;
4651    if (isArray(a) && isArray(b))
4652      return a.concat(b);
4653    return extend({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b));
4654  }
4655  function createPropsRestProxy(props, excludedKeys) {
4656    const ret = {};
4657    for (const key in props) {
4658      if (!excludedKeys.includes(key)) {
4659        Object.defineProperty(ret, key, {
4660          enumerable: true,
4661          get: () => props[key]
4662        });
4663      }
4664    }
4665    return ret;
4666  }
4667  function withAsyncContext(getAwaitable) {
4668    const ctx = getCurrentInstance();
4669    let awaitable = getAwaitable();
4670    unsetCurrentInstance();
4671    if (isPromise(awaitable)) {
4672      awaitable = awaitable.catch((e) => {
4673        setCurrentInstance(ctx);
4674        throw e;
4675      });
4676    }
4677    return [awaitable, () => setCurrentInstance(ctx)];
4678  }
4679  let shouldCacheAccess = true;
4680  function applyOptions(instance) {
4681    const options = resolveMergedOptions(instance);
4682    const publicThis = instance.proxy;
4683    const ctx = instance.ctx;
4684    shouldCacheAccess = false;
4685    if (options.beforeCreate) {
4686      callHook$1(options.beforeCreate, instance, "bc");
4687    }
4688    const {
4689      // state
4690      data: dataOptions,
4691      computed: computedOptions,
4692      methods,
4693      watch: watchOptions,
4694      provide: provideOptions,
4695      inject: injectOptions,
4696      // lifecycle
4697      created,
4698      beforeMount,
4699      mounted,
4700      beforeUpdate,
4701      updated,
4702      activated,
4703      deactivated,
4704      beforeDestroy,
4705      beforeUnmount,
4706      destroyed,
4707      unmounted,
4708      render: render2,
4709      renderTracked,
4710      renderTriggered,
4711      errorCaptured,
4712      serverPrefetch,
4713      // public API
4714      expose,
4715      inheritAttrs,
4716      // assets
4717      components,
4718      directives,
4719      filters
4720    } = options;
4721    const checkDuplicateProperties = null;
4722    if (injectOptions) {
4723      resolveInjections(injectOptions, ctx, checkDuplicateProperties);
4724    }
4725    if (methods) {
4726      for (const key in methods) {
4727        const methodHandler = methods[key];
4728        if (isFunction(methodHandler)) {
4729          {
4730            ctx[key] = methodHandler.bind(publicThis);
4731          }
4732        }
4733      }
4734    }
4735    if (dataOptions) {
4736      const data = dataOptions.call(publicThis, publicThis);
4737      if (!isObject(data))
4738        ;
4739      else {
4740        instance.data = reactive(data);
4741      }
4742    }
4743    shouldCacheAccess = true;
4744    if (computedOptions) {
4745      for (const key in computedOptions) {
4746        const opt = computedOptions[key];
4747        const get = isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;
4748        const set = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : NOOP;
4749        const c = computed({
4750          get,
4751          set
4752        });
4753        Object.defineProperty(ctx, key, {
4754          enumerable: true,
4755          configurable: true,
4756          get: () => c.value,
4757          set: (v) => c.value = v
4758        });
4759      }
4760    }
4761    if (watchOptions) {
4762      for (const key in watchOptions) {
4763        createWatcher(watchOptions[key], ctx, publicThis, key);
4764      }
4765    }
4766    if (provideOptions) {
4767      const provides = isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions;

vendor: 6,938 bytes, lines 4768-5004

4768      Reflect.ownKeys(provides).forEach((key) => {
4769        provide(key, provides[key]);
4770      });
4771    }
4772    if (created) {
4773      callHook$1(created, instance, "c");
4774    }
4775    function registerLifecycleHook(register, hook) {
4776      if (isArray(hook)) {
4777        hook.forEach((_hook) => register(_hook.bind(publicThis)));
4778      } else if (hook) {
4779        register(hook.bind(publicThis));
4780      }
4781    }
4782    registerLifecycleHook(onBeforeMount, beforeMount);
4783    registerLifecycleHook(onMounted, mounted);
4784    registerLifecycleHook(onBeforeUpdate, beforeUpdate);
4785    registerLifecycleHook(onUpdated, updated);
4786    registerLifecycleHook(onActivated, activated);
4787    registerLifecycleHook(onDeactivated, deactivated);
4788    registerLifecycleHook(onErrorCaptured, errorCaptured);
4789    registerLifecycleHook(onRenderTracked, renderTracked);
4790    registerLifecycleHook(onRenderTriggered, renderTriggered);
4791    registerLifecycleHook(onBeforeUnmount, beforeUnmount);
4792    registerLifecycleHook(onUnmounted, unmounted);
4793    registerLifecycleHook(onServerPrefetch, serverPrefetch);
4794    if (isArray(expose)) {
4795      if (expose.length) {
4796        const exposed = instance.exposed || (instance.exposed = {});
4797        expose.forEach((key) => {
4798          Object.defineProperty(exposed, key, {
4799            get: () => publicThis[key],
4800            set: (val) => publicThis[key] = val
4801          });
4802        });
4803      } else if (!instance.exposed) {
4804        instance.exposed = {};
4805      }
4806    }
4807    if (render2 && instance.render === NOOP) {
4808      instance.render = render2;
4809    }
4810    if (inheritAttrs != null) {
4811      instance.inheritAttrs = inheritAttrs;
4812    }
4813    if (components)
4814      instance.components = components;
4815    if (directives)
4816      instance.directives = directives;
4817    if (serverPrefetch) {
4818      markAsyncBoundary(instance);
4819    }
4820  }
4821  function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {
4822    if (isArray(injectOptions)) {
4823      injectOptions = normalizeInject(injectOptions);
4824    }
4825    for (const key in injectOptions) {
4826      const opt = injectOptions[key];
4827      let injected;
4828      if (isObject(opt)) {
4829        if ("default" in opt) {
4830          injected = inject(
4831            opt.from || key,
4832            opt.default,
4833            true
4834          );
4835        } else {
4836          injected = inject(opt.from || key);
4837        }
4838      } else {
4839        injected = inject(opt);
4840      }
4841      if (isRef(injected)) {
4842        Object.defineProperty(ctx, key, {
4843          enumerable: true,
4844          configurable: true,
4845          get: () => injected.value,
4846          set: (v) => injected.value = v
4847        });
4848      } else {
4849        ctx[key] = injected;
4850      }
4851    }
4852  }
4853  function callHook$1(hook, instance, type) {
4854    callWithAsyncErrorHandling(
4855      isArray(hook) ? hook.map((h2) => h2.bind(instance.proxy)) : hook.bind(instance.proxy),
4856      instance,
4857      type
4858    );
4859  }
4860  function createWatcher(raw, ctx, publicThis, key) {
4861    let getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
4862    if (isString(raw)) {
4863      const handler = ctx[raw];
4864      if (isFunction(handler)) {
4865        {
4866          watch(getter, handler);
4867        }
4868      }
4869    } else if (isFunction(raw)) {
4870      {
4871        watch(getter, raw.bind(publicThis));
4872      }
4873    } else if (isObject(raw)) {
4874      if (isArray(raw)) {
4875        raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
4876      } else {
4877        const handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
4878        if (isFunction(handler)) {
4879          watch(getter, handler, raw);
4880        }
4881      }
4882    } else
4883      ;
4884  }
4885  function resolveMergedOptions(instance) {
4886    const base = instance.type;
4887    const { mixins, extends: extendsOptions } = base;
4888    const {
4889      mixins: globalMixins,
4890      optionsCache: cache,
4891      config: { optionMergeStrategies }
4892    } = instance.appContext;
4893    const cached = cache.get(base);
4894    let resolved;
4895    if (cached) {
4896      resolved = cached;
4897    } else if (!globalMixins.length && !mixins && !extendsOptions) {
4898      {
4899        resolved = base;
4900      }
4901    } else {
4902      resolved = {};
4903      if (globalMixins.length) {
4904        globalMixins.forEach(
4905          (m) => mergeOptions(resolved, m, optionMergeStrategies, true)
4906        );
4907      }
4908      mergeOptions(resolved, base, optionMergeStrategies);
4909    }
4910    if (isObject(base)) {
4911      cache.set(base, resolved);
4912    }
4913    return resolved;
4914  }
4915  function mergeOptions(to, from, strats, asMixin = false) {
4916    const { mixins, extends: extendsOptions } = from;
4917    if (extendsOptions) {
4918      mergeOptions(to, extendsOptions, strats, true);
4919    }
4920    if (mixins) {
4921      mixins.forEach(
4922        (m) => mergeOptions(to, m, strats, true)
4923      );
4924    }
4925    for (const key in from) {
4926      if (asMixin && key === "expose")
4927        ;
4928      else {
4929        const strat = internalOptionMergeStrats[key] || strats && strats[key];
4930        to[key] = strat ? strat(to[key], from[key]) : from[key];
4931      }
4932    }
4933    return to;
4934  }
4935  const internalOptionMergeStrats = {
4936    data: mergeDataFn,
4937    props: mergeEmitsOrPropsOptions,
4938    emits: mergeEmitsOrPropsOptions,
4939    // objects
4940    methods: mergeObjectOptions,
4941    computed: mergeObjectOptions,
4942    // lifecycle
4943    beforeCreate: mergeAsArray,
4944    created: mergeAsArray,
4945    beforeMount: mergeAsArray,
4946    mounted: mergeAsArray,
4947    beforeUpdate: mergeAsArray,
4948    updated: mergeAsArray,
4949    beforeDestroy: mergeAsArray,
4950    beforeUnmount: mergeAsArray,
4951    destroyed: mergeAsArray,
4952    unmounted: mergeAsArray,
4953    activated: mergeAsArray,
4954    deactivated: mergeAsArray,
4955    errorCaptured: mergeAsArray,
4956    serverPrefetch: mergeAsArray,
4957    // assets
4958    components: mergeObjectOptions,
4959    directives: mergeObjectOptions,
4960    // watch
4961    watch: mergeWatchOptions,
4962    // provide / inject
4963    provide: mergeDataFn,
4964    inject: mergeInject
4965  };
4966  function mergeDataFn(to, from) {
4967    if (!from) {
4968      return to;
4969    }
4970    if (!to) {
4971      return from;
4972    }
4973    return function mergedDataFn() {
4974      return extend(
4975        isFunction(to) ? to.call(this, this) : to,
4976        isFunction(from) ? from.call(this, this) : from
4977      );
4978    };
4979  }
4980  function mergeInject(to, from) {
4981    return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
4982  }
4983  function normalizeInject(raw) {
4984    if (isArray(raw)) {
4985      const res = {};
4986      for (let i = 0; i < raw.length; i++) {
4987        res[raw[i]] = raw[i];
4988      }
4989      return res;
4990    }
4991    return raw;
4992  }
4993  function mergeAsArray(to, from) {
4994    return to ? [...new Set([].concat(to, from))] : from;
4995  }
4996  function mergeObjectOptions(to, from) {
4997    return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
4998  }
4999  function mergeEmitsOrPropsOptions(to, from) {
5000    if (to) {
5001      if (isArray(to) && isArray(from)) {
5002        return [.../* @__PURE__ */ new Set([...to, ...from])];
5003      }
5004      return extend(

vendor: 6,606 bytes, lines 5005-5217

5005        /* @__PURE__ */ Object.create(null),
5006        normalizePropsOrEmits(to),
5007        normalizePropsOrEmits(from != null ? from : {})
5008      );
5009    } else {
5010      return from;
5011    }
5012  }
5013  function mergeWatchOptions(to, from) {
5014    if (!to)
5015      return from;
5016    if (!from)
5017      return to;
5018    const merged = extend(/* @__PURE__ */ Object.create(null), to);
5019    for (const key in from) {
5020      merged[key] = mergeAsArray(to[key], from[key]);
5021    }
5022    return merged;
5023  }
5024  function createAppContext() {
5025    return {
5026      app: null,
5027      config: {
5028        isNativeTag: NO,
5029        performance: false,
5030        globalProperties: {},
5031        optionMergeStrategies: {},
5032        errorHandler: void 0,
5033        warnHandler: void 0,
5034        compilerOptions: {}
5035      },
5036      mixins: [],
5037      components: {},
5038      directives: {},
5039      provides: /* @__PURE__ */ Object.create(null),
5040      optionsCache: /* @__PURE__ */ new WeakMap(),
5041      propsCache: /* @__PURE__ */ new WeakMap(),
5042      emitsCache: /* @__PURE__ */ new WeakMap()
5043    };
5044  }
5045  let uid$1 = 0;
5046  function createAppAPI(render2, hydrate2) {
5047    return function createApp2(rootComponent, rootProps = null) {
5048      if (!isFunction(rootComponent)) {
5049        rootComponent = extend({}, rootComponent);
5050      }
5051      if (rootProps != null && !isObject(rootProps)) {
5052        rootProps = null;
5053      }
5054      const context = createAppContext();
5055      const installedPlugins = /* @__PURE__ */ new WeakSet();
5056      const pluginCleanupFns = [];
5057      let isMounted = false;
5058      const app = context.app = {
5059        _uid: uid$1++,
5060        _component: rootComponent,
5061        _props: rootProps,
5062        _container: null,
5063        _context: context,
5064        _instance: null,
5065        version,
5066        get config() {
5067          return context.config;
5068        },
5069        set config(v) {
5070        },
5071        use(plugin, ...options) {
5072          if (installedPlugins.has(plugin))
5073            ;
5074          else if (plugin && isFunction(plugin.install)) {
5075            installedPlugins.add(plugin);
5076            plugin.install(app, ...options);
5077          } else if (isFunction(plugin)) {
5078            installedPlugins.add(plugin);
5079            plugin(app, ...options);
5080          } else
5081            ;
5082          return app;
5083        },
5084        mixin(mixin) {
5085          {
5086            if (!context.mixins.includes(mixin)) {
5087              context.mixins.push(mixin);
5088            }
5089          }
5090          return app;
5091        },
5092        component(name, component) {
5093          if (!component) {
5094            return context.components[name];
5095          }
5096          context.components[name] = component;
5097          return app;
5098        },
5099        directive(name, directive) {
5100          if (!directive) {
5101            return context.directives[name];
5102          }
5103          context.directives[name] = directive;
5104          return app;
5105        },
5106        mount(rootContainer, isHydrate, namespace) {
5107          if (!isMounted) {
5108            const vnode = app._ceVNode || createVNode(rootComponent, rootProps);
5109            vnode.appContext = context;
5110            if (namespace === true) {
5111              namespace = "svg";
5112            } else if (namespace === false) {
5113              namespace = void 0;
5114            }
5115            if (isHydrate && hydrate2) {
5116              hydrate2(vnode, rootContainer);
5117            } else {
5118              render2(vnode, rootContainer, namespace);
5119            }
5120            isMounted = true;
5121            app._container = rootContainer;
5122            rootContainer.__vue_app__ = app;
5123            return getComponentPublicInstance(vnode.component);
5124          }
5125        },
5126        onUnmount(cleanupFn) {
5127          pluginCleanupFns.push(cleanupFn);
5128        },
5129        unmount() {
5130          if (isMounted) {
5131            callWithAsyncErrorHandling(
5132              pluginCleanupFns,
5133              app._instance,
5134              16
5135            );
5136            render2(null, app._container);
5137            delete app._container.__vue_app__;
5138          }
5139        },
5140        provide(key, value) {
5141          context.provides[key] = value;
5142          return app;
5143        },
5144        runWithContext(fn) {
5145          const lastApp = currentApp;
5146          currentApp = app;
5147          try {
5148            return fn();
5149          } finally {
5150            currentApp = lastApp;
5151          }
5152        }
5153      };
5154      return app;
5155    };
5156  }
5157  let currentApp = null;
5158  function provide(key, value) {
5159    if (!currentInstance)
5160      ;
5161    else {
5162      let provides = currentInstance.provides;
5163      const parentProvides = currentInstance.parent && currentInstance.parent.provides;
5164      if (parentProvides === provides) {
5165        provides = currentInstance.provides = Object.create(parentProvides);
5166      }
5167      provides[key] = value;
5168    }
5169  }
5170  function inject(key, defaultValue, treatDefaultAsFactory = false) {
5171    const instance = currentInstance || currentRenderingInstance;
5172    if (instance || currentApp) {
5173      const provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
5174      if (provides && key in provides) {
5175        return provides[key];
5176      } else if (arguments.length > 1) {
5177        return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
5178      } else
5179        ;
5180    }
5181  }
5182  function hasInjectionContext() {
5183    return !!(currentInstance || currentRenderingInstance || currentApp);
5184  }
5185  const internalObjectProto = {};
5186  const createInternalObject = () => Object.create(internalObjectProto);
5187  const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
5188  function initProps(instance, rawProps, isStateful, isSSR = false) {
5189    const props = {};
5190    const attrs = createInternalObject();
5191    instance.propsDefaults = /* @__PURE__ */ Object.create(null);
5192    setFullProps(instance, rawProps, props, attrs);
5193    for (const key in instance.propsOptions[0]) {
5194      if (!(key in props)) {
5195        props[key] = void 0;
5196      }
5197    }
5198    if (isStateful) {
5199      instance.props = isSSR ? props : shallowReactive(props);
5200    } else {
5201      if (!instance.type.props) {
5202        instance.props = attrs;
5203      } else {
5204        instance.props = props;
5205      }
5206    }
5207    instance.attrs = attrs;
5208  }
5209  function updateProps(instance, rawProps, rawPrevProps, optimized) {
5210    const {
5211      props,
5212      attrs,
5213      vnode: { patchFlag }
5214    } = instance;
5215    const rawCurrentProps = toRaw(props);
5216    const [options] = instance.propsOptions;
5217    let hasAttrsChanged = false;

vendor: 4,754 bytes, lines 5218-5370

5218    if (
5219      // always force full diff in dev
5220      // - #1942 if hmr is enabled with sfc component
5221      // - vite#872 non-sfc component used by sfc component
5222      (optimized || patchFlag > 0) && !(patchFlag & 16)
5223    ) {
5224      if (patchFlag & 8) {
5225        const propsToUpdate = instance.vnode.dynamicProps;
5226        for (let i = 0; i < propsToUpdate.length; i++) {
5227          let key = propsToUpdate[i];
5228          if (isEmitListener(instance.emitsOptions, key)) {
5229            continue;
5230          }
5231          const value = rawProps[key];
5232          if (options) {
5233            if (hasOwn(attrs, key)) {
5234              if (value !== attrs[key]) {
5235                attrs[key] = value;
5236                hasAttrsChanged = true;
5237              }
5238            } else {
5239              const camelizedKey = camelize(key);
5240              props[camelizedKey] = resolvePropValue(
5241                options,
5242                rawCurrentProps,
5243                camelizedKey,
5244                value,
5245                instance,
5246                false
5247              );
5248            }
5249          } else {
5250            if (value !== attrs[key]) {
5251              attrs[key] = value;
5252              hasAttrsChanged = true;
5253            }
5254          }
5255        }
5256      }
5257    } else {
5258      if (setFullProps(instance, rawProps, props, attrs)) {
5259        hasAttrsChanged = true;
5260      }
5261      let kebabKey;
5262      for (const key in rawCurrentProps) {
5263        if (!rawProps || // for camelCase
5264        !hasOwn(rawProps, key) && // it's possible the original props was passed in as kebab-case
5265        // and converted to camelCase (#955)
5266        ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
5267          if (options) {
5268            if (rawPrevProps && // for camelCase
5269            (rawPrevProps[key] !== void 0 || // for kebab-case
5270            rawPrevProps[kebabKey] !== void 0)) {
5271              props[key] = resolvePropValue(
5272                options,
5273                rawCurrentProps,
5274                key,
5275                void 0,
5276                instance,
5277                true
5278              );
5279            }
5280          } else {
5281            delete props[key];
5282          }
5283        }
5284      }
5285      if (attrs !== rawCurrentProps) {
5286        for (const key in attrs) {
5287          if (!rawProps || !hasOwn(rawProps, key) && true) {
5288            delete attrs[key];
5289            hasAttrsChanged = true;
5290          }
5291        }
5292      }
5293    }
5294    if (hasAttrsChanged) {
5295      trigger(instance.attrs, "set", "");
5296    }
5297  }
5298  function setFullProps(instance, rawProps, props, attrs) {
5299    const [options, needCastKeys] = instance.propsOptions;
5300    let hasAttrsChanged = false;
5301    let rawCastValues;
5302    if (rawProps) {
5303      for (let key in rawProps) {
5304        if (isReservedProp(key)) {
5305          continue;
5306        }
5307        const value = rawProps[key];
5308        let camelKey;
5309        if (options && hasOwn(options, camelKey = camelize(key))) {
5310          if (!needCastKeys || !needCastKeys.includes(camelKey)) {
5311            props[camelKey] = value;
5312          } else {
5313            (rawCastValues || (rawCastValues = {}))[camelKey] = value;
5314          }
5315        } else if (!isEmitListener(instance.emitsOptions, key)) {
5316          if (!(key in attrs) || value !== attrs[key]) {
5317            attrs[key] = value;
5318            hasAttrsChanged = true;
5319          }
5320        }
5321      }
5322    }
5323    if (needCastKeys) {
5324      const rawCurrentProps = toRaw(props);
5325      const castValues = rawCastValues || EMPTY_OBJ;
5326      for (let i = 0; i < needCastKeys.length; i++) {
5327        const key = needCastKeys[i];
5328        props[key] = resolvePropValue(
5329          options,
5330          rawCurrentProps,
5331          key,
5332          castValues[key],
5333          instance,
5334          !hasOwn(castValues, key)
5335        );
5336      }
5337    }
5338    return hasAttrsChanged;
5339  }
5340  function resolvePropValue(options, props, key, value, instance, isAbsent) {
5341    const opt = options[key];
5342    if (opt != null) {
5343      const hasDefault = hasOwn(opt, "default");
5344      if (hasDefault && value === void 0) {
5345        const defaultValue = opt.default;
5346        if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
5347          const { propsDefaults } = instance;
5348          if (key in propsDefaults) {
5349            value = propsDefaults[key];
5350          } else {
5351            const reset = setCurrentInstance(instance);
5352            value = propsDefaults[key] = defaultValue.call(
5353              null,
5354              props
5355            );
5356            reset();
5357          }
5358        } else {
5359          value = defaultValue;
5360        }
5361        if (instance.ce) {
5362          instance.ce._setProp(key, value);
5363        }
5364      }
5365      if (opt[
5366        0
5367        /* shouldCast */
5368      ]) {
5369        if (isAbsent && !hasDefault) {
5370          value = false;

vendor: 16,481 bytes, lines 5371-5910

5371        } else if (opt[
5372          1
5373          /* shouldCastTrue */
5374        ] && (value === "" || value === hyphenate(key))) {
5375          value = true;
5376        }
5377      }
5378    }
5379    return value;
5380  }
5381  const mixinPropsCache = /* @__PURE__ */ new WeakMap();
5382  function normalizePropsOptions(comp, appContext, asMixin = false) {
5383    const cache = asMixin ? mixinPropsCache : appContext.propsCache;
5384    const cached = cache.get(comp);
5385    if (cached) {
5386      return cached;
5387    }
5388    const raw = comp.props;
5389    const normalized = {};
5390    const needCastKeys = [];
5391    let hasExtends = false;
5392    if (!isFunction(comp)) {
5393      const extendProps = (raw2) => {
5394        hasExtends = true;
5395        const [props, keys] = normalizePropsOptions(raw2, appContext, true);
5396        extend(normalized, props);
5397        if (keys)
5398          needCastKeys.push(...keys);
5399      };
5400      if (!asMixin && appContext.mixins.length) {
5401        appContext.mixins.forEach(extendProps);
5402      }
5403      if (comp.extends) {
5404        extendProps(comp.extends);
5405      }
5406      if (comp.mixins) {
5407        comp.mixins.forEach(extendProps);
5408      }
5409    }
5410    if (!raw && !hasExtends) {
5411      if (isObject(comp)) {
5412        cache.set(comp, EMPTY_ARR);
5413      }
5414      return EMPTY_ARR;
5415    }
5416    if (isArray(raw)) {
5417      for (let i = 0; i < raw.length; i++) {
5418        const normalizedKey = camelize(raw[i]);
5419        if (validatePropName(normalizedKey)) {
5420          normalized[normalizedKey] = EMPTY_OBJ;
5421        }
5422      }
5423    } else if (raw) {
5424      for (const key in raw) {
5425        const normalizedKey = camelize(key);
5426        if (validatePropName(normalizedKey)) {
5427          const opt = raw[key];
5428          const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { type: opt } : extend({}, opt);
5429          const propType = prop.type;
5430          let shouldCast = false;
5431          let shouldCastTrue = true;
5432          if (isArray(propType)) {
5433            for (let index2 = 0; index2 < propType.length; ++index2) {
5434              const type = propType[index2];
5435              const typeName = isFunction(type) && type.name;
5436              if (typeName === "Boolean") {
5437                shouldCast = true;
5438                break;
5439              } else if (typeName === "String") {
5440                shouldCastTrue = false;
5441              }
5442            }
5443          } else {
5444            shouldCast = isFunction(propType) && propType.name === "Boolean";
5445          }
5446          prop[
5447            0
5448            /* shouldCast */
5449          ] = shouldCast;
5450          prop[
5451            1
5452            /* shouldCastTrue */
5453          ] = shouldCastTrue;
5454          if (shouldCast || hasOwn(prop, "default")) {
5455            needCastKeys.push(normalizedKey);
5456          }
5457        }
5458      }
5459    }
5460    const res = [normalized, needCastKeys];
5461    if (isObject(comp)) {
5462      cache.set(comp, res);
5463    }
5464    return res;
5465  }
5466  function validatePropName(key) {
5467    if (key[0] !== "$" && !isReservedProp(key)) {
5468      return true;
5469    }
5470    return false;
5471  }
5472  const isInternalKey = (key) => key[0] === "_" || key === "$stable";
5473  const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode$1) : [normalizeVNode$1(value)];
5474  const normalizeSlot = (key, rawSlot, ctx) => {
5475    if (rawSlot._n) {
5476      return rawSlot;
5477    }
5478    const normalized = withCtx((...args) => {
5479      if (false)
5480        ;
5481      return normalizeSlotValue(rawSlot(...args));
5482    }, ctx);
5483    normalized._c = false;
5484    return normalized;
5485  };
5486  const normalizeObjectSlots = (rawSlots, slots, instance) => {
5487    const ctx = rawSlots._ctx;
5488    for (const key in rawSlots) {
5489      if (isInternalKey(key))
5490        continue;
5491      const value = rawSlots[key];
5492      if (isFunction(value)) {
5493        slots[key] = normalizeSlot(key, value, ctx);
5494      } else if (value != null) {
5495        const normalized = normalizeSlotValue(value);
5496        slots[key] = () => normalized;
5497      }
5498    }
5499  };
5500  const normalizeVNodeSlots = (instance, children) => {
5501    const normalized = normalizeSlotValue(children);
5502    instance.slots.default = () => normalized;
5503  };
5504  const assignSlots = (slots, children, optimized) => {
5505    for (const key in children) {
5506      if (optimized || key !== "_") {
5507        slots[key] = children[key];
5508      }
5509    }
5510  };
5511  const initSlots = (instance, children, optimized) => {
5512    const slots = instance.slots = createInternalObject();
5513    if (instance.vnode.shapeFlag & 32) {
5514      const type = children._;
5515      if (type) {
5516        assignSlots(slots, children, optimized);
5517        if (optimized) {
5518          def(slots, "_", type, true);
5519        }
5520      } else {
5521        normalizeObjectSlots(children, slots);
5522      }
5523    } else if (children) {
5524      normalizeVNodeSlots(instance, children);
5525    }
5526  };
5527  const updateSlots = (instance, children, optimized) => {
5528    const { vnode, slots } = instance;
5529    let needDeletionCheck = true;
5530    let deletionComparisonTarget = EMPTY_OBJ;
5531    if (vnode.shapeFlag & 32) {
5532      const type = children._;
5533      if (type) {
5534        if (optimized && type === 1) {
5535          needDeletionCheck = false;
5536        } else {
5537          assignSlots(slots, children, optimized);
5538        }
5539      } else {
5540        needDeletionCheck = !children.$stable;
5541        normalizeObjectSlots(children, slots);
5542      }
5543      deletionComparisonTarget = children;
5544    } else if (children) {
5545      normalizeVNodeSlots(instance, children);
5546      deletionComparisonTarget = { default: 1 };
5547    }
5548    if (needDeletionCheck) {
5549      for (const key in slots) {
5550        if (!isInternalKey(key) && deletionComparisonTarget[key] == null) {
5551          delete slots[key];
5552        }
5553      }
5554    }
5555  };
5556  const queuePostRenderEffect = queueEffectWithSuspense;
5557  function createRenderer(options) {
5558    return baseCreateRenderer(options);
5559  }
5560  function createHydrationRenderer(options) {
5561    return baseCreateRenderer(options, createHydrationFunctions);
5562  }
5563  function baseCreateRenderer(options, createHydrationFns) {
5564    const target = getGlobalThis();
5565    target.__VUE__ = true;
5566    const {
5567      insert: hostInsert,
5568      remove: hostRemove,
5569      patchProp: hostPatchProp,
5570      createElement: hostCreateElement,
5571      createText: hostCreateText,
5572      createComment: hostCreateComment,
5573      setText: hostSetText,
5574      setElementText: hostSetElementText,
5575      parentNode: hostParentNode,
5576      nextSibling: hostNextSibling,
5577      setScopeId: hostSetScopeId = NOOP,
5578      insertStaticContent: hostInsertStaticContent
5579    } = options;
5580    const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, namespace = void 0, slotScopeIds = null, optimized = !!n2.dynamicChildren) => {
5581      if (n1 === n2) {
5582        return;
5583      }
5584      if (n1 && !isSameVNodeType(n1, n2)) {
5585        anchor = getNextHostNode(n1);
5586        unmount(n1, parentComponent, parentSuspense, true);
5587        n1 = null;
5588      }
5589      if (n2.patchFlag === -2) {
5590        optimized = false;
5591        n2.dynamicChildren = null;
5592      }
5593      const { type, ref: ref2, shapeFlag } = n2;
5594      switch (type) {
5595        case Text:
5596          processText(n1, n2, container, anchor);
5597          break;
5598        case Comment:
5599          processCommentNode(n1, n2, container, anchor);
5600          break;
5601        case Static:
5602          if (n1 == null) {
5603            mountStaticNode(n2, container, anchor, namespace);
5604          }
5605          break;
5606        case Fragment:
5607          processFragment(
5608            n1,
5609            n2,
5610            container,
5611            anchor,
5612            parentComponent,
5613            parentSuspense,
5614            namespace,
5615            slotScopeIds,
5616            optimized
5617          );
5618          break;
5619        default:
5620          if (shapeFlag & 1) {
5621            processElement(
5622              n1,
5623              n2,
5624              container,
5625              anchor,
5626              parentComponent,
5627              parentSuspense,
5628              namespace,
5629              slotScopeIds,
5630              optimized
5631            );
5632          } else if (shapeFlag & 6) {
5633            processComponent(
5634              n1,
5635              n2,
5636              container,
5637              anchor,
5638              parentComponent,
5639              parentSuspense,
5640              namespace,
5641              slotScopeIds,
5642              optimized
5643            );
5644          } else if (shapeFlag & 64) {
5645            type.process(
5646              n1,
5647              n2,
5648              container,
5649              anchor,
5650              parentComponent,
5651              parentSuspense,
5652              namespace,
5653              slotScopeIds,
5654              optimized,
5655              internals
5656            );
5657          } else if (shapeFlag & 128) {
5658            type.process(
5659              n1,
5660              n2,
5661              container,
5662              anchor,
5663              parentComponent,
5664              parentSuspense,
5665              namespace,
5666              slotScopeIds,
5667              optimized,
5668              internals
5669            );
5670          } else
5671            ;
5672      }
5673      if (ref2 != null && parentComponent) {
5674        setRef(ref2, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
5675      }
5676    };
5677    const processText = (n1, n2, container, anchor) => {
5678      if (n1 == null) {
5679        hostInsert(
5680          n2.el = hostCreateText(n2.children),
5681          container,
5682          anchor
5683        );
5684      } else {
5685        const el = n2.el = n1.el;
5686        if (n2.children !== n1.children) {
5687          hostSetText(el, n2.children);
5688        }
5689      }
5690    };
5691    const processCommentNode = (n1, n2, container, anchor) => {
5692      if (n1 == null) {
5693        hostInsert(
5694          n2.el = hostCreateComment(n2.children || ""),
5695          container,
5696          anchor
5697        );
5698      } else {
5699        n2.el = n1.el;
5700      }
5701    };
5702    const mountStaticNode = (n2, container, anchor, namespace) => {
5703      [n2.el, n2.anchor] = hostInsertStaticContent(
5704        n2.children,
5705        container,
5706        anchor,
5707        namespace,
5708        n2.el,
5709        n2.anchor
5710      );
5711    };
5712    const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
5713      let next;
5714      while (el && el !== anchor) {
5715        next = hostNextSibling(el);
5716        hostInsert(el, container, nextSibling);
5717        el = next;
5718      }
5719      hostInsert(anchor, container, nextSibling);
5720    };
5721    const removeStaticNode = ({ el, anchor }) => {
5722      let next;
5723      while (el && el !== anchor) {
5724        next = hostNextSibling(el);
5725        hostRemove(el);
5726        el = next;
5727      }
5728      hostRemove(anchor);
5729    };
5730    const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
5731      if (n2.type === "svg") {
5732        namespace = "svg";
5733      } else if (n2.type === "math") {
5734        namespace = "mathml";
5735      }
5736      if (n1 == null) {
5737        mountElement(
5738          n2,
5739          container,
5740          anchor,
5741          parentComponent,
5742          parentSuspense,
5743          namespace,
5744          slotScopeIds,
5745          optimized
5746        );
5747      } else {
5748        patchElement(
5749          n1,
5750          n2,
5751          parentComponent,
5752          parentSuspense,
5753          namespace,
5754          slotScopeIds,
5755          optimized
5756        );
5757      }
5758    };
5759    const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
5760      let el;
5761      let vnodeHook;
5762      const { props, shapeFlag, transition, dirs } = vnode;
5763      el = vnode.el = hostCreateElement(
5764        vnode.type,
5765        namespace,
5766        props && props.is,
5767        props
5768      );
5769      if (shapeFlag & 8) {
5770        hostSetElementText(el, vnode.children);
5771      } else if (shapeFlag & 16) {
5772        mountChildren(
5773          vnode.children,
5774          el,
5775          null,
5776          parentComponent,
5777          parentSuspense,
5778          resolveChildrenNamespace(vnode, namespace),
5779          slotScopeIds,
5780          optimized
5781        );
5782      }
5783      if (dirs) {
5784        invokeDirectiveHook(vnode, null, parentComponent, "created");
5785      }
5786      setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);
5787      if (props) {
5788        for (const key in props) {
5789          if (key !== "value" && !isReservedProp(key)) {
5790            hostPatchProp(el, key, null, props[key], namespace, parentComponent);
5791          }
5792        }
5793        if ("value" in props) {
5794          hostPatchProp(el, "value", null, props.value, namespace);
5795        }
5796        if (vnodeHook = props.onVnodeBeforeMount) {
5797          invokeVNodeHook(vnodeHook, parentComponent, vnode);
5798        }
5799      }
5800      if (dirs) {
5801        invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
5802      }
5803      const needCallTransitionHooks = needTransition(parentSuspense, transition);
5804      if (needCallTransitionHooks) {
5805        transition.beforeEnter(el);
5806      }
5807      hostInsert(el, container, anchor);
5808      if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
5809        queuePostRenderEffect(() => {
5810          vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
5811          needCallTransitionHooks && transition.enter(el);
5812          dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
5813        }, parentSuspense);
5814      }
5815    };
5816    const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
5817      if (scopeId) {
5818        hostSetScopeId(el, scopeId);
5819      }
5820      if (slotScopeIds) {
5821        for (let i = 0; i < slotScopeIds.length; i++) {
5822          hostSetScopeId(el, slotScopeIds[i]);
5823        }
5824      }
5825      if (parentComponent) {
5826        let subTree = parentComponent.subTree;
5827        if (vnode === subTree || isSuspense(subTree.type) && (subTree.ssContent === vnode || subTree.ssFallback === vnode)) {
5828          const parentVNode = parentComponent.vnode;
5829          setScopeId(
5830            el,
5831            parentVNode,
5832            parentVNode.scopeId,
5833            parentVNode.slotScopeIds,
5834            parentComponent.parent
5835          );
5836        }
5837      }
5838    };
5839    const mountChildren = (children, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, start = 0) => {
5840      for (let i = start; i < children.length; i++) {
5841        const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode$1(children[i]);
5842        patch(
5843          null,
5844          child,
5845          container,
5846          anchor,
5847          parentComponent,
5848          parentSuspense,
5849          namespace,
5850          slotScopeIds,
5851          optimized
5852        );
5853      }
5854    };
5855    const patchElement = (n1, n2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
5856      const el = n2.el = n1.el;
5857      let { patchFlag, dynamicChildren, dirs } = n2;
5858      patchFlag |= n1.patchFlag & 16;
5859      const oldProps = n1.props || EMPTY_OBJ;
5860      const newProps = n2.props || EMPTY_OBJ;
5861      let vnodeHook;
5862      parentComponent && toggleRecurse(parentComponent, false);
5863      if (vnodeHook = newProps.onVnodeBeforeUpdate) {
5864        invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
5865      }
5866      if (dirs) {
5867        invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
5868      }
5869      parentComponent && toggleRecurse(parentComponent, true);
5870      if (oldProps.innerHTML && newProps.innerHTML == null || oldProps.textContent && newProps.textContent == null) {
5871        hostSetElementText(el, "");
5872      }
5873      if (dynamicChildren) {
5874        patchBlockChildren(
5875          n1.dynamicChildren,
5876          dynamicChildren,
5877          el,
5878          parentComponent,
5879          parentSuspense,
5880          resolveChildrenNamespace(n2, namespace),
5881          slotScopeIds
5882        );
5883      } else if (!optimized) {
5884        patchChildren(
5885          n1,
5886          n2,
5887          el,
5888          null,
5889          parentComponent,
5890          parentSuspense,
5891          resolveChildrenNamespace(n2, namespace),
5892          slotScopeIds,
5893          false
5894        );
5895      }
5896      if (patchFlag > 0) {
5897        if (patchFlag & 16) {
5898          patchProps(el, oldProps, newProps, parentComponent, namespace);
5899        } else {
5900          if (patchFlag & 2) {
5901            if (oldProps.class !== newProps.class) {
5902              hostPatchProp(el, "class", null, newProps.class, namespace);
5903            }
5904          }
5905          if (patchFlag & 4) {
5906            hostPatchProp(el, "style", oldProps.style, newProps.style, namespace);
5907          }
5908          if (patchFlag & 8) {
5909            const propsToUpdate = n2.dynamicProps;
5910            for (let i = 0; i < propsToUpdate.length; i++) {

vendor: 4,957 bytes, lines 5911-6035

5911              const key = propsToUpdate[i];
5912              const prev = oldProps[key];
5913              const next = newProps[key];
5914              if (next !== prev || key === "value") {
5915                hostPatchProp(el, key, prev, next, namespace, parentComponent);
5916              }
5917            }
5918          }
5919        }
5920        if (patchFlag & 1) {
5921          if (n1.children !== n2.children) {
5922            hostSetElementText(el, n2.children);
5923          }
5924        }
5925      } else if (!optimized && dynamicChildren == null) {
5926        patchProps(el, oldProps, newProps, parentComponent, namespace);
5927      }
5928      if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
5929        queuePostRenderEffect(() => {
5930          vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
5931          dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
5932        }, parentSuspense);
5933      }
5934    };
5935    const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, namespace, slotScopeIds) => {
5936      for (let i = 0; i < newChildren.length; i++) {
5937        const oldVNode = oldChildren[i];
5938        const newVNode = newChildren[i];
5939        const container = (
5940          // oldVNode may be an errored async setup() component inside Suspense
5941          // which will not have a mounted element
5942          oldVNode.el && // - In the case of a Fragment, we need to provide the actual parent
5943          // of the Fragment itself so it can move its children.
5944          (oldVNode.type === Fragment || // - In the case of different nodes, there is going to be a replacement
5945          // which also requires the correct parent container
5946          !isSameVNodeType(oldVNode, newVNode) || // - In the case of a component, it could contain anything.
5947          oldVNode.shapeFlag & (6 | 64)) ? hostParentNode(oldVNode.el) : (
5948            // In other cases, the parent container is not actually used so we
5949            // just pass the block element here to avoid a DOM parentNode call.
5950            fallbackContainer
5951          )
5952        );
5953        patch(
5954          oldVNode,
5955          newVNode,
5956          container,
5957          null,
5958          parentComponent,
5959          parentSuspense,
5960          namespace,
5961          slotScopeIds,
5962          true
5963        );
5964      }
5965    };
5966    const patchProps = (el, oldProps, newProps, parentComponent, namespace) => {
5967      if (oldProps !== newProps) {
5968        if (oldProps !== EMPTY_OBJ) {
5969          for (const key in oldProps) {
5970            if (!isReservedProp(key) && !(key in newProps)) {
5971              hostPatchProp(
5972                el,
5973                key,
5974                oldProps[key],
5975                null,
5976                namespace,
5977                parentComponent
5978              );
5979            }
5980          }
5981        }
5982        for (const key in newProps) {
5983          if (isReservedProp(key))
5984            continue;
5985          const next = newProps[key];
5986          const prev = oldProps[key];
5987          if (next !== prev && key !== "value") {
5988            hostPatchProp(el, key, prev, next, namespace, parentComponent);
5989          }
5990        }
5991        if ("value" in newProps) {
5992          hostPatchProp(el, "value", oldProps.value, newProps.value, namespace);
5993        }
5994      }
5995    };
5996    const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
5997      const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
5998      const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
5999      let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
6000      if (fragmentSlotScopeIds) {
6001        slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
6002      }
6003      if (n1 == null) {
6004        hostInsert(fragmentStartAnchor, container, anchor);
6005        hostInsert(fragmentEndAnchor, container, anchor);
6006        mountChildren(
6007          // #10007
6008          // such fragment like `<></>` will be compiled into
6009          // a fragment which doesn't have a children.
6010          // In this case fallback to an empty array
6011          n2.children || [],
6012          container,
6013          fragmentEndAnchor,
6014          parentComponent,
6015          parentSuspense,
6016          namespace,
6017          slotScopeIds,
6018          optimized
6019        );
6020      } else {
6021        if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && // #2715 the previous fragment could've been a BAILed one as a result
6022        // of renderSlot() with no valid children
6023        n1.dynamicChildren) {
6024          patchBlockChildren(
6025            n1.dynamicChildren,
6026            dynamicChildren,
6027            container,
6028            parentComponent,
6029            parentSuspense,
6030            namespace,
6031            slotScopeIds
6032          );
6033          if (
6034            // #2080 if the stable fragment has a key, it's a <template v-for> that may
6035            //  get moved around. Make sure all root level vnodes inherit el.

vendor: 13,268 bytes, lines 6036-6476

6036            // #2134 or if it's a component root, it may also get moved around
6037            // as the component is being moved.
6038            n2.key != null || parentComponent && n2 === parentComponent.subTree
6039          ) {
6040            traverseStaticChildren(
6041              n1,
6042              n2,
6043              true
6044              /* shallow */
6045            );
6046          }
6047        } else {
6048          patchChildren(
6049            n1,
6050            n2,
6051            container,
6052            fragmentEndAnchor,
6053            parentComponent,
6054            parentSuspense,
6055            namespace,
6056            slotScopeIds,
6057            optimized
6058          );
6059        }
6060      }
6061    };
6062    const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
6063      n2.slotScopeIds = slotScopeIds;
6064      if (n1 == null) {
6065        if (n2.shapeFlag & 512) {
6066          parentComponent.ctx.activate(
6067            n2,
6068            container,
6069            anchor,
6070            namespace,
6071            optimized
6072          );
6073        } else {
6074          mountComponent(
6075            n2,
6076            container,
6077            anchor,
6078            parentComponent,
6079            parentSuspense,
6080            namespace,
6081            optimized
6082          );
6083        }
6084      } else {
6085        updateComponent(n1, n2, optimized);
6086      }
6087    };
6088    const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, namespace, optimized) => {
6089      const instance = initialVNode.component = createComponentInstance$1(
6090        initialVNode,
6091        parentComponent,
6092        parentSuspense
6093      );
6094      if (isKeepAlive(initialVNode)) {
6095        instance.ctx.renderer = internals;
6096      }
6097      {
6098        setupComponent$1(instance, false, optimized);
6099      }
6100      if (instance.asyncDep) {
6101        parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect, optimized);
6102        if (!initialVNode.el) {
6103          const placeholder = instance.subTree = createVNode(Comment);
6104          processCommentNode(null, placeholder, container, anchor);
6105        }
6106      } else {
6107        setupRenderEffect(
6108          instance,
6109          initialVNode,
6110          container,
6111          anchor,
6112          parentSuspense,
6113          namespace,
6114          optimized
6115        );
6116      }
6117    };
6118    const updateComponent = (n1, n2, optimized) => {
6119      const instance = n2.component = n1.component;
6120      if (shouldUpdateComponent(n1, n2, optimized)) {
6121        if (instance.asyncDep && !instance.asyncResolved) {
6122          updateComponentPreRender(instance, n2, optimized);
6123          return;
6124        } else {
6125          instance.next = n2;
6126          instance.update();
6127        }
6128      } else {
6129        n2.el = n1.el;
6130        instance.vnode = n2;
6131      }
6132    };
6133    const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, namespace, optimized) => {
6134      const componentUpdateFn = () => {
6135        if (!instance.isMounted) {
6136          let vnodeHook;
6137          const { el, props } = initialVNode;
6138          const { bm, m, parent, root, type } = instance;
6139          const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);
6140          toggleRecurse(instance, false);
6141          if (bm) {
6142            invokeArrayFns(bm);
6143          }
6144          if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) {
6145            invokeVNodeHook(vnodeHook, parent, initialVNode);
6146          }
6147          toggleRecurse(instance, true);
6148          if (el && hydrateNode) {
6149            const hydrateSubTree = () => {
6150              instance.subTree = renderComponentRoot$1(instance);
6151              hydrateNode(
6152                el,
6153                instance.subTree,
6154                instance,
6155                parentSuspense,
6156                null
6157              );
6158            };
6159            if (isAsyncWrapperVNode && type.__asyncHydrate) {
6160              type.__asyncHydrate(
6161                el,
6162                instance,
6163                hydrateSubTree
6164              );
6165            } else {
6166              hydrateSubTree();
6167            }
6168          } else {
6169            if (root.ce) {
6170              root.ce._injectChildStyle(type);
6171            }
6172            const subTree = instance.subTree = renderComponentRoot$1(instance);
6173            patch(
6174              null,
6175              subTree,
6176              container,
6177              anchor,
6178              instance,
6179              parentSuspense,
6180              namespace
6181            );
6182            initialVNode.el = subTree.el;
6183          }
6184          if (m) {
6185            queuePostRenderEffect(m, parentSuspense);
6186          }
6187          if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
6188            const scopedInitialVNode = initialVNode;
6189            queuePostRenderEffect(
6190              () => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode),
6191              parentSuspense
6192            );
6193          }
6194          if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {
6195            instance.a && queuePostRenderEffect(instance.a, parentSuspense);
6196          }
6197          instance.isMounted = true;
6198          initialVNode = container = anchor = null;
6199        } else {
6200          let { next, bu, u, parent, vnode } = instance;
6201          {
6202            const nonHydratedAsyncRoot = locateNonHydratedAsyncRoot(instance);
6203            if (nonHydratedAsyncRoot) {
6204              if (next) {
6205                next.el = vnode.el;
6206                updateComponentPreRender(instance, next, optimized);
6207              }
6208              nonHydratedAsyncRoot.asyncDep.then(() => {
6209                if (!instance.isUnmounted) {
6210                  componentUpdateFn();
6211                }
6212              });
6213              return;
6214            }
6215          }
6216          let originNext = next;
6217          let vnodeHook;
6218          toggleRecurse(instance, false);
6219          if (next) {
6220            next.el = vnode.el;
6221            updateComponentPreRender(instance, next, optimized);
6222          } else {
6223            next = vnode;
6224          }
6225          if (bu) {
6226            invokeArrayFns(bu);
6227          }
6228          if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) {
6229            invokeVNodeHook(vnodeHook, parent, next, vnode);
6230          }
6231          toggleRecurse(instance, true);
6232          const nextTree = renderComponentRoot$1(instance);
6233          const prevTree = instance.subTree;
6234          instance.subTree = nextTree;
6235          patch(
6236            prevTree,
6237            nextTree,
6238            // parent may have changed if it's in a teleport
6239            hostParentNode(prevTree.el),
6240            // anchor may have changed if it's in a fragment
6241            getNextHostNode(prevTree),
6242            instance,
6243            parentSuspense,
6244            namespace
6245          );
6246          next.el = nextTree.el;
6247          if (originNext === null) {
6248            updateHOCHostEl(instance, nextTree.el);
6249          }
6250          if (u) {
6251            queuePostRenderEffect(u, parentSuspense);
6252          }
6253          if (vnodeHook = next.props && next.props.onVnodeUpdated) {
6254            queuePostRenderEffect(
6255              () => invokeVNodeHook(vnodeHook, parent, next, vnode),
6256              parentSuspense
6257            );
6258          }
6259        }
6260      };
6261      instance.scope.on();
6262      const effect2 = instance.effect = new ReactiveEffect(componentUpdateFn);
6263      instance.scope.off();
6264      const update = instance.update = effect2.run.bind(effect2);
6265      const job = instance.job = effect2.runIfDirty.bind(effect2);
6266      job.i = instance;
6267      job.id = instance.uid;
6268      effect2.scheduler = () => queueJob(job);
6269      toggleRecurse(instance, true);
6270      update();
6271    };
6272    const updateComponentPreRender = (instance, nextVNode, optimized) => {
6273      nextVNode.component = instance;
6274      const prevProps = instance.vnode.props;
6275      instance.vnode = nextVNode;
6276      instance.next = null;
6277      updateProps(instance, nextVNode.props, prevProps, optimized);
6278      updateSlots(instance, nextVNode.children, optimized);
6279      pauseTracking();
6280      flushPreFlushCbs(instance);
6281      resetTracking();
6282    };
6283    const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized = false) => {
6284      const c1 = n1 && n1.children;
6285      const prevShapeFlag = n1 ? n1.shapeFlag : 0;
6286      const c2 = n2.children;
6287      const { patchFlag, shapeFlag } = n2;
6288      if (patchFlag > 0) {
6289        if (patchFlag & 128) {
6290          patchKeyedChildren(
6291            c1,
6292            c2,
6293            container,
6294            anchor,
6295            parentComponent,
6296            parentSuspense,
6297            namespace,
6298            slotScopeIds,
6299            optimized
6300          );
6301          return;
6302        } else if (patchFlag & 256) {
6303          patchUnkeyedChildren(
6304            c1,
6305            c2,
6306            container,
6307            anchor,
6308            parentComponent,
6309            parentSuspense,
6310            namespace,
6311            slotScopeIds,
6312            optimized
6313          );
6314          return;
6315        }
6316      }
6317      if (shapeFlag & 8) {
6318        if (prevShapeFlag & 16) {
6319          unmountChildren(c1, parentComponent, parentSuspense);
6320        }
6321        if (c2 !== c1) {
6322          hostSetElementText(container, c2);
6323        }
6324      } else {
6325        if (prevShapeFlag & 16) {
6326          if (shapeFlag & 16) {
6327            patchKeyedChildren(
6328              c1,
6329              c2,
6330              container,
6331              anchor,
6332              parentComponent,
6333              parentSuspense,
6334              namespace,
6335              slotScopeIds,
6336              optimized
6337            );
6338          } else {
6339            unmountChildren(c1, parentComponent, parentSuspense, true);
6340          }
6341        } else {
6342          if (prevShapeFlag & 8) {
6343            hostSetElementText(container, "");
6344          }
6345          if (shapeFlag & 16) {
6346            mountChildren(
6347              c2,
6348              container,
6349              anchor,
6350              parentComponent,
6351              parentSuspense,
6352              namespace,
6353              slotScopeIds,
6354              optimized
6355            );
6356          }
6357        }
6358      }
6359    };
6360    const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
6361      c1 = c1 || EMPTY_ARR;
6362      c2 = c2 || EMPTY_ARR;
6363      const oldLength = c1.length;
6364      const newLength = c2.length;
6365      const commonLength = Math.min(oldLength, newLength);
6366      let i;
6367      for (i = 0; i < commonLength; i++) {
6368        const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode$1(c2[i]);
6369        patch(
6370          c1[i],
6371          nextChild,
6372          container,
6373          null,
6374          parentComponent,
6375          parentSuspense,
6376          namespace,
6377          slotScopeIds,
6378          optimized
6379        );
6380      }
6381      if (oldLength > newLength) {
6382        unmountChildren(
6383          c1,
6384          parentComponent,
6385          parentSuspense,
6386          true,
6387          false,
6388          commonLength
6389        );
6390      } else {
6391        mountChildren(
6392          c2,
6393          container,
6394          anchor,
6395          parentComponent,
6396          parentSuspense,
6397          namespace,
6398          slotScopeIds,
6399          optimized,
6400          commonLength
6401        );
6402      }
6403    };
6404    const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
6405      let i = 0;
6406      const l2 = c2.length;
6407      let e1 = c1.length - 1;
6408      let e2 = l2 - 1;
6409      while (i <= e1 && i <= e2) {
6410        const n1 = c1[i];
6411        const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode$1(c2[i]);
6412        if (isSameVNodeType(n1, n2)) {
6413          patch(
6414            n1,
6415            n2,
6416            container,
6417            null,
6418            parentComponent,
6419            parentSuspense,
6420            namespace,
6421            slotScopeIds,
6422            optimized
6423          );
6424        } else {
6425          break;
6426        }
6427        i++;
6428      }
6429      while (i <= e1 && i <= e2) {
6430        const n1 = c1[e1];
6431        const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode$1(c2[e2]);
6432        if (isSameVNodeType(n1, n2)) {
6433          patch(
6434            n1,
6435            n2,
6436            container,
6437            null,
6438            parentComponent,
6439            parentSuspense,
6440            namespace,
6441            slotScopeIds,
6442            optimized
6443          );
6444        } else {
6445          break;
6446        }
6447        e1--;
6448        e2--;
6449      }
6450      if (i > e1) {
6451        if (i <= e2) {
6452          const nextPos = e2 + 1;
6453          const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
6454          while (i <= e2) {
6455            patch(
6456              null,
6457              c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode$1(c2[i]),
6458              container,
6459              anchor,
6460              parentComponent,
6461              parentSuspense,
6462              namespace,
6463              slotScopeIds,
6464              optimized
6465            );
6466            i++;
6467          }
6468        }
6469      } else if (i > e2) {
6470        while (i <= e1) {
6471          unmount(c1[i], parentComponent, parentSuspense, true);
6472          i++;
6473        }
6474      } else {
6475        const s1 = i;
6476        const s2 = i;

vendor: 4,794 bytes, lines 6477-6624

6477        const keyToNewIndexMap = /* @__PURE__ */ new Map();
6478        for (i = s2; i <= e2; i++) {
6479          const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode$1(c2[i]);
6480          if (nextChild.key != null) {
6481            keyToNewIndexMap.set(nextChild.key, i);
6482          }
6483        }
6484        let j;
6485        let patched = 0;
6486        const toBePatched = e2 - s2 + 1;
6487        let moved = false;
6488        let maxNewIndexSoFar = 0;
6489        const newIndexToOldIndexMap = new Array(toBePatched);
6490        for (i = 0; i < toBePatched; i++)
6491          newIndexToOldIndexMap[i] = 0;
6492        for (i = s1; i <= e1; i++) {
6493          const prevChild = c1[i];
6494          if (patched >= toBePatched) {
6495            unmount(prevChild, parentComponent, parentSuspense, true);
6496            continue;
6497          }
6498          let newIndex;
6499          if (prevChild.key != null) {
6500            newIndex = keyToNewIndexMap.get(prevChild.key);
6501          } else {
6502            for (j = s2; j <= e2; j++) {
6503              if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {
6504                newIndex = j;
6505                break;
6506              }
6507            }
6508          }
6509          if (newIndex === void 0) {
6510            unmount(prevChild, parentComponent, parentSuspense, true);
6511          } else {
6512            newIndexToOldIndexMap[newIndex - s2] = i + 1;
6513            if (newIndex >= maxNewIndexSoFar) {
6514              maxNewIndexSoFar = newIndex;
6515            } else {
6516              moved = true;
6517            }
6518            patch(
6519              prevChild,
6520              c2[newIndex],
6521              container,
6522              null,
6523              parentComponent,
6524              parentSuspense,
6525              namespace,
6526              slotScopeIds,
6527              optimized
6528            );
6529            patched++;
6530          }
6531        }
6532        const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : EMPTY_ARR;
6533        j = increasingNewIndexSequence.length - 1;
6534        for (i = toBePatched - 1; i >= 0; i--) {
6535          const nextIndex = s2 + i;
6536          const nextChild = c2[nextIndex];
6537          const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;
6538          if (newIndexToOldIndexMap[i] === 0) {
6539            patch(
6540              null,
6541              nextChild,
6542              container,
6543              anchor,
6544              parentComponent,
6545              parentSuspense,
6546              namespace,
6547              slotScopeIds,
6548              optimized
6549            );
6550          } else if (moved) {
6551            if (j < 0 || i !== increasingNewIndexSequence[j]) {
6552              move(nextChild, container, anchor, 2);
6553            } else {
6554              j--;
6555            }
6556          }
6557        }
6558      }
6559    };
6560    const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
6561      const { el, type, transition, children, shapeFlag } = vnode;
6562      if (shapeFlag & 6) {
6563        move(vnode.component.subTree, container, anchor, moveType);
6564        return;
6565      }
6566      if (shapeFlag & 128) {
6567        vnode.suspense.move(container, anchor, moveType);
6568        return;
6569      }
6570      if (shapeFlag & 64) {
6571        type.move(vnode, container, anchor, internals);
6572        return;
6573      }
6574      if (type === Fragment) {
6575        hostInsert(el, container, anchor);
6576        for (let i = 0; i < children.length; i++) {
6577          move(children[i], container, anchor, moveType);
6578        }
6579        hostInsert(vnode.anchor, container, anchor);
6580        return;
6581      }
6582      if (type === Static) {
6583        moveStaticNode(vnode, container, anchor);
6584        return;
6585      }
6586      const needTransition2 = moveType !== 2 && shapeFlag & 1 && transition;
6587      if (needTransition2) {
6588        if (moveType === 0) {
6589          transition.beforeEnter(el);
6590          hostInsert(el, container, anchor);
6591          queuePostRenderEffect(() => transition.enter(el), parentSuspense);
6592        } else {
6593          const { leave, delayLeave, afterLeave } = transition;
6594          const remove22 = () => hostInsert(el, container, anchor);
6595          const performLeave = () => {
6596            leave(el, () => {
6597              remove22();
6598              afterLeave && afterLeave();
6599            });
6600          };
6601          if (delayLeave) {
6602            delayLeave(el, remove22, performLeave);
6603          } else {
6604            performLeave();
6605          }
6606        }
6607      } else {
6608        hostInsert(el, container, anchor);
6609      }
6610    };
6611    const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {
6612      const {
6613        type,
6614        props,
6615        ref: ref2,
6616        children,
6617        dynamicChildren,
6618        shapeFlag,
6619        patchFlag,
6620        dirs,
6621        cacheIndex
6622      } = vnode;
6623      if (patchFlag === -2) {
6624        optimized = false;

vendor: 5,009 bytes, lines 6625-6768

6625      }
6626      if (ref2 != null) {
6627        setRef(ref2, null, parentSuspense, vnode, true);
6628      }
6629      if (cacheIndex != null) {
6630        parentComponent.renderCache[cacheIndex] = void 0;
6631      }
6632      if (shapeFlag & 256) {
6633        parentComponent.ctx.deactivate(vnode);
6634        return;
6635      }
6636      const shouldInvokeDirs = shapeFlag & 1 && dirs;
6637      const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);
6638      let vnodeHook;
6639      if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) {
6640        invokeVNodeHook(vnodeHook, parentComponent, vnode);
6641      }
6642      if (shapeFlag & 6) {
6643        unmountComponent(vnode.component, parentSuspense, doRemove);
6644      } else {
6645        if (shapeFlag & 128) {
6646          vnode.suspense.unmount(parentSuspense, doRemove);
6647          return;
6648        }
6649        if (shouldInvokeDirs) {
6650          invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount");
6651        }
6652        if (shapeFlag & 64) {
6653          vnode.type.remove(
6654            vnode,
6655            parentComponent,
6656            parentSuspense,
6657            internals,
6658            doRemove
6659          );
6660        } else if (dynamicChildren && // #5154
6661        // when v-once is used inside a block, setBlockTracking(-1) marks the
6662        // parent block with hasOnce: true
6663        // so that it doesn't take the fast path during unmount - otherwise
6664        // components nested in v-once are never unmounted.
6665        !dynamicChildren.hasOnce && // #1153: fast path should not be taken for non-stable (v-for) fragments
6666        (type !== Fragment || patchFlag > 0 && patchFlag & 64)) {
6667          unmountChildren(
6668            dynamicChildren,
6669            parentComponent,
6670            parentSuspense,
6671            false,
6672            true
6673          );
6674        } else if (type === Fragment && patchFlag & (128 | 256) || !optimized && shapeFlag & 16) {
6675          unmountChildren(children, parentComponent, parentSuspense);
6676        }
6677        if (doRemove) {
6678          remove2(vnode);
6679        }
6680      }
6681      if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
6682        queuePostRenderEffect(() => {
6683          vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
6684          shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
6685        }, parentSuspense);
6686      }
6687    };
6688    const remove2 = (vnode) => {
6689      const { type, el, anchor, transition } = vnode;
6690      if (type === Fragment) {
6691        {
6692          removeFragment(el, anchor);
6693        }
6694        return;
6695      }
6696      if (type === Static) {
6697        removeStaticNode(vnode);
6698        return;
6699      }
6700      const performRemove = () => {
6701        hostRemove(el);
6702        if (transition && !transition.persisted && transition.afterLeave) {
6703          transition.afterLeave();
6704        }
6705      };
6706      if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
6707        const { leave, delayLeave } = transition;
6708        const performLeave = () => leave(el, performRemove);
6709        if (delayLeave) {
6710          delayLeave(vnode.el, performRemove, performLeave);
6711        } else {
6712          performLeave();
6713        }
6714      } else {
6715        performRemove();
6716      }
6717    };
6718    const removeFragment = (cur, end) => {
6719      let next;
6720      while (cur !== end) {
6721        next = hostNextSibling(cur);
6722        hostRemove(cur);
6723        cur = next;
6724      }
6725      hostRemove(end);
6726    };
6727    const unmountComponent = (instance, parentSuspense, doRemove) => {
6728      const { bum, scope, job, subTree, um, m, a } = instance;
6729      invalidateMount(m);
6730      invalidateMount(a);
6731      if (bum) {
6732        invokeArrayFns(bum);
6733      }
6734      scope.stop();
6735      if (job) {
6736        job.flags |= 8;
6737        unmount(subTree, instance, parentSuspense, doRemove);
6738      }
6739      if (um) {
6740        queuePostRenderEffect(um, parentSuspense);
6741      }
6742      queuePostRenderEffect(() => {
6743        instance.isUnmounted = true;
6744      }, parentSuspense);
6745      if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) {
6746        parentSuspense.deps--;
6747        if (parentSuspense.deps === 0) {
6748          parentSuspense.resolve();
6749        }
6750      }
6751    };
6752    const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
6753      for (let i = start; i < children.length; i++) {
6754        unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);
6755      }
6756    };
6757    const getNextHostNode = (vnode) => {
6758      if (vnode.shapeFlag & 6) {
6759        return getNextHostNode(vnode.component.subTree);
6760      }
6761      if (vnode.shapeFlag & 128) {
6762        return vnode.suspense.next();
6763      }
6764      const el = hostNextSibling(vnode.anchor || vnode.el);
6765      const teleportEnd = el && el[TeleportEndKey];
6766      return teleportEnd ? hostNextSibling(teleportEnd) : el;
6767    };
6768    let isFlushing = false;

vendor: 20,242 bytes, lines 6769-7476

6769    const render2 = (vnode, container, namespace) => {
6770      if (vnode == null) {
6771        if (container._vnode) {
6772          unmount(container._vnode, null, null, true);
6773        }
6774      } else {
6775        patch(
6776          container._vnode || null,
6777          vnode,
6778          container,
6779          null,
6780          null,
6781          null,
6782          namespace
6783        );
6784      }
6785      container._vnode = vnode;
6786      if (!isFlushing) {
6787        isFlushing = true;
6788        flushPreFlushCbs();
6789        flushPostFlushCbs();
6790        isFlushing = false;
6791      }
6792    };
6793    const internals = {
6794      p: patch,
6795      um: unmount,
6796      m: move,
6797      r: remove2,
6798      mt: mountComponent,
6799      mc: mountChildren,
6800      pc: patchChildren,
6801      pbc: patchBlockChildren,
6802      n: getNextHostNode,
6803      o: options
6804    };
6805    let hydrate2;
6806    let hydrateNode;
6807    if (createHydrationFns) {
6808      [hydrate2, hydrateNode] = createHydrationFns(
6809        internals
6810      );
6811    }
6812    return {
6813      render: render2,
6814      hydrate: hydrate2,
6815      createApp: createAppAPI(render2, hydrate2)
6816    };
6817  }
6818  function resolveChildrenNamespace({ type, props }, currentNamespace) {
6819    return currentNamespace === "svg" && type === "foreignObject" || currentNamespace === "mathml" && type === "annotation-xml" && props && props.encoding && props.encoding.includes("html") ? void 0 : currentNamespace;
6820  }
6821  function toggleRecurse({ effect: effect2, job }, allowed) {
6822    if (allowed) {
6823      effect2.flags |= 32;
6824      job.flags |= 4;
6825    } else {
6826      effect2.flags &= ~32;
6827      job.flags &= ~4;
6828    }
6829  }
6830  function needTransition(parentSuspense, transition) {
6831    return (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
6832  }
6833  function traverseStaticChildren(n1, n2, shallow = false) {
6834    const ch1 = n1.children;
6835    const ch2 = n2.children;
6836    if (isArray(ch1) && isArray(ch2)) {
6837      for (let i = 0; i < ch1.length; i++) {
6838        const c1 = ch1[i];
6839        let c2 = ch2[i];
6840        if (c2.shapeFlag & 1 && !c2.dynamicChildren) {
6841          if (c2.patchFlag <= 0 || c2.patchFlag === 32) {
6842            c2 = ch2[i] = cloneIfMounted(ch2[i]);
6843            c2.el = c1.el;
6844          }
6845          if (!shallow && c2.patchFlag !== -2)
6846            traverseStaticChildren(c1, c2);
6847        }
6848        if (c2.type === Text) {
6849          c2.el = c1.el;
6850        }
6851      }
6852    }
6853  }
6854  function getSequence(arr) {
6855    const p2 = arr.slice();
6856    const result = [0];
6857    let i, j, u, v, c;
6858    const len = arr.length;
6859    for (i = 0; i < len; i++) {
6860      const arrI = arr[i];
6861      if (arrI !== 0) {
6862        j = result[result.length - 1];
6863        if (arr[j] < arrI) {
6864          p2[i] = j;
6865          result.push(i);
6866          continue;
6867        }
6868        u = 0;
6869        v = result.length - 1;
6870        while (u < v) {
6871          c = u + v >> 1;
6872          if (arr[result[c]] < arrI) {
6873            u = c + 1;
6874          } else {
6875            v = c;
6876          }
6877        }
6878        if (arrI < arr[result[u]]) {
6879          if (u > 0) {
6880            p2[i] = result[u - 1];
6881          }
6882          result[u] = i;
6883        }
6884      }
6885    }
6886    u = result.length;
6887    v = result[u - 1];
6888    while (u-- > 0) {
6889      result[u] = v;
6890      v = p2[v];
6891    }
6892    return result;
6893  }
6894  function locateNonHydratedAsyncRoot(instance) {
6895    const subComponent = instance.subTree.component;
6896    if (subComponent) {
6897      if (subComponent.asyncDep && !subComponent.asyncResolved) {
6898        return subComponent;
6899      } else {
6900        return locateNonHydratedAsyncRoot(subComponent);
6901      }
6902    }
6903  }
6904  function invalidateMount(hooks) {
6905    if (hooks) {
6906      for (let i = 0; i < hooks.length; i++)
6907        hooks[i].flags |= 8;
6908    }
6909  }
6910  const ssrContextKey = Symbol.for("v-scx");
6911  const useSSRContext = () => {
6912    {
6913      const ctx = inject(ssrContextKey);
6914      return ctx;
6915    }
6916  };
6917  function watchEffect(effect2, options) {
6918    return doWatch(effect2, null, options);
6919  }
6920  function watchPostEffect(effect2, options) {
6921    return doWatch(
6922      effect2,
6923      null,
6924      { flush: "post" }
6925    );
6926  }
6927  function watchSyncEffect(effect2, options) {
6928    return doWatch(
6929      effect2,
6930      null,
6931      { flush: "sync" }
6932    );
6933  }
6934  function watch(source, cb, options) {
6935    return doWatch(source, cb, options);
6936  }
6937  function doWatch(source, cb, options = EMPTY_OBJ) {
6938    const { immediate, deep, flush, once } = options;
6939    const baseWatchOptions = extend({}, options);
6940    const runsImmediately = cb && immediate || !cb && flush !== "post";
6941    let ssrCleanup;
6942    if (isInSSRComponentSetup) {
6943      if (flush === "sync") {
6944        const ctx = useSSRContext();
6945        ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
6946      } else if (!runsImmediately) {
6947        const watchStopHandle = () => {
6948        };
6949        watchStopHandle.stop = NOOP;
6950        watchStopHandle.resume = NOOP;
6951        watchStopHandle.pause = NOOP;
6952        return watchStopHandle;
6953      }
6954    }
6955    const instance = currentInstance;
6956    baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
6957    let isPre = false;
6958    if (flush === "post") {
6959      baseWatchOptions.scheduler = (job) => {
6960        queuePostRenderEffect(job, instance && instance.suspense);
6961      };
6962    } else if (flush !== "sync") {
6963      isPre = true;
6964      baseWatchOptions.scheduler = (job, isFirstRun) => {
6965        if (isFirstRun) {
6966          job();
6967        } else {
6968          queueJob(job);
6969        }
6970      };
6971    }
6972    baseWatchOptions.augmentJob = (job) => {
6973      if (cb) {
6974        job.flags |= 4;
6975      }
6976      if (isPre) {
6977        job.flags |= 2;
6978        if (instance) {
6979          job.id = instance.uid;
6980          job.i = instance;
6981        }
6982      }
6983    };
6984    const watchHandle = watch$1(source, cb, baseWatchOptions);
6985    if (isInSSRComponentSetup) {
6986      if (ssrCleanup) {
6987        ssrCleanup.push(watchHandle);
6988      } else if (runsImmediately) {
6989        watchHandle();
6990      }
6991    }
6992    return watchHandle;
6993  }
6994  function instanceWatch(source, value, options) {
6995    const publicThis = this.proxy;
6996    const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
6997    let cb;
6998    if (isFunction(value)) {
6999      cb = value;
7000    } else {
7001      cb = value.handler;
7002      options = value;
7003    }
7004    const reset = setCurrentInstance(this);
7005    const res = doWatch(getter, cb.bind(publicThis), options);
7006    reset();
7007    return res;
7008  }
7009  function createPathGetter(ctx, path) {
7010    const segments = path.split(".");
7011    return () => {
7012      let cur = ctx;
7013      for (let i = 0; i < segments.length && cur; i++) {
7014        cur = cur[segments[i]];
7015      }
7016      return cur;
7017    };
7018  }
7019  function useModel(props, name, options = EMPTY_OBJ) {
7020    const i = getCurrentInstance();
7021    const camelizedName = camelize(name);
7022    const hyphenatedName = hyphenate(name);
7023    const modifiers = getModelModifiers(props, camelizedName);
7024    const res = customRef((track2, trigger2) => {
7025      let localValue;
7026      let prevSetValue = EMPTY_OBJ;
7027      let prevEmittedValue;
7028      watchSyncEffect(() => {
7029        const propValue = props[camelizedName];
7030        if (hasChanged(localValue, propValue)) {
7031          localValue = propValue;
7032          trigger2();
7033        }
7034      });
7035      return {
7036        get() {
7037          track2();
7038          return options.get ? options.get(localValue) : localValue;
7039        },
7040        set(value) {
7041          const emittedValue = options.set ? options.set(value) : value;
7042          if (!hasChanged(emittedValue, localValue) && !(prevSetValue !== EMPTY_OBJ && hasChanged(value, prevSetValue))) {
7043            return;
7044          }
7045          const rawProps = i.vnode.props;
7046          if (!(rawProps && // check if parent has passed v-model
7047          (name in rawProps || camelizedName in rawProps || hyphenatedName in rawProps) && (`onUpdate:${name}` in rawProps || `onUpdate:${camelizedName}` in rawProps || `onUpdate:${hyphenatedName}` in rawProps))) {
7048            localValue = value;
7049            trigger2();
7050          }
7051          i.emit(`update:${name}`, emittedValue);
7052          if (hasChanged(value, emittedValue) && hasChanged(value, prevSetValue) && !hasChanged(emittedValue, prevEmittedValue)) {
7053            trigger2();
7054          }
7055          prevSetValue = value;
7056          prevEmittedValue = emittedValue;
7057        }
7058      };
7059    });
7060    res[Symbol.iterator] = () => {
7061      let i2 = 0;
7062      return {
7063        next() {
7064          if (i2 < 2) {
7065            return { value: i2++ ? modifiers || EMPTY_OBJ : res, done: false };
7066          } else {
7067            return { done: true };
7068          }
7069        }
7070      };
7071    };
7072    return res;
7073  }
7074  const getModelModifiers = (props, modelName) => {
7075    return modelName === "modelValue" || modelName === "model-value" ? props.modelModifiers : props[`${modelName}Modifiers`] || props[`${camelize(modelName)}Modifiers`] || props[`${hyphenate(modelName)}Modifiers`];
7076  };
7077  function emit(instance, event, ...rawArgs) {
7078    if (instance.isUnmounted)
7079      return;
7080    const props = instance.vnode.props || EMPTY_OBJ;
7081    let args = rawArgs;
7082    const isModelListener2 = event.startsWith("update:");
7083    const modifiers = isModelListener2 && getModelModifiers(props, event.slice(7));
7084    if (modifiers) {
7085      if (modifiers.trim) {
7086        args = rawArgs.map((a) => isString(a) ? a.trim() : a);
7087      }
7088      if (modifiers.number) {
7089        args = rawArgs.map(looseToNumber);
7090      }
7091    }
7092    let handlerName;
7093    let handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249)
7094    props[handlerName = toHandlerKey(camelize(event))];
7095    if (!handler && isModelListener2) {
7096      handler = props[handlerName = toHandlerKey(hyphenate(event))];
7097    }
7098    if (handler) {
7099      callWithAsyncErrorHandling(
7100        handler,
7101        instance,
7102        6,
7103        args
7104      );
7105    }
7106    const onceHandler = props[handlerName + `Once`];
7107    if (onceHandler) {
7108      if (!instance.emitted) {
7109        instance.emitted = {};
7110      } else if (instance.emitted[handlerName]) {
7111        return;
7112      }
7113      instance.emitted[handlerName] = true;
7114      callWithAsyncErrorHandling(
7115        onceHandler,
7116        instance,
7117        6,
7118        args
7119      );
7120    }
7121  }
7122  function normalizeEmitsOptions(comp, appContext, asMixin = false) {
7123    const cache = appContext.emitsCache;
7124    const cached = cache.get(comp);
7125    if (cached !== void 0) {
7126      return cached;
7127    }
7128    const raw = comp.emits;
7129    let normalized = {};
7130    let hasExtends = false;
7131    if (!isFunction(comp)) {
7132      const extendEmits = (raw2) => {
7133        const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
7134        if (normalizedFromExtend) {
7135          hasExtends = true;
7136          extend(normalized, normalizedFromExtend);
7137        }
7138      };
7139      if (!asMixin && appContext.mixins.length) {
7140        appContext.mixins.forEach(extendEmits);
7141      }
7142      if (comp.extends) {
7143        extendEmits(comp.extends);
7144      }
7145      if (comp.mixins) {
7146        comp.mixins.forEach(extendEmits);
7147      }
7148    }
7149    if (!raw && !hasExtends) {
7150      if (isObject(comp)) {
7151        cache.set(comp, null);
7152      }
7153      return null;
7154    }
7155    if (isArray(raw)) {
7156      raw.forEach((key) => normalized[key] = null);
7157    } else {
7158      extend(normalized, raw);
7159    }
7160    if (isObject(comp)) {
7161      cache.set(comp, normalized);
7162    }
7163    return normalized;
7164  }
7165  function isEmitListener(options, key) {
7166    if (!options || !isOn(key)) {
7167      return false;
7168    }
7169    key = key.slice(2).replace(/Once$/, "");
7170    return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
7171  }
7172  function markAttrsAccessed() {
7173  }
7174  function renderComponentRoot$1(instance) {
7175    const {
7176      type: Component,
7177      vnode,
7178      proxy,
7179      withProxy,
7180      propsOptions: [propsOptions],
7181      slots,
7182      attrs,
7183      emit: emit2,
7184      render: render2,
7185      renderCache,
7186      props,
7187      data,
7188      setupState,
7189      ctx,
7190      inheritAttrs
7191    } = instance;
7192    const prev = setCurrentRenderingInstance$1(instance);
7193    let result;
7194    let fallthroughAttrs;
7195    try {
7196      if (vnode.shapeFlag & 4) {
7197        const proxyToUse = withProxy || proxy;
7198        const thisProxy = false ? new Proxy(proxyToUse, {
7199          get(target, key, receiver) {
7200            warn$1(
7201              `Property '${String(
7202                key
7203              )}' was accessed via 'this'. Avoid using 'this' in templates.`
7204            );
7205            return Reflect.get(target, key, receiver);
7206          }
7207        }) : proxyToUse;
7208        result = normalizeVNode$1(
7209          render2.call(
7210            thisProxy,
7211            proxyToUse,
7212            renderCache,
7213            false ? shallowReadonly(props) : props,
7214            setupState,
7215            data,
7216            ctx
7217          )
7218        );
7219        fallthroughAttrs = attrs;
7220      } else {
7221        const render22 = Component;
7222        if (false)
7223          ;
7224        result = normalizeVNode$1(
7225          render22.length > 1 ? render22(
7226            false ? shallowReadonly(props) : props,
7227            false ? {
7228              get attrs() {
7229                markAttrsAccessed();
7230                return shallowReadonly(attrs);
7231              },
7232              slots,
7233              emit: emit2
7234            } : { attrs, slots, emit: emit2 }
7235          ) : render22(
7236            false ? shallowReadonly(props) : props,
7237            null
7238          )
7239        );
7240        fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
7241      }
7242    } catch (err) {
7243      blockStack.length = 0;
7244      handleError(err, instance, 1);
7245      result = createVNode(Comment);
7246    }
7247    let root = result;
7248    if (fallthroughAttrs && inheritAttrs !== false) {
7249      const keys = Object.keys(fallthroughAttrs);
7250      const { shapeFlag } = root;
7251      if (keys.length) {
7252        if (shapeFlag & (1 | 6)) {
7253          if (propsOptions && keys.some(isModelListener)) {
7254            fallthroughAttrs = filterModelListeners(
7255              fallthroughAttrs,
7256              propsOptions
7257            );
7258          }
7259          root = cloneVNode(root, fallthroughAttrs, false, true);
7260        }
7261      }
7262    }
7263    if (vnode.dirs) {
7264      root = cloneVNode(root, null, false, true);
7265      root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
7266    }
7267    if (vnode.transition) {
7268      setTransitionHooks(root, vnode.transition);
7269    }
7270    {
7271      result = root;
7272    }
7273    setCurrentRenderingInstance$1(prev);
7274    return result;
7275  }
7276  function filterSingleRoot(children, recurse = true) {
7277    let singleRoot;
7278    for (let i = 0; i < children.length; i++) {
7279      const child = children[i];
7280      if (isVNode(child)) {
7281        if (child.type !== Comment || child.children === "v-if") {
7282          if (singleRoot) {
7283            return;
7284          } else {
7285            singleRoot = child;
7286          }
7287        }
7288      } else {
7289        return;
7290      }
7291    }
7292    return singleRoot;
7293  }
7294  const getFunctionalFallthrough = (attrs) => {
7295    let res;
7296    for (const key in attrs) {
7297      if (key === "class" || key === "style" || isOn(key)) {
7298        (res || (res = {}))[key] = attrs[key];
7299      }
7300    }
7301    return res;
7302  };
7303  const filterModelListeners = (attrs, props) => {
7304    const res = {};
7305    for (const key in attrs) {
7306      if (!isModelListener(key) || !(key.slice(9) in props)) {
7307        res[key] = attrs[key];
7308      }
7309    }
7310    return res;
7311  };
7312  function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
7313    const { props: prevProps, children: prevChildren, component } = prevVNode;
7314    const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
7315    const emits = component.emitsOptions;
7316    if (nextVNode.dirs || nextVNode.transition) {
7317      return true;
7318    }
7319    if (optimized && patchFlag >= 0) {
7320      if (patchFlag & 1024) {
7321        return true;
7322      }
7323      if (patchFlag & 16) {
7324        if (!prevProps) {
7325          return !!nextProps;
7326        }
7327        return hasPropsChanged(prevProps, nextProps, emits);
7328      } else if (patchFlag & 8) {
7329        const dynamicProps = nextVNode.dynamicProps;
7330        for (let i = 0; i < dynamicProps.length; i++) {
7331          const key = dynamicProps[i];
7332          if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
7333            return true;
7334          }
7335        }
7336      }
7337    } else {
7338      if (prevChildren || nextChildren) {
7339        if (!nextChildren || !nextChildren.$stable) {
7340          return true;
7341        }
7342      }
7343      if (prevProps === nextProps) {
7344        return false;
7345      }
7346      if (!prevProps) {
7347        return !!nextProps;
7348      }
7349      if (!nextProps) {
7350        return true;
7351      }
7352      return hasPropsChanged(prevProps, nextProps, emits);
7353    }
7354    return false;
7355  }
7356  function hasPropsChanged(prevProps, nextProps, emitsOptions) {
7357    const nextKeys = Object.keys(nextProps);
7358    if (nextKeys.length !== Object.keys(prevProps).length) {
7359      return true;
7360    }
7361    for (let i = 0; i < nextKeys.length; i++) {
7362      const key = nextKeys[i];
7363      if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
7364        return true;
7365      }
7366    }
7367    return false;
7368  }
7369  function updateHOCHostEl({ vnode, parent }, el) {
7370    while (parent) {
7371      const root = parent.subTree;
7372      if (root.suspense && root.suspense.activeBranch === vnode) {
7373        root.el = vnode.el;
7374      }
7375      if (root === vnode) {
7376        (vnode = parent.vnode).el = el;
7377        parent = parent.parent;
7378      } else {
7379        break;
7380      }
7381    }
7382  }
7383  const isSuspense = (type) => type.__isSuspense;
7384  let suspenseId = 0;
7385  const SuspenseImpl = {
7386    name: "Suspense",
7387    // In order to make Suspense tree-shakable, we need to avoid importing it
7388    // directly in the renderer. The renderer checks for the __isSuspense flag
7389    // on a vnode's type and calls the `process` method, passing in renderer
7390    // internals.
7391    __isSuspense: true,
7392    process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
7393      if (n1 == null) {
7394        mountSuspense(
7395          n2,
7396          container,
7397          anchor,
7398          parentComponent,
7399          parentSuspense,
7400          namespace,
7401          slotScopeIds,
7402          optimized,
7403          rendererInternals
7404        );
7405      } else {
7406        if (parentSuspense && parentSuspense.deps > 0 && !n1.suspense.isInFallback) {
7407          n2.suspense = n1.suspense;
7408          n2.suspense.vnode = n2;
7409          n2.el = n1.el;
7410          return;
7411        }
7412        patchSuspense(
7413          n1,
7414          n2,
7415          container,
7416          anchor,
7417          parentComponent,
7418          namespace,
7419          slotScopeIds,
7420          optimized,
7421          rendererInternals
7422        );
7423      }
7424    },
7425    hydrate: hydrateSuspense,
7426    normalize: normalizeSuspenseChildren
7427  };
7428  const Suspense = SuspenseImpl;
7429  function triggerEvent(vnode, name) {
7430    const eventListener = vnode.props && vnode.props[name];
7431    if (isFunction(eventListener)) {
7432      eventListener();
7433    }
7434  }
7435  function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
7436    const {
7437      p: patch,
7438      o: { createElement }
7439    } = rendererInternals;
7440    const hiddenContainer = createElement("div");
7441    const suspense = vnode.suspense = createSuspenseBoundary(
7442      vnode,
7443      parentSuspense,
7444      parentComponent,
7445      container,
7446      hiddenContainer,
7447      anchor,
7448      namespace,
7449      slotScopeIds,
7450      optimized,
7451      rendererInternals
7452    );
7453    patch(
7454      null,
7455      suspense.pendingBranch = vnode.ssContent,
7456      hiddenContainer,
7457      null,
7458      parentComponent,
7459      suspense,
7460      namespace,
7461      slotScopeIds
7462    );
7463    if (suspense.deps > 0) {
7464      triggerEvent(vnode, "onPending");
7465      triggerEvent(vnode, "onFallback");
7466      patch(
7467        null,
7468        vnode.ssFallback,
7469        container,
7470        anchor,
7471        parentComponent,
7472        null,
7473        // fallback tree will not have suspense context
7474        namespace,
7475        slotScopeIds
7476      );

7477      setActiveBranch(suspense, vnode.ssFallback);
7478    } else {
7479      suspense.resolve(false, true);
7480    }
7481  }
7482  function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) {
7483    const suspense = n2.suspense = n1.suspense;
7484    suspense.vnode = n2;
7485    n2.el = n1.el;
7486    const newBranch = n2.ssContent;
7487    const newFallback = n2.ssFallback;
7488    const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
7489    if (pendingBranch) {
7490      suspense.pendingBranch = newBranch;
7491      if (isSameVNodeType(newBranch, pendingBranch)) {
7492        patch(
7493          pendingBranch,
7494          newBranch,
7495          suspense.hiddenContainer,
7496          null,
7497          parentComponent,
7498          suspense,
7499          namespace,
7500          slotScopeIds,
7501          optimized
7502        );
7503        if (suspense.deps <= 0) {
7504          suspense.resolve();
7505        } else if (isInFallback) {
7506          if (!isHydrating) {
7507            patch(
7508              activeBranch,
7509              newFallback,
7510              container,
7511              anchor,
7512              parentComponent,
7513              null,
7514              // fallback tree will not have suspense context
7515              namespace,
7516              slotScopeIds,
7517              optimized
7518            );

vendor: 1,147 bytes, lines 7519-7559

7519            setActiveBranch(suspense, newFallback);
7520          }
7521        }
7522      } else {
7523        suspense.pendingId = suspenseId++;
7524        if (isHydrating) {
7525          suspense.isHydrating = false;
7526          suspense.activeBranch = pendingBranch;
7527        } else {
7528          unmount(pendingBranch, parentComponent, suspense);
7529        }
7530        suspense.deps = 0;
7531        suspense.effects.length = 0;
7532        suspense.hiddenContainer = createElement("div");
7533        if (isInFallback) {
7534          patch(
7535            null,
7536            newBranch,
7537            suspense.hiddenContainer,
7538            null,
7539            parentComponent,
7540            suspense,
7541            namespace,
7542            slotScopeIds,
7543            optimized
7544          );
7545          if (suspense.deps <= 0) {
7546            suspense.resolve();
7547          } else {
7548            patch(
7549              activeBranch,
7550              newFallback,
7551              container,
7552              anchor,
7553              parentComponent,
7554              null,
7555              // fallback tree will not have suspense context
7556              namespace,
7557              slotScopeIds,
7558              optimized
7559            );

7560            setActiveBranch(suspense, newFallback);
7561          }
7562        } else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
7563          patch(
7564            activeBranch,
7565            newBranch,
7566            container,
7567            anchor,
7568            parentComponent,
7569            suspense,
7570            namespace,
7571            slotScopeIds,
7572            optimized
7573          );
7574          suspense.resolve(true);
7575        } else {
7576          patch(
7577            null,
7578            newBranch,
7579            suspense.hiddenContainer,
7580            null,
7581            parentComponent,
7582            suspense,
7583            namespace,
7584            slotScopeIds,
7585            optimized
7586          );
7587          if (suspense.deps <= 0) {
7588            suspense.resolve();
7589          }
7590        }
7591      }
7592    } else {
7593      if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
7594        patch(
7595          activeBranch,
7596          newBranch,
7597          container,
7598          anchor,
7599          parentComponent,
7600          suspense,
7601          namespace,
7602          slotScopeIds,
7603          optimized
7604        );
7605        setActiveBranch(suspense, newBranch);
7606      } else {
7607        triggerEvent(n2, "onPending");
7608        suspense.pendingBranch = newBranch;
7609        if (newBranch.shapeFlag & 512) {
7610          suspense.pendingId = newBranch.component.suspenseId;
7611        } else {
7612          suspense.pendingId = suspenseId++;
7613        }
7614        patch(
7615          null,
7616          newBranch,
7617          suspense.hiddenContainer,
7618          null,
7619          parentComponent,
7620          suspense,
7621          namespace,
7622          slotScopeIds,
7623          optimized
7624        );
7625        if (suspense.deps <= 0) {
7626          suspense.resolve();
7627        } else {
7628          const { timeout, pendingId } = suspense;
7629          if (timeout > 0) {
7630            setTimeout(() => {
7631              if (suspense.pendingId === pendingId) {
7632                suspense.fallback(newFallback);
7633              }
7634            }, timeout);
7635          } else if (timeout === 0) {
7636            suspense.fallback(newFallback);
7637          }
7638        }
7639      }
7640    }
7641  }
7642  function createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, namespace, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
7643    const {
7644      p: patch,
7645      m: move,
7646      um: unmount,
7647      n: next,
7648      o: { parentNode, remove: remove2 }
7649    } = rendererInternals;
7650    let parentSuspenseId;
7651    const isSuspensible = isVNodeSuspensible(vnode);
7652    if (isSuspensible) {
7653      if (parentSuspense && parentSuspense.pendingBranch) {
7654        parentSuspenseId = parentSuspense.pendingId;
7655        parentSuspense.deps++;
7656      }
7657    }
7658    const timeout = vnode.props ? toNumber(vnode.props.timeout) : void 0;
7659    const initialAnchor = anchor;
7660    const suspense = {
7661      vnode,
7662      parent: parentSuspense,
7663      parentComponent,
7664      namespace,
7665      container,
7666      hiddenContainer,
7667      deps: 0,
7668      pendingId: suspenseId++,
7669      timeout: typeof timeout === "number" ? timeout : -1,
7670      activeBranch: null,
7671      pendingBranch: null,
7672      isInFallback: !isHydrating,
7673      isHydrating,
7674      isUnmounted: false,
7675      effects: [],
7676      resolve(resume = false, sync = false) {
7677        const {
7678          vnode: vnode2,
7679          activeBranch,
7680          pendingBranch,
7681          pendingId,
7682          effects,
7683          parentComponent: parentComponent2,
7684          container: container2
7685        } = suspense;
7686        let delayEnter = false;
7687        if (suspense.isHydrating) {
7688          suspense.isHydrating = false;
7689        } else if (!resume) {
7690          delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
7691          if (delayEnter) {
7692            activeBranch.transition.afterLeave = () => {
7693              if (pendingId === suspense.pendingId) {
7694                move(
7695                  pendingBranch,
7696                  container2,
7697                  anchor === initialAnchor ? next(activeBranch) : anchor,
7698                  0
7699                );
7700                queuePostFlushCb(effects);
7701              }
7702            };
7703          }
7704          if (activeBranch) {
7705            if (parentNode(activeBranch.el) === container2) {
7706              anchor = next(activeBranch);
7707            }
7708            unmount(activeBranch, parentComponent2, suspense, true);
7709          }
7710          if (!delayEnter) {
7711            move(pendingBranch, container2, anchor, 0);
7712          }
7713        }

7714        setActiveBranch(suspense, pendingBranch);
7715        suspense.pendingBranch = null;
7716        suspense.isInFallback = false;
7717        let parent = suspense.parent;
7718        let hasUnresolvedAncestor = false;
7719        while (parent) {
7720          if (parent.pendingBranch) {
7721            parent.effects.push(...effects);
7722            hasUnresolvedAncestor = true;
7723            break;
7724          }
7725          parent = parent.parent;
7726        }
7727        if (!hasUnresolvedAncestor && !delayEnter) {
7728          queuePostFlushCb(effects);
7729        }
7730        suspense.effects = [];
7731        if (isSuspensible) {
7732          if (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) {
7733            parentSuspense.deps--;
7734            if (parentSuspense.deps === 0 && !sync) {
7735              parentSuspense.resolve();
7736            }
7737          }
7738        }
7739        triggerEvent(vnode2, "onResolve");
7740      },
7741      fallback(fallbackVNode) {
7742        if (!suspense.pendingBranch) {
7743          return;
7744        }
7745        const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, namespace: namespace2 } = suspense;
7746        triggerEvent(vnode2, "onFallback");
7747        const anchor2 = next(activeBranch);
7748        const mountFallback = () => {
7749          if (!suspense.isInFallback) {
7750            return;
7751          }
7752          patch(
7753            null,
7754            fallbackVNode,
7755            container2,
7756            anchor2,
7757            parentComponent2,
7758            null,
7759            // fallback tree will not have suspense context
7760            namespace2,
7761            slotScopeIds,
7762            optimized
7763          );

vendor: 20,335 bytes, lines 7764-8418

7764          setActiveBranch(suspense, fallbackVNode);
7765        };
7766        const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in";
7767        if (delayEnter) {
7768          activeBranch.transition.afterLeave = mountFallback;
7769        }
7770        suspense.isInFallback = true;
7771        unmount(
7772          activeBranch,
7773          parentComponent2,
7774          null,
7775          // no suspense so unmount hooks fire now
7776          true
7777          // shouldRemove
7778        );
7779        if (!delayEnter) {
7780          mountFallback();
7781        }
7782      },
7783      move(container2, anchor2, type) {
7784        suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type);
7785        suspense.container = container2;
7786      },
7787      next() {
7788        return suspense.activeBranch && next(suspense.activeBranch);
7789      },
7790      registerDep(instance, setupRenderEffect, optimized2) {
7791        const isInPendingSuspense = !!suspense.pendingBranch;
7792        if (isInPendingSuspense) {
7793          suspense.deps++;
7794        }
7795        const hydratedEl = instance.vnode.el;
7796        instance.asyncDep.catch((err) => {
7797          handleError(err, instance, 0);
7798        }).then((asyncSetupResult) => {
7799          if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) {
7800            return;
7801          }
7802          instance.asyncResolved = true;
7803          const { vnode: vnode2 } = instance;
7804          handleSetupResult(instance, asyncSetupResult, false);
7805          if (hydratedEl) {
7806            vnode2.el = hydratedEl;
7807          }
7808          const placeholder = !hydratedEl && instance.subTree.el;
7809          setupRenderEffect(
7810            instance,
7811            vnode2,
7812            // component may have been moved before resolve.
7813            // if this is not a hydration, instance.subTree will be the comment
7814            // placeholder.
7815            parentNode(hydratedEl || instance.subTree.el),
7816            // anchor will not be used if this is hydration, so only need to
7817            // consider the comment placeholder case.
7818            hydratedEl ? null : next(instance.subTree),
7819            suspense,
7820            namespace,
7821            optimized2
7822          );
7823          if (placeholder) {
7824            remove2(placeholder);
7825          }
7826          updateHOCHostEl(instance, vnode2.el);
7827          if (isInPendingSuspense && --suspense.deps === 0) {
7828            suspense.resolve();
7829          }
7830        });
7831      },
7832      unmount(parentSuspense2, doRemove) {
7833        suspense.isUnmounted = true;
7834        if (suspense.activeBranch) {
7835          unmount(
7836            suspense.activeBranch,
7837            parentComponent,
7838            parentSuspense2,
7839            doRemove
7840          );
7841        }
7842        if (suspense.pendingBranch) {
7843          unmount(
7844            suspense.pendingBranch,
7845            parentComponent,
7846            parentSuspense2,
7847            doRemove
7848          );
7849        }
7850      }
7851    };
7852    return suspense;
7853  }
7854  function hydrateSuspense(node, vnode, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals, hydrateNode) {
7855    const suspense = vnode.suspense = createSuspenseBoundary(
7856      vnode,
7857      parentSuspense,
7858      parentComponent,
7859      node.parentNode,
7860      // eslint-disable-next-line no-restricted-globals
7861      document.createElement("div"),
7862      null,
7863      namespace,
7864      slotScopeIds,
7865      optimized,
7866      rendererInternals,
7867      true
7868    );
7869    const result = hydrateNode(
7870      node,
7871      suspense.pendingBranch = vnode.ssContent,
7872      parentComponent,
7873      suspense,
7874      slotScopeIds,
7875      optimized
7876    );
7877    if (suspense.deps === 0) {
7878      suspense.resolve(false, true);
7879    }
7880    return result;
7881  }
7882  function normalizeSuspenseChildren(vnode) {
7883    const { shapeFlag, children } = vnode;
7884    const isSlotChildren = shapeFlag & 32;
7885    vnode.ssContent = normalizeSuspenseSlot(
7886      isSlotChildren ? children.default : children
7887    );
7888    vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment);
7889  }
7890  function normalizeSuspenseSlot(s) {
7891    let block;
7892    if (isFunction(s)) {
7893      const trackBlock = isBlockTreeEnabled && s._c;
7894      if (trackBlock) {
7895        s._d = false;
7896        openBlock();
7897      }
7898      s = s();
7899      if (trackBlock) {
7900        s._d = true;
7901        block = currentBlock;
7902        closeBlock();
7903      }
7904    }
7905    if (isArray(s)) {
7906      const singleChild = filterSingleRoot(s);
7907      s = singleChild;
7908    }
7909    s = normalizeVNode$1(s);
7910    if (block && !s.dynamicChildren) {
7911      s.dynamicChildren = block.filter((c) => c !== s);
7912    }
7913    return s;
7914  }
7915  function queueEffectWithSuspense(fn, suspense) {
7916    if (suspense && suspense.pendingBranch) {
7917      if (isArray(fn)) {
7918        suspense.effects.push(...fn);
7919      } else {
7920        suspense.effects.push(fn);
7921      }
7922    } else {
7923      queuePostFlushCb(fn);
7924    }
7925  }
7926  function setActiveBranch(suspense, branch) {
7927    suspense.activeBranch = branch;
7928    const { vnode, parentComponent } = suspense;
7929    let el = branch.el;
7930    while (!el && branch.component) {
7931      branch = branch.component.subTree;
7932      el = branch.el;
7933    }
7934    vnode.el = el;
7935    if (parentComponent && parentComponent.subTree === vnode) {
7936      parentComponent.vnode.el = el;
7937      updateHOCHostEl(parentComponent, el);
7938    }
7939  }
7940  function isVNodeSuspensible(vnode) {
7941    const suspensible = vnode.props && vnode.props.suspensible;
7942    return suspensible != null && suspensible !== false;
7943  }
7944  const Fragment = Symbol.for("v-fgt");
7945  const Text = Symbol.for("v-txt");
7946  const Comment = Symbol.for("v-cmt");
7947  const Static = Symbol.for("v-stc");
7948  const blockStack = [];
7949  let currentBlock = null;
7950  function openBlock(disableTracking = false) {
7951    blockStack.push(currentBlock = disableTracking ? null : []);
7952  }
7953  function closeBlock() {
7954    blockStack.pop();
7955    currentBlock = blockStack[blockStack.length - 1] || null;
7956  }
7957  let isBlockTreeEnabled = 1;
7958  function setBlockTracking(value) {
7959    isBlockTreeEnabled += value;
7960    if (value < 0 && currentBlock) {
7961      currentBlock.hasOnce = true;
7962    }
7963  }
7964  function setupBlock(vnode) {
7965    vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || EMPTY_ARR : null;
7966    closeBlock();
7967    if (isBlockTreeEnabled > 0 && currentBlock) {
7968      currentBlock.push(vnode);
7969    }
7970    return vnode;
7971  }
7972  function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
7973    return setupBlock(
7974      createBaseVNode(
7975        type,
7976        props,
7977        children,
7978        patchFlag,
7979        dynamicProps,
7980        shapeFlag,
7981        true
7982      )
7983    );
7984  }
7985  function createBlock(type, props, children, patchFlag, dynamicProps) {
7986    return setupBlock(
7987      createVNode(
7988        type,
7989        props,
7990        children,
7991        patchFlag,
7992        dynamicProps,
7993        true
7994      )
7995    );
7996  }
7997  function isVNode(value) {
7998    return value ? value.__v_isVNode === true : false;
7999  }
8000  function isSameVNodeType(n1, n2) {
8001    return n1.type === n2.type && n1.key === n2.key;
8002  }
8003  function transformVNodeArgs(transformer) {
8004  }
8005  const normalizeKey = ({ key }) => key != null ? key : null;
8006  const normalizeRef = ({
8007    ref: ref2,
8008    ref_key,
8009    ref_for
8010  }) => {
8011    if (typeof ref2 === "number") {
8012      ref2 = "" + ref2;
8013    }
8014    return ref2 != null ? isString(ref2) || isRef(ref2) || isFunction(ref2) ? { i: currentRenderingInstance, r: ref2, k: ref_key, f: !!ref_for } : ref2 : null;
8015  };
8016  function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
8017    const vnode = {
8018      __v_isVNode: true,
8019      __v_skip: true,
8020      type,
8021      props,
8022      key: props && normalizeKey(props),
8023      ref: props && normalizeRef(props),
8024      scopeId: currentScopeId,
8025      slotScopeIds: null,
8026      children,
8027      component: null,
8028      suspense: null,
8029      ssContent: null,
8030      ssFallback: null,
8031      dirs: null,
8032      transition: null,
8033      el: null,
8034      anchor: null,
8035      target: null,
8036      targetStart: null,
8037      targetAnchor: null,
8038      staticCount: 0,
8039      shapeFlag,
8040      patchFlag,
8041      dynamicProps,
8042      dynamicChildren: null,
8043      appContext: null,
8044      ctx: currentRenderingInstance
8045    };
8046    if (needFullChildrenNormalization) {
8047      normalizeChildren(vnode, children);
8048      if (shapeFlag & 128) {
8049        type.normalize(vnode);
8050      }
8051    } else if (children) {
8052      vnode.shapeFlag |= isString(children) ? 8 : 16;
8053    }
8054    if (isBlockTreeEnabled > 0 && // avoid a block node from tracking itself
8055    !isBlockNode && // has current parent block
8056    currentBlock && // presence of a patch flag indicates this node needs patching on updates.
8057    // component nodes also should always be patched, because even if the
8058    // component doesn't need to update, it needs to persist the instance on to
8059    // the next vnode so that it can be properly unmounted later.
8060    (vnode.patchFlag > 0 || shapeFlag & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the
8061    // vnode should not be considered dynamic due to handler caching.
8062    vnode.patchFlag !== 32) {
8063      currentBlock.push(vnode);
8064    }
8065    return vnode;
8066  }
8067  const createVNode = _createVNode;
8068  function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
8069    if (!type || type === NULL_DYNAMIC_COMPONENT) {
8070      type = Comment;
8071    }
8072    if (isVNode(type)) {
8073      const cloned = cloneVNode(
8074        type,
8075        props,
8076        true
8077        /* mergeRef: true */
8078      );
8079      if (children) {
8080        normalizeChildren(cloned, children);
8081      }
8082      if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
8083        if (cloned.shapeFlag & 6) {
8084          currentBlock[currentBlock.indexOf(type)] = cloned;
8085        } else {
8086          currentBlock.push(cloned);
8087        }
8088      }
8089      cloned.patchFlag = -2;
8090      return cloned;
8091    }
8092    if (isClassComponent(type)) {
8093      type = type.__vccOpts;
8094    }
8095    if (props) {
8096      props = guardReactiveProps(props);
8097      let { class: klass, style } = props;
8098      if (klass && !isString(klass)) {
8099        props.class = normalizeClass(klass);
8100      }
8101      if (isObject(style)) {
8102        if (isProxy(style) && !isArray(style)) {
8103          style = extend({}, style);
8104        }
8105        props.style = normalizeStyle(style);
8106      }
8107    }
8108    const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject(type) ? 4 : isFunction(type) ? 2 : 0;
8109    return createBaseVNode(
8110      type,
8111      props,
8112      children,
8113      patchFlag,
8114      dynamicProps,
8115      shapeFlag,
8116      isBlockNode,
8117      true
8118    );
8119  }
8120  function guardReactiveProps(props) {
8121    if (!props)
8122      return null;
8123    return isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
8124  }
8125  function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
8126    const { props, ref: ref2, patchFlag, children, transition } = vnode;
8127    const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
8128    const cloned = {
8129      __v_isVNode: true,
8130      __v_skip: true,
8131      type: vnode.type,
8132      props: mergedProps,
8133      key: mergedProps && normalizeKey(mergedProps),
8134      ref: extraProps && extraProps.ref ? (
8135        // #2078 in the case of <component :is="vnode" ref="extra"/>
8136        // if the vnode itself already has a ref, cloneVNode will need to merge
8137        // the refs so the single vnode can be set on multiple refs
8138        mergeRef && ref2 ? isArray(ref2) ? ref2.concat(normalizeRef(extraProps)) : [ref2, normalizeRef(extraProps)] : normalizeRef(extraProps)
8139      ) : ref2,
8140      scopeId: vnode.scopeId,
8141      slotScopeIds: vnode.slotScopeIds,
8142      children,
8143      target: vnode.target,
8144      targetStart: vnode.targetStart,
8145      targetAnchor: vnode.targetAnchor,
8146      staticCount: vnode.staticCount,
8147      shapeFlag: vnode.shapeFlag,
8148      // if the vnode is cloned with extra props, we can no longer assume its
8149      // existing patch flag to be reliable and need to add the FULL_PROPS flag.
8150      // note: preserve flag for fragments since they use the flag for children
8151      // fast paths only.
8152      patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
8153      dynamicProps: vnode.dynamicProps,
8154      dynamicChildren: vnode.dynamicChildren,
8155      appContext: vnode.appContext,
8156      dirs: vnode.dirs,
8157      transition,
8158      // These should technically only be non-null on mounted VNodes. However,
8159      // they *should* be copied for kept-alive vnodes. So we just always copy
8160      // them since them being non-null during a mount doesn't affect the logic as
8161      // they will simply be overwritten.
8162      component: vnode.component,
8163      suspense: vnode.suspense,
8164      ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
8165      ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
8166      el: vnode.el,
8167      anchor: vnode.anchor,
8168      ctx: vnode.ctx,
8169      ce: vnode.ce
8170    };
8171    if (transition && cloneTransition) {
8172      setTransitionHooks(
8173        cloned,
8174        transition.clone(cloned)
8175      );
8176    }
8177    return cloned;
8178  }
8179  function createTextVNode(text = " ", flag = 0) {
8180    return createVNode(Text, null, text, flag);
8181  }
8182  function createStaticVNode(content, numberOfNodes) {
8183    const vnode = createVNode(Static, null, content);
8184    vnode.staticCount = numberOfNodes;
8185    return vnode;
8186  }
8187  function createCommentVNode(text = "", asBlock = false) {
8188    return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
8189  }
8190  function normalizeVNode$1(child) {
8191    if (child == null || typeof child === "boolean") {
8192      return createVNode(Comment);
8193    } else if (isArray(child)) {
8194      return createVNode(
8195        Fragment,
8196        null,
8197        // #3666, avoid reference pollution when reusing vnode
8198        child.slice()
8199      );
8200    } else if (isVNode(child)) {
8201      return cloneIfMounted(child);
8202    } else {
8203      return createVNode(Text, null, String(child));
8204    }
8205  }
8206  function cloneIfMounted(child) {
8207    return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
8208  }
8209  function normalizeChildren(vnode, children) {
8210    let type = 0;
8211    const { shapeFlag } = vnode;
8212    if (children == null) {
8213      children = null;
8214    } else if (isArray(children)) {
8215      type = 16;
8216    } else if (typeof children === "object") {
8217      if (shapeFlag & (1 | 64)) {
8218        const slot = children.default;
8219        if (slot) {
8220          slot._c && (slot._d = false);
8221          normalizeChildren(vnode, slot());
8222          slot._c && (slot._d = true);
8223        }
8224        return;
8225      } else {
8226        type = 32;
8227        const slotFlag = children._;
8228        if (!slotFlag && !isInternalObject(children)) {
8229          children._ctx = currentRenderingInstance;
8230        } else if (slotFlag === 3 && currentRenderingInstance) {
8231          if (currentRenderingInstance.slots._ === 1) {
8232            children._ = 1;
8233          } else {
8234            children._ = 2;
8235            vnode.patchFlag |= 1024;
8236          }
8237        }
8238      }
8239    } else if (isFunction(children)) {
8240      children = { default: children, _ctx: currentRenderingInstance };
8241      type = 32;
8242    } else {
8243      children = String(children);
8244      if (shapeFlag & 64) {
8245        type = 16;
8246        children = [createTextVNode(children)];
8247      } else {
8248        type = 8;
8249      }
8250    }
8251    vnode.children = children;
8252    vnode.shapeFlag |= type;
8253  }
8254  function mergeProps(...args) {
8255    const ret = {};
8256    for (let i = 0; i < args.length; i++) {
8257      const toMerge = args[i];
8258      for (const key in toMerge) {
8259        if (key === "class") {
8260          if (ret.class !== toMerge.class) {
8261            ret.class = normalizeClass([ret.class, toMerge.class]);
8262          }
8263        } else if (key === "style") {
8264          ret.style = normalizeStyle([ret.style, toMerge.style]);
8265        } else if (isOn(key)) {
8266          const existing = ret[key];
8267          const incoming = toMerge[key];
8268          if (incoming && existing !== incoming && !(isArray(existing) && existing.includes(incoming))) {
8269            ret[key] = existing ? [].concat(existing, incoming) : incoming;
8270          }
8271        } else if (key !== "") {
8272          ret[key] = toMerge[key];
8273        }
8274      }
8275    }
8276    return ret;
8277  }
8278  function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
8279    callWithAsyncErrorHandling(hook, instance, 7, [
8280      vnode,
8281      prevVNode
8282    ]);
8283  }
8284  const emptyAppContext = createAppContext();
8285  let uid = 0;
8286  function createComponentInstance$1(vnode, parent, suspense) {
8287    const type = vnode.type;
8288    const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
8289    const instance = {
8290      uid: uid++,
8291      vnode,
8292      type,
8293      parent,
8294      appContext,
8295      root: null,
8296      // to be immediately set
8297      next: null,
8298      subTree: null,
8299      // will be set synchronously right after creation
8300      effect: null,
8301      update: null,
8302      // will be set synchronously right after creation
8303      job: null,
8304      scope: new EffectScope(
8305        true
8306        /* detached */
8307      ),
8308      render: null,
8309      proxy: null,
8310      exposed: null,
8311      exposeProxy: null,
8312      withProxy: null,
8313      provides: parent ? parent.provides : Object.create(appContext.provides),
8314      ids: parent ? parent.ids : ["", 0, 0],
8315      accessCache: null,
8316      renderCache: [],
8317      // local resolved assets
8318      components: null,
8319      directives: null,
8320      // resolved props and emits options
8321      propsOptions: normalizePropsOptions(type, appContext),
8322      emitsOptions: normalizeEmitsOptions(type, appContext),
8323      // emit
8324      emit: null,
8325      // to be set immediately
8326      emitted: null,
8327      // props default value
8328      propsDefaults: EMPTY_OBJ,
8329      // inheritAttrs
8330      inheritAttrs: type.inheritAttrs,
8331      // state
8332      ctx: EMPTY_OBJ,
8333      data: EMPTY_OBJ,
8334      props: EMPTY_OBJ,
8335      attrs: EMPTY_OBJ,
8336      slots: EMPTY_OBJ,
8337      refs: EMPTY_OBJ,
8338      setupState: EMPTY_OBJ,
8339      setupContext: null,
8340      // suspense related
8341      suspense,
8342      suspenseId: suspense ? suspense.pendingId : 0,
8343      asyncDep: null,
8344      asyncResolved: false,
8345      // lifecycle hooks
8346      // not using enums here because it results in computed properties
8347      isMounted: false,
8348      isUnmounted: false,
8349      isDeactivated: false,
8350      bc: null,
8351      c: null,
8352      bm: null,
8353      m: null,
8354      bu: null,
8355      u: null,
8356      um: null,
8357      bum: null,
8358      da: null,
8359      a: null,
8360      rtg: null,
8361      rtc: null,
8362      ec: null,
8363      sp: null
8364    };
8365    {
8366      instance.ctx = { _: instance };
8367    }
8368    instance.root = parent ? parent.root : instance;
8369    instance.emit = emit.bind(null, instance);
8370    if (vnode.ce) {
8371      vnode.ce(instance);
8372    }
8373    return instance;
8374  }
8375  let currentInstance = null;
8376  const getCurrentInstance = () => currentInstance || currentRenderingInstance;
8377  let internalSetCurrentInstance;
8378  let setInSSRSetupState;
8379  {
8380    const g = getGlobalThis();
8381    const registerGlobalSetter = (key, setter) => {
8382      let setters;
8383      if (!(setters = g[key]))
8384        setters = g[key] = [];
8385      setters.push(setter);
8386      return (v) => {
8387        if (setters.length > 1)
8388          setters.forEach((set) => set(v));
8389        else
8390          setters[0](v);
8391      };
8392    };
8393    internalSetCurrentInstance = registerGlobalSetter(
8394      `__VUE_INSTANCE_SETTERS__`,
8395      (v) => currentInstance = v
8396    );
8397    setInSSRSetupState = registerGlobalSetter(
8398      `__VUE_SSR_SETTERS__`,
8399      (v) => isInSSRComponentSetup = v
8400    );
8401  }
8402  const setCurrentInstance = (instance) => {
8403    const prev = currentInstance;
8404    internalSetCurrentInstance(instance);
8405    instance.scope.on();
8406    return () => {
8407      instance.scope.off();
8408      internalSetCurrentInstance(prev);
8409    };
8410  };
8411  const unsetCurrentInstance = () => {
8412    currentInstance && currentInstance.scope.off();
8413    internalSetCurrentInstance(null);
8414  };
8415  function isStatefulComponent(instance) {
8416    return instance.vnode.shapeFlag & 4;
8417  }
8418  let isInSSRComponentSetup = false;

8419  function setupComponent$1(instance, isSSR = false, optimized = false) {
8420    isSSR && setInSSRSetupState(isSSR);
8421    const { props, children } = instance.vnode;
8422    const isStateful = isStatefulComponent(instance);
8423    initProps(instance, props, isStateful, isSSR);
8424    initSlots(instance, children, optimized);
8425    const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
8426    isSSR && setInSSRSetupState(false);
8427    return setupResult;
8428  }
8429  function setupStatefulComponent(instance, isSSR) {
8430    const Component = instance.type;
8431    instance.accessCache = /* @__PURE__ */ Object.create(null);
8432    instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers);
8433    const { setup } = Component;
8434    if (setup) {
8435      pauseTracking();
8436      const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
8437      const reset = setCurrentInstance(instance);
8438      const setupResult = callWithErrorHandling(
8439        setup,
8440        instance,
8441        0,
8442        [
8443          instance.props,
8444          setupContext
8445        ]
8446      );
8447      const isAsyncSetup = isPromise(setupResult);
8448      resetTracking();
8449      reset();
8450      if ((isAsyncSetup || instance.sp) && !isAsyncWrapper(instance)) {
8451        markAsyncBoundary(instance);
8452      }
8453      if (isAsyncSetup) {
8454        setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
8455        if (isSSR) {
8456          return setupResult.then((resolvedResult) => {
8457            handleSetupResult(instance, resolvedResult, isSSR);
8458          }).catch((e) => {
8459            handleError(e, instance, 0);
8460          });
8461        } else {
8462          instance.asyncDep = setupResult;
8463        }
8464      } else {
8465        handleSetupResult(instance, setupResult, isSSR);
8466      }
8467    } else {
8468      finishComponentSetup(instance, isSSR);
8469    }
8470  }
8471  function handleSetupResult(instance, setupResult, isSSR) {
8472    if (isFunction(setupResult)) {
8473      if (instance.type.__ssrInlineRender) {
8474        instance.ssrRender = setupResult;
8475      } else {
8476        instance.render = setupResult;
8477      }
8478    } else if (isObject(setupResult)) {
8479      instance.setupState = proxyRefs(setupResult);
8480    } else
8481      ;
8482    finishComponentSetup(instance, isSSR);
8483  }
8484  let compile$1;
8485  let installWithProxy;
8486  function registerRuntimeCompiler(_compile) {
8487    compile$1 = _compile;
8488    installWithProxy = (i) => {
8489      if (i.render._rc) {
8490        i.withProxy = new Proxy(i.ctx, RuntimeCompiledPublicInstanceProxyHandlers);
8491      }
8492    };
8493  }
8494  const isRuntimeOnly = () => !compile$1;
8495  function finishComponentSetup(instance, isSSR, skipOptions) {
8496    const Component = instance.type;
8497    if (!instance.render) {
8498      if (!isSSR && compile$1 && !Component.render) {
8499        const template = Component.template || resolveMergedOptions(instance).template;
8500        if (template) {
8501          const { isCustomElement, compilerOptions } = instance.appContext.config;
8502          const { delimiters, compilerOptions: componentCompilerOptions } = Component;
8503          const finalCompilerOptions = extend(
8504            extend(
8505              {
8506                isCustomElement,
8507                delimiters
8508              },
8509              compilerOptions
8510            ),
8511            componentCompilerOptions
8512          );
8513          Component.render = compile$1(template, finalCompilerOptions);
8514        }
8515      }
8516      instance.render = Component.render || NOOP;
8517      if (installWithProxy) {
8518        installWithProxy(instance);
8519      }
8520    }
8521    {
8522      const reset = setCurrentInstance(instance);
8523      pauseTracking();
8524      try {
8525        applyOptions(instance);
8526      } finally {
8527        resetTracking();
8528        reset();
8529      }
8530    }
8531  }
8532  const attrsProxyHandlers = {
8533    get(target, key) {
8534      track(target, "get", "");
8535      return target[key];
8536    }
8537  };
8538  function createSetupContext(instance) {
8539    const expose = (exposed) => {
8540      instance.exposed = exposed || {};
8541    };
8542    {
8543      return {
8544        attrs: new Proxy(instance.attrs, attrsProxyHandlers),
8545        slots: instance.slots,
8546        emit: instance.emit,
8547        expose
8548      };
8549    }
8550  }
8551  function getComponentPublicInstance(instance) {
8552    if (instance.exposed) {
8553      return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
8554        get(target, key) {
8555          if (key in target) {
8556            return target[key];
8557          } else if (key in publicPropertiesMap) {
8558            return publicPropertiesMap[key](instance);
8559          }
8560        },
8561        has(target, key) {
8562          return key in target || key in publicPropertiesMap;
8563        }
8564      }));
8565    } else {
8566      return instance.proxy;
8567    }
8568  }
8569  const classifyRE = /(?:^|[-_])(\w)/g;
8570  const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
8571  function getComponentName(Component, includeInferred = true) {
8572    return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
8573  }
8574  function formatComponentName(instance, Component, isRoot = false) {
8575    let name = getComponentName(Component);
8576    if (!name && Component.__file) {
8577      const match = Component.__file.match(/([^/\\]+)\.\w+$/);
8578      if (match) {
8579        name = match[1];
8580      }
8581    }
8582    if (!name && instance && instance.parent) {
8583      const inferFromRegistry = (registry) => {
8584        for (const key in registry) {
8585          if (registry[key] === Component) {
8586            return key;
8587          }
8588        }
8589      };
8590      name = inferFromRegistry(
8591        instance.components || instance.parent.type.components
8592      ) || inferFromRegistry(instance.appContext.components);
8593    }
8594    return name ? classify(name) : isRoot ? `App` : `Anonymous`;
8595  }
8596  function isClassComponent(value) {
8597    return isFunction(value) && "__vccOpts" in value;
8598  }
8599  const computed = (getterOrOptions, debugOptions) => {
8600    const c = computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
8601    return c;
8602  };
8603  function h(type, propsOrChildren, children) {
8604    const l = arguments.length;
8605    if (l === 2) {
8606      if (isObject(propsOrChildren) && !isArray(propsOrChildren)) {
8607        if (isVNode(propsOrChildren)) {
8608          return createVNode(type, null, [propsOrChildren]);
8609        }
8610        return createVNode(type, propsOrChildren);
8611      } else {
8612        return createVNode(type, null, propsOrChildren);
8613      }
8614    } else {
8615      if (l > 3) {
8616        children = Array.prototype.slice.call(arguments, 2);
8617      } else if (l === 3 && isVNode(children)) {
8618        children = [children];
8619      }
8620      return createVNode(type, propsOrChildren, children);
8621    }
8622  }
8623  function initCustomFormatter() {
8624    {
8625      return;
8626    }
8627  }
8628  function withMemo(memo, render2, cache, index2) {

8629    const cached = cache[index2];
8630    if (cached && isMemoSame(cached, memo)) {
8631      return cached;
8632    }
8633    const ret = render2();
8634    ret.memo = memo.slice();
8635    ret.cacheIndex = index2;
8636    return cache[index2] = ret;
8637  }
8638  function isMemoSame(cached, memo) {
8639    const prev = cached.memo;
8640    if (prev.length != memo.length) {
8641      return false;
8642    }
8643    for (let i = 0; i < prev.length; i++) {
8644      if (hasChanged(prev[i], memo[i])) {
8645        return false;
8646      }
8647    }
8648    if (isBlockTreeEnabled > 0 && currentBlock) {
8649      currentBlock.push(cached);
8650    }
8651    return true;
8652  }
8653  const version = "3.5.12";
8654  const warn = NOOP;
8655  const ErrorTypeStrings = ErrorTypeStrings$1;
8656  const devtools = devtools$1;
8657  const setDevtoolsHook = setDevtoolsHook$1;
8658  const _ssrUtils = {
8659    createComponentInstance: createComponentInstance$1,
8660    setupComponent: setupComponent$1,
8661    renderComponentRoot: renderComponentRoot$1,
8662    setCurrentRenderingInstance: setCurrentRenderingInstance$1,
8663    isVNode,
8664    normalizeVNode: normalizeVNode$1,
8665    getComponentPublicInstance,
8666    ensureValidVNode,
8667    pushWarningContext: pushWarningContext$1,
8668    popWarningContext: popWarningContext$1
8669  };
8670  const ssrUtils = _ssrUtils;
8671  const resolveFilter = null;
8672  const compatUtils = null;
8673  const DeprecationTypes = null;
8674  /**
8675  * @vue/runtime-dom v3.5.12
8676  * (c) 2018-present Yuxi (Evan) You and Vue contributors
8677  * @license MIT
8678  **/
8679  let policy = void 0;
8680  const tt = typeof window !== "undefined" && window.trustedTypes;
8681  if (tt) {
8682    try {
8683      policy = /* @__PURE__ */ tt.createPolicy("vue", {
8684        createHTML: (val) => val
8685      });
8686    } catch (e) {
8687    }
8688  }
8689  const unsafeToTrustedHTML = policy ? (val) => policy.createHTML(val) : (val) => val;
8690  const svgNS = "http://www.w3.org/2000/svg";
8691  const mathmlNS = "http://www.w3.org/1998/Math/MathML";
8692  const doc = typeof document !== "undefined" ? document : null;

vendor: 14,175 bytes, lines 8693-9135

8693  const templateContainer = doc && /* @__PURE__ */ doc.createElement("template");
8694  const nodeOps = {
8695    insert: (child, parent, anchor) => {
8696      parent.insertBefore(child, anchor || null);
8697    },
8698    remove: (child) => {
8699      const parent = child.parentNode;
8700      if (parent) {
8701        parent.removeChild(child);
8702      }
8703    },
8704    createElement: (tag, namespace, is, props) => {
8705      const el = namespace === "svg" ? doc.createElementNS(svgNS, tag) : namespace === "mathml" ? doc.createElementNS(mathmlNS, tag) : is ? doc.createElement(tag, { is }) : doc.createElement(tag);
8706      if (tag === "select" && props && props.multiple != null) {
8707        el.setAttribute("multiple", props.multiple);
8708      }
8709      return el;
8710    },
8711    createText: (text) => doc.createTextNode(text),
8712    createComment: (text) => doc.createComment(text),
8713    setText: (node, text) => {
8714      node.nodeValue = text;
8715    },
8716    setElementText: (el, text) => {
8717      el.textContent = text;
8718    },
8719    parentNode: (node) => node.parentNode,
8720    nextSibling: (node) => node.nextSibling,
8721    querySelector: (selector) => doc.querySelector(selector),
8722    setScopeId(el, id) {
8723      el.setAttribute(id, "");
8724    },
8725    // __UNSAFE__
8726    // Reason: innerHTML.
8727    // Static content here can only come from compiled templates.
8728    // As long as the user only uses trusted templates, this is safe.
8729    insertStaticContent(content, parent, anchor, namespace, start, end) {
8730      const before = anchor ? anchor.previousSibling : parent.lastChild;
8731      if (start && (start === end || start.nextSibling)) {
8732        while (true) {
8733          parent.insertBefore(start.cloneNode(true), anchor);
8734          if (start === end || !(start = start.nextSibling))
8735            break;
8736        }
8737      } else {
8738        templateContainer.innerHTML = unsafeToTrustedHTML(
8739          namespace === "svg" ? `<svg>${content}</svg>` : namespace === "mathml" ? `<math>${content}</math>` : content
8740        );
8741        const template = templateContainer.content;
8742        if (namespace === "svg" || namespace === "mathml") {
8743          const wrapper = template.firstChild;
8744          while (wrapper.firstChild) {
8745            template.appendChild(wrapper.firstChild);
8746          }
8747          template.removeChild(wrapper);
8748        }
8749        parent.insertBefore(template, anchor);
8750      }
8751      return [
8752        // first
8753        before ? before.nextSibling : parent.firstChild,
8754        // last
8755        anchor ? anchor.previousSibling : parent.lastChild
8756      ];
8757    }
8758  };
8759  const TRANSITION = "transition";
8760  const ANIMATION = "animation";
8761  const vtcKey = Symbol("_vtc");
8762  const DOMTransitionPropsValidators = {
8763    name: String,
8764    type: String,
8765    css: {
8766      type: Boolean,
8767      default: true
8768    },
8769    duration: [String, Number, Object],
8770    enterFromClass: String,
8771    enterActiveClass: String,
8772    enterToClass: String,
8773    appearFromClass: String,
8774    appearActiveClass: String,
8775    appearToClass: String,
8776    leaveFromClass: String,
8777    leaveActiveClass: String,
8778    leaveToClass: String
8779  };
8780  const TransitionPropsValidators = /* @__PURE__ */ extend(
8781    {},
8782    BaseTransitionPropsValidators,
8783    DOMTransitionPropsValidators
8784  );
8785  const decorate$1 = (t) => {
8786    t.displayName = "Transition";
8787    t.props = TransitionPropsValidators;
8788    return t;
8789  };
8790  const Transition = /* @__PURE__ */ decorate$1(
8791    (props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots)
8792  );
8793  const callHook = (hook, args = []) => {
8794    if (isArray(hook)) {
8795      hook.forEach((h2) => h2(...args));
8796    } else if (hook) {
8797      hook(...args);
8798    }
8799  };
8800  const hasExplicitCallback = (hook) => {
8801    return hook ? isArray(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
8802  };
8803  function resolveTransitionProps(rawProps) {
8804    const baseProps = {};
8805    for (const key in rawProps) {
8806      if (!(key in DOMTransitionPropsValidators)) {
8807        baseProps[key] = rawProps[key];
8808      }
8809    }
8810    if (rawProps.css === false) {
8811      return baseProps;
8812    }
8813    const {
8814      name = "v",
8815      type,
8816      duration,
8817      enterFromClass = `${name}-enter-from`,
8818      enterActiveClass = `${name}-enter-active`,
8819      enterToClass = `${name}-enter-to`,
8820      appearFromClass = enterFromClass,
8821      appearActiveClass = enterActiveClass,
8822      appearToClass = enterToClass,
8823      leaveFromClass = `${name}-leave-from`,
8824      leaveActiveClass = `${name}-leave-active`,
8825      leaveToClass = `${name}-leave-to`
8826    } = rawProps;
8827    const durations = normalizeDuration(duration);
8828    const enterDuration = durations && durations[0];
8829    const leaveDuration = durations && durations[1];
8830    const {
8831      onBeforeEnter,
8832      onEnter,
8833      onEnterCancelled,
8834      onLeave,
8835      onLeaveCancelled,
8836      onBeforeAppear = onBeforeEnter,
8837      onAppear = onEnter,
8838      onAppearCancelled = onEnterCancelled
8839    } = baseProps;
8840    const finishEnter = (el, isAppear, done) => {
8841      removeTransitionClass(el, isAppear ? appearToClass : enterToClass);
8842      removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);
8843      done && done();
8844    };
8845    const finishLeave = (el, done) => {
8846      el._isLeaving = false;
8847      removeTransitionClass(el, leaveFromClass);
8848      removeTransitionClass(el, leaveToClass);
8849      removeTransitionClass(el, leaveActiveClass);
8850      done && done();
8851    };
8852    const makeEnterHook = (isAppear) => {
8853      return (el, done) => {
8854        const hook = isAppear ? onAppear : onEnter;
8855        const resolve2 = () => finishEnter(el, isAppear, done);
8856        callHook(hook, [el, resolve2]);
8857        nextFrame(() => {
8858          removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);
8859          addTransitionClass(el, isAppear ? appearToClass : enterToClass);
8860          if (!hasExplicitCallback(hook)) {
8861            whenTransitionEnds(el, type, enterDuration, resolve2);
8862          }
8863        });
8864      };
8865    };
8866    return extend(baseProps, {
8867      onBeforeEnter(el) {
8868        callHook(onBeforeEnter, [el]);
8869        addTransitionClass(el, enterFromClass);
8870        addTransitionClass(el, enterActiveClass);
8871      },
8872      onBeforeAppear(el) {
8873        callHook(onBeforeAppear, [el]);
8874        addTransitionClass(el, appearFromClass);
8875        addTransitionClass(el, appearActiveClass);
8876      },
8877      onEnter: makeEnterHook(false),
8878      onAppear: makeEnterHook(true),
8879      onLeave(el, done) {
8880        el._isLeaving = true;
8881        const resolve2 = () => finishLeave(el, done);
8882        addTransitionClass(el, leaveFromClass);
8883        addTransitionClass(el, leaveActiveClass);
8884        forceReflow();
8885        nextFrame(() => {
8886          if (!el._isLeaving) {
8887            return;
8888          }
8889          removeTransitionClass(el, leaveFromClass);
8890          addTransitionClass(el, leaveToClass);
8891          if (!hasExplicitCallback(onLeave)) {
8892            whenTransitionEnds(el, type, leaveDuration, resolve2);
8893          }
8894        });
8895        callHook(onLeave, [el, resolve2]);
8896      },
8897      onEnterCancelled(el) {
8898        finishEnter(el, false);
8899        callHook(onEnterCancelled, [el]);
8900      },
8901      onAppearCancelled(el) {
8902        finishEnter(el, true);
8903        callHook(onAppearCancelled, [el]);
8904      },
8905      onLeaveCancelled(el) {
8906        finishLeave(el);
8907        callHook(onLeaveCancelled, [el]);
8908      }
8909    });
8910  }
8911  function normalizeDuration(duration) {
8912    if (duration == null) {
8913      return null;
8914    } else if (isObject(duration)) {
8915      return [NumberOf(duration.enter), NumberOf(duration.leave)];
8916    } else {
8917      const n = NumberOf(duration);
8918      return [n, n];
8919    }
8920  }
8921  function NumberOf(val) {
8922    const res = toNumber(val);
8923    return res;
8924  }
8925  function addTransitionClass(el, cls) {
8926    cls.split(/\s+/).forEach((c) => c && el.classList.add(c));
8927    (el[vtcKey] || (el[vtcKey] = /* @__PURE__ */ new Set())).add(cls);
8928  }
8929  function removeTransitionClass(el, cls) {
8930    cls.split(/\s+/).forEach((c) => c && el.classList.remove(c));
8931    const _vtc = el[vtcKey];
8932    if (_vtc) {
8933      _vtc.delete(cls);
8934      if (!_vtc.size) {
8935        el[vtcKey] = void 0;
8936      }
8937    }
8938  }
8939  function nextFrame(cb) {
8940    requestAnimationFrame(() => {
8941      requestAnimationFrame(cb);
8942    });
8943  }
8944  let endId = 0;
8945  function whenTransitionEnds(el, expectedType, explicitTimeout, resolve2) {
8946    const id = el._endId = ++endId;
8947    const resolveIfNotStale = () => {
8948      if (id === el._endId) {
8949        resolve2();
8950      }
8951    };
8952    if (explicitTimeout != null) {
8953      return setTimeout(resolveIfNotStale, explicitTimeout);
8954    }
8955    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
8956    if (!type) {
8957      return resolve2();
8958    }
8959    const endEvent = type + "end";
8960    let ended = 0;
8961    const end = () => {
8962      el.removeEventListener(endEvent, onEnd);
8963      resolveIfNotStale();
8964    };
8965    const onEnd = (e) => {
8966      if (e.target === el && ++ended >= propCount) {
8967        end();
8968      }
8969    };
8970    setTimeout(() => {
8971      if (ended < propCount) {
8972        end();
8973      }
8974    }, timeout + 1);
8975    el.addEventListener(endEvent, onEnd);
8976  }
8977  function getTransitionInfo(el, expectedType) {
8978    const styles = window.getComputedStyle(el);
8979    const getStyleProperties = (key) => (styles[key] || "").split(", ");
8980    const transitionDelays = getStyleProperties(`${TRANSITION}Delay`);
8981    const transitionDurations = getStyleProperties(`${TRANSITION}Duration`);
8982    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
8983    const animationDelays = getStyleProperties(`${ANIMATION}Delay`);
8984    const animationDurations = getStyleProperties(`${ANIMATION}Duration`);
8985    const animationTimeout = getTimeout(animationDelays, animationDurations);
8986    let type = null;
8987    let timeout = 0;
8988    let propCount = 0;
8989    if (expectedType === TRANSITION) {
8990      if (transitionTimeout > 0) {
8991        type = TRANSITION;
8992        timeout = transitionTimeout;
8993        propCount = transitionDurations.length;
8994      }
8995    } else if (expectedType === ANIMATION) {
8996      if (animationTimeout > 0) {
8997        type = ANIMATION;
8998        timeout = animationTimeout;
8999        propCount = animationDurations.length;
9000      }
9001    } else {
9002      timeout = Math.max(transitionTimeout, animationTimeout);
9003      type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;
9004      propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;
9005    }
9006    const hasTransform = type === TRANSITION && /\b(transform|all)(,|$)/.test(
9007      getStyleProperties(`${TRANSITION}Property`).toString()
9008    );
9009    return {
9010      type,
9011      timeout,
9012      propCount,
9013      hasTransform
9014    };
9015  }
9016  function getTimeout(delays, durations) {
9017    while (delays.length < durations.length) {
9018      delays = delays.concat(delays);
9019    }
9020    return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
9021  }
9022  function toMs(s) {
9023    if (s === "auto")
9024      return 0;
9025    return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
9026  }
9027  function forceReflow() {
9028    return document.body.offsetHeight;
9029  }
9030  function patchClass(el, value, isSVG) {
9031    const transitionClasses = el[vtcKey];
9032    if (transitionClasses) {
9033      value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
9034    }
9035    if (value == null) {
9036      el.removeAttribute("class");
9037    } else if (isSVG) {
9038      el.setAttribute("class", value);
9039    } else {
9040      el.className = value;
9041    }
9042  }
9043  const vShowOriginalDisplay = Symbol("_vod");
9044  const vShowHidden = Symbol("_vsh");
9045  const vShow = {
9046    beforeMount(el, { value }, { transition }) {
9047      el[vShowOriginalDisplay] = el.style.display === "none" ? "" : el.style.display;
9048      if (transition && value) {
9049        transition.beforeEnter(el);
9050      } else {
9051        setDisplay(el, value);
9052      }
9053    },
9054    mounted(el, { value }, { transition }) {
9055      if (transition && value) {
9056        transition.enter(el);
9057      }
9058    },
9059    updated(el, { value, oldValue }, { transition }) {
9060      if (!value === !oldValue)
9061        return;
9062      if (transition) {
9063        if (value) {
9064          transition.beforeEnter(el);
9065          setDisplay(el, true);
9066          transition.enter(el);
9067        } else {
9068          transition.leave(el, () => {
9069            setDisplay(el, false);
9070          });
9071        }
9072      } else {
9073        setDisplay(el, value);
9074      }
9075    },
9076    beforeUnmount(el, { value }) {
9077      setDisplay(el, value);
9078    }
9079  };
9080  function setDisplay(el, value) {
9081    el.style.display = value ? el[vShowOriginalDisplay] : "none";
9082    el[vShowHidden] = !value;
9083  }
9084  function initVShowForSSR() {
9085    vShow.getSSRProps = ({ value }) => {
9086      if (!value) {
9087        return { style: { display: "none" } };
9088      }
9089    };
9090  }
9091  const CSS_VAR_TEXT = Symbol("");
9092  function useCssVars(getter) {
9093    const instance = getCurrentInstance();
9094    if (!instance) {
9095      return;
9096    }
9097    const updateTeleports = instance.ut = (vars = getter(instance.proxy)) => {
9098      Array.from(
9099        document.querySelectorAll(`[data-v-owner="${instance.uid}"]`)
9100      ).forEach((node) => setVarsOnNode(node, vars));
9101    };
9102    const setVars = () => {
9103      const vars = getter(instance.proxy);
9104      if (instance.ce) {
9105        setVarsOnNode(instance.ce, vars);
9106      } else {
9107        setVarsOnVNode(instance.subTree, vars);
9108      }
9109      updateTeleports(vars);
9110    };
9111    onBeforeMount(() => {
9112      watchPostEffect(setVars);
9113    });
9114    onMounted(() => {
9115      const ob = new MutationObserver(setVars);
9116      ob.observe(instance.subTree.el.parentNode, { childList: true });
9117      onUnmounted(() => ob.disconnect());
9118    });
9119  }
9120  function setVarsOnVNode(vnode, vars) {
9121    if (vnode.shapeFlag & 128) {
9122      const suspense = vnode.suspense;
9123      vnode = suspense.activeBranch;
9124      if (suspense.pendingBranch && !suspense.isHydrating) {
9125        suspense.effects.push(() => {
9126          setVarsOnVNode(suspense.activeBranch, vars);
9127        });
9128      }
9129    }
9130    while (vnode.component) {
9131      vnode = vnode.component.subTree;
9132    }
9133    if (vnode.shapeFlag & 1 && vnode.el) {
9134      setVarsOnNode(vnode.el, vars);
9135    } else if (vnode.type === Fragment) {

9136      vnode.children.forEach((c) => setVarsOnVNode(c, vars));
9137    } else if (vnode.type === Static) {
9138      let { el, anchor } = vnode;
9139      while (el) {
9140        setVarsOnNode(el, vars);
9141        if (el === anchor)
9142          break;
9143        el = el.nextSibling;
9144      }
9145    }
9146  }
9147  function setVarsOnNode(el, vars) {
9148    if (el.nodeType === 1) {
9149      const style = el.style;
9150      let cssText = "";
9151      for (const key in vars) {
9152        style.setProperty(`--${key}`, vars[key]);
9153        cssText += `--${key}: ${vars[key]};`;
9154      }
9155      style[CSS_VAR_TEXT] = cssText;
9156    }
9157  }
9158  const displayRE = /(^|;)\s*display\s*:/;
9159  function patchStyle(el, prev, next) {
9160    const style = el.style;
9161    const isCssString = isString(next);
9162    let hasControlledDisplay = false;
9163    if (next && !isCssString) {
9164      if (prev) {
9165        if (!isString(prev)) {
9166          for (const key in prev) {
9167            if (next[key] == null) {
9168              setStyle(style, key, "");
9169            }
9170          }
9171        } else {
9172          for (const prevStyle of prev.split(";")) {
9173            const key = prevStyle.slice(0, prevStyle.indexOf(":")).trim();
9174            if (next[key] == null) {
9175              setStyle(style, key, "");
9176            }
9177          }
9178        }
9179      }
9180      for (const key in next) {
9181        if (key === "display") {
9182          hasControlledDisplay = true;
9183        }
9184        setStyle(style, key, next[key]);
9185      }
9186    } else {
9187      if (isCssString) {
9188        if (prev !== next) {
9189          const cssVarText = style[CSS_VAR_TEXT];
9190          if (cssVarText) {
9191            next += ";" + cssVarText;
9192          }
9193          style.cssText = next;
9194          hasControlledDisplay = displayRE.test(next);
9195        }
9196      } else if (prev) {
9197        el.removeAttribute("style");
9198      }
9199    }
9200    if (vShowOriginalDisplay in el) {
9201      el[vShowOriginalDisplay] = hasControlledDisplay ? style.display : "";
9202      if (el[vShowHidden]) {
9203        style.display = "none";
9204      }
9205    }
9206  }
9207  const importantRE = /\s*!important$/;
9208  function setStyle(style, name, val) {
9209    if (isArray(val)) {
9210      val.forEach((v) => setStyle(style, name, v));
9211    } else {
9212      if (val == null)
9213        val = "";
9214      if (name.startsWith("--")) {
9215        style.setProperty(name, val);
9216      } else {
9217        const prefixed = autoPrefix(style, name);
9218        if (importantRE.test(val)) {
9219          style.setProperty(
9220            hyphenate(prefixed),
9221            val.replace(importantRE, ""),
9222            "important"
9223          );
9224        } else {
9225          style[prefixed] = val;
9226        }
9227      }
9228    }
9229  }
9230  const prefixes = ["Webkit", "Moz", "ms"];
9231  const prefixCache = {};
9232  function autoPrefix(style, rawName) {
9233    const cached = prefixCache[rawName];
9234    if (cached) {
9235      return cached;
9236    }
9237    let name = camelize(rawName);
9238    if (name !== "filter" && name in style) {
9239      return prefixCache[rawName] = name;
9240    }
9241    name = capitalize(name);
9242    for (let i = 0; i < prefixes.length; i++) {
9243      const prefixed = prefixes[i] + name;
9244      if (prefixed in style) {
9245        return prefixCache[rawName] = prefixed;
9246      }
9247    }
9248    return rawName;
9249  }
9250  const xlinkNS = "http://www.w3.org/1999/xlink";
9251  function patchAttr(el, key, value, isSVG, instance, isBoolean = isSpecialBooleanAttr(key)) {
9252    if (isSVG && key.startsWith("xlink:")) {
9253      if (value == null) {
9254        el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
9255      } else {
9256        el.setAttributeNS(xlinkNS, key, value);
9257      }
9258    } else {
9259      if (value == null || isBoolean && !includeBooleanAttr(value)) {
9260        el.removeAttribute(key);
9261      } else {
9262        el.setAttribute(
9263          key,
9264          isBoolean ? "" : isSymbol(value) ? String(value) : value
9265        );
9266      }
9267    }
9268  }
9269  function patchDOMProp(el, key, value, parentComponent, attrName) {
9270    if (key === "innerHTML" || key === "textContent") {
9271      if (value != null) {
9272        el[key] = key === "innerHTML" ? unsafeToTrustedHTML(value) : value;
9273      }
9274      return;
9275    }
9276    const tag = el.tagName;
9277    if (key === "value" && tag !== "PROGRESS" && // custom elements may use _value internally
9278    !tag.includes("-")) {
9279      const oldValue = tag === "OPTION" ? el.getAttribute("value") || "" : el.value;
9280      const newValue = value == null ? (
9281        // #11647: value should be set as empty string for null and undefined,
9282        // but <input type="checkbox"> should be set as 'on'.
9283        el.type === "checkbox" ? "on" : ""
9284      ) : String(value);
9285      if (oldValue !== newValue || !("_value" in el)) {
9286        el.value = newValue;
9287      }
9288      if (value == null) {
9289        el.removeAttribute(key);
9290      }
9291      el._value = value;
9292      return;
9293    }
9294    let needRemove = false;

vendor: 1,053 bytes, lines 9295-9326

9295    if (value === "" || value == null) {
9296      const type = typeof el[key];
9297      if (type === "boolean") {
9298        value = includeBooleanAttr(value);
9299      } else if (value == null && type === "string") {
9300        value = "";
9301        needRemove = true;
9302      } else if (type === "number") {
9303        value = 0;
9304        needRemove = true;
9305      }
9306    }
9307    try {
9308      el[key] = value;
9309    } catch (e) {
9310    }
9311    needRemove && el.removeAttribute(attrName || key);
9312  }
9313  function addEventListener(el, event, handler, options) {
9314    el.addEventListener(event, handler, options);
9315  }
9316  function removeEventListener(el, event, handler, options) {
9317    el.removeEventListener(event, handler, options);
9318  }
9319  const veiKey = Symbol("_vei");
9320  function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
9321    const invokers = el[veiKey] || (el[veiKey] = {});
9322    const existingInvoker = invokers[rawName];
9323    if (nextValue && existingInvoker) {
9324      existingInvoker.value = nextValue;
9325    } else {
9326      const [name, options] = parseName(rawName);

vendor: 1,794 bytes, lines 9327-9388

9327      if (nextValue) {
9328        const invoker = invokers[rawName] = createInvoker(
9329          nextValue,
9330          instance
9331        );
9332        addEventListener(el, name, invoker, options);
9333      } else if (existingInvoker) {
9334        removeEventListener(el, name, existingInvoker, options);
9335        invokers[rawName] = void 0;
9336      }
9337    }
9338  }
9339  const optionsModifierRE = /(?:Once|Passive|Capture)$/;
9340  function parseName(name) {
9341    let options;
9342    if (optionsModifierRE.test(name)) {
9343      options = {};
9344      let m;
9345      while (m = name.match(optionsModifierRE)) {
9346        name = name.slice(0, name.length - m[0].length);
9347        options[m[0].toLowerCase()] = true;
9348      }
9349    }
9350    const event = name[2] === ":" ? name.slice(3) : hyphenate(name.slice(2));
9351    return [event, options];
9352  }
9353  let cachedNow = 0;
9354  const p = /* @__PURE__ */ Promise.resolve();
9355  const getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now());
9356  function createInvoker(initialValue, instance) {
9357    const invoker = (e) => {
9358      if (!e._vts) {
9359        e._vts = Date.now();
9360      } else if (e._vts <= invoker.attached) {
9361        return;
9362      }
9363      callWithAsyncErrorHandling(
9364        patchStopImmediatePropagation(e, invoker.value),
9365        instance,
9366        5,
9367        [e]
9368      );
9369    };
9370    invoker.value = initialValue;
9371    invoker.attached = getNow();
9372    return invoker;
9373  }
9374  function patchStopImmediatePropagation(e, value) {
9375    if (isArray(value)) {
9376      const originalStop = e.stopImmediatePropagation;
9377      e.stopImmediatePropagation = () => {
9378        originalStop.call(e);
9379        e._stopped = true;
9380      };
9381      return value.map(
9382        (fn) => (e2) => !e2._stopped && fn && fn(e2)
9383      );
9384    } else {
9385      return value;
9386    }
9387  }
9388  const isNativeOn = (key) =>

9388 key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // lowercase letter
9389  key.charCodeAt(2) > 96 && key.charCodeAt(2) < 123;
9390  const patchProp = (el, key, prevValue, nextValue, namespace, parentComponent) => {
9391    const isSVG = namespace === "svg";
9392    if (key === "class") {
9393      patchClass(el, nextValue, isSVG);
9394    } else if (key === "style") {
9395      patchStyle(el, prevValue, nextValue);
9396    } else if (isOn(key)) {
9397      if (!isModelListener(key)) {
9398        patchEvent(el, key, prevValue, nextValue, parentComponent);
9399      }
9400    } else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
9401      patchDOMProp(el, key, nextValue);
9402      if (!el.tagName.includes("-") && (key === "value" || key === "checked" || key === "selected")) {
9403        patchAttr(el, key, nextValue, isSVG, parentComponent, key !== "value");
9404      }
9405    } else if (
9406      // #11081 force set props for possible async custom element
9407      el._isVueCE && (/[A-Z]/.test(key) || !isString(nextValue))
9408    ) {
9409      patchDOMProp(el, camelize(key), nextValue, parentComponent, key);
9410    } else {
9411      if (key === "true-value") {
9412        el._trueValue = nextValue;
9413      } else if (key === "false-value") {
9414        el._falseValue = nextValue;
9415      }
9416      patchAttr(el, key, nextValue, isSVG);
9417    }
9418  };
9419  function shouldSetAsProp(el, key, value, isSVG) {
9420    if (isSVG) {
9421      if (key === "innerHTML" || key === "textContent") {
9422        return true;
9423      }
9424      if (key in el && isNativeOn(key) && isFunction(value)) {
9425        return true;
9426      }
9427      return false;
9428    }
9429    if (key === "spellcheck" || key === "draggable" || key === "translate") {
9430      return false;
9431    }
9432    if (key === "form") {
9433      return false;
9434    }
9435    if (key === "list" && el.tagName === "INPUT") {
9436      return false;
9437    }
9438    if (key === "type" && el.tagName === "TEXTAREA") {
9439      return false;
9440    }
9441    if (key === "width" || key === "height") {
9442      const tag = el.tagName;
9443      if (tag === "IMG" || tag === "VIDEO" || tag === "CANVAS" || tag === "SOURCE") {
9444        return false;
9445      }
9446    }
9447    if (isNativeOn(key) && isString(value)) {
9448      return false;
9449    }
9450    return key in el;
9451  }
9452  const REMOVAL = {};
9453  /*! #__NO_SIDE_EFFECTS__ */
9454  // @__NO_SIDE_EFFECTS__
9455  function defineCustomElement(options, extraOptions, _createApp) {
9456    const Comp = /* @__PURE__ */ defineComponent(options, extraOptions);
9457    if (isPlainObject(Comp))
9458      extend(Comp, extraOptions);
9459    class VueCustomElement extends VueElement {
9460      constructor(initialProps) {
9461        super(Comp, initialProps, _createApp);
9462      }
9463    }
9464    VueCustomElement.def = Comp;
9465    return VueCustomElement;
9466  }
9467  /*! #__NO_SIDE_EFFECTS__ */
9468  const defineSSRCustomElement = /* @__NO_SIDE_EFFECTS__ */ (options, extraOptions) => {
9469    return /* @__PURE__ */ defineCustomElement(options, extraOptions, createSSRApp);
9470  };
9471  const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {
9472  };
9473  class VueElement extends BaseClass {
9474    constructor(_def, _props = {}, _createApp = createApp) {
9475      super();
9476      this._def = _def;
9477      this._props = _props;
9478      this._createApp = _createApp;
9479      this._isVueCE = true;
9480      this._instance = null;
9481      this._app = null;
9482      this._nonce = this._def.nonce;
9483      this._connected = false;
9484      this._resolved = false;
9485      this._numberProps = null;
9486      this._styleChildren = /* @__PURE__ */ new WeakSet();
9487      this._ob = null;
9488      if (this.shadowRoot && _createApp !== createApp) {
9489        this._root = this.shadowRoot;
9490      } else {
9491        if (_def.shadowRoot !== false) {
9492          this.attachShadow({ mode: "open" });
9493          this._root = this.shadowRoot;
9494        } else {
9495          this._root = this;
9496        }
9497      }
9498      if (!this._def.__asyncLoader) {
9499        this._resolveProps(this._def);
9500      }
9501    }
9502    connectedCallback() {
9503      if (!this.isConnected)
9504        return;
9505      if (!this.shadowRoot) {
9506        this._parseSlots();
9507      }
9508      this._connected = true;
9509      let parent = this;
9510      while (parent = parent && (parent.parentNode || parent.host)) {
9511        if (parent instanceof VueElement) {
9512          this._parent = parent;
9513          break;
9514        }
9515      }
9516      if (!this._instance) {
9517        if (this._resolved) {
9518          this._setParent();
9519          this._update();
9520        } else {
9521          if (parent && parent._pendingResolve) {
9522            this._pendingResolve = parent._pendingResolve.then(() => {
9523              this._pendingResolve = void 0;
9524              this._resolveDef();
9525            });
9526          } else {
9527            this._resolveDef();
9528          }
9529        }
9530      }
9531    }
9532    _setParent(parent = this._parent) {
9533      if (parent) {
9534        this._instance.parent = parent._instance;
9535        this._instance.provides = parent._instance.provides;
9536      }
9537    }
9538    disconnectedCallback() {
9539      this._connected = false;

9540      nextTick(() => {
9541        if (!this._connected) {
9542          if (this._ob) {
9543            this._ob.disconnect();
9544            this._ob = null;
9545          }
9546          this._app && this._app.unmount();
9547          if (this._instance)
9548            this._instance.ce = void 0;
9549          this._app = this._instance = null;
9550        }
9551      });
9552    }
9553    /**
9554     * resolve inner component definition (handle possible async component)
9555     */
9556    _resolveDef() {
9557      if (this._pendingResolve) {
9558        return;
9559      }
9560      for (let i = 0; i < this.attributes.length; i++) {
9561        this._setAttr(this.attributes[i].name);
9562      }
9563      this._ob = new MutationObserver((mutations) => {
9564        for (const m of mutations) {
9565          this._setAttr(m.attributeName);
9566        }
9567      });
9568      this._ob.observe(this, { attributes: true });
9569      const resolve2 = (def2, isAsync = false) => {
9570        this._resolved = true;
9571        this._pendingResolve = void 0;
9572        const { props, styles } = def2;
9573        let numberProps;
9574        if (props && !isArray(props)) {
9575          for (const key in props) {
9576            const opt = props[key];
9577            if (opt === Number || opt && opt.type === Number) {
9578              if (key in this._props) {
9579                this._props[key] = toNumber(this._props[key]);
9580              }
9581              (numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[camelize(key)] = true;
9582            }
9583          }
9584        }
9585        this._numberProps = numberProps;
9586        if (isAsync) {
9587          this._resolveProps(def2);
9588        }
9589        if (this.shadowRoot) {
9590          this._applyStyles(styles);
9591        }
9592        this._mount(def2);
9593      };
9594      const asyncDef = this._def.__asyncLoader;
9595      if (asyncDef) {
9596        this._pendingResolve = asyncDef().then(
9597          (def2) => resolve2(this._def = def2, true)
9598        );
9599      } else {
9600        resolve2(this._def);
9601      }
9602    }
9603    _mount(def2) {
9604      this._app = this._createApp(def2);
9605      if (def2.configureApp) {
9606        def2.configureApp(this._app);
9607      }
9608      this._app._ceVNode = this._createVNode();
9609      this._app.mount(this._root);
9610      const exposed = this._instance && this._instance.exposed;
9611      if (!exposed)
9612        return;
9613      for (const key in exposed) {
9614        if (!hasOwn(this, key)) {
9615          Object.defineProperty(this, key, {
9616            // unwrap ref to be consistent with public instance behavior
9617            get: () => unref(exposed[key])
9618          });
9619        }
9620      }
9621    }
9622    _resolveProps(def2) {
9623      const { props } = def2;
9624      const declaredPropKeys = isArray(props) ? props : Object.keys(props || {});
9625      for (const key of Object.keys(this)) {
9626        if (key[0] !== "_" && declaredPropKeys.includes(key)) {
9627          this._setProp(key, this[key]);
9628        }
9629      }
9630      for (const key of declaredPropKeys.map(camelize)) {
9631        Object.defineProperty(this, key, {
9632          get() {
9633            return this._getProp(key);
9634          },
9635          set(val) {
9636            this._setProp(key, val, true, true);
9637          }
9638        });
9639      }
9640    }
9641    _setAttr(key) {
9642      if (key.startsWith("data-v-"))
9643        return;
9644      const has = this.hasAttribute(key);
9645      let value = has ? this.getAttribute(key) : REMOVAL;
9646      const camelKey = camelize(key);
9647      if (has && this._numberProps && this._numberProps[camelKey]) {
9648        value = toNumber(value);
9649      }
9650      this._setProp(camelKey, value, false, true);
9651    }
9652    /**
9653     * @internal
9654     */
9655    _getProp(key) {
9656      return this._props[key];
9657    }
9658    /**
9659     * @internal
9660     */
9661    _setProp(key, val, shouldReflect = true, shouldUpdate = false) {
9662      if (val !== this._props[key]) {
9663        if (val === REMOVAL) {
9664          delete this._props[key];
9665        } else {
9666          this._props[key] = val;
9667          if (key === "key" && this._app) {
9668            this._app._ceVNode.key = val;
9669          }
9670        }
9671        if (shouldUpdate && this._instance) {
9672          this._update();
9673        }
9674        if (shouldReflect) {
9675          if (val === true) {
9676            this.setAttribute(hyphenate(key), "");
9677          } else if (typeof val === "string" || typeof val === "number") {
9678            this.setAttribute(hyphenate(key), val + "");
9679          } else if (!val) {
9680            this.removeAttribute(hyphenate(key));
9681          }
9682        }
9683      }
9684    }
9685    _update() {
9686      render(this._createVNode(), this._root);
9687    }
9688    _createVNode() {
9689      const baseProps = {};
9690      if (!this.shadowRoot) {
9691        baseProps.onVnodeMounted = baseProps.onVnodeUpdated = this._renderSlots.bind(this);
9692      }
9693      const vnode = createVNode(this._def, extend(baseProps, this._props));
9694      if (!this._instance) {
9695        vnode.ce = (instance) => {
9696          this._instance = instance;
9697          instance.ce = this;
9698          instance.isCE = true;
9699          const dispatch = (event, args) => {
9700            this.dispatchEvent(
9701              new CustomEvent(
9702                event,
9703                isPlainObject(args[0]) ? extend({ detail: args }, args[0]) : { detail: args }
9704              )
9705            );
9706          };
9707          instance.emit = (event, ...args) => {
9708            dispatch(event, args);
9709            if (hyphenate(event) !== event) {
9710              dispatch(hyphenate(event), args);
9711            }
9712          };
9713          this._setParent();
9714        };
9715      }
9716      return vnode;
9717    }
9718    _applyStyles(styles, owner) {
9719      if (!styles)
9720        return;
9721      if (owner) {
9722        if (owner === this._def || this._styleChildren.has(owner)) {
9723          return;
9724        }
9725        this._styleChildren.add(owner);
9726      }
9727      const nonce = this._nonce;
9728      for (let i = styles.length - 1; i >= 0; i--) {
9729        const s = document.createElement("style");
9730        if (nonce)
9731          s.setAttribute("nonce", nonce);
9732        s.textContent = styles[i];

9733        this.shadowRoot.prepend(s);
9734      }
9735    }
9736    /**
9737     * Only called when shadowRoot is false
9738     */
9739    _parseSlots() {
9740      const slots = this._slots = {};
9741      let n;
9742      while (n = this.firstChild) {
9743        const slotName = n.nodeType === 1 && n.getAttribute("slot") || "default";
9744        (slots[slotName] || (slots[slotName] = [])).push(n);
9745        this.removeChild(n);
9746      }
9747    }
9748    /**
9749     * Only called when shadowRoot is false
9750     */
9751    _renderSlots() {
9752      const outlets = (this._teleportTarget || this).querySelectorAll("slot");
9753      const scopeId = this._instance.type.__scopeId;
9754      for (let i = 0; i < outlets.length; i++) {
9755        const o = outlets[i];
9756        const slotName = o.getAttribute("name") || "default";
9757        const content = this._slots[slotName];
9758        const parent = o.parentNode;
9759        if (content) {
9760          for (const n of content) {
9761            if (scopeId && n.nodeType === 1) {
9762              const id = scopeId + "-s";
9763              const walker = document.createTreeWalker(n, 1);
9764              n.setAttribute(id, "");
9765              let child;
9766              while (child = walker.nextNode()) {
9767                child.setAttribute(id, "");
9768              }
9769            }
9770            parent.insertBefore(n, o);
9771          }
9772        } else {
9773          while (o.firstChild)
9774            parent.insertBefore(o.firstChild, o);
9775        }
9776        parent.removeChild(o);
9777      }
9778    }
9779    /**
9780     * @internal
9781     */
9782    _injectChildStyle(comp) {
9783      this._applyStyles(comp.styles, comp);
9784    }
9785    /**
9786     * @internal
9787     */
9788    _removeChildStyle(comp) {
9789    }
9790  }
9791  function useHost(caller) {
9792    const instance = getCurrentInstance();
9793    const el = instance && instance.ce;
9794    if (el) {
9795      return el;
9796    }
9797    return null;
9798  }
9799  function useShadowRoot() {
9800    const el = useHost();
9801    return el && el.shadowRoot;
9802  }
9803  function useCssModule(name = "$style") {
9804    {
9805      const instance = getCurrentInstance();
9806      if (!instance) {
9807        return EMPTY_OBJ;
9808      }
9809      const modules = instance.type.__cssModules;
9810      if (!modules) {
9811        return EMPTY_OBJ;
9812      }
9813      const mod = modules[name];
9814      if (!mod) {
9815        return EMPTY_OBJ;
9816      }
9817      return mod;
9818    }
9819  }
9820  const positionMap = /* @__PURE__ */ new WeakMap();
9821  const newPositionMap = /* @__PURE__ */ new WeakMap();
9822  const moveCbKey = Symbol("_moveCb");
9823  const enterCbKey = Symbol("_enterCb");
9824  const decorate = (t) => {
9825    delete t.props.mode;
9826    return t;
9827  };
9828  const TransitionGroupImpl = /* @__PURE__ */ decorate({
9829    name: "TransitionGroup",
9830    props: /* @__PURE__ */ extend({}, TransitionPropsValidators, {
9831      tag: String,
9832      moveClass: String
9833    }),
9834    setup(props, { slots }) {
9835      const instance = getCurrentInstance();
9836      const state = useTransitionState();
9837      let prevChildren;
9838      let children;
9839      onUpdated(() => {
9840        if (!prevChildren.length) {
9841          return;
9842        }
9843        const moveClass = props.moveClass || `${props.name || "v"}-move`;
9844        if (!hasCSSTransform(
9845          prevChildren[0].el,
9846          instance.vnode.el,
9847          moveClass
9848        )) {
9849          return;
9850        }
9851        prevChildren.forEach(callPendingCbs);
9852        prevChildren.forEach(recordPosition);
9853        const movedChildren = prevChildren.filter(applyTranslation);
9854        forceReflow();
9855        movedChildren.forEach((c) => {
9856          const el = c.el;
9857          const style = el.style;
9858          addTransitionClass(el, moveClass);
9859          style.transform = style.webkitTransform = style.transitionDuration = "";
9860          const cb = el[moveCbKey] = (e) => {
9861            if (e && e.target !== el) {
9862              return;
9863            }
9864            if (!e || /transform$/.test(e.propertyName)) {
9865              el.removeEventListener("transitionend", cb);
9866              el[moveCbKey] = null;
9867              removeTransitionClass(el, moveClass);
9868            }
9869          };
9870          el.addEventListener("transitionend", cb);
9871        });
9872      });
9873      return () => {
9874        const rawProps = toRaw(props);
9875        const cssTransitionProps = resolveTransitionProps(rawProps);
9876        let tag = rawProps.tag || Fragment;
9877        prevChildren = [];
9878        if (children) {
9879          for (let i = 0; i < children.length; i++) {
9880            const child = children[i];
9881            if (child.el && child.el instanceof Element) {
9882              prevChildren.push(child);
9883              setTransitionHooks(
9884                child,
9885                resolveTransitionHooks(
9886                  child,
9887                  cssTransitionProps,
9888                  state,
9889                  instance
9890                )
9891              );
9892              positionMap.set(
9893                child,
9894                child.el.getBoundingClientRect()
9895              );
9896            }
9897          }
9898        }
9899        children = slots.default ? getTransitionRawChildren(slots.default()) : [];
9900        for (let i = 0; i < children.length; i++) {
9901          const child = children[i];
9902          if (child.key != null) {
9903            setTransitionHooks(
9904              child,
9905              resolveTransitionHooks(child, cssTransitionProps, state, instance)
9906            );
9907          }
9908        }
9909        return createVNode(tag, null, children);
9910      };
9911    }
9912  });
9913  const TransitionGroup = TransitionGroupImpl;
9914  function callPendingCbs(c) {
9915    const el = c.el;
9916    if (el[moveCbKey]) {
9917      el[moveCbKey]();
9918    }
9919    if (el[enterCbKey]) {
9920      el[enterCbKey]();
9921    }
9922  }
9923  function recordPosition(c) {
9924    newPositionMap.set(c, c.el.getBoundingClientRect());
9925  }
9926  function applyTranslation(c) {
9927    const oldPos = positionMap.get(c);
9928    const newPos = newPositionMap.get(c);
9929    const dx = oldPos.left - newPos.left;
9930    const dy = oldPos.top - newPos.top;
9931    if (dx || dy) {
9932      const s = c.el.style;
9933      s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
9934      s.transitionDuration = "0s";
9935      return c;
9936    }
9937  }
9938  function hasCSSTransform(el, root, moveClass) {
9939    const clone = el.cloneNode();
9940    const _vtc = el[vtcKey];
9941    if (_vtc) {

9942      _vtc.forEach((cls) => {
9943        cls.split(/\s+/).forEach((c) => c && clone.classList.remove(c));
9944      });
9945    }
9946    moveClass.split(/\s+/).forEach((c) => c && clone.classList.add(c));
9947    clone.style.display = "none";
9948    const container = root.nodeType === 1 ? root : root.parentNode;
9949    container.appendChild(clone);
9950    const { hasTransform } = getTransitionInfo(clone);
9951    container.removeChild(clone);
9952    return hasTransform;
9953  }
9954  const getModelAssigner = (vnode) => {
9955    const fn = vnode.props["onUpdate:modelValue"] || false;
9956    return isArray(fn) ? (value) => invokeArrayFns(fn, value) : fn;
9957  };
9958  function onCompositionStart(e) {
9959    e.target.composing = true;
9960  }
9961  function onCompositionEnd(e) {
9962    const target = e.target;
9963    if (target.composing) {
9964      target.composing = false;
9965      target.dispatchEvent(new Event("input"));
9966    }
9967  }
9968  const assignKey = Symbol("_assign");
9969  const vModelText = {
9970    created(el, { modifiers: { lazy, trim, number } }, vnode) {
9971      el[assignKey] = getModelAssigner(vnode);
9972      const castToNumber = number || vnode.props && vnode.props.type === "number";
9973      addEventListener(el, lazy ? "change" : "input", (e) => {
9974        if (e.target.composing)
9975          return;
9976        let domValue = el.value;
9977        if (trim) {
9978          domValue = domValue.trim();
9979        }
9980        if (castToNumber) {
9981          domValue = looseToNumber(domValue);
9982        }
9983        el[assignKey](domValue);
9984      });
9985      if (trim) {
9986        addEventListener(el, "change", () => {
9987          el.value = el.value.trim();
9988        });
9989      }
9990      if (!lazy) {
9991        addEventListener(el, "compositionstart", onCompositionStart);
9992        addEventListener(el, "compositionend", onCompositionEnd);
9993        addEventListener(el, "change", onCompositionEnd);
9994      }
9995    },
9996    // set value on mounted so it's after min/max for type="range"
9997    mounted(el, { value }) {
9998      el.value = value == null ? "" : value;
9999    },
10000    beforeUpdate(el, { value, oldValue, modifiers: { lazy, trim, number } }, vnode) {
10001      el[assignKey] = getModelAssigner(vnode);
10002      if (el.composing)
10003        return;
10004      const elValue = (number || el.type === "number") && !/^0\d/.test(el.value) ? looseToNumber(el.value) : el.value;
10005      const newValue = value == null ? "" : value;
10006      if (elValue === newValue) {
10007        return;
10008      }
10009      if (document.activeElement === el && el.type !== "range") {
10010        if (lazy && value === oldValue) {
10011          return;
10012        }
10013        if (trim && el.value.trim() === newValue) {
10014          return;
10015        }
10016      }
10017      el.value = newValue;
10018    }
10019  };
10020  const vModelCheckbox = {
10021    // #4096 array checkboxes need to be deep traversed
10022    deep: true,
10023    created(el, _, vnode) {
10024      el[assignKey] = getModelAssigner(vnode);
10025      addEventListener(el, "change", () => {
10026        const modelValue = el._modelValue;
10027        const elementValue = getValue(el);
10028        const checked = el.checked;
10029        const assign = el[assignKey];
10030        if (isArray(modelValue)) {
10031          const index2 = looseIndexOf(modelValue, elementValue);
10032          const found = index2 !== -1;
10033          if (checked && !found) {
10034            assign(modelValue.concat(elementValue));
10035          } else if (!checked && found) {
10036            const filtered = [...modelValue];
10037            filtered.splice(index2, 1);
10038            assign(filtered);
10039          }
10040        } else if (isSet(modelValue)) {
10041          const cloned = new Set(modelValue);
10042          if (checked) {
10043            cloned.add(elementValue);
10044          } else {
10045            cloned.delete(elementValue);
10046          }
10047          assign(cloned);
10048        } else {
10049          assign(getCheckboxValue(el, checked));
10050        }
10051      });
10052    },
10053    // set initial checked on mount to wait for true-value/false-value
10054    mounted: setChecked,
10055    beforeUpdate(el, binding, vnode) {
10056      el[assignKey] = getModelAssigner(vnode);
10057      setChecked(el, binding, vnode);
10058    }
10059  };
10060  function setChecked(el, { value, oldValue }, vnode) {
10061    el._modelValue = value;
10062    let checked;
10063    if (isArray(value)) {
10064      checked = looseIndexOf(value, vnode.props.value) > -1;
10065    } else if (isSet(value)) {
10066      checked = value.has(vnode.props.value);
10067    } else {
10068      if (value === oldValue)
10069        return;
10070      checked = looseEqual(value, getCheckboxValue(el, true));
10071    }
10072    if (el.checked !== checked) {
10073      el.checked = checked;
10074    }
10075  }
10076  const vModelRadio = {
10077    created(el, { value }, vnode) {
10078      el.checked = looseEqual(value, vnode.props.value);
10079      el[assignKey] = getModelAssigner(vnode);
10080      addEventListener(el, "change", () => {
10081        el[assignKey](getValue(el));
10082      });
10083    },
10084    beforeUpdate(el, { value, oldValue }, vnode) {
10085      el[assignKey] = getModelAssigner(vnode);
10086      if (value !== oldValue) {
10087        el.checked = looseEqual(value, vnode.props.value);
10088      }
10089    }
10090  };
10091  const vModelSelect = {
10092    // <select multiple> value need to be deep traversed
10093    deep: true,
10094    created(el, { value, modifiers: { number } }, vnode) {
10095      const isSetModel = isSet(value);
10096      addEventListener(el, "change", () => {
10097        const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map(
10098          (o) => number ? looseToNumber(getValue(o)) : getValue(o)
10099        );
10100        el[assignKey](
10101          el.multiple ? isSetModel ? new Set(selectedVal) : selectedVal : selectedVal[0]
10102        );
10103        el._assigning = true;
10104        nextTick(() => {
10105          el._assigning = false;

vendor: 5,446 bytes, lines 10106-10278

10106        });
10107      });
10108      el[assignKey] = getModelAssigner(vnode);
10109    },
10110    // set value in mounted & updated because <select> relies on its children
10111    // <option>s.
10112    mounted(el, { value }) {
10113      setSelected(el, value);
10114    },
10115    beforeUpdate(el, _binding, vnode) {
10116      el[assignKey] = getModelAssigner(vnode);
10117    },
10118    updated(el, { value }) {
10119      if (!el._assigning) {
10120        setSelected(el, value);
10121      }
10122    }
10123  };
10124  function setSelected(el, value) {
10125    const isMultiple = el.multiple;
10126    const isArrayValue = isArray(value);
10127    if (isMultiple && !isArrayValue && !isSet(value)) {
10128      return;
10129    }
10130    for (let i = 0, l = el.options.length; i < l; i++) {
10131      const option = el.options[i];
10132      const optionValue = getValue(option);
10133      if (isMultiple) {
10134        if (isArrayValue) {
10135          const optionType = typeof optionValue;
10136          if (optionType === "string" || optionType === "number") {
10137            option.selected = value.some((v) => String(v) === String(optionValue));
10138          } else {
10139            option.selected = looseIndexOf(value, optionValue) > -1;
10140          }
10141        } else {
10142          option.selected = value.has(optionValue);
10143        }
10144      } else if (looseEqual(getValue(option), value)) {
10145        if (el.selectedIndex !== i)
10146          el.selectedIndex = i;
10147        return;
10148      }
10149    }
10150    if (!isMultiple && el.selectedIndex !== -1) {
10151      el.selectedIndex = -1;
10152    }
10153  }
10154  function getValue(el) {
10155    return "_value" in el ? el._value : el.value;
10156  }
10157  function getCheckboxValue(el, checked) {
10158    const key = checked ? "_trueValue" : "_falseValue";
10159    return key in el ? el[key] : checked;
10160  }
10161  const vModelDynamic = {
10162    created(el, binding, vnode) {
10163      callModelHook(el, binding, vnode, null, "created");
10164    },
10165    mounted(el, binding, vnode) {
10166      callModelHook(el, binding, vnode, null, "mounted");
10167    },
10168    beforeUpdate(el, binding, vnode, prevVNode) {
10169      callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
10170    },
10171    updated(el, binding, vnode, prevVNode) {
10172      callModelHook(el, binding, vnode, prevVNode, "updated");
10173    }
10174  };
10175  function resolveDynamicModel(tagName, type) {
10176    switch (tagName) {
10177      case "SELECT":
10178        return vModelSelect;
10179      case "TEXTAREA":
10180        return vModelText;
10181      default:
10182        switch (type) {
10183          case "checkbox":
10184            return vModelCheckbox;
10185          case "radio":
10186            return vModelRadio;
10187          default:
10188            return vModelText;
10189        }
10190    }
10191  }
10192  function callModelHook(el, binding, vnode, prevVNode, hook) {
10193    const modelToUse = resolveDynamicModel(
10194      el.tagName,
10195      vnode.props && vnode.props.type
10196    );
10197    const fn = modelToUse[hook];
10198    fn && fn(el, binding, vnode, prevVNode);
10199  }
10200  function initVModelForSSR() {
10201    vModelText.getSSRProps = ({ value }) => ({ value });
10202    vModelRadio.getSSRProps = ({ value }, vnode) => {
10203      if (vnode.props && looseEqual(vnode.props.value, value)) {
10204        return { checked: true };
10205      }
10206    };
10207    vModelCheckbox.getSSRProps = ({ value }, vnode) => {
10208      if (isArray(value)) {
10209        if (vnode.props && looseIndexOf(value, vnode.props.value) > -1) {
10210          return { checked: true };
10211        }
10212      } else if (isSet(value)) {
10213        if (vnode.props && value.has(vnode.props.value)) {
10214          return { checked: true };
10215        }
10216      } else if (value) {
10217        return { checked: true };
10218      }
10219    };
10220    vModelDynamic.getSSRProps = (binding, vnode) => {
10221      if (typeof vnode.type !== "string") {
10222        return;
10223      }
10224      const modelToUse = resolveDynamicModel(
10225        // resolveDynamicModel expects an uppercase tag name, but vnode.type is lowercase
10226        vnode.type.toUpperCase(),
10227        vnode.props && vnode.props.type
10228      );
10229      if (modelToUse.getSSRProps) {
10230        return modelToUse.getSSRProps(binding, vnode);
10231      }
10232    };
10233  }
10234  const systemModifiers = ["ctrl", "shift", "alt", "meta"];
10235  const modifierGuards = {
10236    stop: (e) => e.stopPropagation(),
10237    prevent: (e) => e.preventDefault(),
10238    self: (e) => e.target !== e.currentTarget,
10239    ctrl: (e) => !e.ctrlKey,
10240    shift: (e) => !e.shiftKey,
10241    alt: (e) => !e.altKey,
10242    meta: (e) => !e.metaKey,
10243    left: (e) => "button" in e && e.button !== 0,
10244    middle: (e) => "button" in e && e.button !== 1,
10245    right: (e) => "button" in e && e.button !== 2,
10246    exact: (e, modifiers) => systemModifiers.some((m) => e[`${m}Key`] && !modifiers.includes(m))
10247  };
10248  const withModifiers = (fn, modifiers) => {
10249    const cache = fn._withMods || (fn._withMods = {});
10250    const cacheKey = modifiers.join(".");
10251    return cache[cacheKey] || (cache[cacheKey] = (event, ...args) => {
10252      for (let i = 0; i < modifiers.length; i++) {
10253        const guard = modifierGuards[modifiers[i]];
10254        if (guard && guard(event, modifiers))
10255          return;
10256      }
10257      return fn(event, ...args);
10258    });
10259  };
10260  const keyNames = {
10261    esc: "escape",
10262    space: " ",
10263    up: "arrow-up",
10264    left: "arrow-left",
10265    right: "arrow-right",
10266    down: "arrow-down",
10267    delete: "backspace"
10268  };
10269  const withKeys = (fn, modifiers) => {
10270    const cache = fn._withKeys || (fn._withKeys = {});
10271    const cacheKey = modifiers.join(".");
10272    return cache[cacheKey] || (cache[cacheKey] = (event) => {
10273      if (!("key" in event)) {
10274        return;
10275      }
10276      const eventKey = hyphenate(event.key);
10277      if (modifiers.some(
10278        (k) =>

10278 k === eventKey || keyNames[k] === eventKey
10279      )) {
10280        return fn(event);
10281      }
10282    });
10283  };
10284  const rendererOptions = /* @__PURE__ */ extend({ patchProp }, nodeOps);
10285  let renderer;
10286  let enabledHydration = false;
10287  function ensureRenderer() {
10288    return renderer || (renderer = createRenderer(rendererOptions));
10289  }
10290  function ensureHydrationRenderer() {
10291    renderer = enabledHydration ? renderer : createHydrationRenderer(rendererOptions);
10292    enabledHydration = true;
10293    return renderer;
10294  }
10295  const render = (...args) => {
10296    ensureRenderer().render(...args);
10297  };
10298  const hydrate = (...args) => {
10299    ensureHydrationRenderer().hydrate(...args);
10300  };
10301  const createApp = (...args) => {
10302    const app = ensureRenderer().createApp(...args);
10303    const { mount } = app;
10304    app.mount = (containerOrSelector) => {
10305      const container = normalizeContainer(containerOrSelector);
10306      if (!container)
10307        return;
10308      const component = app._component;
10309      if (!isFunction(component) && !component.render && !component.template) {
10310        component.template = container.innerHTML;
10311      }
10312      if (container.nodeType === 1) {
10313        container.textContent = "";
10314      }
10315      const proxy = mount(container, false, resolveRootNamespace(container));
10316      if (container instanceof Element) {
10317        container.removeAttribute("v-cloak");
10318        container.setAttribute("data-v-app", "");
10319      }
10320      return proxy;
10321    };
10322    return app;
10323  };
10324  const createSSRApp = (...args) => {
10325    const app = ensureHydrationRenderer().createApp(...args);
10326    const { mount } = app;
10327    app.mount = (containerOrSelector) => {
10328      const container = normalizeContainer(containerOrSelector);
10329      if (container) {
10330        return mount(container, true, resolveRootNamespace(container));
10331      }
10332    };
10333    return app;
10334  };
10335  function resolveRootNamespace(container) {
10336    if (container instanceof SVGElement) {
10337      return "svg";
10338    }
10339    if (typeof MathMLElement === "function" && container instanceof MathMLElement) {
10340      return "mathml";
10341    }
10342  }
10343  function normalizeContainer(container) {
10344    if (isString(container)) {
10345      const res = document.querySelector(container);
10346      return res;
10347    }
10348    return container;
10349  }
10350  let ssrDirectiveInitialized = false;
10351  const initDirectivesForSSR = () => {
10352    if (!ssrDirectiveInitialized) {
10353      ssrDirectiveInitialized = true;
10354      initVModelForSSR();
10355      initVShowForSSR();
10356    }
10357  };
10358  /**
10359  * vue v3.5.12
10360  * (c) 2018-present Yuxi (Evan) You and Vue contributors
10361  * @license MIT
10362  **/
10363  const compile = () => {
10364  };
10365  const vue_runtime_esmBundler = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
10366    __proto__: null,
10367    BaseTransition,
10368    BaseTransitionPropsValidators,
10369    Comment,
10370    DeprecationTypes,
10371    EffectScope,
10372    ErrorCodes,
10373    ErrorTypeStrings,
10374    Fragment,
10375    KeepAlive,
10376    ReactiveEffect,
10377    Static,
10378    Suspense,
10379    Teleport,
10380    Text,
10381    TrackOpTypes,
10382    Transition,
10383    TransitionGroup,
10384    TriggerOpTypes,
10385    VueElement,
10386    assertNumber,
10387    callWithAsyncErrorHandling,
10388    callWithErrorHandling,
10389    camelize,
10390    capitalize,
10391    cloneVNode,
10392    compatUtils,
10393    compile,
10394    computed,
10395    createApp,
10396    createBlock,
10397    createCommentVNode,
10398    createElementBlock,
10399    createElementVNode: createBaseVNode,
10400    createHydrationRenderer,
10401    createPropsRestProxy,
10402    createRenderer,
10403    createSSRApp,
10404    createSlots,
10405    createStaticVNode,
10406    createTextVNode,
10407    createVNode,
10408    customRef,
10409    defineAsyncComponent,
10410    defineComponent,
10411    defineCustomElement,
10412    defineEmits,
10413    defineExpose,
10414    defineModel,
10415    defineOptions,
10416    defineProps,
10417    defineSSRCustomElement,
10418    defineSlots,
10419    devtools,
10420    effect,
10421    effectScope,
10422    getCurrentInstance,
10423    getCurrentScope,
10424    getCurrentWatcher,
10425    getTransitionRawChildren,
10426    guardReactiveProps,
10427    h,
10428    handleError,
10429    hasInjectionContext,
10430    hydrate,
10431    hydrateOnIdle,
10432    hydrateOnInteraction,
10433    hydrateOnMediaQuery,
10434    hydrateOnVisible,
10435    initCustomFormatter,
10436    initDirectivesForSSR,
10437    inject,
10438    isMemoSame,
10439    isProxy,
10440    isReactive,
10441    isReadonly,
10442    isRef,
10443    isRuntimeOnly,
10444    isShallow,
10445    isVNode,
10446    markRaw,
10447    mergeDefaults,
10448    mergeModels,
10449    mergeProps,
10450    nextTick,
10451    normalizeClass,
10452    normalizeProps,
10453    normalizeStyle,
10454    onActivated,
10455    onBeforeMount,
10456    onBeforeUnmount,
10457    onBeforeUpdate,
10458    onDeactivated,
10459    onErrorCaptured,
10460    onMounted,
10461    onRenderTracked,
10462    onRenderTriggered,
10463    onScopeDispose,
10464    onServerPrefetch,
10465    onUnmounted,
10466    onUpdated,
10467    onWatcherCleanup,
10468    openBlock,
10469    popScopeId,
10470    provide,
10471    proxyRefs,
10472    pushScopeId,
10473    queuePostFlushCb,
10474    reactive,
10475    readonly,
10476    ref,
10477    registerRuntimeCompiler,
10478    render,
10479    renderList,
10480    renderSlot,
10481    resolveComponent,
10482    resolveDirective,
10483    resolveDynamicComponent,
10484    resolveFilter,
10485    resolveTransitionHooks,
10486    setBlockTracking,
10487    setDevtoolsHook,
10488    setTransitionHooks,
10489    shallowReactive,
10490    shallowReadonly,
10491    shallowRef,
10492    ssrContextKey,
10493    ssrUtils,
10494    stop,
10495    toDisplayString,
10496    toHandlerKey,
10497    toHandlers,
10498    toRaw,
10499    toRef,
10500    toRefs,
10501    toValue,
10502    transformVNodeArgs,
10503    triggerRef,
10504    unref,
10505    useAttrs,
10506    useCssModule,
10507    useCssVars,
10508    useHost,
10509    useId,
10510    useModel,
10511    useSSRContext,
10512    useShadowRoot,
10513    useSlots,
10514    useTemplateRef,
10515    useTransitionState,
10516    vModelCheckbox,
10517    vModelDynamic,
10518    vModelRadio,
10519    vModelSelect,
10520    vModelText,
10521    vShow,
10522    version,
10523    warn,
10524    watch,
10525    watchEffect,
10526    watchPostEffect,
10527    watchSyncEffect,
10528    withAsyncContext,
10529    withCtx,
10530    withDefaults,
10531    withDirectives,
10532    withKeys,
10533    withMemo,
10534    withModifiers,
10535    withScopeId
10536  }, Symbol.toStringTag, { value: "Module" }));
10537  const _sfc_main$8 = /* @__PURE__ */ defineComponent({
10538    __name: "TestFeature",
10539    setup(__props) {
10540      const hello = ref();
10541      setInterval(() => {
10542        if (!hello.value)
10543          return;
10544        hello.value.style.color = hello.value.style.color === "red" ? "black" : "red";
10545      }, 500);
10546      return (_ctx, _cache) => {
10547        return openBlock(), createElementBlock("div", {
10548          ref_key: "hello",
10549          ref: hello
10550        }, " Hello World ", 512);
10551      };
10552    }
10553  });
10554  const _hoisted_1$7 = {
10555    key: 0,
10556    class: "c-section-header__title"
10557  };
10558  const _hoisted_2$5 = { key: 0 };
10559  const _hoisted_3$5 = { key: 1 };
10560  const _hoisted_4$3 = {
10561    key: 2,
10562    class: "s-wysiwyg"
10563  };
10564  const _hoisted_5$3 = ["innerHTML"];
10565  const _sfc_main$7 = /* @__PURE__ */ defineComponent({
10566    __name: "SectionHeader",
10567    props: {
10568      size: {
10569        type: String,
10570        default: ""
10571        // Provide a default value if necessary
10572      },
10573      center: {
10574        type: Boolean,
10575        default: false
10576      },
10577      title: {
10578        type: String,
10579        default: ""
10580      },
10581      text: {
10582        type: String,
10583        default: ""
10584      }
10585    },
10586    setup(__props) {
10587      const props = __props;
10588      const centerClass = computed(() => props.center ? "c-section-header--center container-col6" : "");
10589      const hasContent = computed(() => props.title || props.text);
10590      return (_ctx, _cache) => {
10591        return openBlock(), createElementBlock("div", {
10592          class: normalizeClass(["c-section-header", [centerClass.value]])
10593        }, [
10594          hasContent.value ? (openBlock(), createElementBlock("div", _hoisted_1$7, [
10595            __props.title && __props.size === "Small" ? (openBlock(), createElementBlock("h2", _hoisted_2$5, toDisplayString(__props.title), 1)) : __props.title ? (openBlock(), createElementBlock("h1", _hoisted_3$5, toDisplayString(__props.title), 1)) : createCommentVNode("", true),
10596            __props.text ? (openBlock(), createElementBlock("div", _hoisted_4$3, [
10597              createBaseVNode("span", { innerHTML: __props.text }, null, 8, _hoisted_5$3)
10598            ])) : createCommentVNode("", true)
10599          ])) : createCommentVNode("", true)
10600        ], 2);
10601      };
10602    }
10603  });
10604  const _hoisted_1$6 = { class: "c-tab-horizontal__container" };
10605  const _sfc_main$6 = /* @__PURE__ */ defineComponent({
10606    __name: "TabHorizontal",
10607    props: {
10608      active: {
10609        type: Boolean,
10610        default: false
10611      },
10612      text: {
10613        type: String,
10614        default: ""
10615      },
10616      classes: {
10617        type: String,
10618        default: ""
10619      }
10620    },
10621    emits: ["click"],
10622    setup(__props) {
10623      return (_ctx, _cache) => {
10624        return openBlock(), createElementBlock("button", {
10625          class: normalizeClass(["c-tab-horizontal", [__props.classes, { "is-active": __props.active }]]),
10626          onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("click"))
10627        }, [
10628          createBaseVNode("span", _hoisted_1$6, toDisplayString(__props.text), 1)
10629        ], 2);
10630      };
10631    }
10632  });
10633  const _imports_0$1 = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCjxwYXRoIGQ9Ik0xMC43ODkyIDE3LjUwMDRDMTEuNDU4OSAxOC4xNzAxIDEyLjU0NjQgMTguMTcwMSAxMy4yMTYgMTcuNTAwNEwyMS43ODc0IDguOTI

106335MDJDMjIuNDU3MSA4LjI1OTM4IDIyLjQ1NzEgNy4xNzE4OCAyMS43ODc0IDYuNTAyMjNDMjEuMTE3OCA1LjgzMjU5IDIwLjAzMDMgNS44MzI1OSAxOS4zNjA3IDYuNTAyMjNMMTEuOTk5OSAxMy44NjI5TDQuNjM5MjIgNi41MDc1OUMzLjk2OTU4IDUuODM3OTUgMi44ODIwOCA1LjgzNzk1IDIuMjEyNDQgNi41MDc1OUMxLjU0Mjc5IDcuMTc3MjMgMS41NDI3OSA4LjI2NDczIDIuMjEyNDQgOC45MzQzN0wxMC43ODM5IDE3LjUwNThMMTAuNzg5MiAxNy41MDA0WiIgZmlsbD0iIzAwNEM3MSIvPg0KPC9zdmc+DQo=";
10634  const _hoisted_1$5 = ["for"];
10635  const _hoisted_2$4 = ["id", "name", "value"];
10636  const _hoisted_3$4 = ["value", "data-url", "selected"];
10637  const _sfc_main$5 = /* @__PURE__ */ defineComponent({
10638    __name: "TabHorizontalMobile",
10639    props: {
10640      classes: {
10641        type: String,
10642        default: ""
10643      },
10644      label: {
10645        type: String,
10646        default: ""
10647      },
10648      name: {
10649        type: String,
10650        default: ""
10651      },
10652      tabs: {
10653        type: Array,
10654        default: () => []
10655      },
10656      selected: {
10657        type: Object,
10658        default: null
10659      }
10660    },
10661    emits: ["change"],
10662    setup(__props) {
10663      return (_ctx, _cache) => {
10664        return __props.tabs ? (openBlock(), createElementBlock("div", {
10665          key: 0,
10666          class: normalizeClass(["c-tabs-horizontal-mobile", __props.classes])
10667        }, [
10668          createBaseVNode("label", {
10669            class: "c-tabs-horizontal-mobile__label",
10670            for: __props.name
10671          }, toDisplayString(__props.label), 9, _hoisted_1$5),
10672          createBaseVNode("select", {
10673            id: __props.name,
10674            name: __props.name,
10675            class: "c-tabs-horizontal-mobile__select",
10676            onChange: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("change", $event)),
10677            value: __props.selected.text
10678          }, [
10679            (openBlock(true), createElementBlock(Fragment, null, renderList(__props.tabs, (tab, index2) => {
10680              return openBlock(), createElementBlock("option", {
10681                key: index2,
10682                value: tab.text,
10683                "data-url": tab.url,
10684                selected: tab.active
10685              }, toDisplayString(tab.text), 9, _hoisted_3$4);
10686            }), 128))
10687          ], 40, _hoisted_2$4),
10688          _cache[1] || (_cache[1] = createBaseVNode("img", {
10689            class: "c-tabs-horizontal-mobile__icon",
10690            src: _imports_0$1,
10691            alt: "down"
10692          }, null, -1))
10693        ], 2)) : createCommentVNode("", true);
10694      };
10695    }
10696  });
10697  const _hoisted_1$4 = { key: 0 };
10698  const _sfc_main$4 = /* @__PURE__ */ defineComponent({
10699    __name: "TabsHorizontal",
10700    props: /* @__PURE__ */ mergeModels({
10701      tabs: {
10702        type: Array,
10703        required: true
10704      },
10705      classes: {
10706        type: String,
10707        default: ""
10708      },
10709      name: {
10710        type: String,
10711        default: ""
10712      },
10713      label: {
10714        type: String,
10715        default: ""
10716      }
10717    }, {
10718      "modelValue": {
10719        type: Number,
10720        required: true
10721      },
10722      "modelModifiers": {}
10723    }),
10724    emits: ["update:modelValue"],
10725    setup(__props) {
10726      const selectedIndex = useModel(__props, "modelValue");
10727      const props = __props;
10728      const onMobileTabChange = (event) => {
10729        const target = event.target;
10730        const value = target.value;
10731        selectedIndex.value = props.tabs.findIndex((tab) => tab.text === value);
10732      };
10733      return (_ctx, _cache) => {
10734        return __props.tabs ? (openBlock(), createElementBlock("div", _hoisted_1$4, [
10735          createBaseVNode("ul", {
10736            class: normalizeClass(["c-tabs-horizontal", __props.classes])
10737          }, [
10738            (openBlock(true), createElementBlock(Fragment, null, renderList(__props.tabs, (item, index2) => {
10739              return openBlock(), createElementBlock("li", {
10740                key: index2,
10741                class: "c-tabs-horizontal__item"
10742              }, [
10743                createVNode(_sfc_main$6, {
10744                  url: item.url,
10745                  target: item.target,
10746                  active: selectedIndex.value === index2,
10747                  text: item.text,
10748                  classes: item.classes,
10749                  onClick: ($event) => selectedIndex.value = index2
10750                }, null, 8, ["url", "target", "active", "text", "classes", "onClick"])
10751              ]);
10752            }), 128))
10753          ], 2),
10754          createVNode(_sfc_main$5, {

10755            tabs: __props.tabs,
10756            onChange: onMobileTabChange,
10757            selected: __props.tabs[selectedIndex.value],
10758            name: __props.name,
10759            label: __props.label
10760          }, null, 8, ["tabs", "selected", "name", "label"])
10761        ])) : createCommentVNode("", true);
10762      };
10763    }
10764  });
10765  const _hoisted_1$3 = {
10766    key: 0,
10767    class: "c-picture c-card-resource__picture"
10768  };
10769  const _hoisted_2$3 = ["src", "alt"];
10770  const _hoisted_3$3 = { class: "c-card-resource__content" };
10771  const _hoisted_4$2 = { class: "c-card-resource__header" };
10772  const _hoisted_5$2 = { class: "c-tagline" };
10773  const _hoisted_6$1 = { class: "c-card-resource__title" };
10774  const _hoisted_7 = { class: "c-card-resource__text" };
10775  const _hoisted_8 = ["target", "href"];
10776  const _hoisted_9 = {
10777    key: 0,
10778    class: "border-neutral-10 my-6 vp7:my-10 last:mt-6 last:mb-0 vp7:last:mt-10 vp7:last:mb-0"
10779  };
10780  const _sfc_main$3 = /* @__PURE__ */ defineComponent({
10781    __name: "Card",
10782    props: {
10783      imageSrc: {
10784        type: String,
10785        default: ""
10786      },
10787      imageAlt: {
10788        type: String
10789      },
10790      title: {
10791        type: String
10792      },
10793      text: {
10794        type: String
10795      },
10796      tagline: {
10797        type: String,
10798        required: false
10799      },
10800      link: {
10801        type: Object
10802      },
10803      showDivider: {
10804        type: Boolean,
10805        default: true
10806      },
10807      useHorizontalLayout: {
10808        type: Boolean,
10809        default: false
10810      }
10811    },
10812    setup(__props) {
10813      return (_ctx, _cache) => {
10814        return openBlock(), createElementBlock(Fragment, null, [
10815          createBaseVNode("div", {
10816            class: normalizeClass(["c-card-resource", { "c-card-resource--vertical": !__props.useHorizontalLayout }])
10817          }, [
10818            __props.imageSrc ? (openBlock(), createElementBlock("picture", _hoisted_1$3, [
10819              createBaseVNode("img", {
10820                src: __props.imageSrc,
10821                alt: __props.imageAlt,
10822                loading: "lazy",
10823                class: "c-picture c-card-resource__picture"
10824              }, null, 8, _hoisted_2$3)
10825            ])) : createCommentVNode("", true),
10826            createBaseVNode("div", _hoisted_3$3, [
10827              createBaseVNode("div", _hoisted_4$2, [
10828                createBaseVNode("div", _hoisted_5$2, toDisplayString(__props.tagline), 1),
10829                createBaseVNode("h3", _hoisted_6$1, toDisplayString(__props.title), 1)
10830              ]),
10831              createBaseVNode("p", _hoisted_7, toDisplayString(__props.text), 1),
10832              __props.link ? (openBlock(), createElementBlock("a", {
10833                key: 0,
10834                class: "c-link",
10835                target: __props.link.target,
10836                href: __props.link.url
10837              }, toDisplayString(__props.link.text), 9, _hoisted_8)) : createCommentVNode("", true)
10838            ])
10839          ], 2),
10840          __props.showDivider ? (openBlock(), createElementBlock("hr", _hoisted_9)) : createCommentVNode("", true)
10841        ], 64);
10842      };
10843    }
10844  });
10845  const _imports_0 = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCjxwYXRoIGQ9Ik03LjIxMDk4IDEwLjc5MDdDNi41NDEzNCAxMS40NjAzIDYuNTQxMzQgMTIuNTQ3OCA3LjIxMDk4IDEzLjIxNzVMMTUuNzgyNCAyMS43ODg5QzE2LjQ1MiAyMi40NTg1IDE3LjUzOTUgMjIuNDU4NSAxOC4yMDkyIDIxLjc4ODlDMTguODc4OCAyMS4xMTkzIDE4Ljg3ODggMjAuMDMxOCAxOC4yMDkyIDE5LjM2MjFMMTAuODQ4NSAxMi4wMDE0TDE4LjIwMzggNC42NDA2OUMxOC44NzM1IDMuOTcxMDQgMTguODczNSAyLjg4MzU0IDE4LjIwMzggMi4yMTM5QzE3LjUzNDIgMS41NDQyNiAxNi40NDY3IDEuNTQ0MjYgMTUuNzc3MSAyLjIxMzlMNy4yMDU2MiAxMC43ODUzTDcuMjEwOTggMTAuNzkwN1oiIGZpbGw9IiMwMDRDNzEiLz4NCjwvc3ZnPg0K";
10846  const _imports_1 = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCjxwYXRoIGQ9Ik0xOC4yMDk0IDEzLjIxMjFDMTguODc5MSAxMi41NDI1IDE4Ljg3OTEgMTEuNDU1IDE4LjIwOTQgMTAuNzg1M0w5LjYzOCAyLjIxMzlDOC45NjgzNiAxLjU0NDI2IDcuODgwODYgMS41NDQyNiA3LjIxMTIyIDIuMjEzOUM2LjU0MTU3IDIuODgzNTUgNi41NDE1NyAzLjk3MTA1IDcuMjExMjIgNC42NDA2OUwxNC41NzE5IDEyLjAwMTRMNy4yMTY1NyAxOS4zNjIxQzYuNTQ2OTMgMjAuMDMxOCA2LjU0NjkzIDIxLjExOTMgNy4yMTY1NyAyMS43ODg5QzcuODg2MjIgMjIuNDU4NSA4Ljk3MzcyIDIyLjQ1ODUgOS42NDMzNiAyMS43ODg5TDE4LjIxNDggMTMuMjE3NUwxOC4yMDk0IDEzLjIxMjFaIiBmaWxsPSIjMDA0QzcxIi8+DQo8L3N2Zz4NCg==";
10847  const _hoisted_1$2 = {
10848    key: 0,
10849    class: "c-pagination"
10850  };
10851  const _hoisted_2$2 = { class: "c-pagination__items" };
10852  const _hoisted_3$2 = ["onClick"];
10853  const _sfc_main$2 = /* @__PURE__ */ defineComponent({
10854    __name: "Pagination",
10855    props: /* @__PURE__ */ mergeModels({
10856      itemsPerPage: {
10857        type: Number,
10858        default: 0
10859      },
10860      amountOfPages: {
10861        type: Number,
10862        default: 0
10863      }
10864    }, {

10865      "modelValue": {
10866        type: Number,
10867        required: true
10868      },
10869      "modelModifiers": {}
10870    }),
10871    emits: ["update:modelValue"],
10872    setup(__props) {
10873      const currentPage = useModel(__props, "modelValue");
10874      const props = __props;
10875      const pageCount = computed(() => Math.ceil(props.amountOfPages / props.itemsPerPage));
10876      return (_ctx, _cache) => {
10877        return pageCount.value > 1 ? (openBlock(), createElementBlock("div", _hoisted_1$2, [
10878          currentPage.value > 1 ? (openBlock(), createElementBlock("button", {
10879            key: 0,
10880            class: "c-pagination__icon",
10881            onClick: _cache[0] || (_cache[0] = () => {
10882              currentPage.value = currentPage.value -= 1;
10883            })
10884          }, _cache[2] || (_cache[2] = [
10885            createBaseVNode("img", {
10886              src: _imports_0,
10887              alt: "previous",
10888              class: "c-icon--small"
10889            }, null, -1)
10890          ]))) : createCommentVNode("", true),
10891          createBaseVNode("div", _hoisted_2$2, [
10892            (openBlock(true), createElementBlock(Fragment, null, renderList(pageCount.value, (p2) => {
10893              return openBlock(), createElementBlock("button", {
10894                key: p2,
10895                class: normalizeClass(["c-pagination__item", { active: p2 === currentPage.value }]),
10896                onClick: () => {
10897                  currentPage.value = p2;
10898                }
10899              }, toDisplayString(p2), 11, _hoisted_3$2);
10900            }), 128))
10901          ]),

10902          currentPage.value < pageCount.value ? (openBlock(), createElementBlock("a", {
10903            key: 1,
10904            class: "c-pagination__icon",
10905            onClick: _cache[1] || (_cache[1] = ($event) => currentPage.value += 1)
10906          }, _cache[3] || (_cache[3] = [
10907            createBaseVNode("img", {
10908              src: _imports_1,
10909              alt: "next",
10910              class: "c-icon--small"
10911            }, null, -1)
10912          ]))) : createCommentVNode("", true)
10913        ])) : createCommentVNode("", true);
10914      };
10915    }
10916  });
10917  const _hoisted_1$1 = { class: "container container-space-x flex flex-col gap-10" };
10918  const _hoisted_2$1 = {
10919    key: 0,
10920    "data-aos": "fade-up"
10921  };
10922  const _hoisted_3$1 = {
10923    key: 1,
10924    "data-aos": "fade-up"
10925  };
10926  const _hoisted_4$1 = {
10927    class: "mt-6 vp7:my-10",
10928    ref: "cardsContainer"
10929  };
10930  const _hoisted_5$1 = {
10931    class: "card-container container-col8",
10932    "data-aos": "fade-up"
10933  };
10934  const _hoisted_6 = { class: "flex flex-col items-center mt-6" };
10935  const _sfc_main$1 = /* @__PURE__ */ defineComponent({
10936    __name: "TabCardResources",
10937    props: {
10938      classes: {
10939        type: String,
10940        default: ""
10941      },
10942      header: {
10943        type: Object,
10944        default: null
10945      },
10946      label: {
10947        type: String,
10948        default: ""
10949      },
10950      name: {
10951        type: String,
10952        default: ""
10953      },
10954      tabs: {
10955        type: Array,
10956        default: () => []
10957      },
10958      itemsPerPage: {
10959        type: Number,
10960        default: 5
10961      },
10962      content: {
10963        type: Array,
10964        default: () => []
10965      }
10966    },
10967    setup(__props) {
10968      const props = __props;
10969      const selectedIndex = ref(0);
10970      const selectedPage = ref(1);
10971      const top = ref(null);
10972      const amountOfPages = computed(() => {
10973        if (props.content.length === 0) {
10974          return 0;
10975        }
10976        return props.content[selectedIndex.value].length;
10977      });
10978      const cards = computed(() => {
10979        return props.content[selectedIndex.value];
10980      });
10981      const pagedCards = computed(() => {
10982        if (!cards.value || cards.value.length === 0) {
10983          return [];
10984        }
10985        if (props.itemsPerPage === 0) {
10986          return cards.value;
10987        }
10988        const start = (selectedPage.value - 1) * props.itemsPerPage;
10989        const end = start + props.itemsPerPage;
10990        return cards.value.slice(start, end);
10991      });
10992      watch(selectedIndex, () => {
10993        selectedPage.value = 1;
10994      });
10995      watch(selectedPage, () => {
10996        nextTick(() => {
10997          if (top.value) {
10998            const topPos = top.value.offsetTop;
10999            window.scrollTo({ top: topPos, behavior: "smooth" });
11000          }
11001        });
11002      });
11003      return (_ctx, _cache) => {
11004        var _a;
11005        return __props.tabs ? (openBlock(), createElementBlock("div", {
11006          key: 0,
11007          class: "section-lg",
11008          ref_key: "top",
11009          ref: top
11010        }, [
11011          createBaseVNode("div", _hoisted_1$1, [
11012            __props.header ? (openBlock(), createElementBlock("div", _hoisted_2$1, [
11013              createVNode(_sfc_main$7, {
11014                title: __props.header.title,
11015                text: __props.header.text,
11016                size: __props.header.size.toString(),
11017                center: __props.header.center
11018              }, null, 8, ["title", "text", "size", "center"])
11019            ])) : createCommentVNode("", true),
11020            ((_a = __props.tabs) == null ? void 0 : _a.length) > 0 ? (openBlock(), createElementBlock("div", _hoisted_3$1, [
11021              createVNode(_sfc_main$4, {
11022                tabs: __props.tabs,
11023                name: __props.name,
11024                label: __props.label,
11025                modelValue: selectedIndex.value,
11026                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => selectedIndex.value = $event)
11027              }, null, 8, ["tabs", "name", "label", "modelValue"]),
11028              createBaseVNode("div", _hoisted_4$1, [
11029                createBaseVNode("div", _hoisted_5$1, [
11030                  (openBlock(true), createElementBlock(Fragment, null, renderList(pagedCards.value, (card) => {
11031                    return openBlock(), createBlock(_sfc_main$3, {
11032                      key: card.key,
11033                      imageAlt: card.alt,
11034                      imageSrc: card.src,
11035                      title: card.title,
11036                      text: card.text,
11037                      link: card.link.link
11038                    }, null, 8, ["imageAlt", "imageSrc", "title", "text", "link"]);
11039                  }), 128))
11040                ]),
11041                createBaseVNode("div", _hoisted_6, [
11042                  __props.itemsPerPage && __props.itemsPerPage != 0 ? (openBlock(), createBlock(_sfc_main$2, {
11043                    key: 0,
11044                    modelValue: selectedPage.value,
11045                    "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => selectedPage.value = $event),
11046                    "items-per-page": __props.itemsPerPage,
11047                    "amount-of-pages": amountOfPages.value
11048                  }, null, 8, ["modelValue", "items-per-page", "amount-of-pages"])) : createCommentVNode("", true)
11049                ])
11050              ], 512)
11051            ])) : createCommentVNode("", true)
11052          ])
11053        ], 512)) : createCommentVNode("", true);
11054      };
11055    }
11056  });
11057  const _hoisted_1 = { class: "container container-space-x flex flex-col gap-10" };
11058  const _hoisted_2 = {
11059    key: 0,
11060    "data-aos": "fade-up"
11061  };
11062  const _hoisted_3 = { key: 1 };
11063  const _hoisted_4 = {
11064    key: 0,
11065    class: "container-col8",
11066    "data-aos": "fade-up"
11067  };
11068  const _hoisted_5 = { class: "flex flex-col items-center mt-6" };

11069  const _sfc_main = /* @__PURE__ */ defineComponent({
11070    __name: "CardResources",
11071    props: {
11072      classes: {
11073        type: String,
11074        default: ""
11075      },
11076      header: {
11077        type: Object,
11078        default: null
11079      },
11080      itemsPerPage: {
11081        type: Number,
11082        default: 0
11083      },
11084      content: {
11085        type: Array,
11086        default: () => []
11087      },
11088      cardsPerRow: {
11089        type: Number,
11090        default: 3
11091      },
11092      isVertical: {
11093        type: Boolean,
11094        default: false
11095      }
11096    },
11097    setup(__props) {
11098      const props = __props;
11099      const selectedPage = ref(1);
11100      const top = ref(null);
11101      const totalItems = computed(() => {
11102        var _a;
11103        return ((_a = props.content) == null ? void 0 : _a.length) ?? 0;
11104      });
11105      const gridColsClass = computed(() => {
11106        const value = Math.min(Math.max(props.cardsPerRow, 1), 4);
11107        switch (value) {
11108          case 1:
11109            return "vp7:grid-cols-1";
11110          case 2:
11111            return "vp7:grid-cols-2";
11112          case 4:
11113            return "vp7:grid-cols-4";
11114          default:
11115            return "vp7:grid-cols-3";
11116        }
11117      });
11118      const pagedCards = computed(() => {
11119        if (!props.content || props.content.length === 0) {
11120          return [];
11121        }
11122        if (props.itemsPerPage === 0) {
11123          return props.content;
11124        }
11125        const start = (selectedPage.value - 1) * props.itemsPerPage;
11126        const end = start + props.itemsPerPage;
11127        return props.content.slice(start, end);
11128      });
11129      watch(() => props.itemsPerPage, () => {
11130        selectedPage.value = 1;
11131      });
11132      watch(() => {
11133        var _a;
11134        return (_a = props.content) == null ? void 0 : _a.length;
11135      }, () => {
11136        selectedPage.value = 1;
11137      });
11138      watch(selectedPage, () => {
11139        nextTick(() => {
11140          if (top.value) {
11141            const topPos = top.value.offsetTop;
11142            window.scrollTo({ top: topPos, behavior: "smooth" });
11143          }
11144        });
11145      });
11146      return (_ctx, _cache) => {
11147        return openBlock(), createElementBlock("div", {
11148          class: normalizeClass(__props.classes || "section-lg"),
11149          ref_key: "top",
11150          ref: top
11151        }, [
11152          createBaseVNode("div", _hoisted_1, [
11153            __props.header ? (openBlock(), createElementBlock("div", _hoisted_2, [
11154              createVNode(_sfc_main$7, {
11155                title: __props.header.title,
11156                text: __props.header.text,
11157                size: __props.header.size.toString(),
11158                center: __props.header.center
11159              }, null, 8, ["title", "text", "size", "center"])
11160            ])) : createCommentVNode("", true),
11161            __props.content && __props.content.length > 0 ? (openBlock(), createElementBlock("div", _hoisted_3, [
11162              __props.isVertical ? (openBlock(), createElementBlock("div", _hoisted_4, [
11163                (openBlock(true), createElementBlock(Fragment, null, renderList(pagedCards.value, (card) => {
11164                  var _a;
11165                  return openBlock(), createBlock(_sfc_main$3, {
11166                    key: card.key,
11167                    imageAlt: card.alt,
11168                    imageSrc: card.src,
11169                    title: card.title,
11170                    text: card.text,
11171                    tagline: (_a = card.category) == null ? void 0 : _a.text,
11172                    link: card.link.link,
11173                    useHorizontalLayout: true
11174                  }, null, 8, ["imageAlt", "imageSrc", "title", "text", "tagline", "link"]);
11175                }), 128))
11176              ])) : (openBlock(), createElementBlock("div", {
11177                key: 1,
11178                class: normalizeClass(["grid grid-cols-1 vp5:grid-cols-2 gap-10", gridColsClass.value]),
11179                "data-aos": "fade-up"
11180              }, [
11181                (openBlock(true), createElementBlock(Fragment, null, renderList(pagedCards.value, (card) => {
11182                  var _a;
11183                  return openBlock(), createBlock(_sfc_main$3, {
11184                    key: card.key,
11185                    imageAlt: card.alt,
11186                    imageSrc: card.src,
11187                    title: card.title,
11188                    text: card.text,
11189                    tagline: (_a = card.category) == null ? void 0 : _a.text,
11190                    link: card.link.link,
11191                    showDivider: false
11192                  }, null, 8, ["imageAlt", "imageSrc", "title", "text", "tagline", "link"]);
11193                }), 128))
11194              ], 2)),
11195              createBaseVNode("div", _hoisted_5, [
11196                __props.itemsPerPage && __props.itemsPerPage !== 0 ? (openBlock(), createBlock(_sfc_main$2, {
11197                  key: 0,
11198                  modelValue: selectedPage.value,
11199                  "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => selectedPage.value = $event),
11200                  "items-per-page": __props.itemsPerPage,
11201                  "amount-of-pages": totalItems.value
11202                }, null, 8, ["modelValue", "items-per-page", "amount-of-pages"])) : createCommentVNode("", true)
11203              ])
11204            ])) : createCommentVNode("", true)
11205          ])
11206        ], 2);
11207      };
11208    }
11209  });
11210  const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
11211    __proto__: null,
11212    CardResources: _sfc_main,
11213    TabCardResources: _sfc_main$1,
11214    TestFeature: _sfc_main$8
11215  }, Symbol.toStringTag, { value: "Module" }));
11216  /**
11217  * @vue/server-renderer v3.5.12
11218  * (c) 2018-present Yuxi (Evan) You and Vue contributors
11219  * @license MIT
11220  **/
11221  const shouldIgnoreProp = /* @__PURE__ */ makeMap(
11222    `,key,ref,innerHTML,textContent,ref_key,ref_for`
11223  );
11224  function ssrRenderAttrs(props, tag) {
11225    let ret = "";
11226    for (const key in props) {
11227      if (shouldIgnoreProp(key) || isOn(key) || tag === "textarea" && key === "value") {
11228        continue;
11229      }
11230      const value = props[key];
11231      if (key === "class") {
11232        ret += ` class="${ssrRenderClass(value)}"`;
11233      } else if (key === "style") {
11234        ret += ` style="${ssrRenderStyle(value)}"`;
11235      } else if (key === "className") {
11236        ret += ` class="${String(value)}"`;
11237      } else {
11238        ret += ssrRenderDynamicAttr(key, value, tag);
11239      }
11240    }
11241    return ret;
11242  }
11243  function ssrRenderDynamicAttr(key, value, tag) {
11244    if (!isRenderableAttrValue(value)) {
11245      return ``;
11246    }
11247    const attrKey = tag && (tag.indexOf("-") > 0 || isSVGTag(tag)) ? key : propsToAttrMap[key] || key.toLowerCase();
11248    if (isBooleanAttr(attrKey)) {
11249      return includeBooleanAttr(value) ? ` ${attrKey}` : ``;
11250    } else if (isSSRSafeAttrName(attrKey)) {
11251      return value === "" ? ` ${attrKey}` : ` ${attrKey}="${escapeHtml(value)}"`;
11252    } else {
11253      console.warn(
11254        `[@vue/server-renderer] Skipped rendering unsafe attribute name: ${attrKey}`
11255      );
11256      return ``;
11257    }
11258  }
11259  function ssrRenderClass(raw) {
11260    return escapeHtml(normalizeClass(raw));
11261  }
11262  function ssrRenderStyle(raw) {
11263    if (!raw) {
11264      return "";
11265    }
11266    if (isString(raw)) {
11267      return escapeHtml(raw);
11268    }
11269    const styles = normalizeStyle(raw);
11270    return escapeHtml(stringifyStyle(styles));
11271  }
11272  function ssrRenderTeleport(parentPush, contentRenderFn, target, disabled, parentComponent) {
11273    parentPush("<!--teleport start-->");
11274    const context = parentComponent.appContext.provides[ssrContextKey];
11275    const teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
11276    const targetBuffer = teleportBuffers[target] || (teleportBuffers[target] = []);
11277    const bufferIndex = targetBuffer.length;
11278    let teleportContent;
11279    if (disabled) {
11280      contentRenderFn(parentPush);
11281      teleportContent = `<!--teleport start anchor--><!--teleport anchor-->`;
11282    } else {
11283      const { getBuffer, push } = createBuffer();
11284      push(`<!--teleport start anchor-->`);
11285      contentRenderFn(push);
11286      push(`<!--teleport anchor-->`);
11287      teleportContent = getBuffer();
11288    }
11289    targetBuffer.splice(bufferIndex, 0, teleportContent);
11290    parentPush("<!--teleport end-->");
11291  }
11292  {
11293    const g = getGlobalThis();
11294    const registerGlobalSetter = (key, setter) => {
11295      let setters;
11296      if (!(setters = g[key]))
11297        setters = g[key] = [];
11298      setters.push(setter);
11299      return (v) => {
11300        if (setters.length > 1)

11301          setters.forEach((set) => set(v));
11302        else
11303          setters[0](v);
11304      };
11305    };
11306    registerGlobalSetter(
11307      `__VUE_INSTANCE_SETTERS__`,
11308      (v) => v
11309    );
11310    registerGlobalSetter(
11311      `__VUE_SSR_SETTERS__`,
11312      (v) => v
11313    );
11314  }
11315  function ssrCompile(template, instance) {
11316    {
11317      throw new Error(
11318        `On-the-fly template compilation is not supported in the ESM build of @vue/server-renderer. All templates must be pre-compiled into render functions.`
11319      );
11320    }
11321  }
11322  const {
11323    createComponentInstance,
11324    setCurrentRenderingInstance,
11325    setupComponent,
11326    renderComponentRoot,
11327    normalizeVNode,
11328    pushWarningContext,
11329    popWarningContext
11330  } = ssrUtils;
11331  function createBuffer() {
11332    let appendable = false;
11333    const buffer2 = [];
11334    return {
11335      getBuffer() {
11336        return buffer2;
11337      },
11338      push(item) {
11339        const isStringItem = isString(item);
11340        if (appendable && isStringItem) {
11341          buffer2[buffer2.length - 1] += item;
11342          return;
11343        }
11344        buffer2.push(item);
11345        appendable = isStringItem;
11346        if (isPromise(item) || isArray(item) && item.hasAsync) {
11347          buffer2.hasAsync = true;
11348        }
11349      }
11350    };
11351  }
11352  function renderComponentVNode(vnode, parentComponent = null, slotScopeId) {
11353    const instance = vnode.component = createComponentInstance(
11354      vnode,
11355      parentComponent,
11356      null
11357    );
11358    const res = setupComponent(
11359      instance,
11360      true
11361      /* isSSR */
11362    );
11363    const hasAsyncSetup = isPromise(res);
11364    let prefetches = instance.sp;
11365    if (hasAsyncSetup || prefetches) {
11366      const p2 = Promise.resolve(res).then(() => {
11367        if (hasAsyncSetup)
11368          prefetches = instance.sp;
11369        if (prefetches) {
11370          return Promise.all(
11371            prefetches.map((prefetch) => prefetch.call(instance.proxy))
11372          );
11373        }
11374      }).catch(NOOP);
11375      return p2.then(() => renderComponentSubTree(instance, slotScopeId));
11376    } else {
11377      return renderComponentSubTree(instance, slotScopeId);
11378    }
11379  }
11380  function renderComponentSubTree(instance, slotScopeId) {
11381    const comp = instance.type;
11382    const { getBuffer, push } = createBuffer();
11383    if (isFunction(comp)) {
11384      let root = renderComponentRoot(instance);
11385      if (!comp.props) {
11386        for (const key in instance.attrs) {
11387          if (key.startsWith(`data-v-`)) {
11388            (root.props || (root.props = {}))[key] = ``;
11389          }
11390        }
11391      }
11392      renderVNode(push, instance.subTree = root, instance, slotScopeId);
11393    } else {
11394      if ((!instance.render || instance.render === NOOP) && !instance.ssrRender && !comp.ssrRender && isString(comp.template)) {
11395        comp.ssrRender = ssrCompile(comp.template);
11396      }
11397      const ssrRender = instance.ssrRender || comp.ssrRender;
11398      if (ssrRender) {
11399        let attrs = instance.inheritAttrs !== false ? instance.attrs : void 0;
11400        let hasCloned = false;
11401        let cur = instance;
11402        while (true) {
11403          const scopeId = cur.vnode.scopeId;
11404          if (scopeId) {
11405            if (!hasCloned) {
11406              attrs = { ...attrs };
11407              hasCloned = true;
11408            }
11409            attrs[scopeId] = "";
11410          }
11411          const parent = cur.parent;
11412          if (parent && parent.subTree && parent.subTree === cur.vnode) {
11413            cur = parent;
11414          } else {
11415            break;
11416          }
11417        }
11418        if (slotScopeId) {
11419          if (!hasCloned)
11420            attrs = { ...attrs };
11421          const slotScopeIdList = slotScopeId.trim().split(" ");
11422          for (let i = 0; i < slotScopeIdList.length; i++) {
11423            attrs[slotScopeIdList[i]] = "";
11424          }
11425        }
11426        const prev = setCurrentRenderingInstance(instance);
11427        try {
11428          ssrRender(
11429            instance.proxy,
11430            push,
11431            instance,
11432            attrs,
11433            // compiler-optimized bindings
11434            instance.props,
11435            instance.setupState,
11436            instance.data,
11437            instance.ctx
11438          );
11439        } finally {
11440          setCurrentRenderingInstance(prev);
11441        }
11442      } else if (instance.render && instance.render !== NOOP) {
11443        renderVNode(
11444          push,
11445          instance.subTree = renderComponentRoot(instance),
11446          instance,
11447          slotScopeId
11448        );
11449      } else {
11450        comp.name || comp.__file || `<Anonymous>`;
11451        push(`<!---->`);
11452      }
11453    }
11454    return getBuffer();
11455  }
11456  function renderVNode(push, vnode, parentComponent, slotScopeId) {
11457    const { type, shapeFlag, children, dirs, props } = vnode;
11458    if (dirs) {
11459      vnode.props = applySSRDirectives(vnode, props, dirs);
11460    }
11461    switch (type) {
11462      case Text:
11463        push(escapeHtml(children));
11464        break;
11465      case Comment:
11466        push(
11467          children ? `<!--${escapeHtmlComment(children)}-->` : `<!---->`
11468        );
11469        break;
11470      case Static:
11471        push(children);
11472        break;
11473      case Fragment:
11474        if (vnode.slotScopeIds) {
11475          slotScopeId = (slotScopeId ? slotScopeId + " " : "") + vnode.slotScopeIds.join(" ");
11476        }
11477        push(`<!--[-->`);
11478        renderVNodeChildren(
11479          push,
11480          children,
11481          parentComponent,
11482          slotScopeId
11483        );
11484        push(`<!--]-->`);
11485        break;
11486      default:
11487        if (shapeFlag & 1) {
11488          renderElementVNode(push, vnode, parentComponent, slotScopeId);
11489        } else if (shapeFlag & 6) {
11490          push(renderComponentVNode(vnode, parentComponent, slotScopeId));
11491        } else if (shapeFlag & 64) {
11492          renderTeleportVNode(push, vnode, parentComponent, slotScopeId);
11493        } else if (shapeFlag & 128) {
11494          renderVNode(push, vnode.ssContent, parentComponent, slotScopeId);
11495        } else
11496          ;
11497    }
11498  }
11499  function renderVNodeChildren(push, children, parentComponent, slotScopeId) {
11500    for (let i = 0; i < children.length; i++) {
11501      renderVNode(push, normalizeVNode(children[i]), parentComponent, slotScopeId);
11502    }
11503  }
11504  function renderElementVNode(push, vnode, parentComponent, slotScopeId) {
11505    const tag = vnode.type;
11506    let { props, children, shapeFlag, scopeId } = vnode;
11507    let openTag = `<${tag}`;
11508    if (props) {
11509      openTag += ssrRenderAttrs(props, tag);
11510    }
11511    if (scopeId) {
11512      openTag += ` ${scopeId}`;
11513    }

11514    let curParent = parentComponent;
11515    let curVnode = vnode;
11516    while (curParent && curVnode === curParent.subTree) {
11517      curVnode = curParent.vnode;
11518      if (curVnode.scopeId) {
11519        openTag += ` ${curVnode.scopeId}`;
11520      }
11521      curParent = curParent.parent;
11522    }
11523    if (slotScopeId) {
11524      openTag += ` ${slotScopeId}`;
11525    }
11526    push(openTag + `>`);
11527    if (!isVoidTag(tag)) {
11528      let hasChildrenOverride = false;
11529      if (props) {
11530        if (props.innerHTML) {
11531          hasChildrenOverride = true;
11532          push(props.innerHTML);
11533        } else if (props.textContent) {
11534          hasChildrenOverride = true;
11535          push(escapeHtml(props.textContent));
11536        } else if (tag === "textarea" && props.value) {
11537          hasChildrenOverride = true;
11538          push(escapeHtml(props.value));
11539        }
11540      }
11541      if (!hasChildrenOverride) {
11542        if (shapeFlag & 8) {
11543          push(escapeHtml(children));
11544        } else if (shapeFlag & 16) {
11545          renderVNodeChildren(
11546            push,
11547            children,
11548            parentComponent,
11549            slotScopeId
11550          );
11551        }
11552      }
11553      push(`</${tag}>`);
11554    }
11555  }
11556  function applySSRDirectives(vnode, rawProps, dirs) {
11557    const toMerge = [];
11558    for (let i = 0; i < dirs.length; i++) {
11559      const binding = dirs[i];
11560      const {
11561        dir: { getSSRProps }
11562      } = binding;
11563      if (getSSRProps) {
11564        const props = getSSRProps(binding, vnode);
11565        if (props)
11566          toMerge.push(props);
11567      }
11568    }
11569    return mergeProps(rawProps || {}, ...toMerge);
11570  }
11571  function renderTeleportVNode(push, vnode, parentComponent, slotScopeId) {
11572    const target = vnode.props && vnode.props.to;
11573    const disabled = vnode.props && vnode.props.disabled;
11574    if (!target) {
11575      return [];
11576    }
11577    if (!isString(target)) {
11578      return [];
11579    }
11580    ssrRenderTeleport(
11581      push,
11582      (push2) => {
11583        renderVNodeChildren(
11584          push2,
11585          vnode.children,
11586          parentComponent,
11587          slotScopeId
11588        );
11589      },
11590      target,
11591      disabled || disabled === "",
11592      parentComponent
11593    );
11594  }
11595  const { isVNode: isVNode$1 } = ssrUtils;
11596  function nestedUnrollBuffer(buffer2, parentRet, startIndex) {
11597    if (!buffer2.hasAsync) {
11598      return parentRet + unrollBufferSync$1(buffer2);
11599    }
11600    let ret = parentRet;
11601    for (let i = startIndex; i < buffer2.length; i += 1) {
11602      const item = buffer2[i];
11603      if (isString(item)) {
11604        ret += item;
11605        continue;
11606      }
11607      if (isPromise(item)) {
11608        return item.then((nestedItem) => {
11609          buffer2[i] = nestedItem;
11610          return nestedUnrollBuffer(buffer2, ret, i);
11611        });
11612      }
11613      const result = nestedUnrollBuffer(item, ret, 0);
11614      if (isPromise(result)) {
11615        return result.then((nestedItem) => {
11616          buffer2[i] = nestedItem;
11617          return nestedUnrollBuffer(buffer2, "", i);
11618        });
11619      }
11620      ret = result;
11621    }
11622    return ret;
11623  }
11624  function unrollBuffer$1(buffer2) {
11625    return nestedUnrollBuffer(buffer2, "", 0);
11626  }
11627  function unrollBufferSync$1(buffer2) {
11628    let ret = "";
11629    for (let i = 0; i < buffer2.length; i++) {
11630      let item = buffer2[i];
11631      if (isString(item)) {
11632        ret += item;
11633      } else {
11634        ret += unrollBufferSync$1(item);
11635      }
11636    }
11637    return ret;
11638  }
11639  async function renderToString(input, context = {}) {
11640    if (isVNode$1(input)) {
11641      return renderToString(createApp({ render: () => input }), context);
11642    }
11643    const vnode = createVNode(input._component, input._props);
11644    vnode.appContext = input._context;
11645    input.provide(ssrContextKey, context);
11646    const buffer2 = await renderComponentVNode(vnode);
11647    const result = await unrollBuffer$1(buffer2);
11648    await resolveTeleports(context);
11649    if (context.__watcherHandles) {
11650      for (const unwatch of context.__watcherHandles) {
11651        unwatch();
11652      }
11653    }
11654    return result;
11655  }
11656  async function resolveTeleports(context) {
11657    if (context.__teleportBuffers) {
11658      context.teleports = context.teleports || {};
11659      for (const key in context.__teleportBuffers) {
11660        context.teleports[key] = await unrollBuffer$1(
11661          await Promise.all([context.__teleportBuffers[key]])
11662        );
11663      }
11664    }
11665  }
11666  initDirectivesForSSR();
11667  exports2.Components = index;
11668  exports2.Vue = vue_runtime_esmBundler;
11669  exports2.renderToString = renderToString;
11670  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
11671});

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.