nuxt-intlayer 6.1.6 → 7.0.0-canary.3

package/dist/esm/node_modules/.bun/@vue_runtime-core@3.5.22/node_modules/@vue/runtime-core/dist/runtime-core.cjs.mjs

@@ -0,0 +1,867 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_shared } from "../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/index.mjs";
+import { require_reactivity } from "../../../../../@vue_reactivity@3.5.22/node_modules/@vue/reactivity/index.mjs";
+
+//#region ../../node_modules/.bun/@vue+runtime-core@3.5.22/node_modules/@vue/runtime-core/dist/runtime-core.cjs.js
+var require_runtime_core_cjs = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/@vue+runtime-core@3.5.22/node_modules/@vue/runtime-core/dist/runtime-core.cjs.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var reactivity = require_reactivity();
+	var shared = require_shared();
+	const stack = [];
+	function pushWarningContext(vnode) {
+		stack.push(vnode);
+	}
+	function popWarningContext() {
+		stack.pop();
+	}
+	let isWarning = false;
+	function warn$1(msg, ...args) {
+		if (isWarning) return;
+		isWarning = true;
+		reactivity.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.map((a) => {
+				var _a, _b;
+				return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
+			}).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);
+		}
+		reactivity.resetTracking();
+		isWarning = false;
+	}
+	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 (shared.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 (reactivity.isRef(value)) {
+			value = formatProp(key, reactivity.toRaw(value.value), true);
+			return raw ? value : [
+				`${key}=Ref<`,
+				value,
+				`>`
+			];
+		} else if (shared.isFunction(value)) return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+		else {
+			value = reactivity.toRaw(value);
+			return raw ? value : [`${key}=`, value];
+		}
+	}
+	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(fn, instance, type, args) {
+		try {
+			return args ? fn(...args) : fn();
+		} catch (err) {
+			handleError(err, instance, type);
+		}
+	}
+	function callWithAsyncErrorHandling(fn, instance, type, args) {
+		if (shared.isFunction(fn)) {
+			const res = callWithErrorHandling(fn, instance, type, args);
+			if (res && shared.isPromise(res)) res.catch((err) => {
+				handleError(err, instance, type);
+			});
+			return res;
+		}
+		if (shared.isArray(fn)) {
+			const values = [];
+			for (let i = 0; i < fn.length; i++) values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
+			return values;
+		} else warn$1(`Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`);
+	}
+	function handleError(err, instance, type, throwInDev = true) {
+		const contextVNode = instance ? instance.vnode : null;
+		const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || shared.EMPTY_OBJ;
+		if (instance) {
+			let cur = instance.parent;
+			const exposedInstance = instance.proxy;
+			const errorInfo = ErrorTypeStrings$1[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;
+			}
+			if (errorHandler) {
+				reactivity.pauseTracking();
+				callWithErrorHandling(errorHandler, null, 10, [
+					err,
+					exposedInstance,
+					errorInfo
+				]);
+				reactivity.resetTracking();
+				return;
+			}
+		}
+		logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
+	}
+	function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
+		{
+			const info = ErrorTypeStrings$1[type];
+			if (contextVNode) pushWarningContext(contextVNode);
+			warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+			if (contextVNode) popWarningContext();
+			if (throwInDev) throw err;
+			else console.error(err);
+		}
+	}
+	const queue = [];
+	let flushIndex = -1;
+	const pendingPostFlushCbs = [];
+	let activePostFlushCbs = null;
+	let postFlushIndex = 0;
+	const resolvedPromise = /* @__PURE__ */ Promise.resolve();
+	let currentFlushPromise = null;
+	const 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.flags & 2) start = middle + 1;
+			else end = middle;
+		}
+		return start;
+	}
+	function queueJob(job) {
+		if (!(job.flags & 1)) {
+			const jobId = getId(job);
+			const lastJob = queue[queue.length - 1];
+			if (!lastJob || !(job.flags & 2) && jobId >= getId(lastJob)) queue.push(job);
+			else queue.splice(findInsertionIndex(jobId), 0, job);
+			job.flags |= 1;
+			queueFlush();
+		}
+	}
+	function queueFlush() {
+		if (!currentFlushPromise) currentFlushPromise = resolvedPromise.then(flushJobs);
+	}
+	function queuePostFlushCb(cb) {
+		if (!shared.isArray(cb)) {
+			if (activePostFlushCbs && cb.id === -1) activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
+			else if (!(cb.flags & 1)) {
+				pendingPostFlushCbs.push(cb);
+				cb.flags |= 1;
+			}
+		} else pendingPostFlushCbs.push(...cb);
+		queueFlush();
+	}
+	function flushPostFlushCbs(seen) {
+		if (pendingPostFlushCbs.length) {
+			const deduped = [...new Set(pendingPostFlushCbs)].sort((a, b) => getId(a) - getId(b));
+			pendingPostFlushCbs.length = 0;
+			if (activePostFlushCbs) {
+				activePostFlushCbs.push(...deduped);
+				return;
+			}
+			activePostFlushCbs = deduped;
+			seen = seen || /* @__PURE__ */ new Map();
+			for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+				const cb = activePostFlushCbs[postFlushIndex];
+				if (checkRecursiveUpdates(seen, cb)) continue;
+				if (cb.flags & 4) cb.flags &= -2;
+				if (!(cb.flags & 8)) cb();
+				cb.flags &= -2;
+			}
+			activePostFlushCbs = null;
+			postFlushIndex = 0;
+		}
+	}
+	const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
+	function flushJobs(seen) {
+		seen = seen || /* @__PURE__ */ new Map();
+		const check = (job) => checkRecursiveUpdates(seen, job);
+		try {
+			for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+				const job = queue[flushIndex];
+				if (job && !(job.flags & 8)) {
+					if (check(job)) continue;
+					if (job.flags & 4) job.flags &= -2;
+					callWithErrorHandling(job, job.i, job.i ? 15 : 14);
+					if (!(job.flags & 4)) job.flags &= -2;
+				}
+			}
+		} finally {
+			for (; flushIndex < queue.length; flushIndex++) {
+				const job = queue[flushIndex];
+				if (job) job.flags &= -2;
+			}
+			flushIndex = -1;
+			queue.length = 0;
+			flushPostFlushCbs(seen);
+			currentFlushPromise = null;
+			if (queue.length || pendingPostFlushCbs.length) flushJobs(seen);
+		}
+	}
+	function checkRecursiveUpdates(seen, fn) {
+		const count = seen.get(fn) || 0;
+		if (count > RECURSION_LIMIT) {
+			const instance = fn.i;
+			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;
+		}
+		seen.set(fn, count + 1);
+		return false;
+	}
+	let isHmrUpdating = false;
+	const hmrDirtyComponents = /* @__PURE__ */ new Map();
+	shared.getGlobalThis().__VUE_HMR_RUNTIME__ = {
+		createRecord: tryWrap(createRecord),
+		rerender: tryWrap(rerender),
+		reload: tryWrap(reload)
+	};
+	const 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;
+			if (!(instance.job.flags & 8)) 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 (let i = 0; i < instances.length; i++) {
+			const instance = instances[i];
+			const oldComp = normalizeClassComponent(instance.type);
+			let dirtyInstances = hmrDirtyComponents.get(oldComp);
+			if (!dirtyInstances) {
+				if (oldComp !== record.initialDef) updateComponentDef(oldComp, newComp);
+				hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
+			}
+			dirtyInstances.add(instance);
+			instance.appContext.propsCache.delete(instance.type);
+			instance.appContext.emitsCache.delete(instance.type);
+			instance.appContext.optionsCache.delete(instance.type);
+			if (instance.ceReload) {
+				dirtyInstances.add(instance);
+				instance.ceReload(newComp.styles);
+				dirtyInstances.delete(instance);
+			} else if (instance.parent) queueJob(() => {
+				if (!(instance.job.flags & 8)) {
+					isHmrUpdating = true;
+					instance.parent.update();
+					isHmrUpdating = false;
+					dirtyInstances.delete(instance);
+				}
+			});
+			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.");
+			if (instance.root.ce && instance !== instance.root) instance.root.ce._removeChildStyle(oldComp);
+		}
+		queuePostFlushCb(() => {
+			hmrDirtyComponents.clear();
+		});
+	}
+	function updateComponentDef(oldComp, newComp) {
+		shared.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.`);
+			}
+		};
+	}
+	let currentRenderingInstance = null;
+	const TeleportEndKey = Symbol("_vte");
+	const leaveCbKey = Symbol("_leaveCb");
+	const enterCbKey = Symbol("_enterCb");
+	const requestIdleCallback = shared.getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb, 1));
+	const cancelIdleCallback = shared.getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id));
+	function injectHook(type, hook, target = currentInstance, prepend = false) {
+		if (target) {
+			const hooks = target[type] || (target[type] = []);
+			const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
+				reactivity.pauseTracking();
+				const reset = setCurrentInstance(target);
+				const res = callWithAsyncErrorHandling(hook, target, type, args);
+				reset();
+				reactivity.resetTracking();
+				return res;
+			});
+			if (prepend) hooks.unshift(wrappedHook);
+			else hooks.push(wrappedHook);
+			return wrappedHook;
+		} else warn$1(`${shared.toHandlerKey(ErrorTypeStrings$1[type].replace(/ hook$/, ""))} 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.`);
+	}
+	const createHook = (lifecycle) => (hook, target = currentInstance) => {
+		if (!isInSSRComponentSetup || lifecycle === "sp") injectHook(lifecycle, (...args) => hook(...args), target);
+	};
+	const onBeforeMount = createHook("bm");
+	const onMounted = createHook("m");
+	const onBeforeUpdate = createHook("bu");
+	const onUpdated = createHook("u");
+	const onBeforeUnmount = createHook("bum");
+	const onUnmounted = createHook("um");
+	const onServerPrefetch = createHook("sp");
+	const onRenderTriggered = createHook("rtg");
+	const onRenderTracked = createHook("rtc");
+	const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
+	const getPublicInstance = (i) => {
+		if (!i) return null;
+		if (isStatefulComponent(i)) return getComponentPublicInstance(i);
+		return getPublicInstance(i.parent);
+	};
+	const publicPropertiesMap = /* @__PURE__ */ shared.extend(/* @__PURE__ */ Object.create(null), {
+		$: (i) => i,
+		$el: (i) => i.vnode.el,
+		$data: (i) => i.data,
+		$props: (i) => reactivity.shallowReadonly(i.props),
+		$attrs: (i) => reactivity.shallowReadonly(i.attrs),
+		$slots: (i) => reactivity.shallowReadonly(i.slots),
+		$refs: (i) => reactivity.shallowReadonly(i.refs),
+		$parent: (i) => getPublicInstance(i.parent),
+		$root: (i) => getPublicInstance(i.root),
+		$host: (i) => i.ce,
+		$emit: (i) => i.emit,
+		$options: (i) => resolveMergedOptions(i),
+		$forceUpdate: (i) => i.f || (i.f = () => {
+			queueJob(i.update);
+		}),
+		$nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
+		$watch: (i) => instanceWatch.bind(i)
+	});
+	const isReservedPrefix = (key) => key === "_" || key === "$";
+	const hasSetupBinding = (state, key) => state !== shared.EMPTY_OBJ && !state.__isScriptSetup && shared.hasOwn(state, key);
+	const PublicInstanceProxyHandlers = {
+		get({ _: instance }, key) {
+			if (key === "__v_skip") return true;
+			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 !== shared.EMPTY_OBJ && shared.hasOwn(data, key)) {
+					accessCache[key] = 2;
+					return data[key];
+				} else if ((normalizedProps = instance.propsOptions[0]) && shared.hasOwn(normalizedProps, key)) {
+					accessCache[key] = 3;
+					return props[key];
+				} else if (ctx !== shared.EMPTY_OBJ && shared.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") {
+					reactivity.track(instance.attrs, "get", "");
+					markAttrsAccessed();
+				} else if (key === "$slots") reactivity.track(instance, "get", key);
+				return publicGetter(instance);
+			} else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) return cssModule;
+			else if (ctx !== shared.EMPTY_OBJ && shared.hasOwn(ctx, key)) {
+				accessCache[key] = 4;
+				return ctx[key];
+			} else if (globalProperties = appContext.config.globalProperties, shared.hasOwn(globalProperties, key)) return globalProperties[key];
+			else if (currentRenderingInstance && (!shared.isString(key) || key.indexOf("__v") !== 0)) {
+				if (data !== shared.EMPTY_OBJ && isReservedPrefix(key[0]) && shared.hasOwn(data, key)) warn$1(`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) warn$1(`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 && shared.hasOwn(setupState, key)) {
+				warn$1(`Cannot mutate <script setup> binding "${key}" from Options API.`);
+				return false;
+			} else if (data !== shared.EMPTY_OBJ && shared.hasOwn(data, key)) {
+				data[key] = value;
+				return true;
+			} else if (shared.hasOwn(instance.props, key)) {
+				warn$1(`Attempting to mutate prop "${key}". Props are readonly.`);
+				return false;
+			}
+			if (key[0] === "$" && key.slice(1) in instance) {
+				warn$1(`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, type } }, key) {
+			let normalizedProps, cssModules;
+			return !!(accessCache[key] || data !== shared.EMPTY_OBJ && key[0] !== "$" && shared.hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && shared.hasOwn(normalizedProps, key) || shared.hasOwn(ctx, key) || shared.hasOwn(publicPropertiesMap, key) || shared.hasOwn(appContext.config.globalProperties, key) || (cssModules = type.__cssModules) && cssModules[key]);
+		},
+		defineProperty(target, key, descriptor) {
+			if (descriptor.get != null) target._.accessCache[key] = 0;
+			else if (shared.hasOwn(descriptor, "value")) this.set(target, key, descriptor.value, null);
+			return Reflect.defineProperty(target, key, descriptor);
+		}
+	};
+	PublicInstanceProxyHandlers.ownKeys = (target) => {
+		warn$1(`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 shared.isArray(props) ? props.reduce((normalized, p) => (normalized[p] = null, normalized), {}) : props;
+	}
+	let 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) => mergeOptions(resolved, m, optionMergeStrategies, true));
+			mergeOptions(resolved, base, optionMergeStrategies);
+		}
+		if (shared.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) => mergeOptions(to, m, strats, true));
+		for (const key in from) if (asMixin && key === "expose") warn$1(`"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;
+	}
+	const 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 shared.extend(shared.isFunction(to) ? to.call(this, this) : to, shared.isFunction(from) ? from.call(this, this) : from);
+		};
+	}
+	function mergeInject(to, from) {
+		return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
+	}
+	function normalizeInject(raw) {
+		if (shared.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 ? shared.extend(/* @__PURE__ */ Object.create(null), to, from) : from;
+	}
+	function mergeEmitsOrPropsOptions(to, from) {
+		if (to) {
+			if (shared.isArray(to) && shared.isArray(from)) return [.../* @__PURE__ */ new Set([...to, ...from])];
+			return shared.extend(/* @__PURE__ */ Object.create(null), normalizePropsOrEmits(to), normalizePropsOrEmits(from != null ? from : {}));
+		} else return from;
+	}
+	function mergeWatchOptions(to, from) {
+		if (!to) return from;
+		if (!from) return to;
+		const merged = shared.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: shared.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()
+		};
+	}
+	let currentApp = null;
+	function inject(key, defaultValue, treatDefaultAsFactory = false) {
+		const instance = getCurrentInstance();
+		if (instance || currentApp) {
+			let provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null || instance.ce ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
+			if (provides && key in provides) return provides[key];
+			else if (arguments.length > 1) return treatDefaultAsFactory && shared.isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
+			else warn$1(`injection "${String(key)}" not found.`);
+		} else warn$1(`inject() can only be used inside setup() or functional components.`);
+	}
+	const queuePostRenderEffect = queueEffectWithSuspense;
+	const ssrContextKey = Symbol.for("v-scx");
+	const useSSRContext = () => {
+		{
+			const ctx = inject(ssrContextKey);
+			if (!ctx) warn$1(`Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`);
+			return ctx;
+		}
+	};
+	function doWatch(source, cb, options = shared.EMPTY_OBJ) {
+		const { immediate, deep, flush, once } = options;
+		if (!cb) {
+			if (immediate !== void 0) warn$1(`watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`);
+			if (deep !== void 0) warn$1(`watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`);
+			if (once !== void 0) warn$1(`watch() "once" option is only respected when using the watch(source, callback, options?) signature.`);
+		}
+		const baseWatchOptions = shared.extend({}, options);
+		baseWatchOptions.onWarn = warn$1;
+		const runsImmediately = cb && immediate || !cb && flush !== "post";
+		let ssrCleanup;
+		if (isInSSRComponentSetup) {
+			if (flush === "sync") {
+				const ctx = useSSRContext();
+				ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
+			} else if (!runsImmediately) {
+				const watchStopHandle = () => {};
+				watchStopHandle.stop = shared.NOOP;
+				watchStopHandle.resume = shared.NOOP;
+				watchStopHandle.pause = shared.NOOP;
+				return watchStopHandle;
+			}
+		}
+		const instance = currentInstance;
+		baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
+		let isPre = false;
+		if (flush === "post") baseWatchOptions.scheduler = (job) => {
+			queuePostRenderEffect(job, instance && instance.suspense);
+		};
+		else if (flush !== "sync") {
+			isPre = true;
+			baseWatchOptions.scheduler = (job, isFirstRun) => {
+				if (isFirstRun) job();
+				else queueJob(job);
+			};
+		}
+		baseWatchOptions.augmentJob = (job) => {
+			if (cb) job.flags |= 4;
+			if (isPre) {
+				job.flags |= 2;
+				if (instance) {
+					job.id = instance.uid;
+					job.i = instance;
+				}
+			}
+		};
+		const watchHandle = reactivity.watch(source, cb, baseWatchOptions);
+		if (isInSSRComponentSetup) {
+			if (ssrCleanup) ssrCleanup.push(watchHandle);
+			else if (runsImmediately) watchHandle();
+		}
+		return watchHandle;
+	}
+	function instanceWatch(source, value, options) {
+		const publicThis = this.proxy;
+		const getter = shared.isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
+		let cb;
+		if (shared.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;
+		};
+	}
+	let accessedAttrs = false;
+	function markAttrsAccessed() {
+		accessedAttrs = true;
+	}
+	function queueEffectWithSuspense(fn, suspense) {
+		if (suspense && suspense.pendingBranch) if (shared.isArray(fn)) suspense.effects.push(...fn);
+		else suspense.effects.push(fn);
+		else queuePostFlushCb(fn);
+	}
+	const Fragment = Symbol.for("v-fgt");
+	const Text = Symbol.for("v-txt");
+	const Comment = Symbol.for("v-cmt");
+	const Static = Symbol.for("v-stc");
+	const emptyAppContext = createAppContext();
+	let currentInstance = null;
+	const getCurrentInstance = () => currentInstance || currentRenderingInstance;
+	let internalSetCurrentInstance;
+	let setInSSRSetupState;
+	{
+		const g = shared.getGlobalThis();
+		const registerGlobalSetter = (key, setter) => {
+			let setters;
+			if (!(setters = g[key])) setters = g[key] = [];
+			setters.push(setter);
+			return (v) => {
+				if (setters.length > 1) setters.forEach((set) => set(v));
+				else setters[0](v);
+			};
+		};
+		internalSetCurrentInstance = registerGlobalSetter(`__VUE_INSTANCE_SETTERS__`, (v) => currentInstance = v);
+		setInSSRSetupState = registerGlobalSetter(`__VUE_SSR_SETTERS__`, (v) => isInSSRComponentSetup = v);
+	}
+	const setCurrentInstance = (instance) => {
+		const prev = currentInstance;
+		internalSetCurrentInstance(instance);
+		instance.scope.on();
+		return () => {
+			instance.scope.off();
+			internalSetCurrentInstance(prev);
+		};
+	};
+	function isStatefulComponent(instance) {
+		return instance.vnode.shapeFlag & 4;
+	}
+	let isInSSRComponentSetup = false;
+	function getComponentPublicInstance(instance) {
+		if (instance.exposed) return instance.exposeProxy || (instance.exposeProxy = new Proxy(reactivity.proxyRefs(reactivity.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;
+			}
+		}));
+		else return instance.proxy;
+	}
+	const classifyRE = /(?:^|[-_])\w/g;
+	const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
+	function getComponentName(Component, includeInferred = true) {
+		return shared.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 shared.isFunction(value) && "__vccOpts" in value;
+	}
+	exports.EffectScope = reactivity.EffectScope;
+	exports.ReactiveEffect = reactivity.ReactiveEffect;
+	exports.TrackOpTypes = reactivity.TrackOpTypes;
+	exports.TriggerOpTypes = reactivity.TriggerOpTypes;
+	exports.customRef = reactivity.customRef;
+	exports.effect = reactivity.effect;
+	exports.effectScope = reactivity.effectScope;
+	exports.getCurrentScope = reactivity.getCurrentScope;
+	exports.getCurrentWatcher = reactivity.getCurrentWatcher;
+	exports.isProxy = reactivity.isProxy;
+	exports.isReactive = reactivity.isReactive;
+	exports.isReadonly = reactivity.isReadonly;
+	exports.isRef = reactivity.isRef;
+	exports.isShallow = reactivity.isShallow;
+	exports.markRaw = reactivity.markRaw;
+	exports.onScopeDispose = reactivity.onScopeDispose;
+	exports.onWatcherCleanup = reactivity.onWatcherCleanup;
+	exports.proxyRefs = reactivity.proxyRefs;
+	exports.reactive = reactivity.reactive;
+	exports.readonly = reactivity.readonly;
+	exports.ref = reactivity.ref;
+	exports.shallowReactive = reactivity.shallowReactive;
+	exports.shallowReadonly = reactivity.shallowReadonly;
+	exports.shallowRef = reactivity.shallowRef;
+	exports.stop = reactivity.stop;
+	exports.toRaw = reactivity.toRaw;
+	exports.toRef = reactivity.toRef;
+	exports.toRefs = reactivity.toRefs;
+	exports.toValue = reactivity.toValue;
+	exports.triggerRef = reactivity.triggerRef;
+	exports.unref = reactivity.unref;
+	exports.camelize = shared.camelize;
+	exports.capitalize = shared.capitalize;
+	exports.normalizeClass = shared.normalizeClass;
+	exports.normalizeProps = shared.normalizeProps;
+	exports.normalizeStyle = shared.normalizeStyle;
+	exports.toDisplayString = shared.toDisplayString;
+	exports.toHandlerKey = shared.toHandlerKey;
+}) });
+
+//#endregion
+export default require_runtime_core_cjs();
+
+export { require_runtime_core_cjs };
+//# sourceMappingURL=runtime-core.cjs.mjs.map