pinia-react 1.4.0 → 1.5.0-beta.2

package/dist/index.js

@@ -1,2 +1,2253 @@
-import{ReactiveEffect as e,activeEffect as t,computed as n,effectScope as r,isReactive as i,isRef as a,markRaw as o,nextTick as s,reactive as c,ref as l,toRaw as u,toRefs as d,watch as f}from"@maoism/runtime-core";import{useCallback as p,useEffect as m,useId as h,useRef as g,useSyncExternalStore as _}from"react";import"savage-types";import"savage-utils";const v=()=>y;let y;function b(e){y=e}function x(){let e=r(!0),t=e.run(()=>l({})),n=[],i=o({use(e){return n.push(e),this},_p:n,_e:e,_s:new Map,state:t});return b(i),i}const S=()=>{};function C(e,t,n,r,i=S){t.add(n);let a=()=>{t.delete(n),i()};return r||e[0].push(a),a}function w(e,...t){e.forEach(e=>{e(...t)})}let T=function(e){return e.direct=`direct`,e.patchObject=`patch object`,e.patchFunction=`patch function`,e}({});function E(){return{}}function D(e){return e&&typeof e==`object`&&Object.prototype.toString.call(e)===`[object Object]`&&typeof e.toJSON!=`function`}function O(e,t){for(let n in e instanceof Map&&t instanceof Map&&t.forEach((t,n)=>e.set(n,t)),e instanceof Set&&t instanceof Set&&t.forEach(e.add,e),t){if(!Object.hasOwn(t,n))continue;let r=t[n],o=e[n];D(o)&&D(r)&&e.hasOwnProperty(n)&&!a(r)&&!i(r)?e[n]=O(o,r):e[n]=r}return e}const k=Symbol(),A=Symbol(),{assign:j}=Object;function M(e,t,r){let{state:i,actions:a,getters:s}=t,c=r.state.value[e],l;function u(){c||(r.state.value[e]=i?i():{});let t=d(r.state.value[e]);return j(t,a,Object.keys(s||{}).reduce((i,a)=>(a in t&&console.warn(`[🍍]: A getter cannot have the same name as another state property. Rename one of them. Found with "${a}" in store "${e}".`),i[a]=o(n(()=>{b(r);let t=r._s.get(e);return s[a].call(t,t)})),i),{}))}return l=N(e,u,t,r),l}function N(e,t,n={},i){let a,o=j({actions:{}},n),l={deep:!0},d,p,m=new Set,h=new Set,g=[],_;function v(t){let n;d=p=!1,typeof t==`function`?(t(i.state.value[e]),n={type:T.patchFunction,storeId:e,events:g}):(O(i.state.value[e],t),n={type:T.patchObject,payload:t,storeId:e,events:g}),_=Symbol();let r=_;s().then(()=>{_===r&&(d=!0)}),p=!0,w(m,n,i.state.value[e])}let y=function(){let{state:e}=n,t=e?e():{};this.$patch(e=>{j(e,t)})},x=(t,n=``)=>{if(k in t)return t[A]=n,t;let r=function(){b(i);let n=Array.from(arguments),a=new Set,o=new Set;function s(e){a.add(e)}function c(e){o.add(e)}w(h,{args:n,name:r[A],store:E,after:s,onError:c});let l;try{l=t.apply(this&&this.$id===e?this:E,n)}catch(e){throw w(o,e),e}return l instanceof Promise?l.then(e=>(w(a,e),e)).catch(e=>(w(o,e),Promise.reject(e))):(w(a,l),l)};return r[k]=!0,r[A]=n,r},S={_p:i,$id:e,$onAction:C.bind(null,P,h),$patch:v,$reset:y,$subscribe(t,n={}){let r=C([[]],m,t,n.detached,()=>o()),o=a.run(()=>f(()=>i.state.value[e],r=>{(n.flush===`sync`?p:d)&&t({storeId:e,type:T.direct,events:g},r)},j({},l,n)));return r}},E=c(S);i._s.set(e,E),a=r();let D=a.run(()=>t({action:x}));for(let e in D){let t=D[e];if(typeof t==`function`){let n=x(t,e);D[e]=n,o.actions[e]=t}}return j(E,D),j(u(E),D),Object.defineProperty(E,`$state`,{get:()=>i.state.value[e],set:e=>{v(t=>{j(t,e)})}}),i._p.forEach(e=>{j(E,a.run(()=>e({store:E,pinia:i,options:o})))}),d=!0,p=!0,E}const P=[[]];function F(n,r){let i=new WeakMap,a=new WeakMap,o=new WeakMap;function s(s){if(s&&b(s),!y)throw Error(`[🍍]: "getActivePinia()" was called but there was no active Pinia. Are you trying to use a store before calling "createPinia()"?
-`);s=y;let c=t.value;t.value=void 0,s._s.has(n)||M(n,r,s),t.value=c;let l=s._s.get(n),u=g([h()]),d=g({...l}),f=g(!1);o.get(u.current)||o.set(u.current,[]),P[0]=o.get(u.current),m(()=>(P[0]=o.get(u.current),()=>{o.get(u.current).forEach(e=>e())}),[]);let v=p(e=>(a.set(u.current,e),()=>{let e=i.get(u.current);e&&e.stop(),a.delete(u.current),i.delete(u.current)}),[]);_(v,()=>d.current,()=>d.current);let x=i.get(u.current);if(!x){let n=()=>{let e=a.get(u.current);f.current||(d.current={...l},e?.())};x=new e(n,E,()=>{x?.dirty&&x.run()}),t.value=x,f.current=!0,x.run(),i.set(u.current,x),f.current=!1}return l}return s.$id=n,s.$getStore=e=>{e&&b(e),e=y,e._s.has(n)||M(n,r,e);let t=e._s.get(n);return t},s}export{T as MutationType,x as createPinia,F as defineStore,v as getActivePinia,b as setActivePinia};
+import { useCallback, useEffect, useId, useRef, useSyncExternalStore } from "react";
+
+//#region ../../node_modules/.pnpm/@maoism+runtime-core@3.4.13/node_modules/@maoism/runtime-core/dist/runtime-core.esm-bundler.js
+function makeMap(str, expectsLowerCase) {
+	const set2 = new Set(str.split(","));
+	return expectsLowerCase ? (val) => set2.has(val.toLowerCase()) : (val) => set2.has(val);
+}
+var EMPTY_OBJ = Object.freeze({});
+var EMPTY_ARR = Object.freeze([]);
+var NOOP = () => {};
+var NO = () => false;
+var extend = Object.assign;
+var remove = (arr, el) => {
+	const i = arr.indexOf(el);
+	if (i > -1) arr.splice(i, 1);
+};
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var hasOwn = (val, key) => hasOwnProperty.call(val, key);
+var isArray = Array.isArray;
+var isMap = (val) => toTypeString(val) === "[object Map]";
+var isSet = (val) => toTypeString(val) === "[object Set]";
+var isFunction = (val) => typeof val === "function";
+var isString = (val) => typeof val === "string";
+var isSymbol = (val) => typeof val === "symbol";
+var isObject = (val) => val !== null && typeof val === "object";
+var isPromise = (val) => {
+	return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
+};
+var objectToString = Object.prototype.toString;
+var toTypeString = (value) => objectToString.call(value);
+var toRawType = (value) => {
+	return toTypeString(value).slice(8, -1);
+};
+var isPlainObject$1 = (val) => toTypeString(val) === "[object Object]";
+var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+var cacheStringFunction = (fn) => {
+	const cache = /* @__PURE__ */ Object.create(null);
+	return (str) => {
+		const hit = cache[str];
+		return hit || (cache[str] = fn(str));
+	};
+};
+var camelizeRE = /-(\w)/g;
+var camelize = cacheStringFunction((str) => {
+	return str.replace(camelizeRE, (_$1, c) => c ? c.toUpperCase() : "");
+});
+var hyphenateRE = /\B([A-Z])/g;
+var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+var capitalize = cacheStringFunction((str) => {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+});
+var toHandlerKey = cacheStringFunction((str) => {
+	const s = str ? `on${capitalize(str)}` : ``;
+	return s;
+});
+var hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+var def = (obj, key, value) => {
+	Object.defineProperty(obj, key, {
+		configurable: true,
+		enumerable: false,
+		value
+	});
+};
+var _globalThis;
+var getGlobalThis = () => {
+	return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+};
+var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+var isBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
+function warn(msg, ...args) {
+	console.warn(`[Vue warn] ${msg}`, ...args);
+}
+var activeEffectScope;
+var EffectScope = class {
+	constructor(detached = false) {
+		this.detached = detached;
+		/**
+		* @internal
+		*/
+		this._active = true;
+		/**
+		* @internal
+		*/
+		this.effects = [];
+		/**
+		* @internal
+		*/
+		this.cleanups = [];
+		this.parent = activeEffectScope;
+		if (!detached && activeEffectScope) this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
+	}
+	get active() {
+		return this._active;
+	}
+	run(fn) {
+		if (this._active) {
+			const currentEffectScope = activeEffectScope;
+			try {
+				activeEffectScope = this;
+				return fn();
+			} finally {
+				activeEffectScope = currentEffectScope;
+			}
+		} else warn(`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(fromParent) {
+		if (this._active) {
+			let i, l;
+			for (i = 0, l = this.effects.length; i < l; i++) this.effects[i].stop();
+			for (i = 0, l = this.cleanups.length; i < l; i++) this.cleanups[i]();
+			if (this.scopes) for (i = 0, l = this.scopes.length; i < l; i++) this.scopes[i].stop(true);
+			if (!this.detached && this.parent && !fromParent) {
+				const last = this.parent.scopes.pop();
+				if (last && last !== this) {
+					this.parent.scopes[this.index] = last;
+					last.index = this.index;
+				}
+			}
+			this.parent = void 0;
+			this._active = false;
+		}
+	}
+};
+function effectScope(detached) {
+	return new EffectScope(detached);
+}
+function recordEffectScope(effect2, scope = activeEffectScope) {
+	if (scope && scope.active) scope.effects.push(effect2);
+}
+function getCurrentScope() {
+	return activeEffectScope;
+}
+var activeEffect = { value: void 0 };
+var ReactiveEffect = class {
+	constructor(fn, trigger2, scheduler, scope) {
+		this.fn = fn;
+		this.trigger = trigger2;
+		this.scheduler = scheduler;
+		this.active = true;
+		this.deps = [];
+		/**
+		* @internal
+		*/
+		this._dirtyLevel = 2;
+		/**
+		* @internal
+		*/
+		this._trackId = 0;
+		/**
+		* @internal
+		*/
+		this._runnings = 0;
+		/**
+		* @internal
+		*/
+		this._shouldSchedule = false;
+		/**
+		* @internal
+		*/
+		this._depsLength = 0;
+		recordEffectScope(this, scope);
+	}
+	get dirty() {
+		if (this._dirtyLevel === 1) {
+			pauseTracking();
+			for (let i = 0; i < this._depsLength; i++) {
+				const dep = this.deps[i];
+				if (dep.computed) {
+					triggerComputed(dep.computed);
+					if (this._dirtyLevel >= 2) break;
+				}
+			}
+			if (this._dirtyLevel < 2) this._dirtyLevel = 0;
+			resetTracking();
+		}
+		return this._dirtyLevel >= 2;
+	}
+	set dirty(v) {
+		this._dirtyLevel = v ? 2 : 0;
+	}
+	run() {
+		this._dirtyLevel = 0;
+		if (!this.active) return this.fn();
+		let lastShouldTrack = shouldTrack;
+		let lastEffect = activeEffect.value;
+		try {
+			shouldTrack = true;
+			activeEffect.value = this;
+			this._runnings++;
+			preCleanupEffect(this);
+			return this.fn();
+		} finally {
+			postCleanupEffect(this);
+			this._runnings--;
+			activeEffect.value = lastEffect;
+			shouldTrack = lastShouldTrack;
+		}
+	}
+	stop() {
+		if (this.active) {
+			preCleanupEffect(this);
+			postCleanupEffect(this);
+			this.onStop?.();
+			this.active = false;
+		}
+	}
+};
+function triggerComputed(computed3) {
+	return computed3.value;
+}
+function preCleanupEffect(effect2) {
+	effect2._trackId++;
+	effect2._depsLength = 0;
+}
+function postCleanupEffect(effect2) {
+	if (effect2.deps && effect2.deps.length > effect2._depsLength) {
+		for (let i = effect2._depsLength; i < effect2.deps.length; i++) cleanupDepEffect(effect2.deps[i], effect2);
+		effect2.deps.length = effect2._depsLength;
+	}
+}
+function cleanupDepEffect(dep, effect2) {
+	const trackId = dep.get(effect2);
+	if (trackId !== void 0 && effect2._trackId !== trackId) {
+		dep.delete(effect2);
+		if (dep.size === 0) dep.cleanup();
+	}
+}
+var shouldTrack = true;
+var pauseScheduleStack = 0;
+var trackStack = [];
+function pauseTracking() {
+	trackStack.push(shouldTrack);
+	shouldTrack = false;
+}
+function resetTracking() {
+	const last = trackStack.pop();
+	shouldTrack = last === void 0 ? true : last;
+}
+function pauseScheduling() {
+	pauseScheduleStack++;
+}
+function resetScheduling() {
+	pauseScheduleStack--;
+	while (!pauseScheduleStack && queueEffectSchedulers.length) queueEffectSchedulers.shift()();
+}
+function trackEffect(effect2, dep, debuggerEventExtraInfo) {
+	if (dep.get(effect2) !== effect2._trackId) {
+		dep.set(effect2, effect2._trackId);
+		const oldDep = effect2.deps[effect2._depsLength];
+		if (oldDep !== dep) {
+			if (oldDep) cleanupDepEffect(oldDep, effect2);
+			effect2.deps[effect2._depsLength++] = dep;
+		} else effect2._depsLength++;
+		effect2.onTrack?.(extend({ effect: effect2 }, debuggerEventExtraInfo));
+	}
+}
+var queueEffectSchedulers = [];
+function triggerEffects(dep, dirtyLevel, debuggerEventExtraInfo) {
+	pauseScheduling();
+	for (const effect2 of dep.keys()) {
+		if (dep.get(effect2) !== effect2._trackId) continue;
+		if (effect2._dirtyLevel < dirtyLevel) {
+			const lastDirtyLevel = effect2._dirtyLevel;
+			effect2._dirtyLevel = dirtyLevel;
+			if (lastDirtyLevel === 0) {
+				effect2._shouldSchedule = true;
+				effect2.onTrigger?.(extend({ effect: effect2 }, debuggerEventExtraInfo));
+				effect2.trigger();
+			}
+		}
+		if (effect2.scheduler && effect2._shouldSchedule && (!effect2._runnings || effect2.allowRecurse)) {
+			effect2._shouldSchedule = false;
+			queueEffectSchedulers.push(effect2.scheduler);
+		}
+	}
+	resetScheduling();
+}
+var createDep = (cleanup, computed3) => {
+	const dep = /* @__PURE__ */ new Map();
+	dep.cleanup = cleanup;
+	dep.computed = computed3;
+	return dep;
+};
+var targetMap = /* @__PURE__ */ new WeakMap();
+var ITERATE_KEY = Symbol("iterate");
+var MAP_KEY_ITERATE_KEY = Symbol("Map key iterate");
+function track(target, type, key) {
+	if (shouldTrack && activeEffect.value) {
+		let depsMap = targetMap.get(target);
+		if (!depsMap) targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+		let dep = depsMap.get(key);
+		if (!dep) depsMap.set(key, dep = createDep(() => depsMap.delete(key)));
+		trackEffect(activeEffect.value, dep, {
+			target,
+			type,
+			key
+		});
+	}
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+	const depsMap = targetMap.get(target);
+	if (!depsMap) return;
+	let deps = [];
+	if (type === "clear") deps = [...depsMap.values()];
+	else if (key === "length" && isArray(target)) {
+		const newLength = Number(newValue);
+		depsMap.forEach((dep, key2) => {
+			if (key2 === "length" || !isSymbol(key2) && key2 >= newLength) deps.push(dep);
+		});
+	} else {
+		if (key !== void 0) deps.push(depsMap.get(key));
+		switch (type) {
+			case "add":
+				if (!isArray(target)) {
+					deps.push(depsMap.get(ITERATE_KEY));
+					if (isMap(target)) deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+				} else if (isIntegerKey(key)) deps.push(depsMap.get("length"));
+				break;
+			case "delete":
+				if (!isArray(target)) {
+					deps.push(depsMap.get(ITERATE_KEY));
+					if (isMap(target)) deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+				}
+				break;
+			case "set":
+				if (isMap(target)) deps.push(depsMap.get(ITERATE_KEY));
+				break;
+		}
+	}
+	pauseScheduling();
+	for (const dep of deps) if (dep) triggerEffects(dep, 2, {
+		target,
+		type,
+		key,
+		newValue,
+		oldValue,
+		oldTarget
+	});
+	resetScheduling();
+}
+function getDepFromReactive(object, key) {
+	return targetMap.get(object)?.get(key);
+}
+var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
+var builtInSymbols = new Set(/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol));
+var arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
+function createArrayInstrumentations() {
+	const instrumentations = {};
+	[
+		"includes",
+		"indexOf",
+		"lastIndexOf"
+	].forEach((key) => {
+		instrumentations[key] = function(...args) {
+			const arr = toRaw(this);
+			for (let i = 0, l = this.length; i < l; i++) track(arr, "get", i + "");
+			const res = arr[key](...args);
+			if (res === -1 || res === false) return arr[key](...args.map(toRaw));
+			else return res;
+		};
+	});
+	[
+		"push",
+		"pop",
+		"shift",
+		"unshift",
+		"splice"
+	].forEach((key) => {
+		instrumentations[key] = function(...args) {
+			pauseTracking();
+			pauseScheduling();
+			const res = toRaw(this)[key].apply(this, args);
+			resetScheduling();
+			resetTracking();
+			return res;
+		};
+	});
+	return instrumentations;
+}
+function hasOwnProperty2(key) {
+	const obj = toRaw(this);
+	track(obj, "has", key);
+	return obj.hasOwnProperty(key);
+}
+var BaseReactiveHandler = class {
+	constructor(_isReadonly = false, _shallow = false) {
+		this._isReadonly = _isReadonly;
+		this._shallow = _shallow;
+	}
+	get(target, key, receiver) {
+		const isReadonly2 = this._isReadonly, shallow = this._shallow;
+		if (key === "__v_isReactive") return !isReadonly2;
+		else if (key === "__v_isReadonly") return isReadonly2;
+		else if (key === "__v_isShallow") return shallow;
+		else if (key === "__v_raw") {
+			if (receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target) || Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) return target;
+			return;
+		}
+		const targetIsArray = isArray(target);
+		if (!isReadonly2) {
+			if (targetIsArray && hasOwn(arrayInstrumentations, key)) return Reflect.get(arrayInstrumentations, key, receiver);
+			if (key === "hasOwnProperty") return hasOwnProperty2;
+		}
+		const res = Reflect.get(target, key, receiver);
+		if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) return res;
+		if (!isReadonly2) track(target, "get", key);
+		if (shallow) return res;
+		if (isRef(res)) return targetIsArray && isIntegerKey(key) ? res : res.value;
+		if (isObject(res)) return isReadonly2 ? readonly(res) : reactive(res);
+		return res;
+	}
+};
+var MutableReactiveHandler = class extends BaseReactiveHandler {
+	constructor(shallow = false) {
+		super(false, shallow);
+	}
+	set(target, key, value, receiver) {
+		let oldValue = target[key];
+		if (!this._shallow) {
+			const isOldValueReadonly = isReadonly(oldValue);
+			if (!isShallow(value) && !isReadonly(value)) {
+				oldValue = toRaw(oldValue);
+				value = toRaw(value);
+			}
+			if (!isArray(target) && isRef(oldValue) && !isRef(value)) if (isOldValueReadonly) return false;
+			else {
+				oldValue.value = value;
+				return true;
+			}
+		}
+		const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
+		const result = Reflect.set(target, key, value, receiver);
+		if (target === toRaw(receiver)) {
+			if (!hadKey) trigger(target, "add", key, value);
+			else if (hasChanged(value, oldValue)) trigger(target, "set", key, value, oldValue);
+		}
+		return result;
+	}
+	deleteProperty(target, key) {
+		const hadKey = hasOwn(target, key);
+		const oldValue = target[key];
+		const result = Reflect.deleteProperty(target, key);
+		if (result && hadKey) trigger(target, "delete", key, void 0, oldValue);
+		return result;
+	}
+	has(target, key) {
+		const result = Reflect.has(target, key);
+		if (!isSymbol(key) || !builtInSymbols.has(key)) track(target, "has", key);
+		return result;
+	}
+	ownKeys(target) {
+		track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
+		return Reflect.ownKeys(target);
+	}
+};
+var ReadonlyReactiveHandler = class extends BaseReactiveHandler {
+	constructor(shallow = false) {
+		super(true, shallow);
+	}
+	set(target, key) {
+		warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
+		return true;
+	}
+	deleteProperty(target, key) {
+		warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
+		return true;
+	}
+};
+var mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
+var readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
+var shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
+var toShallow = (value) => value;
+var getProto = (v) => Reflect.getPrototypeOf(v);
+function get(target, key, isReadonly2 = false, isShallow2 = false) {
+	target = target["__v_raw"];
+	const rawTarget = toRaw(target);
+	const rawKey = toRaw(key);
+	if (!isReadonly2) {
+		if (hasChanged(key, rawKey)) track(rawTarget, "get", key);
+		track(rawTarget, "get", rawKey);
+	}
+	const { has: has2 } = getProto(rawTarget);
+	const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+	if (has2.call(rawTarget, key)) return wrap(target.get(key));
+	else if (has2.call(rawTarget, rawKey)) return wrap(target.get(rawKey));
+	else if (target !== rawTarget) target.get(key);
+}
+function has(key, isReadonly2 = false) {
+	const target = this["__v_raw"];
+	const rawTarget = toRaw(target);
+	const rawKey = toRaw(key);
+	if (!isReadonly2) {
+		if (hasChanged(key, rawKey)) track(rawTarget, "has", key);
+		track(rawTarget, "has", rawKey);
+	}
+	return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+}
+function size(target, isReadonly2 = false) {
+	target = target["__v_raw"];
+	!isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
+	return Reflect.get(target, "size", target);
+}
+function add(value) {
+	value = toRaw(value);
+	const target = toRaw(this);
+	const proto = getProto(target);
+	const hadKey = proto.has.call(target, value);
+	if (!hadKey) {
+		target.add(value);
+		trigger(target, "add", value, value);
+	}
+	return this;
+}
+function set(key, value) {
+	value = toRaw(value);
+	const target = toRaw(this);
+	const { has: has2, get: get2 } = getProto(target);
+	let hadKey = has2.call(target, key);
+	if (!hadKey) {
+		key = toRaw(key);
+		hadKey = has2.call(target, key);
+	} else checkIdentityKeys(target, has2, key);
+	const oldValue = get2.call(target, key);
+	target.set(key, value);
+	if (!hadKey) trigger(target, "add", key, value);
+	else if (hasChanged(value, oldValue)) trigger(target, "set", key, value, oldValue);
+	return this;
+}
+function deleteEntry(key) {
+	const target = toRaw(this);
+	const { has: has2, get: get2 } = getProto(target);
+	let hadKey = has2.call(target, key);
+	if (!hadKey) {
+		key = toRaw(key);
+		hadKey = has2.call(target, key);
+	} else checkIdentityKeys(target, has2, key);
+	const oldValue = get2 ? get2.call(target, key) : void 0;
+	const result = target.delete(key);
+	if (hadKey) trigger(target, "delete", key, void 0, oldValue);
+	return result;
+}
+function clear() {
+	const target = toRaw(this);
+	const hadItems = target.size !== 0;
+	const oldTarget = isMap(target) ? new Map(target) : new Set(target);
+	const result = target.clear();
+	if (hadItems) trigger(target, "clear", void 0, void 0, oldTarget);
+	return result;
+}
+function createForEach(isReadonly2, isShallow2) {
+	return function forEach(callback, thisArg) {
+		const observed = this;
+		const target = observed["__v_raw"];
+		const rawTarget = toRaw(target);
+		const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+		!isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY);
+		return target.forEach((value, key) => {
+			return callback.call(thisArg, wrap(value), wrap(key), observed);
+		});
+	};
+}
+function createIterableMethod(method, isReadonly2, isShallow2) {
+	return function(...args) {
+		const target = this["__v_raw"];
+		const rawTarget = toRaw(target);
+		const targetIsMap = isMap(rawTarget);
+		const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+		const isKeyOnly = method === "keys" && targetIsMap;
+		const innerIterator = target[method](...args);
+		const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+		!isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
+		return {
+			next() {
+				const { value, done } = innerIterator.next();
+				return done ? {
+					value,
+					done
+				} : {
+					value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+					done
+				};
+			},
+			[Symbol.iterator]() {
+				return this;
+			}
+		};
+	};
+}
+function createReadonlyMethod(type) {
+	return function(...args) {
+		{
+			const key = args[0] ? `on key "${args[0]}" ` : ``;
+			console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
+		}
+		return type === "delete" ? false : type === "clear" ? void 0 : this;
+	};
+}
+function createInstrumentations() {
+	const mutableInstrumentations2 = {
+		get(key) {
+			return get(this, key);
+		},
+		get size() {
+			return size(this);
+		},
+		has,
+		add,
+		set,
+		delete: deleteEntry,
+		clear,
+		forEach: createForEach(false, false)
+	};
+	const shallowInstrumentations2 = {
+		get(key) {
+			return get(this, key, false, true);
+		},
+		get size() {
+			return size(this);
+		},
+		has,
+		add,
+		set,
+		delete: deleteEntry,
+		clear,
+		forEach: createForEach(false, true)
+	};
+	const readonlyInstrumentations2 = {
+		get(key) {
+			return get(this, key, true);
+		},
+		get size() {
+			return size(this, true);
+		},
+		has(key) {
+			return has.call(this, key, true);
+		},
+		add: createReadonlyMethod("add"),
+		set: createReadonlyMethod("set"),
+		delete: createReadonlyMethod("delete"),
+		clear: createReadonlyMethod("clear"),
+		forEach: createForEach(true, false)
+	};
+	const shallowReadonlyInstrumentations2 = {
+		get(key) {
+			return get(this, key, true, true);
+		},
+		get size() {
+			return size(this, true);
+		},
+		has(key) {
+			return has.call(this, key, true);
+		},
+		add: createReadonlyMethod("add"),
+		set: createReadonlyMethod("set"),
+		delete: createReadonlyMethod("delete"),
+		clear: createReadonlyMethod("clear"),
+		forEach: createForEach(true, true)
+	};
+	const iteratorMethods = [
+		"keys",
+		"values",
+		"entries",
+		Symbol.iterator
+	];
+	iteratorMethods.forEach((method) => {
+		mutableInstrumentations2[method] = createIterableMethod(method, false, false);
+		readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
+		shallowInstrumentations2[method] = createIterableMethod(method, false, true);
+		shallowReadonlyInstrumentations2[method] = createIterableMethod(method, true, true);
+	});
+	return [
+		mutableInstrumentations2,
+		readonlyInstrumentations2,
+		shallowInstrumentations2,
+		shallowReadonlyInstrumentations2
+	];
+}
+var [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* @__PURE__ */ createInstrumentations();
+function createInstrumentationGetter(isReadonly2, shallow) {
+	const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;
+	return (target, key, receiver) => {
+		if (key === "__v_isReactive") return !isReadonly2;
+		else if (key === "__v_isReadonly") return isReadonly2;
+		else if (key === "__v_raw") return target;
+		return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
+	};
+}
+var mutableCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(false, false) };
+var readonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, false) };
+var shallowReadonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, true) };
+function checkIdentityKeys(target, has2, key) {
+	const rawKey = toRaw(key);
+	if (rawKey !== key && has2.call(target, rawKey)) {
+		const type = toRawType(target);
+		console.warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`);
+	}
+}
+var reactiveMap = /* @__PURE__ */ new WeakMap();
+var shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+var readonlyMap = /* @__PURE__ */ new WeakMap();
+var shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+function targetTypeMap(rawType) {
+	switch (rawType) {
+		case "Object":
+		case "Array": return 1;
+		case "Map":
+		case "Set":
+		case "WeakMap":
+		case "WeakSet": return 2;
+		default: return 0;
+	}
+}
+function getTargetType(value) {
+	return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
+}
+function reactive(target) {
+	if (isReadonly(target)) return target;
+	return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
+}
+function readonly(target) {
+	return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
+}
+function shallowReadonly(target) {
+	return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
+}
+function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+	if (!isObject(target)) {
+		console.warn(`value cannot be made reactive: ${String(target)}`);
+		return target;
+	}
+	if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) return target;
+	const existingProxy = proxyMap.get(target);
+	if (existingProxy) return existingProxy;
+	const targetType = getTargetType(target);
+	if (targetType === 0) return target;
+	const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
+	proxyMap.set(target, proxy);
+	return proxy;
+}
+function isReactive(value) {
+	if (isReadonly(value)) return isReactive(value["__v_raw"]);
+	return !!(value && value["__v_isReactive"]);
+}
+function isReadonly(value) {
+	return !!(value && value["__v_isReadonly"]);
+}
+function isShallow(value) {
+	return !!(value && value["__v_isShallow"]);
+}
+function isProxy(value) {
+	return isReactive(value) || isReadonly(value);
+}
+function toRaw(observed) {
+	const raw = observed && observed["__v_raw"];
+	return raw ? toRaw(raw) : observed;
+}
+function markRaw(value) {
+	def(value, "__v_skip", true);
+	return value;
+}
+var toReactive = (value) => isObject(value) ? reactive(value) : value;
+var toReadonly = (value) => isObject(value) ? readonly(value) : value;
+var _a;
+var ComputedRefImpl = class {
+	constructor(getter, _setter, isReadonly2, isSSR) {
+		this._setter = _setter;
+		this.dep = void 0;
+		this.__v_isRef = true;
+		this[_a] = false;
+		this.effect = new ReactiveEffect(() => getter(this._value), () => triggerRefValue(this, 1));
+		this.effect.computed = this;
+		this.effect.active = this._cacheable = !isSSR;
+		this["__v_isReadonly"] = isReadonly2;
+	}
+	static {
+		_a = "__v_isReadonly";
+	}
+	get value() {
+		const self2 = toRaw(this);
+		if (!self2._cacheable || self2.effect.dirty) {
+			if (hasChanged(self2._value, self2._value = self2.effect.run())) triggerRefValue(self2, 2);
+		}
+		trackRefValue(self2);
+		return self2._value;
+	}
+	set value(newValue) {
+		this._setter(newValue);
+	}
+	get _dirty() {
+		return this.effect.dirty;
+	}
+	set _dirty(v) {
+		this.effect.dirty = v;
+	}
+};
+function computed(getterOrOptions, debugOptions, isSSR = false) {
+	let getter;
+	let setter;
+	const onlyGetter = isFunction(getterOrOptions);
+	if (onlyGetter) {
+		getter = getterOrOptions;
+		setter = () => {
+			console.warn("Write operation failed: computed value is readonly");
+		};
+	} else {
+		getter = getterOrOptions.get;
+		setter = getterOrOptions.set;
+	}
+	const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
+	if (debugOptions && !isSSR) {
+		cRef.effect.onTrack = debugOptions.onTrack;
+		cRef.effect.onTrigger = debugOptions.onTrigger;
+	}
+	return cRef;
+}
+function trackRefValue(ref2) {
+	if (shouldTrack && activeEffect.value) {
+		ref2 = toRaw(ref2);
+		trackEffect(activeEffect.value, ref2.dep || (ref2.dep = createDep(() => ref2.dep = void 0, ref2 instanceof ComputedRefImpl ? ref2 : void 0)), {
+			target: ref2,
+			type: "get",
+			key: "value"
+		});
+	}
+}
+function triggerRefValue(ref2, dirtyLevel = 2, newVal) {
+	ref2 = toRaw(ref2);
+	const dep = ref2.dep;
+	if (dep) triggerEffects(dep, dirtyLevel, {
+		target: ref2,
+		type: "set",
+		key: "value",
+		newValue: newVal
+	});
+}
+function isRef(r) {
+	return !!(r && r.__v_isRef === true);
+}
+function ref(value) {
+	return createRef(value, false);
+}
+function createRef(rawValue, shallow) {
+	if (isRef(rawValue)) return rawValue;
+	return new RefImpl(rawValue, shallow);
+}
+var RefImpl = class {
+	constructor(value, __v_isShallow) {
+		this.__v_isShallow = __v_isShallow;
+		this.dep = void 0;
+		this.__v_isRef = true;
+		this._rawValue = __v_isShallow ? value : toRaw(value);
+		this._value = __v_isShallow ? value : toReactive(value);
+	}
+	get value() {
+		trackRefValue(this);
+		return this._value;
+	}
+	set value(newVal) {
+		const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
+		newVal = useDirectValue ? newVal : toRaw(newVal);
+		if (hasChanged(newVal, this._rawValue)) {
+			this._rawValue = newVal;
+			this._value = useDirectValue ? newVal : toReactive(newVal);
+			triggerRefValue(this, 2, newVal);
+		}
+	}
+};
+function unref(ref2) {
+	return isRef(ref2) ? ref2.value : ref2;
+}
+var shallowUnwrapHandlers = {
+	get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
+	set: (target, key, value, receiver) => {
+		const oldValue = target[key];
+		if (isRef(oldValue) && !isRef(value)) {
+			oldValue.value = value;
+			return true;
+		} else return Reflect.set(target, key, value, receiver);
+	}
+};
+function proxyRefs(objectWithRefs) {
+	return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
+}
+function toRefs(object) {
+	if (!isProxy(object)) console.warn(`toRefs() expects a reactive object but received a plain one.`);
+	const ret = isArray(object) ? new Array(object.length) : {};
+	for (const key in object) ret[key] = propertyToRef(object, key);
+	return ret;
+}
+var ObjectRefImpl = class {
+	constructor(_object, _key, _defaultValue) {
+		this._object = _object;
+		this._key = _key;
+		this._defaultValue = _defaultValue;
+		this.__v_isRef = true;
+	}
+	get value() {
+		const val = this._object[this._key];
+		return val === void 0 ? this._defaultValue : val;
+	}
+	set value(newVal) {
+		this._object[this._key] = newVal;
+	}
+	get dep() {
+		return getDepFromReactive(toRaw(this._object), this._key);
+	}
+};
+function propertyToRef(source, key, defaultValue) {
+	const val = source[key];
+	return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
+}
+var stack = [];
+function pushWarningContext(vnode) {
+	stack.push(vnode);
+}
+function popWarningContext() {
+	stack.pop();
+}
+function warn2(msg, ...args) {
+	pauseTracking();
+	const instance = stack.length ? stack[stack.length - 1].component : null;
+	const appWarnHandler = instance && instance.appContext.config.warnHandler;
+	const trace = getComponentTrace();
+	if (appWarnHandler) callWithErrorHandling(appWarnHandler, instance, 11, [
+		msg + args.join(""),
+		instance && instance.proxy,
+		trace.map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`).join("\n"),
+		trace
+	]);
+	else {
+		const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+		if (trace.length && true) warnArgs.push(`
+`, ...formatTrace(trace));
+		console.warn(...warnArgs);
+	}
+	resetTracking();
+}
+function getComponentTrace() {
+	let currentVNode = stack[stack.length - 1];
+	if (!currentVNode) return [];
+	const normalizedStack = [];
+	while (currentVNode) {
+		const last = normalizedStack[0];
+		if (last && last.vnode === currentVNode) last.recurseCount++;
+		else normalizedStack.push({
+			vnode: currentVNode,
+			recurseCount: 0
+		});
+		const parentInstance = currentVNode.component && currentVNode.component.parent;
+		currentVNode = parentInstance && parentInstance.vnode;
+	}
+	return normalizedStack;
+}
+function formatTrace(trace) {
+	const logs = [];
+	trace.forEach((entry, i) => {
+		logs.push(...i === 0 ? [] : [`
+`], ...formatTraceEntry(entry));
+	});
+	return logs;
+}
+function formatTraceEntry({ vnode, recurseCount }) {
+	const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+	const isRoot = vnode.component ? vnode.component.parent == null : false;
+	const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;
+	const close = `>` + postfix;
+	return vnode.props ? [
+		open,
+		...formatProps(vnode.props),
+		close
+	] : [open + close];
+}
+function formatProps(props) {
+	const res = [];
+	const keys = Object.keys(props);
+	keys.slice(0, 3).forEach((key) => {
+		res.push(...formatProp(key, props[key]));
+	});
+	if (keys.length > 3) res.push(` ...`);
+	return res;
+}
+function formatProp(key, value, raw) {
+	if (isString(value)) {
+		value = JSON.stringify(value);
+		return raw ? value : [`${key}=${value}`];
+	} else if (typeof value === "number" || typeof value === "boolean" || value == null) return raw ? value : [`${key}=${value}`];
+	else if (isRef(value)) {
+		value = formatProp(key, toRaw(value.value), true);
+		return raw ? value : [
+			`${key}=Ref<`,
+			value,
+			`>`
+		];
+	} else if (isFunction(value)) return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+	else {
+		value = toRaw(value);
+		return raw ? value : [`${key}=`, value];
+	}
+}
+var ErrorTypeStrings = {
+	["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. This is likely a Vue internals bug. Please open an issue at https://github.com/vuejs/core ."
+};
+function callWithErrorHandling(fn, instance, type, args) {
+	let res;
+	try {
+		res = args ? fn(...args) : fn();
+	} catch (err) {
+		handleError(err, instance, type);
+	}
+	return res;
+}
+function callWithAsyncErrorHandling(fn, instance, type, args) {
+	if (isFunction(fn)) {
+		const res = callWithErrorHandling(fn, instance, type, args);
+		if (res && isPromise(res)) res.catch((err) => {
+			handleError(err, instance, type);
+		});
+		return res;
+	}
+	const values = [];
+	for (let i = 0; i < fn.length; i++) values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
+	return values;
+}
+function handleError(err, instance, type, throwInDev = true) {
+	const contextVNode = instance ? instance.vnode : null;
+	if (instance) {
+		let cur = instance.parent;
+		const exposedInstance = instance.proxy;
+		const errorInfo = ErrorTypeStrings[type];
+		while (cur) {
+			const errorCapturedHooks = cur.ec;
+			if (errorCapturedHooks) {
+				for (let i = 0; i < errorCapturedHooks.length; i++) if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) return;
+			}
+			cur = cur.parent;
+		}
+		const appErrorHandler = instance.appContext.config.errorHandler;
+		if (appErrorHandler) {
+			callWithErrorHandling(appErrorHandler, null, 10, [
+				err,
+				exposedInstance,
+				errorInfo
+			]);
+			return;
+		}
+	}
+	logError(err, type, contextVNode, throwInDev);
+}
+function logError(err, type, contextVNode, throwInDev = true) {
+	{
+		const info = ErrorTypeStrings[type];
+		if (contextVNode) pushWarningContext(contextVNode);
+		warn2(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+		if (contextVNode) popWarningContext();
+		if (throwInDev) throw err;
+		else console.error(err);
+	}
+}
+var isFlushing = false;
+var isFlushPending = false;
+var queue = [];
+var flushIndex = 0;
+var pendingPostFlushCbs = [];
+var activePostFlushCbs = null;
+var postFlushIndex = 0;
+var resolvedPromise = /* @__PURE__ */ Promise.resolve();
+var currentFlushPromise = null;
+var RECURSION_LIMIT = 100;
+function nextTick(fn) {
+	const p = currentFlushPromise || resolvedPromise;
+	return fn ? p.then(this ? fn.bind(this) : fn) : p;
+}
+function findInsertionIndex(id) {
+	let start = flushIndex + 1;
+	let end = queue.length;
+	while (start < end) {
+		const middle = start + end >>> 1;
+		const middleJob = queue[middle];
+		const middleJobId = getId(middleJob);
+		if (middleJobId < id || middleJobId === id && middleJob.pre) start = middle + 1;
+		else end = middle;
+	}
+	return start;
+}
+function queueJob(job) {
+	if (!queue.length || !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) {
+		if (job.id == null) queue.push(job);
+		else queue.splice(findInsertionIndex(job.id), 0, job);
+		queueFlush();
+	}
+}
+function queueFlush() {
+	if (!isFlushing && !isFlushPending) {
+		isFlushPending = true;
+		currentFlushPromise = resolvedPromise.then(flushJobs);
+	}
+}
+function queuePostFlushCb(cb) {
+	if (!isArray(cb)) {
+		if (!activePostFlushCbs || !activePostFlushCbs.includes(cb, cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex)) pendingPostFlushCbs.push(cb);
+	} else pendingPostFlushCbs.push(...cb);
+	queueFlush();
+}
+function flushPostFlushCbs(seen) {
+	if (pendingPostFlushCbs.length) {
+		const deduped = [...new Set(pendingPostFlushCbs)].sort((a$1, b$1) => getId(a$1) - getId(b$1));
+		pendingPostFlushCbs.length = 0;
+		if (activePostFlushCbs) {
+			activePostFlushCbs.push(...deduped);
+			return;
+		}
+		activePostFlushCbs = deduped;
+		seen = seen || /* @__PURE__ */ new Map();
+		for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+			if (checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) continue;
+			activePostFlushCbs[postFlushIndex]();
+		}
+		activePostFlushCbs = null;
+		postFlushIndex = 0;
+	}
+}
+var getId = (job) => job.id == null ? Infinity : job.id;
+var comparator = (a$1, b$1) => {
+	const diff = getId(a$1) - getId(b$1);
+	if (diff === 0) {
+		if (a$1.pre && !b$1.pre) return -1;
+		if (b$1.pre && !a$1.pre) return 1;
+	}
+	return diff;
+};
+function flushJobs(seen) {
+	isFlushPending = false;
+	isFlushing = true;
+	seen = seen || /* @__PURE__ */ new Map();
+	queue.sort(comparator);
+	const check = (job) => checkRecursiveUpdates(seen, job);
+	try {
+		for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+			const job = queue[flushIndex];
+			if (job && job.active !== false) {
+				if (check(job)) continue;
+				callWithErrorHandling(job, null, 14);
+			}
+		}
+	} finally {
+		flushIndex = 0;
+		queue.length = 0;
+		flushPostFlushCbs(seen);
+		isFlushing = false;
+		currentFlushPromise = null;
+		if (queue.length || pendingPostFlushCbs.length) flushJobs(seen);
+	}
+}
+function checkRecursiveUpdates(seen, fn) {
+	if (!seen.has(fn)) seen.set(fn, 1);
+	else {
+		const count = seen.get(fn);
+		if (count > RECURSION_LIMIT) {
+			const instance = fn.ownerInstance;
+			const componentName = instance && getComponentName(instance.type);
+			handleError(`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`, null, 10);
+			return true;
+		} else seen.set(fn, count + 1);
+	}
+}
+var isHmrUpdating = false;
+var hmrDirtyComponents = /* @__PURE__ */ new Set();
+getGlobalThis().__VUE_HMR_RUNTIME__ = {
+	createRecord: tryWrap(createRecord),
+	rerender: tryWrap(rerender),
+	reload: tryWrap(reload)
+};
+var map = /* @__PURE__ */ new Map();
+function createRecord(id, initialDef) {
+	if (map.has(id)) return false;
+	map.set(id, {
+		initialDef: normalizeClassComponent(initialDef),
+		instances: /* @__PURE__ */ new Set()
+	});
+	return true;
+}
+function normalizeClassComponent(component) {
+	return isClassComponent(component) ? component.__vccOpts : component;
+}
+function rerender(id, newRender) {
+	const record = map.get(id);
+	if (!record) return;
+	record.initialDef.render = newRender;
+	[...record.instances].forEach((instance) => {
+		if (newRender) {
+			instance.render = newRender;
+			normalizeClassComponent(instance.type).render = newRender;
+		}
+		instance.renderCache = [];
+		isHmrUpdating = true;
+		instance.effect.dirty = true;
+		instance.update();
+		isHmrUpdating = false;
+	});
+}
+function reload(id, newComp) {
+	const record = map.get(id);
+	if (!record) return;
+	newComp = normalizeClassComponent(newComp);
+	updateComponentDef(record.initialDef, newComp);
+	const instances = [...record.instances];
+	for (const instance of instances) {
+		const oldComp = normalizeClassComponent(instance.type);
+		if (!hmrDirtyComponents.has(oldComp)) {
+			if (oldComp !== record.initialDef) updateComponentDef(oldComp, newComp);
+			hmrDirtyComponents.add(oldComp);
+		}
+		instance.appContext.propsCache.delete(instance.type);
+		instance.appContext.emitsCache.delete(instance.type);
+		instance.appContext.optionsCache.delete(instance.type);
+		if (instance.ceReload) {
+			hmrDirtyComponents.add(oldComp);
+			instance.ceReload(newComp.styles);
+			hmrDirtyComponents.delete(oldComp);
+		} else if (instance.parent) {
+			instance.parent.effect.dirty = true;
+			queueJob(instance.parent.update);
+		} else if (instance.appContext.reload) instance.appContext.reload();
+		else if (typeof window !== "undefined") window.location.reload();
+		else console.warn("[HMR] Root or manually mounted instance modified. Full reload required.");
+	}
+	queuePostFlushCb(() => {
+		for (const instance of instances) hmrDirtyComponents.delete(normalizeClassComponent(instance.type));
+	});
+}
+function updateComponentDef(oldComp, newComp) {
+	extend(oldComp, newComp);
+	for (const key in oldComp) if (key !== "__file" && !(key in newComp)) delete oldComp[key];
+}
+function tryWrap(fn) {
+	return (id, arg) => {
+		try {
+			return fn(id, arg);
+		} catch (e) {
+			console.error(e);
+			console.warn(`[HMR] Something went wrong during Vue component hot-reload. Full reload required.`);
+		}
+	};
+}
+var currentRenderingInstance = null;
+var accessedAttrs = false;
+function markAttrsAccessed() {
+	accessedAttrs = true;
+}
+var ssrContextKey = Symbol.for("v-scx");
+var useSSRContext = () => {
+	{
+		const ctx = inject(ssrContextKey);
+		if (!ctx) warn2(`Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`);
+		return ctx;
+	}
+};
+var INITIAL_WATCHER_VALUE = {};
+function watch(source, cb, options) {
+	if (!isFunction(cb)) warn2(`\`watch(fn, options?)\` signature has been moved to a separate API. Use \`watchEffect(fn, options?)\` instead. \`watch\` now only supports \`watch(source, cb, options?) signature.`);
+	return doWatch(source, cb, options);
+}
+function doWatch(source, cb, { immediate, deep, flush, once, onTrack, onTrigger } = EMPTY_OBJ) {
+	if (cb && once) {
+		const _cb = cb;
+		cb = (...args) => {
+			_cb(...args);
+			unwatch();
+		};
+	}
+	if (deep !== void 0 && typeof deep === "number") warn2(`watch() "deep" option with number value will be used as watch depth in future versions. Please use a boolean instead to avoid potential breakage.`);
+	if (!cb) {
+		if (immediate !== void 0) warn2(`watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`);
+		if (deep !== void 0) warn2(`watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`);
+		if (once !== void 0) warn2(`watch() "once" option is only respected when using the watch(source, callback, options?) signature.`);
+	}
+	const warnInvalidSource = (s) => {
+		warn2(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`);
+	};
+	const instance = currentInstance;
+	const reactiveGetter = (source2) => deep === true ? source2 : traverse(source2, deep === false ? 1 : void 0);
+	let getter;
+	let forceTrigger = false;
+	let isMultiSource = false;
+	if (isRef(source)) {
+		getter = () => source.value;
+		forceTrigger = isShallow(source);
+	} else if (isReactive(source)) {
+		getter = () => reactiveGetter(source);
+		forceTrigger = true;
+	} else if (isArray(source)) {
+		isMultiSource = true;
+		forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
+		getter = () => source.map((s) => {
+			if (isRef(s)) return s.value;
+			else if (isReactive(s)) return reactiveGetter(s);
+			else if (isFunction(s)) return callWithErrorHandling(s, instance, 2);
+			else warnInvalidSource(s);
+		});
+	} else if (isFunction(source)) if (cb) getter = () => callWithErrorHandling(source, instance, 2);
+	else getter = () => {
+		if (cleanup) cleanup();
+		return callWithAsyncErrorHandling(source, instance, 3, [onCleanup]);
+	};
+	else {
+		getter = NOOP;
+		warnInvalidSource(source);
+	}
+	if (cb && deep) {
+		const baseGetter = getter;
+		getter = () => traverse(baseGetter());
+	}
+	let cleanup;
+	let onCleanup = (fn) => {
+		cleanup = effect2.onStop = () => {
+			callWithErrorHandling(fn, instance, 4);
+			cleanup = effect2.onStop = void 0;
+		};
+	};
+	let ssrCleanup;
+	if (isInSSRComponentSetup) {
+		onCleanup = NOOP;
+		if (!cb) getter();
+		else if (immediate) callWithAsyncErrorHandling(cb, instance, 3, [
+			getter(),
+			isMultiSource ? [] : void 0,
+			onCleanup
+		]);
+		if (flush === "sync") {
+			const ctx = useSSRContext();
+			ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
+		} else return NOOP;
+	}
+	let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
+	const job = () => {
+		if (!effect2.active || !effect2.dirty) return;
+		if (cb) {
+			const newValue = effect2.run();
+			if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || false) {
+				if (cleanup) cleanup();
+				callWithAsyncErrorHandling(cb, instance, 3, [
+					newValue,
+					oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
+					onCleanup
+				]);
+				oldValue = newValue;
+			}
+		} else effect2.run();
+	};
+	job.allowRecurse = !!cb;
+	let scheduler;
+	if (flush === "sync") scheduler = job;
+	else if (flush === "post") scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
+	else {
+		job.pre = true;
+		if (instance) job.id = instance.uid;
+		scheduler = () => queueJob(job);
+	}
+	const effect2 = new ReactiveEffect(getter, NOOP, scheduler);
+	const scope = getCurrentScope();
+	const unwatch = () => {
+		effect2.stop();
+		if (scope) remove(scope.effects, effect2);
+	};
+	effect2.onTrack = onTrack;
+	effect2.onTrigger = onTrigger;
+	if (cb) if (immediate) job();
+	else oldValue = effect2.run();
+	else if (flush === "post") queuePostRenderEffect(effect2.run.bind(effect2), instance && instance.suspense);
+	else effect2.run();
+	if (ssrCleanup) ssrCleanup.push(unwatch);
+	return unwatch;
+}
+function instanceWatch(source, value, options) {
+	const publicThis = this.proxy;
+	const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
+	let cb;
+	if (isFunction(value)) cb = value;
+	else {
+		cb = value.handler;
+		options = value;
+	}
+	const reset = setCurrentInstance(this);
+	const res = doWatch(getter, cb.bind(publicThis), options);
+	reset();
+	return res;
+}
+function createPathGetter(ctx, path) {
+	const segments = path.split(".");
+	return () => {
+		let cur = ctx;
+		for (let i = 0; i < segments.length && cur; i++) cur = cur[segments[i]];
+		return cur;
+	};
+}
+function traverse(value, depth, currentDepth = 0, seen) {
+	if (!isObject(value) || value["__v_skip"]) return value;
+	if (depth && depth > 0) {
+		if (currentDepth >= depth) return value;
+		currentDepth++;
+	}
+	seen = seen || /* @__PURE__ */ new Set();
+	if (seen.has(value)) return value;
+	seen.add(value);
+	if (isRef(value)) traverse(value.value, depth, currentDepth, seen);
+	else if (isArray(value)) for (let i = 0; i < value.length; i++) traverse(value[i], depth, currentDepth, seen);
+	else if (isSet(value) || isMap(value)) value.forEach((v) => {
+		traverse(v, depth, currentDepth, seen);
+	});
+	else if (isPlainObject$1(value)) for (const key in value) traverse(value[key], depth, currentDepth, seen);
+	return value;
+}
+var leaveCbKey = Symbol("_leaveCb");
+var enterCbKey = Symbol("_enterCb");
+function injectHook(type, hook, target = currentInstance, prepend = false) {
+	if (target) {
+		const hooks = target[type] || (target[type] = []);
+		const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
+			if (target.isUnmounted) return;
+			pauseTracking();
+			const reset = setCurrentInstance(target);
+			const res = callWithAsyncErrorHandling(hook, target, type, args);
+			reset();
+			resetTracking();
+			return res;
+		});
+		if (prepend) hooks.unshift(wrappedHook);
+		else hooks.push(wrappedHook);
+		return wrappedHook;
+	} else {
+		const apiName = toHandlerKey(ErrorTypeStrings[type].replace(/ hook$/, ""));
+		warn2(`${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup(). If you are using async setup(), make sure to register lifecycle hooks before the first await statement.`);
+	}
+}
+var createHook = (lifecycle) => (hook, target = currentInstance) => (!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, (...args) => hook(...args), target);
+var onBeforeMount = createHook("bm");
+var onMounted = createHook("m");
+var onBeforeUpdate = createHook("bu");
+var onUpdated = createHook("u");
+var onBeforeUnmount = createHook("bum");
+var onUnmounted = createHook("um");
+var onServerPrefetch = createHook("sp");
+var onRenderTriggered = createHook("rtg");
+var onRenderTracked = createHook("rtc");
+var NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
+var getPublicInstance = (i) => {
+	if (!i) return null;
+	if (isStatefulComponent(i)) return getExposeProxy(i) || i.proxy;
+	return getPublicInstance(i.parent);
+};
+var publicPropertiesMap = /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {
+	$: (i) => i,
+	$el: (i) => i.vnode.el,
+	$data: (i) => i.data,
+	$props: (i) => shallowReadonly(i.props),
+	$attrs: (i) => shallowReadonly(i.attrs),
+	$slots: (i) => shallowReadonly(i.slots),
+	$refs: (i) => shallowReadonly(i.refs),
+	$parent: (i) => getPublicInstance(i.parent),
+	$root: (i) => getPublicInstance(i.root),
+	$emit: (i) => i.emit,
+	$options: (i) => resolveMergedOptions(i),
+	$forceUpdate: (i) => i.f || (i.f = () => {
+		i.effect.dirty = true;
+		queueJob(i.update);
+	}),
+	$nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
+	$watch: (i) => instanceWatch.bind(i)
+});
+var isReservedPrefix = (key) => key === "_" || key === "$";
+var hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
+var PublicInstanceProxyHandlers = {
+	get({ _: instance }, key) {
+		const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
+		if (key === "__isVue") return true;
+		let normalizedProps;
+		if (key[0] !== "$") {
+			const n = accessCache[key];
+			if (n !== void 0) switch (n) {
+				case 1: return setupState[key];
+				case 2: return data[key];
+				case 4: return ctx[key];
+				case 3: return props[key];
+			}
+			else if (hasSetupBinding(setupState, key)) {
+				accessCache[key] = 1;
+				return setupState[key];
+			} else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+				accessCache[key] = 2;
+				return data[key];
+			} else if ((normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)) {
+				accessCache[key] = 3;
+				return props[key];
+			} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+				accessCache[key] = 4;
+				return ctx[key];
+			} else if (shouldCacheAccess) accessCache[key] = 0;
+		}
+		const publicGetter = publicPropertiesMap[key];
+		let cssModule, globalProperties;
+		if (publicGetter) {
+			if (key === "$attrs") {
+				track(instance, "get", key);
+				markAttrsAccessed();
+			} else if (key === "$slots") track(instance, "get", key);
+			return publicGetter(instance);
+		} else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) return cssModule;
+		else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+			accessCache[key] = 4;
+			return ctx[key];
+		} else if (globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)) return globalProperties[key];
+		else if (currentRenderingInstance && (!isString(key) || key.indexOf("__v") !== 0)) {
+			if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(data, key)) warn2(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`);
+			else if (instance === currentRenderingInstance) warn2(`Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`);
+		}
+	},
+	set({ _: instance }, key, value) {
+		const { data, setupState, ctx } = instance;
+		if (hasSetupBinding(setupState, key)) {
+			setupState[key] = value;
+			return true;
+		} else if (setupState.__isScriptSetup && hasOwn(setupState, key)) {
+			warn2(`Cannot mutate <script setup> binding "${key}" from Options API.`);
+			return false;
+		} else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+			data[key] = value;
+			return true;
+		} else if (hasOwn(instance.props, key)) {
+			warn2(`Attempting to mutate prop "${key}". Props are readonly.`);
+			return false;
+		}
+		if (key[0] === "$" && key.slice(1) in instance) {
+			warn2(`Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.`);
+			return false;
+		} else if (key in instance.appContext.config.globalProperties) Object.defineProperty(ctx, key, {
+			enumerable: true,
+			configurable: true,
+			value
+		});
+		else ctx[key] = value;
+		return true;
+	},
+	has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {
+		let normalizedProps;
+		return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
+	},
+	defineProperty(target, key, descriptor) {
+		if (descriptor.get != null) target._.accessCache[key] = 0;
+		else if (hasOwn(descriptor, "value")) this.set(target, key, descriptor.value, null);
+		return Reflect.defineProperty(target, key, descriptor);
+	}
+};
+PublicInstanceProxyHandlers.ownKeys = (target) => {
+	warn2(`Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead.`);
+	return Reflect.ownKeys(target);
+};
+function normalizePropsOrEmits(props) {
+	return isArray(props) ? props.reduce((normalized, p) => (normalized[p] = null, normalized), {}) : props;
+}
+var shouldCacheAccess = true;
+function resolveMergedOptions(instance) {
+	const base = instance.type;
+	const { mixins, extends: extendsOptions } = base;
+	const { mixins: globalMixins, optionsCache: cache, config: { optionMergeStrategies } } = instance.appContext;
+	const cached = cache.get(base);
+	let resolved;
+	if (cached) resolved = cached;
+	else if (!globalMixins.length && !mixins && !extendsOptions) resolved = base;
+	else {
+		resolved = {};
+		if (globalMixins.length) globalMixins.forEach((m$1) => mergeOptions(resolved, m$1, optionMergeStrategies, true));
+		mergeOptions(resolved, base, optionMergeStrategies);
+	}
+	if (isObject(base)) cache.set(base, resolved);
+	return resolved;
+}
+function mergeOptions(to, from, strats, asMixin = false) {
+	const { mixins, extends: extendsOptions } = from;
+	if (extendsOptions) mergeOptions(to, extendsOptions, strats, true);
+	if (mixins) mixins.forEach((m$1) => mergeOptions(to, m$1, strats, true));
+	for (const key in from) if (asMixin && key === "expose") warn2(`"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.`);
+	else {
+		const strat = internalOptionMergeStrats[key] || strats && strats[key];
+		to[key] = strat ? strat(to[key], from[key]) : from[key];
+	}
+	return to;
+}
+var internalOptionMergeStrats = {
+	data: mergeDataFn,
+	props: mergeEmitsOrPropsOptions,
+	emits: mergeEmitsOrPropsOptions,
+	methods: mergeObjectOptions,
+	computed: mergeObjectOptions,
+	beforeCreate: mergeAsArray,
+	created: mergeAsArray,
+	beforeMount: mergeAsArray,
+	mounted: mergeAsArray,
+	beforeUpdate: mergeAsArray,
+	updated: mergeAsArray,
+	beforeDestroy: mergeAsArray,
+	beforeUnmount: mergeAsArray,
+	destroyed: mergeAsArray,
+	unmounted: mergeAsArray,
+	activated: mergeAsArray,
+	deactivated: mergeAsArray,
+	errorCaptured: mergeAsArray,
+	serverPrefetch: mergeAsArray,
+	components: mergeObjectOptions,
+	directives: mergeObjectOptions,
+	watch: mergeWatchOptions,
+	provide: mergeDataFn,
+	inject: mergeInject
+};
+function mergeDataFn(to, from) {
+	if (!from) return to;
+	if (!to) return from;
+	return function mergedDataFn() {
+		return extend(isFunction(to) ? to.call(this, this) : to, isFunction(from) ? from.call(this, this) : from);
+	};
+}
+function mergeInject(to, from) {
+	return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
+}
+function normalizeInject(raw) {
+	if (isArray(raw)) {
+		const res = {};
+		for (let i = 0; i < raw.length; i++) res[raw[i]] = raw[i];
+		return res;
+	}
+	return raw;
+}
+function mergeAsArray(to, from) {
+	return to ? [...new Set([].concat(to, from))] : from;
+}
+function mergeObjectOptions(to, from) {
+	return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
+}
+function mergeEmitsOrPropsOptions(to, from) {
+	if (to) {
+		if (isArray(to) && isArray(from)) return [.../* @__PURE__ */ new Set([...to, ...from])];
+		return extend(/* @__PURE__ */ Object.create(null), normalizePropsOrEmits(to), normalizePropsOrEmits(from ?? {}));
+	} else return from;
+}
+function mergeWatchOptions(to, from) {
+	if (!to) return from;
+	if (!from) return to;
+	const merged = extend(/* @__PURE__ */ Object.create(null), to);
+	for (const key in from) merged[key] = mergeAsArray(to[key], from[key]);
+	return merged;
+}
+function createAppContext() {
+	return {
+		app: null,
+		config: {
+			isNativeTag: NO,
+			performance: false,
+			globalProperties: {},
+			optionMergeStrategies: {},
+			errorHandler: void 0,
+			warnHandler: void 0,
+			compilerOptions: {}
+		},
+		mixins: [],
+		components: {},
+		directives: {},
+		provides: /* @__PURE__ */ Object.create(null),
+		optionsCache: /* @__PURE__ */ new WeakMap(),
+		propsCache: /* @__PURE__ */ new WeakMap(),
+		emitsCache: /* @__PURE__ */ new WeakMap()
+	};
+}
+var currentApp = null;
+function inject(key, defaultValue, treatDefaultAsFactory = false) {
+	const instance = currentInstance || currentRenderingInstance;
+	if (instance || currentApp) {
+		const provides = instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : currentApp._context.provides;
+		if (provides && key in provides) return provides[key];
+		else if (arguments.length > 1) return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
+		else warn2(`injection "${String(key)}" not found.`);
+	} else warn2(`inject() can only be used inside setup() or functional components.`);
+}
+var queuePostRenderEffect = queueEffectWithSuspense;
+function queueEffectWithSuspense(fn, suspense) {
+	if (suspense && suspense.pendingBranch) if (isArray(fn)) suspense.effects.push(...fn);
+	else suspense.effects.push(fn);
+	else queuePostFlushCb(fn);
+}
+var Fragment = Symbol.for("v-fgt");
+var Text = Symbol.for("v-txt");
+var Comment = Symbol.for("v-cmt");
+var Static = Symbol.for("v-stc");
+var emptyAppContext = createAppContext();
+var currentInstance = null;
+var internalSetCurrentInstance;
+var setInSSRSetupState;
+{
+	const g$1 = getGlobalThis();
+	const registerGlobalSetter = (key, setter) => {
+		let setters;
+		if (!(setters = g$1[key])) setters = g$1[key] = [];
+		setters.push(setter);
+		return (v) => {
+			if (setters.length > 1) setters.forEach((set2) => set2(v));
+			else setters[0](v);
+		};
+	};
+	internalSetCurrentInstance = registerGlobalSetter(`__VUE_INSTANCE_SETTERS__`, (v) => currentInstance = v);
+	setInSSRSetupState = registerGlobalSetter(`__VUE_SSR_SETTERS__`, (v) => isInSSRComponentSetup = v);
+}
+var setCurrentInstance = (instance) => {
+	const prev = currentInstance;
+	internalSetCurrentInstance(instance);
+	instance.scope.on();
+	return () => {
+		instance.scope.off();
+		internalSetCurrentInstance(prev);
+	};
+};
+function isStatefulComponent(instance) {
+	return instance.vnode.shapeFlag & 4;
+}
+var isInSSRComponentSetup = false;
+function getExposeProxy(instance) {
+	if (instance.exposed) return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
+		get(target, key) {
+			if (key in target) return target[key];
+			else if (key in publicPropertiesMap) return publicPropertiesMap[key](instance);
+		},
+		has(target, key) {
+			return key in target || key in publicPropertiesMap;
+		}
+	}));
+}
+var classifyRE = /(?:^|[-_])(\w)/g;
+var classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
+function getComponentName(Component, includeInferred = true) {
+	return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
+}
+function formatComponentName(instance, Component, isRoot = false) {
+	let name = getComponentName(Component);
+	if (!name && Component.__file) {
+		const match = Component.__file.match(/([^/\\]+)\.\w+$/);
+		if (match) name = match[1];
+	}
+	if (!name && instance && instance.parent) {
+		const inferFromRegistry = (registry) => {
+			for (const key in registry) if (registry[key] === Component) return key;
+		};
+		name = inferFromRegistry(instance.components || instance.parent.type.components) || inferFromRegistry(instance.appContext.components);
+	}
+	return name ? classify(name) : isRoot ? `App` : `Anonymous`;
+}
+function isClassComponent(value) {
+	return isFunction(value) && "__vccOpts" in value;
+}
+var computed2 = (getterOrOptions, debugOptions) => {
+	return computed(getterOrOptions, debugOptions, isInSSRComponentSetup);
+};
+/*! #__NO_SIDE_EFFECTS__ */
+
+//#endregion
+//#region src/rootStore.ts
+/**
+* Get the currently active pinia if there is any.
+*/
+const getActivePinia = () => activePinia;
+let activePinia;
+function setActivePinia(_pinia) {
+	activePinia = _pinia;
+}
+
+//#endregion
+//#region src/createPinia.ts
+/**
+* Creates a Pinia instance to be used by the application
+*/
+function createPinia() {
+	const scope = effectScope(true);
+	const state = scope.run(() => ref({}));
+	const _p = [];
+	const pinia = markRaw({
+		use(plugin) {
+			_p.push(plugin);
+			return this;
+		},
+		_p,
+		_e: scope,
+		_s: /* @__PURE__ */ new Map(),
+		state
+	});
+	setActivePinia(pinia);
+	return pinia;
+}
+
+//#endregion
+//#region src/subscription.ts
+const noop$1 = () => {};
+function addSubscription(activeComponentCleanUp$1, subscriptions, callback, detached, onCleanup = noop$1) {
+	subscriptions.add(callback);
+	const removeSubscription = () => {
+		subscriptions.delete(callback);
+		onCleanup();
+	};
+	if (!detached) activeComponentCleanUp$1[0].push(removeSubscription);
+	return removeSubscription;
+}
+function triggerSubscriptions(subscriptions, ...args) {
+	subscriptions.forEach((callback) => {
+		callback(...args);
+	});
+}
+
+//#endregion
+//#region src/types.ts
+/**
+* Possible types for SubscriptionCallback
+*/
+let MutationType = /* @__PURE__ */ function(MutationType$1) {
+	/**
+	* Direct mutation of the state:
+	*
+	* - `store.name = 'new name'`
+	* - `store.$state.name = 'new name'`
+	* - `store.list.push('new item')`
+	*/
+	MutationType$1["direct"] = "direct";
+	/**
+	* Mutated the state with `$patch` and an object
+	*
+	* - `store.$patch({ name: 'newName' })`
+	*/
+	MutationType$1["patchObject"] = "patch object";
+	/**
+	* Mutated the state with `$patch` and a function
+	*
+	* - `store.$patch(state => state.name = 'newName')`
+	*/
+	MutationType$1["patchFunction"] = "patch function";
+	return MutationType$1;
+}({});
+
+//#endregion
+//#region ../../node_modules/.pnpm/savage-types@1.0.20/node_modules/savage-types/dist/index.js
+function o(t) {
+	return Object.prototype.toString.call(t).slice(8, -1) === "Array";
+}
+function G(t) {
+	return Object.prototype.toString.call(t).slice(8, -1) === "Object";
+}
+function _(t) {
+	return Object.prototype.toString.call(t).slice(8, -1) === "Null";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/savage-utils@1.0.65/node_modules/savage-utils/dist/index.js
+var a = class {
+	constructor(e = {}) {
+		this.subscribeList = {};
+		this.pubAndNoSub = {};
+		return Object.assign(this, e);
+	}
+	subscribe(e, t) {
+		var s;
+		this.pubAndNoSub[e] && (t(this.pubAndNoSub[e]), Reflect.deleteProperty(this.pubAndNoSub, e)), (s = this.subscribeList[e]) != null && s.push(t) || (this.subscribeList[e] = [t]);
+	}
+	publish(e, t) {
+		let s = this.subscribeList[e];
+		!s || s.length === 0 ? this.pubAndNoSub[e] = t : s.forEach((r) => r(t));
+	}
+	remove(e, t) {
+		let s = this.subscribeList[e];
+		!s || s.length === 0 || (t ? s.forEach((r, o$1) => {
+			r === t && this.subscribeList[e].splice(o$1, 1);
+		}) : this.subscribeList[e] = []);
+	}
+}, D = new a();
+var b = class {
+	constructor() {
+		this.copyShallow = (e) => this.copy(e, "shallow");
+		this.copyDeep = (e) => this.copy(e, "deep");
+	}
+	copy(e, t) {
+		if (typeof e == "object" && e !== null) {
+			let s = Reflect.construct(e.constructor, []);
+			return Object.keys(e).forEach((r) => {
+				s[r] = t === "shallow" ? e[r] : this.copy(e[r], "deep");
+			}), s;
+		}
+		return e;
+	}
+}, { copyShallow: Q, copyDeep: g } = new b();
+var T = class {
+	constructor() {
+		this.compareShallow = (e, t) => this.compare(e, t, "shallow");
+		this.compareDeep = (e, t) => this.compare(e, t, "deep");
+	}
+	compare(e, t, s) {
+		if (e === t) return !0;
+		if (!G(e) || _(e) || !G(t) || _(t)) return !1;
+		let r = Object.keys(e).length, o$1 = Object.keys(t).length;
+		if (r !== o$1) return !1;
+		for (let l of Object.keys(e)) {
+			let c = l;
+			if (s === "shallow" && e[c] !== t[c]) return !1;
+			if (s === "deep") {
+				let i = this.compare(e[c], t[c], "deep");
+				if (!i) return i;
+			}
+		}
+		return !0;
+	}
+}, { compareShallow: X, compareDeep: Y } = new T();
+var m = class {
+	constructor() {
+		this.mergeShallow = (e, ...t) => this.merge(e, "shallow", ...t);
+		this.mergeDeep = (e, ...t) => this.merge(e, "deep", ...t);
+	}
+	merge(e, t, ...s) {
+		if (o(s)) {
+			for (; s.length > 0;) {
+				let r = s.pop();
+				if (!G(r)) return e;
+				Reflect.ownKeys(r).forEach((o$1) => {
+					if (t === "shallow") e[o$1] = r[o$1];
+					else {
+						if (!Reflect.has(e, o$1) || !G(r[o$1])) return e[o$1] = g(r[o$1]);
+						this.merge(e[o$1], "deep", r[o$1]);
+					}
+				});
+			}
+			return e;
+		}
+		return e;
+	}
+}, { mergeShallow: oe, mergeDeep: ie } = new m();
+
+//#endregion
+//#region src/utils.ts
+function noop() {
+	return {};
+}
+function isPlainObject(o$1) {
+	return o$1 && typeof o$1 === "object" && Object.prototype.toString.call(o$1) === "[object Object]" && typeof o$1.toJSON !== "function";
+}
+function mergeReactiveObjects(target, patchToApply) {
+	if (target instanceof Map && patchToApply instanceof Map) patchToApply.forEach((value, key) => target.set(key, value));
+	if (target instanceof Set && patchToApply instanceof Set) patchToApply.forEach(target.add, target);
+	for (const key in patchToApply) {
+		if (!Object.hasOwn(patchToApply, key)) continue;
+		const subPatch = patchToApply[key];
+		const targetValue = target[key];
+		if (isPlainObject(targetValue) && isPlainObject(subPatch) && target.hasOwnProperty(key) && !isRef(subPatch) && !isReactive(subPatch)) target[key] = mergeReactiveObjects(targetValue, subPatch);
+		else target[key] = subPatch;
+	}
+	return target;
+}
+
+//#endregion
+//#region src/store.ts
+/**
+* Marks a function as an action for `$onAction`
+* @internal
+*/
+const ACTION_MARKER = Symbol();
+/**
+* Action name symbol. Allows to add a name to an action after defining it
+* @internal
+*/
+const ACTION_NAME = Symbol();
+const { assign } = Object;
+function createOptionsStore(id, options, pinia) {
+	const { state, actions, getters } = options;
+	const initialState = pinia.state.value[id];
+	let store;
+	function setup() {
+		if (!initialState) pinia.state.value[id] = state ? state() : {};
+		const localState = toRefs(pinia.state.value[id]);
+		return assign(localState, actions, Object.keys(getters || {}).reduce((computedGetters, name) => {
+			if (name in localState) console.warn(`[🍍]: A getter cannot have the same name as another state property. Rename one of them. Found with "${name}" in store "${id}".`);
+			computedGetters[name] = markRaw(computed2(() => {
+				setActivePinia(pinia);
+				const store$1 = pinia._s.get(id);
+				return getters[name].call(store$1, store$1);
+			}));
+			return computedGetters;
+		}, {}));
+	}
+	store = createSetupStore(id, setup, options, pinia);
+	return store;
+}
+function createSetupStore($id, setup, options = {}, pinia) {
+	let scope;
+	const optionsForPlugin = assign({ actions: {} }, options);
+	const $subscribeOptions = { deep: true };
+	let isListening;
+	let isSyncListening;
+	const subscriptions = /* @__PURE__ */ new Set();
+	const actionSubscriptions = /* @__PURE__ */ new Set();
+	const debuggerEvents = [];
+	let activeListener;
+	function $patch(partialStateOrMutator) {
+		let subscriptionMutation;
+		isListening = isSyncListening = false;
+		/* istanbul ignore else */
+		if (typeof partialStateOrMutator === "function") {
+			partialStateOrMutator(pinia.state.value[$id]);
+			subscriptionMutation = {
+				type: MutationType.patchFunction,
+				storeId: $id,
+				events: debuggerEvents
+			};
+		} else {
+			mergeReactiveObjects(pinia.state.value[$id], partialStateOrMutator);
+			subscriptionMutation = {
+				type: MutationType.patchObject,
+				payload: partialStateOrMutator,
+				storeId: $id,
+				events: debuggerEvents
+			};
+		}
+		activeListener = Symbol();
+		const myListenerId = activeListener;
+		nextTick().then(() => {
+			if (activeListener === myListenerId) isListening = true;
+		});
+		isSyncListening = true;
+		triggerSubscriptions(subscriptions, subscriptionMutation, pinia.state.value[$id]);
+	}
+	const $reset = function $reset$1() {
+		const { state } = options;
+		const newState = state ? state() : {};
+		this.$patch(($state) => {
+			assign($state, newState);
+		});
+	};
+	/**
+	* Helper that wraps function so it can be tracked with $onAction
+	* @param fn - action to wrap
+	* @param name - name of the action
+	*/
+	const action = (fn, name = "") => {
+		if (ACTION_MARKER in fn) {
+			fn[ACTION_NAME] = name;
+			return fn;
+		}
+		const wrappedAction = function() {
+			setActivePinia(pinia);
+			const args = Array.from(arguments);
+			const afterCallbackSet = /* @__PURE__ */ new Set();
+			const onErrorCallbackSet = /* @__PURE__ */ new Set();
+			function after(callback) {
+				afterCallbackSet.add(callback);
+			}
+			function onError(callback) {
+				onErrorCallbackSet.add(callback);
+			}
+			triggerSubscriptions(actionSubscriptions, {
+				args,
+				name: wrappedAction[ACTION_NAME],
+				store,
+				after,
+				onError
+			});
+			let ret;
+			try {
+				ret = fn.apply(this && this.$id === $id ? this : store, args);
+			} catch (error) {
+				triggerSubscriptions(onErrorCallbackSet, error);
+				throw error;
+			}
+			if (ret instanceof Promise) return ret.then((value) => {
+				triggerSubscriptions(afterCallbackSet, value);
+				return value;
+			}).catch((error) => {
+				triggerSubscriptions(onErrorCallbackSet, error);
+				return Promise.reject(error);
+			});
+			triggerSubscriptions(afterCallbackSet, ret);
+			return ret;
+		};
+		wrappedAction[ACTION_MARKER] = true;
+		wrappedAction[ACTION_NAME] = name;
+		return wrappedAction;
+	};
+	const partialStore = {
+		_p: pinia,
+		$id,
+		$onAction: addSubscription.bind(null, activeComponentCleanUp, actionSubscriptions),
+		$patch,
+		$reset,
+		$subscribe(callback, options$1 = {}) {
+			const removeSubscription = addSubscription([[]], subscriptions, callback, options$1.detached, () => stopWatcher());
+			const stopWatcher = scope.run(() => watch(() => pinia.state.value[$id], (state) => {
+				if (options$1.flush === "sync" ? isSyncListening : isListening) callback({
+					storeId: $id,
+					type: MutationType.direct,
+					events: debuggerEvents
+				}, state);
+			}, assign({}, $subscribeOptions, options$1)));
+			return removeSubscription;
+		}
+	};
+	const store = reactive(partialStore);
+	pinia._s.set($id, store);
+	scope = effectScope();
+	const setupStore = scope.run(() => setup({ action }));
+	for (const key in setupStore) {
+		const prop = setupStore[key];
+		if (typeof prop === "function") {
+			const actionValue = action(prop, key);
+			setupStore[key] = actionValue;
+			optionsForPlugin.actions[key] = prop;
+		}
+	}
+	assign(store, setupStore);
+	assign(toRaw(store), setupStore);
+	Object.defineProperty(store, "$state", {
+		get: () => pinia.state.value[$id],
+		set: (state) => {
+			$patch(($state) => {
+				assign($state, state);
+			});
+		}
+	});
+	pinia._p.forEach((extender) => {
+		assign(store, scope.run(() => extender({
+			store,
+			pinia,
+			options: optionsForPlugin
+		})));
+	});
+	isListening = true;
+	isSyncListening = true;
+	return store;
+}
+const activeComponentCleanUp = [[]];
+/**
+* Creates a `useStore` function that retrieves the store instance
+*
+* @param id - id of the store (must be unique)
+* @param options - options to define the store
+*/
+function defineStore(id, options) {
+	const effectMap = /* @__PURE__ */ new WeakMap();
+	const subscribeMap = /* @__PURE__ */ new WeakMap();
+	const cleanUpMap = /* @__PURE__ */ new WeakMap();
+	function useStore(pinia) {
+		if (pinia) setActivePinia(pinia);
+		if (!activePinia) throw new Error(`[🍍]: "getActivePinia()" was called but there was no active Pinia. Are you trying to use a store before calling "createPinia()"?\n`);
+		pinia = activePinia;
+		const lastEffect = activeEffect.value;
+		activeEffect.value = void 0;
+		if (!pinia._s.has(id)) createOptionsStore(id, options, pinia);
+		activeEffect.value = lastEffect;
+		const store = pinia._s.get(id);
+		const _id = useRef([useId()]);
+		const storeSnapshotRef = useRef({ ...store });
+		const isCollectDep = useRef(false);
+		if (!cleanUpMap.get(_id.current)) cleanUpMap.set(_id.current, []);
+		activeComponentCleanUp[0] = cleanUpMap.get(_id.current);
+		useEffect(() => {
+			activeComponentCleanUp[0] = cleanUpMap.get(_id.current);
+			return () => {
+				cleanUpMap.get(_id.current).forEach((fn) => {
+					fn();
+				});
+			};
+		}, []);
+		const subscribe = useCallback((onStoreChange) => {
+			subscribeMap.set(_id.current, onStoreChange);
+			return () => {
+				const effect$1 = effectMap.get(_id.current);
+				if (effect$1) effect$1.stop();
+				subscribeMap.delete(_id.current);
+				effectMap.delete(_id.current);
+			};
+		}, []);
+		useSyncExternalStore(subscribe, () => storeSnapshotRef.current, () => storeSnapshotRef.current);
+		let effect = effectMap.get(_id.current);
+		if (!effect) {
+			const fn = () => {
+				const onStoreChange = subscribeMap.get(_id.current);
+				if (!isCollectDep.current) {
+					storeSnapshotRef.current = { ...store };
+					onStoreChange?.();
+				}
+			};
+			effect = new ReactiveEffect(fn, noop, () => {
+				if (effect?.dirty) effect.run();
+			});
+			activeEffect.value = effect;
+			isCollectDep.current = true;
+			effect.run();
+			effectMap.set(_id.current, effect);
+			isCollectDep.current = false;
+		}
+		return store;
+	}
+	useStore.$id = id;
+	useStore.$getStore = (pinia) => {
+		if (pinia) setActivePinia(pinia);
+		pinia = activePinia;
+		if (!pinia._s.has(id)) createOptionsStore(id, options, pinia);
+		const store = pinia._s.get(id);
+		return store;
+	};
+	return useStore;
+}
+
+//#endregion
+export { MutationType, createPinia, defineStore, getActivePinia, setActivePinia };