diff --git a/packages/playground/__tests__/__snapshots__/uni_modules.spec.ts.snap b/packages/playground/__tests__/__snapshots__/uni_modules.spec.ts.snap index 3e1951289ab..63d4a399e87 100644 --- a/packages/playground/__tests__/__snapshots__/uni_modules.spec.ts.snap +++ b/packages/playground/__tests__/__snapshots__/uni_modules.spec.ts.snap @@ -15,6 +15,9 @@ exports[`uni_modules playground uni-app-x build:app-android 1`] = ` "components": [ "text", "image" + ], + "modules": [ + "uni-getSystemInfo" ] } } @@ -34,6 +37,9 @@ exports[`uni_modules playground uni-app-x build:app-android 2`] = ` "components": [ "text", "video" + ], + "modules": [ + "uni-video" ] } } @@ -674,7 +680,11 @@ exports[`uni_modules playground uni-app-x dev:app-android 1`] = ` "uni.getSystemInfo", "uniCloud.importObject" ], - "components": [] + "components": [], + "modules": [ + "uni-getSystemInfo", + "uni-cloud-client" + ] } } }" @@ -692,7 +702,10 @@ exports[`uni_modules playground uni-app-x dev:app-android 2`] = ` "apis": [ "uniCloud.importObject" ], - "components": [] + "components": [], + "modules": [ + "uni-cloud-client" + ] } } }" diff --git a/packages/uni-app/dist/uni-app.d.ts b/packages/uni-app/dist/uni-app.d.ts index 4078b505c41..add3c597a9b 100644 --- a/packages/uni-app/dist/uni-app.d.ts +++ b/packages/uni-app/dist/uni-app.d.ts @@ -1,115 +1,115 @@ -/// - -import { capitalize } from '@vue/shared'; -import type { ComponentInternalInstance } from 'vue'; -import { extend } from '@vue/shared'; -import { hasOwn } from '@vue/shared'; -import { isPlainObject } from '@vue/shared'; -import { ref } from 'vue'; -import { shallowRef } from 'vue'; -import type { Slots } from 'vue'; - -export { capitalize } - -export { extend } - -export declare function formatAppLog(type: 'log' | 'info' | 'debug' | 'warn' | 'error', filename: string, ...args: unknown[]): void; - -export declare function formatH5Log(type: keyof Console, filename: string, ...args: unknown[]): void; - -/** - * uni 对象是跨实例的，而此处列的 API 均是需要跟当前实例关联的，比如 requireNativePlugin 获取 dom 时，依赖当前 weex 实例 - */ -/// -export declare function getCurrentSubNVue(): UniApp.SubNVue; - -export declare function getSsrGlobalData(): any; - -export { hasOwn } - -export { isPlainObject } - -declare interface NavigationBarSearchInputFocusChanged { - focus: boolean; -} - -export declare const onAddToFavorites: (hook: (options: Page.AddToFavoritesOption) => Page.CustomFavoritesContent, target?: ComponentInternalInstance | null) => void; - -export declare const onBackPress: (hook: (options: Page.BackPressOption) => any, target?: ComponentInternalInstance | null) => void; - -export declare const onError: (hook: (error: string) => void, target?: ComponentInternalInstance | null) => void; - -export declare const onExit: (hook: () => void, target?: ComponentInternalInstance | null) => void; - -export declare const onHide: (hook: () => any, target?: ComponentInternalInstance | null) => void; - -export declare const onInit: (hook: (query?: AnyObject | undefined) => void, target?: ComponentInternalInstance | null) => void; - -export declare const onLaunch: (hook: (options?: App.LaunchShowOption | undefined) => void, target?: ComponentInternalInstance | null) => void; - -export declare const onLoad: (hook: (query?: AnyObject | undefined) => void, target?: ComponentInternalInstance | null) => void; - -export declare const onNavigationBarButtonTap: (hook: (options: Page.NavigationBarButtonTapOption) => void, target?: ComponentInternalInstance | null) => void; - -export declare const onNavigationBarSearchInputChanged: (hook: (event: Page.NavigationBarSearchInputEvent) => void, target?: ComponentInternalInstance | null) => void; - -export declare const onNavigationBarSearchInputClicked: (hook: () => any, target?: ComponentInternalInstance | null) => void; - -export declare const onNavigationBarSearchInputConfirmed: (hook: (event: Page.NavigationBarSearchInputEvent) => void, target?: ComponentInternalInstance | null) => void; - -export declare const onNavigationBarSearchInputFocusChanged: (hook: onNavigationBarSearchInputFocusChangedHook, target?: ComponentInternalInstance | null) => void; - -declare type onNavigationBarSearchInputFocusChangedHook = (options: NavigationBarSearchInputFocusChanged) => void; - -export declare const onPageHide: (hook: () => any, target?: ComponentInternalInstance | null) => void; - -export declare const onPageNotFound: (hook: (options: App.PageNotFoundOption) => void, target?: ComponentInternalInstance | null) => void; - -export declare const onPageScroll: (hook: (options: Page.PageScrollOption) => void, target?: ComponentInternalInstance | null) => void; - -export declare const onPageShow: (hook: ((options?: App.LaunchShowOption | undefined) => void) | (() => void), target?: ComponentInternalInstance | null) => void; - -export declare const onPullDownRefresh: (hook: () => any, target?: ComponentInternalInstance | null) => void; - -export declare const onReachBottom: (hook: () => any, target?: ComponentInternalInstance | null) => void; - -export declare const onReady: (hook: () => any, target?: ComponentInternalInstance | null) => void; - -export declare const onResize: (hook: (options: Page.ResizeOption) => void, target?: ComponentInternalInstance | null) => void; - -export declare const onSaveExitState: (hook: onSaveExitStateHook, target?: ComponentInternalInstance | null) => void; - -declare type onSaveExitStateHook = () => SaveExitState; - -export declare const onShareAppMessage: (hook: (options: Page.ShareAppMessageOption) => Page.CustomShareContent | Promise>, target?: ComponentInternalInstance | null) => void; - -export declare const onShareTimeline: (hook: () => Page.ShareTimelineContent, target?: ComponentInternalInstance | null) => void; - -export declare const onShow: (hook: ((options?: App.LaunchShowOption | undefined) => void) | (() => void), target?: ComponentInternalInstance | null) => void; - -export declare const onTabItemTap: (hook: (options: Page.TabItemTapOption) => void, target?: ComponentInternalInstance | null) => void; - -export declare const onThemeChange: (hook: (options: UniApp.OnThemeChangeCallbackResult) => void, target?: ComponentInternalInstance | null) => void; - -export declare const onUnhandledRejection: (hook: (options: UniApp.OnUnhandledRejectionCallbackResult) => void, target?: ComponentInternalInstance | null) => void; - -export declare const onUnload: (hook: () => any, target?: ComponentInternalInstance | null) => void; - -export declare function renderComponentSlot(slots: Slots, name: string, props?: any | null): any | null; - -export declare function requireNativePlugin(name: string): any; - -export declare function resolveEasycom(component: unknown, easycom: unknown): unknown; - -declare interface SaveExitState { - data: any; - expireTimeStamp: number; -} - -export declare const shallowSsrRef: SSRRef; - -declare type SSRRef = (value: unknown, key?: string, shallow?: boolean) => ReturnType | ReturnType; - -export declare const ssrRef: SSRRef; - -export { } +/// + +import { capitalize } from '@vue/shared'; +import type { ComponentInternalInstance } from 'vue'; +import { extend } from '@vue/shared'; +import { hasOwn } from '@vue/shared'; +import { isPlainObject } from '@vue/shared'; +import { ref } from 'vue'; +import { shallowRef } from 'vue'; +import type { Slots } from 'vue'; + +export { capitalize } + +export { extend } + +export declare function formatAppLog(type: 'log' | 'info' | 'debug' | 'warn' | 'error', filename: string, ...args: unknown[]): void; + +export declare function formatH5Log(type: keyof Console, filename: string, ...args: unknown[]): void; + +/** + * uni 对象是跨实例的，而此处列的 API 均是需要跟当前实例关联的，比如 requireNativePlugin 获取 dom 时，依赖当前 weex 实例 + */ +/// +export declare function getCurrentSubNVue(): UniApp.SubNVue; + +export declare function getSsrGlobalData(): any; + +export { hasOwn } + +export { isPlainObject } + +declare interface NavigationBarSearchInputFocusChanged { + focus: boolean; +} + +export declare const onAddToFavorites: (hook: (options: Page.AddToFavoritesOption) => Page.CustomFavoritesContent, target?: ComponentInternalInstance | null) => void; + +export declare const onBackPress: (hook: (options: Page.BackPressOption) => any, target?: ComponentInternalInstance | null) => void; + +export declare const onError: (hook: (error: string) => void, target?: ComponentInternalInstance | null) => void; + +export declare const onExit: (hook: () => void, target?: ComponentInternalInstance | null) => void; + +export declare const onHide: (hook: () => any, target?: ComponentInternalInstance | null) => void; + +export declare const onInit: (hook: (query?: AnyObject | undefined) => void, target?: ComponentInternalInstance | null) => void; + +export declare const onLaunch: (hook: (options?: App.LaunchShowOption | undefined) => void, target?: ComponentInternalInstance | null) => void; + +export declare const onLoad: (hook: (query?: AnyObject | undefined) => void, target?: ComponentInternalInstance | null) => void; + +export declare const onNavigationBarButtonTap: (hook: (options: Page.NavigationBarButtonTapOption) => void, target?: ComponentInternalInstance | null) => void; + +export declare const onNavigationBarSearchInputChanged: (hook: (event: Page.NavigationBarSearchInputEvent) => void, target?: ComponentInternalInstance | null) => void; + +export declare const onNavigationBarSearchInputClicked: (hook: () => any, target?: ComponentInternalInstance | null) => void; + +export declare const onNavigationBarSearchInputConfirmed: (hook: (event: Page.NavigationBarSearchInputEvent) => void, target?: ComponentInternalInstance | null) => void; + +export declare const onNavigationBarSearchInputFocusChanged: (hook: onNavigationBarSearchInputFocusChangedHook, target?: ComponentInternalInstance | null) => void; + +declare type onNavigationBarSearchInputFocusChangedHook = (options: NavigationBarSearchInputFocusChanged) => void; + +export declare const onPageHide: (hook: () => any, target?: ComponentInternalInstance | null) => void; + +export declare const onPageNotFound: (hook: (options: App.PageNotFoundOption) => void, target?: ComponentInternalInstance | null) => void; + +export declare const onPageScroll: (hook: (options: Page.PageScrollOption) => void, target?: ComponentInternalInstance | null) => void; + +export declare const onPageShow: (hook: ((options?: App.LaunchShowOption | undefined) => void) | (() => void), target?: ComponentInternalInstance | null) => void; + +export declare const onPullDownRefresh: (hook: () => any, target?: ComponentInternalInstance | null) => void; + +export declare const onReachBottom: (hook: () => any, target?: ComponentInternalInstance | null) => void; + +export declare const onReady: (hook: () => any, target?: ComponentInternalInstance | null) => void; + +export declare const onResize: (hook: (options: Page.ResizeOption) => void, target?: ComponentInternalInstance | null) => void; + +export declare const onSaveExitState: (hook: onSaveExitStateHook, target?: ComponentInternalInstance | null) => void; + +declare type onSaveExitStateHook = () => SaveExitState; + +export declare const onShareAppMessage: (hook: (options: Page.ShareAppMessageOption) => Page.CustomShareContent | Promise>, target?: ComponentInternalInstance | null) => void; + +export declare const onShareTimeline: (hook: () => Page.ShareTimelineContent, target?: ComponentInternalInstance | null) => void; + +export declare const onShow: (hook: ((options?: App.LaunchShowOption | undefined) => void) | (() => void), target?: ComponentInternalInstance | null) => void; + +export declare const onTabItemTap: (hook: (options: Page.TabItemTapOption) => void, target?: ComponentInternalInstance | null) => void; + +export declare const onThemeChange: (hook: (options: UniApp.OnThemeChangeCallbackResult) => void, target?: ComponentInternalInstance | null) => void; + +export declare const onUnhandledRejection: (hook: (options: UniApp.OnUnhandledRejectionCallbackResult) => void, target?: ComponentInternalInstance | null) => void; + +export declare const onUnload: (hook: () => any, target?: ComponentInternalInstance | null) => void; + +export declare function renderComponentSlot(slots: Slots, name: string, props?: any | null): any | null; + +export declare function requireNativePlugin(name: string): any; + +export declare function resolveEasycom(component: unknown, easycom: unknown): unknown; + +declare interface SaveExitState { + data: any; + expireTimeStamp: number; +} + +export declare const shallowSsrRef: SSRRef; + +declare type SSRRef = (value: unknown, key?: string, shallow?: boolean) => ReturnType | ReturnType; + +export declare const ssrRef: SSRRef; + +export { } diff --git a/packages/uni-cli-shared/src/uni_modules.ts b/packages/uni-cli-shared/src/uni_modules.ts index 46c1e4c5293..d096ecc8663 100644 --- a/packages/uni-cli-shared/src/uni_modules.ts +++ b/packages/uni-cli-shared/src/uni_modules.ts @@ -624,13 +624,20 @@ function findLastIndex( let encryptUniModules: ReturnType = {} -export function resolveEncryptUniModule(id: string) { +export function resolveEncryptUniModule( + id: string, + platform: typeof process.env.UNI_UTS_PLATFORM, + isX: boolean = true +) { const parts = id.split('/') const index = findLastIndex(parts, (part) => part === 'uni_modules') if (index !== -1) { const uniModuleId = parts[index + 1] if (uniModuleId in encryptUniModules) { - return `@/uni_modules/${uniModuleId}?uni_helpers` + // 原生平台走旧的uts-proxy + return `@/uni_modules/${uniModuleId}?${ + isX && platform === 'app-android' ? 'uts-proxy' : 'uni_helpers' + }` } } } diff --git a/packages/uni-cli-shared/src/vite/cloud.ts b/packages/uni-cli-shared/src/vite/cloud.ts index b09349cffa2..11b3d12dccd 100644 --- a/packages/uni-cli-shared/src/vite/cloud.ts +++ b/packages/uni-cli-shared/src/vite/cloud.ts @@ -118,6 +118,13 @@ export function uniEncryptUniModulesPlugin(): Plugin { uni_modules: [], }) if (result) { + const apis = result.inject_apis + const components = getUniModulesExtApiComponents(uniModule) + const modules = resolveUTSCompiler().parseInjectModules( + apis, + {}, + components + ) fs.writeFileSync( path.resolve( process.env.UNI_OUTPUT_DIR, @@ -127,8 +134,9 @@ export function uniEncryptUniModulesPlugin(): Plugin { ), genUniModulesPackageJson(uniModule, tempOutputDir, { env: initCheckEnv(), - apis: result.inject_apis, - components: getUniModulesExtApiComponents(uniModule), + apis, + components, + modules, }) ) } diff --git a/packages/uni-cli-shared/src/vite/plugins/uts/uni_modules.ts b/packages/uni-cli-shared/src/vite/plugins/uts/uni_modules.ts index 2fdb1d0925b..72ac9f5c523 100644 --- a/packages/uni-cli-shared/src/vite/plugins/uts/uni_modules.ts +++ b/packages/uni-cli-shared/src/vite/plugins/uts/uni_modules.ts @@ -114,28 +114,38 @@ export function uniUTSUniModulesPlugin( } } + const isX = process.env.UNI_APP_X === 'true' + return { name: 'uni:uts-uni_modules', apply: 'build', enforce: 'pre', async configResolved() { - const manifest = parseManifestJsonOnce(inputDir) - await checkEncryptUniModules(inputDir, { - mode: - process.env.NODE_ENV !== 'development' ? 'production' : 'development', - compilerVersion: process.env.UNI_COMPILER_VERSION, - appid: manifest.appid, - appname: manifest.name, - platform: process.env.UNI_UTS_PLATFORM, - 'uni-app-x': process.env.UNI_APP_X === 'true', - }) + if (isX) { + const manifest = parseManifestJsonOnce(inputDir) + await checkEncryptUniModules(inputDir, { + mode: + process.env.NODE_ENV !== 'development' + ? 'production' + : 'development', + compilerVersion: process.env.UNI_COMPILER_VERSION, + appid: manifest.appid, + appname: manifest.name, + platform: process.env.UNI_UTS_PLATFORM, + 'uni-app-x': isX, + }) + } }, resolveId(id, importer) { if (isUTSProxy(id) || isUniHelpers(id)) { return id } - if (process.env.UNI_COMPILE_TARGET !== 'uni_modules') { - const resolvedId = resolveEncryptUniModule(id) + if (isX && process.env.UNI_COMPILE_TARGET !== 'uni_modules') { + const resolvedId = resolveEncryptUniModule( + id, + process.env.UNI_UTS_PLATFORM, + process.env.UNI_APP_X === 'true' + ) if (resolvedId) { return resolvedId } diff --git a/packages/uni-mp-vue/dist/vue.runtime.esm.js b/packages/uni-mp-vue/dist/vue.runtime.esm.js new file mode 100644 index 00000000000..c456e2e48af --- /dev/null +++ b/packages/uni-mp-vue/dist/vue.runtime.esm.js @@ -0,0 +1,8083 @@ +import { isRootHook, getValueByDataPath, isUniLifecycleHook, ON_ERROR, UniLifecycleHooks, invokeCreateErrorHandler, dynamicSlotName } from '@dcloudio/uni-shared'; +import { isSymbol, extend, isObject, toRawType, def, hasOwn, isArray, isIntegerKey, makeMap, hasChanged, isMap, capitalize, getGlobalThis, isString, normalizeClass, normalizeStyle, isFunction, isOn, NOOP, EMPTY_OBJ, isPromise, isSet, isPlainObject, camelize, remove, toHandlerKey, hyphenate, isReservedProp, toTypeString, invokeArrayFns, isBuiltInDirective, looseToNumber, NO, EMPTY_ARR, isModelListener, toNumber, toDisplayString } from '@vue/shared'; +export { EMPTY_OBJ, camelize, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from '@vue/shared'; + +/** +* @vue/reactivity v3.4.21 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/ + +function warn$4(msg, ...args) { + console.warn(`[Vue warn] ${msg}`, ...args); +} + +let activeEffectScope$1; +function recordEffectScope$1(effect, scope = activeEffectScope$1) { + if (scope && scope.active) { + scope.effects.push(effect); + } +} + +let activeEffect$1; +let ReactiveEffect$1 = class ReactiveEffect { + constructor(fn, trigger, scheduler, scope) { + this.fn = fn; + this.trigger = trigger; + this.scheduler = scheduler; + this.active = true; + this.deps = []; + /** + * @internal + */ + this._dirtyLevel = 4; + /** + * @internal + */ + this._trackId = 0; + /** + * @internal + */ + this._runnings = 0; + /** + * @internal + */ + this._shouldSchedule = false; + /** + * @internal + */ + this._depsLength = 0; + recordEffectScope$1(this, scope); + } + get dirty() { + if (this._dirtyLevel === 2 || this._dirtyLevel === 3) { + this._dirtyLevel = 1; + pauseTracking$1(); + for (let i = 0; i < this._depsLength; i++) { + const dep = this.deps[i]; + if (dep.computed) { + triggerComputed$1(dep.computed); + if (this._dirtyLevel >= 4) { + break; + } + } + } + if (this._dirtyLevel === 1) { + this._dirtyLevel = 0; + } + resetTracking$1(); + } + return this._dirtyLevel >= 4; + } + set dirty(v) { + this._dirtyLevel = v ? 4 : 0; + } + run() { + this._dirtyLevel = 0; + if (!this.active) { + return this.fn(); + } + let lastShouldTrack = shouldTrack$1; + let lastEffect = activeEffect$1; + try { + shouldTrack$1 = true; + activeEffect$1 = this; + this._runnings++; + preCleanupEffect$1(this); + return this.fn(); + } finally { + postCleanupEffect$1(this); + this._runnings--; + activeEffect$1 = lastEffect; + shouldTrack$1 = lastShouldTrack; + } + } + stop() { + var _a; + if (this.active) { + preCleanupEffect$1(this); + postCleanupEffect$1(this); + (_a = this.onStop) == null ? void 0 : _a.call(this); + this.active = false; + } + } +}; +function triggerComputed$1(computed) { + return computed.value; +} +function preCleanupEffect$1(effect2) { + effect2._trackId++; + effect2._depsLength = 0; +} +function postCleanupEffect$1(effect2) { + if (effect2.deps.length > effect2._depsLength) { + for (let i = effect2._depsLength; i < effect2.deps.length; i++) { + cleanupDepEffect$1(effect2.deps[i], effect2); + } + effect2.deps.length = effect2._depsLength; + } +} +function cleanupDepEffect$1(dep, effect2) { + const trackId = dep.get(effect2); + if (trackId !== void 0 && effect2._trackId !== trackId) { + dep.delete(effect2); + if (dep.size === 0) { + dep.cleanup(); + } + } +} +let shouldTrack$1 = true; +let pauseScheduleStack$1 = 0; +const trackStack$1 = []; +function pauseTracking$1() { + trackStack$1.push(shouldTrack$1); + shouldTrack$1 = false; +} +function resetTracking$1() { + const last = trackStack$1.pop(); + shouldTrack$1 = last === void 0 ? true : last; +} +function pauseScheduling$1() { + pauseScheduleStack$1++; +} +function resetScheduling$1() { + pauseScheduleStack$1--; + while (!pauseScheduleStack$1 && queueEffectSchedulers$1.length) { + queueEffectSchedulers$1.shift()(); + } +} +function trackEffect$1(effect2, dep, debuggerEventExtraInfo) { + var _a; + if (dep.get(effect2) !== effect2._trackId) { + dep.set(effect2, effect2._trackId); + const oldDep = effect2.deps[effect2._depsLength]; + if (oldDep !== dep) { + if (oldDep) { + cleanupDepEffect$1(oldDep, effect2); + } + effect2.deps[effect2._depsLength++] = dep; + } else { + effect2._depsLength++; + } + if (!!(process.env.NODE_ENV !== "production")) { + (_a = effect2.onTrack) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo)); + } + } +} +const queueEffectSchedulers$1 = []; +function triggerEffects$1(dep, dirtyLevel, debuggerEventExtraInfo) { + var _a; + pauseScheduling$1(); + for (const effect2 of dep.keys()) { + let tracking; + if (effect2._dirtyLevel < dirtyLevel && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) { + effect2._shouldSchedule || (effect2._shouldSchedule = effect2._dirtyLevel === 0); + effect2._dirtyLevel = dirtyLevel; + } + if (effect2._shouldSchedule && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) { + if (!!(process.env.NODE_ENV !== "production")) { + (_a = effect2.onTrigger) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo)); + } + effect2.trigger(); + if ((!effect2._runnings || effect2.allowRecurse) && effect2._dirtyLevel !== 2) { + effect2._shouldSchedule = false; + if (effect2.scheduler) { + queueEffectSchedulers$1.push(effect2.scheduler); + } + } + } + } + resetScheduling$1(); +} + +const createDep$1 = (cleanup, computed) => { + const dep = /* @__PURE__ */ new Map(); + dep.cleanup = cleanup; + dep.computed = computed; + return dep; +}; + +const targetMap$1 = /* @__PURE__ */ new WeakMap(); +const ITERATE_KEY$1 = Symbol(!!(process.env.NODE_ENV !== "production") ? "iterate" : ""); +const MAP_KEY_ITERATE_KEY$1 = Symbol(!!(process.env.NODE_ENV !== "production") ? "Map key iterate" : ""); +function track$1(target, type, key) { + if (shouldTrack$1 && activeEffect$1) { + let depsMap = targetMap$1.get(target); + if (!depsMap) { + targetMap$1.set(target, depsMap = /* @__PURE__ */ new Map()); + } + let dep = depsMap.get(key); + if (!dep) { + depsMap.set(key, dep = createDep$1(() => depsMap.delete(key))); + } + trackEffect$1( + activeEffect$1, + dep, + !!(process.env.NODE_ENV !== "production") ? { + target, + type, + key + } : void 0 + ); + } +} +function trigger$1(target, type, key, newValue, oldValue, oldTarget) { + const depsMap = targetMap$1.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$1)); + if (isMap(target)) { + deps.push(depsMap.get(MAP_KEY_ITERATE_KEY$1)); + } + } else if (isIntegerKey(key)) { + deps.push(depsMap.get("length")); + } + break; + case "delete": + if (!isArray(target)) { + deps.push(depsMap.get(ITERATE_KEY$1)); + if (isMap(target)) { + deps.push(depsMap.get(MAP_KEY_ITERATE_KEY$1)); + } + } + break; + case "set": + if (isMap(target)) { + deps.push(depsMap.get(ITERATE_KEY$1)); + } + break; + } + } + pauseScheduling$1(); + for (const dep of deps) { + if (dep) { + triggerEffects$1( + dep, + 4, + !!(process.env.NODE_ENV !== "production") ? { + target, + type, + key, + newValue, + oldValue, + oldTarget + } : void 0 + ); + } + } + resetScheduling$1(); +} + +const isNonTrackableKeys$1 = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`); +const builtInSymbols$1 = new Set( + /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol) +); +const arrayInstrumentations$1 = /* @__PURE__ */ createArrayInstrumentations$1(); +function createArrayInstrumentations$1() { + const instrumentations = {}; + ["includes", "indexOf", "lastIndexOf"].forEach((key) => { + instrumentations[key] = function(...args) { + const arr = toRaw$1(this); + for (let i = 0, l = this.length; i < l; i++) { + track$1(arr, "get", i + ""); + } + const res = arr[key](...args); + if (res === -1 || res === false) { + return arr[key](...args.map(toRaw$1)); + } else { + return res; + } + }; + }); + ["push", "pop", "shift", "unshift", "splice"].forEach((key) => { + instrumentations[key] = function(...args) { + pauseTracking$1(); + pauseScheduling$1(); + const res = toRaw$1(this)[key].apply(this, args); + resetScheduling$1(); + resetTracking$1(); + return res; + }; + }); + return instrumentations; +} +function hasOwnProperty$1(key) { + const obj = toRaw$1(this); + track$1(obj, "has", key); + return obj.hasOwnProperty(key); +} +let BaseReactiveHandler$1 = class BaseReactiveHandler { + constructor(_isReadonly = false, _isShallow = false) { + this._isReadonly = _isReadonly; + this._isShallow = _isShallow; + } + get(target, key, receiver) { + const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow; + if (key === "__v_isReactive") { + return !isReadonly2; + } else if (key === "__v_isReadonly") { + return isReadonly2; + } else if (key === "__v_isShallow") { + return isShallow2; + } else if (key === "__v_raw") { + if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap$1 : readonlyMap$1 : isShallow2 ? shallowReactiveMap$1 : reactiveMap$1).get(target) || // receiver is not the reactive proxy, but has the same prototype + // this means the reciever is a user proxy of the reactive proxy + Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) { + return target; + } + return; + } + const targetIsArray = isArray(target); + if (!isReadonly2) { + if (targetIsArray && hasOwn(arrayInstrumentations$1, key)) { + return Reflect.get(arrayInstrumentations$1, key, receiver); + } + if (key === "hasOwnProperty") { + return hasOwnProperty$1; + } + } + const res = Reflect.get(target, key, receiver); + if (isSymbol(key) ? builtInSymbols$1.has(key) : isNonTrackableKeys$1(key)) { + return res; + } + if (!isReadonly2) { + track$1(target, "get", key); + } + if (isShallow2) { + return res; + } + if (isRef$1(res)) { + return targetIsArray && isIntegerKey(key) ? res : res.value; + } + if (isObject(res)) { + return isReadonly2 ? readonly$1(res) : reactive$1(res); + } + return res; + } +}; +let MutableReactiveHandler$1 = class MutableReactiveHandler extends BaseReactiveHandler$1 { + constructor(isShallow2 = false) { + super(false, isShallow2); + } + set(target, key, value, receiver) { + let oldValue = target[key]; + if (!this._isShallow) { + const isOldValueReadonly = isReadonly$1(oldValue); + if (!isShallow$1(value) && !isReadonly$1(value)) { + oldValue = toRaw$1(oldValue); + value = toRaw$1(value); + } + if (!isArray(target) && isRef$1(oldValue) && !isRef$1(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$1(receiver)) { + if (!hadKey) { + trigger$1(target, "add", key, value); + } else if (hasChanged(value, oldValue)) { + trigger$1(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$1(target, "delete", key, void 0, oldValue); + } + return result; + } + has(target, key) { + const result = Reflect.has(target, key); + if (!isSymbol(key) || !builtInSymbols$1.has(key)) { + track$1(target, "has", key); + } + return result; + } + ownKeys(target) { + track$1( + target, + "iterate", + isArray(target) ? "length" : ITERATE_KEY$1 + ); + return Reflect.ownKeys(target); + } +}; +let ReadonlyReactiveHandler$1 = class ReadonlyReactiveHandler extends BaseReactiveHandler$1 { + constructor(isShallow2 = false) { + super(true, isShallow2); + } + set(target, key) { + if (!!(process.env.NODE_ENV !== "production")) { + warn$4( + `Set operation on key "${String(key)}" failed: target is readonly.`, + target + ); + } + return true; + } + deleteProperty(target, key) { + if (!!(process.env.NODE_ENV !== "production")) { + warn$4( + `Delete operation on key "${String(key)}" failed: target is readonly.`, + target + ); + } + return true; + } +}; +const mutableHandlers$1 = /* @__PURE__ */ new MutableReactiveHandler$1(); +const readonlyHandlers$1 = /* @__PURE__ */ new ReadonlyReactiveHandler$1(); +const shallowReadonlyHandlers$1 = /* @__PURE__ */ new ReadonlyReactiveHandler$1(true); + +const toShallow$1 = (value) => value; +const getProto$1 = (v) => Reflect.getPrototypeOf(v); +function get$1(target, key, isReadonly = false, isShallow = false) { + target = target["__v_raw"]; + const rawTarget = toRaw$1(target); + const rawKey = toRaw$1(key); + if (!isReadonly) { + if (hasChanged(key, rawKey)) { + track$1(rawTarget, "get", key); + } + track$1(rawTarget, "get", rawKey); + } + const { has: has2 } = getProto$1(rawTarget); + const wrap = isShallow ? toShallow$1 : isReadonly ? toReadonly$1 : toReactive$1; + 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$1(key, isReadonly = false) { + const target = this["__v_raw"]; + const rawTarget = toRaw$1(target); + const rawKey = toRaw$1(key); + if (!isReadonly) { + if (hasChanged(key, rawKey)) { + track$1(rawTarget, "has", key); + } + track$1(rawTarget, "has", rawKey); + } + return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey); +} +function size$1(target, isReadonly = false) { + target = target["__v_raw"]; + !isReadonly && track$1(toRaw$1(target), "iterate", ITERATE_KEY$1); + return Reflect.get(target, "size", target); +} +function add$1(value) { + value = toRaw$1(value); + const target = toRaw$1(this); + const proto = getProto$1(target); + const hadKey = proto.has.call(target, value); + if (!hadKey) { + target.add(value); + trigger$1(target, "add", value, value); + } + return this; +} +function set$2(key, value) { + value = toRaw$1(value); + const target = toRaw$1(this); + const { has: has2, get: get2 } = getProto$1(target); + let hadKey = has2.call(target, key); + if (!hadKey) { + key = toRaw$1(key); + hadKey = has2.call(target, key); + } else if (!!(process.env.NODE_ENV !== "production")) { + checkIdentityKeys$1(target, has2, key); + } + const oldValue = get2.call(target, key); + target.set(key, value); + if (!hadKey) { + trigger$1(target, "add", key, value); + } else if (hasChanged(value, oldValue)) { + trigger$1(target, "set", key, value, oldValue); + } + return this; +} +function deleteEntry$1(key) { + const target = toRaw$1(this); + const { has: has2, get: get2 } = getProto$1(target); + let hadKey = has2.call(target, key); + if (!hadKey) { + key = toRaw$1(key); + hadKey = has2.call(target, key); + } else if (!!(process.env.NODE_ENV !== "production")) { + checkIdentityKeys$1(target, has2, key); + } + const oldValue = get2 ? get2.call(target, key) : void 0; + const result = target.delete(key); + if (hadKey) { + trigger$1(target, "delete", key, void 0, oldValue); + } + return result; +} +function clear$1() { + const target = toRaw$1(this); + const hadItems = target.size !== 0; + const oldTarget = !!(process.env.NODE_ENV !== "production") ? isMap(target) ? new Map(target) : new Set(target) : void 0; + const result = target.clear(); + if (hadItems) { + trigger$1(target, "clear", void 0, void 0, oldTarget); + } + return result; +} +function createForEach$1(isReadonly, isShallow) { + return function forEach(callback, thisArg) { + const observed = this; + const target = observed["__v_raw"]; + const rawTarget = toRaw$1(target); + const wrap = isShallow ? toShallow$1 : isReadonly ? toReadonly$1 : toReactive$1; + !isReadonly && track$1(rawTarget, "iterate", ITERATE_KEY$1); + return target.forEach((value, key) => { + return callback.call(thisArg, wrap(value), wrap(key), observed); + }); + }; +} +function createIterableMethod$1(method, isReadonly, isShallow) { + return function(...args) { + const target = this["__v_raw"]; + const rawTarget = toRaw$1(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 = isShallow ? toShallow$1 : isReadonly ? toReadonly$1 : toReactive$1; + !isReadonly && track$1( + rawTarget, + "iterate", + isKeyOnly ? MAP_KEY_ITERATE_KEY$1 : ITERATE_KEY$1 + ); + return { + // iterator protocol + next() { + const { value, done } = innerIterator.next(); + return done ? { value, done } : { + value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), + done + }; + }, + // iterable protocol + [Symbol.iterator]() { + return this; + } + }; + }; +} +function createReadonlyMethod$1(type) { + return function(...args) { + if (!!(process.env.NODE_ENV !== "production")) { + const key = args[0] ? `on key "${args[0]}" ` : ``; + warn$4( + `${capitalize(type)} operation ${key}failed: target is readonly.`, + toRaw$1(this) + ); + } + return type === "delete" ? false : type === "clear" ? void 0 : this; + }; +} +function createInstrumentations$1() { + const mutableInstrumentations2 = { + get(key) { + return get$1(this, key); + }, + get size() { + return size$1(this); + }, + has: has$1, + add: add$1, + set: set$2, + delete: deleteEntry$1, + clear: clear$1, + forEach: createForEach$1(false, false) + }; + const shallowInstrumentations2 = { + get(key) { + return get$1(this, key, false, true); + }, + get size() { + return size$1(this); + }, + has: has$1, + add: add$1, + set: set$2, + delete: deleteEntry$1, + clear: clear$1, + forEach: createForEach$1(false, true) + }; + const readonlyInstrumentations2 = { + get(key) { + return get$1(this, key, true); + }, + get size() { + return size$1(this, true); + }, + has(key) { + return has$1.call(this, key, true); + }, + add: createReadonlyMethod$1("add"), + set: createReadonlyMethod$1("set"), + delete: createReadonlyMethod$1("delete"), + clear: createReadonlyMethod$1("clear"), + forEach: createForEach$1(true, false) + }; + const shallowReadonlyInstrumentations2 = { + get(key) { + return get$1(this, key, true, true); + }, + get size() { + return size$1(this, true); + }, + has(key) { + return has$1.call(this, key, true); + }, + add: createReadonlyMethod$1("add"), + set: createReadonlyMethod$1("set"), + delete: createReadonlyMethod$1("delete"), + clear: createReadonlyMethod$1("clear"), + forEach: createForEach$1(true, true) + }; + const iteratorMethods = ["keys", "values", "entries", Symbol.iterator]; + iteratorMethods.forEach((method) => { + mutableInstrumentations2[method] = createIterableMethod$1( + method, + false, + false + ); + readonlyInstrumentations2[method] = createIterableMethod$1( + method, + true, + false + ); + shallowInstrumentations2[method] = createIterableMethod$1( + method, + false, + true + ); + shallowReadonlyInstrumentations2[method] = createIterableMethod$1( + method, + true, + true + ); + }); + return [ + mutableInstrumentations2, + readonlyInstrumentations2, + shallowInstrumentations2, + shallowReadonlyInstrumentations2 + ]; +} +const [ + mutableInstrumentations$1, + readonlyInstrumentations$1, + shallowInstrumentations$1, + shallowReadonlyInstrumentations$1 +] = /* @__PURE__ */ createInstrumentations$1(); +function createInstrumentationGetter$1(isReadonly, shallow) { + const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations$1 : shallowInstrumentations$1 : isReadonly ? readonlyInstrumentations$1 : mutableInstrumentations$1; + return (target, key, receiver) => { + if (key === "__v_isReactive") { + return !isReadonly; + } else if (key === "__v_isReadonly") { + return isReadonly; + } else if (key === "__v_raw") { + return target; + } + return Reflect.get( + hasOwn(instrumentations, key) && key in target ? instrumentations : target, + key, + receiver + ); + }; +} +const mutableCollectionHandlers$1 = { + get: /* @__PURE__ */ createInstrumentationGetter$1(false, false) +}; +const readonlyCollectionHandlers$1 = { + get: /* @__PURE__ */ createInstrumentationGetter$1(true, false) +}; +const shallowReadonlyCollectionHandlers$1 = { + get: /* @__PURE__ */ createInstrumentationGetter$1(true, true) +}; +function checkIdentityKeys$1(target, has2, key) { + const rawKey = toRaw$1(key); + if (rawKey !== key && has2.call(target, rawKey)) { + const type = toRawType(target); + warn$4( + `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.` + ); + } +} + +const reactiveMap$1 = /* @__PURE__ */ new WeakMap(); +const shallowReactiveMap$1 = /* @__PURE__ */ new WeakMap(); +const readonlyMap$1 = /* @__PURE__ */ new WeakMap(); +const shallowReadonlyMap$1 = /* @__PURE__ */ new WeakMap(); +function targetTypeMap$1(rawType) { + switch (rawType) { + case "Object": + case "Array": + return 1 /* COMMON */; + case "Map": + case "Set": + case "WeakMap": + case "WeakSet": + return 2 /* COLLECTION */; + default: + return 0 /* INVALID */; + } +} +function getTargetType$1(value) { + return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap$1(toRawType(value)); +} +function reactive$1(target) { + if (isReadonly$1(target)) { + return target; + } + return createReactiveObject$1( + target, + false, + mutableHandlers$1, + mutableCollectionHandlers$1, + reactiveMap$1 + ); +} +function readonly$1(target) { + return createReactiveObject$1( + target, + true, + readonlyHandlers$1, + readonlyCollectionHandlers$1, + readonlyMap$1 + ); +} +function shallowReadonly$1(target) { + return createReactiveObject$1( + target, + true, + shallowReadonlyHandlers$1, + shallowReadonlyCollectionHandlers$1, + shallowReadonlyMap$1 + ); +} +function createReactiveObject$1(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) { + if (!isObject(target)) { + if (!!(process.env.NODE_ENV !== "production")) { + warn$4(`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$1(target); + if (targetType === 0 /* INVALID */) { + return target; + } + const proxy = new Proxy( + target, + targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers + ); + proxyMap.set(target, proxy); + return proxy; +} +function isReactive$1(value) { + if (isReadonly$1(value)) { + return isReactive$1(value["__v_raw"]); + } + return !!(value && value["__v_isReactive"]); +} +function isReadonly$1(value) { + return !!(value && value["__v_isReadonly"]); +} +function isShallow$1(value) { + return !!(value && value["__v_isShallow"]); +} +function isProxy$1(value) { + return isReactive$1(value) || isReadonly$1(value); +} +function toRaw$1(observed) { + const raw = observed && observed["__v_raw"]; + return raw ? toRaw$1(raw) : observed; +} +function markRaw$1(value) { + if (Object.isExtensible(value)) { + def(value, "__v_skip", true); + } + return value; +} +const toReactive$1 = (value) => isObject(value) ? reactive$1(value) : value; +const toReadonly$1 = (value) => isObject(value) ? readonly$1(value) : value; +function isRef$1(r) { + return !!(r && r.__v_isRef === true); +} +function unref$1(ref2) { + return isRef$1(ref2) ? ref2.value : ref2; +} +const shallowUnwrapHandlers$1 = { + get: (target, key, receiver) => unref$1(Reflect.get(target, key, receiver)), + set: (target, key, value, receiver) => { + const oldValue = target[key]; + if (isRef$1(oldValue) && !isRef$1(value)) { + oldValue.value = value; + return true; + } else { + return Reflect.set(target, key, value, receiver); + } + } +}; +function proxyRefs$1(objectWithRefs) { + return isReactive$1(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers$1); +} + +/** +* @vue/runtime-core v3.4.21 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/ + +const stack$1 = []; +function pushWarningContext$1(vnode) { + stack$1.push(vnode); +} +function popWarningContext$1() { + stack$1.pop(); +} +function warn$1$1(msg, ...args) { + pauseTracking$1(); + const instance = stack$1.length ? stack$1[stack$1.length - 1].component : null; + const appWarnHandler = instance && instance.appContext.config.warnHandler; + const trace = getComponentTrace$1(); + if (appWarnHandler) { + callWithErrorHandling$1( + 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$1(instance, vnode.type)}>` + ).join("\n"), + trace + ] + ); + } else { + const warnArgs = [`[Vue warn]: ${msg}`, ...args]; + if (trace.length && // avoid spamming console during tests + true) { + warnArgs.push(` +`, ...formatTrace$1(trace)); + } + console.warn(...warnArgs); + } + resetTracking$1(); +} +function getComponentTrace$1() { + let currentVNode = stack$1[stack$1.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$1(trace) { + const logs = []; + trace.forEach((entry, i) => { + logs.push(...i === 0 ? [] : [` +`], ...formatTraceEntry$1(entry)); + }); + return logs; +} +function formatTraceEntry$1({ vnode, recurseCount }) { + const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``; + const isRoot = vnode.component ? vnode.component.parent == null : false; + const open = ` at <${formatComponentName$1( + vnode.component, + vnode.type, + isRoot + )}`; + const close = `>` + postfix; + return vnode.props ? [open, ...formatProps$1(vnode.props), close] : [open + close]; +} +function formatProps$1(props) { + const res = []; + const keys = Object.keys(props); + keys.slice(0, 3).forEach((key) => { + res.push(...formatProp$1(key, props[key])); + }); + if (keys.length > 3) { + res.push(` ...`); + } + return res; +} +function formatProp$1(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$1(value)) { + value = formatProp$1(key, toRaw$1(value.value), true); + return raw ? value : [`${key}=Ref<`, value, `>`]; + } else if (isFunction(value)) { + return [`${key}=fn${value.name ? `<${value.name}>` : ``}`]; + } else { + value = toRaw$1(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. This is likely a Vue internals bug. Please open an issue at https://github.com/vuejs/core ." +}; +function callWithErrorHandling$1(fn, instance, type, args) { + try { + return args ? fn(...args) : fn(); + } catch (err) { + handleError$1(err, instance, type); + } +} +function callWithAsyncErrorHandling$1(fn, instance, type, args) { + if (isFunction(fn)) { + const res = callWithErrorHandling$1(fn, instance, type, args); + if (res && isPromise(res)) { + res.catch((err) => { + handleError$1(err, instance, type); + }); + } + return res; + } + const values = []; + for (let i = 0; i < fn.length; i++) { + values.push(callWithAsyncErrorHandling$1(fn[i], instance, type, args)); + } + return values; +} +function handleError$1(err, instance, type, throwInDev = true) { + const contextVNode = instance ? instance.vnode : null; + if (instance) { + let cur = instance.parent; + const exposedInstance = instance.proxy; + const errorInfo = !!(process.env.NODE_ENV !== "production") ? ErrorTypeStrings$1[type] : `https://vuejs.org/error-reference/#runtime-${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$1( + appErrorHandler, + null, + 10, + [err, exposedInstance, errorInfo] + ); + return; + } + } + logError$1(err, type, contextVNode, throwInDev); +} +function logError$1(err, type, contextVNode, throwInDev = true) { + if (!!(process.env.NODE_ENV !== "production")) { + const info = ErrorTypeStrings$1[type]; + if (contextVNode) { + pushWarningContext$1(contextVNode); + } + warn$1$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`); + if (contextVNode) { + popWarningContext$1(); + } + if (throwInDev) { + throw err; + } else { + console.error(err); + } + } else { + console.error(err); + } +} + +let isFlushing$1 = false; +let isFlushPending$1 = false; +const queue$1 = []; +let flushIndex$1 = 0; +const pendingPostFlushCbs$1 = []; +let activePostFlushCbs$1 = null; +let postFlushIndex$1 = 0; +const resolvedPromise$1 = /* @__PURE__ */ Promise.resolve(); +let currentFlushPromise$1 = null; +const RECURSION_LIMIT$1 = 100; +function nextTick$2(fn) { + const p = currentFlushPromise$1 || resolvedPromise$1; + return fn ? p.then(this ? fn.bind(this) : fn) : p; +} +function findInsertionIndex$1(id) { + let start = flushIndex$1 + 1; + let end = queue$1.length; + while (start < end) { + const middle = start + end >>> 1; + const middleJob = queue$1[middle]; + const middleJobId = getId$1(middleJob); + if (middleJobId < id || middleJobId === id && middleJob.pre) { + start = middle + 1; + } else { + end = middle; + } + } + return start; +} +function queueJob$1(job) { + if (!queue$1.length || !queue$1.includes( + job, + isFlushing$1 && job.allowRecurse ? flushIndex$1 + 1 : flushIndex$1 + )) { + if (job.id == null) { + queue$1.push(job); + } else { + queue$1.splice(findInsertionIndex$1(job.id), 0, job); + } + queueFlush$1(); + } +} +function queueFlush$1() { + if (!isFlushing$1 && !isFlushPending$1) { + isFlushPending$1 = true; + currentFlushPromise$1 = resolvedPromise$1.then(flushJobs$1); + } +} +function queuePostFlushCb$1(cb) { + if (!isArray(cb)) { + if (!activePostFlushCbs$1 || !activePostFlushCbs$1.includes( + cb, + cb.allowRecurse ? postFlushIndex$1 + 1 : postFlushIndex$1 + )) { + pendingPostFlushCbs$1.push(cb); + } + } else { + pendingPostFlushCbs$1.push(...cb); + } + queueFlush$1(); +} +function flushPostFlushCbs$1(seen) { + if (pendingPostFlushCbs$1.length) { + const deduped = [...new Set(pendingPostFlushCbs$1)].sort( + (a, b) => getId$1(a) - getId$1(b) + ); + pendingPostFlushCbs$1.length = 0; + if (activePostFlushCbs$1) { + activePostFlushCbs$1.push(...deduped); + return; + } + activePostFlushCbs$1 = deduped; + if (!!(process.env.NODE_ENV !== "production")) { + seen = seen || /* @__PURE__ */ new Map(); + } + for (postFlushIndex$1 = 0; postFlushIndex$1 < activePostFlushCbs$1.length; postFlushIndex$1++) { + if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates$1(seen, activePostFlushCbs$1[postFlushIndex$1])) { + continue; + } + activePostFlushCbs$1[postFlushIndex$1](); + } + activePostFlushCbs$1 = null; + postFlushIndex$1 = 0; + } +} +const getId$1 = (job) => job.id == null ? Infinity : job.id; +const comparator$1 = (a, b) => { + const diff = getId$1(a) - getId$1(b); + if (diff === 0) { + if (a.pre && !b.pre) + return -1; + if (b.pre && !a.pre) + return 1; + } + return diff; +}; +function flushJobs$1(seen) { + isFlushPending$1 = false; + isFlushing$1 = true; + if (!!(process.env.NODE_ENV !== "production")) { + seen = seen || /* @__PURE__ */ new Map(); + } + queue$1.sort(comparator$1); + const check = !!(process.env.NODE_ENV !== "production") ? (job) => checkRecursiveUpdates$1(seen, job) : NOOP; + try { + for (flushIndex$1 = 0; flushIndex$1 < queue$1.length; flushIndex$1++) { + const job = queue$1[flushIndex$1]; + if (job && job.active !== false) { + if (!!(process.env.NODE_ENV !== "production") && check(job)) { + continue; + } + callWithErrorHandling$1(job, null, 14); + } + } + } finally { + flushIndex$1 = 0; + queue$1.length = 0; + flushPostFlushCbs$1(seen); + isFlushing$1 = false; + currentFlushPromise$1 = null; + if (queue$1.length || pendingPostFlushCbs$1.length) { + flushJobs$1(seen); + } + } +} +function checkRecursiveUpdates$1(seen, fn) { + if (!seen.has(fn)) { + seen.set(fn, 1); + } else { + const count = seen.get(fn); + if (count > RECURSION_LIMIT$1) { + const instance = fn.ownerInstance; + const componentName = instance && getComponentName$1(instance.type); + handleError$1( + `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); + } + } +} +const hmrDirtyComponents = /* @__PURE__ */ new Set(); +if (!!(process.env.NODE_ENV !== "production")) { + 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$1(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 = []; + instance.effect.dirty = true; + instance.update(); + }); +} +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$1(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$1(() => { + 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.` + ); + } + }; +} + +let devtools$1; +let buffer$1 = []; +function setDevtoolsHook$1(hook, target) { + var _a, _b; + devtools$1 = hook; + if (devtools$1) { + devtools$1.enabled = true; + buffer$1.forEach(({ event, args }) => devtools$1.emit(event, ...args)); + buffer$1 = []; + } else if ( + // handle late devtools injection - only do this if we are in an actual + // browser environment to avoid the timer handle stalling test runner exit + // (#4815) + typeof window !== "undefined" && // some envs mock window but not fully + window.HTMLElement && // also exclude jsdom + !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom")) + ) { + const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || []; + replay.push((newHook) => { + setDevtoolsHook$1(newHook, target); + }); + setTimeout(() => { + if (!devtools$1) { + target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null; + buffer$1 = []; + } + }, 3e3); + } else { + buffer$1 = []; + } +} + +let currentRenderingInstance$1 = null; +let currentScopeId$1 = null; +function markAttrsAccessed$1() { +} +const NULL_DYNAMIC_COMPONENT$1 = Symbol.for("v-ndc"); + +const isSuspense = (type) => type.__isSuspense; +function queueEffectWithSuspense(fn, suspense) { + if (suspense && suspense.pendingBranch) { + if (isArray(fn)) { + suspense.effects.push(...fn); + } else { + suspense.effects.push(fn); + } + } else { + queuePostFlushCb$1(fn); + } +} + +const ssrContextKey$1 = Symbol.for("v-scx"); +const useSSRContext$1 = () => { + { + const ctx = inject$1(ssrContextKey$1); + if (!ctx) { + !!(process.env.NODE_ENV !== "production") && warn$1$1( + `Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.` + ); + } + return ctx; + } +}; +const INITIAL_WATCHER_VALUE$1 = {}; +function doWatch$1(source, cb, { + immediate, + deep, + flush, + once, + onTrack, + onTrigger +} = EMPTY_OBJ) { + if (cb && once) { + const _cb = cb; + cb = (...args) => { + _cb(...args); + unwatch(); + }; + } + if (!!(process.env.NODE_ENV !== "production") && deep !== void 0 && typeof deep === "number") { + warn$1$1( + `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 (!!(process.env.NODE_ENV !== "production") && !cb) { + if (immediate !== void 0) { + warn$1$1( + `watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.` + ); + } + if (deep !== void 0) { + warn$1$1( + `watch() "deep" option is only respected when using the watch(source, callback, options?) signature.` + ); + } + if (once !== void 0) { + warn$1$1( + `watch() "once" option is only respected when using the watch(source, callback, options?) signature.` + ); + } + } + const warnInvalidSource = (s) => { + warn$1$1( + `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$1; + const reactiveGetter = (source2) => deep === true ? source2 : ( + // for deep: false, only traverse root-level properties + traverse$1(source2, deep === false ? 1 : void 0) + ); + let getter; + let forceTrigger = false; + let isMultiSource = false; + if (isRef$1(source)) { + getter = () => source.value; + forceTrigger = isShallow$1(source); + } else if (isReactive$1(source)) { + getter = () => reactiveGetter(source); + forceTrigger = true; + } else if (isArray(source)) { + isMultiSource = true; + forceTrigger = source.some((s) => isReactive$1(s) || isShallow$1(s)); + getter = () => source.map((s) => { + if (isRef$1(s)) { + return s.value; + } else if (isReactive$1(s)) { + return reactiveGetter(s); + } else if (isFunction(s)) { + return callWithErrorHandling$1(s, instance, 2); + } else { + !!(process.env.NODE_ENV !== "production") && warnInvalidSource(s); + } + }); + } else if (isFunction(source)) { + if (cb) { + getter = () => callWithErrorHandling$1(source, instance, 2); + } else { + getter = () => { + if (cleanup) { + cleanup(); + } + return callWithAsyncErrorHandling$1( + source, + instance, + 3, + [onCleanup] + ); + }; + } + } else { + getter = NOOP; + !!(process.env.NODE_ENV !== "production") && warnInvalidSource(source); + } + if (cb && deep) { + const baseGetter = getter; + getter = () => traverse$1(baseGetter()); + } + let cleanup; + let onCleanup = (fn) => { + cleanup = effect.onStop = () => { + callWithErrorHandling$1(fn, instance, 4); + cleanup = effect.onStop = void 0; + }; + }; + let ssrCleanup; + if (isInSSRComponentSetup$1) { + onCleanup = NOOP; + if (!cb) { + getter(); + } else if (immediate) { + callWithAsyncErrorHandling$1(cb, instance, 3, [ + getter(), + isMultiSource ? [] : void 0, + onCleanup + ]); + } + if (flush === "sync") { + const ctx = useSSRContext$1(); + ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []); + } else { + return NOOP; + } + } + let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE$1) : INITIAL_WATCHER_VALUE$1; + const job = () => { + if (!effect.active || !effect.dirty) { + return; + } + if (cb) { + const newValue = effect.run(); + if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || false) { + if (cleanup) { + cleanup(); + } + callWithAsyncErrorHandling$1(cb, instance, 3, [ + newValue, + // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE$1 ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE$1 ? [] : oldValue, + onCleanup + ]); + oldValue = newValue; + } + } else { + effect.run(); + } + }; + job.allowRecurse = !!cb; + let scheduler; + if (flush === "sync") { + scheduler = job; + } else if (flush === "post") { + scheduler = () => queuePostRenderEffect$2(job, instance && instance.suspense); + } else { + job.pre = true; + if (instance) + job.id = instance.uid; + scheduler = () => queueJob$1(job); + } + const effect = new ReactiveEffect$1(getter, NOOP, scheduler); + const unwatch = () => { + effect.stop(); + }; + if (!!(process.env.NODE_ENV !== "production")) { + effect.onTrack = onTrack; + effect.onTrigger = onTrigger; + } + if (cb) { + if (immediate) { + job(); + } else { + oldValue = effect.run(); + } + } else if (flush === "post") { + queuePostRenderEffect$2( + effect.run.bind(effect), + instance && instance.suspense + ); + } else { + effect.run(); + } + if (ssrCleanup) + ssrCleanup.push(unwatch); + return unwatch; +} +function instanceWatch$1(source, value, options) { + const publicThis = this.proxy; + const getter = isString(source) ? source.includes(".") ? createPathGetter$1(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis); + let cb; + if (isFunction(value)) { + cb = value; + } else { + cb = value.handler; + options = value; + } + const reset = setCurrentInstance$1(this); + const res = doWatch$1(getter, cb.bind(publicThis), options); + reset(); + return res; +} +function createPathGetter$1(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$1(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$1(value)) { + traverse$1(value.value, depth, currentDepth, seen); + } else if (isArray(value)) { + for (let i = 0; i < value.length; i++) { + traverse$1(value[i], depth, currentDepth, seen); + } + } else if (isSet(value) || isMap(value)) { + value.forEach((v) => { + traverse$1(v, depth, currentDepth, seen); + }); + } else if (isPlainObject(value)) { + for (const key in value) { + traverse$1(value[key], depth, currentDepth, seen); + } + } + return value; +} + +const getPublicInstance$1 = (i) => { + if (!i) + return null; + if (isStatefulComponent$1(i)) + return getExposeProxy$1(i) || i.proxy; + return getPublicInstance$1(i.parent); +}; +const publicPropertiesMap$1 = ( + // Move PURE marker to new line to workaround compiler discarding it + // due to type annotation + /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), { + $: (i) => i, + $el: (i) => i.vnode.el, + $data: (i) => i.data, + $props: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly$1(i.props) : i.props, + $attrs: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly$1(i.attrs) : i.attrs, + $slots: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly$1(i.slots) : i.slots, + $refs: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly$1(i.refs) : i.refs, + $parent: (i) => getPublicInstance$1(i.parent), + $root: (i) => getPublicInstance$1(i.root), + $emit: (i) => i.emit, + $options: (i) => __VUE_OPTIONS_API__ ? resolveMergedOptions$1(i) : i.type, + $forceUpdate: (i) => i.f || (i.f = () => { + i.effect.dirty = true; + queueJob$1(i.update); + }), + $nextTick: (i) => i.n || (i.n = nextTick$2.bind(i.proxy)), + $watch: (i) => __VUE_OPTIONS_API__ ? instanceWatch$1.bind(i) : NOOP + }) +); +const isReservedPrefix$1 = (key) => key === "_" || key === "$"; +const hasSetupBinding$1 = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key); +const PublicInstanceProxyHandlers$1 = { + get({ _: instance }, key) { + const { ctx, setupState, data, props, accessCache, type, appContext } = instance; + if (!!(process.env.NODE_ENV !== "production") && key === "__isVue") { + return true; + } + let normalizedProps; + if (key[0] !== "$") { + const n = accessCache[key]; + if (n !== void 0) { + switch (n) { + case 1 /* SETUP */: + return setupState[key]; + case 2 /* DATA */: + return data[key]; + case 4 /* CONTEXT */: + return ctx[key]; + case 3 /* PROPS */: + return props[key]; + } + } else if (hasSetupBinding$1(setupState, key)) { + accessCache[key] = 1 /* SETUP */; + return setupState[key]; + } else if (data !== EMPTY_OBJ && hasOwn(data, key)) { + accessCache[key] = 2 /* DATA */; + return data[key]; + } else if ( + // only cache other properties when instance has declared (thus stable) + // props + (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key) + ) { + accessCache[key] = 3 /* PROPS */; + return props[key]; + } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + accessCache[key] = 4 /* CONTEXT */; + return ctx[key]; + } else if (!__VUE_OPTIONS_API__ || shouldCacheAccess$1) { + accessCache[key] = 0 /* OTHER */; + } + } + const publicGetter = publicPropertiesMap$1[key]; + let cssModule, globalProperties; + if (publicGetter) { + if (key === "$attrs") { + track$1(instance, "get", key); + !!(process.env.NODE_ENV !== "production") && markAttrsAccessed$1(); + } else if (!!(process.env.NODE_ENV !== "production") && key === "$slots") { + track$1(instance, "get", key); + } + return publicGetter(instance); + } else if ( + // css module (injected by vue-loader) + (cssModule = type.__cssModules) && (cssModule = cssModule[key]) + ) { + return cssModule; + } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + accessCache[key] = 4 /* CONTEXT */; + return ctx[key]; + } else if ( + // global properties + globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key) + ) { + { + return globalProperties[key]; + } + } else if (!!(process.env.NODE_ENV !== "production") && currentRenderingInstance$1 && (!isString(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading + // to infinite warning loop + key.indexOf("__v") !== 0)) { + if (data !== EMPTY_OBJ && isReservedPrefix$1(key[0]) && hasOwn(data, key)) { + warn$1$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$1) { + warn$1$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$1(setupState, key)) { + setupState[key] = value; + return true; + } else if (!!(process.env.NODE_ENV !== "production") && setupState.__isScriptSetup && hasOwn(setupState, key)) { + warn$1$1(`Cannot mutate