@swap-coffee/ui-sdk
Version:
User Interface SDK of swap.coffee DEX aggregator for integration in web applications
1,453 lines • 4.64 MB
JavaScript
var tr = Object.defineProperty;
var rr = (r, f, d) => f in r ? tr(r, f, { enumerable: !0, configurable: !0, writable: !0, value: d }) : r[f] = d;
var zt = (r, f, d) => rr(r, typeof f != "symbol" ? f + "" : f, d);
function getDefaultExportFromCjs$1(r) {
return r && r.__esModule && Object.prototype.hasOwnProperty.call(r, "default") ? r.default : r;
}
var browser$d = { exports: {} }, process = browser$d.exports = {}, cachedSetTimeout, cachedClearTimeout;
function defaultSetTimout() {
throw new Error("setTimeout has not been defined");
}
function defaultClearTimeout() {
throw new Error("clearTimeout has not been defined");
}
(function() {
try {
typeof setTimeout == "function" ? cachedSetTimeout = setTimeout : cachedSetTimeout = defaultSetTimout;
} catch {
cachedSetTimeout = defaultSetTimout;
}
try {
typeof clearTimeout == "function" ? cachedClearTimeout = clearTimeout : cachedClearTimeout = defaultClearTimeout;
} catch {
cachedClearTimeout = defaultClearTimeout;
}
})();
function runTimeout(r) {
if (cachedSetTimeout === setTimeout)
return setTimeout(r, 0);
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout)
return cachedSetTimeout = setTimeout, setTimeout(r, 0);
try {
return cachedSetTimeout(r, 0);
} catch {
try {
return cachedSetTimeout.call(null, r, 0);
} catch {
return cachedSetTimeout.call(this, r, 0);
}
}
}
function runClearTimeout(r) {
if (cachedClearTimeout === clearTimeout)
return clearTimeout(r);
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout)
return cachedClearTimeout = clearTimeout, clearTimeout(r);
try {
return cachedClearTimeout(r);
} catch {
try {
return cachedClearTimeout.call(null, r);
} catch {
return cachedClearTimeout.call(this, r);
}
}
}
var queue$1 = [], draining = !1, currentQueue, queueIndex = -1;
function cleanUpNextTick() {
!draining || !currentQueue || (draining = !1, currentQueue.length ? queue$1 = currentQueue.concat(queue$1) : queueIndex = -1, queue$1.length && drainQueue());
}
function drainQueue() {
if (!draining) {
var r = runTimeout(cleanUpNextTick);
draining = !0;
for (var f = queue$1.length; f; ) {
for (currentQueue = queue$1, queue$1 = []; ++queueIndex < f; )
currentQueue && currentQueue[queueIndex].run();
queueIndex = -1, f = queue$1.length;
}
currentQueue = null, draining = !1, runClearTimeout(r);
}
}
process.nextTick = function(r) {
var f = new Array(arguments.length - 1);
if (arguments.length > 1)
for (var d = 1; d < arguments.length; d++)
f[d - 1] = arguments[d];
queue$1.push(new Item(r, f)), queue$1.length === 1 && !draining && runTimeout(drainQueue);
};
function Item(r, f) {
this.fun = r, this.array = f;
}
Item.prototype.run = function() {
this.fun.apply(null, this.array);
};
process.title = "browser";
process.browser = !0;
process.env = {};
process.argv = [];
process.version = "";
process.versions = {};
function noop$2() {
}
process.on = noop$2;
process.addListener = noop$2;
process.once = noop$2;
process.off = noop$2;
process.removeListener = noop$2;
process.removeAllListeners = noop$2;
process.emit = noop$2;
process.prependListener = noop$2;
process.prependOnceListener = noop$2;
process.listeners = function(r) {
return [];
};
process.binding = function(r) {
throw new Error("process.binding is not supported");
};
process.cwd = function() {
return "/";
};
process.chdir = function(r) {
throw new Error("process.chdir is not supported");
};
process.umask = function() {
return 0;
};
var browserExports = browser$d.exports;
const process$1 = /* @__PURE__ */ getDefaultExportFromCjs$1(browserExports), global$1 = globalThis || void 0 || self;
/**
* @vue/shared v3.5.13
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function makeMap(r) {
const f = /* @__PURE__ */ Object.create(null);
for (const d of r.split(",")) f[d] = 1;
return (d) => d in f;
}
const EMPTY_OBJ = process$1.env.NODE_ENV !== "production" ? Object.freeze({}) : {}, EMPTY_ARR = process$1.env.NODE_ENV !== "production" ? Object.freeze([]) : [], NOOP = () => {
}, NO = () => !1, isOn = (r) => r.charCodeAt(0) === 111 && r.charCodeAt(1) === 110 && // uppercase letter
(r.charCodeAt(2) > 122 || r.charCodeAt(2) < 97), isModelListener = (r) => r.startsWith("onUpdate:"), extend$1 = Object.assign, remove = (r, f) => {
const d = r.indexOf(f);
d > -1 && r.splice(d, 1);
}, hasOwnProperty$3 = Object.prototype.hasOwnProperty, hasOwn$1 = (r, f) => hasOwnProperty$3.call(r, f), isArray$3 = Array.isArray, isMap$1 = (r) => toTypeString$1(r) === "[object Map]", isSet$1 = (r) => toTypeString$1(r) === "[object Set]", isFunction$2 = (r) => typeof r == "function", isString$4 = (r) => typeof r == "string", isSymbol$1 = (r) => typeof r == "symbol", isObject$3 = (r) => r !== null && typeof r == "object", isPromise$1 = (r) => (isObject$3(r) || isFunction$2(r)) && isFunction$2(r.then) && isFunction$2(r.catch), objectToString$1 = Object.prototype.toString, toTypeString$1 = (r) => objectToString$1.call(r), toRawType = (r) => toTypeString$1(r).slice(8, -1), isPlainObject$3 = (r) => toTypeString$1(r) === "[object Object]", isIntegerKey = (r) => isString$4(r) && r !== "NaN" && r[0] !== "-" && "" + parseInt(r, 10) === r, isReservedProp = /* @__PURE__ */ makeMap(
// the leading comma is intentional so empty string "" is also included
",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
), isBuiltInDirective = /* @__PURE__ */ makeMap(
"bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
), cacheStringFunction = (r) => {
const f = /* @__PURE__ */ Object.create(null);
return (d) => f[d] || (f[d] = r(d));
}, camelizeRE = /-(\w)/g, camelize = cacheStringFunction(
(r) => r.replace(camelizeRE, (f, d) => d ? d.toUpperCase() : "")
), hyphenateRE = /\B([A-Z])/g, hyphenate = cacheStringFunction(
(r) => r.replace(hyphenateRE, "-$1").toLowerCase()
), capitalize$1 = cacheStringFunction((r) => r.charAt(0).toUpperCase() + r.slice(1)), toHandlerKey = cacheStringFunction(
(r) => r ? `on${capitalize$1(r)}` : ""
), hasChanged = (r, f) => !Object.is(r, f), invokeArrayFns = (r, ...f) => {
for (let d = 0; d < r.length; d++)
r[d](...f);
}, def = (r, f, d, m = !1) => {
Object.defineProperty(r, f, {
configurable: !0,
enumerable: !1,
writable: m,
value: d
});
}, looseToNumber = (r) => {
const f = parseFloat(r);
return isNaN(f) ? r : f;
}, toNumber = (r) => {
const f = isString$4(r) ? Number(r) : NaN;
return isNaN(f) ? r : f;
};
let _globalThis$1;
const getGlobalThis$1 = () => _globalThis$1 || (_globalThis$1 = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : typeof global$1 < "u" ? global$1 : {});
function normalizeStyle(r) {
if (isArray$3(r)) {
const f = {};
for (let d = 0; d < r.length; d++) {
const m = r[d], y = isString$4(m) ? parseStringStyle(m) : normalizeStyle(m);
if (y)
for (const g in y)
f[g] = y[g];
}
return f;
} else if (isString$4(r) || isObject$3(r))
return r;
}
const listDelimiterRE = /;(?![^(]*\))/g, propertyDelimiterRE = /:([^]+)/, styleCommentRE = /\/\*[^]*?\*\//g;
function parseStringStyle(r) {
const f = {};
return r.replace(styleCommentRE, "").split(listDelimiterRE).forEach((d) => {
if (d) {
const m = d.split(propertyDelimiterRE);
m.length > 1 && (f[m[0].trim()] = m[1].trim());
}
}), f;
}
function normalizeClass(r) {
let f = "";
if (isString$4(r))
f = r;
else if (isArray$3(r))
for (let d = 0; d < r.length; d++) {
const m = normalizeClass(r[d]);
m && (f += m + " ");
}
else if (isObject$3(r))
for (const d in r)
r[d] && (f += d + " ");
return f.trim();
}
const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot", 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", 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", isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS), isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS), isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS), specialBooleanAttrs = "itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly", isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
function includeBooleanAttr(r) {
return !!r || r === "";
}
const isRef$2 = (r) => !!(r && r.__v_isRef === !0), toDisplayString$1 = (r) => isString$4(r) ? r : r == null ? "" : isArray$3(r) || isObject$3(r) && (r.toString === objectToString$1 || !isFunction$2(r.toString)) ? isRef$2(r) ? toDisplayString$1(r.value) : JSON.stringify(r, replacer, 2) : String(r), replacer = (r, f) => isRef$2(f) ? replacer(r, f.value) : isMap$1(f) ? {
[`Map(${f.size})`]: [...f.entries()].reduce(
(d, [m, y], g) => (d[stringifySymbol(m, g) + " =>"] = y, d),
{}
)
} : isSet$1(f) ? {
[`Set(${f.size})`]: [...f.values()].map((d) => stringifySymbol(d))
} : isSymbol$1(f) ? stringifySymbol(f) : isObject$3(f) && !isArray$3(f) && !isPlainObject$3(f) ? String(f) : f, stringifySymbol = (r, f = "") => {
var d;
return (
// Symbol.description in es2019+ so we need to cast here to pass
// the lib: es2016 check
isSymbol$1(r) ? `Symbol(${(d = r.description) != null ? d : f})` : r
);
};
function warn$3(r, ...f) {
console.warn(`[Vue warn] ${r}`, ...f);
}
let activeEffectScope;
class EffectScope {
constructor(f = !1) {
this.detached = f, this._active = !0, this.effects = [], this.cleanups = [], this._isPaused = !1, this.parent = activeEffectScope, !f && activeEffectScope && (this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
this
) - 1);
}
get active() {
return this._active;
}
pause() {
if (this._active) {
this._isPaused = !0;
let f, d;
if (this.scopes)
for (f = 0, d = this.scopes.length; f < d; f++)
this.scopes[f].pause();
for (f = 0, d = this.effects.length; f < d; f++)
this.effects[f].pause();
}
}
/**
* Resumes the effect scope, including all child scopes and effects.
*/
resume() {
if (this._active && this._isPaused) {
this._isPaused = !1;
let f, d;
if (this.scopes)
for (f = 0, d = this.scopes.length; f < d; f++)
this.scopes[f].resume();
for (f = 0, d = this.effects.length; f < d; f++)
this.effects[f].resume();
}
}
run(f) {
if (this._active) {
const d = activeEffectScope;
try {
return activeEffectScope = this, f();
} finally {
activeEffectScope = d;
}
} else process$1.env.NODE_ENV !== "production" && warn$3("cannot run an inactive effect scope.");
}
/**
* This should only be called on non-detached scopes
* @internal
*/
on() {
activeEffectScope = this;
}
/**
* This should only be called on non-detached scopes
* @internal
*/
off() {
activeEffectScope = this.parent;
}
stop(f) {
if (this._active) {
this._active = !1;
let d, m;
for (d = 0, m = this.effects.length; d < m; d++)
this.effects[d].stop();
for (this.effects.length = 0, d = 0, m = this.cleanups.length; d < m; d++)
this.cleanups[d]();
if (this.cleanups.length = 0, this.scopes) {
for (d = 0, m = this.scopes.length; d < m; d++)
this.scopes[d].stop(!0);
this.scopes.length = 0;
}
if (!this.detached && this.parent && !f) {
const y = this.parent.scopes.pop();
y && y !== this && (this.parent.scopes[this.index] = y, y.index = this.index);
}
this.parent = void 0;
}
}
}
function effectScope(r) {
return new EffectScope(r);
}
function getCurrentScope() {
return activeEffectScope;
}
function onScopeDispose(r, f = !1) {
activeEffectScope ? activeEffectScope.cleanups.push(r) : process$1.env.NODE_ENV !== "production" && !f && warn$3(
"onScopeDispose() is called when there is no active effect scope to be associated with."
);
}
let activeSub;
const pausedQueueEffects = /* @__PURE__ */ new WeakSet();
class ReactiveEffect {
constructor(f) {
this.fn = f, this.deps = void 0, this.depsTail = void 0, this.flags = 5, this.next = void 0, this.cleanup = void 0, this.scheduler = void 0, activeEffectScope && activeEffectScope.active && activeEffectScope.effects.push(this);
}
pause() {
this.flags |= 64;
}
resume() {
this.flags & 64 && (this.flags &= -65, pausedQueueEffects.has(this) && (pausedQueueEffects.delete(this), this.trigger()));
}
/**
* @internal
*/
notify() {
this.flags & 2 && !(this.flags & 32) || this.flags & 8 || batch$1(this);
}
run() {
if (!(this.flags & 1))
return this.fn();
this.flags |= 2, cleanupEffect(this), prepareDeps(this);
const f = activeSub, d = shouldTrack;
activeSub = this, shouldTrack = !0;
try {
return this.fn();
} finally {
process$1.env.NODE_ENV !== "production" && activeSub !== this && warn$3(
"Active effect was not restored correctly - this is likely a Vue internal bug."
), cleanupDeps(this), activeSub = f, shouldTrack = d, this.flags &= -3;
}
}
stop() {
if (this.flags & 1) {
for (let f = this.deps; f; f = f.nextDep)
removeSub(f);
this.deps = this.depsTail = void 0, cleanupEffect(this), this.onStop && this.onStop(), this.flags &= -2;
}
}
trigger() {
this.flags & 64 ? pausedQueueEffects.add(this) : this.scheduler ? this.scheduler() : this.runIfDirty();
}
/**
* @internal
*/
runIfDirty() {
isDirty(this) && this.run();
}
get dirty() {
return isDirty(this);
}
}
let batchDepth = 0, batchedSub, batchedComputed;
function batch$1(r, f = !1) {
if (r.flags |= 8, f) {
r.next = batchedComputed, batchedComputed = r;
return;
}
r.next = batchedSub, batchedSub = r;
}
function startBatch() {
batchDepth++;
}
function endBatch() {
if (--batchDepth > 0)
return;
if (batchedComputed) {
let f = batchedComputed;
for (batchedComputed = void 0; f; ) {
const d = f.next;
f.next = void 0, f.flags &= -9, f = d;
}
}
let r;
for (; batchedSub; ) {
let f = batchedSub;
for (batchedSub = void 0; f; ) {
const d = f.next;
if (f.next = void 0, f.flags &= -9, f.flags & 1)
try {
f.trigger();
} catch (m) {
r || (r = m);
}
f = d;
}
}
if (r) throw r;
}
function prepareDeps(r) {
for (let f = r.deps; f; f = f.nextDep)
f.version = -1, f.prevActiveLink = f.dep.activeLink, f.dep.activeLink = f;
}
function cleanupDeps(r) {
let f, d = r.depsTail, m = d;
for (; m; ) {
const y = m.prevDep;
m.version === -1 ? (m === d && (d = y), removeSub(m), removeDep(m)) : f = m, m.dep.activeLink = m.prevActiveLink, m.prevActiveLink = void 0, m = y;
}
r.deps = f, r.depsTail = d;
}
function isDirty(r) {
for (let f = r.deps; f; f = f.nextDep)
if (f.dep.version !== f.version || f.dep.computed && (refreshComputed(f.dep.computed) || f.dep.version !== f.version))
return !0;
return !!r._dirty;
}
function refreshComputed(r) {
if (r.flags & 4 && !(r.flags & 16) || (r.flags &= -17, r.globalVersion === globalVersion))
return;
r.globalVersion = globalVersion;
const f = r.dep;
if (r.flags |= 2, f.version > 0 && !r.isSSR && r.deps && !isDirty(r)) {
r.flags &= -3;
return;
}
const d = activeSub, m = shouldTrack;
activeSub = r, shouldTrack = !0;
try {
prepareDeps(r);
const y = r.fn(r._value);
(f.version === 0 || hasChanged(y, r._value)) && (r._value = y, f.version++);
} catch (y) {
throw f.version++, y;
} finally {
activeSub = d, shouldTrack = m, cleanupDeps(r), r.flags &= -3;
}
}
function removeSub(r, f = !1) {
const { dep: d, prevSub: m, nextSub: y } = r;
if (m && (m.nextSub = y, r.prevSub = void 0), y && (y.prevSub = m, r.nextSub = void 0), process$1.env.NODE_ENV !== "production" && d.subsHead === r && (d.subsHead = y), d.subs === r && (d.subs = m, !m && d.computed)) {
d.computed.flags &= -5;
for (let g = d.computed.deps; g; g = g.nextDep)
removeSub(g, !0);
}
!f && !--d.sc && d.map && d.map.delete(d.key);
}
function removeDep(r) {
const { prevDep: f, nextDep: d } = r;
f && (f.nextDep = d, r.prevDep = void 0), d && (d.prevDep = f, r.nextDep = void 0);
}
let shouldTrack = !0;
const trackStack = [];
function pauseTracking() {
trackStack.push(shouldTrack), shouldTrack = !1;
}
function resetTracking() {
const r = trackStack.pop();
shouldTrack = r === void 0 ? !0 : r;
}
function cleanupEffect(r) {
const { cleanup: f } = r;
if (r.cleanup = void 0, f) {
const d = activeSub;
activeSub = void 0;
try {
f();
} finally {
activeSub = d;
}
}
}
let globalVersion = 0, Link$1 = class {
constructor(f, d) {
this.sub = f, this.dep = d, this.version = d.version, this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
}
};
class Dep {
constructor(f) {
this.computed = f, this.version = 0, this.activeLink = void 0, this.subs = void 0, this.map = void 0, this.key = void 0, this.sc = 0, process$1.env.NODE_ENV !== "production" && (this.subsHead = void 0);
}
track(f) {
if (!activeSub || !shouldTrack || activeSub === this.computed)
return;
let d = this.activeLink;
if (d === void 0 || d.sub !== activeSub)
d = this.activeLink = new Link$1(activeSub, this), activeSub.deps ? (d.prevDep = activeSub.depsTail, activeSub.depsTail.nextDep = d, activeSub.depsTail = d) : activeSub.deps = activeSub.depsTail = d, addSub(d);
else if (d.version === -1 && (d.version = this.version, d.nextDep)) {
const m = d.nextDep;
m.prevDep = d.prevDep, d.prevDep && (d.prevDep.nextDep = m), d.prevDep = activeSub.depsTail, d.nextDep = void 0, activeSub.depsTail.nextDep = d, activeSub.depsTail = d, activeSub.deps === d && (activeSub.deps = m);
}
return process$1.env.NODE_ENV !== "production" && activeSub.onTrack && activeSub.onTrack(
extend$1(
{
effect: activeSub
},
f
)
), d;
}
trigger(f) {
this.version++, globalVersion++, this.notify(f);
}
notify(f) {
startBatch();
try {
if (process$1.env.NODE_ENV !== "production")
for (let d = this.subsHead; d; d = d.nextSub)
d.sub.onTrigger && !(d.sub.flags & 8) && d.sub.onTrigger(
extend$1(
{
effect: d.sub
},
f
)
);
for (let d = this.subs; d; d = d.prevSub)
d.sub.notify() && d.sub.dep.notify();
} finally {
endBatch();
}
}
}
function addSub(r) {
if (r.dep.sc++, r.sub.flags & 4) {
const f = r.dep.computed;
if (f && !r.dep.subs) {
f.flags |= 20;
for (let m = f.deps; m; m = m.nextDep)
addSub(m);
}
const d = r.dep.subs;
d !== r && (r.prevSub = d, d && (d.nextSub = r)), process$1.env.NODE_ENV !== "production" && r.dep.subsHead === void 0 && (r.dep.subsHead = r), r.dep.subs = r;
}
}
const targetMap = /* @__PURE__ */ new WeakMap(), ITERATE_KEY = Symbol(
process$1.env.NODE_ENV !== "production" ? "Object iterate" : ""
), MAP_KEY_ITERATE_KEY = Symbol(
process$1.env.NODE_ENV !== "production" ? "Map keys iterate" : ""
), ARRAY_ITERATE_KEY = Symbol(
process$1.env.NODE_ENV !== "production" ? "Array iterate" : ""
);
function track(r, f, d) {
if (shouldTrack && activeSub) {
let m = targetMap.get(r);
m || targetMap.set(r, m = /* @__PURE__ */ new Map());
let y = m.get(d);
y || (m.set(d, y = new Dep()), y.map = m, y.key = d), process$1.env.NODE_ENV !== "production" ? y.track({
target: r,
type: f,
key: d
}) : y.track();
}
}
function trigger(r, f, d, m, y, g) {
const b = targetMap.get(r);
if (!b) {
globalVersion++;
return;
}
const E = (T) => {
T && (process$1.env.NODE_ENV !== "production" ? T.trigger({
target: r,
type: f,
key: d,
newValue: m,
oldValue: y,
oldTarget: g
}) : T.trigger());
};
if (startBatch(), f === "clear")
b.forEach(E);
else {
const T = isArray$3(r), I = T && isIntegerKey(d);
if (T && d === "length") {
const C = Number(m);
b.forEach((O, R) => {
(R === "length" || R === ARRAY_ITERATE_KEY || !isSymbol$1(R) && R >= C) && E(O);
});
} else
switch ((d !== void 0 || b.has(void 0)) && E(b.get(d)), I && E(b.get(ARRAY_ITERATE_KEY)), f) {
case "add":
T ? I && E(b.get("length")) : (E(b.get(ITERATE_KEY)), isMap$1(r) && E(b.get(MAP_KEY_ITERATE_KEY)));
break;
case "delete":
T || (E(b.get(ITERATE_KEY)), isMap$1(r) && E(b.get(MAP_KEY_ITERATE_KEY)));
break;
case "set":
isMap$1(r) && E(b.get(ITERATE_KEY));
break;
}
}
endBatch();
}
function getDepFromReactive(r, f) {
const d = targetMap.get(r);
return d && d.get(f);
}
function reactiveReadArray(r) {
const f = toRaw$1(r);
return f === r ? f : (track(f, "iterate", ARRAY_ITERATE_KEY), isShallow(r) ? f : f.map(toReactive));
}
function shallowReadArray(r) {
return track(r = toRaw$1(r), "iterate", ARRAY_ITERATE_KEY), r;
}
const arrayInstrumentations = {
__proto__: null,
[Symbol.iterator]() {
return iterator(this, Symbol.iterator, toReactive);
},
concat(...r) {
return reactiveReadArray(this).concat(
...r.map((f) => isArray$3(f) ? reactiveReadArray(f) : f)
);
},
entries() {
return iterator(this, "entries", (r) => (r[1] = toReactive(r[1]), r));
},
every(r, f) {
return apply$1(this, "every", r, f, void 0, arguments);
},
filter(r, f) {
return apply$1(this, "filter", r, f, (d) => d.map(toReactive), arguments);
},
find(r, f) {
return apply$1(this, "find", r, f, toReactive, arguments);
},
findIndex(r, f) {
return apply$1(this, "findIndex", r, f, void 0, arguments);
},
findLast(r, f) {
return apply$1(this, "findLast", r, f, toReactive, arguments);
},
findLastIndex(r, f) {
return apply$1(this, "findLastIndex", r, f, void 0, arguments);
},
// flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
forEach(r, f) {
return apply$1(this, "forEach", r, f, void 0, arguments);
},
includes(...r) {
return searchProxy(this, "includes", r);
},
indexOf(...r) {
return searchProxy(this, "indexOf", r);
},
join(r) {
return reactiveReadArray(this).join(r);
},
// keys() iterator only reads `length`, no optimisation required
lastIndexOf(...r) {
return searchProxy(this, "lastIndexOf", r);
},
map(r, f) {
return apply$1(this, "map", r, f, void 0, arguments);
},
pop() {
return noTracking(this, "pop");
},
push(...r) {
return noTracking(this, "push", r);
},
reduce(r, ...f) {
return reduce(this, "reduce", r, f);
},
reduceRight(r, ...f) {
return reduce(this, "reduceRight", r, f);
},
shift() {
return noTracking(this, "shift");
},
// slice could use ARRAY_ITERATE but also seems to beg for range tracking
some(r, f) {
return apply$1(this, "some", r, f, void 0, arguments);
},
splice(...r) {
return noTracking(this, "splice", r);
},
toReversed() {
return reactiveReadArray(this).toReversed();
},
toSorted(r) {
return reactiveReadArray(this).toSorted(r);
},
toSpliced(...r) {
return reactiveReadArray(this).toSpliced(...r);
},
unshift(...r) {
return noTracking(this, "unshift", r);
},
values() {
return iterator(this, "values", toReactive);
}
};
function iterator(r, f, d) {
const m = shallowReadArray(r), y = m[f]();
return m !== r && !isShallow(r) && (y._next = y.next, y.next = () => {
const g = y._next();
return g.value && (g.value = d(g.value)), g;
}), y;
}
const arrayProto = Array.prototype;
function apply$1(r, f, d, m, y, g) {
const b = shallowReadArray(r), E = b !== r && !isShallow(r), T = b[f];
if (T !== arrayProto[f]) {
const O = T.apply(r, g);
return E ? toReactive(O) : O;
}
let I = d;
b !== r && (E ? I = function(O, R) {
return d.call(this, toReactive(O), R, r);
} : d.length > 2 && (I = function(O, R) {
return d.call(this, O, R, r);
}));
const C = T.call(b, I, m);
return E && y ? y(C) : C;
}
function reduce(r, f, d, m) {
const y = shallowReadArray(r);
let g = d;
return y !== r && (isShallow(r) ? d.length > 3 && (g = function(b, E, T) {
return d.call(this, b, E, T, r);
}) : g = function(b, E, T) {
return d.call(this, b, toReactive(E), T, r);
}), y[f](g, ...m);
}
function searchProxy(r, f, d) {
const m = toRaw$1(r);
track(m, "iterate", ARRAY_ITERATE_KEY);
const y = m[f](...d);
return (y === -1 || y === !1) && isProxy(d[0]) ? (d[0] = toRaw$1(d[0]), m[f](...d)) : y;
}
function noTracking(r, f, d = []) {
pauseTracking(), startBatch();
const m = toRaw$1(r)[f].apply(r, d);
return endBatch(), resetTracking(), m;
}
const isNonTrackableKeys = /* @__PURE__ */ makeMap("__proto__,__v_isRef,__isVue"), builtInSymbols = new Set(
/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((r) => r !== "arguments" && r !== "caller").map((r) => Symbol[r]).filter(isSymbol$1)
);
function hasOwnProperty$2(r) {
isSymbol$1(r) || (r = String(r));
const f = toRaw$1(this);
return track(f, "has", r), f.hasOwnProperty(r);
}
class BaseReactiveHandler {
constructor(f = !1, d = !1) {
this._isReadonly = f, this._isShallow = d;
}
get(f, d, m) {
if (d === "__v_skip") return f.__v_skip;
const y = this._isReadonly, g = this._isShallow;
if (d === "__v_isReactive")
return !y;
if (d === "__v_isReadonly")
return y;
if (d === "__v_isShallow")
return g;
if (d === "__v_raw")
return m === (y ? g ? shallowReadonlyMap : readonlyMap : g ? shallowReactiveMap : reactiveMap).get(f) || // receiver is not the reactive proxy, but has the same prototype
// this means the receiver is a user proxy of the reactive proxy
Object.getPrototypeOf(f) === Object.getPrototypeOf(m) ? f : void 0;
const b = isArray$3(f);
if (!y) {
let T;
if (b && (T = arrayInstrumentations[d]))
return T;
if (d === "hasOwnProperty")
return hasOwnProperty$2;
}
const E = Reflect.get(
f,
d,
// if this is a proxy wrapping a ref, return methods using the raw ref
// as receiver so that we don't have to call `toRaw` on the ref in all
// its class methods
isRef$1(f) ? f : m
);
return (isSymbol$1(d) ? builtInSymbols.has(d) : isNonTrackableKeys(d)) || (y || track(f, "get", d), g) ? E : isRef$1(E) ? b && isIntegerKey(d) ? E : E.value : isObject$3(E) ? y ? readonly(E) : reactive(E) : E;
}
}
class MutableReactiveHandler extends BaseReactiveHandler {
constructor(f = !1) {
super(!1, f);
}
set(f, d, m, y) {
let g = f[d];
if (!this._isShallow) {
const T = isReadonly$1(g);
if (!isShallow(m) && !isReadonly$1(m) && (g = toRaw$1(g), m = toRaw$1(m)), !isArray$3(f) && isRef$1(g) && !isRef$1(m))
return T ? !1 : (g.value = m, !0);
}
const b = isArray$3(f) && isIntegerKey(d) ? Number(d) < f.length : hasOwn$1(f, d), E = Reflect.set(
f,
d,
m,
isRef$1(f) ? f : y
);
return f === toRaw$1(y) && (b ? hasChanged(m, g) && trigger(f, "set", d, m, g) : trigger(f, "add", d, m)), E;
}
deleteProperty(f, d) {
const m = hasOwn$1(f, d), y = f[d], g = Reflect.deleteProperty(f, d);
return g && m && trigger(f, "delete", d, void 0, y), g;
}
has(f, d) {
const m = Reflect.has(f, d);
return (!isSymbol$1(d) || !builtInSymbols.has(d)) && track(f, "has", d), m;
}
ownKeys(f) {
return track(
f,
"iterate",
isArray$3(f) ? "length" : ITERATE_KEY
), Reflect.ownKeys(f);
}
}
class ReadonlyReactiveHandler extends BaseReactiveHandler {
constructor(f = !1) {
super(!0, f);
}
set(f, d) {
return process$1.env.NODE_ENV !== "production" && warn$3(
`Set operation on key "${String(d)}" failed: target is readonly.`,
f
), !0;
}
deleteProperty(f, d) {
return process$1.env.NODE_ENV !== "production" && warn$3(
`Delete operation on key "${String(d)}" failed: target is readonly.`,
f
), !0;
}
}
const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler(), readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(), shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(!0), shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(!0), toShallow = (r) => r, getProto = (r) => Reflect.getPrototypeOf(r);
function createIterableMethod(r, f, d) {
return function(...m) {
const y = this.__v_raw, g = toRaw$1(y), b = isMap$1(g), E = r === "entries" || r === Symbol.iterator && b, T = r === "keys" && b, I = y[r](...m), C = d ? toShallow : f ? toReadonly : toReactive;
return !f && track(
g,
"iterate",
T ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
), {
// iterator protocol
next() {
const { value: O, done: R } = I.next();
return R ? { value: O, done: R } : {
value: E ? [C(O[0]), C(O[1])] : C(O),
done: R
};
},
// iterable protocol
[Symbol.iterator]() {
return this;
}
};
};
}
function createReadonlyMethod(r) {
return function(...f) {
if (process$1.env.NODE_ENV !== "production") {
const d = f[0] ? `on key "${f[0]}" ` : "";
warn$3(
`${capitalize$1(r)} operation ${d}failed: target is readonly.`,
toRaw$1(this)
);
}
return r === "delete" ? !1 : r === "clear" ? void 0 : this;
};
}
function createInstrumentations(r, f) {
const d = {
get(y) {
const g = this.__v_raw, b = toRaw$1(g), E = toRaw$1(y);
r || (hasChanged(y, E) && track(b, "get", y), track(b, "get", E));
const { has: T } = getProto(b), I = f ? toShallow : r ? toReadonly : toReactive;
if (T.call(b, y))
return I(g.get(y));
if (T.call(b, E))
return I(g.get(E));
g !== b && g.get(y);
},
get size() {
const y = this.__v_raw;
return !r && track(toRaw$1(y), "iterate", ITERATE_KEY), Reflect.get(y, "size", y);
},
has(y) {
const g = this.__v_raw, b = toRaw$1(g), E = toRaw$1(y);
return r || (hasChanged(y, E) && track(b, "has", y), track(b, "has", E)), y === E ? g.has(y) : g.has(y) || g.has(E);
},
forEach(y, g) {
const b = this, E = b.__v_raw, T = toRaw$1(E), I = f ? toShallow : r ? toReadonly : toReactive;
return !r && track(T, "iterate", ITERATE_KEY), E.forEach((C, O) => y.call(g, I(C), I(O), b));
}
};
return extend$1(
d,
r ? {
add: createReadonlyMethod("add"),
set: createReadonlyMethod("set"),
delete: createReadonlyMethod("delete"),
clear: createReadonlyMethod("clear")
} : {
add(y) {
!f && !isShallow(y) && !isReadonly$1(y) && (y = toRaw$1(y));
const g = toRaw$1(this);
return getProto(g).has.call(g, y) || (g.add(y), trigger(g, "add", y, y)), this;
},
set(y, g) {
!f && !isShallow(g) && !isReadonly$1(g) && (g = toRaw$1(g));
const b = toRaw$1(this), { has: E, get: T } = getProto(b);
let I = E.call(b, y);
I ? process$1.env.NODE_ENV !== "production" && checkIdentityKeys(b, E, y) : (y = toRaw$1(y), I = E.call(b, y));
const C = T.call(b, y);
return b.set(y, g), I ? hasChanged(g, C) && trigger(b, "set", y, g, C) : trigger(b, "add", y, g), this;
},
delete(y) {
const g = toRaw$1(this), { has: b, get: E } = getProto(g);
let T = b.call(g, y);
T ? process$1.env.NODE_ENV !== "production" && checkIdentityKeys(g, b, y) : (y = toRaw$1(y), T = b.call(g, y));
const I = E ? E.call(g, y) : void 0, C = g.delete(y);
return T && trigger(g, "delete", y, void 0, I), C;
},
clear() {
const y = toRaw$1(this), g = y.size !== 0, b = process$1.env.NODE_ENV !== "production" ? isMap$1(y) ? new Map(y) : new Set(y) : void 0, E = y.clear();
return g && trigger(
y,
"clear",
void 0,
void 0,
b
), E;
}
}
), [
"keys",
"values",
"entries",
Symbol.iterator
].forEach((y) => {
d[y] = createIterableMethod(y, r, f);
}), d;
}
function createInstrumentationGetter(r, f) {
const d = createInstrumentations(r, f);
return (m, y, g) => y === "__v_isReactive" ? !r : y === "__v_isReadonly" ? r : y === "__v_raw" ? m : Reflect.get(
hasOwn$1(d, y) && y in m ? d : m,
y,
g
);
}
const mutableCollectionHandlers = {
get: /* @__PURE__ */ createInstrumentationGetter(!1, !1)
}, shallowCollectionHandlers = {
get: /* @__PURE__ */ createInstrumentationGetter(!1, !0)
}, readonlyCollectionHandlers = {
get: /* @__PURE__ */ createInstrumentationGetter(!0, !1)
}, shallowReadonlyCollectionHandlers = {
get: /* @__PURE__ */ createInstrumentationGetter(!0, !0)
};
function checkIdentityKeys(r, f, d) {
const m = toRaw$1(d);
if (m !== d && f.call(r, m)) {
const y = toRawType(r);
warn$3(
`Reactive ${y} contains both the raw and reactive versions of the same object${y === "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.`
);
}
}
const reactiveMap = /* @__PURE__ */ new WeakMap(), shallowReactiveMap = /* @__PURE__ */ new WeakMap(), readonlyMap = /* @__PURE__ */ new WeakMap(), shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
function targetTypeMap(r) {
switch (r) {
case "Object":
case "Array":
return 1;
case "Map":
case "Set":
case "WeakMap":
case "WeakSet":
return 2;
default:
return 0;
}
}
function getTargetType(r) {
return r.__v_skip || !Object.isExtensible(r) ? 0 : targetTypeMap(toRawType(r));
}
function reactive(r) {
return isReadonly$1(r) ? r : createReactiveObject(
r,
!1,
mutableHandlers,
mutableCollectionHandlers,
reactiveMap
);
}
function shallowReactive(r) {
return createReactiveObject(
r,
!1,
shallowReactiveHandlers,
shallowCollectionHandlers,
shallowReactiveMap
);
}
function readonly(r) {
return createReactiveObject(
r,
!0,
readonlyHandlers,
readonlyCollectionHandlers,
readonlyMap
);
}
function shallowReadonly(r) {
return createReactiveObject(
r,
!0,
shallowReadonlyHandlers,
shallowReadonlyCollectionHandlers,
shallowReadonlyMap
);
}
function createReactiveObject(r, f, d, m, y) {
if (!isObject$3(r))
return process$1.env.NODE_ENV !== "production" && warn$3(
`value cannot be made ${f ? "readonly" : "reactive"}: ${String(
r
)}`
), r;
if (r.__v_raw && !(f && r.__v_isReactive))
return r;
const g = y.get(r);
if (g)
return g;
const b = getTargetType(r);
if (b === 0)
return r;
const E = new Proxy(
r,
b === 2 ? m : d
);
return y.set(r, E), E;
}
function isReactive$1(r) {
return isReadonly$1(r) ? isReactive$1(r.__v_raw) : !!(r && r.__v_isReactive);
}
function isReadonly$1(r) {
return !!(r && r.__v_isReadonly);
}
function isShallow(r) {
return !!(r && r.__v_isShallow);
}
function isProxy(r) {
return r ? !!r.__v_raw : !1;
}
function toRaw$1(r) {
const f = r && r.__v_raw;
return f ? toRaw$1(f) : r;
}
function markRaw(r) {
return !hasOwn$1(r, "__v_skip") && Object.isExtensible(r) && def(r, "__v_skip", !0), r;
}
const toReactive = (r) => isObject$3(r) ? reactive(r) : r, toReadonly = (r) => isObject$3(r) ? readonly(r) : r;
function isRef$1(r) {
return r ? r.__v_isRef === !0 : !1;
}
function ref$1(r) {
return createRef(r, !1);
}
function shallowRef(r) {
return createRef(r, !0);
}
function createRef(r, f) {
return isRef$1(r) ? r : new RefImpl(r, f);
}
class RefImpl {
constructor(f, d) {
this.dep = new Dep(), this.__v_isRef = !0, this.__v_isShallow = !1, this._rawValue = d ? f : toRaw$1(f), this._value = d ? f : toReactive(f), this.__v_isShallow = d;
}
get value() {
return process$1.env.NODE_ENV !== "production" ? this.dep.track({
target: this,
type: "get",
key: "value"
}) : this.dep.track(), this._value;
}
set value(f) {
const d = this._rawValue, m = this.__v_isShallow || isShallow(f) || isReadonly$1(f);
f = m ? f : toRaw$1(f), hasChanged(f, d) && (this._rawValue = f, this._value = m ? f : toReactive(f), process$1.env.NODE_ENV !== "production" ? this.dep.trigger({
target: this,
type: "set",
key: "value",
newValue: f,
oldValue: d
}) : this.dep.trigger());
}
}
function unref(r) {
return isRef$1(r) ? r.value : r;
}
const shallowUnwrapHandlers = {
get: (r, f, d) => f === "__v_raw" ? r : unref(Reflect.get(r, f, d)),
set: (r, f, d, m) => {
const y = r[f];
return isRef$1(y) && !isRef$1(d) ? (y.value = d, !0) : Reflect.set(r, f, d, m);
}
};
function proxyRefs(r) {
return isReactive$1(r) ? r : new Proxy(r, shallowUnwrapHandlers);
}
function toRefs(r) {
process$1.env.NODE_ENV !== "production" && !isProxy(r) && warn$3("toRefs() expects a reactive object but received a plain one.");
const f = isArray$3(r) ? new Array(r.length) : {};
for (const d in r)
f[d] = propertyToRef(r, d);
return f;
}
class ObjectRefImpl {
constructor(f, d, m) {
this._object = f, this._key = d, this._defaultValue = m, this.__v_isRef = !0, this._value = void 0;
}
get value() {
const f = this._object[this._key];
return this._value = f === void 0 ? this._defaultValue : f;
}
set value(f) {
this._object[this._key] = f;
}
get dep() {
return getDepFromReactive(toRaw$1(this._object), this._key);
}
}
class GetterRefImpl {
constructor(f) {
this._getter = f, this.__v_isRef = !0, this.__v_isReadonly = !0, this._value = void 0;
}
get value() {
return this._value = this._getter();
}
}
function toRef(r, f, d) {
return isRef$1(r) ? r : isFunction$2(r) ? new GetterRefImpl(r) : isObject$3(r) && arguments.length > 1 ? propertyToRef(r, f, d) : ref$1(r);
}
function propertyToRef(r, f, d) {
const m = r[f];
return isRef$1(m) ? m : new ObjectRefImpl(r, f, d);
}
class ComputedRefImpl {
constructor(f, d, m) {
this.fn = f, this.setter = d, this._value = void 0, this.dep = new Dep(this), this.__v_isRef = !0, this.deps = void 0, this.depsTail = void 0, this.flags = 16, this.globalVersion = globalVersion - 1, this.next = void 0, this.effect = this, this.__v_isReadonly = !d, this.isSSR = m;
}
/**
* @internal
*/
notify() {
if (this.flags |= 16, !(this.flags & 8) && // avoid infinite self recursion
activeSub !== this)
return batch$1(this, !0), !0;
process$1.env.NODE_ENV;
}
get value() {
const f = process$1.env.NODE_ENV !== "production" ? this.dep.track({
target: this,
type: "get",
key: "value"
}) : this.dep.track();
return refreshComputed(this), f && (f.version = this.dep.version), this._value;
}
set value(f) {
this.setter ? this.setter(f) : process$1.env.NODE_ENV !== "production" && warn$3("Write operation failed: computed value is readonly");
}
}
function computed$1(r, f, d = !1) {
let m, y;
isFunction$2(r) ? m = r : (m = r.get, y = r.set);
const g = new ComputedRefImpl(m, y, d);
return process$1.env.NODE_ENV !== "production" && f && !d && (g.onTrack = f.onTrack, g.onTrigger = f.onTrigger), g;
}
const INITIAL_WATCHER_VALUE = {}, cleanupMap = /* @__PURE__ */ new WeakMap();
let activeWatcher;
function onWatcherCleanup(r, f = !1, d = activeWatcher) {
if (d) {
let m = cleanupMap.get(d);
m || cleanupMap.set(d, m = []), m.push(r);
} else process$1.env.NODE_ENV !== "production" && !f && warn$3(
"onWatcherCleanup() was called when there was no active watcher to associate with."
);
}
function watch$1(r, f, d = EMPTY_OBJ) {
const { immediate: m, deep: y, once: g, scheduler: b, augmentJob: E, call: T } = d, I = (Y) => {
(d.onWarn || warn$3)(
"Invalid watch source: ",
Y,
"A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types."
);
}, C = (Y) => y ? Y : isShallow(Y) || y === !1 || y === 0 ? traverse$1(Y, 1) : traverse$1(Y);
let O, R, D, V, F = !1, H = !1;
if (isRef$1(r) ? (R = () => r.value, F = isShallow(r)) : isReactive$1(r) ? (R = () => C(r), F = !0) : isArray$3(r) ? (H = !0, F = r.some((Y) => isReactive$1(Y) || isShallow(Y)), R = () => r.map((Y) => {
if (isRef$1(Y))
return Y.value;
if (isReactive$1(Y))
return C(Y);
if (isFunction$2(Y))
return T ? T(Y, 2) : Y();
process$1.env.NODE_ENV !== "production" && I(Y);
})) : isFunction$2(r) ? f ? R = T ? () => T(r, 2) : r : R = () => {
if (D) {
pauseTracking();
try {
D();
} finally {
resetTracking();
}
}
const Y = activeWatcher;
activeWatcher = O;
try {
return T ? T(r, 3, [V]) : r(V);
} finally {
activeWatcher = Y;
}
} : (R = NOOP, process$1.env.NODE_ENV !== "production" && I(r)), f && y) {
const Y = R, Q = y === !0 ? 1 / 0 : y;
R = () => traverse$1(Y(), Q);
}
const U = getCurrentScope(), j = () => {
O.stop(), U && U.active && remove(U.effects, O);
};
if (g && f) {
const Y = f;
f = (...Q) => {
Y(...Q), j();
};
}
let q = H ? new Array(r.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
const G = (Y) => {
if (!(!(O.flags & 1) || !O.dirty && !Y))
if (f) {
const Q = O.run();
if (y || F || (H ? Q.some((oe, fe) => hasChanged(oe, q[fe])) : hasChanged(Q, q))) {
D && D();
const oe = activeWatcher;
activeWatcher = O;
try {
const fe = [
Q,
// pass undefined as the old value when it's changed for the first time
q === INITIAL_WATCHER_VALUE ? void 0 : H && q[0] === INITIAL_WATCHER_VALUE ? [] : q,
V
];
T ? T(f, 3, fe) : (
// @ts-expect-error
f(...fe)
), q = Q;
} finally {
activeWatcher = oe;
}
}
} else
O.run();
};
return E && E(G), O = new ReactiveEffect(R), O.scheduler = b ? () => b(G, !1) : G, V = (Y) => onWatcherCleanup(Y, !1, O), D = O.onStop = () => {
const Y = cleanupMap.get(O);
if (Y) {
if (T)
T(Y, 4);
else
for (const Q of Y) Q();
cleanupMap.delete(O);
}
}, process$1.env.NODE_ENV !== "production" && (O.onTrack = d.onTrack, O.onTrigger = d.onTrigger), f ? m ? G(!0) : q = O.run() : b ? b(G.bind(null, !0), !0) : O.run(), j.pause = O.pause.bind(O), j.resume = O.resume.bind(O), j.stop = j, j;
}
function traverse$1(r, f = 1 / 0, d) {
if (f <= 0 || !isObject$3(r) || r.__v_skip || (d = d || /* @__PURE__ */ new Set(), d.has(r)))
return r;
if (d.add(r), f--, isRef$1(r))
traverse$1(r.value, f, d);
else if (isArray$3(r))
for (let m = 0; m < r.length; m++)
traverse$1(r[m], f, d);
else if (isSet$1(r) || isMap$1(r))
r.forEach((m) => {
traverse$1(m, f, d);
});
else if (isPlainObject$3(r)) {
for (const m in r)
traverse$1(r[m], f, d);
for (const m of Object.getOwnPropertySymbols(r))
Object.prototype.propertyIsEnumerable.call(r, m) && traverse$1(r[m], f, d);
}
return r;
}
const stack = [];
function pushWarningContext(r) {
stack.push(r);
}
function popWarningContext() {
stack.pop();
}
let isWarning = !1;
function warn$1(r, ...f) {
if (isWarning) return;
isWarning = !0, pauseTracking();
const d = stack.length ? stack[stack.length - 1].component : null, m = d && d.appContext.config.warnHandler, y = getComponentTrace();
if (m)
callWithErrorHandling(
m,
d,
11,
[
// eslint-disable-next-line no-restricted-syntax
r + f.map((g) => {
var b, E;
return (E = (b = g.toString) == null ? void 0 : b.call(g)) != null ? E : JSON.stringify(g);
}).join(""),
d && d.proxy,
y.map(
({ vnode: g }) => `at <${formatComponentName(d, g.type)}>`
).join(`
`),
y
]
);
else {
const g = [`[Vue warn]: ${r}`, ...f];
y.length && g.push(`
`, ...formatTrace(y)), console.warn(...g);
}
resetTracking(), isWarning = !1;
}
function getComponentTrace() {
let r = stack[stack.length - 1];
if (!r)
return [];
const f = [];
for (; r; ) {
const d = f[0];
d && d.vnode === r ? d.recurseCount++ : f.push({
vnode: r,
recurseCount: 0
});
const m = r.component && r.component.parent;
r = m && m.vnode;
}
return f;
}
function formatTrace(r) {
const f = [];
return r.forEach((d, m) => {
f.push(...m === 0 ? [] : [`
`], ...formatTraceEntry(d));
}), f;
}
function formatTraceEntry({ vnode: r, recurseCount: f }) {
const d = f > 0 ? `... (${f} recursive calls)` : "", m = r.component ? r.component.parent == null : !1, y = ` at <${formatComponentName(
r.component,
r.type,
m
)}`, g = ">" + d;
return r.props ? [y, ...formatProps(r.props), g] : [y + g];
}
function formatProps(r) {
const f = [], d = Object.keys(r);
return d.slice(0, 3).forEach((m) => {
f.push(...formatProp(m, r[m]));
}), d.length > 3 && f.push(" ..."), f;
}
function formatProp(r, f, d) {
return isString$4(f) ? (f = JSON.stringify(f), d ? f : [`${r}=${f}`]) : typeof f == "number" || typeof f == "boolean" || f == null ? d ? f : [`${r}=${f}`] : isRef$1(f) ? (f = formatProp(r, toRaw$1(f.value), !0), d ? f : [`${r}=Ref<`, f, ">"]) : isFunction$2(f) ? [`${r}=fn${f.name ? `<${f.name}>` : ""}`] : (f = toRaw$1(f), d ? f : [`${r}=`, f]);
}
function assertNumber(r, f) {
process$1.env.NODE_ENV !== "production" && r !== void 0 && (typeof r != "number" ? warn$1(`${f} is not a valid number - got ${JSON.stringify(r)}.`) : isNaN(r) && warn$1(`${f} is NaN - the duration expression might be incorrect.`));
}
const ErrorTypeStrings$1 = {
sp: "serverPrefetch hook",
bc: "beforeCreate hook",
c: "created hook",
bm: "beforeMount hook",
m: "mounted hook",
bu: "beforeUpdate hook",
u: "updated",
bum: "beforeUnmount hook",
um: "unmounted hook",
a: "activated hook",
da: "deactivated hook",
ec: "errorCaptured hook",
rtc: "renderTracked hook",
rtg: "renderTriggered hook",
0: "setup function",
1: "render function",
2: "watcher getter",
3: "watcher callback",
4: "watcher cleanup function",
5: "native event handler",
6: "component event handler",
7: "vnode hook",
8: "directive hook",
9: "transition hook",
10: "app errorHandler",
11: "app warnHandler",
12: "ref function",
13: "async component loader",
14: "scheduler flush",
15: "component update",
16: "app unmount cleanup function"
};
function callWithErrorHandling(r, f, d, m) {
try {
return m ? r(...m) : r();
} catch (y) {
handleError$1(y, f, d);
}
}
function callWithAsyncErrorHandling(r, f, d, m) {
if (isFunction$2(r)) {
const y = callWithErrorHandling(r, f, d, m);
return y && isPromise$1(y) && y.catch((g) => {
handleError$1(g, f, d);
}), y;
}
if (isArray$3(r)) {
const y = [];
for (let g = 0; g < r.length; g++)
y.push(callWithAsyncErrorHandling(r[g], f, d, m));
return y;
} else process$1.env.NODE_ENV !== "production" && warn$1(
`Invalid value type passed to callWithAsyncErrorHandling(): ${typeof r}`
);
}
function handleError$1(r, f, d, m = !0) {
const y = f ? f.vnode : null, { errorHandler: g, throwUnhandledErrorInProduction: b } = f && f.appContext.config || EMPTY_OBJ;
if (f) {
let E = f.parent;
const T = f.proxy, I = process$1.env.NODE_ENV !== "production" ? ErrorTypeStrings$1[d] : `https://vuejs.org/error-reference/#runtime-${d}`;
for (; E; ) {
const C = E.ec;
if (C) {
for (let O = 0; O < C.length; O++)
if (C[O](r, T, I) === !1)
return;
}
E = E.parent;
}
if (g) {
pauseTracking(), callWithErr