https://fairsoftwarechecklist.net/assets/chunk-546a4201.js

1function makeMap(str, expectsLowerCase) {
2  const map = /* @__PURE__ */ Object.create(null);
3  const list = str.split(",");
4  for (let i = 0; i < list.length; i++) {
5    map[list[i]] = true;
6  }
7  return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
8}
9const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
10const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
11function includeBooleanAttr(value) {
12  return !!value || value === "";
13}
14function normalizeStyle(value) {
15  if (isArray(value)) {
16    const res = {};
17    for (let i = 0; i < value.length; i++) {
18      const item = value[i];
19      const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
20      if (normalized) {
21        for (const key in normalized) {
22          res[key] = normalized[key];
23        }
24      }
25    }
26    return res;
27  } else if (isString(value)) {
28    return value;
29  } else if (isObject(value)) {
30    return value;
31  }
32}
33const listDelimiterRE = /;(?![^(]*\))/g;
34const propertyDelimiterRE = /:(.+)/;
35function parseStringStyle(cssText) {
36  const ret = {};
37  cssText.split(listDelimiterRE).forEach((item) => {
38    if (item) {
39      const tmp = item.split(propertyDelimiterRE);
40      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
41    }
42  });
43  return ret;
44}
45function normalizeClass(value) {
46  let res = "";
47  if (isString(value)) {
48    res = value;
49  } else if (isArray(value)) {
50    for (let i = 0; i < value.length; i++) {
51      const normalized = normalizeClass(value[i]);
52      if (normalized) {
53        res += normalized + " ";
54      }
55    }
56  } else if (isObject(value)) {
57    for (const name in value) {
58      if (value[name]) {
59        res += name + " ";
60      }
61    }
62  }
63  return res.trim();
64}
65const toDisplayString = (val) => {
66  return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val);
67};
68const replacer = (_key, val) => {
69  if (val && val.__v_isRef) {
70    return replacer(_key, val.value);
71  } else if (isMap(val)) {
72    return {
73      [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2]) => {
74        entries[`${key} =>`] = val2;
75        return entries;
76      }, {})
77    };
78  } else if (isSet(val)) {
79    return {
80      [`Set(${val.size})`]: [...val.values()]
81    };
82  } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
83    return String(val);
84  }
85  return val;
86};
87const EMPTY_OBJ = {};
88const EMPTY_ARR = [];
89const NOOP = () => {
90};
91const NO = () => false;
92const onRE = /^on[^a-z]/;
93const isOn = (key) => onRE.test(key);
94const isModelListener = (key) => key.startsWith("onUpdate:");
95const extend = Object.assign;
96const remove = (arr, el) => {
97  const i = arr.indexOf(el);
98  if (i > -1) {
99    arr.splice(i, 1);
100  }
101};
102const hasOwnProperty = Object.prototype.hasOwnProperty;
103const hasOwn = (val, key) => hasOwnProperty.call(val, key);
104const isArray = Array.isArray;
105const isMap = (val) => toTypeString(val) === "[object Map]";
106const isSet = (val) => toTypeString(val) === "[object Set]";
107const isFunction = (val) => typeof val === "function";
108const isString = (val) => typeof val === "string";
109const isSymbol = (val) => typeof val === "symbol";
110const isObject = (val) => val !== null && typeof val === "object";
111const isPromise = (val) => {
112  return isObject(val) && isFunction(val.then) && isFunction(val.catch);
113};
114const objectToString = Object.prototype.toString;
115const toTypeString = (value) => objectToString.call(value);
116const toRawType = (value) => {
117  return toTypeString(value).slice(8, -1);
118};
119const isPlainObject = (val) => toTypeString(val) === "[object Object]";
120const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
121const isReservedProp = /* @__PURE__ */ makeMap(
122  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
123);
124const cacheStringFunction = (fn) => {
125  const cache = /* @__PURE__ */ Object.create(null);
126  return (str) => {
127    const hit = cache[str];
128    return hit || (cache[str] = fn(str));
129  };
130};
131const camelizeRE = /-(\w)/g;
132const camelize = cacheStringFunction((str) => {
133  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
134});
135const hyphenateRE = /\B([A-Z])/g;
136const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
137const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
138const toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``);
139const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
140const invokeArrayFns = (fns, arg) => {
141  for (let i = 0; i < fns.length; i++) {
142    fns[i](arg);
143  }
144};
145const def = (obj, key, value) => {
146  Object.defineProperty(obj, key, {
147    configurable: true,
148    enumerable: false,
149    value
150  });
151};
152const toNumber = (val) => {
153  const n = parseFloat(val);
154  return isNaN(n) ? val : n;
155};
156let _globalThis;
157const getGlobalThis = () => {
158  return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
159};
160let activeEffectScope;
161class EffectScope {
162  constructor(detached = false) {
163    this.detached = detached;
164    this.active = true;
165    this.effects = [];
166    this.cleanups = [];
167    this.parent = activeEffectScope;
168    if (!detached && activeEffectScope) {
169      this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
170    }
171  }
172  run(fn) {
173    if (this.active) {
174      const currentEffectScope = activeEffectScope;

175      try {
176        activeEffectScope = this;
177        return fn();
178      } finally {
179        activeEffectScope = currentEffectScope;
180      }
181    }
182  }
183  on() {
184    activeEffectScope = this;
185  }
186  off() {
187    activeEffectScope = this.parent;
188  }
189  stop(fromParent) {
190    if (this.active) {
191      let i, l;
192      for (i = 0, l = this.effects.length; i < l; i++) {
193        this.effects[i].stop();
194      }
195      for (i = 0, l = this.cleanups.length; i < l; i++) {
196        this.cleanups[i]();
197      }
198      if (this.scopes) {
199        for (i = 0, l = this.scopes.length; i < l; i++) {
200          this.scopes[i].stop(true);
201        }
202      }
203      if (!this.detached && this.parent && !fromParent) {
204        const last = this.parent.scopes.pop();
205        if (last && last !== this) {
206          this.parent.scopes[this.index] = last;
207          last.index = this.index;
208        }
209      }
210      this.parent = void 0;
211      this.active = false;
212    }
213  }
214}
215function recordEffectScope(effect, scope = activeEffectScope) {
216  if (scope && scope.active) {
217    scope.effects.push(effect);
218  }
219}
220const createDep = (effects) => {
221  const dep = new Set(effects);
222  dep.w = 0;
223  dep.n = 0;
224  return dep;
225};
226const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
227const newTracked = (dep) => (dep.n & trackOpBit) > 0;
228const initDepMarkers = ({ deps }) => {
229  if (deps.length) {
230    for (let i = 0; i < deps.length; i++) {
231      deps[i].w |= trackOpBit;
232    }
233  }
234};
235const finalizeDepMarkers = (effect) => {
236  const { deps } = effect;
237  if (deps.length) {
238    let ptr = 0;
239    for (let i = 0; i < deps.length; i++) {
240      const dep = deps[i];
241      if (wasTracked(dep) && !newTracked(dep)) {
242        dep.delete(effect);
243      } else {
244        deps[ptr++] = dep;
245      }
246      dep.w &= ~trackOpBit;
247      dep.n &= ~trackOpBit;
248    }
249    deps.length = ptr;
250  }
251};
252const targetMap = /* @__PURE__ */ new WeakMap();
253let effectTrackDepth = 0;
254let trackOpBit = 1;
255const maxMarkerBits = 30;
256let activeEffect;
257const ITERATE_KEY = Symbol("");
258const MAP_KEY_ITERATE_KEY = Symbol("");
259class ReactiveEffect {
260  constructor(fn, scheduler = null, scope) {
261    this.fn = fn;
262    this.scheduler = scheduler;
263    this.active = true;
264    this.deps = [];
265    this.parent = void 0;
266    recordEffectScope(this, scope);
267  }
268  run() {
269    if (!this.active) {
270      return this.fn();
271    }
272    let parent = activeEffect;
273    let lastShouldTrack = shouldTrack;
274    while (parent) {
275      if (parent === this) {
276        return;
277      }
278      parent = parent.parent;
279    }
280    try {
281      this.parent = activeEffect;
282      activeEffect = this;
283      shouldTrack = true;
284      trackOpBit = 1 << ++effectTrackDepth;
285      if (effectTrackDepth <= maxMarkerBits) {
286        initDepMarkers(this);
287      } else {
288        cleanupEffect(this);
289      }
290      return this.fn();
291    } finally {
292      if (effectTrackDepth <= maxMarkerBits) {
293        finalizeDepMarkers(this);
294      }
295      trackOpBit = 1 << --effectTrackDepth;
296      activeEffect = this.parent;
297      shouldTrack = lastShouldTrack;
298      this.parent = void 0;
299      if (this.deferStop) {
300        this.stop();
301      }
302    }
303  }
304  stop() {
305    if (activeEffect === this) {
306      this.deferStop = true;
307    } else if (this.active) {
308      cleanupEffect(this);
309      if (this.onStop) {
310        this.onStop();
311      }
312      this.active = false;
313    }
314  }
315}
316function cleanupEffect(effect) {
317  const { deps } = effect;
318  if (deps.length) {
319    for (let i = 0; i < deps.length; i++) {
320      deps[i].delete(effect);
321    }
322    deps.length = 0;
323  }
324}
325let shouldTrack = true;
326const trackStack = [];
327function pauseTracking() {
328  trackStack.push(shouldTrack);
329  shouldTrack = false;
330}
331function resetTracking() {
332  const last = trackStack.pop();
333  shouldTrack = last === void 0 ? true : last;
334}
335function track(target, type, key) {
336  if (shouldTrack && activeEffect) {
337    let depsMap = targetMap.get(target);
338    if (!depsMap) {
339      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
340    }
341    let dep = depsMap.get(key);
342    if (!dep) {
343      depsMap.set(key, dep = createDep());
344    }
345    trackEffects(dep);
346  }
347}
348function trackEffects(dep, debuggerEventExtraInfo) {
349  let shouldTrack2 = false;

350  if (effectTrackDepth <= maxMarkerBits) {
351    if (!newTracked(dep)) {
352      dep.n |= trackOpBit;
353      shouldTrack2 = !wasTracked(dep);
354    }
355  } else {
356    shouldTrack2 = !dep.has(activeEffect);
357  }
358  if (shouldTrack2) {
359    dep.add(activeEffect);
360    activeEffect.deps.push(dep);
361  }
362}
363function trigger(target, type, key, newValue, oldValue, oldTarget) {
364  const depsMap = targetMap.get(target);
365  if (!depsMap) {
366    return;
367  }
368  let deps = [];
369  if (type === "clear") {
370    deps = [...depsMap.values()];
371  } else if (key === "length" && isArray(target)) {
372    depsMap.forEach((dep, key2) => {
373      if (key2 === "length" || key2 >= newValue) {
374        deps.push(dep);
375      }
376    });
377  } else {
378    if (key !== void 0) {
379      deps.push(depsMap.get(key));
380    }
381    switch (type) {
382      case "add":
383        if (!isArray(target)) {
384          deps.push(depsMap.get(ITERATE_KEY));
385          if (isMap(target)) {
386            deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
387          }
388        } else if (isIntegerKey(key)) {
389          deps.push(depsMap.get("length"));
390        }
391        break;
392      case "delete":
393        if (!isArray(target)) {
394          deps.push(depsMap.get(ITERATE_KEY));
395          if (isMap(target)) {
396            deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
397          }
398        }
399        break;
400      case "set":
401        if (isMap(target)) {
402          deps.push(depsMap.get(ITERATE_KEY));
403        }
404        break;
405    }
406  }
407  if (deps.length === 1) {
408    if (deps[0]) {
409      {
410        triggerEffects(deps[0]);
411      }
412    }
413  } else {
414    const effects = [];
415    for (const dep of deps) {
416      if (dep) {
417        effects.push(...dep);
418      }
419    }
420    {
421      triggerEffects(createDep(effects));
422    }
423  }
424}
425function triggerEffects(dep, debuggerEventExtraInfo) {
426  const effects = isArray(dep) ? dep : [...dep];
427  for (const effect of effects) {
428    if (effect.computed) {
429      triggerEffect(effect);
430    }
431  }
432  for (const effect of effects) {
433    if (!effect.computed) {
434      triggerEffect(effect);
435    }
436  }
437}
438function triggerEffect(effect, debuggerEventExtraInfo) {
439  if (effect !== activeEffect || effect.allowRecurse) {
440    if (effect.scheduler) {
441      effect.scheduler();
442    } else {
443      effect.run();
444    }
445  }
446}
447const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
448const builtInSymbols = new Set(
449  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
450);
451const get = /* @__PURE__ */ createGetter();
452const shallowGet = /* @__PURE__ */ createGetter(false, true);
453const readonlyGet = /* @__PURE__ */ createGetter(true);
454const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
455function createArrayInstrumentations() {
456  const instrumentations = {};
457  ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
458    instrumentations[key] = function(...args) {
459      const arr = toRaw(this);
460      for (let i = 0, l = this.length; i < l; i++) {
461        track(arr, "get", i + "");
462      }
463      const res = arr[key](...args);
464      if (res === -1 || res === false) {
465        return arr[key](...args.map(toRaw));
466      } else {
467        return res;
468      }
469    };
470  });
471  ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
472    instrumentations[key] = function(...args) {
473      pauseTracking();
474      const res = toRaw(this)[key].apply(this, args);
475      resetTracking();
476      return res;
477    };
478  });
479  return instrumentations;
480}
481function createGetter(isReadonly2 = false, shallow = false) {
482  return function get2(target, key, receiver) {
483    if (key === "__v_isReactive") {
484      return !isReadonly2;
485    } else if (key === "__v_isReadonly") {
486      return isReadonly2;
487    } else if (key === "__v_isShallow") {
488      return shallow;
489    } else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
490      return target;
491    }
492    const targetIsArray = isArray(target);
493    if (!isReadonly2 && targetIsArray && hasOwn(arrayInstrumentations, key)) {
494      return Reflect.get(arrayInstrumentations, key, receiver);
495    }
496    const res = Reflect.get(target, key, receiver);

497    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
498      return res;
499    }
500    if (!isReadonly2) {
501      track(target, "get", key);
502    }
503    if (shallow) {
504      return res;
505    }
506    if (isRef(res)) {
507      return targetIsArray && isIntegerKey(key) ? res : res.value;
508    }
509    if (isObject(res)) {
510      return isReadonly2 ? readonly(res) : reactive(res);
511    }
512    return res;
513  };
514}
515const set = /* @__PURE__ */ createSetter();
516const shallowSet = /* @__PURE__ */ createSetter(true);
517function createSetter(shallow = false) {
518  return function set2(target, key, value, receiver) {
519    let oldValue = target[key];
520    if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
521      return false;
522    }
523    if (!shallow) {
524      if (!isShallow(value) && !isReadonly(value)) {
525        oldValue = toRaw(oldValue);
526        value = toRaw(value);
527      }
528      if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
529        oldValue.value = value;
530        return true;
531      }
532    }
533    const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
534    const result = Reflect.set(target, key, value, receiver);
535    if (target === toRaw(receiver)) {
536      if (!hadKey) {
537        trigger(target, "add", key, value);
538      } else if (hasChanged(value, oldValue)) {
539        trigger(target, "set", key, value);
540      }
541    }
542    return result;
543  };
544}
545function deleteProperty(target, key) {
546  const hadKey = hasOwn(target, key);
547  target[key];
548  const result = Reflect.deleteProperty(target, key);
549  if (result && hadKey) {
550    trigger(target, "delete", key, void 0);
551  }
552  return result;
553}
554function has(target, key) {
555  const result = Reflect.has(target, key);
556  if (!isSymbol(key) || !builtInSymbols.has(key)) {
557    track(target, "has", key);
558  }
559  return result;
560}
561function ownKeys(target) {
562  track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
563  return Reflect.ownKeys(target);
564}
565const mutableHandlers = {
566  get,
567  set,
568  deleteProperty,
569  has,
570  ownKeys
571};
572const readonlyHandlers = {
573  get: readonlyGet,
574  set(target, key) {
575    return true;
576  },
577  deleteProperty(target, key) {
578    return true;
579  }
580};
581const shallowReactiveHandlers = /* @__PURE__ */ extend({}, mutableHandlers, {
582  get: shallowGet,
583  set: shallowSet
584});
585const toShallow = (value) => value;
586const getProto = (v) => Reflect.getPrototypeOf(v);
587function get$1(target, key, isReadonly2 = false, isShallow2 = false) {
588  target = target["__v_raw"];
589  const rawTarget = toRaw(target);
590  const rawKey = toRaw(key);
591  if (!isReadonly2) {
592    if (key !== rawKey) {
593      track(rawTarget, "get", key);
594    }
595    track(rawTarget, "get", rawKey);
596  }
597  const { has: has2 } = getProto(rawTarget);
598  const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
599  if (has2.call(rawTarget, key)) {
600    return wrap(target.get(key));
601  } else if (has2.call(rawTarget, rawKey)) {
602    return wrap(target.get(rawKey));
603  } else if (target !== rawTarget) {
604    target.get(key);
605  }
606}
607function has$1(key, isReadonly2 = false) {
608  const target = this["__v_raw"];
609  const rawTarget = toRaw(target);
610  const rawKey = toRaw(key);
611  if (!isReadonly2) {
612    if (key !== rawKey) {
613      track(rawTarget, "has", key);
614    }
615    track(rawTarget, "has", rawKey);
616  }
617  return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
618}
619function size(target, isReadonly2 = false) {
620  target = target["__v_raw"];
621  !isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
622  return Reflect.get(target, "size", target);
623}
624function add(value) {
625  value = toRaw(value);
626  const target = toRaw(this);
627  const proto = getProto(target);
628  const hadKey = proto.has.call(target, value);
629  if (!hadKey) {
630    target.add(value);
631    trigger(target, "add", value, value);
632  }
633  return this;
634}
635function set$1(key, value) {
636  value = toRaw(value);
637  const target = toRaw(this);
638  const { has: has2, get: get2 } = getProto(target);
639  let hadKey = has2.call(target, key);
640  if (!hadKey) {
641    key = toRaw(key);
642    hadKey = has2.call(target, key);
643  }
644  const oldValue = get2.call(target, key);
645  target.set(key, value);
646  if (!hadKey) {
647    trigger(target, "add", key, value);
648  } else if (hasChanged(value, oldValue)) {
649    trigger(target, "set", key, value);
650  }
651  return this;
652}
653function deleteEntry(key) {
654  const target = toRaw(this);
655  const { has: has2, get: get2 } = getProto(target);
656  let hadKey = has2.call(target, key);
657  if (!hadKey) {
658    key = toRaw(key);
659    hadKey = has2.call(target, key);
660  }
661  get2 ? get2.call(target, key) : void 0;
662  const result = target.delete(key);
663  if (hadKey) {
664    trigger(target, "delete", key, void 0);
665  }
666  return result;
667}
668function clear() {
669  const target = toRaw(this);
670  const hadItems = target.size !== 0;
671  const result = target.clear();
672  if (hadItems) {
673    trigger(target, "clear", void 0, void 0);
674  }
675  return result;
676}
677function createForEach(isReadonly2, isShallow2) {
678  return function forEach(callback, thisArg) {
679    const observed = this;
680    const target = observed["__v_raw"];
681    const rawTarget = toRaw(target);
682    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
683    !isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY);
684    return target.forEach((value, key) => {
685      return callback.call(thisArg, wrap(value), wrap(key), observed);
686    });
687  };
688}
689function createIterableMethod(method, isReadonly2, isShallow2) {
690  return function(...args) {
691    const target = this["__v_raw"];
692    const rawTarget = toRaw(target);
693    const targetIsMap = isMap(rawTarget);
694    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
695    const isKeyOnly = method === "keys" && targetIsMap;
696    const innerIterator = target[method](...args);
697    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
698    !isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
699    return {
700      next() {
701        const { value, done } = innerIterator.next();
702        return done ? { value, done } : {
703          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),

704          done
705        };
706      },
707      [Symbol.iterator]() {
708        return this;
709      }
710    };
711  };
712}
713function createReadonlyMethod(type) {
714  return function(...args) {
715    return type === "delete" ? false : this;
716  };
717}
718function createInstrumentations() {
719  const mutableInstrumentations2 = {
720    get(key) {
721      return get$1(this, key);
722    },
723    get size() {
724      return size(this);
725    },
726    has: has$1,
727    add,
728    set: set$1,
729    delete: deleteEntry,
730    clear,
731    forEach: createForEach(false, false)
732  };
733  const shallowInstrumentations2 = {
734    get(key) {
735      return get$1(this, key, false, true);
736    },
737    get size() {
738      return size(this);
739    },
740    has: has$1,
741    add,
742    set: set$1,
743    delete: deleteEntry,
744    clear,
745    forEach: createForEach(false, true)
746  };
747  const readonlyInstrumentations2 = {
748    get(key) {
749      return get$1(this, key, true);
750    },
751    get size() {
752      return size(this, true);
753    },
754    has(key) {
755      return has$1.call(this, key, true);
756    },
757    add: createReadonlyMethod("add"),
758    set: createReadonlyMethod("set"),
759    delete: createReadonlyMethod("delete"),
760    clear: createReadonlyMethod("clear"),
761    forEach: createForEach(true, false)
762  };
763  const shallowReadonlyInstrumentations2 = {
764    get(key) {
765      return get$1(this, key, true, true);
766    },
767    get size() {
768      return size(this, true);
769    },
770    has(key) {
771      return has$1.call(this, key, true);
772    },
773    add: createReadonlyMethod("add"),
774    set: createReadonlyMethod("set"),
775    delete: createReadonlyMethod("delete"),
776    clear: createReadonlyMethod("clear"),
777    forEach: createForEach(true, true)
778  };
779  const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
780  iteratorMethods.forEach((method) => {
781    mutableInstrumentations2[method] = createIterableMethod(method, false, false);
782    readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
783    shallowInstrumentations2[method] = createIterableMethod(method, false, true);
784    shallowReadonlyInstrumentations2[method] = createIterableMethod(method, true, true);
785  });
786  return [
787    mutableInstrumentations2,
788    readonlyInstrumentations2,
789    shallowInstrumentations2,
790    shallowReadonlyInstrumentations2
791  ];
792}
793const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* @__PURE__ */ createInstrumentations();
794function createInstrumentationGetter(isReadonly2, shallow) {
795  const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;
796  return (target, key, receiver) => {
797    if (key === "__v_isReactive") {
798      return !isReadonly2;
799    } else if (key === "__v_isReadonly") {
800      return isReadonly2;
801    } else if (key === "__v_raw") {
802      return target;
803    }
804    return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
805  };
806}
807const mutableCollectionHandlers = {
808  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
809};
810const shallowCollectionHandlers = {
811  get: /* @__PURE__ */ createInstrumentationGetter(false, true)
812};
813const readonlyCollectionHandlers = {
814  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
815};
816const reactiveMap = /* @__PURE__ */ new WeakMap();
817const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
818const readonlyMap = /* @__PURE__ */ new WeakMap();
819const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
820function targetTypeMap(rawType) {
821  switch (rawType) {
822    case "Object":
823    case "Array":
824      return 1;
825    case "Map":
826    case "Set":
827    case "WeakMap":
828    case "WeakSet":
829      return 2;
830    default:
831      return 0;
832  }
833}
834function getTargetType(value) {
835  return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
836}
837function reactive(target) {
838  if (isReadonly(target)) {
839    return target;
840  }
841  return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
842}
843function shallowReactive(target) {
844  return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
845}
846function readonly(target) {
847  return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
848}
849function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
850  if (!isObject(target)) {
851    return target;
852  }
853  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
854    return target;
855  }
856  const existingProxy = proxyMap.get(target);
857  if (existingProxy) {
858    return existingProxy;
859  }
860  const targetType = getTargetType(target);
861  if (targetType === 0) {
862    return target;
863  }
864  const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
865  proxyMap.set(target, proxy);
866  return proxy;
867}
868function isReactive(value) {
869  if (isReadonly(value)) {
870    return isReactive(value["__v_raw"]);
871  }
872  return !!(value && value["__v_isReactive"]);
873}
874function isReadonly(value) {
875  return !!(value && value["__v_isReadonly"]);
876}
877function isShallow(value) {
878  return !!(value && value["__v_isShallow"]);
879}
880function isProxy(value) {
881  return isReactive(value) || isReadonly(value);
882}
883function toRaw(observed) {
884  const raw = observed && observed["__v_raw"];
885  return raw ? toRaw(raw) : observed;
886}
887function markRaw(value) {
888  def(value, "__v_skip", true);
889  return value;
890}
891const toReactive = (value) => isObject(value) ? reactive(value) : value;
892const toReadonly = (value) => isObject(value) ? readonly(value) : value;
893function trackRefValue(ref2) {
894  if (shouldTrack && activeEffect) {
895    ref2 = toRaw(ref2);
896    {
897      trackEffects(ref2.dep || (ref2.dep = createDep()));
898    }
899  }
900}
901function triggerRefValue(ref2, newVal) {
902  ref2 = toRaw(ref2);
903  if (ref2.dep) {
904    {
905      triggerEffects(ref2.dep);
906    }
907  }
908}
909function isRef(r) {
910  return !!(r && r.__v_isRef === true);
911}
912function ref(value) {
913  return createRef(value, false);
914}
915function createRef(rawValue, shallow) {
916  if (isRef(rawValue)) {
917    return rawValue;
918  }
919  return new RefImpl(rawValue, shallow);
920}
921class RefImpl {

922  constructor(value, __v_isShallow) {
923    this.__v_isShallow = __v_isShallow;
924    this.dep = void 0;
925    this.__v_isRef = true;
926    this._rawValue = __v_isShallow ? value : toRaw(value);
927    this._value = __v_isShallow ? value : toReactive(value);
928  }
929  get value() {
930    trackRefValue(this);
931    return this._value;
932  }
933  set value(newVal) {
934    const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
935    newVal = useDirectValue ? newVal : toRaw(newVal);
936    if (hasChanged(newVal, this._rawValue)) {
937      this._rawValue = newVal;
938      this._value = useDirectValue ? newVal : toReactive(newVal);
939      triggerRefValue(this);
940    }
941  }
942}
943function unref(ref2) {
944  return isRef(ref2) ? ref2.value : ref2;
945}
946const shallowUnwrapHandlers = {
947  get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
948  set: (target, key, value, receiver) => {
949    const oldValue = target[key];
950    if (isRef(oldValue) && !isRef(value)) {
951      oldValue.value = value;
952      return true;
953    } else {
954      return Reflect.set(target, key, value, receiver);
955    }
956  }
957};
958function proxyRefs(objectWithRefs) {
959  return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
960}
961var _a;
962class ComputedRefImpl {
963  constructor(getter, _setter, isReadonly2, isSSR) {
964    this._setter = _setter;
965    this.dep = void 0;
966    this.__v_isRef = true;
967    this[_a] = false;
968    this._dirty = true;
969    this.effect = new ReactiveEffect(getter, () => {
970      if (!this._dirty) {
971        this._dirty = true;
972        triggerRefValue(this);
973      }
974    });
975    this.effect.computed = this;
976    this.effect.active = this._cacheable = !isSSR;
977    this["__v_isReadonly"] = isReadonly2;
978  }
979  get value() {
980    const self2 = toRaw(this);
981    trackRefValue(self2);
982    if (self2._dirty || !self2._cacheable) {
983      self2._dirty = false;
984      self2._value = self2.effect.run();
985    }
986    return self2._value;
987  }
988  set value(newValue) {
989    this._setter(newValue);
990  }
991}
992_a = "__v_isReadonly";
993function computed$1(getterOrOptions, debugOptions, isSSR = false) {
994  let getter;
995  let setter;
996  const onlyGetter = isFunction(getterOrOptions);
997  if (onlyGetter) {
998    getter = getterOrOptions;
999    setter = NOOP;
1000  } else {
1001    getter = getterOrOptions.get;
1002    setter = getterOrOptions.set;
1003  }
1004  const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
1005  return cRef;
1006}
1007const stack = [];
1008function warn(msg, ...args) {
1009  pauseTracking();
1010  const instance = stack.length ? stack[stack.length - 1].component : null;
1011  const appWarnHandler = instance && instance.appContext.config.warnHandler;
1012  const trace = getComponentTrace();
1013  if (appWarnHandler) {
1014    callWithErrorHandling(appWarnHandler, instance, 11, [
1015      msg + args.join(""),
1016      instance && instance.proxy,
1017      trace.map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`).join("\n"),
1018      trace
1019    ]);
1020  } else {
1021    const warnArgs = [`[Vue warn]: ${msg}`, ...args];
1022    if (trace.length && true) {
1023      warnArgs.push(`
1024`, ...formatTrace(trace));
1025    }
1026    console.warn(...warnArgs);
1027  }
1028  resetTracking();
1029}
1030function getComponentTrace() {
1031  let currentVNode = stack[stack.length - 1];
1032  if (!currentVNode) {
1033    return [];
1034  }
1035  const normalizedStack = [];
1036  while (currentVNode) {
1037    const last = normalizedStack[0];
1038    if (last && last.vnode === currentVNode) {
1039      last.recurseCount++;
1040    } else {
1041      normalizedStack.push({
1042        vnode: currentVNode,
1043        recurseCount: 0
1044      });
1045    }
1046    const parentInstance = currentVNode.component && currentVNode.component.parent;
1047    currentVNode = parentInstance && parentInstance.vnode;
1048  }
1049  return normalizedStack;
1050}
1051function formatTrace(trace) {
1052  const logs = [];
1053  trace.forEach((entry, i) => {
1054    logs.push(...i === 0 ? [] : [`
1055`], ...formatTraceEntry(entry));
1056  });
1057  return logs;
1058}
1059function formatTraceEntry({ vnode, recurseCount }) {
1060  const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
1061  const isRoot = vnode.component ? vnode.component.parent == null : false;

1062  const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;
1063  const close = `>` + postfix;
1064  return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
1065}
1066function formatProps(props) {
1067  const res = [];
1068  const keys = Object.keys(props);
1069  keys.slice(0, 3).forEach((key) => {
1070    res.push(...formatProp(key, props[key]));
1071  });
1072  if (keys.length > 3) {
1073    res.push(` ...`);
1074  }
1075  return res;
1076}
1077function formatProp(key, value, raw) {
1078  if (isString(value)) {
1079    value = JSON.stringify(value);
1080    return raw ? value : [`${key}=${value}`];
1081  } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
1082    return raw ? value : [`${key}=${value}`];
1083  } else if (isRef(value)) {
1084    value = formatProp(key, toRaw(value.value), true);
1085    return raw ? value : [`${key}=Ref<`, value, `>`];
1086  } else if (isFunction(value)) {
1087    return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
1088  } else {
1089    value = toRaw(value);
1090    return raw ? value : [`${key}=`, value];
1091  }
1092}
1093function callWithErrorHandling(fn, instance, type, args) {
1094  let res;
1095  try {
1096    res = args ? fn(...args) : fn();
1097  } catch (err) {
1098    handleError(err, instance, type);
1099  }
1100  return res;
1101}
1102function callWithAsyncErrorHandling(fn, instance, type, args) {
1103  if (isFunction(fn)) {
1104    const res = callWithErrorHandling(fn, instance, type, args);
1105    if (res && isPromise(res)) {
1106      res.catch((err) => {
1107        handleError(err, instance, type);
1108      });
1109    }
1110    return res;
1111  }
1112  const values = [];
1113  for (let i = 0; i < fn.length; i++) {
1114    values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
1115  }
1116  return values;
1117}
1118function handleError(err, instance, type, throwInDev = true) {
1119  const contextVNode = instance ? instance.vnode : null;
1120  if (instance) {
1121    let cur = instance.parent;
1122    const exposedInstance = instance.proxy;
1123    const errorInfo = type;
1124    while (cur) {

1125      const errorCapturedHooks = cur.ec;
1126      if (errorCapturedHooks) {
1127        for (let i = 0; i < errorCapturedHooks.length; i++) {
1128          if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
1129            return;
1130          }
1131        }
1132      }
1133      cur = cur.parent;
1134    }
1135    const appErrorHandler = instance.appContext.config.errorHandler;
1136    if (appErrorHandler) {
1137      callWithErrorHandling(appErrorHandler, null, 10, [err, exposedInstance, errorInfo]);
1138      return;
1139    }
1140  }
1141  logError(err, type, contextVNode, throwInDev);
1142}
1143function logError(err, type, contextVNode, throwInDev = true) {
1144  {
1145    console.error(err);
1146  }
1147}
1148let isFlushing = false;
1149let isFlushPending = false;
1150const queue = [];
1151let flushIndex = 0;
1152const pendingPostFlushCbs = [];
1153let activePostFlushCbs = null;
1154let postFlushIndex = 0;
1155const resolvedPromise = /* @__PURE__ */ Promise.resolve();
1156let currentFlushPromise = null;
1157function nextTick(fn) {
1158  const p = currentFlushPromise || resolvedPromise;
1159  return fn ? p.then(this ? fn.bind(this) : fn) : p;
1160}
1161function findInsertionIndex(id) {
1162  let start = flushIndex + 1;
1163  let end = queue.length;
1164  while (start < end) {
1165    const middle = start + end >>> 1;
1166    const middleJobId = getId(queue[middle]);
1167    middleJobId < id ? start = middle + 1 : end = middle;
1168  }
1169  return start;
1170}
1171function queueJob(job) {
1172  if (!queue.length || !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) {
1173    if (job.id == null) {
1174      queue.push(job);
1175    } else {
1176      queue.splice(findInsertionIndex(job.id), 0, job);
1177    }
1178    queueFlush();
1179  }
1180}
1181function queueFlush() {
1182  if (!isFlushing && !isFlushPending) {
1183    isFlushPending = true;
1184    currentFlushPromise = resolvedPromise.then(flushJobs);
1185  }
1186}

1187function invalidateJob(job) {
1188  const i = queue.indexOf(job);
1189  if (i > flushIndex) {
1190    queue.splice(i, 1);
1191  }
1192}
1193function queuePostFlushCb(cb) {
1194  if (!isArray(cb)) {
1195    if (!activePostFlushCbs || !activePostFlushCbs.includes(cb, cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex)) {
1196      pendingPostFlushCbs.push(cb);
1197    }
1198  } else {
1199    pendingPostFlushCbs.push(...cb);
1200  }
1201  queueFlush();
1202}
1203function flushPreFlushCbs(seen, i = isFlushing ? flushIndex + 1 : 0) {
1204  for (; i < queue.length; i++) {
1205    const cb = queue[i];
1206    if (cb && cb.pre) {
1207      queue.splice(i, 1);
1208      i--;
1209      cb();
1210    }
1211  }
1212}
1213function flushPostFlushCbs(seen) {
1214  if (pendingPostFlushCbs.length) {
1215    const deduped = [...new Set(pendingPostFlushCbs)];
1216    pendingPostFlushCbs.length = 0;
1217    if (activePostFlushCbs) {
1218      activePostFlushCbs.push(...deduped);
1219      return;
1220    }
1221    activePostFlushCbs = deduped;
1222    activePostFlushCbs.sort((a, b) => getId(a) - getId(b));
1223    for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
1224      activePostFlushCbs[postFlushIndex]();
1225    }
1226    activePostFlushCbs = null;
1227    postFlushIndex = 0;
1228  }
1229}
1230const getId = (job) => job.id == null ? Infinity : job.id;
1231const comparator = (a, b) => {
1232  const diff = getId(a) - getId(b);
1233  if (diff === 0) {
1234    if (a.pre && !b.pre)
1235      return -1;
1236    if (b.pre && !a.pre)
1237      return 1;
1238  }
1239  return diff;
1240};
1241function flushJobs(seen) {
1242  isFlushPending = false;
1243  isFlushing = true;
1244  queue.sort(comparator);
1245  const check = NOOP;
1246  try {
1247    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
1248      const job = queue[flushIndex];
1249      if (job && job.active !== false) {
1250        if (false)
1251          ;
1252        callWithErrorHandling(job, null, 14);
1253      }
1254    }
1255  } finally {
1256    flushIndex = 0;
1257    queue.length = 0;
1258    flushPostFlushCbs();
1259    isFlushing = false;
1260    currentFlushPromise = null;
1261    if (queue.length || pendingPostFlushCbs.length) {
1262      flushJobs();
1263    }
1264  }
1265}
1266function emit$1(instance, event, ...rawArgs) {
1267  if (instance.isUnmounted)
1268    return;
1269  const props = instance.vnode.props || EMPTY_OBJ;
1270  let args = rawArgs;
1271  const isModelListener2 = event.startsWith("update:");
1272  const modelArg = isModelListener2 && event.slice(7);
1273  if (modelArg && modelArg in props) {
1274    const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`;
1275    const { number, trim } = props[modifiersKey] || EMPTY_OBJ;
1276    if (trim) {
1277      args = rawArgs.map((a) => a.trim());
1278    }
1279    if (number) {
1280      args = rawArgs.map(toNumber);
1281    }
1282  }
1283  let handlerName;
1284  let handler = props[handlerName = toHandlerKey(event)] || props[handlerName = toHandlerKey(camelize(event))];
1285  if (!handler && isModelListener2) {
1286    handler = props[handlerName = toHandlerKey(hyphenate(event))];
1287  }
1288  if (handler) {
1289    callWithAsyncErrorHandling(handler, instance, 6, args);
1290  }
1291  const onceHandler = props[handlerName + `Once`];
1292  if (onceHandler) {
1293    if (!instance.emitted) {
1294      instance.emitted = {};
1295    } else if (instance.emitted[handlerName]) {
1296      return;
1297    }
1298    instance.emitted[handlerName] = true;
1299    callWithAsyncErrorHandling(onceHandler, instance, 6, args);
1300  }
1301}
1302function normalizeEmitsOptions(comp, appContext, asMixin = false) {
1303  const cache = appContext.emitsCache;
1304  const cached = cache.get(comp);
1305  if (cached !== void 0) {
1306    return cached;
1307  }
1308  const raw = comp.emits;
1309  let normalized = {};
1310  let hasExtends = false;
1311  if (!isFunction(comp)) {
1312    const extendEmits = (raw2) => {
1313      const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
1314      if (normalizedFromExtend) {
1315        hasExtends = true;
1316        extend(normalized, normalizedFromExtend);
1317      }
1318    };
1319    if (!asMixin && appContext.mixins.length) {
1320      appContext.mixins.forEach(extendEmits);
1321    }
1322    if (comp.extends) {
1323      extendEmits(comp.extends);
1324    }
1325    if (comp.mixins) {
1326      comp.mixins.forEach(extendEmits);
1327    }
1328  }
1329  if (!raw && !hasExtends) {
1330    if (isObject(comp)) {
1331      cache.set(comp, null);
1332    }
1333    return null;
1334  }
1335  if (isArray(raw)) {
1336    raw.forEach((key) => normalized[key] = null);
1337  } else {
1338    extend(normalized, raw);
1339  }
1340  if (isObject(comp)) {
1341    cache.set(comp, normalized);
1342  }
1343  return normalized;
1344}
1345function isEmitListener(options, key) {
1346  if (!options || !isOn(key)) {
1347    return false;

1348  }
1349  key = key.slice(2).replace(/Once$/, "");
1350  return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
1351}
1352let currentRenderingInstance = null;
1353let currentScopeId = null;
1354function setCurrentRenderingInstance(instance) {
1355  const prev = currentRenderingInstance;
1356  currentRenderingInstance = instance;
1357  currentScopeId = instance && instance.type.__scopeId || null;
1358  return prev;
1359}
1360function pushScopeId(id) {
1361  currentScopeId = id;
1362}
1363function popScopeId() {
1364  currentScopeId = null;
1365}
1366function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
1367  if (!ctx)
1368    return fn;
1369  if (fn._n) {
1370    return fn;
1371  }
1372  const renderFnWithContext = (...args) => {
1373    if (renderFnWithContext._d) {
1374      setBlockTracking(-1);
1375    }
1376    const prevInstance = setCurrentRenderingInstance(ctx);
1377    let res;
1378    try {
1379      res = fn(...args);
1380    } finally {
1381      setCurrentRenderingInstance(prevInstance);
1382      if (renderFnWithContext._d) {
1383        setBlockTracking(1);
1384      }
1385    }
1386    return res;
1387  };
1388  renderFnWithContext._n = true;
1389  renderFnWithContext._c = true;
1390  renderFnWithContext._d = true;
1391  return renderFnWithContext;
1392}
1393function markAttrsAccessed() {
1394}
1395function renderComponentRoot(instance) {
1396  const { type: Component, vnode, proxy, withProxy, props, propsOptions: [propsOptions], slots, attrs, emit, render, renderCache, data, setupState, ctx, inheritAttrs } = instance;
1397  let result;
1398  let fallthroughAttrs;
1399  const prev = setCurrentRenderingInstance(instance);
1400  try {
1401    if (vnode.shapeFlag & 4) {
1402      const proxyToUse = withProxy || proxy;
1403      result = normalizeVNode(render.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx));
1404      fallthroughAttrs = attrs;
1405    } else {
1406      const render2 = Component;
1407      if (false)
1408        ;
1409      result = normalizeVNode(render2.length > 1 ? render2(props, false ? {
1410        get attrs() {
1411          markAttrsAccessed();
1412          return attrs;
1413        },
1414        slots,
1415        emit
1416      } : { attrs, slots, emit }) : render2(props, null));
1417      fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
1418    }
1419  } catch (err) {
1420    blockStack.length = 0;
1421    handleError(err, instance, 1);
1422    result = createVNode(Comment);
1423  }
1424  let root = result;
1425  if (fallthroughAttrs && inheritAttrs !== false) {
1426    const keys = Object.keys(fallthroughAttrs);
1427    const { shapeFlag } = root;
1428    if (keys.length) {
1429      if (shapeFlag & (1 | 6)) {
1430        if (propsOptions && keys.some(isModelListener)) {
1431          fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions);
1432        }
1433        root = cloneVNode(root, fallthroughAttrs);
1434      }
1435    }
1436  }
1437  if (vnode.dirs) {
1438    root = cloneVNode(root);
1439    root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
1440  }
1441  if (vnode.transition) {
1442    root.transition = vnode.transition;
1443  }
1444  {
1445    result = root;
1446  }
1447  setCurrentRenderingInstance(prev);
1448  return result;
1449}
1450const getFunctionalFallthrough = (attrs) => {
1451  let res;
1452  for (const key in attrs) {
1453    if (key === "class" || key === "style" || isOn(key)) {
1454      (res || (res = {}))[key] = attrs[key];
1455    }
1456  }
1457  return res;
1458};
1459const filterModelListeners = (attrs, props) => {
1460  const res = {};
1461  for (const key in attrs) {
1462    if (!isModelListener(key) || !(key.slice(9) in props)) {
1463      res[key] = attrs[key];
1464    }
1465  }
1466  return res;
1467};
1468function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
1469  const { props: prevProps, children: prevChildren, component } = prevVNode;
1470  const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
1471  const emits = component.emitsOptions;
1472  if (nextVNode.dirs || nextVNode.transition) {
1473    return true;
1474  }
1475  if (optimized && patchFlag >= 0) {
1476    if (patchFlag & 1024) {
1477      return true;
1478    }
1479    if (patchFlag & 16) {
1480      if (!prevProps) {
1481        return !!nextProps;
1482      }
1483      return hasPropsChanged(prevProps, nextProps, emits);
1484    } else if (patchFlag & 8) {
1485      const dynamicProps = nextVNode.dynamicProps;
1486      for (let i = 0; i < dynamicProps.length; i++) {

1487        const key = dynamicProps[i];
1488        if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
1489          return true;
1490        }
1491      }
1492    }
1493  } else {
1494    if (prevChildren || nextChildren) {
1495      if (!nextChildren || !nextChildren.$stable) {
1496        return true;
1497      }
1498    }
1499    if (prevProps === nextProps) {
1500      return false;
1501    }
1502    if (!prevProps) {
1503      return !!nextProps;
1504    }
1505    if (!nextProps) {
1506      return true;
1507    }
1508    return hasPropsChanged(prevProps, nextProps, emits);
1509  }
1510  return false;
1511}
1512function hasPropsChanged(prevProps, nextProps, emitsOptions) {
1513  const nextKeys = Object.keys(nextProps);
1514  if (nextKeys.length !== Object.keys(prevProps).length) {
1515    return true;
1516  }
1517  for (let i = 0; i < nextKeys.length; i++) {
1518    const key = nextKeys[i];
1519    if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
1520      return true;
1521    }
1522  }
1523  return false;
1524}
1525function updateHOCHostEl({ vnode, parent }, el) {
1526  while (parent && parent.subTree === vnode) {
1527    (vnode = parent.vnode).el = el;
1528    parent = parent.parent;
1529  }
1530}
1531const isSuspense = (type) => type.__isSuspense;
1532function queueEffectWithSuspense(fn, suspense) {
1533  if (suspense && suspense.pendingBranch) {
1534    if (isArray(fn)) {
1535      suspense.effects.push(...fn);
1536    } else {
1537      suspense.effects.push(fn);
1538    }
1539  } else {
1540    queuePostFlushCb(fn);
1541  }
1542}
1543function provide(key, value) {
1544  if (!currentInstance)
1545    ;
1546  else {
1547    let provides = currentInstance.provides;
1548    const parentProvides = currentInstance.parent && currentInstance.parent.provides;
1549    if (parentProvides === provides) {
1550      provides = currentInstance.provides = Object.create(parentProvides);
1551    }
1552    provides[key] = value;
1553  }
1554}
1555function inject(key, defaultValue, treatDefaultAsFactory = false) {
1556  const instance = currentInstance || currentRenderingInstance;
1557  if (instance) {
1558    const provides = instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides;
1559    if (provides && key in provides) {
1560      return provides[key];
1561    } else if (arguments.length > 1) {
1562      return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance.proxy) : defaultValue;
1563    } else
1564      ;
1565  }
1566}
1567function watchPostEffect(effect, options) {
1568  return doWatch(effect, null, { flush: "post" });
1569}
1570const INITIAL_WATCHER_VALUE = {};
1571function watch(source, cb, options) {
1572  return doWatch(source, cb, options);
1573}
1574function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ) {
1575  const instance = currentInstance;
1576  let getter;
1577  let forceTrigger = false;
1578  let isMultiSource = false;

1579  if (isRef(source)) {
1580    getter = () => source.value;
1581    forceTrigger = isShallow(source);
1582  } else if (isReactive(source)) {
1583    getter = () => source;
1584    deep = true;
1585  } else if (isArray(source)) {
1586    isMultiSource = true;
1587    forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
1588    getter = () => source.map((s) => {
1589      if (isRef(s)) {
1590        return s.value;
1591      } else if (isReactive(s)) {
1592        return traverse(s);
1593      } else if (isFunction(s)) {
1594        return callWithErrorHandling(s, instance, 2);
1595      } else
1596        ;
1597    });
1598  } else if (isFunction(source)) {
1599    if (cb) {
1600      getter = () => callWithErrorHandling(source, instance, 2);
1601    } else {
1602      getter = () => {
1603        if (instance && instance.isUnmounted) {
1604          return;
1605        }
1606        if (cleanup) {
1607          cleanup();
1608        }
1609        return callWithAsyncErrorHandling(source, instance, 3, [onCleanup]);
1610      };
1611    }
1612  } else {
1613    getter = NOOP;
1614  }
1615  if (cb && deep) {
1616    const baseGetter = getter;
1617    getter = () => traverse(baseGetter());
1618  }
1619  let cleanup;
1620  let onCleanup = (fn) => {
1621    cleanup = effect.onStop = () => {
1622      callWithErrorHandling(fn, instance, 4);
1623    };
1624  };
1625  if (isInSSRComponentSetup) {
1626    onCleanup = NOOP;
1627    if (!cb) {
1628      getter();
1629    } else if (immediate) {
1630      callWithAsyncErrorHandling(cb, instance, 3, [
1631        getter(),
1632        isMultiSource ? [] : void 0,
1633        onCleanup
1634      ]);
1635    }
1636    return NOOP;
1637  }
1638  let oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE;
1639  const job = () => {
1640    if (!effect.active) {
1641      return;
1642    }
1643    if (cb) {
1644      const newValue = effect.run();
1645      if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || false) {
1646        if (cleanup) {
1647          cleanup();
1648        }
1649        callWithAsyncErrorHandling(cb, instance, 3, [
1650          newValue,
1651          oldValue === INITIAL_WATCHER_VALUE ? void 0 : oldValue,
1652          onCleanup
1653        ]);
1654        oldValue = newValue;
1655      }
1656    } else {
1657      effect.run();
1658    }
1659  };
1660  job.allowRecurse = !!cb;
1661  let scheduler;
1662  if (flush === "sync") {
1663    scheduler = job;
1664  } else if (flush === "post") {
1665    scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
1666  } else {
1667    job.pre = true;
1668    if (instance)
1669      job.id = instance.uid;
1670    scheduler = () => queueJob(job);
1671  }
1672  const effect = new ReactiveEffect(getter, scheduler);
1673  if (cb) {
1674    if (immediate) {
1675      job();
1676    } else {
1677      oldValue = effect.run();
1678    }
1679  } else if (flush === "post") {
1680    queuePostRenderEffect(effect.run.bind(effect), instance && instance.suspense);
1681  } else {
1682    effect.run();
1683  }
1684  return () => {
1685    effect.stop();
1686    if (instance && instance.scope) {
1687      remove(instance.scope.effects, effect);
1688    }
1689  };
1690}
1691function instanceWatch(source, value, options) {
1692  const publicThis = this.proxy;
1693  const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
1694  let cb;
1695  if (isFunction(value)) {
1696    cb = value;
1697  } else {
1698    cb = value.handler;
1699    options = value;
1700  }
1701  const cur = currentInstance;
1702  setCurrentInstance(this);
1703  const res = doWatch(getter, cb.bind(publicThis), options);
1704  if (cur) {
1705    setCurrentInstance(cur);
1706  } else {
1707    unsetCurrentInstance();
1708  }
1709  return res;
1710}
1711function createPathGetter(ctx, path) {
1712  const segments = path.split(".");
1713  return () => {

1714    let cur = ctx;
1715    for (let i = 0; i < segments.length && cur; i++) {
1716      cur = cur[segments[i]];
1717    }
1718    return cur;
1719  };
1720}
1721function traverse(value, seen) {
1722  if (!isObject(value) || value["__v_skip"]) {
1723    return value;
1724  }
1725  seen = seen || /* @__PURE__ */ new Set();
1726  if (seen.has(value)) {
1727    return value;
1728  }
1729  seen.add(value);
1730  if (isRef(value)) {
1731    traverse(value.value, seen);
1732  } else if (isArray(value)) {
1733    for (let i = 0; i < value.length; i++) {
1734      traverse(value[i], seen);
1735    }
1736  } else if (isSet(value) || isMap(value)) {
1737    value.forEach((v) => {
1738      traverse(v, seen);
1739    });
1740  } else if (isPlainObject(value)) {
1741    for (const key in value) {
1742      traverse(value[key], seen);
1743    }
1744  }
1745  return value;
1746}
1747function defineComponent(options) {
1748  return isFunction(options) ? { setup: options, name: options.name } : options;
1749}
1750const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
1751const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
1752function onActivated(hook, target) {
1753  registerKeepAliveHook(hook, "a", target);
1754}
1755function onDeactivated(hook, target) {
1756  registerKeepAliveHook(hook, "da", target);
1757}
1758function registerKeepAliveHook(hook, type, target = currentInstance) {
1759  const wrappedHook = hook.__wdc || (hook.__wdc = () => {

1760    let current = target;
1761    while (current) {
1762      if (current.isDeactivated) {
1763        return;
1764      }
1765      current = current.parent;
1766    }
1767    return hook();
1768  });
1769  injectHook(type, wrappedHook, target);
1770  if (target) {
1771    let current = target.parent;
1772    while (current && current.parent) {
1773      if (isKeepAlive(current.parent.vnode)) {
1774        injectToKeepAliveRoot(wrappedHook, type, target, current);
1775      }
1776      current = current.parent;
1777    }
1778  }
1779}
1780function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
1781  const injected = injectHook(type, hook, keepAliveRoot, true);
1782  onUnmounted(() => {
1783    remove(keepAliveRoot[type], injected);
1784  }, target);
1785}
1786function injectHook(type, hook, target = currentInstance, prepend = false) {
1787  if (target) {
1788    const hooks = target[type] || (target[type] = []);
1789    const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
1790      if (target.isUnmounted) {
1791        return;
1792      }
1793      pauseTracking();
1794      setCurrentInstance(target);
1795      const res = callWithAsyncErrorHandling(hook, target, type, args);
1796      unsetCurrentInstance();
1797      resetTracking();
1798      return res;
1799    });
1800    if (prepend) {
1801      hooks.unshift(wrappedHook);
1802    } else {
1803      hooks.push(wrappedHook);
1804    }
1805    return wrappedHook;
1806  }
1807}
1808const createHook = (lifecycle) => (hook, target = currentInstance) => (!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, (...args) => hook(...args), target);
1809const onBeforeMount = createHook("bm");
1810const onMounted = createHook("m");
1811const onBeforeUpdate = createHook("bu");
1812const onUpdated = createHook("u");
1813const onBeforeUnmount = createHook("bum");
1814const onUnmounted = createHook("um");
1815const onServerPrefetch = createHook("sp");
1816const onRenderTriggered = createHook("rtg");
1817const onRenderTracked = createHook("rtc");
1818function onErrorCaptured(hook, target = currentInstance) {
1819  injectHook("ec", hook, target);
1820}
1821function invokeDirectiveHook(vnode, prevVNode, instance, name) {
1822  const bindings = vnode.dirs;
1823  const oldBindings = prevVNode && prevVNode.dirs;
1824  for (let i = 0; i < bindings.length; i++) {
1825    const binding = bindings[i];
1826    if (oldBindings) {
1827      binding.oldValue = oldBindings[i].value;
1828    }
1829    let hook = binding.dir[name];
1830    if (hook) {
1831      pauseTracking();
1832      callWithAsyncErrorHandling(hook, instance, 8, [
1833        vnode.el,
1834        binding,
1835        vnode,
1836        prevVNode
1837      ]);
1838      resetTracking();
1839    }
1840  }
1841}
1842const NULL_DYNAMIC_COMPONENT = Symbol();
1843function renderList(source, renderItem, cache, index) {
1844  let ret;
1845  const cached = cache && cache[index];
1846  if (isArray(source) || isString(source)) {
1847    ret = new Array(source.length);
1848    for (let i = 0, l = source.length; i < l; i++) {
1849      ret[i] = renderItem(source[i], i, void 0, cached && cached[i]);
1850    }
1851  } else if (typeof source === "number") {
1852    ret = new Array(source);
1853    for (let i = 0; i < source; i++) {
1854      ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
1855    }
1856  } else if (isObject(source)) {
1857    if (source[Symbol.iterator]) {
1858      ret = Array.from(source, (item, i) => renderItem(item, i, void 0, cached && cached[i]));
1859    } else {
1860      const keys = Object.keys(source);
1861      ret = new Array(keys.length);
1862      for (let i = 0, l = keys.length; i < l; i++) {
1863        const key = keys[i];
1864        ret[i] = renderItem(source[key], key, i, cached && cached[i]);
1865      }
1866    }
1867  } else {
1868    ret = [];
1869  }
1870  if (cache) {
1871    cache[index] = ret;
1872  }
1873  return ret;
1874}
1875function renderSlot(slots, name, props = {}, fallback, noSlotted) {
1876  if (currentRenderingInstance.isCE || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.isCE) {
1877    return createVNode("slot", name === "default" ? null : { name }, fallback && fallback());
1878  }
1879  let slot = slots[name];
1880  if (slot && slot._c) {
1881    slot._d = false;
1882  }
1883  openBlock();
1884  const validSlotContent = slot && ensureValidVNode(slot(props));
1885  const rendered = createBlock(Fragment, {
1886    key: props.key || validSlotContent && validSlotContent.key || `_${name}`
1887  }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 ? 64 : -2);
1888  if (!noSlotted && rendered.scopeId) {
1889    rendered.slotScopeIds = [rendered.scopeId + "-s"];
1890  }
1891  if (slot && slot._c) {
1892    slot._d = true;
1893  }
1894  return rendered;
1895}
1896function ensureValidVNode(vnodes) {
1897  return vnodes.some((child) => {
1898    if (!isVNode(child))
1899      return true;
1900    if (child.type === Comment)
1901      return false;
1902    if (child.type === Fragment && !ensureValidVNode(child.children))
1903      return false;
1904    return true;
1905  }) ? vnodes : null;
1906}
1907const getPublicInstance = (i) => {
1908  if (!i)
1909    return null;
1910  if (isStatefulComponent(i))
1911    return getExposeProxy(i) || i.proxy;
1912  return getPublicInstance(i.parent);
1913};
1914const publicPropertiesMap = /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {
1915  $: (i) => i,
1916  $el: (i) => i.vnode.el,
1917  $data: (i) => i.data,
1918  $props: (i) => i.props,
1919  $attrs: (i) => i.attrs,
1920  $slots: (i) => i.slots,
1921  $refs: (i) => i.refs,
1922  $parent: (i) => getPublicInstance(i.parent),
1923  $root: (i) => getPublicInstance(i.root),
1924  $emit: (i) => i.emit,
1925  $options: (i) => resolveMergedOptions(i),
1926  $forceUpdate: (i) => i.f || (i.f = () => queueJob(i.update)),
1927  $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
1928  $watch: (i) => instanceWatch.bind(i)
1929});
1930const PublicInstanceProxyHandlers = {
1931  get({ _: instance }, key) {
1932    const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
1933    let normalizedProps;
1934    if (key[0] !== "$") {
1935      const n = accessCache[key];
1936      if (n !== void 0) {
1937        switch (n) {
1938          case 1:
1939            return setupState[key];
1940          case 2:
1941            return data[key];
1942          case 4:
1943            return ctx[key];
1944          case 3:
1945            return props[key];
1946        }
1947      } else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {
1948        accessCache[key] = 1;
1949        return setupState[key];
1950      } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
1951        accessCache[key] = 2;
1952        return data[key];
1953      } else if ((normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)) {
1954        accessCache[key] = 3;
1955        return props[key];
1956      } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
1957        accessCache[key] = 4;
1958        return ctx[key];
1959      } else if (shouldCacheAccess) {
1960        accessCache[key] = 0;
1961      }
1962    }
1963    const publicGetter = publicPropertiesMap[key];
1964    let cssModule, globalProperties;
1965    if (publicGetter) {
1966      if (key === "$attrs") {
1967        track(instance, "get", key);
1968      }
1969      return publicGetter(instance);
1970    } else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) {
1971      return cssModule;
1972    } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
1973      accessCache[key] = 4;
1974      return ctx[key];
1975    } else if (globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)) {
1976      {
1977        return globalProperties[key];
1978      }
1979    } else
1980      ;
1981  },
1982  set({ _: instance }, key, value) {
1983    const { data, setupState, ctx } = instance;
1984    if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {
1985      setupState[key] = value;
1986      return true;
1987    } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
1988      data[key] = value;
1989      return true;
1990    } else if (hasOwn(instance.props, key)) {
1991      return false;
1992    }
1993    if (key[0] === "$" && key.slice(1) in instance) {
1994      return false;
1995    } else {
1996      {
1997        ctx[key] = value;
1998      }
1999    }
2000    return true;
2001  },
2002  has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {
2003    let normalizedProps;
2004    return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || setupState !== EMPTY_OBJ && hasOwn(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
2005  },
2006  defineProperty(target, key, descriptor) {
2007    if (descriptor.get != null) {
2008      target._.accessCache[key] = 0;
2009    } else if (hasOwn(descriptor, "value")) {
2010      this.set(target, key, descriptor.value, null);
2011    }
2012    return Reflect.defineProperty(target, key, descriptor);
2013  }
2014};
2015let shouldCacheAccess = true;
2016function applyOptions(instance) {
2017  const options = resolveMergedOptions(instance);
2018  const publicThis = instance.proxy;
2019  const ctx = instance.ctx;
2020  shouldCacheAccess = false;
2021  if (options.beforeCreate) {
2022    callHook(options.beforeCreate, instance, "bc");
2023  }
2024  const {
2025    data: dataOptions,
2026    computed: computedOptions,
2027    methods,
2028    watch: watchOptions,
2029    provide: provideOptions,
2030    inject: injectOptions,
2031    created,
2032    beforeMount,
2033    mounted,
2034    beforeUpdate,
2035    updated,
2036    activated,
2037    deactivated,
2038    beforeDestroy,
2039    beforeUnmount,
2040    destroyed,
2041    unmounted,
2042    render,
2043    renderTracked,
2044    renderTriggered,
2045    errorCaptured,
2046    serverPrefetch,
2047    expose,
2048    inheritAttrs,
2049    components,
2050    directives,
2051    filters
2052  } = options;
2053  const checkDuplicateProperties = null;
2054  if (injectOptions) {
2055    resolveInjections(injectOptions, ctx, checkDuplicateProperties, instance.appContext.config.unwrapInjectedRef);
2056  }
2057  if (methods) {
2058    for (const key in methods) {
2059      const methodHandler = methods[key];
2060      if (isFunction(methodHandler)) {
2061        {
2062          ctx[key] = methodHandler.bind(publicThis);
2063        }
2064      }
2065    }
2066  }
2067  if (dataOptions) {
2068    const data = dataOptions.call(publicThis, publicThis);
2069    if (!isObject(data))
2070      ;
2071    else {
2072      instance.data = reactive(data);
2073    }
2074  }
2075  shouldCacheAccess = true;
2076  if (computedOptions) {
2077    for (const key in computedOptions) {
2078      const opt = computedOptions[key];
2079      const get2 = isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;
2080      const set2 = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : NOOP;
2081      const c = computed({
2082        get: get2,
2083        set: set2
2084      });
2085      Object.defineProperty(ctx, key, {
2086        enumerable: true,
2087        configurable: true,
2088        get: () => c.value,
2089        set: (v) => c.value = v
2090      });
2091    }
2092  }
2093  if (watchOptions) {
2094    for (const key in watchOptions) {
2095      createWatcher(watchOptions[key], ctx, publicThis, key);
2096    }
2097  }
2098  if (provideOptions) {
2099    const provides = isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
2100    Reflect.ownKeys(provides).forEach((key) => {
2101      provide(key, provides[key]);
2102    });
2103  }
2104  if (created) {
2105    callHook(created, instance, "c");
2106  }
2107  function registerLifecycleHook(register, hook) {
2108    if (isArray(hook)) {
2109      hook.forEach((_hook) => register(_hook.bind(publicThis)));
2110    } else if (hook) {
2111      register(hook.bind(publicThis));
2112    }
2113  }
2114  registerLifecycleHook(onBeforeMount, beforeMount);
2115  registerLifecycleHook(onMounted, mounted);
2116  registerLifecycleHook(onBeforeUpdate, beforeUpdate);
2117  registerLifecycleHook(onUpdated, updated);
2118  registerLifecycleHook(onActivated, activated);
2119  registerLifecycleHook(onDeactivated, deactivated);
2120  registerLifecycleHook(onErrorCaptured, errorCaptured);
2121  registerLifecycleHook(onRenderTracked, renderTracked);
2122  registerLifecycleHook(onRenderTriggered, renderTriggered);
2123  registerLifecycleHook(onBeforeUnmount, beforeUnmount);
2124  registerLifecycleHook(onUnmounted, unmounted);
2125  registerLifecycleHook(onServerPrefetch, serverPrefetch);
2126  if (isArray(expose)) {
2127    if (expose.length) {
2128      const exposed = instance.exposed || (instance.exposed = {});
2129      expose.forEach((key) => {
2130        Object.defineProperty(exposed, key, {
2131          get: () => publicThis[key],
2132          set: (val) => publicThis[key] = val
2133        });
2134      });
2135    } else if (!instance.exposed) {
2136      instance.exposed = {};
2137    }
2138  }
2139  if (render && instance.render === NOOP) {
2140    instance.render = render;
2141  }
2142  if (inheritAttrs != null) {
2143    instance.inheritAttrs = inheritAttrs;
2144  }
2145  if (components)
2146    instance.components = components;
2147  if (directives)
2148    instance.directives = directives;
2149}
2150function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP, unwrapRef = false) {
2151  if (isArray(injectOptions)) {
2152    injectOptions = normalizeInject(injectOptions);
2153  }
2154  for (const key in injectOptions) {
2155    const opt = injectOptions[key];
2156    let injected;
2157    if (isObject(opt)) {
2158      if ("default" in opt) {
2159        injected = inject(opt.from || key, opt.default, true);
2160      } else {
2161        injected = inject(opt.from || key);
2162      }
2163    } else {
2164      injected = inject(opt);
2165    }
2166    if (isRef(injected)) {
2167      if (unwrapRef) {
2168        Object.defineProperty(ctx, key, {
2169          enumerable: true,
2170          configurable: true,
2171          get: () => injected.value,
2172          set: (v) => injected.value = v
2173        });
2174      } else {
2175        ctx[key] = injected;
2176      }
2177    } else {
2178      ctx[key] = injected;
2179    }
2180  }
2181}
2182function callHook(hook, instance, type) {
2183  callWithAsyncErrorHandling(isArray(hook) ? hook.map((h2) => h2.bind(instance.proxy)) : hook.bind(instance.proxy), instance, type);
2184}
2185function createWatcher(raw, ctx, publicThis, key) {
2186  const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
2187  if (isString(raw)) {
2188    const handler = ctx[raw];
2189    if (isFunction(handler)) {
2190      watch(getter, handler);
2191    }
2192  } else if (isFunction(raw)) {
2193    watch(getter, raw.bind(publicThis));
2194  } else if (isObject(raw)) {
2195    if (isArray(raw)) {
2196      raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
2197    } else {
2198      const handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
2199      if (isFunction(handler)) {
2200        watch(getter, handler, raw);
2201      }
2202    }
2203  } else
2204    ;
2205}
2206function resolveMergedOptions(instance) {
2207  const base = instance.type;
2208  const { mixins, extends: extendsOptions } = base;
2209  const { mixins: globalMixins, optionsCache: cache, config: { optionMergeStrategies } } = instance.appContext;
2210  const cached = cache.get(base);
2211  let resolved;
2212  if (cached) {
2213    resolved = cached;
2214  } else if (!globalMixins.length && !mixins && !extendsOptions) {
2215    {
2216      resolved = base;
2217    }
2218  } else {
2219    resolved = {};
2220    if (globalMixins.length) {
2221      globalMixins.forEach((m) => mergeOptions(resolved, m, optionMergeStrategies, true));
2222    }
2223    mergeOptions(resolved, base, optionMergeStrategies);
2224  }
2225  if (isObject(base)) {
2226    cache.set(base, resolved);
2227  }
2228  return resolved;
2229}
2230function mergeOptions(to, from, strats, asMixin = false) {
2231  const { mixins, extends: extendsOptions } = from;
2232  if (extendsOptions) {
2233    mergeOptions(to, extendsOptions, strats, true);
2234  }
2235  if (mixins) {
2236    mixins.forEach((m) => mergeOptions(to, m, strats, true));
2237  }
2238  for (const key in from) {
2239    if (asMixin && key === "expose")
2240      ;
2241    else {
2242      const strat = internalOptionMergeStrats[key] || strats && strats[key];
2243      to[key] = strat ? strat(to[key], from[key]) : from[key];
2244    }
2245  }
2246  return to;
2247}
2248const internalOptionMergeStrats = {
2249  data: mergeDataFn,
2250  props: mergeObjectOptions,
2251  emits: mergeObjectOptions,
2252  methods: mergeObjectOptions,
2253  computed: mergeObjectOptions,
2254  beforeCreate: mergeAsArray,
2255  created: mergeAsArray,
2256  beforeMount: mergeAsArray,
2257  mounted: mergeAsArray,
2258  beforeUpdate: mergeAsArray,
2259  updated: mergeAsArray,
2260  beforeDestroy: mergeAsArray,
2261  beforeUnmount: mergeAsArray,
2262  destroyed: mergeAsArray,
2263  unmounted: mergeAsArray,
2264  activated: mergeAsArray,
2265  deactivated: mergeAsArray,
2266  errorCaptured: mergeAsArray,
2267  serverPrefetch: mergeAsArray,
2268  components: mergeObjectOptions,
2269  directives: mergeObjectOptions,
2270  watch: mergeWatchOptions,
2271  provide: mergeDataFn,
2272  inject: mergeInject
2273};
2274function mergeDataFn(to, from) {
2275  if (!from) {
2276    return to;
2277  }
2278  if (!to) {
2279    return from;
2280  }
2281  return function mergedDataFn() {
2282    return extend(isFunction(to) ? to.call(this, this) : to, isFunction(from) ? from.call(this, this) : from);
2283  };
2284}
2285function mergeInject(to, from) {
2286  return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
2287}
2288function normalizeInject(raw) {
2289  if (isArray(raw)) {
2290    const res = {};
2291    for (let i = 0; i < raw.length; i++) {
2292      res[raw[i]] = raw[i];
2293    }
2294    return res;
2295  }
2296  return raw;
2297}
2298function mergeAsArray(to, from) {
2299  return to ? [...new Set([].concat(to, from))] : from;
2300}
2301function mergeObjectOptions(to, from) {
2302  return to ? extend(extend(/* @__PURE__ */ Object.create(null), to), from) : from;
2303}
2304function mergeWatchOptions(to, from) {
2305  if (!to)
2306    return from;
2307  if (!from)
2308    return to;
2309  const merged = extend(/* @__PURE__ */ Object.create(null), to);
2310  for (const key in from) {
2311    merged[key] = mergeAsArray(to[key], from[key]);
2312  }
2313  return merged;
2314}
2315function initProps(instance, rawProps, isStateful, isSSR = false) {
2316  const props = {};
2317  const attrs = {};
2318  def(attrs, InternalObjectKey, 1);
2319  instance.propsDefaults = /* @__PURE__ */ Object.create(null);
2320  setFullProps(instance, rawProps, props, attrs);
2321  for (const key in instance.propsOptions[0]) {
2322    if (!(key in props)) {
2323      props[key] = void 0;
2324    }
2325  }
2326  if (isStateful) {
2327    instance.props = isSSR ? props : shallowReactive(props);
2328  } else {
2329    if (!instance.type.props) {
2330      instance.props = attrs;
2331    } else {
2332      instance.props = props;
2333    }
2334  }
2335  instance.attrs = attrs;
2336}
2337function updateProps(instance, rawProps, rawPrevProps, optimized) {
2338  const { props, attrs, vnode: { patchFlag } } = instance;
2339  const rawCurrentProps = toRaw(props);
2340  const [options] = instance.propsOptions;
2341  let hasAttrsChanged = false;
2342  if ((optimized || patchFlag > 0) && !(patchFlag & 16)) {
2343    if (patchFlag & 8) {
2344      const propsToUpdate = instance.vnode.dynamicProps;
2345      for (let i = 0; i < propsToUpdate.length; i++) {
2346        let key = propsToUpdate[i];
2347        if (isEmitListener(instance.emitsOptions, key)) {
2348          continue;
2349        }
2350        const value = rawProps[key];
2351        if (options) {
2352          if (hasOwn(attrs, key)) {
2353            if (value !== attrs[key]) {
2354              attrs[key] = value;
2355              hasAttrsChanged = true;
2356            }
2357          } else {
2358            const camelizedKey = camelize(key);
2359            props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance, false);
2360          }
2361        } else {
2362          if (value !== attrs[key]) {
2363            attrs[key] = value;
2364            hasAttrsChanged = true;
2365          }
2366        }
2367      }
2368    }
2369  } else {
2370    if (setFullProps(instance, rawProps, props, attrs)) {
2371      hasAttrsChanged = true;
2372    }
2373    let kebabKey;
2374    for (const key in rawCurrentProps) {
2375      if (!rawProps || !hasOwn(rawProps, key) && ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
2376        if (options) {
2377          if (rawPrevProps && (rawPrevProps[key] !== void 0 || rawPrevProps[kebabKey] !== void 0)) {
2378            props[key] = resolvePropValue(options, rawCurrentProps, key, void 0, instance, true);
2379          }
2380        } else {
2381          delete props[key];
2382        }
2383      }
2384    }
2385    if (attrs !== rawCurrentProps) {
2386      for (const key in attrs) {
2387        if (!rawProps || !hasOwn(rawProps, key) && true) {
2388          delete attrs[key];
2389          hasAttrsChanged = true;
2390        }
2391      }
2392    }
2393  }
2394  if (hasAttrsChanged) {
2395    trigger(instance, "set", "$attrs");
2396  }
2397}
2398function setFullProps(instance, rawProps, props, attrs) {
2399  const [options, needCastKeys] = instance.propsOptions;
2400  let hasAttrsChanged = false;
2401  let rawCastValues;
2402  if (rawProps) {
2403    for (let key in rawProps) {
2404      if (isReservedProp(key)) {
2405        continue;
2406      }
2407      const value = rawProps[key];
2408      let camelKey;
2409      if (options && hasOwn(options, camelKey = camelize(key))) {
2410        if (!needCastKeys || !needCastKeys.includes(camelKey)) {
2411          props[camelKey] = value;
2412        } else {
2413          (rawCastValues || (rawCastValues = {}))[camelKey] = value;
2414        }
2415      } else if (!isEmitListener(instance.emitsOptions, key)) {
2416        if (!(key in attrs) || value !== attrs[key]) {
2417          attrs[key] = value;
2418          hasAttrsChanged = true;
2419        }
2420      }
2421    }
2422  }
2423  if (needCastKeys) {
2424    const rawCurrentProps = toRaw(props);
2425    const castValues = rawCastValues || EMPTY_OBJ;
2426    for (let i = 0; i < needCastKeys.length; i++) {
2427      const key = needCastKeys[i];
2428      props[key] = resolvePropValue(options, rawCurrentProps, key, castValues[key], instance, !hasOwn(castValues, key));
2429    }
2430  }
2431  return hasAttrsChanged;
2432}
2433function resolvePropValue(options, props, key, value, instance, isAbsent) {
2434  const opt = options[key];
2435  if (opt != null) {
2436    const hasDefault = hasOwn(opt, "default");
2437    if (hasDefault && value === void 0) {
2438      const defaultValue = opt.default;
2439      if (opt.type !== Function && isFunction(defaultValue)) {
2440        const { propsDefaults } = instance;
2441        if (key in propsDefaults) {
2442          value = propsDefaults[key];
2443        } else {
2444          setCurrentInstance(instance);
2445          value = propsDefaults[key] = defaultValue.call(null, props);
2446          unsetCurrentInstance();
2447        }
2448      } else {
2449        value = defaultValue;
2450      }
2451    }
2452    if (opt[0]) {
2453      if (isAbsent && !hasDefault) {
2454        value = false;
2455      } else if (opt[1] && (value === "" || value === hyphenate(key))) {
2456        value = true;
2457      }
2458    }
2459  }
2460  return value;
2461}
2462function normalizePropsOptions(comp, appContext, asMixin = false) {
2463  const cache = appContext.propsCache;
2464  const cached = cache.get(comp);
2465  if (cached) {
2466    return cached;
2467  }
2468  const raw = comp.props;
2469  const normalized = {};
2470  const needCastKeys = [];
2471  let hasExtends = false;
2472  if (!isFunction(comp)) {
2473    const extendProps = (raw2) => {
2474      hasExtends = true;
2475      const [props, keys] = normalizePropsOptions(raw2, appContext, true);
2476      extend(normalized, props);
2477      if (keys)
2478        needCastKeys.push(...keys);
2479    };
2480    if (!asMixin && appContext.mixins.length) {
2481      appContext.mixins.forEach(extendProps);
2482    }
2483    if (comp.extends) {
2484      extendProps(comp.extends);
2485    }
2486    if (comp.mixins) {
2487      comp.mixins.forEach(extendProps);
2488    }
2489  }
2490  if (!raw && !hasExtends) {
2491    if (isObject(comp)) {
2492      cache.set(comp, EMPTY_ARR);
2493    }
2494    return EMPTY_ARR;
2495  }
2496  if (isArray(raw)) {
2497    for (let i = 0; i < raw.length; i++) {
2498      const normalizedKey = camelize(raw[i]);
2499      if (validatePropName(normalizedKey)) {
2500        normalized[normalizedKey] = EMPTY_OBJ;
2501      }
2502    }
2503  } else if (raw) {
2504    for (const key in raw) {
2505      const normalizedKey = camelize(key);
2506      if (validatePropName(normalizedKey)) {
2507        const opt = raw[key];
2508        const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { type: opt } : opt;
2509        if (prop) {
2510          const booleanIndex = getTypeIndex(Boolean, prop.type);
2511          const stringIndex = getTypeIndex(String, prop.type);
2512          prop[0] = booleanIndex > -1;
2513          prop[1] = stringIndex < 0 || booleanIndex < stringIndex;
2514          if (booleanIndex > -1 || hasOwn(prop, "default")) {
2515            needCastKeys.push(normalizedKey);
2516          }
2517        }
2518      }
2519    }
2520  }
2521  const res = [normalized, needCastKeys];
2522  if (isObject(comp)) {
2523    cache.set(comp, res);
2524  }
2525  return res;
2526}
2527function validatePropName(key) {
2528  if (key[0] !== "$") {
2529    return true;
2530  }
2531  return false;
2532}
2533function getType(ctor) {
2534  const match = ctor && ctor.toString().match(/^\s*function (\w+)/);
2535  return match ? match[1] : ctor === null ? "null" : "";
2536}
2537function isSameType(a, b) {
2538  return getType(a) === getType(b);
2539}
2540function getTypeIndex(type, expectedTypes) {
2541  if (isArray(expectedTypes)) {
2542    return expectedTypes.findIndex((t) => isSameType(t, type));
2543  } else if (isFunction(expectedTypes)) {
2544    return isSameType(expectedTypes, type) ? 0 : -1;
2545  }
2546  return -1;
2547}
2548const isInternalKey = (key) => key[0] === "_" || key === "$stable";
2549const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
2550const normalizeSlot = (key, rawSlot, ctx) => {
2551  if (rawSlot._n) {
2552    return rawSlot;
2553  }
2554  const normalized = withCtx((...args) => {
2555    if (false)
2556      ;
2557    return normalizeSlotValue(rawSlot(...args));
2558  }, ctx);
2559  normalized._c = false;

2560  return normalized;
2561};
2562const normalizeObjectSlots = (rawSlots, slots, instance) => {
2563  const ctx = rawSlots._ctx;
2564  for (const key in rawSlots) {
2565    if (isInternalKey(key))
2566      continue;
2567    const value = rawSlots[key];
2568    if (isFunction(value)) {
2569      slots[key] = normalizeSlot(key, value, ctx);
2570    } else if (value != null) {
2571      const normalized = normalizeSlotValue(value);
2572      slots[key] = () => normalized;
2573    }
2574  }
2575};
2576const normalizeVNodeSlots = (instance, children) => {
2577  const normalized = normalizeSlotValue(children);
2578  instance.slots.default = () => normalized;
2579};
2580const initSlots = (instance, children) => {
2581  if (instance.vnode.shapeFlag & 32) {
2582    const type = children._;
2583    if (type) {
2584      instance.slots = toRaw(children);
2585      def(children, "_", type);
2586    } else {
2587      normalizeObjectSlots(children, instance.slots = {});
2588    }
2589  } else {
2590    instance.slots = {};
2591    if (children) {
2592      normalizeVNodeSlots(instance, children);
2593    }
2594  }
2595  def(instance.slots, InternalObjectKey, 1);
2596};
2597const updateSlots = (instance, children, optimized) => {
2598  const { vnode, slots } = instance;
2599  let needDeletionCheck = true;
2600  let deletionComparisonTarget = EMPTY_OBJ;
2601  if (vnode.shapeFlag & 32) {
2602    const type = children._;
2603    if (type) {
2604      if (optimized && type === 1) {
2605        needDeletionCheck = false;
2606      } else {
2607        extend(slots, children);
2608        if (!optimized && type === 1) {
2609          delete slots._;
2610        }
2611      }
2612    } else {
2613      needDeletionCheck = !children.$stable;
2614      normalizeObjectSlots(children, slots);
2615    }
2616    deletionComparisonTarget = children;
2617  } else if (children) {
2618    normalizeVNodeSlots(instance, children);
2619    deletionComparisonTarget = { default: 1 };
2620  }
2621  if (needDeletionCheck) {
2622    for (const key in slots) {
2623      if (!isInternalKey(key) && !(key in deletionComparisonTarget)) {
2624        delete slots[key];
2625      }
2626    }
2627  }
2628};
2629function createAppContext() {
2630  return {
2631    app: null,
2632    config: {
2633      isNativeTag: NO,
2634      performance: false,
2635      globalProperties: {},
2636      optionMergeStrategies: {},
2637      errorHandler: void 0,
2638      warnHandler: void 0,
2639      compilerOptions: {}
2640    },
2641    mixins: [],
2642    components: {},
2643    directives: {},
2644    provides: /* @__PURE__ */ Object.create(null),
2645    optionsCache: /* @__PURE__ */ new WeakMap(),
2646    propsCache: /* @__PURE__ */ new WeakMap(),
2647    emitsCache: /* @__PURE__ */ new WeakMap()
2648  };
2649}
2650let uid = 0;
2651function createAppAPI(render, hydrate) {
2652  return function createApp(rootComponent, rootProps = null) {
2653    if (!isFunction(rootComponent)) {
2654      rootComponent = Object.assign({}, rootComponent);
2655    }
2656    if (rootProps != null && !isObject(rootProps)) {
2657      rootProps = null;
2658    }
2659    const context = createAppContext();
2660    const installedPlugins = /* @__PURE__ */ new Set();
2661    let isMounted = false;
2662    const app = context.app = {
2663      _uid: uid++,
2664      _component: rootComponent,
2665      _props: rootProps,
2666      _container: null,
2667      _context: context,
2668      _instance: null,
2669      version,
2670      get config() {
2671        return context.config;
2672      },
2673      set config(v) {
2674      },
2675      use(plugin, ...options) {
2676        if (installedPlugins.has(plugin))
2677          ;
2678        else if (plugin && isFunction(plugin.install)) {
2679          installedPlugins.add(plugin);
2680          plugin.install(app, ...options);
2681        } else if (isFunction(plugin)) {
2682          installedPlugins.add(plugin);
2683          plugin(app, ...options);
2684        } else
2685          ;
2686        return app;
2687      },
2688      mixin(mixin) {
2689        {
2690          if (!context.mixins.includes(mixin)) {
2691            context.mixins.push(mixin);
2692          }
2693        }
2694        return app;
2695      },
2696      component(name, component) {
2697        if (!component) {
2698          return context.components[name];
2699        }
2700        context.components[name] = component;
2701        return app;
2702      },
2703      directive(name, directive) {
2704        if (!directive) {
2705          return context.directives[name];
2706        }
2707        context.directives[name] = directive;
2708        return app;
2709      },
2710      mount(rootContainer, isHydrate, isSVG) {
2711        if (!isMounted) {
2712          const vnode = createVNode(rootComponent, rootProps);
2713          vnode.appContext = context;
2714          if (isHydrate && hydrate) {
2715            hydrate(vnode, rootContainer);
2716          } else {
2717            render(vnode, rootContainer, isSVG);
2718          }
2719          isMounted = true;
2720          app._container = rootContainer;
2721          rootContainer.__vue_app__ = app;
2722          return getExposeProxy(vnode.component) || vnode.component.proxy;
2723        }
2724      },
2725      unmount() {
2726        if (isMounted) {
2727          render(null, app._container);
2728          delete app._container.__vue_app__;
2729        }
2730      },
2731      provide(key, value) {
2732        context.provides[key] = value;
2733        return app;
2734      }
2735    };
2736    return app;
2737  };
2738}
2739function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
2740  if (isArray(rawRef)) {
2741    rawRef.forEach((r, i) => setRef(r, oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode, isUnmount));
2742    return;
2743  }
2744  if (isAsyncWrapper(vnode) && !isUnmount) {
2745    return;
2746  }
2747  const refValue = vnode.shapeFlag & 4 ? getExposeProxy(vnode.component) || vnode.component.proxy : vnode.el;
2748  const value = isUnmount ? null : refValue;
2749  const { i: owner, r: ref2 } = rawRef;
2750  const oldRef = oldRawRef && oldRawRef.r;
2751  const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
2752  const setupState = owner.setupState;