https://www.badfoerderung.at/build/bundlefa5b1177e02e083c8be3.js

548**/
549// @__NO_SIDE_EFFECTS__
550function shared_esm_bundler_makeMap(str) {
551  const map = /* @__PURE__ */ Object.create(null);
552  for (const key of str.split(",")) map[key] = 1;
553  return (val) => val in map;
554}
555
556const EMPTY_OBJ =  false ? 0 : {};
557const EMPTY_ARR =  false ? 0 : [];
558const shared_esm_bundler_NOOP = () => {
559};
560const NO = () => false;
561const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
562(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
563const isModelListener = (key) => key.startsWith("onUpdate:");
564const shared_esm_bundler_extend = Object.assign;
565const remove = (arr, el) => {
566  const i = arr.indexOf(el);
567  if (i > -1) {
568    arr.splice(i, 1);
569  }
570};
571const shared_esm_bundler_hasOwnProperty = Object.prototype.hasOwnProperty;
572const hasOwn = (val, key) => shared_esm_bundler_hasOwnProperty.call(val, key);
573const shared_esm_bundler_isArray = Array.isArray;
574const isMap = (val) => toTypeString(val) === "[object Map]";
575const isSet = (val) => toTypeString(val) === "[object Set]";
576const isDate = (val) => toTypeString(val) === "[object Date]";
577const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
578const shared_esm_bundler_isFunction = (val) => typeof val === "function";
579const shared_esm_bundler_isString = (val) => typeof val === "string";
580const isSymbol = (val) => typeof val === "symbol";
581const shared_esm_bundler_isObject = (val) => val !== null && typeof val === "object";
582const isPromise = (val) => {
583  return (shared_esm_bundler_isObject(val) || shared_esm_bundler_isFunction(val)) && shared_esm_bundler_isFunction(val.then) && shared_esm_bundler_isFunction(val.catch);
584};
585const objectToString = Object.prototype.toString;
586const toTypeString = (value) => objectToString.call(value);
587const shared_esm_bundler_toRawType = (value) => {
588  return toTypeString(value).slice(8, -1);
589};
590const isPlainObject = (val) => toTypeString(val) === "[object Object]";
591const isIntegerKey = (key) => shared_esm_bundler_isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
592const isReservedProp = /* @__PURE__ */ shared_esm_bundler_makeMap(
593  // the leading comma is intentional so empty string "" is also included
594  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
595);
596const shared_esm_bundler_isBuiltInDirective = /* @__PURE__ */ shared_esm_bundler_makeMap(
597  "bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
598);
599const cacheStringFunction = (fn) => {
600  const cache = /* @__PURE__ */ Object.create(null);
601  return ((str) => {
602    const hit = cache[str];
603    return hit || (cache[str] = fn(str));
604  });
605};
606const camelizeRE = /-\w/g;
607const shared_esm_bundler_camelize = cacheStringFunction(
608  (str) => {
609    return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
610  }
611);
612const hyphenateRE = /\B([A-Z])/g;
613const hyphenate = cacheStringFunction(
614  (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
615);
616const shared_esm_bundler_capitalize = cacheStringFunction((str) => {
617  return str.charAt(0).toUpperCase() + str.slice(1);
618});
619const toHandlerKey = cacheStringFunction(
620  (str) => {
621    const s = str ? `on${shared_esm_bundler_capitalize(str)}` : ``;
622    return s;
623  }
624);
625const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
626const invokeArrayFns = (fns, ...arg) => {
627  for (let i = 0; i < fns.length; i++) {
628    fns[i](...arg);
629  }
630};
631const def = (obj, key, value, writable = false) => {
632  Object.defineProperty(obj, key, {
633    configurable: true,
634    enumerable: false,
635    writable,
636    value
637  });
638};
639const looseToNumber = (val) => {
640  const n = parseFloat(val);
641  return isNaN(n) ? val : n;
642};
643const toNumber = (val) => {
644  const n = shared_esm_bundler_isString(val) ? Number(val) : NaN;
645  return isNaN(n) ? val : n;
646};
647let _globalThis;
648const getGlobalThis = () => {
649  return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : {});
650};
651const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
652function genPropsAccessExp(name) {
653  return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;
654}
655function genCacheKey(source, options) {
656  return source + JSON.stringify(
657    options,
658    (_, val) => typeof val === "function" ? val.toString() : val
659  );
660}
661
662const PatchFlags = {
663  "TEXT": 1,
664  "1": "TEXT",
665  "CLASS": 2,
666  "2": "CLASS",
667  "STYLE": 4,
668  "4": "STYLE",
669  "PROPS": 8,
670  "8": "PROPS",
671  "FULL_PROPS": 16,
672  "16": "FULL_PROPS",
673  "NEED_HYDRATION": 32,
674  "32": "NEED_HYDRATION",
675  "STABLE_FRAGMENT": 64,
676  "64": "STABLE_FRAGMENT",
677  "KEYED_FRAGMENT": 128,
678  "128": "KEYED_FRAGMENT",
679  "UNKEYED_FRAGMENT": 256,
680  "256": "UNKEYED_FRAGMENT",
681  "NEED_PATCH": 512,
682  "512": "NEED_PATCH",
683  "DYNAMIC_SLOTS": 1024,
684  "1024": "DYNAMIC_SLOTS",
685  "DEV_ROOT_FRAGMENT": 2048,
686  "2048": "DEV_ROOT_FRAGMENT",
687  "CACHED": -1,
688  "-1": "CACHED",
689  "BAIL": -2,
690  "-2": "BAIL"
691};
692const PatchFlagNames = {
693  [1]: `TEXT`,
694  [2]: `CLASS`,
695  [4]: `STYLE`,
696  [8]: `PROPS`,
697  [16]: `FULL_PROPS`,
698  [32]: `NEED_HYDRATION`,
699  [64]: `STABLE_FRAGMENT`,
700  [128]: `KEYED_FRAGMENT`,
701  [256]: `UNKEYED_FRAGMENT`,
702  [512]: `NEED_PATCH`,
703  [1024]: `DYNAMIC_SLOTS`,
704  [2048]: `DEV_ROOT_FRAGMENT`,
705  [-1]: `CACHED`,
706  [-2]: `BAIL`
707};
708
709const ShapeFlags = {
710  "ELEMENT": 1,
711  "1": "ELEMENT",
712  "FUNCTIONAL_COMPONENT": 2,
713  "2": "FUNCTIONAL_COMPONENT",
714  "STATEFUL_COMPONENT": 4,
715  "4": "STATEFUL_COMPONENT",
716  "TEXT_CHILDREN": 8,
717  "8": "TEXT_CHILDREN",
718  "ARRAY_CHILDREN": 16,
719  "16": "ARRAY_CHILDREN",
720  "SLOTS_CHILDREN": 32,
721  "32": "SLOTS_CHILDREN",
722  "TELEPORT": 64,
723  "64": "TELEPORT",
724  "SUSPENSE": 128,
725  "128": "SUSPENSE",
726  "COMPONENT_SHOULD_KEEP_ALIVE": 256,
727  "256": "COMPONENT_SHOULD_KEEP_ALIVE",
728  "COMPONENT_KEPT_ALIVE": 512,
729  "512": "COMPONENT_KEPT_ALIVE",
730  "COMPONENT": 6,
731  "6": "COMPONENT"
732};
733
734const SlotFlags = {
735  "STABLE": 1,
736  "1": "STABLE",
737  "DYNAMIC": 2,
738  "2": "DYNAMIC",
739  "FORWARDED": 3,
740  "3": "FORWARDED"
741};
742const slotFlagsText = {
743  [1]: "STABLE",
744  [2]: "DYNAMIC",
745  [3]: "FORWARDED"
746};
747
748const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decode

748URI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol";
749const isGloballyAllowed = /* @__PURE__ */ shared_esm_bundler_makeMap(GLOBALS_ALLOWED);
750const isGloballyWhitelisted = (/* unused pure expression or super */ null && (isGloballyAllowed));
751
752const range = 2;
753function generateCodeFrame(source, start = 0, end = source.length) {
754  start = Math.max(0, Math.min(start, source.length));
755  end = Math.max(0, Math.min(end, source.length));
756  if (start > end) return "";
757  let lines = source.split(/(\r?\n)/);
758  const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
759  lines = lines.filter((_, idx) => idx % 2 === 0);
760  let count = 0;
761  const res = [];
762  for (let i = 0; i < lines.length; i++) {
763    count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
764    if (count >= start) {
765      for (let j = i - range; j <= i + range || end > count; j++) {
766        if (j < 0 || j >= lines.length) continue;
767        const line = j + 1;
768        res.push(
769          `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`
770        );
771        const lineLength = lines[j].length;
772        const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
773        if (j === i) {
774          const pad = start - (count - (lineLength + newLineSeqLength));
775          const length = Math.max(
776            1,
777            end > count ? lineLength - pad : end - start
778          );
779          res.push(`   |  ` + " ".repeat(pad) + "^".repeat(length));
780        } else if (j > i) {
781          if (end > count) {
782            const length = Math.max(Math.min(end - count, lineLength), 1);
783            res.push(`   |  ` + "^".repeat(length));
784          }
785          count += lineLength + newLineSeqLength;
786        }
787      }
788      break;
789    }
790  }
791  return res.join("\n");
792}
793
794function normalizeStyle(value) {
795  if (shared_esm_bundler_isArray(value)) {
796    const res = {};
797    for (let i = 0; i < value.length; i++) {
798      const item = value[i];
799      const normalized = shared_esm_bundler_isString(item) ? parseStringStyle(item) : normalizeStyle(item);
800      if (normalized) {
801        for (const key in normalized) {
802          res[key] = normalized[key];
803        }
804      }
805    }
806    return res;
807  } else if (shared_esm_bundler_isString(value) || shared_esm_bundler_isObject(value)) {
808    return value;
809  }
810}
811const listDelimiterRE = /;(?![^(]*\))/g;
812const propertyDelimiterRE = /:([^]+)/;
813const styleCommentRE = /\/\*[^]*?\*\//g;
814function parseStringStyle(cssText) {
815  const ret = {};
816  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
817    if (item) {
818      const tmp = item.split(propertyDelimiterRE);
819      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
820    }
821  });
822  return ret;
823}
824function stringifyStyle(styles) {
825  if (!styles) return "";
826  if (shared_esm_bundler_isString(styles)) return styles;
827  let ret = "";
828  for (const key in styles) {
829    const value = styles[key];
830    if (shared_esm_bundler_isString(value) || typeof value === "number") {
831      const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
832      ret += `${normalizedKey}:${value};`;
833    }
834  }
835  return ret;
836}
837function normalizeClass(value) {
838  let res = "";
839  if (shared_esm_bundler_isString(value)) {
840    res = value;
841  } else if (shared_esm_bundler_isArray(value)) {
842    for (let i = 0; i < value.length; i++) {
843      const normalized = normalizeClass(value[i]);
844      if (normalized) {
845        res += normalized + " ";
846      }
847    }
848  } else if (shared_esm_bundler_isObject(value)) {
849    for (const name in value) {
850      if (value[name]) {
851        res += name + " ";
852      }
853    }
854  }
855  return res.trim();
856}
857function normalizeProps(props) {
858  if (!props) return null;
859  let { class: klass, style } = props;
860  if (klass && !shared_esm_bundler_isString(klass)) {
861    props.class = normalizeClass(klass);
862  }
863  if (style) {
864    props.style = normalizeStyle(style);
865  }
866  return props;
867}
868
869const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
870const 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";
871const MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics";
872const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
873const shared_esm_bundler_isHTMLTag = /* @__PURE__ */ shared_esm_bundler_makeMap(HTML_TAGS);
874const shared_esm_bundler_isSVGTag = /* @__PURE__ */ shared_esm_bundler_makeMap(SVG_TAGS);
875const shared_esm_bundler_isMathMLTag = /* @__PURE__ */ shared_esm_bundler_makeMap(MATH_TAGS);
876const isVoidTag = /* @__PURE__ */ shared_esm_bundler_makeMap(VOID_TAGS);
877
878const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
879const isSpecialBooleanAttr = /* @__PURE__ */ shared_esm_bundler_makeMap(specialBooleanAttrs);
880const isBooleanAttr = /* @__PURE__ */ shared_esm_bundler_makeMap(
881  specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,

1013      }
1014    }
1015  }
1016  return String(a) === String(b);
1017}
1018function looseIndexOf(arr, val) {
1019  return arr.findIndex((item) => looseEqual(item, val));
1020}
1021
1022const isRef = (val) => {
1023  return !!(val && val["__v_isRef"] === true);
1024};
1025const toDisplayString = (val) => {
1026  return shared_esm_bundler_isString(val) ? val : val == null ? "" : shared_esm_bundler_isArray(val) || shared_esm_bundler_isObject(val) && (val.toString === objectToString || !shared_esm_bundler_isFunction(val.toString)) ? isRef(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
1027};
1028const replacer = (_key, val) => {
1029  if (isRef(val)) {
1030    return replacer(_key, val.value);
1031  } else if (isMap(val)) {
1032    return {
1033      [`Map(${val.size})`]: [...val.entries()].reduce(
1034        (entries, [key, val2], i) => {
1035          entries[stringifySymbol(key, i) + " =>"] = val2;
1036          return entries;
1037        },
1038        {}
1039      )
1040    };
1041  } else if (isSet(val)) {
1042    return {
1043      [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
1044    };
1045  } else if (isSymbol(val)) {
1046    return stringifySymbol(val);
1047  } else if (shared_esm_bundler_isObject(val) && !shared_esm_bundler_isArray(val) && !isPlainObject(val)) {
1048    return String(val);
1049  }
1050  return val;
1051};
1052const stringifySymbol = (v, i = "") => {
1053  var _a;
1054  return (
1055    // Symbol.description in es2019+ so we need to cast here to pass
1056    // the lib: es2016 check
1057    isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v
1058  );
1059};
1060
1061function normalizeCssVarValue(value) {
1062  if (value == null) {
1063    return "initial";
1064  }
1065  if (typeof value === "string") {
1066    return value === "" ? " " : value;
1067  }
1068  if (typeof value !== "number" || !Number.isFinite(value)) {
1069    if (false) // removed by dead control flow
1070{}
1071  }
1072  return String(value);
1073}
1074
1075
1076
1077;// ./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
1078/**
1079* @vue/reactivity v3.5.25
1080* (c) 2018-present Yuxi (Evan) You and Vue contributors
1081* @license MIT

1281      if (pausedQueueEffects.has(this)) {
1282        pausedQueueEffects.delete(this);
1283        this.trigger();
1284      }
1285    }
1286  }
1287  /**
1288   * @internal
1289   */
1290  notify() {
1291    if (this.flags & 2 && !(this.flags & 32)) {
1292      return;
1293    }
1294    if (!(this.flags & 8)) {
1295      batch(this);
1296    }
1297  }
1298  run() {
1299    if (!(this.flags & 1)) {
1300      return this.fn();
1301    }
1302    this.flags |= 2;
1303    cleanupEffect(this);
1304    prepareDeps(this);
1305    const prevEffect = activeSub;
1306    const prevShouldTrack = shouldTrack;
1307    activeSub = this;
1308    shouldTrack = true;
1309    try {
1310      return this.fn();
1311    } finally {
1312      if (false) // removed by dead control flow
1313{}
1314      cleanupDeps(this);
1315      activeSub = prevEffect;
1316      shouldTrack = prevShouldTrack;
1317      this.flags &= -3;
1318    }
1319  }
1320  stop() {
1321    if (this.flags & 1) {
1322      for (let link = this.deps; link; link = link.nextDep) {
1323        removeSub(link);
1324      }
1325      this.deps = this.depsTail = void 0;
1326      cleanupEffect(this);
1327      this.onStop && this.onStop();
1328      this.flags &= -2;
1329    }
1330  }
1331  trigger() {
1332    if (this.flags & 64) {
1333      pausedQueueEffects.add(this);
1334    } else if (this.scheduler) {
1335      this.scheduler();
1336    } else {
1337      this.runIfDirty();
1338    }
1339  }
1340  /**
1341   * @internal
1342   */
1343  runIfDirty() {
1344    if (isDirty(this)) {
1345      this.run();
1346    }
1347  }
1348  get dirty() {
1349    return isDirty(this);
1350  }
1351}
1352let batchDepth = 0;
1353let batchedSub;
1354let batchedComputed;
1355function batch(sub, isComputed = false) {
1356  sub.flags |= 8;
1357  if (isComputed) {
1358    sub.next = batchedComputed;
1359    batchedComputed = sub;
1360    return;
1361  }
1362  sub.next = batchedSub;
1363  batchedSub = sub;
1364}
1365function startBatch() {
1366  batchDepth++;
1367}
1368function endBatch() {
1369  if (--batchDepth > 0) {
1370    return;
1371  }
1372  if (batchedComputed) {
1373    let e = batchedComputed;
1374    batchedComputed = void 0;
1375    while (e) {
1376      const next = e.next;
1377      e.next = void 0;
1378      e.flags &= -9;
1379      e = next;
1380    }
1381  }
1382  let error;
1383  while (batchedSub) {
1384    let e = batchedSub;
1385    batchedSub = void 0;
1386    while (e) {
1387      const next = e.next;
1388      e.next = void 0;
1389      e.flags &= -9;
1390      if (e.flags & 1) {
1391        try {
1392          ;
1393          e.trigger();
1394        } catch (err) {
1395          if (!error) error = err;
1396        }
1397      }
1398      e = next;
1399    }
1400  }
1401  if (error) throw error;
1402}
1403function prepareDeps(sub) {
1404  for (let link = sub.deps; link; link = link.nextDep) {
1405    link.version = -1;
1406    link.prevActiveLink = link.dep.activeLink;
1407    link.dep.activeLink = link;
1408  }
1409}
1410function cleanupDeps(sub) {
1411  let head;
1412  let tail = sub.depsTail;
1413  let link = tail;
1414  while (link) {
1415    const prev = link.prevDep;
1416    if (link.version === -1) {
1417      if (link === tail) tail = prev;
1418      removeSub(link);
1419      removeDep(link);
1420    } else {
1421      head = link;
1422    }
1423    link.dep.activeLink = link.prevActiveLink;
1424    link.prevActiveLink = void 0;
1425    link = prev;
1426  }
1427  sub.deps = head;
1428  sub.depsTail = tail;
1429}
1430function isDirty(sub) {
1431  for (let link = sub.deps; link; link = link.nextDep) {
1432    if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
1433      return true;
1434    }
1435  }
1436  if (sub._dirty) {
1437    return true;
1438  }
1439  return false;
1440}
1441function refreshComputed(computed) {
1442  if (computed.flags & 4 && !(computed.flags & 16)) {
1443    return;
1444  }
1445  computed.flags &= -17;
1446  if (computed.globalVersion === globalVersion) {
1447    return;
1448  }
1449  computed.globalVersion = globalVersion;
1450  if (!computed.isSSR && computed.flags & 128 && (!computed.deps && !computed._dirty || !isDirty(computed))) {
1451    return;
1452  }
1453  computed.flags |= 2;
1454  const dep = computed.dep;
1455  const prevSub = activeSub;
1456  const prevShouldTrack = shouldTrack;
1457  activeSub = computed;
1458  shouldTrack = true;
1459  try {
1460    prepareDeps(computed);
1461    const value = computed.fn(computed._value);
1462    if (dep.version === 0 || hasChanged(value, computed._value)) {
1463      computed.flags |= 128;
1464      computed._value = value;
1465      dep.version++;
1466    }
1467  } catch (err) {
1468    dep.version++;
1469    throw err;
1470  } finally {
1471    activeSub = prevSub;
1472    shouldTrack = prevShouldTrack;
1473    cleanupDeps(computed);
1474    computed.flags &= -3;
1475  }
1476}
1477function removeSub(link, soft = false) {
1478  const { dep, prevSub, nextSub } = link;
1479  if (prevSub) {
1480    prevSub.nextSub = nextSub;
1481    link.prevSub = void 0;
1482  }
1483  if (nextSub) {
1484    nextSub.prevSub = prevSub;
1485    link.nextSub = void 0;
1486  }
1487  if (false) // removed by dead control flow
1488{}
1489  if (dep.subs === link) {
1490    dep.subs = prevSub;
1491    if (!prevSub && dep.computed) {
1492      dep.computed.flags &= -5;
1493      for (let l = dep.computed.deps; l; l = l.nextDep) {
1494        removeSub(l, true);
1495      }
1496    }
1497  }
1498  if (!soft && !--dep.sc && dep.map) {

1499    dep.map.delete(dep.key);
1500  }
1501}
1502function removeDep(link) {
1503  const { prevDep, nextDep } = link;
1504  if (prevDep) {
1505    prevDep.nextDep = nextDep;
1506    link.prevDep = void 0;
1507  }
1508  if (nextDep) {
1509    nextDep.prevDep = prevDep;
1510    link.nextDep = void 0;
1511  }
1512}
1513function effect(fn, options) {
1514  if (fn.effect instanceof ReactiveEffect) {
1515    fn = fn.effect.fn;
1516  }
1517  const e = new ReactiveEffect(fn);
1518  if (options) {
1519    shared_esm_bundler_extend(e, options);
1520  }
1521  try {
1522    e.run();
1523  } catch (err) {
1524    e.stop();
1525    throw err;
1526  }
1527  const runner = e.run.bind(e);
1528  runner.effect = e;
1529  return runner;
1530}
1531function stop(runner) {
1532  runner.effect.stop();
1533}
1534let shouldTrack = true;
1535const trackStack = [];
1536function pauseTracking() {
1537  trackStack.push(shouldTrack);
1538  shouldTrack = false;
1539}
1540function enableTracking() {
1541  trackStack.push(shouldTrack);
1542  shouldTrack = true;
1543}
1544function resetTracking() {
1545  const last = trackStack.pop();
1546  shouldTrack = last === void 0 ? true : last;
1547}
1548function onEffectCleanup(fn, failSilently = false) {
1549  if (activeSub instanceof ReactiveEffect) {
1550    activeSub.cleanup = fn;
1551  } else if (false) // removed by dead control flow
1552{}
1553}
1554function cleanupEffect(e) {
1555  const { cleanup } = e;
1556  e.cleanup = void 0;
1557  if (cleanup) {
1558    const prevSub = activeSub;
1559    activeSub = void 0;
1560    try {
1561      cleanup();
1562    } finally {
1563      activeSub = prevSub;
1564    }
1565  }
1566}
1567
1568let globalVersion = 0;
1569class Link {
1570  constructor(sub, dep) {
1571    this.sub = sub;
1572    this.dep = dep;
1573    this.version = dep.version;
1574    this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
1575  }
1576}
1577class Dep {
1578  // TODO isolatedDeclarations "__v_skip"
1579  constructor(computed) {
1580    this.computed = computed;
1581    this.version = 0;
1582    /**
1583     * Link between this dep and the current active effect
1584     */
1585    this.activeLink = void 0;
1586    /**
1587     * Doubly linked list representing the subscribing effects (tail)
1588     */
1589    this.subs = void 0;
1590    /**
1591     * For object property deps cleanup
1592     */
1593    this.map = void 0;
1594    this.key = void 0;
1595    /**
1596     * Subscriber counter
1597     */
1598    this.sc = 0;
1599    /**
1600     * @internal
1601     */
1602    this.__v_skip = true;
1603    if (false) // removed by dead control flow
1604{}
1605  }
1606  track(debugInfo) {
1607    if (!activeSub || !shouldTrack || activeSub === this.computed) {
1608      return;
1609    }
1610    let link = this.activeLink;
1611    if (link === void 0 || link.sub !== activeSub) {
1612      link = this.activeLink = new Link(activeSub, this);
1613      if (!activeSub.deps) {
1614        activeSub.deps = activeSub.depsTail = link;
1615      } else {
1616        link.prevDep = activeSub.depsTail;
1617        activeSub.depsTail.nextDep = link;
1618        activeSub.depsTail = link;
1619      }
1620      addSub(link);
1621    } else if (link.version === -1) {
1622      link.version = this.version;
1623      if (link.nextDep) {
1624        const next = link.nextDep;
1625        next.prevDep = link.prevDep;
1626        if (link.prevDep) {
1627          link.prevDep.nextDep = next;
1628        }
1629        link.prevDep = activeSub.depsTail;
1630        link.nextDep = void 0;
1631        activeSub.depsTail.nextDep = link;
1632        activeSub.depsTail = link;
1633        if (activeSub.deps === link) {
1634          activeSub.deps = next;
1635        }
1636      }
1637    }
1638    if (false) // removed by dead control flow
1639{}
1640    return link;
1641  }
1642  trigger(debugInfo) {
1643    this.version++;
1644    globalVersion++;
1645    this.notify(debugInfo);
1646  }
1647  notify(debugInfo) {
1648    startBatch();
1649    try {
1650      if (false) // removed by dead control flow
1651{}
1652      for (let link = this.subs; link; link = link.prevSub) {
1653        if (link.sub.notify()) {
1654          ;
1655          link.sub.dep.notify();
1656        }
1657      }
1658    } finally {
1659      endBatch();
1660    }
1661  }
1662}
1663function addSub(link) {
1664  link.dep.sc++;
1665  if (link.sub.flags & 4) {
1666    const computed = link.dep.computed;
1667    if (computed && !link.dep.subs) {
1668      computed.flags |= 4 | 16;
1669      for (let l = computed.deps; l; l = l.nextDep) {
1670        addSub(l);
1671      }
1672    }
1673    const currentTail = link.dep.subs;
1674    if (currentTail !== link) {
1675      link.prevSub = currentTail;
1676      if (currentTail) currentTail.nextSub = link;
1677    }
1678    if (false) // removed by dead control flow
1679{}
1680    link.dep.subs = link;
1681  }
1682}
1683const targetMap = /* @__PURE__ */ new WeakMap();
1684const ITERATE_KEY = Symbol(
1685   false ? 0 : ""
1686);
1687const MAP_KEY_ITERATE_KEY = Symbol(
1688   false ? 0 : ""
1689);
1690const ARRAY_ITERATE_KEY = Symbol(
1691   false ? 0 : ""
1692);
1693function reactivity_esm_bundler_track(target, type, key) {
1694  if (shouldTrack && activeSub) {
1695    let depsMap = targetMap.get(target);
1696    if (!depsMap) {
1697      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
1698    }
1699    let dep = depsMap.get(key);
1700    if (!dep) {
1701      depsMap.set(key, dep = new Dep());
1702      dep.map = depsMap;
1703      dep.key = key;
1704    }
1705    if (false) // removed by dead control flow
1706{} else {
1707      dep.track();
1708    }
1709  }
1710}
1711function trigger(target, type, key, newValue, oldValue, oldTarget) {
1712  const depsMap = targetMap.get(target);
1713  if (!depsMap) {
1714    globalVersion++;
1715    return;
1716  }
1717  const run = (dep) => {
1718    if (dep) {
1719      if (false) // removed by dead control flow
1720{} else {
1721        dep.trigger();
1722      }
1723    }
1724  };
1725  startBatch();
1726  if (type === "clear") {

1727    depsMap.forEach(run);
1728  } else {
1729    const targetIsArray = shared_esm_bundler_isArray(target);
1730    const isArrayIndex = targetIsArray && isIntegerKey(key);
1731    if (targetIsArray && key === "length") {
1732      const newLength = Number(newValue);
1733      depsMap.forEach((dep, key2) => {
1734        if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
1735          run(dep);
1736        }
1737      });
1738    } else {
1739      if (key !== void 0 || depsMap.has(void 0)) {
1740        run(depsMap.get(key));
1741      }
1742      if (isArrayIndex) {
1743        run(depsMap.get(ARRAY_ITERATE_KEY));
1744      }
1745      switch (type) {
1746        case "add":
1747          if (!targetIsArray) {
1748            run(depsMap.get(ITERATE_KEY));
1749            if (isMap(target)) {
1750              run(depsMap.get(MAP_KEY_ITERATE_KEY));
1751            }
1752          } else if (isArrayIndex) {
1753            run(depsMap.get("length"));
1754          }
1755          break;
1756        case "delete":
1757          if (!targetIsArray) {
1758            run(depsMap.get(ITERATE_KEY));
1759            if (isMap(target)) {
1760              run(depsMap.get(MAP_KEY_ITERATE_KEY));
1761            }
1762          }
1763          break;
1764        case "set":
1765          if (isMap(target)) {
1766            run(depsMap.get(ITERATE_KEY));
1767          }
1768          break;
1769      }
1770    }
1771  }
1772  endBatch();
1773}
1774function getDepFromReactive(object, key) {
1775  const depMap = targetMap.get(object);
1776  return depMap && depMap.get(key);
1777}
1778
1779function reactiveReadArray(array) {
1780  const raw = reactivity_esm_bundler_toRaw(array);
1781  if (raw === array) return raw;
1782  reactivity_esm_bundler_track(raw, "iterate", ARRAY_ITERATE_KEY);
1783  return isShallow(array) ? raw : raw.map(toReactive);
1784}
1785function shallowReadArray(arr) {
1786  reactivity_esm_bundler_track(arr = reactivity_esm_bundler_toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
1787  return arr;
1788}
1789function toWrapped(target, item) {
1790  if (isReadonly(target)) {
1791    return isReactive(target) ? toReadonly(toReactive(item)) : toReadonly(item);
1792  }
1793  return toReactive(item);
1794}
1795const arrayInstrumentations = {
1796  __proto__: null,
1797  [Symbol.iterator]() {
1798    return iterator(this, Symbol.iterator, (item) => toWrapped(this, item));
1799  },
1800  concat(...args) {
1801    return reactiveReadArray(this).concat(
1802      ...args.map((x) => shared_esm_bundler_isArray(x) ? reactiveReadArray(x) : x)
1803    );
1804  },
1805  entries() {
1806    return iterator(this, "entries", (value) => {
1807      value[1] = toWrapped(this, value[1]);
1808      return value;
1809    });
1810  },
1811  every(fn, thisArg) {
1812    return apply(this, "every", fn, thisArg, void 0, arguments);
1813  },
1814  filter(fn, thisArg) {
1815    return apply(
1816      this,
1817      "filter",
1818      fn,
1819      thisArg,
1820      (v) => v.map((item) => toWrapped(this, item)),
1821      arguments
1822    );
1823  },
1824  find(fn, thisArg) {
1825    return apply(
1826      this,
1827      "find",
1828      fn,
1829      thisArg,
1830      (item) => toWrapped(this, item),
1831      arguments
1832    );
1833  },
1834  findIndex(fn, thisArg) {
1835    return apply(this, "findIndex", fn, thisArg, void 0, arguments);
1836  },
1837  findLast(fn, thisArg) {
1838    return apply(
1839      this,
1840      "findLast",
1841      fn,
1842      thisArg,
1843      (item) => toWrapped(this, item),
1844      arguments
1845    );
1846  },
1847  findLastIndex(fn, thisArg) {
1848    return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
1849  },
1850  // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
1851  forEach(fn, thisArg) {
1852    return apply(this, "forEach", fn, thisArg, void 0, arguments);
1853  },
1854  includes(...args) {
1855    return searchProxy(this, "includes", args);
1856  },
1857  indexOf(...args) {
1858    return searchProxy(this, "indexOf", args);
1859  },
1860  join(separator) {
1861    return reactiveReadArray(this).join(separator);
1862  },
1863  // keys() iterator only reads `length`, no optimization required
1864  lastIndexOf(...args) {
1865    return searchProxy(this, "lastIndexOf", args);
1866  },
1867  map(fn, thisArg) {
1868    return apply(this, "map", fn, thisArg, void 0, arguments);
1869  },
1870  pop() {
1871    return noTracking(this, "pop");
1872  },
1873  push(...args) {
1874    return noTracking(this, "push", args);
1875  },
1876  reduce(fn, ...args) {
1877    return reduce(this, "reduce", fn, args);
1878  },
1879  reduceRight(fn, ...args) {
1880    return reduce(this, "reduceRight", fn, args);
1881  },
1882  shift() {
1883    return noTracking(this, "shift");
1884  },
1885  // slice could use ARRAY_ITERATE but also seems to beg for range tracking
1886  some(fn, thisArg) {
1887    return apply(this, "some", fn, thisArg, void 0, arguments);
1888  },
1889  splice(...args) {
1890    return noTracking(this, "splice", args);
1891  },
1892  toReversed() {
1893    return reactiveReadArray(this).toReversed();
1894  },
1895  toSorted(comparer) {
1896    return reactiveReadArray(this).toSorted(comparer);
1897  },
1898  toSpliced(...args) {
1899    return reactiveReadArray(this).toSpliced(...args);
1900  },
1901  unshift(...args) {
1902    return noTracking(this, "unshift", args);
1903  },
1904  values() {
1905    return iterator(this, "values", (item) => toWrapped(this, item));
1906  }
1907};
1908function iterator(self, method, wrapValue) {
1909  const arr = shallowReadArray(self);
1910  const iter = arr[method]();
1911  if (arr !== self && !isShallow(self)) {
1912    iter._next = iter.next;
1913    iter.next = () => {
1914      const result = iter._next();
1915      if (!result.done) {
1916        result.value = wrapValue(result.value);
1917      }
1918      return result;
1919    };
1920  }
1921  return iter;
1922}
1923const arrayProto = Array.prototype;
1924function apply(self, method, fn, thisArg, wrappedRetFn, args) {
1925  const arr = shallowReadArray(self);
1926  const needsWrap = arr !== self && !isShallow(self);
1927  const methodFn = arr[method];
1928  if (methodFn !== arrayProto[method]) {
1929    const result2 = methodFn.apply(self, args);
1930    return needsWrap ? toReactive(result2) : result2;
1931  }
1932  let wrappedFn = fn;
1933  if (arr !== self) {
1934    if (needsWrap) {
1935      wrappedFn = function(item, index) {
1936        return fn.call(this, toWrapped(self, item), index, self);
1937      };
1938    } else if (fn.length > 2) {
1939      wrappedFn = function(item, index) {
1940        return fn.call(this, item, index, self);
1941      };
1942    }
1943  }
1944  const result = methodFn.call(arr, wrappedFn, thisArg);
1945  return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
1946}
1947function reduce(self, method, fn, args) {
1948  const arr = shallowReadArray(self);
1949  let wrappedFn = fn;
1950  if (arr !== self) {
1951    if (!isShallow(self)) {
1952      wrappedFn = function(acc, item, index) {
1953        return fn.call(this, acc, toWrapped(self, item), index, self);
1954      };
1955    } else if (fn.length > 3) {
1956      wrappedFn = function(acc, item, index) {
1957        return fn.call(this, acc, item, index, self);
1958      };
1959    }
1960  }
1961  return arr[method](wrappedFn, ...args);
1962}
1963function searchProxy(self, method, args) {
1964  const arr = reactivity_esm_bundler_toRaw(self);
1965  reactivity_esm_bundler_track(arr, "iterate", ARRAY_ITERATE_KEY);
1966  const res = arr[method](...args);
1967  if ((res === -1 || res === false) && isProxy(args[0])) {
1968    args[0] = reactivity_esm_bundler_toRaw(args[0]);
1969    return arr[method](...args);
1970  }
1971  return res;
1972}
1973function noTracking(self, method, args = []) {
1974  pauseTracking();
1975  startBatch();
1976  const res = reactivity_esm_bundler_toRaw(self)[method].apply(self, args);
1977  endBatch();
1978  resetTracking();
1979  return res;
1980}
1981
1982const isNonTrackableKeys = /* @__PURE__ */ shared_esm_bundler_makeMap(`__proto__,__v_isRef,__isVue`);
1983const builtInSymbols = new Set(
1984  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
1985);
1986function reactivity_esm_bundler_hasOwnProperty(key) {
1987  if (!isSymbol(key)) key = String(key);
1988  const obj = reactivity_esm_bundler_toRaw(this);
1989  reactivity_esm_bundler_track(obj, "has", key);
1990  return obj.hasOwnProperty(key);
1991}
1992class BaseReactiveHandler {
1993  constructor(_isReadonly = false, _isShallow = false) {
1994    this._isReadonly = _isReadonly;
1995    this._isShallow = _isShallow;
1996  }
1997  get(target, key, receiver) {
1998    if (key === "__v_skip") return target["__v_skip"];
1999    const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
2000    if (key === "__v_isReactive") {
2001      return !isReadonly2;
2002    } else if (key === "__v_isReadonly") {
2003      return isReadonly2;
2004    } else if (key === "__v_isShallow") {
2005      return isShallow2;
2006    } else if (key === "__v_raw") {
2007      if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
2008      // this means the receiver is a user proxy of the reactive proxy
2009      Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
2010        return target;
2011      }
2012      return;
2013    }
2014    const targetIsArray = shared_esm_bundler_isArray(target);
2015    if (!isReadonly2) {
2016      let fn;
2017      if (targetIsArray && (fn = arrayInstrumentations[key])) {
2018        return fn;
2019      }
2020      if (key === "hasOwnProperty") {
2021        return reactivity_esm_bundler_hasOwnProperty;
2022      }
2023    }
2024    const res = Reflect.get(
2025      target,
2026      key,
2027      // if this is a proxy wrapping a ref, return methods using the raw ref
2028      // as receiver so that we don't have to call `toRaw` on the ref in all
2029      // its class methods
2030      reactivity_esm_bundler_isRef(target) ? target : receiver
2031    );
2032    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
2033      return res;
2034    }
2035    if (!isReadonly2) {
2036      reactivity_esm_bundler_track(target, "get", key);
2037    }
2038    if (isShallow2) {
2039      return res;
2040    }
2041    if (reactivity_esm_bundler_isRef(res)) {
2042      const value = targetIsArray && isIntegerKey(key) ? res : res.value;
2043      return isReadonly2 && shared_esm_bundler_isObject(value) ? readonly(value) : value;
2044    }
2045    if (shared_esm_bundler_isObject(res)) {
2046      return isReadonly2 ? readonly(res) : reactive(res);
2047    }
2048    return res;
2049  }
2050}
2051class MutableReactiveHandler extends BaseReactiveHandler {

2052  constructor(isShallow2 = false) {
2053    super(false, isShallow2);
2054  }
2055  set(target, key, value, receiver) {
2056    let oldValue = target[key];
2057    const isArrayWithIntegerKey = shared_esm_bundler_isArray(target) && isIntegerKey(key);
2058    if (!this._isShallow) {
2059      const isOldValueReadonly = isReadonly(oldValue);
2060      if (!isShallow(value) && !isReadonly(value)) {
2061        oldValue = reactivity_esm_bundler_toRaw(oldValue);
2062        value = reactivity_esm_bundler_toRaw(value);
2063      }
2064      if (!isArrayWithIntegerKey && reactivity_esm_bundler_isRef(oldValue) && !reactivity_esm_bundler_isRef(value)) {
2065        if (isOldValueReadonly) {
2066          if (false) // removed by dead control flow
2067{}
2068          return true;
2069        } else {
2070          oldValue.value = value;
2071          return true;
2072        }
2073      }
2074    }
2075    const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn(target, key);
2076    const result = Reflect.set(
2077      target,
2078      key,
2079      value,
2080      reactivity_esm_bundler_isRef(target) ? target : receiver
2081    );
2082    if (target === reactivity_esm_bundler_toRaw(receiver)) {
2083      if (!hadKey) {
2084        trigger(target, "add", key, value);
2085      } else if (hasChanged(value, oldValue)) {
2086        trigger(target, "set", key, value, oldValue);
2087      }
2088    }
2089    return result;
2090  }
2091  deleteProperty(target, key) {
2092    const hadKey = hasOwn(target, key);
2093    const oldValue = target[key];
2094    const result = Reflect.deleteProperty(target, key);
2095    if (result && hadKey) {
2096      trigger(target, "delete", key, void 0, oldValue);
2097    }
2098    return result;
2099  }
2100  has(target, key) {
2101    const result = Reflect.has(target, key);
2102    if (!isSymbol(key) || !builtInSymbols.has(key)) {
2103      reactivity_esm_bundler_track(target, "has", key);
2104    }
2105    return result;
2106  }
2107  ownKeys(target) {
2108    reactivity_esm_bundler_track(
2109      target,
2110      "iterate",
2111      shared_esm_bundler_isArray(target) ? "length" : ITERATE_KEY
2112    );
2113    return Reflect.ownKeys(target);
2114  }
2115}
2116class ReadonlyReactiveHandler extends BaseReactiveHandler {
2117  constructor(isShallow2 = false) {
2118    super(true, isShallow2);
2119  }
2120  set(target, key) {
2121    if (false) // removed by dead control flow
2122{}
2123    return true;
2124  }
2125  deleteProperty(target, key) {
2126    if (false) // removed by dead control flow
2127{}
2128    return true;
2129  }
2130}
2131const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
2132const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
2133const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true);
2134const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
2135
2136const toShallow = (value) => value;
2137const getProto = (v) => Reflect.getPrototypeOf(v);
2138function createIterableMethod(method, isReadonly2, isShallow2) {
2139  return function(...args) {
2140    const target = this["__v_raw"];
2141    const rawTarget = reactivity_esm_bundler_toRaw(target);
2142    const targetIsMap = isMap(rawTarget);
2143    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
2144    const isKeyOnly = method === "keys" && targetIsMap;
2145    const innerIterator = target[method](...args);
2146    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
2147    !isReadonly2 && reactivity_esm_bundler_track(
2148      rawTarget,
2149      "iterate",
2150      isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
2151    );
2152    return {
2153      // iterator protocol
2154      next() {
2155        const { value, done } = innerIterator.next();
2156        return done ? { value, done } : {
2157          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
2158          done
2159        };
2160      },
2161      // iterable protocol
2162      [Symbol.iterator]() {
2163        return this;
2164      }
2165    };
2166  };
2167}
2168function createReadonlyMethod(type) {
2169  return function(...args) {
2170    if (false) // removed by dead control flow
2171{}
2172    return type === "delete" ? false : type === "clear" ? void 0 : this;
2173  };
2174}
2175function createInstrumentations(readonly, shallow) {
2176  const instrumentations = {
2177    get(key) {
2178      const target = this["__v_raw"];
2179      const rawTarget = reactivity_esm_bundler_toRaw(target);
2180      const rawKey = reactivity_esm_bundler_toRaw(key);
2181      if (!readonly) {
2182        if (hasChanged(key, rawKey)) {
2183          reactivity_esm_bundler_track(rawTarget, "get", key);
2184        }
2185        reactivity_esm_bundler_track(rawTarget, "get", rawKey);
2186      }
2187      const { has } = getProto(rawTarget);
2188      const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
2189      if (has.call(rawTarget, key)) {
2190        return wrap(target.get(key));
2191      } else if (has.call(rawTarget, rawKey)) {
2192        return wrap(target.get(rawKey));
2193      } else if (target !== rawTarget) {
2194        target.get(key);
2195      }
2196    },
2197    get size() {
2198      const target = this["__v_raw"];
2199      !readonly && reactivity_esm_bundler_track(reactivity_esm_bundler_toRaw(target), "iterate", ITERATE_KEY);
2200      return target.size;
2201    },
2202    has(key) {
2203      const target = this["__v_raw"];
2204      const rawTarget = reactivity_esm_bundler_toRaw(target);
2205      const rawKey = reactivity_esm_bundler_toRaw(key);
2206      if (!readonly) {
2207        if (hasChanged(key, rawKey)) {
2208          reactivity_esm_bundler_track(rawTarget, "has", key);
2209        }
2210        reactivity_esm_bundler_track(rawTarget, "has", rawKey);
2211      }
2212      return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
2213    },
2214    forEach(callback, thisArg) {
2215      const observed = this;
2216      const target = observed["__v_raw"];
2217      const rawTarget = reactivity_esm_bundler_toRaw(target);
2218      const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
2219      !readonly && reactivity_esm_bundler_track(rawTarget, "iterate", ITERATE_KEY);
2220      return target.forEach((value, key) => {
2221        return callback.call(thisArg, wrap(value), wrap(key), observed);
2222      });
2223    }
2224  };
2225  shared_esm_bundler_extend(
2226    instrumentations,
2227    readonly ? {
2228      add: createReadonlyMethod("add"),
2229      set: createReadonlyMethod("set"),
2230      delete: createReadonlyMethod("delete"),
2231      clear: createReadonlyMethod("clear")
2232    } : {
2233      add(value) {
2234        if (!shallow && !isShallow(value) && !isReadonly(value)) {
2235          value = reactivity_esm_bundler_toRaw(value);
2236        }
2237        const target = reactivity_esm_bundler_toRaw(this);
2238        const proto = getProto(target);
2239        const hadKey = proto.has.call(target, value);
2240        if (!hadKey) {
2241          target.add(value);
2242          trigger(target, "add", value, value);
2243        }
2244        return this;
2245      },
2246      set(key, value) {
2247        if (!shallow && !isShallow(value) && !isReadonly(value)) {
2248          value = reactivity_esm_bundler_toRaw(value);
2249        }
2250        const target = reactivity_esm_bundler_toRaw(this);
2251        const { has, get } = getProto(target);
2252        let hadKey = has.call(target, key);
2253        if (!hadKey) {
2254          key = reactivity_esm_bundler_toRaw(key);
2255          hadKey = has.call(target, key);
2256        } else if (false) // removed by dead control flow
2257{}
2258        const oldValue = get.call(target, key);
2259        target.set(key, value);
2260        if (!hadKey) {
2261          trigger(target, "add", key, value);
2262        } else if (hasChanged(value, oldValue)) {
2263          trigger(target, "set", key, value, oldValue);
2264        }
2265        return this;
2266      },
2267      delete(key) {
2268        const target = reactivity_esm_bundler_toRaw(this);
2269        const { has, get } = getProto(target);
2270        let hadKey = has.call(target, key);
2271        if (!hadKey) {
2272          key = reactivity_esm_bundler_toRaw(key);
2273          hadKey = has.call(target, key);
2274        } else if (false) // removed by dead control flow
2275{}
2276        const oldValue = get ? get.call(target, key) : void 0;
2277        const result = target.delete(key);
2278        if (hadKey) {
2279          trigger(target, "delete", key, void 0, oldValue);
2280        }
2281        return result;
2282      },
2283      clear() {
2284        const target = reactivity_esm_bundler_toRaw(this);
2285        const hadItems = target.size !== 0;
2286        const oldTarget =  false ? 0 : void 0;
2287        const result = target.clear();
2288        if (hadItems) {
2289          trigger(
2290            target,
2291            "clear",
2292            void 0,
2293            void 0,
2294            oldTarget
2295          );
2296        }
2297        return result;
2298      }
2299    }
2300  );
2301  const iteratorMethods = [
2302    "keys",
2303    "values",
2304    "entries",
2305    Symbol.iterator
2306  ];
2307  iteratorMethods.forEach((method) => {
2308    instrumentations[method] = createIterableMethod(method, readonly, shallow);
2309  });
2310  return instrumentations;
2311}
2312function createInstrumentationGetter(isReadonly2, shallow) {
2313  const instrumentations = createInstrumentations(isReadonly2, shallow);
2314  return (target, key, receiver) => {
2315    if (key === "__v_isReactive") {
2316      return !isReadonly2;
2317    } else if (key === "__v_isReadonly") {
2318      return isReadonly2;
2319    } else if (key === "__v_raw") {
2320      return target;
2321    }
2322    return Reflect.get(
2323      hasOwn(instrumentations, key) && key in target ? instrumentations : target,
2324      key,
2325      receiver
2326    );
2327  };
2328}
2329const mutableCollectionHandlers = {
2330  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
2331};
2332const shallowCollectionHandlers = {
2333  get: /* @__PURE__ */ createInstrumentationGetter(false, true)
2334};
2335const readonlyCollectionHandlers = {
2336  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
2337};
2338const shallowReadonlyCollectionHandlers = {
2339  get: /* @__PURE__ */ createInstrumentationGetter(true, true)
2340};
2341function checkIdentityKeys(target, has, key) {
2342  const rawKey = reactivity_esm_bundler_toRaw(key);
2343  if (rawKey !== key && has.call(target, rawKey)) {
2344    const type = toRawType(target);
2345    reactivity_esm_bundler_warn(
2346      `Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`
2347    );
2348  }
2349}
2350
2351const reactiveMap = /* @__PURE__ */ new WeakMap();
2352const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
2353const readonlyMap = /* @__PURE__ */ new WeakMap();
2354const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
2355function targetTypeMap(rawType) {
2356  switch (rawType) {
2357    case "Object":
2358    case "Array":
2359      return 1 /* COMMON */;
2360    case "Map":
2361    case "Set":
2362    case "WeakMap":
2363    case "WeakSet":
2364      return 2 /* COLLECTION */;
2365    default:
2366      return 0 /* INVALID */;
2367  }
2368}
2369function getTargetType(value) {
2370  return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap(shared_esm_bundler_toRawType(value));
2371}
2372function reactive(target) {
2373  if (isReadonly(target)) {
2374    return target;
2375  }
2376  return createReactiveObject(
2377    target,
2378    false,
2379    mutableHandlers,
2380    mutableCollectionHandlers,
2381    reactiveMap
2382  );
2383}
2384function shallowReactive(target) {
2385  return createReactiveObject(
2386    target,
2387    false,
2388    shallowReactiveHandlers,
2389    shallowCollectionHandlers,
2390    shallowReactiveMap
2391  );
2392}
2393function readonly(target) {
2394  return createReactiveObject(
2395    target,
2396    true,
2397    readonlyHandlers,
2398    readonlyCollectionHandlers,
2399    readonlyMap
2400  );
2401}
2402function shallowReadonly(target) {
2403  return createReactiveObject(
2404    target,
2405    true,
2406    shallowReadonlyHandlers,
2407    shallowReadonlyCollectionHandlers,
2408    shallowReadonlyMap
2409  );
2410}
2411function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
2412  if (!shared_esm_bundler_isObject(target)) {
2413    if (false) // removed by dead control flow
2414{}
2415    return target;
2416  }
2417  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
2418    return target;
2419  }
2420  const targetType = getTargetType(target);
2421  if (targetType === 0 /* INVALID */) {
2422    return target;
2423  }
2424  const existingProxy = proxyMap.get(target);
2425  if (existingProxy) {
2426    return existingProxy;
2427  }
2428  const proxy = new Proxy(
2429    target,
2430    targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers
2431  );
2432  proxyMap.set(target, proxy);
2433  return proxy;
2434}
2435function isReactive(value) {
2436  if (isReadonly(value)) {
2437    return isReactive(value["__v_raw"]);
2438  }
2439  return !!(value && value["__v_isReactive"]);
2440}
2441function isReadonly(value) {
2442  return !!(value && value["__v_isReadonly"]);
2443}
2444function isShallow(value) {
2445  return !!(value && value["__v_isShallow"]);
2446}
2447function isProxy(value) {
2448  return value ? !!value["__v_raw"] : false;
2449}
2450function reactivity_esm_bundler_toRaw(observed) {
2451  const raw = observed && observed["__v_raw"];
2452  return raw ? reactivity_esm_bundler_toRaw(raw) : observed;
2453}
2454function markRaw(value) {
2455  if (!hasOwn(value, "__v_skip") && Object.isExtensible(value)) {
2456    def(value, "__v_skip", true);
2457  }
2458  return value;
2459}
2460const toReactive = (value) => shared_esm_bundler_isObject(value) ? reactive(value) : value;
2461const toReadonly = (value) => shared_esm_bundler_isObject(value) ? readonly(value) : value;
2462
2463function reactivity_esm_bundler_isRef(r) {
2464  return r ? r["__v_isRef"] === true : false;
2465}
2466function ref(value) {
2467  return createRef(value, false);
2468}
2469function shallowRef(value) {
2470  return createRef(value, true);
2471}
2472function createRef(rawValue, shallow) {
2473  if (reactivity_esm_bundler_isRef(rawValue)) {
2474    return rawValue;
2475  }
2476  return new RefImpl(rawValue, shallow);
2477}
2478class RefImpl {
2479  constructor(value, isShallow2) {
2480    this.dep = new Dep();
2481    this["__v_isRef"] = true;
2482    this["__v_isShallow"] = false;
2483    this._rawValue = isShallow2 ? value : reactivity_esm_bundler_toRaw(value);
2484    this._value = isShallow2 ? value : toReactive(value);
2485    this["__v_isShallow"] = isShallow2;
2486  }
2487  get value() {
2488    if (false) // removed by dead control flow
2489{} else {
2490      this.dep.track();
2491    }
2492    return this._value;
2493  }
2494  set value(newValue) {
2495    const oldValue = this._rawValue;
2496    const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
2497    newValue = useDirectValue ? newValue : reactivity_esm_bundler_toRaw(newValue);
2498    if (hasChanged(newValue, oldValue)) {
2499      this._rawValue = newValue;
2500      this._value = useDirectValue ? newValue : toReactive(newValue);
2501      if (false) // removed by dead control flow
2502{} else {
2503        this.dep.trigger();
2504      }
2505    }
2506  }
2507}
2508function triggerRef(ref2) {
2509  if (ref2.dep) {
2510    if (false) // removed by dead control flow
2511{} else {
2512      ref2.dep.trigger();
2513    }
2514  }
2515}
2516function unref(ref2) {
2517  return reactivity_esm_bundler_isRef(ref2) ? ref2.value : ref2;
2518}
2519function toValue(source) {
2520  return shared_esm_bundler_isFunction(source) ? source() : unref(source);
2521}
2522const shallowUnwrapHandlers = {
2523  get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)),
2524  set: (target, key, value, receiver) => {
2525    const oldValue = target[key];
2526    if (reactivity_esm_bundler_isRef(oldValue) && !reactivity_esm_bundler_isRef(value)) {
2527      oldValue.value = value;
2528      return true;
2529    } else {
2530      return Reflect.set(target, key, value, receiver);
2531    }
2532  }
2533};
2534function proxyRefs(objectWithRefs) {
2535  return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
2536}
2537class CustomRefImpl {
2538  constructor(factory) {
2539    this["__v_isRef"] = true;
2540    this._value = void 0;
2541    const dep = this.dep = new Dep();
2542    const { get, set } = factory(dep.track.bind(dep), dep.trigger.bind(dep));
2543    this._get = get;
2544    this._set = set;
2545  }
2546  get value() {
2547    return this._value = this._get();
2548  }
2549  set value(newVal) {
2550    this._set(newVal);
2551  }
2552}
2553function customRef(factory) {
2554  return new CustomRefImpl(factory);
2555}
2556function toRefs(object) {
2557  if (false) // removed by dead control flow
2558{}
2559  const ret = shared_esm_bundler_isArray(object) ? new Array(object.length) : {};
2560  for (const key in object) {
2561    ret[key] = propertyToRef(object, key);
2562  }
2563  return ret;
2564}
2565class ObjectRefImpl {
2566  constructor(_object, _key, _defaultValue) {
2567    this._object = _object;
2568    this._key = _key;
2569    this._defaultValue = _defaultValue;
2570    this["__v_isRef"] = true;
2571    this._value = void 0;
2572    this._raw = reactivity_esm_bundler_toRaw(_object);
2573    let shallow = true;
2574    let obj = _object;
2575    if (!shared_esm_bundler_isArray(_object) || !isIntegerKey(String(_key))) {
2576      do {
2577        shallow = !isProxy(obj) || isShallow(obj);
2578      } while (shallow && (obj = obj["__v_raw"]));
2579    }
2580    this._shallow = shallow;
2581  }
2582  get value() {
2583    let val = this._object[this._key];
2584    if (this._shallow) {
2585      val = unref(val);
2586    }
2587    return this._value = val === void 0 ? this._defaultValue : val;
2588  }
2589  set value(newVal) {
2590    if (this._shallow && reactivity_esm_bundler_isRef(this._raw[this._key])) {
2591      const nestedRef = this._object[this._key];
2592      if (reactivity_esm_bundler_isRef(nestedRef)) {
2593        nestedRef.value = newVal;
2594        return;
2595      }
2596    }
2597    this._object[this._key] = newVal;
2598  }
2599  get dep() {
2600    return getDepFromReactive(this._raw, this._key);
2601  }
2602}
2603class GetterRefImpl {
2604  constructor(_getter) {
2605    this._getter = _getter;
2606    this["__v_isRef"] = true;
2607    this["__v_isReadonly"] = true;
2608    this._value = void 0;
2609  }
2610  get value() {
2611    return this._value = this._getter();
2612  }
2613}
2614function toRef(source, key, defaultValue) {
2615  if (reactivity_esm_bundler_isRef(source)) {
2616    return source;
2617  } else if (shared_esm_bundler_isFunction(source)) {
2618    return new GetterRefImpl(source);
2619  } else if (shared_esm_bundler_isObject(source) && arguments.length > 1) {
2620    return propertyToRef(source, key, defaultValue);
2621  } else {
2622    return ref(source);
2623  }
2624}
2625function propertyToRef(source, key, defaultValue) {
2626  return new ObjectRefImpl(source, key, defaultValue);
2627}
2628
2629class ComputedRefImpl {
2630  constructor(fn, setter, isSSR) {
2631    this.fn = fn;
2632    this.setter = setter;
2633    /**
2634     * @internal
2635     */
2636    this._value = void 0;
2637    /**
2638     * @internal
2639     */
2640    this.dep = new Dep(this);
2641    /**
2642     * @internal
2643     */
2644    this.__v_isRef = true;
2645    // TODO isolatedDeclarations "__v_isReadonly"
2646    // A computed is also a subscriber that tracks other deps
2647    /**
2648     * @internal
2649     */
2650    this.deps = void 0;
2651    /**
2652     * @internal
2653     */
2654    this.depsTail = void 0;
2655    /**
2656     * @internal
2657     */
2658    this.flags = 16;
2659    /**
2660     * @internal
2661     */
2662    this.globalVersion = globalVersion - 1;
2663    /**
2664     * @internal
2665     */
2666    this.next = void 0;
2667    // for backwards compat
2668    this.effect = this;
2669    this["__v_isReadonly"] = !setter;
2670    this.isSSR = isSSR;
2671  }
2672  /**
2673   * @internal
2674   */
2675  notify() {
2676    this.flags |= 16;
2677    if (!(this.flags & 8) && // avoid infinite self recursion
2678    activeSub !== this) {
2679      batch(this, true);
2680      return true;
2681    } else if (false) // removed by dead control flow
2682{}
2683  }
2684  get value() {
2685    const link =  false ? 0 : this.dep.track();
2686    refreshComputed(this);
2687    if (link) {
2688      link.version = this.dep.version;
2689    }
2690    return this._value;
2691  }
2692  set value(newValue) {
2693    if (this.setter) {
2694      this.setter(newValue);
2695    } else if (false) // removed by dead control flow
2696{}
2697  }
2698}
2699function computed(getterOrOptions, debugOptions, isSSR = false) {
2700  let getter;
2701  let setter;
2702  if (shared_esm_bundler_isFunction(getterOrOptions)) {
2703    getter = getterOrOptions;
2704  } else {
2705    getter = getterOrOptions.get;
2706    setter = getterOrOptions.set;
2707  }
2708  const cRef = new ComputedRefImpl(getter, setter, isSSR);
2709  if (false) // removed by dead control flow
2710{}
2711  return cRef;
2712}
2713
2714const TrackOpTypes = {
2715  "GET": "get",
2716  "HAS": "has",
2717  "ITERATE": "iterate"
2718};
2719const TriggerOpTypes = {
2720  "SET": "set",
2721  "ADD": "add",
2722  "DELETE": "delete",
2723  "CLEAR": "clear"
2724};
2725const ReactiveFlags = {
2726  "SKIP": "__v_skip",
2727  "IS_REACTIVE": "__v_isReactive",
2728  "IS_READONLY": "__v_isReadonly",
2729  "IS_SHALLOW": "__v_isShallow",
2730  "RAW": "__v_raw",
2731  "IS_REF": "__v_isRef"
2732};
2733
2734const WatchErrorCodes = {
2735  "WATCH_GETTER": 2,
2736  "2": "WATCH_GETTER",
2737  "WATCH_CALLBACK": 3,
2738  "3": "WATCH_CALLBACK",
2739  "WATCH_CLEANUP": 4,
2740  "4": "WATCH_CLEANUP"
2741};
2742const INITIAL_WATCHER_VALUE = {};
2743const cleanupMap = /* @__PURE__ */ new WeakMap();
2744let activeWatcher = void 0;
2745function getCurrentWatcher() {
2746  return activeWatcher;
2747}
2748function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
2749  if (owner) {
2750    let cleanups = cleanupMap.get(owner);
2751    if (!cleanups) cleanupMap.set(owner, cleanups = []);
2752    cleanups.push(cleanupFn);
2753  } else if (false) // removed by dead control flow
2754{}
2755}
2756function watch(source, cb, options = EMPTY_OBJ) {
2757  const { immediate, deep, once, scheduler, augmentJob, call } = options;
2758  const warnInvalidSource = (s) => {
2759    (options.onWarn || reactivity_esm_bundler_warn)(
2760      `Invalid watch source: `,
2761      s,
2762      `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`
2763    );
2764  };
2765  const reactiveGetter = (source2) => {
2766    if (deep) return source2;
2767    if (isShallow(source2) || deep === false || deep === 0)
2768      return traverse(source2, 1);
2769    return traverse(source2);
2770  };
2771  let effect;
2772  let getter;
2773  let cleanup;
2774  let boundCleanup;
2775  let forceTrigger = false;
2776  let isMultiSource = false;
2777  if (reactivity_esm_bundler_isRef(source)) {
2778    getter = () => source.value;
2779    forceTrigger = isShallow(source);
2780  } else if (isReactive(source)) {
2781    getter = () => reactiveGetter(source);
2782    forceTrigger = true;
2783  } else if (shared_esm_bundler_isArray(source)) {
2784    isMultiSource = true;
2785    forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
2786    getter = () => source.map((s) => {
2787      if (reactivity_esm_bundler_isRef(s)) {
2788        return s.value;
2789      } else if (isReactive(s)) {
2790        return reactiveGetter(s);
2791      } else if (shared_esm_bundler_isFunction(s)) {
2792        return call ? call(s, 2) : s();
2793      } else {
2794         false && 0;
2795      }
2796    });
2797  } else if (shared_esm_bundler_isFunction(source)) {
2798    if (cb) {
2799      getter = call ? () => call(source, 2) : source;
2800    } else {
2801      getter = () => {
2802        if (cleanup) {
2803          pauseTracking();
2804          try {
2805            cleanup();
2806          } finally {
2807            resetTracking();
2808          }
2809        }
2810        const currentEffect = activeWatcher;
2811        activeWatcher = effect;
2812        try {
2813          return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
2814        } finally {
2815          activeWatcher = currentEffect;
2816        }
2817      };
2818    }
2819  } else {
2820    getter = shared_esm_bundler_NOOP;
2821     false && 0;
2822  }
2823  if (cb && deep) {
2824    const baseGetter = getter;
2825    const depth = deep === true ? Infinity : deep;
2826    getter = () => traverse(baseGetter(), depth);
2827  }
2828  const scope = getCurrentScope();
2829  const watchHandle = () => {
2830    effect.stop();
2831    if (scope && scope.active) {
2832      remove(scope.effects, effect);
2833    }
2834  };
2835  if (once && cb) {
2836    const _cb = cb;
2837    cb = (...args) => {
2838      _cb(...args);
2839      watchHandle();
2840    };
2841  }
2842  let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
2843  const job = (immediateFirstRun) => {
2844    if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) {
2845      return;
2846    }
2847    if (cb) {
2848      const newValue = effect.run();
2849      if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
2850        if (cleanup) {
2851          cleanup();
2852        }
2853        const currentWatcher = activeWatcher;
2854        activeWatcher = effect;
2855        try {
2856          const args = [
2857            newValue,
2858            // pass undefined as the old value when it's changed for the first time
2859            oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
2860            boundCleanup
2861          ];
2862          oldValue = newValue;
2863          call ? call(cb, 3, args) : (
2864            // @ts-expect-error
2865            cb(...args)
2866          );
2867        } finally {
2868          activeWatcher = currentWatcher;
2869        }
2870      }
2871    } else {
2872      effect.run();
2873    }
2874  };
2875  if (augmentJob) {
2876    augmentJob(job);
2877  }
2878  effect = new ReactiveEffect(getter);
2879  effect.scheduler = scheduler ? () => scheduler(job, false) : job;
2880  boundCleanup = (fn) => onWatcherCleanup(fn, false, effect);
2881  cleanup = effect.onStop = () => {
2882    const cleanups = cleanupMap.get(effect);
2883    if (cleanups) {
2884      if (call) {
2885        call(cleanups, 4);
2886      } else {
2887        for (const cleanup2 of cleanups) cleanup2();
2888      }
2889      cleanupMap.delete(effect);
2890    }
2891  };
2892  if (false) // removed by dead control flow
2893{}
2894  if (cb) {
2895    if (immediate) {
2896      job(true);
2897    } else {
2898      oldValue = effect.run();
2899    }
2900  } else if (scheduler) {
2901    scheduler(job.bind(null, true), true);
2902  } else {
2903    effect.run();
2904  }
2905  watchHandle.pause = effect.pause.bind(effect);
2906  watchHandle.resume = effect.resume.bind(effect);
2907  watchHandle.stop = watchHandle;
2908  return watchHandle;
2909}
2910function traverse(value, depth = Infinity, seen) {
2911  if (depth <= 0 || !shared_esm_bundler_isObject(value) || value["__v_skip"]) {
2912    return value;
2913  }
2914  seen = seen || /* @__PURE__ */ new Map();
2915  if ((seen.get(value) || 0) >= depth) {
2916    return value;
2917  }
2918  seen.set(value, depth);
2919  depth--;
2920  if (reactivity_esm_bundler_isRef(value)) {
2921    traverse(value.value, depth, seen);
2922  } else if (shared_esm_bundler_isArray(value)) {
2923    for (let i = 0; i < value.length; i++) {
2924      traverse(value[i], depth, seen);
2925    }
2926  } else if (isSet(value) || isMap(value)) {
2927    value.forEach((v) => {
2928      traverse(v, depth, seen);
2929    });
2930  } else if (isPlainObject(value)) {
2931    for (const key in value) {
2932      traverse(value[key], depth, seen);
2933    }
2934    for (const key of Object.getOwnPropertySymbols(value)) {
2935      if (Object.prototype.propertyIsEnumerable.call(value, key)) {
2936        traverse(value[key], depth, seen);
2937      }
2938    }
2939  }
2940  return value;
2941}
2942
2943
2944
2945;// ./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
2946/**
2947* @vue/runtime-core v3.5.25
2948* (c) 2018-present Yuxi (Evan) You and Vue contributors
2949* @license MIT