https://atlasfinancialstrategies.com/_nuxt/C_gQNvg5.js

27 key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
28(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
29const isModelListener = (key) => key.startsWith("onUpdate:");
30const extend$1 = Object.assign;
31const remove = (arr, el) => {
32  const i = arr.indexOf(el);
33  if (i > -1) {
34    arr.splice(i, 1);
35  }
36};
37const hasOwnProperty$d = Object.prototype.hasOwnProperty;
38const hasOwn = (val, key) => hasOwnProperty$d.call(val, key);
39const isArray$4 = Array.isArray;
40const isMap$1 = (val) => toTypeString(val) === "[object Map]";
41const isSet$1 = (val) => toTypeString(val) === "[object Set]";
42const isDate$2 = (val) => toTypeString(val) === "[object Date]";
43const isRegExp$1 = (val) => toTypeString(val) === "[object RegExp]";
44const isFunction$4 = (val) => typeof val === "function";
45const isString$1 = (val) => typeof val === "string";
46const isSymbol$1 = (val) => typeof val === "symbol";
47const isObject$4 = (val) => val !== null && typeof val === "object";
48const isPromise$1 = (val) => {
49  return (isObject$4(val) || isFunction$4(val)) && isFunction$4(val.then) && isFunction$4(val.catch);
50};
51const objectToString$2 = Object.prototype.toString;
52const toTypeString = (value) => objectToString$2.call(value);
53const toRawType = (value) => {
54  return toTypeString(value).slice(8, -1);
55};
56const isPlainObject$4 = (val) => toTypeString(val) === "[object Object]";
57const isIntegerKey = (key) => isString$1(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
58const isReservedProp = /* @__PURE__ */ makeMap(
59  // the leading comma is intentional so empty string "" is also included
60  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
61);
62const isBuiltInDirective = /* @__PURE__ */ makeMap(
63  "bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
64);
65const cacheStringFunction = (fn) => {
66  const cache = /* @__PURE__ */ Object.create(null);
67  return (str) => {
68    const hit = cache[str];
69    return hit || (cache[str] = fn(str));
70  };
71};
72const camelizeRE = /-(\w)/g;
73const camelize = cacheStringFunction(
74  (str) => {
75    return str.replace(camelizeRE, (_, c2) => c2 ? c2.toUpperCase() : "");
76  }
77);
78const hyphenateRE = /\B([A-Z])/g;
79const hyphenate = cacheStringFunction(
80  (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
81);
82const capitalize$1 = cacheStringFunction((str) => {
83  return str.charAt(0).toUpperCase() + str.slice(1);
84});
85const toHandlerKey = cacheStringFunction(
86  (str) => {
87    const s = str ? `on${capitalize$1(str)}` : ``;
88    return s;
89  }
90);
91const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
92const invokeArrayFns = (fns, ...arg) => {
93  for (let i = 0; i < fns.length; i++) {
94    fns[i](...arg);
95  }
96};
97const def = (obj, key, value, writable = false) => {
98  Object.defineProperty(obj, key, {
99    configurable: true,
100    enumerable: false,
101    writable,
102    value
103  });
104};
105const looseToNumber = (val) => {
106  const n = parseFloat(val);
107  return isNaN(n) ? val : n;
108};
109const toNumber$2 = (val) => {
110  const n = isString$1(val) ? Number(val) : NaN;
111  return isNaN(n) ? val : n;
112};
113let _globalThis$1;
114const getGlobalThis = () => {
115  return _globalThis$1 || (_globalThis$1 = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
116};
117const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
118function genPropsAccessExp(name) {
119  return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;
120}
121function genCacheKey(source, options) {
122  return source + JSON.stringify(
123    options,
124    (_, val) => typeof val === "function" ? val.toString() : val
125  );
126}
127const PatchFlags = {
128  "TEXT": 1,
129  "1": "TEXT",
130  "CLASS": 2,
131  "2": "CLASS",
132  "STYLE": 4,
133  "4": "STYLE",
134  "PROPS": 8,
135  "8": "PROPS",
136  "FULL_PROPS": 16,
137  "16": "FULL_PROPS",
138  "NEED_HYDRATION": 32,
139  "32": "NEED_HYDRATION",
140  "STABLE_FRAGMENT": 64,
141  "64": "STABLE_FRAGMENT",
142  "KEYED_FRAGMENT": 128,
143  "128": "KEYED_FRAGMENT",
144  "UNKEYED_FRAGMENT": 256,
145  "256": "UNKEYED_FRAGMENT",
146  "NEED_PATCH": 512,
147  "512": "NEED_PATCH",
148  "DYNAMIC_SLOTS": 1024,
149  "1024": "DYNAMIC_SLOTS",
150  "DEV_ROOT_FRAGMENT": 2048,
151  "2048": "DEV_ROOT_FRAGMENT",
152  "CACHED": -1,
153  "-1": "CACHED",
154  "BAIL": -2,
155  "-2": "BAIL"
156};
157const PatchFlagNames = {
158  [1]: `TEXT`,
159  [2]: `CLASS`,
160  [4]: `STYLE`,
161  [8]: `PROPS`,
162  [16]: `FULL_PROPS`,
163  [32]: `NEED_HYDRATION`,
164  [64]: `STABLE_FRAGMENT`,
165  [128]: `KEYED_FRAGMENT`,
166  [256]: `UNKEYED_FRAGMENT`,
167  [512]: `NEED_PATCH`,
168  [1024]: `DYNAMIC_SLOTS`,
169  [2048]: `DEV_ROOT_FRAGMENT`,
170  [-1]: `HOISTED`,
171  [-2]: `BAIL`
172};
173const ShapeFlags = {
174  "ELEMENT": 1,
175  "1": "ELEMENT",
176  "FUNCTIONAL_COMPONENT": 2,
177  "2": "FUNCTIONAL_COMPONENT",
178  "STATEFUL_COMPONENT": 4,
179  "4": "STATEFUL_COMPONENT",
180  "TEXT_CHILDREN": 8,
181  "8": "TEXT_CHILDREN",
182  "ARRAY_CHILDREN": 16,
183  "16": "ARRAY_CHILDREN",
184  "SLOTS_CHILDREN": 32,
185  "32": "SLOTS_CHILDREN",
186  "TELEPORT": 64,
187  "64": "TELEPORT",
188  "SUSPENSE": 128,
189  "128": "SUSPENSE",
190  "COMPONENT_SHOULD_KEEP_ALIVE": 256,
191  "256": "COMPONENT_SHOULD_KEEP_ALIVE",
192  "COMPONENT_KEPT_ALIVE": 512,
193  "512": "COMPONENT_KEPT_ALIVE",
194  "COMPONENT": 6,
195  "6": "COMPONENT"
196};
197const SlotFlags = {
198  "STABLE": 1,
199  "1": "STABLE",
200  "DYNAMIC": 2,
201  "2": "DYNAMIC",
202  "FORWARDED": 3,
203  "3": "FORWARDED"
204};
205const slotFlagsText = {
206  [1]: "STABLE",
207  [2]: "DYNAMIC",
208  [3]: "FORWARDED"
209};
210const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol";
211const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
212const isGloballyWhitelisted = isGloballyAllowed;
213const range = 2;
214function generateCodeFrame(source, start = 0, end = source.length) {
215  start = Math.max(0, Math.min(start, source.length));
216  end = Math.max(0, Math.min(end, source.length));
217  if (start > end) return "";
218  let lines = source.split(/(\r?\n)/);
219  const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
220  lines = lines.filter((_, idx) => idx % 2 === 0);
221  let count = 0;
222  const res = [];
223  for (let i = 0; i < lines.length; i++) {
224    count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
225    if (count >= start) {
226      for (let j = i - range; j <= i + range || end > count; j++) {
227        if (j < 0 || j >= lines.length) continue;
228        const line = j + 1;
229        res.push(
230          `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`
231        );
232        const lineLength = lines[j].length;
233        const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
234        if (j === i) {
235          const pad = start - (count - (lineLength + newLineSeqLength));
236          const length = Math.max(
237            1,
238            end > count ? lineLength - pad : end - start
239          );
240          res.push(`   |  ` + " ".repeat(pad) + "^".repeat(length));
241        } else if (j > i) {
242          if (end > count) {
243            const length = Math.max(Math.min(end - count, lineLength), 1);
244            res.push(`   |  ` + "^".repeat(length));
245          }
246          count += lineLength + newLineSeqLength;
247        }
248      }
249      break;
250    }
251  }
252  return res.join("\n");
253}
254function normalizeStyle(value) {
255  if (isArray$4(value)) {
256    const res = {};
257    for (let i = 0; i < value.length; i++) {
258      const item = value[i];
259      const normalized = isString$1(item) ? parseStringStyle(item) : normalizeStyle(item);
260      if (normalized) {
261        for (const key in normalized) {
262          res[key] = normalized[key];
263        }
264      }
265    }
266    return res;
267  } else if (isString$1(value) || isObject$4(value)) {
268    return value;
269  }
270}
271const listDelimiterRE = /;(?![^(]*\))/g;
272const propertyDelimiterRE = /:([^]+)/;
273const styleCommentRE = /\/\*[^]*?\*\//g;
274function parseStringStyle(cssText) {
275  const ret = {};
276  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
277    if (item) {
278      const tmp = item.split(propertyDelimiterRE);
279      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
280    }
281  });
282  return ret;
283}
284function stringifyStyle(styles) {
285  if (!styles) return "";
286  if (isString$1(styles)) return styles;
287  let ret = "";
288  for (const key in styles) {
289    const value = styles[key];
290    if (isString$1(value) || typeof value === "number") {
291      const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
292      ret += `${normalizedKey}:${value};`;
293    }
294  }
295  return ret;
296}
297function normalizeClass(value) {
298  let res = "";
299  if (isString$1(value)) {
300    res = value;
301  } else if (isArray$4(value)) {
302    for (let i = 0; i < value.length; i++) {
303      const normalized = normalizeClass(value[i]);
304      if (normalized) {
305        res += normalized + " ";
306      }
307    }
308  } else if (isObject$4(value)) {
309    for (const name in value) {
310      if (value[name]) {
311        res += name + " ";
312      }
313    }
314  }
315  return res.trim();
316}
317function normalizeProps$1(props) {
318  if (!props) return null;
319  let { class: klass, style } = props;
320  if (klass && !isString$1(klass)) {
321    props.class = normalizeClass(klass);
322  }
323  if (style) {
324    props.style = normalizeStyle(style);
325  }
326  return props;
327}
328const 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";
329const 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";
330const 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";
331const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
332const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
333const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
334const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
335const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
336const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
337const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
338const isBooleanAttr = /* @__PURE__ */ makeMap(
339  specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,

782      pausedQueueEffects.add(this);
783    } else if (this.scheduler) {
784      this.scheduler();
785    } else {
786      this.runIfDirty();
787    }
788  }
789  /**
790   * @internal
791   */
792  runIfDirty() {
793    if (isDirty(this)) {
794      this.run();
795    }
796  }
797  get dirty() {
798    return isDirty(this);
799  }
800}
801let batchDepth = 0;
802let batchedSub;
803let batchedComputed;
804function batch(sub2, isComputed = false) {
805  sub2.flags |= 8;
806  if (isComputed) {
807    sub2.next = batchedComputed;
808    batchedComputed = sub2;
809    return;
810  }
811  sub2.next = batchedSub;
812  batchedSub = sub2;
813}
814function startBatch() {
815  batchDepth++;
816}
817function endBatch() {
818  if (--batchDepth > 0) {
819    return;
820  }
821  if (batchedComputed) {
822    let e = batchedComputed;
823    batchedComputed = void 0;
824    while (e) {
825      const next = e.next;
826      e.next = void 0;
827      e.flags &= -9;
828      e = next;
829    }
830  }
831  let error;
832  while (batchedSub) {
833    let e = batchedSub;
834    batchedSub = void 0;
835    while (e) {
836      const next = e.next;
837      e.next = void 0;
838      e.flags &= -9;
839      if (e.flags & 1) {
840        try {
841          ;
842          e.trigger();
843        } catch (err) {
844          if (!error) error = err;
845        }
846      }
847      e = next;
848    }
849  }
850  if (error) throw error;
851}
852function prepareDeps(sub2) {
853  for (let link = sub2.deps; link; link = link.nextDep) {
854    link.version = -1;
855    link.prevActiveLink = link.dep.activeLink;
856    link.dep.activeLink = link;
857  }
858}
859function cleanupDeps(sub2) {
860  let head;
861  let tail = sub2.depsTail;
862  let link = tail;
863  while (link) {
864    const prev = link.prevDep;
865    if (link.version === -1) {
866      if (link === tail) tail = prev;
867      removeSub(link);
868      removeDep(link);
869    } else {
870      head = link;
871    }
872    link.dep.activeLink = link.prevActiveLink;
873    link.prevActiveLink = void 0;
874    link = prev;
875  }
876  sub2.deps = head;
877  sub2.depsTail = tail;
878}
879function isDirty(sub2) {
880  for (let link = sub2.deps; link; link = link.nextDep) {
881    if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
882      return true;
883    }
884  }
885  if (sub2._dirty) {
886    return true;
887  }
888  return false;
889}
890function refreshComputed(computed2) {
891  if (computed2.flags & 4 && !(computed2.flags & 16)) {
892    return;
893  }
894  computed2.flags &= -17;
895  if (computed2.globalVersion === globalVersion) {
896    return;
897  }
898  computed2.globalVersion = globalVersion;
899  const dep = computed2.dep;
900  computed2.flags |= 2;
901  if (dep.version > 0 && !computed2.isSSR && computed2.deps && !isDirty(computed2)) {
902    computed2.flags &= -3;
903    return;
904  }
905  const prevSub = activeSub;
906  const prevShouldTrack = shouldTrack;
907  activeSub = computed2;
908  shouldTrack = true;
909  try {
910    prepareDeps(computed2);
911    const value = computed2.fn(computed2._value);
912    if (dep.version === 0 || hasChanged(value, computed2._value)) {
913      computed2._value = value;
914      dep.version++;
915    }
916  } catch (err) {
917    dep.version++;
918    throw err;
919  } finally {
920    activeSub = prevSub;
921    shouldTrack = prevShouldTrack;
922    cleanupDeps(computed2);
923    computed2.flags &= -3;
924  }
925}
926function removeSub(link, soft = false) {
927  const { dep, prevSub, nextSub } = link;
928  if (prevSub) {
929    prevSub.nextSub = nextSub;
930    link.prevSub = void 0;
931  }
932  if (nextSub) {
933    nextSub.prevSub = prevSub;
934    link.nextSub = void 0;
935  }
936  if (dep.subs === link) {
937    dep.subs = prevSub;
938    if (!prevSub && dep.computed) {
939      dep.computed.flags &= -5;
940      for (let l3 = dep.computed.deps; l3; l3 = l3.nextDep) {
941        removeSub(l3, true);
942      }
943    }
944  }
945  if (!soft && !--dep.sc && dep.map) {
946    dep.map.delete(dep.key);
947  }
948}
949function removeDep(link) {
950  const { prevDep, nextDep } = link;
951  if (prevDep) {
952    prevDep.nextDep = nextDep;
953    link.prevDep = void 0;
954  }
955  if (nextDep) {
956    nextDep.prevDep = prevDep;
957    link.nextDep = void 0;
958  }
959}
960function effect(fn, options) {
961  if (fn.effect instanceof ReactiveEffect) {
962    fn = fn.effect.fn;
963  }
964  const e = new ReactiveEffect(fn);
965  if (options) {
966    extend$1(e, options);
967  }
968  try {
969    e.run();
970  } catch (err) {
971    e.stop();
972    throw err;
973  }
974  const runner = e.run.bind(e);
975  runner.effect = e;
976  return runner;
977}
978function stop(runner) {
979  runner.effect.stop();
980}
981let shouldTrack = true;
982const trackStack = [];
983function pauseTracking() {
984  trackStack.push(shouldTrack);
985  shouldTrack = false;

986}
987function resetTracking() {
988  const last = trackStack.pop();
989  shouldTrack = last === void 0 ? true : last;
990}
991function cleanupEffect(e) {
992  const { cleanup } = e;
993  e.cleanup = void 0;
994  if (cleanup) {
995    const prevSub = activeSub;
996    activeSub = void 0;
997    try {
998      cleanup();
999    } finally {
1000      activeSub = prevSub;
1001    }
1002  }
1003}
1004let globalVersion = 0;
1005class Link {
1006  constructor(sub2, dep) {
1007    this.sub = sub2;
1008    this.dep = dep;
1009    this.version = dep.version;
1010    this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
1011  }
1012}
1013class Dep {
1014  constructor(computed2) {
1015    this.computed = computed2;
1016    this.version = 0;
1017    this.activeLink = void 0;
1018    this.subs = void 0;
1019    this.map = void 0;
1020    this.key = void 0;
1021    this.sc = 0;
1022  }
1023  track(debugInfo) {
1024    if (!activeSub || !shouldTrack || activeSub === this.computed) {
1025      return;
1026    }
1027    let link = this.activeLink;
1028    if (link === void 0 || link.sub !== activeSub) {
1029      link = this.activeLink = new Link(activeSub, this);
1030      if (!activeSub.deps) {
1031        activeSub.deps = activeSub.depsTail = link;
1032      } else {
1033        link.prevDep = activeSub.depsTail;
1034        activeSub.depsTail.nextDep = link;
1035        activeSub.depsTail = link;
1036      }
1037      addSub(link);
1038    } else if (link.version === -1) {
1039      link.version = this.version;
1040      if (link.nextDep) {
1041        const next = link.nextDep;
1042        next.prevDep = link.prevDep;
1043        if (link.prevDep) {
1044          link.prevDep.nextDep = next;
1045        }
1046        link.prevDep = activeSub.depsTail;
1047        link.nextDep = void 0;
1048        activeSub.depsTail.nextDep = link;
1049        activeSub.depsTail = link;
1050        if (activeSub.deps === link) {
1051          activeSub.deps = next;
1052        }
1053      }
1054    }
1055    return link;
1056  }
1057  trigger(debugInfo) {
1058    this.version++;
1059    globalVersion++;
1060    this.notify(debugInfo);
1061  }
1062  notify(debugInfo) {
1063    startBatch();
1064    try {
1065      if (false) ;
1066      for (let link = this.subs; link; link = link.prevSub) {
1067        if (link.sub.notify()) {
1068          ;
1069          link.sub.dep.notify();
1070        }
1071      }
1072    } finally {
1073      endBatch();
1074    }
1075  }
1076}
1077function addSub(link) {
1078  link.dep.sc++;
1079  if (link.sub.flags & 4) {
1080    const computed2 = link.dep.computed;
1081    if (computed2 && !link.dep.subs) {
1082      computed2.flags |= 4 | 16;
1083      for (let l3 = computed2.deps; l3; l3 = l3.nextDep) {
1084        addSub(l3);
1085      }
1086    }
1087    const currentTail = link.dep.subs;
1088    if (currentTail !== link) {
1089      link.prevSub = currentTail;
1090      if (currentTail) currentTail.nextSub = link;
1091    }
1092    link.dep.subs = link;
1093  }
1094}
1095const targetMap = /* @__PURE__ */ new WeakMap();
1096const ITERATE_KEY = Symbol(
1097  ""
1098);
1099const MAP_KEY_ITERATE_KEY = Symbol(
1100  ""
1101);
1102const ARRAY_ITERATE_KEY = Symbol(
1103  ""
1104);
1105function track(target, type, key) {
1106  if (shouldTrack && activeSub) {
1107    let depsMap = targetMap.get(target);
1108    if (!depsMap) {
1109      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
1110    }
1111    let dep = depsMap.get(key);
1112    if (!dep) {
1113      depsMap.set(key, dep = new Dep());
1114      dep.map = depsMap;
1115      dep.key = key;
1116    }
1117    {
1118      dep.track();
1119    }
1120  }
1121}
1122function trigger(target, type, key, newValue, oldValue, oldTarget) {
1123  const depsMap = targetMap.get(target);
1124  if (!depsMap) {
1125    globalVersion++;
1126    return;
1127  }
1128  const run = (dep) => {
1129    if (dep) {
1130      {
1131        dep.trigger();
1132      }
1133    }
1134  };
1135  startBatch();
1136  if (type === "clear") {
1137    depsMap.forEach(run);
1138  } else {
1139    const targetIsArray = isArray$4(target);
1140    const isArrayIndex = targetIsArray && isIntegerKey(key);
1141    if (targetIsArray && key === "length") {
1142      const newLength = Number(newValue);
1143      depsMap.forEach((dep, key2) => {

1584    forEach(callback, thisArg) {
1585      const observed = this;
1586      const target = observed["__v_raw"];
1587      const rawTarget = toRaw(target);
1588      const wrap = shallow ? toShallow : readonly2 ? toReadonly : toReactive;
1589      !readonly2 && track(rawTarget, "iterate", ITERATE_KEY);
1590      return target.forEach((value, key) => {
1591        return callback.call(thisArg, wrap(value), wrap(key), observed);
1592      });
1593    }
1594  };
1595  extend$1(
1596    instrumentations,
1597    readonly2 ? {
1598      add: createReadonlyMethod("add"),
1599      set: createReadonlyMethod("set"),
1600      delete: createReadonlyMethod("delete"),
1601      clear: createReadonlyMethod("clear")
1602    } : {
1603      add(value) {
1604        if (!shallow && !isShallow(value) && !isReadonly(value)) {
1605          value = toRaw(value);
1606        }
1607        const target = toRaw(this);
1608        const proto = getProto(target);
1609        const hadKey = proto.has.call(target, value);
1610        if (!hadKey) {
1611          target.add(value);
1612          trigger(target, "add", value, value);
1613        }
1614        return this;
1615      },
1616      set(key, value) {
1617        if (!shallow && !isShallow(value) && !isReadonly(value)) {
1618          value = toRaw(value);
1619        }
1620        const target = toRaw(this);
1621        const { has, get: get2 } = getProto(target);
1622        let hadKey = has.call(target, key);
1623        if (!hadKey) {
1624          key = toRaw(key);
1625          hadKey = has.call(target, key);
1626        }
1627        const oldValue = get2.call(target, key);
1628        target.set(key, value);
1629        if (!hadKey) {
1630          trigger(target, "add", key, value);
1631        } else if (hasChanged(value, oldValue)) {
1632          trigger(target, "set", key, value);
1633        }
1634        return this;
1635      },
1636      delete(key) {
1637        const target = toRaw(this);
1638        const { has, get: get2 } = getProto(target);
1639        let hadKey = has.call(target, key);
1640        if (!hadKey) {
1641          key = toRaw(key);
1642          hadKey = has.call(target, key);
1643        }
1644        get2 ? get2.call(target, key) : void 0;
1645        const result = target.delete(key);
1646        if (hadKey) {
1647          trigger(target, "delete", key, void 0);
1648        }
1649        return result;
1650      },
1651      clear() {
1652        const target = toRaw(this);
1653        const hadItems = target.size !== 0;
1654        const result = target.clear();
1655        if (hadItems) {
1656          trigger(
1657            target,
1658            "clear",
1659            void 0,
1660            void 0
1661          );
1662        }
1663        return result;
1664      }
1665    }
1666  );
1667  const iteratorMethods = [
1668    "keys",
1669    "values",
1670    "entries",
1671    Symbol.iterator
1672  ];
1673  iteratorMethods.forEach((method) => {
1674    instrumentations[method] = createIterableMethod(method, readonly2, shallow);
1675  });
1676  return instrumentations;
1677}
1678function createInstrumentationGetter(isReadonly2, shallow) {
1679  const instrumentations = createInstrumentations(isReadonly2, shallow);
1680  return (target, key, receiver) => {
1681    if (key === "__v_isReactive") {
1682      return !isReadonly2;
1683    } else if (key === "__v_isReadonly") {
1684      return isReadonly2;
1685    } else if (key === "__v_raw") {
1686      return target;
1687    }
1688    return Reflect.get(
1689      hasOwn(instrumentations, key) && key in target ? instrumentations : target,
1690      key,
1691      receiver
1692    );
1693  };
1694}
1695const mutableCollectionHandlers = {
1696  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
1697};
1698const shallowCollectionHandlers = {
1699  get: /* @__PURE__ */ createInstrumentationGetter(false, true)
1700};
1701const readonlyCollectionHandlers = {
1702  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
1703};
1704const shallowReadonlyCollectionHandlers = {
1705  get: /* @__PURE__ */ createInstrumentationGetter(true, true)
1706};
1707const reactiveMap = /* @__PURE__ */ new WeakMap();
1708const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
1709const readonlyMap = /* @__PURE__ */ new WeakMap();
1710const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
1711function targetTypeMap(rawType) {
1712  switch (rawType) {
1713    case "Object":
1714    case "Array":
1715      return 1;
1716    case "Map":
1717    case "Set":
1718    case "WeakMap":
1719    case "WeakSet":
1720      return 2;
1721    default:
1722      return 0;
1723  }
1724}
1725function getTargetType(value) {
1726  return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
1727}
1728function reactive(target) {
1729  if (isReadonly(target)) {
1730    return target;
1731  }
1732  return createReactiveObject(
1733    target,
1734    false,
1735    mutableHandlers,
1736    mutableCollectionHandlers,
1737    reactiveMap
1738  );
1739}
1740function shallowReactive(target) {
1741  return createReactiveObject(
1742    target,
1743    false,
1744    shallowReactiveHandlers,
1745    shallowCollectionHandlers,
1746    shallowReactiveMap
1747  );
1748}
1749function readonly(target) {
1750  return createReactiveObject(
1751    target,
1752    true,
1753    readonlyHandlers,
1754    readonlyCollectionHandlers,
1755    readonlyMap
1756  );
1757}
1758function shallowReadonly(target) {
1759  return createReactiveObject(
1760    target,
1761    true,
1762    shallowReadonlyHandlers,
1763    shallowReadonlyCollectionHandlers,
1764    shallowReadonlyMap
1765  );
1766}
1767function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
1768  if (!isObject$4(target)) {
1769    return target;
1770  }
1771  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
1772    return target;
1773  }
1774  const existingProxy = proxyMap.get(target);
1775  if (existingProxy) {
1776    return existingProxy;
1777  }
1778  const targetType = getTargetType(target);
1779  if (targetType === 0) {
1780    return target;
1781  }
1782  const proxy = new Proxy(
1783    target,
1784    targetType === 2 ? collectionHandlers : baseHandlers
1785  );
1786  proxyMap.set(target, proxy);
1787  return proxy;
1788}
1789function isReactive(value) {
1790  if (isReadonly(value)) {
1791    return isReactive(value["__v_raw"]);
1792  }
1793  return !!(value && value["__v_isReactive"]);
1794}
1795function isReadonly(value) {
1796  return !!(value && value["__v_isReadonly"]);
1797}
1798function isShallow(value) {
1799  return !!(value && value["__v_isShallow"]);
1800}
1801function isProxy(value) {
1802  return value ? !!value["__v_raw"] : false;
1803}
1804function toRaw(observed) {
1805  const raw = observed && observed["__v_raw"];
1806  return raw ? toRaw(raw) : observed;
1807}
1808function markRaw(value) {
1809  if (!hasOwn(value, "__v_skip") && Object.isExtensible(value)) {
1810    def(value, "__v_skip", true);
1811  }
1812  return value;
1813}
1814const toReactive = (value) => isObject$4(value) ? reactive(value) : value;
1815const toReadonly = (value) => isObject$4(value) ? readonly(value) : value;
1816function isRef(r2) {
1817  return r2 ? r2["__v_isRef"] === true : false;
1818}
1819function ref(value) {
1820  return createRef(value, false);
1821}
1822function shallowRef(value) {
1823  return createRef(value, true);
1824}
1825function createRef(rawValue2, shallow) {
1826  if (isRef(rawValue2)) {
1827    return rawValue2;
1828  }
1829  return new RefImpl(rawValue2, shallow);
1830}
1831class RefImpl {
1832  constructor(value, isShallow2) {
1833    this.dep = new Dep();
1834    this["__v_isRef"] = true;
1835    this["__v_isShallow"] = false;
1836    this._rawValue = isShallow2 ? value : toRaw(value);
1837    this._value = isShallow2 ? value : toReactive(value);
1838    this["__v_isShallow"] = isShallow2;
1839  }
1840  get value() {
1841    {
1842      this.dep.track();
1843    }
1844    return this._value;
1845  }
1846  set value(newValue) {
1847    const oldValue = this._rawValue;
1848    const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
1849    newValue = useDirectValue ? newValue : toRaw(newValue);
1850    if (hasChanged(newValue, oldValue)) {
1851      this._rawValue = newValue;
1852      this._value = useDirectValue ? newValue : toReactive(newValue);
1853      {
1854        this.dep.trigger();
1855      }
1856    }
1857  }
1858}
1859function triggerRef(ref2) {
1860  if (ref2.dep) {
1861    {
1862      ref2.dep.trigger();
1863    }
1864  }
1865}
1866function unref(ref2) {
1867  return isRef(ref2) ? ref2.value : ref2;
1868}
1869function toValue(source) {
1870  return isFunction$4(source) ? source() : unref(source);
1871}
1872const shallowUnwrapHandlers = {
1873  get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)),
1874  set: (target, key, value, receiver) => {
1875    const oldValue = target[key];
1876    if (isRef(oldValue) && !isRef(value)) {
1877      oldValue.value = value;
1878      return true;
1879    } else {
1880      return Reflect.set(target, key, value, receiver);
1881    }
1882  }
1883};
1884function proxyRefs(objectWithRefs) {
1885  return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
1886}
1887class CustomRefImpl {
1888  constructor(factory2) {
1889    this["__v_isRef"] = true;
1890    this._value = void 0;
1891    const dep = this.dep = new Dep();
1892    const { get: get2, set: set2 } = factory2(dep.track.bind(dep), dep.trigger.bind(dep));
1893    this._get = get2;
1894    this._set = set2;
1895  }
1896  get value() {
1897    return this._value = this._get();
1898  }
1899  set value(newVal) {
1900    this._set(newVal);
1901  }
1902}
1903function customRef(factory2) {
1904  return new CustomRefImpl(factory2);
1905}
1906function toRefs(object) {
1907  const ret = isArray$4(object) ? new Array(object.length) : {};
1908  for (const key in object) {
1909    ret[key] = propertyToRef(object, key);
1910  }
1911  return ret;
1912}
1913class ObjectRefImpl {
1914  constructor(_object, _key, _defaultValue) {
1915    this._object = _object;
1916    this._key = _key;
1917    this._defaultValue = _defaultValue;
1918    this["__v_isRef"] = true;
1919    this._value = void 0;
1920  }
1921  get value() {
1922    const val = this._object[this._key];
1923    return this._value = val === void 0 ? this._defaultValue : val;
1924  }
1925  set value(newVal) {
1926    this._object[this._key] = newVal;
1927  }
1928  get dep() {
1929    return getDepFromReactive(toRaw(this._object), this._key);
1930  }
1931}
1932class GetterRefImpl {
1933  constructor(_getter) {
1934    this._getter = _getter;
1935    this["__v_isRef"] = true;
1936    this["__v_isReadonly"] = true;
1937    this._value = void 0;
1938  }
1939  get value() {
1940    return this._value = this._getter();
1941  }
1942}
1943function toRef(source, key, defaultValue) {
1944  if (isRef(source)) {
1945    return source;
1946  } else if (isFunction$4(source)) {
1947    return new GetterRefImpl(source);
1948  } else if (isObject$4(source) && arguments.length > 1) {
1949    return propertyToRef(source, key, defaultValue);
1950  } else {
1951    return ref(source);
1952  }
1953}
1954function propertyToRef(source, key, defaultValue) {
1955  const val = source[key];
1956  return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
1957}
1958class ComputedRefImpl {
1959  constructor(fn, setter, isSSR) {
1960    this.fn = fn;
1961    this.setter = setter;
1962    this._value = void 0;
1963    this.dep = new Dep(this);
1964    this.__v_isRef = true;
1965    this.deps = void 0;
1966    this.depsTail = void 0;
1967    this.flags = 16;
1968    this.globalVersion = globalVersion - 1;
1969    this.next = void 0;
1970    this.effect = this;
1971    this["__v_isReadonly"] = !setter;
1972    this.isSSR = isSSR;
1973  }
1974  /**
1975   * @internal
1976   */
1977  notify() {
1978    this.flags |= 16;
1979    if (!(this.flags & 8) && // avoid infinite self recursion
1980    activeSub !== this) {
1981      batch(this, true);
1982      return true;
1983    }
1984  }
1985  get value() {
1986    const link = this.dep.track();
1987    refreshComputed(this);
1988    if (link) {
1989      link.version = this.dep.version;
1990    }
1991    return this._value;
1992  }
1993  set value(newValue) {
1994    if (this.setter) {
1995      this.setter(newValue);
1996    }
1997  }
1998}
1999function computed$1(getterOrOptions, debugOptions, isSSR = false) {
2000  let getter;
2001  let setter;
2002  if (isFunction$4(getterOrOptions)) {
2003    getter = getterOrOptions;
2004  } else {
2005    getter = getterOrOptions.get;
2006    setter = getterOrOptions.set;
2007  }
2008  const cRef = new ComputedRefImpl(getter, setter, isSSR);
2009  return cRef;
2010}
2011const TrackOpTypes = {
2012  "GET": "get",
2013  "HAS": "has",
2014  "ITERATE": "iterate"
2015};
2016const TriggerOpTypes = {
2017  "SET": "set",
2018  "ADD": "add",
2019  "DELETE": "delete",
2020  "CLEAR": "clear"
2021};
2022const INITIAL_WATCHER_VALUE = {};
2023const cleanupMap = /* @__PURE__ */ new WeakMap();
2024let activeWatcher = void 0;
2025function getCurrentWatcher() {
2026  return activeWatcher;
2027}
2028function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
2029  if (owner) {
2030    let cleanups = cleanupMap.get(owner);
2031    if (!cleanups) cleanupMap.set(owner, cleanups = []);
2032    cleanups.push(cleanupFn);
2033  }
2034}
2035function watch$1(source, cb, options = EMPTY_OBJ) {
2036  const { immediate, deep, once, scheduler, augmentJob, call } = options;
2037  const reactiveGetter = (source2) => {
2038    if (deep) return source2;
2039    if (isShallow(source2) || deep === false || deep === 0)
2040      return traverse(source2, 1);
2041    return traverse(source2);
2042  };
2043  let effect2;
2044  let getter;
2045  let cleanup;
2046  let boundCleanup;
2047  let forceTrigger = false;
2048  let isMultiSource = false;
2049  if (isRef(source)) {
2050    getter = () => source.value;
2051    forceTrigger = isShallow(source);
2052  } else if (isReactive(source)) {
2053    getter = () => reactiveGetter(source);
2054    forceTrigger = true;
2055  } else if (isArray$4(source)) {
2056    isMultiSource = true;
2057    forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
2058    getter = () => source.map((s) => {
2059      if (isRef(s)) {
2060        return s.value;
2061      } else if (isReactive(s)) {
2062        return reactiveGetter(s);
2063      } else if (isFunction$4(s)) {
2064        return call ? call(s, 2) : s();
2065      } else ;
2066    });
2067  } else if (isFunction$4(source)) {
2068    if (cb) {
2069      getter = call ? () => call(source, 2) : source;
2070    } else {
2071      getter = () => {
2072        if (cleanup) {
2073          pauseTracking();
2074          try {
2075            cleanup();
2076          } finally {
2077            resetTracking();
2078          }
2079        }
2080        const currentEffect = activeWatcher;
2081        activeWatcher = effect2;
2082        try {
2083          return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
2084        } finally {
2085          activeWatcher = currentEffect;
2086        }
2087      };
2088    }
2089  } else {
2090    getter = NOOP;
2091  }
2092  if (cb && deep) {
2093    const baseGetter = getter;
2094    const depth = deep === true ? Infinity : deep;
2095    getter = () => traverse(baseGetter(), depth);
2096  }
2097  const scope = getCurrentScope();
2098  const watchHandle = () => {
2099    effect2.stop();
2100    if (scope && scope.active) {
2101      remove(scope.effects, effect2);
2102    }
2103  };
2104  if (once && cb) {
2105    const _cb = cb;
2106    cb = (...args) => {
2107      _cb(...args);
2108      watchHandle();
2109    };
2110  }
2111  let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
2112  const job = (immediateFirstRun) => {
2113    if (!(effect2.flags & 1) || !effect2.dirty && !immediateFirstRun) {
2114      return;
2115    }
2116    if (cb) {
2117      const newValue = effect2.run();
2118      if (deep || forceTrigger || (isMultiSource ? newValue.some((v2, i) => hasChanged(v2, oldValue[i])) : hasChanged(newValue, oldValue))) {
2119        if (cleanup) {
2120          cleanup();
2121        }
2122        const currentWatcher = activeWatcher;
2123        activeWatcher = effect2;
2124        try {
2125          const args = [
2126            newValue,
2127            // pass undefined as the old value when it's changed for the first time
2128            oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
2129            boundCleanup
2130          ];
2131          call ? call(cb, 3, args) : (
2132            // @ts-expect-error
2133            cb(...args)
2134          );
2135          oldValue = newValue;
2136        } finally {
2137          activeWatcher = currentWatcher;
2138        }
2139      }
2140    } else {
2141      effect2.run();
2142    }
2143  };
2144  if (augmentJob) {
2145    augmentJob(job);
2146  }
2147  effect2 = new ReactiveEffect(getter);
2148  effect2.scheduler = scheduler ? () => scheduler(job, false) : job;
2149  boundCleanup = (fn) => onWatcherCleanup(fn, false, effect2);
2150  cleanup = effect2.onStop = () => {
2151    const cleanups = cleanupMap.get(effect2);
2152    if (cleanups) {
2153      if (call) {
2154        call(cleanups, 4);
2155      } else {
2156        for (const cleanup2 of cleanups) cleanup2();
2157      }
2158      cleanupMap.delete(effect2);
2159    }
2160  };
2161  if (cb) {
2162    if (immediate) {
2163      job(true);
2164    } else {
2165      oldValue = effect2.run();
2166    }
2167  } else if (scheduler) {
2168    scheduler(job.bind(null, true), true);
2169  } else {
2170    effect2.run();
2171  }
2172  watchHandle.pause = effect2.pause.bind(effect2);
2173  watchHandle.resume = effect2.resume.bind(effect2);
2174  watchHandle.stop = watchHandle;
2175  return watchHandle;
2176}
2177function traverse(value, depth = Infinity, seen2) {
2178  if (depth <= 0 || !isObject$4(value) || value["__v_skip"]) {
2179    return value;
2180  }
2181  seen2 = seen2 || /* @__PURE__ */ new Set();
2182  if (seen2.has(value)) {
2183    return value;
2184  }
2185  seen2.add(value);
2186  depth--;
2187  if (isRef(value)) {
2188    traverse(value.value, depth, seen2);
2189  } else if (isArray$4(value)) {
2190    for (let i = 0; i < value.length; i++) {
2191      traverse(value[i], depth, seen2);
2192    }
2193  } else if (isSet$1(value) || isMap$1(value)) {
2194    value.forEach((v2) => {
2195      traverse(v2, depth, seen2);
2196    });
2197  } else if (isPlainObject$4(value)) {
2198    for (const key in value) {
2199      traverse(value[key], depth, seen2);
2200    }
2201    for (const key of Object.getOwnPropertySymbols(value)) {
2202      if (Object.prototype.propertyIsEnumerable.call(value, key)) {
2203        traverse(value[key], depth, seen2);
2204      }
2205    }
2206  }
2207  return value;
2208}
2209/**
2210* @vue/runtime-core v3.5.13
2211* (c) 2018-present Yuxi (Evan) You and Vue contributors
2212* @license MIT

2213**/
2214const stack = [];
2215function pushWarningContext(vnode) {
2216  stack.push(vnode);
2217}
2218function popWarningContext() {
2219  stack.pop();
2220}
2221let isWarning = false;
2222function warn$1(msg, ...args) {
2223  if (isWarning) return;
2224  isWarning = true;
2225  pauseTracking();
2226  const instance = stack.length ? stack[stack.length - 1].component : null;
2227  const appWarnHandler = instance && instance.appContext.config.warnHandler;
2228  const trace = getComponentTrace();
2229  if (appWarnHandler) {
2230    callWithErrorHandling(
2231      appWarnHandler,
2232      instance,
2233      11,
2234      [
2235        // eslint-disable-next-line no-restricted-syntax
2236        msg + args.map((a) => {
2237          var _a, _b;
2238          return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
2239        }).join(""),
2240        instance && instance.proxy,
2241        trace.map(
2242          ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
2243        ).join("\n"),
2244        trace
2245      ]
2246    );
2247  } else {
2248    const warnArgs = [`[Vue warn]: ${msg}`, ...args];
2249    if (trace.length && // avoid spamming console during tests
2250    true) {
2251      warnArgs.push(`
2252`, ...formatTrace(trace));
2253    }
2254    console.warn(...warnArgs);
2255  }
2256  resetTracking();
2257  isWarning = false;
2258}
2259function getComponentTrace() {
2260  let currentVNode = stack[stack.length - 1];
2261  if (!currentVNode) {
2262    return [];
2263  }
2264  const normalizedStack = [];
2265  while (currentVNode) {
2266    const last = normalizedStack[0];
2267    if (last && last.vnode === currentVNode) {
2268      last.recurseCount++;
2269    } else {
2270      normalizedStack.push({
2271        vnode: currentVNode,
2272        recurseCount: 0
2273      });
2274    }
2275    const parentInstance = currentVNode.component && currentVNode.component.parent;
2276    currentVNode = parentInstance && parentInstance.vnode;
2277  }
2278  return normalizedStack;
2279}
2280function formatTrace(trace) {
2281  const logs = [];
2282  trace.forEach((entry, i) => {
2283    logs.push(...i === 0 ? [] : [`
2284`], ...formatTraceEntry(entry));
2285  });
2286  return logs;
2287}
2288function formatTraceEntry({ vnode, recurseCount }) {
2289  const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
2290  const isRoot = vnode.component ? vnode.component.parent == null : false;
2291  const open2 = ` at <${formatComponentName(
2292    vnode.component,
2293    vnode.type,
2294    isRoot
2295  )}`;
2296  const close = `>` + postfix;
2297  return vnode.props ? [open2, ...formatProps(vnode.props), close] : [open2 + close];
2298}
2299function formatProps(props) {
2300  const res = [];
2301  const keys2 = Object.keys(props);
2302  keys2.slice(0, 3).forEach((key) => {
2303    res.push(...formatProp(key, props[key]));
2304  });
2305  if (keys2.length > 3) {
2306    res.push(` ...`);
2307  }
2308  return res;
2309}
2310function formatProp(key, value, raw) {
2311  if (isString$1(value)) {
2312    value = JSON.stringify(value);
2313    return raw ? value : [`${key}=${value}`];
2314  } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
2315    return raw ? value : [`${key}=${value}`];
2316  } else if (isRef(value)) {
2317    value = formatProp(key, toRaw(value.value), true);
2318    return raw ? value : [`${key}=Ref<`, value, `>`];
2319  } else if (isFunction$4(value)) {
2320    return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
2321  } else {
2322    value = toRaw(value);
2323    return raw ? value : [`${key}=`, value];
2324  }
2325}
2326function assertNumber(val, type) {
2327  return;
2328}
2329const ErrorCodes = {
2330  "SETUP_FUNCTION": 0,
2331  "0": "SETUP_FUNCTION",
2332  "RENDER_FUNCTION": 1,
2333  "1": "RENDER_FUNCTION",
2334  "NATIVE_EVENT_HANDLER": 5,
2335  "5": "NATIVE_EVENT_HANDLER",
2336  "COMPONENT_EVENT_HANDLER": 6,
2337  "6": "COMPONENT_EVENT_HANDLER",
2338  "VNODE_HOOK": 7,
2339  "7": "VNODE_HOOK",
2340  "DIRECTIVE_HOOK": 8,
2341  "8": "DIRECTIVE_HOOK",
2342  "TRANSITION_HOOK": 9,
2343  "9": "TRANSITION_HOOK",
2344  "APP_ERROR_HANDLER": 10,
2345  "10": "APP_ERROR_HANDLER",
2346  "APP_WARN_HANDLER": 11,
2347  "11": "APP_WARN_HANDLER",
2348  "FUNCTION_REF": 12,
2349  "12": "FUNCTION_REF",
2350  "ASYNC_COMPONENT_LOADER": 13,
2351  "13": "ASYNC_COMPONENT_LOADER",
2352  "SCHEDULER": 14,
2353  "14": "SCHEDULER",
2354  "COMPONENT_UPDATE": 15,
2355  "15": "COMPONENT_UPDATE",
2356  "APP_UNMOUNT_CLEANUP": 16,
2357  "16": "APP_UNMOUNT_CLEANUP"
2358};
2359const ErrorTypeStrings$1 = {
2360  ["sp"]: "serverPrefetch hook",
2361  ["bc"]: "beforeCreate hook",
2362  ["c"]: "created hook",
2363  ["bm"]: "beforeMount hook",
2364  ["m"]: "mounted hook",
2365  ["bu"]: "beforeUpdate hook",
2366  ["u"]: "updated",
2367  ["bum"]: "beforeUnmount hook",
2368  ["um"]: "unmounted hook",
2369  ["a"]: "activated hook",
2370  ["da"]: "deactivated hook",
2371  ["ec"]: "errorCaptured hook",
2372  ["rtc"]: "renderTracked hook",
2373  ["rtg"]: "renderTriggered hook",
2374  [0]: "setup function",
2375  [1]: "render function",
2376  [2]: "watcher getter",

2377  [3]: "watcher callback",
2378  [4]: "watcher cleanup function",
2379  [5]: "native event handler",
2380  [6]: "component event handler",
2381  [7]: "vnode hook",
2382  [8]: "directive hook",
2383  [9]: "transition hook",
2384  [10]: "app errorHandler",
2385  [11]: "app warnHandler",
2386  [12]: "ref function",
2387  [13]: "async component loader",
2388  [14]: "scheduler flush",
2389  [15]: "component update",
2390  [16]: "app unmount cleanup function"
2391};
2392function callWithErrorHandling(fn, instance, type, args) {
2393  try {
2394    return args ? fn(...args) : fn();
2395  } catch (err) {
2396    handleError(err, instance, type);
2397  }
2398}
2399function callWithAsyncErrorHandling(fn, instance, type, args) {
2400  if (isFunction$4(fn)) {
2401    const res = callWithErrorHandling(fn, instance, type, args);
2402    if (res && isPromise$1(res)) {
2403      res.catch((err) => {
2404        handleError(err, instance, type);
2405      });
2406    }
2407    return res;
2408  }
2409  if (isArray$4(fn)) {
2410    const values = [];
2411    for (let i = 0; i < fn.length; i++) {
2412      values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
2413    }
2414    return values;
2415  }
2416}
2417function handleError(err, instance, type, throwInDev = true) {
2418  const contextVNode = instance ? instance.vnode : null;
2419  const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
2420  if (instance) {
2421    let cur = instance.parent;
2422    const exposedInstance = instance.proxy;
2423    const errorInfo = `https://vuejs.org/error-reference/#runtime-${type}`;
2424    while (cur) {